android-notify 1.59.3__py3-none-any.whl → 1.60.0__py3-none-any.whl

venv/Lib/site-packages/markdown_it/rules_inline/state_inline.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from collections import namedtuple
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal
+
+from ..common.utils import isMdAsciiPunct, isPunctChar, isWhiteSpace
+from ..ruler import StateBase
+from ..token import Token
+from ..utils import EnvType
+
+if TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
+
+@dataclass(slots=True)
+class Delimiter:
+    # Char code of the starting marker (number).
+    marker: int
+
+    # Total length of these series of delimiters.
+    length: int
+
+    # A position of the token this delimiter corresponds to.
+    token: int
+
+    # If this delimiter is matched as a valid opener, `end` will be
+    # equal to its position, otherwise it's `-1`.
+    end: int
+
+    # Boolean flags that determine if this delimiter could open or close
+    # an emphasis.
+    open: bool
+    close: bool
+
+    level: bool | None = None
+
+
+Scanned = namedtuple("Scanned", ["can_open", "can_close", "length"])
+
+
+class StateInline(StateBase):
+    def __init__(
+        self, src: str, md: MarkdownIt, env: EnvType, outTokens: list[Token]
+    ) -> None:
+        self.src = src
+        self.env = env
+        self.md = md
+        self.tokens = outTokens
+        self.tokens_meta: list[dict[str, Any] | None] = [None] * len(outTokens)
+
+        self.pos = 0
+        self.posMax = len(self.src)
+        self.level = 0
+        self.pending = ""
+        self.pendingLevel = 0
+
+        # Stores { start: end } pairs. Useful for backtrack
+        # optimization of pairs parse (emphasis, strikes).
+        self.cache: dict[int, int] = {}
+
+        # List of emphasis-like delimiters for current tag
+        self.delimiters: list[Delimiter] = []
+
+        # Stack of delimiter lists for upper level tags
+        self._prev_delimiters: list[list[Delimiter]] = []
+
+        # backticklength => last seen position
+        self.backticks: dict[int, int] = {}
+        self.backticksScanned = False
+
+        # Counter used to disable inline linkify-it execution
+        # inside <a> and markdown links
+        self.linkLevel = 0
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}"
+            f"(pos=[{self.pos} of {self.posMax}], token={len(self.tokens)})"
+        )
+
+    def pushPending(self) -> Token:
+        token = Token("text", "", 0)
+        token.content = self.pending
+        token.level = self.pendingLevel
+        self.tokens.append(token)
+        self.pending = ""
+        return token
+
+    def push(self, ttype: str, tag: str, nesting: Literal[-1, 0, 1]) -> Token:
+        """Push new token to "stream".
+        If pending text exists - flush it as text token
+        """
+        if self.pending:
+            self.pushPending()
+
+        token = Token(ttype, tag, nesting)
+        token_meta = None
+
+        if nesting < 0:
+            # closing tag
+            self.level -= 1
+            self.delimiters = self._prev_delimiters.pop()
+
+        token.level = self.level
+
+        if nesting > 0:
+            # opening tag
+            self.level += 1
+            self._prev_delimiters.append(self.delimiters)
+            self.delimiters = []
+            token_meta = {"delimiters": self.delimiters}
+
+        self.pendingLevel = self.level
+        self.tokens.append(token)
+        self.tokens_meta.append(token_meta)
+        return token
+
+    def scanDelims(self, start: int, canSplitWord: bool) -> Scanned:
+        """
+        Scan a sequence of emphasis-like markers, and determine whether
+        it can start an emphasis sequence or end an emphasis sequence.
+
+         - start - position to scan from (it should point at a valid marker);
+         - canSplitWord - determine if these markers can be found inside a word
+
+        """
+        pos = start
+        maximum = self.posMax
+        marker = self.src[start]
+
+        # treat beginning of the line as a whitespace
+        lastChar = self.src[start - 1] if start > 0 else " "
+
+        while pos < maximum and self.src[pos] == marker:
+            pos += 1
+
+        count = pos - start
+
+        # treat end of the line as a whitespace
+        nextChar = self.src[pos] if pos < maximum else " "
+
+        isLastPunctChar = isMdAsciiPunct(ord(lastChar)) or isPunctChar(lastChar)
+        isNextPunctChar = isMdAsciiPunct(ord(nextChar)) or isPunctChar(nextChar)
+
+        isLastWhiteSpace = isWhiteSpace(ord(lastChar))
+        isNextWhiteSpace = isWhiteSpace(ord(nextChar))
+
+        left_flanking = not (
+            isNextWhiteSpace
+            or (isNextPunctChar and not (isLastWhiteSpace or isLastPunctChar))
+        )
+        right_flanking = not (
+            isLastWhiteSpace
+            or (isLastPunctChar and not (isNextWhiteSpace or isNextPunctChar))
+        )
+
+        can_open = left_flanking and (
+            canSplitWord or (not right_flanking) or isLastPunctChar
+        )
+        can_close = right_flanking and (
+            canSplitWord or (not left_flanking) or isNextPunctChar
+        )
+
+        return Scanned(can_open, can_close, count)

