Upload folder using huggingface_hub (part 6)

.gitattributes

@@ -64,3 +64,6 @@ venv/lib/python3.12/site-packages/huggingface_hub/inference/__pycache__/_client.
 venv/lib/python3.12/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.12/site-packages/jinja2/__pycache__/compiler.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.12/site-packages/joblib/test/__pycache__/test_parallel.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/mpmath/__pycache__/function_docs.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/mpmath/tests/__pycache__/test_fp.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/mpmath/tests/__pycache__/test_functions2.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

venv/lib/python3.12/site-packages/markdown_it/common/html_blocks.py

@@ -0,0 +1,69 @@
+"""List of valid html blocks names, according to commonmark spec
+http://jgm.github.io/CommonMark/spec.html#html-blocks
+"""
+
+# see https://spec.commonmark.org/0.31.2/#html-blocks
+block_names = [
+    "address",
+    "article",
+    "aside",
+    "base",
+    "basefont",
+    "blockquote",
+    "body",
+    "caption",
+    "center",
+    "col",
+    "colgroup",
+    "dd",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "html",
+    "iframe",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "menu",
+    "menuitem",
+    "nav",
+    "noframes",
+    "ol",
+    "optgroup",
+    "option",
+    "p",
+    "param",
+    "search",
+    "section",
+    "summary",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "title",
+    "tr",
+    "track",
+    "ul",
+]

venv/lib/python3.12/site-packages/markdown_it/common/html_re.py

@@ -0,0 +1,39 @@
+"""Regexps to match html elements"""
+
+import re
+
+attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
+
+unquoted = "[^\"'=<>`\\x00-\\x20]+"
+single_quoted = "'[^']*'"
+double_quoted = '"[^"]*"'
+
+attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")"
+
+attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)"
+
+open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>"
+
+close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>"
+comment = "<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->"
+processing = "<[?][\\s\\S]*?[?]>"
+declaration = "<![A-Za-z][^>]*>"
+cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
+
+HTML_TAG_RE = re.compile(
+    "^(?:"
+    + open_tag
+    + "|"
+    + close_tag
+    + "|"
+    + comment
+    + "|"
+    + processing
+    + "|"
+    + declaration
+    + "|"
+    + cdata
+    + ")"
+)
+HTML_OPEN_CLOSE_TAG_STR = "^(?:" + open_tag + "|" + close_tag + ")"
+HTML_OPEN_CLOSE_TAG_RE = re.compile(HTML_OPEN_CLOSE_TAG_STR)

venv/lib/python3.12/site-packages/markdown_it/common/normalize_url.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextlib import suppress
+import re
+from urllib.parse import quote, unquote, urlparse, urlunparse  # noqa: F401
+
+import mdurl
+
+from .. import _punycode
+
+RECODE_HOSTNAME_FOR = ("http:", "https:", "mailto:")
+
+
+def normalizeLink(url: str) -> str:
+    """Normalize destination URLs in links
+
+    ::
+
+        [label]:   destination   'title'
+                ^^^^^^^^^^^
+    """
+    parsed = mdurl.parse(url, slashes_denote_host=True)
+
+    # Encode hostnames in urls like:
+    # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    #
+    # We don't encode unknown schemas, because it's likely that we encode
+    # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    #
+    if parsed.hostname and (
+        not parsed.protocol or parsed.protocol in RECODE_HOSTNAME_FOR
+    ):
+        with suppress(Exception):
+            parsed = parsed._replace(hostname=_punycode.to_ascii(parsed.hostname))
+
+    return mdurl.encode(mdurl.format(parsed))
+
+
+def normalizeLinkText(url: str) -> str:
+    """Normalize autolink content
+
+    ::
+
+        <destination>
+         ~~~~~~~~~~~
+    """
+    parsed = mdurl.parse(url, slashes_denote_host=True)
+
+    # Encode hostnames in urls like:
+    # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    #
+    # We don't encode unknown schemas, because it's likely that we encode
+    # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    #
+    if parsed.hostname and (
+        not parsed.protocol or parsed.protocol in RECODE_HOSTNAME_FOR
+    ):
+        with suppress(Exception):
+            parsed = parsed._replace(hostname=_punycode.to_unicode(parsed.hostname))
+
+    # add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720
+    return mdurl.decode(mdurl.format(parsed), mdurl.DECODE_DEFAULT_CHARS + "%")
+
+
+BAD_PROTO_RE = re.compile(r"^(vbscript|javascript|file|data):")
+GOOD_DATA_RE = re.compile(r"^data:image\/(gif|png|jpeg|webp);")
+
+
+def validateLink(url: str, validator: Callable[[str], bool] | None = None) -> bool:
+    """Validate URL link is allowed in output.
+
+    This validator can prohibit more than really needed to prevent XSS.
+    It's a tradeoff to keep code simple and to be secure by default.
+
+    Note: url should be normalized at this point, and existing entities decoded.
+    """
+    if validator is not None:
+        return validator(url)
+    url = url.strip().lower()
+    return bool(GOOD_DATA_RE.search(url)) if BAD_PROTO_RE.search(url) else True

venv/lib/python3.12/site-packages/markdown_it/common/utils.py

@@ -0,0 +1,313 @@
+"""Utilities for parsing source text"""
+
+from __future__ import annotations
+
+import re
+from re import Match
+from typing import TypeVar
+import unicodedata
+
+from .entities import entities
+
+
+def charCodeAt(src: str, pos: int) -> int | None:
+    """
+    Returns the Unicode value of the character at the specified location.
+
+    @param - index The zero-based index of the desired character.
+    If there is no character at the specified index, NaN is returned.
+
+    This was added for compatibility with python
+    """
+    try:
+        return ord(src[pos])
+    except IndexError:
+        return None
+
+
+def charStrAt(src: str, pos: int) -> str | None:
+    """
+    Returns the Unicode value of the character at the specified location.
+
+    @param - index The zero-based index of the desired character.
+    If there is no character at the specified index, NaN is returned.
+
+    This was added for compatibility with python
+    """
+    try:
+        return src[pos]
+    except IndexError:
+        return None
+
+
+_ItemTV = TypeVar("_ItemTV")
+
+
+def arrayReplaceAt(
+    src: list[_ItemTV], pos: int, newElements: list[_ItemTV]
+) -> list[_ItemTV]:
+    """
+    Remove element from array and put another array at those position.
+    Useful for some operations with tokens
+    """
+    return src[:pos] + newElements + src[pos + 1 :]
+
+
+def isValidEntityCode(c: int) -> bool:
+    # broken sequence
+    if c >= 0xD800 and c <= 0xDFFF:
+        return False
+    # never used
+    if c >= 0xFDD0 and c <= 0xFDEF:
+        return False
+    if ((c & 0xFFFF) == 0xFFFF) or ((c & 0xFFFF) == 0xFFFE):
+        return False
+    # control codes
+    if c >= 0x00 and c <= 0x08:
+        return False
+    if c == 0x0B:
+        return False
+    if c >= 0x0E and c <= 0x1F:
+        return False
+    if c >= 0x7F and c <= 0x9F:
+        return False
+    # out of range
+    return not (c > 0x10FFFF)
+
+
+def fromCodePoint(c: int) -> str:
+    """Convert ordinal to unicode.
+
+    Note, in the original Javascript two string characters were required,
+    for codepoints larger than `0xFFFF`.
+    But Python 3 can represent any unicode codepoint in one character.
+    """
+    return chr(c)
+
+
+# UNESCAPE_MD_RE = re.compile(r'\\([!"#$%&\'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])')
+# ENTITY_RE_g       = re.compile(r'&([a-z#][a-z0-9]{1,31})', re.IGNORECASE)
+UNESCAPE_ALL_RE = re.compile(
+    r'\\([!"#$%&\'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])' + "|" + r"&([a-z#][a-z0-9]{1,31});",
+    re.IGNORECASE,
+)
+DIGITAL_ENTITY_BASE10_RE = re.compile(r"#([0-9]{1,8})")
+DIGITAL_ENTITY_BASE16_RE = re.compile(r"#x([a-f0-9]{1,8})", re.IGNORECASE)
+
+
+def replaceEntityPattern(match: str, name: str) -> str:
+    """Convert HTML entity patterns,
+    see https://spec.commonmark.org/0.30/#entity-references
+    """
+    if name in entities:
+        return entities[name]
+
+    code: None | int = None
+    if pat := DIGITAL_ENTITY_BASE10_RE.fullmatch(name):
+        code = int(pat.group(1), 10)
+    elif pat := DIGITAL_ENTITY_BASE16_RE.fullmatch(name):
+        code = int(pat.group(1), 16)
+
+    if code is not None and isValidEntityCode(code):
+        return fromCodePoint(code)
+
+    return match
+
+
+def unescapeAll(string: str) -> str:
+    def replacer_func(match: Match[str]) -> str:
+        escaped = match.group(1)
+        if escaped:
+            return escaped
+        entity = match.group(2)
+        return replaceEntityPattern(match.group(), entity)
+
+    if "\\" not in string and "&" not in string:
+        return string
+    return UNESCAPE_ALL_RE.sub(replacer_func, string)
+
+
+ESCAPABLE = r"""\\!"#$%&'()*+,./:;<=>?@\[\]^`{}|_~-"""
+ESCAPE_CHAR = re.compile(r"\\([" + ESCAPABLE + r"])")
+
+
+def stripEscape(string: str) -> str:
+    """Strip escape \\ characters"""
+    return ESCAPE_CHAR.sub(r"\1", string)
+
+
+def escapeHtml(raw: str) -> str:
+    """Replace special characters "&", "<", ">" and '"' to HTML-safe sequences."""
+    # like html.escape, but without escaping single quotes
+    raw = raw.replace("&", "&amp;")  # Must be done first!
+    raw = raw.replace("<", "&lt;")
+    raw = raw.replace(">", "&gt;")
+    raw = raw.replace('"', "&quot;")
+    return raw
+
+
+# //////////////////////////////////////////////////////////////////////////////
+
+REGEXP_ESCAPE_RE = re.compile(r"[.?*+^$[\]\\(){}|-]")
+
+
+def escapeRE(string: str) -> str:
+    string = REGEXP_ESCAPE_RE.sub("\\$&", string)
+    return string
+
+
+# //////////////////////////////////////////////////////////////////////////////
+
+
+def isSpace(code: int | None) -> bool:
+    """Check if character code is a whitespace."""
+    return code in (0x09, 0x20)
+
+
+def isStrSpace(ch: str | None) -> bool:
+    """Check if character is a whitespace."""
+    return ch in ("\t", " ")
+
+
+MD_WHITESPACE = {
+    0x09,  # \t
+    0x0A,  # \n
+    0x0B,  # \v
+    0x0C,  # \f
+    0x0D,  # \r
+    0x20,  # space
+    0xA0,
+    0x1680,
+    0x202F,
+    0x205F,
+    0x3000,
+}
+
+
+def isWhiteSpace(code: int) -> bool:
+    r"""Zs (unicode class) || [\t\f\v\r\n]"""
+    if code >= 0x2000 and code <= 0x200A:
+        return True
+    return code in MD_WHITESPACE
+
+
+# //////////////////////////////////////////////////////////////////////////////
+
+
+def isPunctChar(ch: str) -> bool:
+    """Check if character is a punctuation character."""
+    return unicodedata.category(ch).startswith(("P", "S"))
+
+
+MD_ASCII_PUNCT = {
+    0x21,  # /* ! */
+    0x22,  # /* " */
+    0x23,  # /* # */
+    0x24,  # /* $ */
+    0x25,  # /* % */
+    0x26,  # /* & */
+    0x27,  # /* ' */
+    0x28,  # /* ( */
+    0x29,  # /* ) */
+    0x2A,  # /* * */
+    0x2B,  # /* + */
+    0x2C,  # /* , */
+    0x2D,  # /* - */
+    0x2E,  # /* . */
+    0x2F,  # /* / */
+    0x3A,  # /* : */
+    0x3B,  # /* ; */
+    0x3C,  # /* < */
+    0x3D,  # /* = */
+    0x3E,  # /* > */
+    0x3F,  # /* ? */
+    0x40,  # /* @ */
+    0x5B,  # /* [ */
+    0x5C,  # /* \ */
+    0x5D,  # /* ] */
+    0x5E,  # /* ^ */
+    0x5F,  # /* _ */
+    0x60,  # /* ` */
+    0x7B,  # /* { */
+    0x7C,  # /* | */
+    0x7D,  # /* } */
+    0x7E,  # /* ~ */
+}
+
+
+def isMdAsciiPunct(ch: int) -> bool:
+    """Markdown ASCII punctuation characters.
+
+    ::
+
+        !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~
+
+    See http://spec.commonmark.org/0.15/#ascii-punctuation-character
+
+    Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
+
+    """
+    return ch in MD_ASCII_PUNCT
+
+
+def normalizeReference(string: str) -> str:
+    """Helper to unify [reference labels]."""
+    # Trim and collapse whitespace
+    #
+    string = re.sub(r"\s+", " ", string.strip())
+
+    # In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug
+    # fixed in v12 (couldn't find any details).
+    #
+    # So treat this one as a special case
+    # (remove this when node v10 is no longer supported).
+    #
+    # if ('ẞ'.toLowerCase() === 'Ṿ') {
+    #   str = str.replace(/ẞ/g, 'ß')
+    # }
+
+    # .toLowerCase().toUpperCase() should get rid of all differences
+    # between letter variants.
+    #
+    # Simple .toLowerCase() doesn't normalize 125 code points correctly,
+    # and .toUpperCase doesn't normalize 6 of them (list of exceptions:
+    # İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
+    # uppercased versions).
+    #
+    # Here's an example showing how it happens. Lets take greek letter omega:
+    # uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
+    #
+    # Unicode entries:
+    # 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8
+    # 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
+    # 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
+    # 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8
+    #
+    # Case-insensitive comparison should treat all of them as equivalent.
+    #
+    # But .toLowerCase() doesn't change ϑ (it's already lowercase),
+    # and .toUpperCase() doesn't change ϴ (already uppercase).
+    #
+    # Applying first lower then upper case normalizes any character:
+    # '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
+    #
+    # Note: this is equivalent to unicode case folding; unicode normalization
+    # is a different step that is not required here.
+    #
+    # Final result should be uppercased, because it's later stored in an object
+    # (this avoid a conflict with Object.prototype members,
+    # most notably, `__proto__`)
+    #
+    return string.lower().upper()
+
+
+LINK_OPEN_RE = re.compile(r"^<a[>\s]", flags=re.IGNORECASE)
+LINK_CLOSE_RE = re.compile(r"^</a\s*>", flags=re.IGNORECASE)
+
+
+def isLinkOpen(string: str) -> bool:
+    return bool(LINK_OPEN_RE.search(string))
+
+
+def isLinkClose(string: str) -> bool:
+    return bool(LINK_CLOSE_RE.search(string))

