SkidSec WebShell

Server Address : 172.31.38.4

Web Server : Apache/2.4.58 (Ubuntu)

Uname : Linux ip-172-31-38-4 6.14.0-1017-aws #17~24.04.1-Ubuntu SMP Wed Nov 5 10:48:17 UTC 2025 x86_64

PHP Version : 7.4.33

from __future__ import annotations from collections.abc import Callable, MutableMapping import dataclasses as dc from typing import Any, Literal import warnings from markdown_it._compat import DATACLASS_KWARGS def convert_attrs(value: Any) -> Any: """Convert Token.attrs set as ``None`` or ``[[key, value], ...]`` to a dict. This improves compatibility with upstream markdown-it. """ if not value: return {} if isinstance(value, list): return dict(value) return value @dc.dataclass(**DATACLASS_KWARGS) class Token: type: str """Type of the token (string, e.g. "paragraph_open")""" tag: str """HTML tag name, e.g. 'p'""" nesting: Literal[-1, 0, 1] """Level change (number in {-1, 0, 1} set), where: - `1` means the tag is opening - `0` means the tag is self-closing - `-1` means the tag is closing """ attrs: dict[str, str | int | float] = dc.field(default_factory=dict) """HTML attributes. Note this differs from the upstream "list of lists" format, although than an instance can still be initialised with this format. """ map: list[int] | None = None """Source map info. Format: `[ line_begin, line_end ]`""" level: int = 0 """Nesting level, the same as `state.level`""" children: list[Token] | None = None """Array of child nodes (inline and img tokens).""" content: str = "" """Inner content, in the case of a self-closing tag (code, html, fence, etc.),""" markup: str = "" """'*' or '_' for emphasis, fence string for fence, etc.""" info: str = "" """Additional information: - Info string for "fence" tokens - The value "auto" for autolink "link_open" and "link_close" tokens - The string value of the item marker for ordered-list "list_item_open" tokens """ meta: dict[Any, Any] = dc.field(default_factory=dict) """A place for plugins to store any arbitrary data""" block: bool = False """True for block-level tokens, false for inline tokens. Used in renderer to calculate line breaks """ hidden: bool = False """If true, ignore this element when rendering. Used for tight lists to hide paragraphs. """ def __post_init__(self) -> None: self.attrs = convert_attrs(self.attrs) def attrIndex(self, name: str) -> int: warnings.warn( # noqa: B028 "Token.attrIndex should not be used, since Token.attrs is a dictionary", UserWarning, ) if name not in self.attrs: return -1 return list(self.attrs.keys()).index(name) def attrItems(self) -> list[tuple[str, str | int | float]]: """Get (key, value) list of attrs.""" return list(self.attrs.items()) def attrPush(self, attrData: tuple[str, str | int | float]) -> None: """Add `[ name, value ]` attribute to list. Init attrs if necessary.""" name, value = attrData self.attrSet(name, value) def attrSet(self, name: str, value: str | int | float) -> None: """Set `name` attribute to `value`. Override old value if exists.""" self.attrs[name] = value def attrGet(self, name: str) -> None | str | int | float: """Get the value of attribute `name`, or null if it does not exist.""" return self.attrs.get(name, None) def attrJoin(self, name: str, value: str) -> None: """Join value to existing attribute via space. Or create new attribute if not exists. Useful to operate with token classes. """ if name in self.attrs: current = self.attrs[name] if not isinstance(current, str): raise TypeError( f"existing attr 'name' is not a str: {self.attrs[name]}" ) self.attrs[name] = f"{current} {value}" else: self.attrs[name] = value def copy(self, **changes: Any) -> Token: """Return a shallow copy of the instance.""" return dc.replace(self, **changes) def as_dict( self, *, children: bool = True, as_upstream: bool = True, meta_serializer: Callable[[dict[Any, Any]], Any] | None = None, filter: Callable[[str, Any], bool] | None = None, dict_factory: Callable[..., MutableMapping[str, Any]] = dict, ) -> MutableMapping[str, Any]: """Return the token as a dictionary. :param children: Also convert children to dicts :param as_upstream: Ensure the output dictionary is equal to that created by markdown-it For example, attrs are converted to null or lists :param meta_serializer: hook for serializing ``Token.meta`` :param filter: A callable whose return code determines whether an attribute or element is included (``True``) or dropped (``False``). Is called with the (key, value) pair. :param dict_factory: A callable to produce dictionaries from. For example, to produce ordered dictionaries instead of normal Python dictionaries, pass in ``collections.OrderedDict``. """ mapping = dict_factory((f.name, getattr(self, f.name)) for f in dc.fields(self)) if filter: mapping = dict_factory((k, v) for k, v in mapping.items() if filter(k, v)) if as_upstream and "attrs" in mapping: mapping["attrs"] = ( None if not mapping["attrs"] else [[k, v] for k, v in mapping["attrs"].items()] ) if meta_serializer and "meta" in mapping: mapping["meta"] = meta_serializer(mapping["meta"]) if children and mapping.get("children", None): mapping["children"] = [ child.as_dict( children=children, filter=filter, dict_factory=dict_factory, as_upstream=as_upstream, meta_serializer=meta_serializer, ) for child in mapping["children"] ] return mapping @classmethod def from_dict(cls, dct: MutableMapping[str, Any]) -> Token: """Convert a dict to a Token.""" token = cls(**dct) if token.children: token.children = [cls.from_dict(c) for c in token.children] # type: ignore[arg-type] return token