venv/Lib/site-packages/markdown_it/rules_inline/strikethrough.py

@@ -0,0 +1,127 @@
+# ~~strike through~~
+from __future__ import annotations
+
+from .state_inline import Delimiter, StateInline
+
+
+def tokenize(state: StateInline, silent: bool) -> bool:
+    """Insert each marker as a separate text token, and add it to delimiter list"""
+    start = state.pos
+    ch = state.src[start]
+
+    if silent:
+        return False
+
+    if ch != "~":
+        return False
+
+    scanned = state.scanDelims(state.pos, True)
+    length = scanned.length
+
+    if length < 2:
+        return False
+
+    if length % 2:
+        token = state.push("text", "", 0)
+        token.content = ch
+        length -= 1
+
+    i = 0
+    while i < length:
+        token = state.push("text", "", 0)
+        token.content = ch + ch
+        state.delimiters.append(
+            Delimiter(
+                marker=ord(ch),
+                length=0,  # disable "rule of 3" length checks meant for emphasis
+                token=len(state.tokens) - 1,
+                end=-1,
+                open=scanned.can_open,
+                close=scanned.can_close,
+            )
+        )
+
+        i += 2
+
+    state.pos += scanned.length
+
+    return True
+
+
+def _postProcess(state: StateInline, delimiters: list[Delimiter]) -> None:
+    loneMarkers = []
+    maximum = len(delimiters)
+
+    i = 0
+    while i < maximum:
+        startDelim = delimiters[i]
+
+        if startDelim.marker != 0x7E:  # /* ~ */
+            i += 1
+            continue
+
+        if startDelim.end == -1:
+            i += 1
+            continue
+
+        endDelim = delimiters[startDelim.end]
+
+        token = state.tokens[startDelim.token]
+        token.type = "s_open"
+        token.tag = "s"
+        token.nesting = 1
+        token.markup = "~~"
+        token.content = ""
+
+        token = state.tokens[endDelim.token]
+        token.type = "s_close"
+        token.tag = "s"
+        token.nesting = -1
+        token.markup = "~~"
+        token.content = ""
+
+        if (
+            state.tokens[endDelim.token - 1].type == "text"
+            and state.tokens[endDelim.token - 1].content == "~"
+        ):
+            loneMarkers.append(endDelim.token - 1)
+
+        i += 1
+
+    # If a marker sequence has an odd number of characters, it's split
+    # like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
+    # start of the sequence.
+    #
+    # So, we have to move all those markers after subsequent s_close tags.
+    #
+    while loneMarkers:
+        i = loneMarkers.pop()
+        j = i + 1
+
+        while (j < len(state.tokens)) and (state.tokens[j].type == "s_close"):
+            j += 1
+
+        j -= 1
+
+        if i != j:
+            token = state.tokens[j]
+            state.tokens[j] = state.tokens[i]
+            state.tokens[i] = token
+
+
+def postProcess(state: StateInline) -> None:
+    """Walk through delimiter list and replace text tokens with tags."""
+    tokens_meta = state.tokens_meta
+    maximum = len(state.tokens_meta)
+    _postProcess(state, state.delimiters)
+
+    curr = 0
+    while curr < maximum:
+        try:
+            curr_meta = tokens_meta[curr]
+        except IndexError:
+            pass
+        else:
+            if curr_meta and "delimiters" in curr_meta:
+                _postProcess(state, curr_meta["delimiters"])
+        curr += 1

venv/Lib/site-packages/markdown_it/rules_inline/text.py

@@ -0,0 +1,62 @@
+import functools
+import re
+
+# Skip text characters for text token, place those to pending buffer
+# and increment current pos
+from .state_inline import StateInline
+
+# Rule to skip pure text
+# '{}$%@~+=:' reserved for extensions
+
+# !!!! Don't confuse with "Markdown ASCII Punctuation" chars
+# http://spec.commonmark.org/0.15/#ascii-punctuation-character
+
+
+_TerminatorChars = {
+    "\n",
+    "!",
+    "#",
+    "$",
+    "%",
+    "&",
+    "*",
+    "+",
+    "-",
+    ":",
+    "<",
+    "=",
+    ">",
+    "@",
+    "[",
+    "\\",
+    "]",
+    "^",
+    "_",
+    "`",
+    "{",
+    "}",
+    "~",
+}
+
+
+@functools.cache
+def _terminator_char_regex() -> re.Pattern[str]:
+    return re.compile("[" + re.escape("".join(_TerminatorChars)) + "]")
+
+
+def text(state: StateInline, silent: bool) -> bool:
+    pos = state.pos
+    posMax = state.posMax
+
+    terminator_char = _terminator_char_regex().search(state.src, pos)
+    pos = terminator_char.start() if terminator_char else posMax
+
+    if pos == state.pos:
+        return False
+
+    if not silent:
+        state.pending += state.src[state.pos : pos]
+
+    state.pos = pos
+
+    return True

venv/Lib/site-packages/markdown_it/token.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from collections.abc import Callable, MutableMapping
+import dataclasses as dc
+from typing import Any, Literal
+import warnings
+
+
+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(slots=True)
+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