venv/lib/python3.12/site-packages/markdown_it/helpers/__init__.py

@@ -0,0 +1,6 @@
+"""Functions for parsing Links"""
+
+__all__ = ("parseLinkDestination", "parseLinkLabel", "parseLinkTitle")
+from .parse_link_destination import parseLinkDestination
+from .parse_link_label import parseLinkLabel
+from .parse_link_title import parseLinkTitle

venv/lib/python3.12/site-packages/markdown_it/helpers/parse_link_destination.py

@@ -0,0 +1,83 @@
+"""
+Parse link destination
+"""
+
+from ..common.utils import charCodeAt, unescapeAll
+
+
+class _Result:
+    __slots__ = ("ok", "pos", "str")
+
+    def __init__(self) -> None:
+        self.ok = False
+        self.pos = 0
+        self.str = ""
+
+
+def parseLinkDestination(string: str, pos: int, maximum: int) -> _Result:
+    start = pos
+    result = _Result()
+
+    if charCodeAt(string, pos) == 0x3C:  # /* < */
+        pos += 1
+        while pos < maximum:
+            code = charCodeAt(string, pos)
+            if code == 0x0A:  # /* \n */)
+                return result
+            if code == 0x3C:  # / * < * /
+                return result
+            if code == 0x3E:  # /* > */) {
+                result.pos = pos + 1
+                result.str = unescapeAll(string[start + 1 : pos])
+                result.ok = True
+                return result
+
+            if code == 0x5C and pos + 1 < maximum:  # \
+                pos += 2
+                continue
+
+            pos += 1
+
+        # no closing '>'
+        return result
+
+    # this should be ... } else { ... branch
+
+    level = 0
+    while pos < maximum:
+        code = charCodeAt(string, pos)
+
+        if code is None or code == 0x20:
+            break
+
+        # ascii control characters
+        if code < 0x20 or code == 0x7F:
+            break
+
+        if code == 0x5C and pos + 1 < maximum:
+            if charCodeAt(string, pos + 1) == 0x20:
+                break
+            pos += 2
+            continue
+
+        if code == 0x28:  # /* ( */)
+            level += 1
+            if level > 32:
+                return result
+
+        if code == 0x29:  # /* ) */)
+            if level == 0:
+                break
+            level -= 1
+
+        pos += 1
+
+    if start == pos:
+        return result
+    if level != 0:
+        return result
+
+    result.str = unescapeAll(string[start:pos])
+    result.pos = pos
+    result.ok = True
+    return result

venv/lib/python3.12/site-packages/markdown_it/helpers/parse_link_label.py

@@ -0,0 +1,44 @@
+"""
+Parse link label
+
+this function assumes that first character ("[") already matches
+returns the end of the label
+
+"""
+
+from markdown_it.rules_inline import StateInline
+
+
+def parseLinkLabel(state: StateInline, start: int, disableNested: bool = False) -> int:
+    labelEnd = -1
+    oldPos = state.pos
+    found = False
+
+    state.pos = start + 1
+    level = 1
+
+    while state.pos < state.posMax:
+        marker = state.src[state.pos]
+        if marker == "]":
+            level -= 1
+            if level == 0:
+                found = True
+                break
+
+        prevPos = state.pos
+        state.md.inline.skipToken(state)
+        if marker == "[":
+            if prevPos == state.pos - 1:
+                # increase level if we find text `[`,
+                # which is not a part of any token
+                level += 1
+            elif disableNested:
+                state.pos = oldPos
+                return -1
+    if found:
+        labelEnd = state.pos
+
+    # restore old state
+    state.pos = oldPos
+
+    return labelEnd

venv/lib/python3.12/site-packages/markdown_it/helpers/parse_link_title.py

@@ -0,0 +1,75 @@
+"""Parse link title"""
+
+from ..common.utils import charCodeAt, unescapeAll
+
+
+class _State:
+    __slots__ = ("can_continue", "marker", "ok", "pos", "str")
+
+    def __init__(self) -> None:
+        self.ok = False
+        """if `true`, this is a valid link title"""
+        self.can_continue = False
+        """if `true`, this link can be continued on the next line"""
+        self.pos = 0
+        """if `ok`, it's the position of the first character after the closing marker"""
+        self.str = ""
+        """if `ok`, it's the unescaped title"""
+        self.marker = 0
+        """expected closing marker character code"""
+
+    def __str__(self) -> str:
+        return self.str
+
+
+def parseLinkTitle(
+    string: str, start: int, maximum: int, prev_state: _State | None = None
+) -> _State:
+    """Parse link title within `str` in [start, max] range,
+    or continue previous parsing if `prev_state` is defined (equal to result of last execution).
+    """
+    pos = start
+    state = _State()
+
+    if prev_state is not None:
+        # this is a continuation of a previous parseLinkTitle call on the next line,
+        # used in reference links only
+        state.str = prev_state.str
+        state.marker = prev_state.marker
+    else:
+        if pos >= maximum:
+            return state
+
+        marker = charCodeAt(string, pos)
+
+        # /* " */  /* ' */  /* ( */
+        if marker != 0x22 and marker != 0x27 and marker != 0x28:
+            return state
+
+        start += 1
+        pos += 1
+
+        # if opening marker is "(", switch it to closing marker ")"
+        if marker == 0x28:
+            marker = 0x29
+
+        state.marker = marker
+
+    while pos < maximum:
+        code = charCodeAt(string, pos)
+        if code == state.marker:
+            state.pos = pos + 1
+            state.str += unescapeAll(string[start:pos])
+            state.ok = True
+            return state
+        elif code == 0x28 and state.marker == 0x29:  # /* ( */  /* ) */
+            return state
+        elif code == 0x5C and pos + 1 < maximum:  # /* \ */
+            pos += 1
+
+        pos += 1
+
+    # no closing marker found, but this link title may continue on the next line (for references)
+    state.can_continue = True
+    state.str += unescapeAll(string[start:pos])
+    return state

venv/lib/python3.12/site-packages/markdown_it/main.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Generator, Iterable, Mapping, MutableMapping
+from contextlib import contextmanager
+from typing import Any, Literal, overload
+
+from . import helpers, presets
+from .common import normalize_url, utils
+from .parser_block import ParserBlock
+from .parser_core import ParserCore
+from .parser_inline import ParserInline
+from .renderer import RendererHTML, RendererProtocol
+from .rules_core.state_core import StateCore
+from .token import Token
+from .utils import EnvType, OptionsDict, OptionsType, PresetType
+
+try:
+    import linkify_it
+except ModuleNotFoundError:
+    linkify_it = None
+
+
+_PRESETS: dict[str, PresetType] = {
+    "default": presets.default.make(),
+    "js-default": presets.js_default.make(),
+    "zero": presets.zero.make(),
+    "commonmark": presets.commonmark.make(),
+    "gfm-like": presets.gfm_like.make(),
+    "gfm-like2": presets.gfm_like2.make(),
+}
+
+
+class MarkdownIt:
+    def __init__(
+        self,
+        config: str | PresetType = "commonmark",
+        options_update: Mapping[str, Any] | None = None,
+        *,
+        renderer_cls: Callable[[MarkdownIt], RendererProtocol] = RendererHTML,
+    ):
+        """Main parser class
+
+        :param config: name of configuration to load or a pre-defined dictionary
+        :param options_update: dictionary that will be merged into ``config["options"]``
+        :param renderer_cls: the class to load as the renderer:
+            ``self.renderer = renderer_cls(self)
+        """
+        # add modules
+        self.utils = utils
+        self.helpers = helpers
+
+        # initialise classes
+        self.inline = ParserInline()
+        self.block = ParserBlock()
+        self.core = ParserCore()
+        self.renderer = renderer_cls(self)
+        self.linkify = linkify_it.LinkifyIt() if linkify_it else None
+
+        # set the configuration
+        if options_update and not isinstance(options_update, Mapping):
+            # catch signature change where renderer_cls was not used as a key-word
+            raise TypeError(
+                f"options_update should be a mapping: {options_update}"
+                "\n(Perhaps you intended this to be the renderer_cls?)"
+            )
+        self.configure(config, options_update=options_update)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__module__}.{self.__class__.__name__}()"
+
+    @overload
+    def __getitem__(self, name: Literal["inline"]) -> ParserInline: ...
+
+    @overload
+    def __getitem__(self, name: Literal["block"]) -> ParserBlock: ...
+
+    @overload
+    def __getitem__(self, name: Literal["core"]) -> ParserCore: ...
+
+    @overload
+    def __getitem__(self, name: Literal["renderer"]) -> RendererProtocol: ...
+
+    @overload
+    def __getitem__(self, name: str) -> Any: ...
+
+    def __getitem__(self, name: str) -> Any:
+        return {
+            "inline": self.inline,
+            "block": self.block,
+            "core": self.core,
+            "renderer": self.renderer,
+        }[name]
+
+    def set(self, options: OptionsType) -> None:
+        """Set parser options (in the same format as in constructor).
+        Probably, you will never need it, but you can change options after constructor call.
+
+        __Note:__ To achieve the best possible performance, don't modify a
+        `markdown-it` instance options on the fly. If you need multiple configurations
+        it's best to create multiple instances and initialize each with separate config.
+        """
+        self.options = OptionsDict(options)
+
+    def configure(
+        self, presets: str | PresetType, options_update: Mapping[str, Any] | None = None
+    ) -> MarkdownIt:
+        """Batch load of all options and component settings.
+        This is an internal method, and you probably will not need it.
+        But if you will - see available presets and data structure
+        [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
+
+        We strongly recommend to use presets instead of direct config loads.
+        That will give better compatibility with next versions.
+        """
+        if isinstance(presets, str):
+            if presets not in _PRESETS:
+                raise KeyError(f"Wrong `markdown-it` preset '{presets}', check name")
+            config = _PRESETS[presets]
+        else:
+            config = presets
+
+        if not config:
+            raise ValueError("Wrong `markdown-it` config, can't be empty")
+
+        options = config.get("options", {}) or {}
+        if options_update:
+            options = {**options, **options_update}  # type: ignore
+
+        self.set(options)
+
+        if "components" in config:
+            for name, component in config["components"].items():
+                rules = component.get("rules", None)
+                if rules:
+                    self[name].ruler.enableOnly(rules)
+                rules2 = component.get("rules2", None)
+                if rules2:
+                    self[name].ruler2.enableOnly(rules2)
+
+        return self
+
+    def get_all_rules(self) -> dict[str, list[str]]:
+        """Return the names of all active rules."""
+        rules = {
+            chain: self[chain].ruler.get_all_rules()
+            for chain in ["core", "block", "inline"]
+        }
+        rules["inline2"] = self.inline.ruler2.get_all_rules()
+        return rules
+
+    def get_active_rules(self) -> dict[str, list[str]]:
+        """Return the names of all active rules."""
+        rules = {
+            chain: self[chain].ruler.get_active_rules()
+            for chain in ["core", "block", "inline"]
+        }
+        rules["inline2"] = self.inline.ruler2.get_active_rules()
+        return rules
+
+    def enable(
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> MarkdownIt:
+        """Enable list or rules. (chainable)
+
+        :param names: rule name or list of rule names to enable.
+        :param ignoreInvalid: set `true` to ignore errors when rule not found.
+
+        It will automatically find appropriate components,
+        containing rules with given names. If rule not found, and `ignoreInvalid`
+        not set - throws exception.
+
+        Example::
+
+            md = MarkdownIt().enable(['sub', 'sup']).disable('smartquotes')
+
+        """
+        result = []
+
+        if isinstance(names, str):
+            names = [names]
+
+        for chain in ["core", "block", "inline"]:
+            result.extend(self[chain].ruler.enable(names, True))
+        result.extend(self.inline.ruler2.enable(names, True))
+
+        missed = [name for name in names if name not in result]
+        if missed and not ignoreInvalid:
+            raise ValueError(f"MarkdownIt. Failed to enable unknown rule(s): {missed}")
+
+        return self
+
+    def disable(
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> MarkdownIt:
+        """The same as [[MarkdownIt.enable]], but turn specified rules off. (chainable)
+
+        :param names: rule name or list of rule names to disable.
+        :param ignoreInvalid: set `true` to ignore errors when rule not found.
+
+        """
+        result = []
+
+        if isinstance(names, str):
+            names = [names]
+
+        for chain in ["core", "block", "inline"]:
+            result.extend(self[chain].ruler.disable(names, True))
+        result.extend(self.inline.ruler2.disable(names, True))
+
+        missed = [name for name in names if name not in result]
+        if missed and not ignoreInvalid:
+            raise ValueError(f"MarkdownIt. Failed to disable unknown rule(s): {missed}")
+        return self
+
+    @contextmanager
+    def reset_rules(self) -> Generator[None, None, None]:
+        """A context manager, that will reset the current enabled rules on exit."""
+        chain_rules = self.get_active_rules()
+        yield
+        for chain, rules in chain_rules.items():
+            if chain != "inline2":
+                self[chain].ruler.enableOnly(rules)
+        self.inline.ruler2.enableOnly(chain_rules["inline2"])
+
+    def add_render_rule(
+        self, name: str, function: Callable[..., Any], fmt: str = "html"
+    ) -> None:
+        """Add a rule for rendering a particular Token type.
+
+        Only applied when ``renderer.__output__ == fmt``
+        """
+        if self.renderer.__output__ == fmt:
+            self.renderer.rules[name] = function.__get__(self.renderer)  # type: ignore
+
+    def use(
+        self, plugin: Callable[..., None], *params: Any, **options: Any
+    ) -> MarkdownIt:
+        """Load specified plugin with given params into current parser instance. (chainable)
+
+        It's just a sugar to call `plugin(md, params)` with curring.
+
+        Example::
+
+            def func(tokens, idx):
+                tokens[idx].content = tokens[idx].content.replace('foo', 'bar')
+            md = MarkdownIt().use(plugin, 'foo_replace', 'text', func)
+
+        """
+        plugin(self, *params, **options)
+        return self
+
+    def parse(self, src: str, env: EnvType | None = None) -> list[Token]:
+        """Parse the source string to a token stream
+
+        :param src: source string
+        :param env: environment sandbox
+
+        Parse input string and return list of block tokens (special token type
+        "inline" will contain list of inline tokens).
+
+        `env` is used to pass data between "distributed" rules and return additional
+        metadata like reference info, needed for the renderer. It also can be used to
+        inject data in specific cases. Usually, you will be ok to pass `{}`,
+        and then pass updated object to renderer.
+        """
+        env = {} if env is None else env
+        if not isinstance(env, MutableMapping):
+            raise TypeError(f"Input data should be a MutableMapping, not {type(env)}")
+        if not isinstance(src, str):
+            raise TypeError(f"Input data should be a string, not {type(src)}")
+        state = StateCore(src, self, env)
+        self.core.process(state)
+        return state.tokens
+
+    def render(self, src: str, env: EnvType | None = None) -> Any:
+        """Render markdown string into html. It does all magic for you :).
+
+        :param src: source string
+        :param env: environment sandbox
+        :returns: The output of the loaded renderer
+
+        `env` can be used to inject additional metadata (`{}` by default).
+        But you will not need it with high probability. See also comment
+        in [[MarkdownIt.parse]].
+        """
+        env = {} if env is None else env
+        return self.renderer.render(self.parse(src, env), self.options, env)
+
+    def parseInline(self, src: str, env: EnvType | None = None) -> list[Token]:
+        """The same as [[MarkdownIt.parse]] but skip all block rules.
+
+        :param src: source string
+        :param env: environment sandbox
+
+        It returns the
+        block tokens list with the single `inline` element, containing parsed inline
+        tokens in `children` property. Also updates `env` object.
+        """
+        env = {} if env is None else env
+        if not isinstance(env, MutableMapping):
+            raise TypeError(f"Input data should be an MutableMapping, not {type(env)}")
+        if not isinstance(src, str):
+            raise TypeError(f"Input data should be a string, not {type(src)}")
+        state = StateCore(src, self, env)
+        state.inlineMode = True
+        self.core.process(state)
+        return state.tokens
+
+    def renderInline(self, src: str, env: EnvType | None = None) -> Any:
+        """Similar to [[MarkdownIt.render]] but for single paragraph content.
+
+        :param src: source string
+        :param env: environment sandbox
+
+        Similar to [[MarkdownIt.render]] but for single paragraph content. Result
+        will NOT be wrapped into `<p>` tags.
+        """
+        env = {} if env is None else env
+        return self.renderer.render(self.parseInline(src, env), self.options, env)
+
+    # link methods
+
+    def validateLink(self, url: str) -> bool:
+        """Validate if the URL link is allowed in output.
+
+        This validator can prohibit more than really needed to prevent XSS.
+        It's a tradeoff to keep code simple and to be secure by default.
+
+        Note: the url should be normalized at this point, and existing entities decoded.
+        """
+        return normalize_url.validateLink(url)
+
+    def normalizeLink(self, url: str) -> str:
+        """Normalize destination URLs in links
+
+        ::
+
+            [label]:   destination   'title'
+                    ^^^^^^^^^^^
+        """
+        return normalize_url.normalizeLink(url)
+
+    def normalizeLinkText(self, link: str) -> str:
+        """Normalize autolink content
+
+        ::
+
+            <destination>
+            ~~~~~~~~~~~
+        """
+        return normalize_url.normalizeLinkText(link)

venv/lib/python3.12/site-packages/markdown_it/parser_block.py

@@ -0,0 +1,113 @@
+"""Block-level tokenizer."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import logging
+from typing import TYPE_CHECKING
+
+from . import rules_block
+from .ruler import Ruler
+from .rules_block.state_block import StateBlock
+from .token import Token
+from .utils import EnvType
+
+if TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
+LOGGER = logging.getLogger(__name__)
+
+
+RuleFuncBlockType = Callable[[StateBlock, int, int, bool], bool]
+"""(state: StateBlock, startLine: int, endLine: int, silent: bool) -> matched: bool)
+
+`silent` disables token generation, useful for lookahead.
+"""
+
+_rules: list[tuple[str, RuleFuncBlockType, list[str]]] = [
+    # First 2 params - rule name & source. Secondary array - list of rules,
+    # which can be terminated by this one.
+    ("table", rules_block.table, ["paragraph", "reference"]),
+    ("code", rules_block.code, []),
+    ("fence", rules_block.fence, ["paragraph", "reference", "blockquote", "list"]),
+    (
+        "blockquote",
+        rules_block.blockquote,
+        ["paragraph", "reference", "blockquote", "list"],
+    ),
+    ("hr", rules_block.hr, ["paragraph", "reference", "blockquote", "list"]),
+    ("list", rules_block.list_block, ["paragraph", "reference", "blockquote"]),
+    ("reference", rules_block.reference, []),
+    ("html_block", rules_block.html_block, ["paragraph", "reference", "blockquote"]),
+    ("heading", rules_block.heading, ["paragraph", "reference", "blockquote"]),
+    ("lheading", rules_block.lheading, []),
+    ("paragraph", rules_block.paragraph, []),
+]
+
+
+class ParserBlock:
+    """
+    ParserBlock#ruler -> Ruler
+
+    [[Ruler]] instance. Keep configuration of block rules.
+    """
+
+    def __init__(self) -> None:
+        self.ruler = Ruler[RuleFuncBlockType]()
+        for name, rule, alt in _rules:
+            self.ruler.push(name, rule, {"alt": alt})
+
+    def tokenize(self, state: StateBlock, startLine: int, endLine: int) -> None:
+        """Generate tokens for input range."""
+        rules = self.ruler.getRules("")
+        line = startLine
+        maxNesting = state.md.options.maxNesting
+        hasEmptyLines = False
+
+        while line < endLine:
+            state.line = line = state.skipEmptyLines(line)
+            if line >= endLine:
+                break
+            if state.sCount[line] < state.blkIndent:
+                # Termination condition for nested calls.
+                # Nested calls currently used for blockquotes & lists
+                break
+            if state.level >= maxNesting:
+                # If nesting level exceeded - skip tail to the end.
+                # That's not ordinary situation and we should not care about content.
+                state.line = endLine
+                break
+
+            # Try all possible rules.
+            # On success, rule should:
+            # - update `state.line`
+            # - update `state.tokens`
+            # - return True
+            for rule in rules:
+                if rule(state, line, endLine, False):
+                    break
+
+            # set state.tight if we had an empty line before current tag
+            # i.e. latest empty line should not count
+            state.tight = not hasEmptyLines
+
+            line = state.line
+
+            # paragraph might "eat" one newline after it in nested lists
+            if (line - 1) < endLine and state.isEmpty(line - 1):
+                hasEmptyLines = True
+
+            if line < endLine and state.isEmpty(line):
+                hasEmptyLines = True
+                line += 1
+                state.line = line
+
+    def parse(
+        self, src: str, md: MarkdownIt, env: EnvType, outTokens: list[Token]
+    ) -> list[Token] | None:
+        """Process input string and push block tokens into `outTokens`."""
+        if not src:
+            return None
+        state = StateBlock(src, md, env, outTokens)
+        self.tokenize(state, state.line, state.lineMax)
+        return state.tokens

venv/lib/python3.12/site-packages/markdown_it/parser_core.py

@@ -0,0 +1,46 @@
+"""
+* class Core
+*
+* Top-level rules executor. Glues block/inline parsers and does intermediate
+* transformations.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from .ruler import Ruler
+from .rules_core import (
+    block,
+    inline,
+    linkify,
+    normalize,
+    replace,
+    smartquotes,
+    text_join,
+)
+from .rules_core.state_core import StateCore
+
+RuleFuncCoreType = Callable[[StateCore], None]
+
+_rules: list[tuple[str, RuleFuncCoreType]] = [
+    ("normalize", normalize),
+    ("block", block),
+    ("inline", inline),
+    ("linkify", linkify),
+    ("replacements", replace),
+    ("smartquotes", smartquotes),
+    ("text_join", text_join),
+]
+
+
+class ParserCore:
+    def __init__(self) -> None:
+        self.ruler = Ruler[RuleFuncCoreType]()
+        for name, rule in _rules:
+            self.ruler.push(name, rule)
+
+    def process(self, state: StateCore) -> None:
+        """Executes core chain rules."""
+        for rule in self.ruler.getRules(""):
+            rule(state)

venv/lib/python3.12/site-packages/markdown_it/parser_inline.py

@@ -0,0 +1,215 @@
+"""Tokenizes paragraph content."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import functools
+import re
+from typing import TYPE_CHECKING
+
+from . import rules_inline
+from .ruler import Ruler
+from .rules_inline.state_inline import StateInline
+from .token import Token
+from .utils import EnvType
+
+if TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
+
+# Default set of characters that terminate a text token and allow inline rules to fire.
+# '{}$%@~+=:' reserved for extensions.
+# Note: Don't confuse with "Markdown ASCII Punctuation" chars.
+# http://spec.commonmark.org/0.15/#ascii-punctuation-character
+_DEFAULT_TERMINATORS: frozenset[str] = frozenset(
+    {
+        "\n",
+        "!",
+        "#",
+        "$",
+        "%",
+        "&",
+        "*",
+        "+",
+        "-",
+        ":",
+        "<",
+        "=",
+        ">",
+        "@",
+        "[",
+        "\\",
+        "]",
+        "^",
+        "_",
+        "`",
+        "{",
+        "}",
+        "~",
+    }
+)
+
+
+# Lazily compiled regex for the default terminator set.  The @cache ensures it is
+# compiled at most once (on first ParserInline instantiation) and shared across all
+# instances that have not added extra chars, keeping __init__ cost near zero.
+@functools.cache
+def _default_terminator_re() -> re.Pattern[str]:
+    return re.compile("[" + re.escape("".join(_DEFAULT_TERMINATORS)) + "]")
+
+
+# Parser rules
+RuleFuncInlineType = Callable[[StateInline, bool], bool]
+"""(state: StateInline, silent: bool) -> matched: bool)
+
+`silent` disables token generation, useful for lookahead.
+"""
+_rules: list[tuple[str, RuleFuncInlineType]] = [
+    ("text", rules_inline.text),
+    ("linkify", rules_inline.linkify),
+    ("newline", rules_inline.newline),
+    ("escape", rules_inline.escape),
+    ("backticks", rules_inline.backtick),
+    ("strikethrough", rules_inline.strikethrough.tokenize),
+    ("emphasis", rules_inline.emphasis.tokenize),
+    ("link", rules_inline.link),
+    ("image", rules_inline.image),
+    ("autolink", rules_inline.autolink),
+    ("html_inline", rules_inline.html_inline),
+    ("entity", rules_inline.entity),
+]
+
+# Note `rule2` ruleset was created specifically for emphasis/strikethrough
+# post-processing and may be changed in the future.
+#
+# Don't use this for anything except pairs (plugins working with `balance_pairs`).
+#
+RuleFuncInline2Type = Callable[[StateInline], None]
+_rules2: list[tuple[str, RuleFuncInline2Type]] = [
+    ("balance_pairs", rules_inline.link_pairs),
+    ("strikethrough", rules_inline.strikethrough.postProcess),
+    ("emphasis", rules_inline.emphasis.postProcess),
+    # rules for pairs separate '**' into its own text tokens, which may be left unused,
+    # rule below merges unused segments back with the rest of the text
+    ("fragments_join", rules_inline.fragments_join),
+]
+
+
+class ParserInline:
+    def __init__(self) -> None:
+        self.ruler = Ruler[RuleFuncInlineType]()
+        for name, rule in _rules:
+            self.ruler.push(name, rule)
+        # Second ruler used for post-processing (e.g. in emphasis-like rules)
+        self.ruler2 = Ruler[RuleFuncInline2Type]()
+        for name, rule2 in _rules2:
+            self.ruler2.push(name, rule2)
+        # Characters that stop the text rule, allowing other inline rules to fire.
+        # _extra_terminator_chars is only allocated when add_terminator_char() is called
+        # with a char outside the defaults, keeping __init__ allocation-free.
+        self._extra_terminator_chars: set[str] = set()
+        # Pre-compiled regex shared with all default instances (no copy in the common path).
+        self.terminator_re: re.Pattern[str] = _default_terminator_re()
+
+    def add_terminator_char(self, ch: str) -> None:
+        """Register a character that stops the ``text`` rule, allowing inline rules to fire.
+
+        This lets plugins declare which characters their inline rules react to,
+        mirroring the ``MARKER`` mechanism in the Rust markdown-it implementation.
+
+        :param ch: A single character to add to the terminator set.
+        """
+        if ch not in _DEFAULT_TERMINATORS and ch not in self._extra_terminator_chars:
+            self._extra_terminator_chars.add(ch)
+            self.terminator_re = re.compile(
+                "["
+                + re.escape(
+                    "".join(_DEFAULT_TERMINATORS | self._extra_terminator_chars)
+                )
+                + "]"
+            )
+
+    def skipToken(self, state: StateInline) -> None:
+        """Skip single token by running all rules in validation mode;
+        returns `True` if any rule reported success
+        """
+        ok = False
+        pos = state.pos
+        rules = self.ruler.getRules("")
+        maxNesting = state.md.options["maxNesting"]
+        cache = state.cache
+
+        if pos in cache:
+            state.pos = cache[pos]
+            return
+
+        if state.level < maxNesting:
+            for rule in rules:
+                #  Increment state.level and decrement it later to limit recursion.
+                # It's harmless to do here, because no tokens are created.
+                # But ideally, we'd need a separate private state variable for this purpose.
+                state.level += 1
+                ok = rule(state, True)
+                state.level -= 1
+                if ok:
+                    break
+        else:
+            # Too much nesting, just skip until the end of the paragraph.
+            #
+            # NOTE: this will cause links to behave incorrectly in the following case,
+            #       when an amount of `[` is exactly equal to `maxNesting + 1`:
+            #
+            #       [[[[[[[[[[[[[[[[[[[[[foo]()
+            #
+            # TODO: remove this workaround when CM standard will allow nested links
+            #       (we can replace it by preventing links from being parsed in
+            #       validation mode)
+            #
+            state.pos = state.posMax
+
+        if not ok:
+            state.pos += 1
+        cache[pos] = state.pos
+
+    def tokenize(self, state: StateInline) -> None:
+        """Generate tokens for input range."""
+        ok = False
+        rules = self.ruler.getRules("")
+        end = state.posMax
+        maxNesting = state.md.options["maxNesting"]
+
+        while state.pos < end:
+            # Try all possible rules.
+            # On success, rule should:
+            #
+            # - update `state.pos`
+            # - update `state.tokens`
+            # - return true
+
+            if state.level < maxNesting:
+                for rule in rules:
+                    ok = rule(state, False)
+                    if ok:
+                        break
+
+            if ok:
+                if state.pos >= end:
+                    break
+                continue
+
+            state.pending += state.src[state.pos]
+            state.pos += 1
+
+        if state.pending:
+            state.pushPending()
+
+    def parse(
+        self, src: str, md: MarkdownIt, env: EnvType, tokens: list[Token]
+    ) -> list[Token]:
+        """Process input string and push inline tokens into `tokens`"""
+        state = StateInline(src, md, env, tokens)
+        self.tokenize(state)
+        rules2 = self.ruler2.getRules("")
+        for rule in rules2:
+            rule(state)
+        return state.tokens

venv/lib/python3.12/site-packages/markdown_it/port.yaml

@@ -0,0 +1,48 @@
+- package: markdown-it/markdown-it
+  version: 14.1.0
+  commit: 0fe7ccb4b7f30236fb05f623be6924961d296d3d
+  date: Mar 19, 2024
+  notes:
+    - Rename variables that use python built-in names, e.g.
+      - `max` -> `maximum`
+      - `len` -> `length`
+      - `str` -> `string`
+    - |
+      Convert JS `for` loops to `while` loops
+      this is generally the main difference between the codes,
+      because in python you can't do e.g. `for {i=1;i<x;i++} {}`
+    - |
+      `env` is a common Python dictionary, and so does not have attribute access to keys,
+      as with JavaScript dictionaries.
+      `options` have attribute access only to core markdownit configuration options
+    - |
+      `Token.attrs` is a dictionary, instead of a list of lists.
+      Upstream the list format is only used to guarantee order: https://github.com/markdown-it/markdown-it/issues/142,
+      but in Python 3.7+ order of dictionaries is guaranteed.
+      One should anyhow use the `attrGet`, `attrSet`, `attrPush` and `attrJoin` methods
+      to manipulate `Token.attrs`, which have an identical signature to those upstream.
+    - Use python version of `charCodeAt`
+    - |
+      Use `str` units instead of `int`s to represent Unicode codepoints.
+      This provides a significant performance boost
+    - |
+      In markdown_it/rules_block/reference.py,
+      record line range in state.env["references"] and add state.env["duplicate_refs"]
+      This is to allow renderers to report on issues regarding references
+    - |
+      The `MarkdownIt.__init__` signature is slightly different for updating options,
+      since you must always specify the config first, e.g.
+      use `MarkdownIt("commonmark", {"html": False})` instead of `MarkdownIt({"html": False})`
+    - The default configuration preset for `MarkdownIt` is "commonmark" not "default"
+    - Allow custom renderer to be passed to `MarkdownIt`
+    - |
+      change render method signatures
+      `func(tokens, idx, options, env, slf)` to
+      `func(self, tokens, idx, options, env)`
+    - |
+      Extensions add render methods by format
+      `MarkdownIt.add_render_rule(name, function, fmt="html")`,
+      rather than `MarkdownIt.renderer.rules[name] = function`
+      and renderers should declare a class property `__output__ = "html"`.
+      This allows for extensibility to more than just HTML renderers
+    - inline tokens in tables are assigned a map (this is helpful for propagation to children)

venv/lib/python3.12/site-packages/markdown_it/presets/__init__.py

@@ -0,0 +1,48 @@
+__all__ = ("commonmark", "default", "gfm_like", "gfm_like2", "js_default", "zero")
+
+from ..utils import PresetType
+from . import commonmark, default, zero
+
+js_default = default
+
+
+class gfm_like:  # noqa: N801
+    """GitHub Flavoured Markdown (GFM) like.
+
+    This adds the linkify, table and strikethrough components to CommmonMark.
+
+    Note, it lacks task-list items and raw HTML filtering,
+    to meet the the full GFM specification
+    (see https://github.github.com/gfm/#autolinks-extension-).
+    """
+
+    @staticmethod
+    def make() -> PresetType:
+        config = commonmark.make()
+        config["components"]["core"]["rules"].append("linkify")
+        config["components"]["block"]["rules"].append("table")
+        config["components"]["inline"]["rules"].extend(["strikethrough", "linkify"])
+        config["components"]["inline"]["rules2"].append("strikethrough")
+        config["options"]["linkify"] = True
+        config["options"]["html"] = True
+        return config
+
+
+class gfm_like2:  # noqa: N801
+    """GitHub Flavoured Markdown (GFM) like, extended.
+
+    Builds on ``gfm-like`` and additionally enables:
+
+    - Task lists (``- [x] done``)
+    - Alerts (``> [!NOTE]``)
+    - Single-tilde strikethrough (``~text~`` in addition to ``~~text~~``)
+    """
+
+    @staticmethod
+    def make() -> PresetType:
+        config = gfm_like.make()
+        config["options"]["tasklists"] = True
+        config["options"]["tasklists_editable"] = False
+        config["options"]["alerts"] = True
+        config["options"]["strikethrough_single_tilde"] = True
+        return config

venv/lib/python3.12/site-packages/markdown_it/presets/commonmark.py

@@ -0,0 +1,75 @@
+"""Commonmark default options.
+
+This differs to presets.default,
+primarily in that it allows HTML and does not enable components:
+
+- block: table
+- inline: strikethrough
+"""
+
+from ..utils import PresetType
+
+
+def make() -> PresetType:
+    return {
+        "options": {
+            "maxNesting": 20,  # Internal protection, recursion limit
+            "html": True,  # Enable HTML tags in source,
+            # this is just a shorthand for .enable(["html_inline", "html_block"])
+            # used by the linkify rule:
+            "linkify": False,  # autoconvert URL-like texts to links
+            # used by the replacements and smartquotes rules
+            # Enable some language-neutral replacements + quotes beautification
+            "typographer": False,
+            # used by the smartquotes rule:
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Could be either a String or an Array.
+            #
+            # For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+            # and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+            "quotes": "\u201c\u201d\u2018\u2019",  # /* “”‘’ */
+            # Renderer specific; these options are used directly in the HTML renderer
+            "xhtmlOut": True,  # Use '/' to close single tags (<br />)
+            "breaks": False,  # Convert '\n' in paragraphs into <br>
+            "langPrefix": "language-",  # CSS language prefix for fenced blocks
+            # Highlighter function. Should return escaped HTML,
+            # or '' if the source string is not changed and should be escaped externally.
+            # If result starts with <pre... internal wrapper is skipped.
+            #
+            # function (/*str, lang, attrs*/) { return ''; }
+            #
+            "highlight": None,
+        },
+        "components": {
+            "core": {"rules": ["normalize", "block", "inline", "text_join"]},
+            "block": {
+                "rules": [
+                    "blockquote",
+                    "code",
+                    "fence",
+                    "heading",
+                    "hr",
+                    "html_block",
+                    "lheading",
+                    "list",
+                    "reference",
+                    "paragraph",
+                ]
+            },
+            "inline": {
+                "rules": [
+                    "autolink",
+                    "backticks",
+                    "emphasis",
+                    "entity",
+                    "escape",
+                    "html_inline",
+                    "image",
+                    "link",
+                    "newline",
+                    "text",
+                ],
+                "rules2": ["balance_pairs", "emphasis", "fragments_join"],
+            },
+        },
+    }

venv/lib/python3.12/site-packages/markdown_it/presets/default.py

@@ -0,0 +1,36 @@
+"""markdown-it default options."""
+
+from ..utils import PresetType
+
+
+def make() -> PresetType:
+    return {
+        "options": {
+            "maxNesting": 100,  # Internal protection, recursion limit
+            "html": False,  # Enable HTML tags in source
+            # this is just a shorthand for .disable(["html_inline", "html_block"])
+            # used by the linkify rule:
+            "linkify": False,  # autoconvert URL-like texts to links
+            # used by the replacements and smartquotes rules:
+            # Enable some language-neutral replacements + quotes beautification
+            "typographer": False,
+            # used by the smartquotes rule:
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Could be either a String or an Array.
+            # For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+            # and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+            "quotes": "\u201c\u201d\u2018\u2019",  # /* “”‘’ */
+            # Renderer specific; these options are used directly in the HTML renderer
+            "xhtmlOut": False,  # Use '/' to close single tags (<br />)
+            "breaks": False,  # Convert '\n' in paragraphs into <br>
+            "langPrefix": "language-",  # CSS language prefix for fenced blocks
+            # Highlighter function. Should return escaped HTML,
+            # or '' if the source string is not changed and should be escaped externally.
+            # If result starts with <pre... internal wrapper is skipped.
+            #
+            # function (/*str, lang, attrs*/) { return ''; }
+            #
+            "highlight": None,
+        },
+        "components": {"core": {}, "block": {}, "inline": {}},
+    }

venv/lib/python3.12/site-packages/markdown_it/presets/zero.py

@@ -0,0 +1,44 @@
+"""
+"Zero" preset, with nothing enabled. Useful for manual configuring of simple
+modes. For example, to parse bold/italic only.
+"""
+
+from ..utils import PresetType
+
+
+def make() -> PresetType:
+    return {
+        "options": {
+            "maxNesting": 20,  # Internal protection, recursion limit
+            "html": False,  # Enable HTML tags in source
+            # this is just a shorthand for .disable(["html_inline", "html_block"])
+            # used by the linkify rule:
+            "linkify": False,  # autoconvert URL-like texts to links
+            # used by the replacements and smartquotes rules:
+            # Enable some language-neutral replacements + quotes beautification
+            "typographer": False,
+            # used by the smartquotes rule:
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Could be either a String or an Array.
+            # For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+            # and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+            "quotes": "\u201c\u201d\u2018\u2019",  # /* “”‘’ */
+            # Renderer specific; these options are used directly in the HTML renderer
+            "xhtmlOut": False,  # Use '/' to close single tags (<br />)
+            "breaks": False,  # Convert '\n' in paragraphs into <br>
+            "langPrefix": "language-",  # CSS language prefix for fenced blocks
+            # Highlighter function. Should return escaped HTML,
+            # or '' if the source string is not changed and should be escaped externally.
+            # If result starts with <pre... internal wrapper is skipped.
+            # function (/*str, lang, attrs*/) { return ''; }
+            "highlight": None,
+        },
+        "components": {
+            "core": {"rules": ["normalize", "block", "inline", "text_join"]},
+            "block": {"rules": ["paragraph"]},
+            "inline": {
+                "rules": ["text"],
+                "rules2": ["balance_pairs", "fragments_join"],
+            },
+        },
+    }

venv/lib/python3.12/site-packages/markdown_it/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

venv/lib/python3.12/site-packages/markdown_it/renderer.py

@@ -0,0 +1,356 @@
+"""
+class Renderer
+
+Generates HTML from parsed token stream. Each instance has independent
+copy of rules. Those can be rewritten with ease. Also, you can add new
+rules if you create plugin and adds new token types.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+import inspect
+from typing import Any, ClassVar, Protocol
+
+from .common.utils import escapeHtml, unescapeAll
+from .token import Token
+from .utils import EnvType, OptionsDict
+
+
+class RendererProtocol(Protocol):
+    __output__: ClassVar[str]
+
+    def render(
+        self, tokens: Sequence[Token], options: OptionsDict, env: EnvType
+    ) -> Any: ...
+
+
+class RendererHTML(RendererProtocol):
+    """Contains render rules for tokens. Can be updated and extended.
+
+    Example:
+
+    Each rule is called as independent static function with fixed signature:
+
+    ::
+
+        class Renderer:
+            def token_type_name(self, tokens, idx, options, env) {
+                # ...
+                return renderedHTML
+
+    ::
+
+        class CustomRenderer(RendererHTML):
+            def strong_open(self, tokens, idx, options, env):
+                return '<b>'
+            def strong_close(self, tokens, idx, options, env):
+                return '</b>'
+
+        md = MarkdownIt(renderer_cls=CustomRenderer)
+
+        result = md.render(...)
+
+    See https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js
+    for more details and examples.
+    """
+
+    __output__ = "html"
+
+    def __init__(self, parser: Any = None):
+        self.rules = {
+            k: v
+            for k, v in inspect.getmembers(self, predicate=inspect.ismethod)
+            if not (k.startswith("render") or k.startswith("_"))
+        }
+
+    def render(
+        self, tokens: Sequence[Token], options: OptionsDict, env: EnvType
+    ) -> str:
+        """Takes token stream and generates HTML.
+
+        :param tokens: list on block tokens to render
+        :param options: params of parser instance
+        :param env: additional data from parsed input
+
+        """
+        result = ""
+
+        for i, token in enumerate(tokens):
+            if token.type == "inline":
+                if token.children:
+                    result += self.renderInline(token.children, options, env)
+            elif token.type in self.rules:
+                result += self.rules[token.type](tokens, i, options, env)
+            else:
+                result += self.renderToken(tokens, i, options, env)
+
+        return result
+
+    def renderInline(
+        self, tokens: Sequence[Token], options: OptionsDict, env: EnvType
+    ) -> str:
+        """The same as ``render``, but for single token of `inline` type.
+
+        :param tokens: list on block tokens to render
+        :param options: params of parser instance
+        :param env: additional data from parsed input (references, for example)
+        """
+        result = ""
+
+        for i, token in enumerate(tokens):
+            if token.type in self.rules:
+                result += self.rules[token.type](tokens, i, options, env)
+            else:
+                result += self.renderToken(tokens, i, options, env)
+
+        return result
+
+    def renderToken(
+        self,
+        tokens: Sequence[Token],
+        idx: int,
+        options: OptionsDict,
+        env: EnvType,
+    ) -> str:
+        """Default token renderer.
+
+        Can be overridden by custom function
+
+        :param idx: token index to render
+        :param options: params of parser instance
+        """
+        result = ""
+        needLf = False
+        token = tokens[idx]
+
+        # Tight list paragraphs
+        if token.hidden:
+            return ""
+
+        # Insert a newline between hidden paragraph and subsequent opening
+        # block-level tag.
+        #
+        # For example, here we should insert a newline before blockquote:
+        #  - a
+        #    >
+        #
+        if token.block and token.nesting != -1 and idx and tokens[idx - 1].hidden:
+            result += "\n"
+
+        # Add token name, e.g. `<img`
+        result += ("</" if token.nesting == -1 else "<") + token.tag
+
+        # Encode attributes, e.g. `<img src="foo"`
+        result += self.renderAttrs(token)
+
+        # Add a slash for self-closing tags, e.g. `<img src="foo" /`
+        if token.nesting == 0 and options["xhtmlOut"]:
+            result += " /"
+
+        # Check if we need to add a newline after this tag
+        if token.block:
+            needLf = True
+
+            if token.nesting == 1 and (idx + 1 < len(tokens)):
+                nextToken = tokens[idx + 1]
+
+                if nextToken.type == "inline" or nextToken.hidden:
+                    # Block-level tag containing an inline tag.
+                    #
+                    needLf = False
+
+                elif nextToken.nesting == -1 and nextToken.tag == token.tag:
+                    # Opening tag + closing tag of the same type. E.g. `<li></li>`.
+                    #
+                    needLf = False
+
+        result += ">\n" if needLf else ">"
+
+        return result
+
+    @staticmethod
+    def renderAttrs(token: Token) -> str:
+        """Render token attributes to string."""
+        result = ""
+
+        for key, value in token.attrItems():
+            result += " " + escapeHtml(key) + '="' + escapeHtml(str(value)) + '"'
+
+        return result
+
+    def renderInlineAsText(
+        self,
+        tokens: Sequence[Token] | None,
+        options: OptionsDict,
+        env: EnvType,
+    ) -> str:
+        """Special kludge for image `alt` attributes to conform CommonMark spec.
+
+        Don't try to use it! Spec requires to show `alt` content with stripped markup,
+        instead of simple escaping.
+
+        :param tokens: list on block tokens to render
+        :param options: params of parser instance
+        :param env: additional data from parsed input
+        """
+        result = ""
+
+        for token in tokens or []:
+            if token.type == "text":
+                result += token.content
+            elif token.type == "image":
+                if token.children:
+                    result += self.renderInlineAsText(token.children, options, env)
+            elif token.type == "softbreak":
+                result += "\n"
+
+        return result
+
+    ###################################################
+
+    def list_item_open(
+        self,
+        tokens: Sequence[Token],
+        idx: int,
+        options: OptionsDict,
+        env: EnvType,
+    ) -> str:
+        token = tokens[idx]
+        result = self.renderToken(tokens, idx, options, env)
+        if token.meta and "checked" in token.meta:
+            checked_attr = ' checked=""' if token.meta["checked"] else ""
+            disabled_attr = (
+                "" if options.get("tasklists_editable", False) else ' disabled=""'
+            )
+            result += (
+                '<input class="task-list-item-checkbox"'
+                f'{disabled_attr} type="checkbox"{checked_attr}> '
+            )
+        return result
+
+    def code_inline(
+        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
+    ) -> str:
+        token = tokens[idx]
+        return (
+            "<code"
+            + self.renderAttrs(token)
+            + ">"
+            + escapeHtml(tokens[idx].content)
+            + "</code>"
+        )
+
+    def code_block(
+        self,
+        tokens: Sequence[Token],
+        idx: int,
+        options: OptionsDict,
+        env: EnvType,
+    ) -> str:
+        token = tokens[idx]
+
+        return (
+            "<pre"
+            + self.renderAttrs(token)
+            + "><code>"
+            + escapeHtml(tokens[idx].content)
+            + "</code></pre>\n"
+        )
+
+    def fence(
+        self,
+        tokens: Sequence[Token],
+        idx: int,
+        options: OptionsDict,
+        env: EnvType,
+    ) -> str:
+        token = tokens[idx]
+        info = unescapeAll(token.info).strip() if token.info else ""
+        langName = ""
+        langAttrs = ""
+
+        if info:
+            arr = info.split(maxsplit=1)
+            langName = arr[0]
+            if len(arr) == 2:
+                langAttrs = arr[1]
+
+        if options.highlight:
+            highlighted = options.highlight(
+                token.content, langName, langAttrs
+            ) or escapeHtml(token.content)
+        else:
+            highlighted = escapeHtml(token.content)
+
+        if highlighted.startswith("<pre"):
+            return highlighted + "\n"
+
+        # If language exists, inject class gently, without modifying original token.
+        # May be, one day we will add .deepClone() for token and simplify this part, but
+        # now we prefer to keep things local.
+        if info:
+            # Fake token just to render attributes
+            tmpToken = Token(type="", tag="", nesting=0, attrs=token.attrs.copy())
+            tmpToken.attrJoin("class", options.langPrefix + langName)
+
+            return (
+                "<pre><code"
+                + self.renderAttrs(tmpToken)
+                + ">"
+                + highlighted
+                + "</code></pre>\n"
+            )
+
+        return (
+            "<pre><code"
+            + self.renderAttrs(token)
+            + ">"
+            + highlighted
+            + "</code></pre>\n"
+        )
+
+    def image(
+        self,
+        tokens: Sequence[Token],
+        idx: int,
+        options: OptionsDict,
+        env: EnvType,
+    ) -> str:
+        token = tokens[idx]
+
+        # "alt" attr MUST be set, even if empty. Because it's mandatory and
+        # should be placed on proper position for tests.
+        if token.children:
+            token.attrSet("alt", self.renderInlineAsText(token.children, options, env))
+        else:
+            token.attrSet("alt", "")
+
+        return self.renderToken(tokens, idx, options, env)
+
+    def hardbreak(
+        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
+    ) -> str:
+        return "<br />\n" if options.xhtmlOut else "<br>\n"
+
+    def softbreak(
+        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
+    ) -> str:
+        return (
+            ("<br />\n" if options.xhtmlOut else "<br>\n") if options.breaks else "\n"
+        )
+
+    def text(
+        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
+    ) -> str:
+        return escapeHtml(tokens[idx].content)
+
+    def html_block(
+        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
+    ) -> str:
+        return tokens[idx].content
+
+    def html_inline(
+        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
+    ) -> str:
+        return tokens[idx].content

venv/lib/python3.12/site-packages/markdown_it/ruler.py

@@ -0,0 +1,275 @@
+"""
+class Ruler
+
+Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
+[[MarkdownIt#inline]] to manage sequences of functions (rules):
+
+- keep rules in defined order
+- assign the name to each rule
+- enable/disable rules
+- add/replace rules
+- allow assign rules to additional named chains (in the same)
+- caching lists of active rules
+
+You will not need use this class directly until write plugins. For simple
+rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
+[[MarkdownIt.use]].
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Generic, TypedDict, TypeVar
+import warnings
+
+from .utils import EnvType
+
+if TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
+
+class StateBase:
+    def __init__(self, src: str, md: MarkdownIt, env: EnvType):
+        self.src = src
+        self.env = env
+        self.md = md
+
+    @property
+    def src(self) -> str:
+        return self._src
+
+    @src.setter
+    def src(self, value: str) -> None:
+        self._src = value
+        self._srcCharCode: tuple[int, ...] | None = None
+
+    @property
+    def srcCharCode(self) -> tuple[int, ...]:
+        warnings.warn(
+            "StateBase.srcCharCode is deprecated. Use StateBase.src instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if self._srcCharCode is None:
+            self._srcCharCode = tuple(ord(c) for c in self._src)
+        return self._srcCharCode
+
+
+class RuleOptionsType(TypedDict, total=False):
+    alt: list[str]
+
+
+RuleFuncTv = TypeVar("RuleFuncTv")
+"""A rule function, whose signature is dependent on the state type."""
+
+
+@dataclass(slots=True)
+class Rule(Generic[RuleFuncTv]):
+    name: str
+    enabled: bool
+    fn: RuleFuncTv = field(repr=False)
+    alt: list[str]
+
+
+class Ruler(Generic[RuleFuncTv]):
+    def __init__(self) -> None:
+        # List of added rules.
+        self.__rules__: list[Rule[RuleFuncTv]] = []
+        # Cached rule chains.
+        # First level - chain name, '' for default.
+        # Second level - diginal anchor for fast filtering by charcodes.
+        self.__cache__: dict[str, list[RuleFuncTv]] | None = None
+
+    def __find__(self, name: str) -> int:
+        """Find rule index by name"""
+        for i, rule in enumerate(self.__rules__):
+            if rule.name == name:
+                return i
+        return -1
+
+    def __compile__(self) -> None:
+        """Build rules lookup cache"""
+        chains = {""}
+        # collect unique names
+        for rule in self.__rules__:
+            if not rule.enabled:
+                continue
+            for name in rule.alt:
+                chains.add(name)
+        self.__cache__ = {}
+        for chain in chains:
+            self.__cache__[chain] = []
+            for rule in self.__rules__:
+                if not rule.enabled:
+                    continue
+                if chain and (chain not in rule.alt):
+                    continue
+                self.__cache__[chain].append(rule.fn)
+
+    def at(
+        self, ruleName: str, fn: RuleFuncTv, options: RuleOptionsType | None = None
+    ) -> None:
+        """Replace rule by name with new function & options.
+
+        :param ruleName: rule name to replace.
+        :param fn: new rule function.
+        :param options: new rule options (not mandatory).
+        :raises: KeyError if name not found
+        """
+        index = self.__find__(ruleName)
+        options = options or {}
+        if index == -1:
+            raise KeyError(f"Parser rule not found: {ruleName}")
+        self.__rules__[index].fn = fn
+        self.__rules__[index].alt = options.get("alt", [])
+        self.__cache__ = None
+
+    def before(
+        self,
+        beforeName: str,
+        ruleName: str,
+        fn: RuleFuncTv,
+        options: RuleOptionsType | None = None,
+    ) -> None:
+        """Add new rule to chain before one with given name.
+
+        :param beforeName: new rule will be added before this one.
+        :param ruleName: new rule will be added before this one.
+        :param fn: new rule function.
+        :param options: new rule options (not mandatory).
+        :raises: KeyError if name not found
+        """
+        index = self.__find__(beforeName)
+        options = options or {}
+        if index == -1:
+            raise KeyError(f"Parser rule not found: {beforeName}")
+        self.__rules__.insert(
+            index, Rule[RuleFuncTv](ruleName, True, fn, options.get("alt", []))
+        )
+        self.__cache__ = None
+
+    def after(
+        self,
+        afterName: str,
+        ruleName: str,
+        fn: RuleFuncTv,
+        options: RuleOptionsType | None = None,
+    ) -> None:
+        """Add new rule to chain after one with given name.
+
+        :param afterName: new rule will be added after this one.
+        :param ruleName: new rule will be added after this one.
+        :param fn: new rule function.
+        :param options: new rule options (not mandatory).
+        :raises: KeyError if name not found
+        """
+        index = self.__find__(afterName)
+        options = options or {}
+        if index == -1:
+            raise KeyError(f"Parser rule not found: {afterName}")
+        self.__rules__.insert(
+            index + 1, Rule[RuleFuncTv](ruleName, True, fn, options.get("alt", []))
+        )
+        self.__cache__ = None
+
+    def push(
+        self, ruleName: str, fn: RuleFuncTv, options: RuleOptionsType | None = None
+    ) -> None:
+        """Push new rule to the end of chain.
+
+        :param ruleName: new rule will be added to the end of chain.
+        :param fn: new rule function.
+        :param options: new rule options (not mandatory).
+
+        """
+        self.__rules__.append(
+            Rule[RuleFuncTv](ruleName, True, fn, (options or {}).get("alt", []))
+        )
+        self.__cache__ = None
+
+    def enable(
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> list[str]:
+        """Enable rules with given names.
+
+        :param names: name or list of rule names to enable.
+        :param ignoreInvalid: ignore errors when rule not found
+        :raises: KeyError if name not found and not ignoreInvalid
+        :return: list of found rule names
+        """
+        if isinstance(names, str):
+            names = [names]
+        result: list[str] = []
+        for name in names:
+            idx = self.__find__(name)
+            if (idx < 0) and ignoreInvalid:
+                continue
+            if (idx < 0) and not ignoreInvalid:
+                raise KeyError(f"Rules manager: invalid rule name {name}")
+            self.__rules__[idx].enabled = True
+            result.append(name)
+        self.__cache__ = None
+        return result
+
+    def enableOnly(
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> list[str]:
+        """Enable rules with given names, and disable everything else.
+
+        :param names: name or list of rule names to enable.
+        :param ignoreInvalid: ignore errors when rule not found
+        :raises: KeyError if name not found and not ignoreInvalid
+        :return: list of found rule names
+        """
+        if isinstance(names, str):
+            names = [names]
+        for rule in self.__rules__:
+            rule.enabled = False
+        return self.enable(names, ignoreInvalid)
+
+    def disable(
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> list[str]:
+        """Disable rules with given names.
+
+        :param names: name or list of rule names to enable.
+        :param ignoreInvalid: ignore errors when rule not found
+        :raises: KeyError if name not found and not ignoreInvalid
+        :return: list of found rule names
+        """
+        if isinstance(names, str):
+            names = [names]
+        result = []
+        for name in names:
+            idx = self.__find__(name)
+            if (idx < 0) and ignoreInvalid:
+                continue
+            if (idx < 0) and not ignoreInvalid:
+                raise KeyError(f"Rules manager: invalid rule name {name}")
+            self.__rules__[idx].enabled = False
+            result.append(name)
+        self.__cache__ = None
+        return result
+
+    def getRules(self, chainName: str = "") -> list[RuleFuncTv]:
+        """Return array of active functions (rules) for given chain name.
+        It analyzes rules configuration, compiles caches if not exists and returns result.
+
+        Default chain name is `''` (empty string). It can't be skipped.
+        That's done intentionally, to keep signature monomorphic for high speed.
+
+        """
+        if self.__cache__ is None:
+            self.__compile__()
+            assert self.__cache__ is not None
+        # Chain can be empty, if rules disabled. But we still have to return Array.
+        return self.__cache__.get(chainName, []) or []
+
+    def get_all_rules(self) -> list[str]:
+        """Return all available rule names."""
+        return [r.name for r in self.__rules__]
+
+    def get_active_rules(self) -> list[str]:
+        """Return the active rule names."""
+        return [r.name for r in self.__rules__ if r.enabled]

venv/lib/python3.12/site-packages/markdown_it/rules_block/__init__.py

@@ -0,0 +1,28 @@
+__all__ = (
+    "StateBlock",
+    "blockquote",
+    "code",
+    "fence",
+    "heading",
+    "hr",
+    "html_block",
+    "lheading",
+    "list_block",
+    "make_fence_rule",
+    "paragraph",
+    "reference",
+    "table",
+)
+
+from .blockquote import blockquote
+from .code import code
+from .fence import fence, make_fence_rule
+from .heading import heading
+from .hr import hr
+from .html_block import html_block
+from .lheading import lheading
+from .list import list_block
+from .paragraph import paragraph
+from .reference import reference
+from .state_block import StateBlock
+from .table import table

venv/lib/python3.12/site-packages/markdown_it/rules_block/blockquote.py

@@ -0,0 +1,368 @@
+# Block quotes
+from __future__ import annotations
+
+import logging
+
+from ..common.utils import isStrSpace
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def blockquote(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug(
+        "entering blockquote: %s, %s, %s, %s", state, startLine, endLine, silent
+    )
+
+    oldLineMax = state.lineMax
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    max = state.eMarks[startLine]
+
+    if state.is_code_block(startLine):
+        return False
+
+    # check the block quote marker
+    try:
+        if state.src[pos] != ">":
+            return False
+    except IndexError:
+        return False
+    pos += 1
+
+    # we know that it's going to be a valid blockquote,
+    # so no point trying to find the end of it in silent mode
+    if silent:
+        return True
+
+    # set offset past spaces and ">"
+    initial = offset = state.sCount[startLine] + 1
+
+    try:
+        second_char: str | None = state.src[pos]
+    except IndexError:
+        second_char = None
+
+    # skip one optional space after '>'
+    if second_char == " ":
+        # ' >   test '
+        #     ^ -- position start of line here:
+        pos += 1
+        initial += 1
+        offset += 1
+        adjustTab = False
+        spaceAfterMarker = True
+    elif second_char == "\t":
+        spaceAfterMarker = True
+
+        if (state.bsCount[startLine] + offset) % 4 == 3:
+            # '  >\t  test '
+            #       ^ -- position start of line here (tab has width==1)
+            pos += 1
+            initial += 1
+            offset += 1
+            adjustTab = False
+        else:
+            # ' >\t  test '
+            #    ^ -- position start of line here + shift bsCount slightly
+            #         to make extra space appear
+            adjustTab = True
+
+    else:
+        spaceAfterMarker = False
+
+    oldBMarks = [state.bMarks[startLine]]
+    state.bMarks[startLine] = pos
+
+    while pos < max:
+        ch = state.src[pos]
+
+        if isStrSpace(ch):
+            if ch == "\t":
+                offset += (
+                    4
+                    - (offset + state.bsCount[startLine] + (1 if adjustTab else 0)) % 4
+                )
+            else:
+                offset += 1
+
+        else:
+            break
+
+        pos += 1
+
+    oldBSCount = [state.bsCount[startLine]]
+    state.bsCount[startLine] = (
+        state.sCount[startLine] + 1 + (1 if spaceAfterMarker else 0)
+    )
+
+    lastLineEmpty = pos >= max
+
+    oldSCount = [state.sCount[startLine]]
+    state.sCount[startLine] = offset - initial
+
+    oldTShift = [state.tShift[startLine]]
+    state.tShift[startLine] = pos - state.bMarks[startLine]
+
+    terminatorRules = state.md.block.ruler.getRules("blockquote")
+
+    oldParentType = state.parentType
+    state.parentType = "blockquote"
+
+    # Search the end of the block
+    #
+    # Block ends with either:
+    #  1. an empty line outside:
+    #     ```
+    #     > test
+    #
+    #     ```
+    #  2. an empty line inside:
+    #     ```
+    #     >
+    #     test
+    #     ```
+    #  3. another tag:
+    #     ```
+    #     > test
+    #      - - -
+    #     ```
+
+    # for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
+    nextLine = startLine + 1
+    while nextLine < endLine:
+        # check if it's outdented, i.e. it's inside list item and indented
+        # less than said list item:
+        #
+        # ```
+        # 1. anything
+        #    > current blockquote
+        # 2. checking this line
+        # ```
+        isOutdented = state.sCount[nextLine] < state.blkIndent
+
+        pos = state.bMarks[nextLine] + state.tShift[nextLine]
+        max = state.eMarks[nextLine]
+
+        if pos >= max:
+            # Case 1: line is not inside the blockquote, and this line is empty.
+            break
+
+        evaluatesTrue = state.src[pos] == ">" and not isOutdented
+        pos += 1
+        if evaluatesTrue:
+            # This line is inside the blockquote.
+
+            # set offset past spaces and ">"
+            initial = offset = state.sCount[nextLine] + 1
+
+            try:
+                next_char: str | None = state.src[pos]
+            except IndexError:
+                next_char = None
+
+            # skip one optional space after '>'
+            if next_char == " ":
+                # ' >   test '
+                #     ^ -- position start of line here:
+                pos += 1
+                initial += 1
+                offset += 1
+                adjustTab = False
+                spaceAfterMarker = True
+            elif next_char == "\t":
+                spaceAfterMarker = True
+
+                if (state.bsCount[nextLine] + offset) % 4 == 3:
+                    # '  >\t  test '
+                    #       ^ -- position start of line here (tab has width==1)
+                    pos += 1
+                    initial += 1
+                    offset += 1
+                    adjustTab = False
+                else:
+                    # ' >\t  test '
+                    #    ^ -- position start of line here + shift bsCount slightly
+                    #         to make extra space appear
+                    adjustTab = True
+
+            else:
+                spaceAfterMarker = False
+
+            oldBMarks.append(state.bMarks[nextLine])
+            state.bMarks[nextLine] = pos
+
+            while pos < max:
+                ch = state.src[pos]
+
+                if isStrSpace(ch):
+                    if ch == "\t":
+                        offset += (
+                            4
+                            - (
+                                offset
+                                + state.bsCount[nextLine]
+                                + (1 if adjustTab else 0)
+                            )
+                            % 4
+                        )
+                    else:
+                        offset += 1
+                else:
+                    break
+
+                pos += 1
+
+            lastLineEmpty = pos >= max
+
+            oldBSCount.append(state.bsCount[nextLine])
+            state.bsCount[nextLine] = (
+                state.sCount[nextLine] + 1 + (1 if spaceAfterMarker else 0)
+            )
+
+            oldSCount.append(state.sCount[nextLine])
+            state.sCount[nextLine] = offset - initial
+
+            oldTShift.append(state.tShift[nextLine])
+            state.tShift[nextLine] = pos - state.bMarks[nextLine]
+
+            nextLine += 1
+            continue
+
+        # Case 2: line is not inside the blockquote, and the last line was empty.
+        if lastLineEmpty:
+            break
+
+        # Case 3: another tag found.
+        terminate = False
+
+        for terminatorRule in terminatorRules:
+            if terminatorRule(state, nextLine, endLine, True):
+                terminate = True
+                break
+
+        if terminate:
+            # Quirk to enforce "hard termination mode" for paragraphs;
+            # normally if you call `tokenize(state, startLine, nextLine)`,
+            # paragraphs will look below nextLine for paragraph continuation,
+            # but if blockquote is terminated by another tag, they shouldn't
+            state.lineMax = nextLine
+
+            if state.blkIndent != 0:
+                # state.blkIndent was non-zero, we now set it to zero,
+                # so we need to re-calculate all offsets to appear as
+                # if indent wasn't changed
+                oldBMarks.append(state.bMarks[nextLine])
+                oldBSCount.append(state.bsCount[nextLine])
+                oldTShift.append(state.tShift[nextLine])
+                oldSCount.append(state.sCount[nextLine])
+                state.sCount[nextLine] -= state.blkIndent
+
+            break
+
+        oldBMarks.append(state.bMarks[nextLine])
+        oldBSCount.append(state.bsCount[nextLine])
+        oldTShift.append(state.tShift[nextLine])
+        oldSCount.append(state.sCount[nextLine])
+
+        # A negative indentation means that this is a paragraph continuation
+        #
+        state.sCount[nextLine] = -1
+
+        nextLine += 1
+
+    oldIndent = state.blkIndent
+    state.blkIndent = 0
+
+    # Detect GitHub-style alert marker on the first content line.
+    # Note: `startLine` here refers to the first content line of the
+    # blockquote, after the `>` prefix has already been stripped by the
+    # blockquote parser above (bMarks/tShift adjusted to skip `> `).
+    alert_kind = None
+    if state.md.options.get("alerts", False) and nextLine > startLine:
+        alert_kind = _detect_alert(state, startLine)
+
+    lines = [startLine, 0]
+
+    if alert_kind is not None:
+        # Emit alert tokens instead of blockquote tokens
+        alert_lower = alert_kind.lower()
+        token = state.push("alert_open", "div", 1)
+        token.markup = ">"
+        token.attrSet("class", f"markdown-alert markdown-alert-{alert_lower}")
+        token.map = lines
+        token.info = alert_kind
+        token.meta = {"kind": alert_kind}
+
+        # Emit a title paragraph: <p class="markdown-alert-title">Kind</p>
+        token = state.push("alert_title_open", "p", 1)
+        token.attrSet("class", "markdown-alert-title")
+        title_token = state.push("inline", "", 0)
+        title_token.content = alert_kind.capitalize()
+        title_token.children = []
+        token = state.push("alert_title_close", "p", -1)
+
+        # Skip the marker line (startLine) and tokenize from startLine + 1.
+        contentStart = startLine + 1
+        if contentStart < nextLine:
+            # tokenize() updates state.line to nextLine as part of its
+            # contract, consistent with the blockquote code path below.
+            state.md.block.tokenize(state, contentStart, nextLine)
+        else:
+            state.line = nextLine
+
+        token = state.push("alert_close", "div", -1)
+        token.markup = ">"
+    else:
+        token = state.push("blockquote_open", "blockquote", 1)
+        token.markup = ">"
+        token.map = lines
+
+        state.md.block.tokenize(state, startLine, nextLine)
+
+        token = state.push("blockquote_close", "blockquote", -1)
+        token.markup = ">"
+
+    state.lineMax = oldLineMax
+    state.parentType = oldParentType
+    # Update the opening token map for both alert and blockquote containers.
+    lines[1] = state.line
+
+    # Restore original tShift; this might not be necessary since the parser
+    # has already been here, but just to make sure we can do that.
+    for i, item in enumerate(oldTShift):
+        state.bMarks[i + startLine] = oldBMarks[i]
+        state.tShift[i + startLine] = item
+        state.sCount[i + startLine] = oldSCount[i]
+        state.bsCount[i + startLine] = oldBSCount[i]
+
+    state.blkIndent = oldIndent
+
+    return True
+
+
+_ALERT_TYPES = {"NOTE", "TIP", "IMPORTANT", "WARNING", "CAUTION"}
+
+
+def _detect_alert(state: StateBlock, startLine: int) -> str | None:
+    """Detect ``[!TYPE]`` on *startLine* (after ``>`` prefix has been stripped).
+
+    Returns the alert type string (e.g. ``"NOTE"``) or ``None``.
+    """
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+    src = state.src
+
+    # Trim trailing whitespace
+    while maximum > pos and src[maximum - 1] in (" ", "\t"):
+        maximum -= 1
+
+    if maximum - pos < 4:
+        return None
+    if src[pos] != "[" or src[pos + 1] != "!":
+        return None
+    if src[maximum - 1] != "]":
+        return None
+    type_str = src[pos + 2 : maximum - 1].upper()
+    if type_str not in _ALERT_TYPES:
+        return None
+    return type_str

venv/lib/python3.12/site-packages/markdown_it/rules_block/code.py

@@ -0,0 +1,36 @@
+"""Code block (4 spaces padded)."""
+
+import logging
+
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def code(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug("entering code: %s, %s, %s, %s", state, startLine, endLine, silent)
+
+    if not state.is_code_block(startLine):
+        return False
+
+    last = nextLine = startLine + 1
+
+    while nextLine < endLine:
+        if state.isEmpty(nextLine):
+            nextLine += 1
+            continue
+
+        if state.is_code_block(nextLine):
+            nextLine += 1
+            last = nextLine
+            continue
+
+        break
+
+    state.line = last
+
+    token = state.push("code_block", "code", 0)
+    token.content = state.getLines(startLine, last, 4 + state.blkIndent, False) + "\n"
+    token.map = [startLine, state.line]
+
+    return True

venv/lib/python3.12/site-packages/markdown_it/rules_block/fence.py

@@ -0,0 +1,146 @@
+# fences (``` lang, ~~~ lang)
+from __future__ import annotations
+
+from collections.abc import Callable
+import logging
+
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def make_fence_rule(
+    *,
+    markers: tuple[str, ...] = ("~", "`"),
+    token_type: str = "fence",
+    exact_match: bool = False,
+    disallow_marker_in_info: tuple[str, ...] = ("`",),
+    min_markers: int = 3,
+) -> Callable[[StateBlock, int, int, bool], bool]:
+    """Create a fence parsing rule with configurable options.
+
+    :param markers: Tuple of single characters that can be used as fence markers.
+    :param token_type: The token type name to emit (e.g. "fence", "colon_fence").
+    :param exact_match: If True, the closing fence must have exactly the same
+        number of marker characters as the opening fence (not "at least as many").
+        This enables nesting of fences with different marker counts.
+    :param disallow_marker_in_info: Tuple of marker characters that are not allowed
+        to appear in the info string. The check only applies when the actual opening
+        marker is in this tuple (e.g. a tilde fence is unaffected by ``"`"`` being
+        listed). Per CommonMark, backtick fences cannot have backticks in the info
+        string. Use ``()`` to disable this restriction.
+    :param min_markers: Minimum number of marker characters to form a fence.
+    :return: A block rule function with signature
+        ``(state, startLine, endLine, silent) -> bool``.
+    """
+
+    closing_matcher: Callable[[int, int], bool]
+    if exact_match:
+        # closing code fence must have exactly the same number of markers as the opening one
+        closing_matcher = lambda opening_len, closing_len: closing_len == opening_len  # noqa: E731
+    else:
+        # closing code fence must be at least as long as the opening one
+        closing_matcher = lambda opening_len, closing_len: closing_len >= opening_len  # noqa: E731
+
+    def _fence_rule(
+        state: StateBlock, startLine: int, endLine: int, silent: bool
+    ) -> bool:
+        LOGGER.debug(
+            "entering fence: %s, %s, %s, %s", state, startLine, endLine, silent
+        )
+
+        haveEndMarker = False
+        pos = state.bMarks[startLine] + state.tShift[startLine]
+        maximum = state.eMarks[startLine]
+
+        if state.is_code_block(startLine):
+            return False
+
+        if pos + min_markers > maximum:
+            return False
+
+        marker = state.src[pos]
+
+        if marker not in markers:
+            return False
+
+        # scan marker length
+        mem = pos
+        pos = state.skipCharsStr(pos, marker)
+
+        length = pos - mem
+
+        if length < min_markers:
+            return False
+
+        markup = state.src[mem:pos]
+        params = state.src[pos:maximum]
+
+        if marker in disallow_marker_in_info and marker in params:
+            return False
+
+        # Since start is found, we can report success here in validation mode
+        if silent:
+            return True
+
+        # search end of block
+        nextLine = startLine
+
+        while True:
+            nextLine += 1
+            if nextLine >= endLine:
+                # unclosed block should be autoclosed by end of document.
+                # also block seems to be autoclosed by end of parent
+                break
+
+            pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]
+            maximum = state.eMarks[nextLine]
+
+            if pos < maximum and state.sCount[nextLine] < state.blkIndent:
+                # non-empty line with negative indent should stop the list:
+                # - ```
+                #  test
+                break
+
+            try:
+                if state.src[pos] != marker:
+                    continue
+            except IndexError:
+                break
+
+            if state.is_code_block(nextLine):
+                continue
+
+            pos = state.skipCharsStr(pos, marker)
+
+            if not closing_matcher(length, pos - mem):
+                continue
+
+            # make sure tail has spaces only
+            pos = state.skipSpaces(pos)
+
+            if pos < maximum:
+                continue
+
+            haveEndMarker = True
+            # found!
+            break
+
+        # If a fence has heading spaces, they should be removed from its inner block
+        length = state.sCount[startLine]
+
+        state.line = nextLine + (1 if haveEndMarker else 0)
+
+        token = state.push(token_type, "code", 0)
+        token.info = params
+        token.content = state.getLines(startLine + 1, nextLine, length, True)
+        token.markup = markup
+        token.map = [startLine, state.line]
+
+        return True
+
+    return _fence_rule
+
+
+#: The default fence rule (backtick and tilde markers, CommonMark compliant).
+fence = make_fence_rule()

venv/lib/python3.12/site-packages/markdown_it/rules_block/heading.py

@@ -0,0 +1,69 @@
+"""Atex heading (#, ##, ...)"""
+
+from __future__ import annotations
+
+import logging
+
+from ..common.utils import isStrSpace
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def heading(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug("entering heading: %s, %s, %s, %s", state, startLine, endLine, silent)
+
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+
+    if state.is_code_block(startLine):
+        return False
+
+    ch: str | None = state.src[pos]
+
+    if ch != "#" or pos >= maximum:
+        return False
+
+    # count heading level
+    level = 1
+    pos += 1
+    try:
+        ch = state.src[pos]
+    except IndexError:
+        ch = None
+    while ch == "#" and pos < maximum and level <= 6:
+        level += 1
+        pos += 1
+        try:
+            ch = state.src[pos]
+        except IndexError:
+            ch = None
+
+    if level > 6 or (pos < maximum and not isStrSpace(ch)):
+        return False
+
+    if silent:
+        return True
+
+    # Let's cut tails like '    ###  ' from the end of string
+
+    maximum = state.skipSpacesBack(maximum, pos)
+    tmp = state.skipCharsStrBack(maximum, "#", pos)
+    if tmp > pos and isStrSpace(state.src[tmp - 1]):
+        maximum = tmp
+
+    state.line = startLine + 1
+
+    token = state.push("heading_open", "h" + str(level), 1)
+    token.markup = "########"[:level]
+    token.map = [startLine, state.line]
+
+    token = state.push("inline", "", 0)
+    token.content = state.src[pos:maximum].strip()
+    token.map = [startLine, state.line]
+    token.children = []
+
+    token = state.push("heading_close", "h" + str(level), -1)
+    token.markup = "########"[:level]
+
+    return True

venv/lib/python3.12/site-packages/markdown_it/rules_block/hr.py

@@ -0,0 +1,56 @@
+"""Horizontal rule
+
+At least 3 of these characters on a line * - _
+"""
+
+import logging
+
+from ..common.utils import isStrSpace
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def hr(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug("entering hr: %s, %s, %s, %s", state, startLine, endLine, silent)
+
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+
+    if state.is_code_block(startLine):
+        return False
+
+    try:
+        marker = state.src[pos]
+    except IndexError:
+        return False
+    pos += 1
+
+    # Check hr marker
+    if marker not in ("*", "-", "_"):
+        return False
+
+    # markers can be mixed with spaces, but there should be at least 3 of them
+
+    cnt = 1
+    while pos < maximum:
+        ch = state.src[pos]
+        pos += 1
+        if ch != marker and not isStrSpace(ch):
+            return False
+        if ch == marker:
+            cnt += 1
+
+    if cnt < 3:
+        return False
+
+    if silent:
+        return True
+
+    state.line = startLine + 1
+
+    token = state.push("hr", "hr", 0)
+    token.map = [startLine, state.line]
+    token.markup = marker * (cnt + 1)
+
+    return True

venv/lib/python3.12/site-packages/markdown_it/rules_block/html_block.py

@@ -0,0 +1,90 @@
+# HTML block
+from __future__ import annotations
+
+import logging
+import re
+
+from ..common.html_blocks import block_names
+from ..common.html_re import HTML_OPEN_CLOSE_TAG_STR
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+# An array of opening and corresponding closing sequences for html tags,
+# last argument defines whether it can terminate a paragraph or not
+HTML_SEQUENCES: list[tuple[re.Pattern[str], re.Pattern[str], bool]] = [
+    (
+        re.compile(r"^<(script|pre|style|textarea)(?=(\s|>|$))", re.IGNORECASE),
+        re.compile(r"<\/(script|pre|style|textarea)>", re.IGNORECASE),
+        True,
+    ),
+    (re.compile(r"^<!--"), re.compile(r"-->"), True),
+    (re.compile(r"^<\?"), re.compile(r"\?>"), True),
+    (re.compile(r"^<![A-Z]"), re.compile(r">"), True),
+    (re.compile(r"^<!\[CDATA\["), re.compile(r"\]\]>"), True),
+    (
+        re.compile("^</?(" + "|".join(block_names) + ")(?=(\\s|/?>|$))", re.IGNORECASE),
+        re.compile(r"^$"),
+        True,
+    ),
+    (re.compile(HTML_OPEN_CLOSE_TAG_STR + "\\s*$"), re.compile(r"^$"), False),
+]
+
+
+def html_block(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug(
+        "entering html_block: %s, %s, %s, %s", state, startLine, endLine, silent
+    )
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+
+    if state.is_code_block(startLine):
+        return False
+
+    if not state.md.options.get("html", None):
+        return False
+
+    if state.src[pos] != "<":
+        return False
+
+    lineText = state.src[pos:maximum]
+
+    html_seq = None
+    for HTML_SEQUENCE in HTML_SEQUENCES:
+        if HTML_SEQUENCE[0].search(lineText):
+            html_seq = HTML_SEQUENCE
+            break
+
+    if not html_seq:
+        return False
+
+    if silent:
+        # true if this sequence can be a terminator, false otherwise
+        return html_seq[2]
+
+    nextLine = startLine + 1
+
+    # If we are here - we detected HTML block.
+    # Let's roll down till block end.
+    if not html_seq[1].search(lineText):
+        while nextLine < endLine:
+            if state.sCount[nextLine] < state.blkIndent:
+                break
+
+            pos = state.bMarks[nextLine] + state.tShift[nextLine]
+            maximum = state.eMarks[nextLine]
+            lineText = state.src[pos:maximum]
+
+            if html_seq[1].search(lineText):
+                if len(lineText) != 0:
+                    nextLine += 1
+                break
+            nextLine += 1
+
+    state.line = nextLine
+
+    token = state.push("html_block", "", 0)
+    token.map = [startLine, nextLine]
+    token.content = state.getLines(startLine, nextLine, state.blkIndent, True)
+
+    return True

venv/lib/python3.12/site-packages/markdown_it/rules_block/lheading.py

@@ -0,0 +1,86 @@
+# lheading (---, ==)
+import logging
+
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def lheading(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug("entering lheading: %s, %s, %s, %s", state, startLine, endLine, silent)
+
+    level = None
+    nextLine = startLine + 1
+    ruler = state.md.block.ruler
+    terminatorRules = ruler.getRules("paragraph")
+
+    if state.is_code_block(startLine):
+        return False
+
+    oldParentType = state.parentType
+    state.parentType = "paragraph"  # use paragraph to match terminatorRules
+
+    # jump line-by-line until empty one or EOF
+    while nextLine < endLine and not state.isEmpty(nextLine):
+        # this would be a code block normally, but after paragraph
+        # it's considered a lazy continuation regardless of what's there
+        if state.sCount[nextLine] - state.blkIndent > 3:
+            nextLine += 1
+            continue
+
+        # Check for underline in setext header
+        if state.sCount[nextLine] >= state.blkIndent:
+            pos = state.bMarks[nextLine] + state.tShift[nextLine]
+            maximum = state.eMarks[nextLine]
+
+            if pos < maximum:
+                marker = state.src[pos]
+
+                if marker in ("-", "="):
+                    pos = state.skipCharsStr(pos, marker)
+                    pos = state.skipSpaces(pos)
+
+                    # /* = */
+                    if pos >= maximum:
+                        level = 1 if marker == "=" else 2
+                        break
+
+        # quirk for blockquotes, this line should already be checked by that rule
+        if state.sCount[nextLine] < 0:
+            nextLine += 1
+            continue
+
+        # Some tags can terminate paragraph without empty line.
+        terminate = False
+        for terminatorRule in terminatorRules:
+            if terminatorRule(state, nextLine, endLine, True):
+                terminate = True
+                break
+        if terminate:
+            break
+
+        nextLine += 1
+
+    if not level:
+        # Didn't find valid underline
+        return False
+
+    content = state.getLines(startLine, nextLine, state.blkIndent, False).strip()
+
+    state.line = nextLine + 1
+
+    token = state.push("heading_open", "h" + str(level), 1)
+    token.markup = marker
+    token.map = [startLine, state.line]
+
+    token = state.push("inline", "", 0)
+    token.content = content
+    token.map = [startLine, state.line - 1]
+    token.children = []
+
+    token = state.push("heading_close", "h" + str(level), -1)
+    token.markup = marker
+
+    state.parentType = oldParentType
+
+    return True