Add files using upload-large-folder tool

evalkit_tf446/lib/python3.10/site-packages/markdown_it/parser_core.py

@@ -0,0 +1,45 @@
+"""
+ * class Core
+ *
+ * Top-level rules executor. Glues block/inline parsers and does intermediate
+ * transformations.
+"""
+from __future__ import annotations
+
+from typing 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)

evalkit_tf446/lib/python3.10/site-packages/markdown_it/presets/__init__.py

@@ -0,0 +1,28 @@
+__all__ = ("commonmark", "default", "zero", "js_default", "gfm_like")
+
+from . import commonmark, default, zero
+from ..utils import PresetType
+
+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

evalkit_tf446/lib/python3.10/site-packages/markdown_it/presets/commonmark.py

@@ -0,0 +1,74 @@
+"""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"],
+            },
+        },
+    }

evalkit_tf446/lib/python3.10/site-packages/markdown_it/presets/zero.py

@@ -0,0 +1,43 @@
+"""
+"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"],
+            },
+        },
+    }

evalkit_tf446/lib/python3.10/site-packages/markdown_it/py.typed

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

evalkit_tf446/lib/python3.10/site-packages/markdown_it/renderer.py

@@ -0,0 +1,336 @@
+"""
+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:  # noqa: SIM114
+                    # 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 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

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_block/__init__.py

@@ -0,0 +1,27 @@
+__all__ = (
+    "StateBlock",
+    "paragraph",
+    "heading",
+    "lheading",
+    "code",
+    "fence",
+    "hr",
+    "list_block",
+    "reference",
+    "blockquote",
+    "html_block",
+    "table",
+)
+
+from .blockquote import blockquote
+from .code import code
+from .fence import fence
+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

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_block/blockquote.py

@@ -0,0 +1,299 @@
+# 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
+
+    token = state.push("blockquote_open", "blockquote", 1)
+    token.markup = ">"
+    token.map = lines = [startLine, 0]
+
+    state.md.block.tokenize(state, startLine, nextLine)
+
+    token = state.push("blockquote_close", "blockquote", -1)
+    token.markup = ">"
+
+    state.lineMax = oldLineMax
+    state.parentType = oldParentType
+    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

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_block/heading.py

@@ -0,0 +1,68 @@
+""" 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

evalkit_tf446/lib/python3.10/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

evalkit_tf446/lib/python3.10/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

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_block/paragraph.py

@@ -0,0 +1,65 @@
+"""Paragraph."""
+import logging
+
+from .state_block import StateBlock
+
+LOGGER = logging.getLogger(__name__)
+
+
+def paragraph(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    LOGGER.debug(
+        "entering paragraph: %s, %s, %s, %s", state, startLine, endLine, silent
+    )
+
+    nextLine = startLine + 1
+    ruler = state.md.block.ruler
+    terminatorRules = ruler.getRules("paragraph")
+    endLine = state.lineMax
+
+    oldParentType = state.parentType
+    state.parentType = "paragraph"
+
+    # jump line-by-line until empty one or EOF
+    while nextLine < endLine:
+        if state.isEmpty(nextLine):
+            break
+        # 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
+
+        # 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
+
+    content = state.getLines(startLine, nextLine, state.blkIndent, False).strip()
+
+    state.line = nextLine
+
+    token = state.push("paragraph_open", "p", 1)
+    token.map = [startLine, state.line]
+
+    token = state.push("inline", "", 0)
+    token.content = content
+    token.map = [startLine, state.line]
+    token.children = []
+
+    token = state.push("paragraph_close", "p", -1)
+
+    state.parentType = oldParentType
+
+    return True

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_block/state_block.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from ..common.utils import isStrSpace
+from ..ruler import StateBase
+from ..token import Token
+from ..utils import EnvType
+
+if TYPE_CHECKING:
+    from markdown_it.main import MarkdownIt
+
+
+class StateBlock(StateBase):
+    def __init__(
+        self, src: str, md: MarkdownIt, env: EnvType, tokens: list[Token]
+    ) -> None:
+        self.src = src
+
+        # link to parser instance
+        self.md = md
+
+        self.env = env
+
+        #
+        # Internal state variables
+        #
+
+        self.tokens = tokens
+
+        self.bMarks: list[int] = []  # line begin offsets for fast jumps
+        self.eMarks: list[int] = []  # line end offsets for fast jumps
+        # offsets of the first non-space characters (tabs not expanded)
+        self.tShift: list[int] = []
+        self.sCount: list[int] = []  # indents for each line (tabs expanded)
+
+        # An amount of virtual spaces (tabs expanded) between beginning
+        # of each line (bMarks) and real beginning of that line.
+        #
+        # It exists only as a hack because blockquotes override bMarks
+        # losing information in the process.
+        #
+        # It's used only when expanding tabs, you can think about it as
+        # an initial tab length, e.g. bsCount=21 applied to string `\t123`
+        # means first tab should be expanded to 4-21%4 === 3 spaces.
+        #
+        self.bsCount: list[int] = []
+
+        # block parser variables
+        self.blkIndent = 0  # required block content indent (for example, if we are
+        # inside a list, it would be positioned after list marker)
+        self.line = 0  # line index in src
+        self.lineMax = 0  # lines count
+        self.tight = False  # loose/tight mode for lists
+        self.ddIndent = -1  # indent of the current dd block (-1 if there isn't any)
+        self.listIndent = -1  # indent of the current list block (-1 if there isn't any)
+
+        # can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
+        # used in lists to determine if they interrupt a paragraph
+        self.parentType = "root"
+
+        self.level = 0
+
+        # renderer
+        self.result = ""
+
+        # Create caches
+        # Generate markers.
+        indent_found = False
+
+        start = pos = indent = offset = 0
+        length = len(self.src)
+
+        for pos, character in enumerate(self.src):
+            if not indent_found:
+                if isStrSpace(character):
+                    indent += 1
+
+                    if character == "\t":
+                        offset += 4 - offset % 4
+                    else:
+                        offset += 1
+                    continue
+                else:
+                    indent_found = True
+
+            if character == "\n" or pos == length - 1:
+                if character != "\n":
+                    pos += 1
+                self.bMarks.append(start)
+                self.eMarks.append(pos)
+                self.tShift.append(indent)
+                self.sCount.append(offset)
+                self.bsCount.append(0)
+
+                indent_found = False
+                indent = 0
+                offset = 0
+                start = pos + 1
+
+        # Push fake entry to simplify cache bounds checks
+        self.bMarks.append(length)
+        self.eMarks.append(length)
+        self.tShift.append(0)
+        self.sCount.append(0)
+        self.bsCount.append(0)
+
+        self.lineMax = len(self.bMarks) - 1  # don't count last fake line
+
+        # pre-check if code blocks are enabled, to speed up is_code_block method
+        self._code_enabled = "code" in self.md["block"].ruler.get_active_rules()
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}"
+            f"(line={self.line},level={self.level},tokens={len(self.tokens)})"
+        )
+
+    def push(self, ttype: str, tag: str, nesting: Literal[-1, 0, 1]) -> Token:
+        """Push new token to "stream"."""
+        token = Token(ttype, tag, nesting)
+        token.block = True
+        if nesting < 0:
+            self.level -= 1  # closing tag
+        token.level = self.level
+        if nesting > 0:
+            self.level += 1  # opening tag
+        self.tokens.append(token)
+        return token
+
+    def isEmpty(self, line: int) -> bool:
+        """."""
+        return (self.bMarks[line] + self.tShift[line]) >= self.eMarks[line]
+
+    def skipEmptyLines(self, from_pos: int) -> int:
+        """."""
+        while from_pos < self.lineMax:
+            try:
+                if (self.bMarks[from_pos] + self.tShift[from_pos]) < self.eMarks[
+                    from_pos
+                ]:
+                    break
+            except IndexError:
+                pass
+            from_pos += 1
+        return from_pos
+
+    def skipSpaces(self, pos: int) -> int:
+        """Skip spaces from given position."""
+        while True:
+            try:
+                current = self.src[pos]
+            except IndexError:
+                break
+            if not isStrSpace(current):
+                break
+            pos += 1
+        return pos
+
+    def skipSpacesBack(self, pos: int, minimum: int) -> int:
+        """Skip spaces from given position in reverse."""
+        if pos <= minimum:
+            return pos
+        while pos > minimum:
+            pos -= 1
+            if not isStrSpace(self.src[pos]):
+                return pos + 1
+        return pos
+
+    def skipChars(self, pos: int, code: int) -> int:
+        """Skip character code from given position."""
+        while True:
+            try:
+                current = self.srcCharCode[pos]
+            except IndexError:
+                break
+            if current != code:
+                break
+            pos += 1
+        return pos
+
+    def skipCharsStr(self, pos: int, ch: str) -> int:
+        """Skip character string from given position."""
+        while True:
+            try:
+                current = self.src[pos]
+            except IndexError:
+                break
+            if current != ch:
+                break
+            pos += 1
+        return pos
+
+    def skipCharsBack(self, pos: int, code: int, minimum: int) -> int:
+        """Skip character code reverse from given position - 1."""
+        if pos <= minimum:
+            return pos
+        while pos > minimum:
+            pos -= 1
+            if code != self.srcCharCode[pos]:
+                return pos + 1
+        return pos
+
+    def skipCharsStrBack(self, pos: int, ch: str, minimum: int) -> int:
+        """Skip character string reverse from given position - 1."""
+        if pos <= minimum:
+            return pos
+        while pos > minimum:
+            pos -= 1
+            if ch != self.src[pos]:
+                return pos + 1
+        return pos
+
+    def getLines(self, begin: int, end: int, indent: int, keepLastLF: bool) -> str:
+        """Cut lines range from source."""
+        line = begin
+        if begin >= end:
+            return ""
+
+        queue = [""] * (end - begin)
+
+        i = 1
+        while line < end:
+            lineIndent = 0
+            lineStart = first = self.bMarks[line]
+            last = (
+                self.eMarks[line] + 1
+                if line + 1 < end or keepLastLF
+                else self.eMarks[line]
+            )
+
+            while (first < last) and (lineIndent < indent):
+                ch = self.src[first]
+                if isStrSpace(ch):
+                    if ch == "\t":
+                        lineIndent += 4 - (lineIndent + self.bsCount[line]) % 4
+                    else:
+                        lineIndent += 1
+                elif first - lineStart < self.tShift[line]:
+                    lineIndent += 1
+                else:
+                    break
+                first += 1
+
+            if lineIndent > indent:
+                # partially expanding tabs in code blocks, e.g '\t\tfoobar'
+                # with indent=2 becomes '  \tfoobar'
+                queue[i - 1] = (" " * (lineIndent - indent)) + self.src[first:last]
+            else:
+                queue[i - 1] = self.src[first:last]
+
+            line += 1
+            i += 1
+
+        return "".join(queue)
+
+    def is_code_block(self, line: int) -> bool:
+        """Check if line is a code block,
+        i.e. the code block rule is enabled and text is indented by more than 3 spaces.
+        """
+        return self._code_enabled and (self.sCount[line] - self.blkIndent) >= 4

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_block/table.py

@@ -0,0 +1,236 @@
+# GFM table, https://github.github.com/gfm/#tables-extension-
+from __future__ import annotations
+
+import re
+
+from ..common.utils import charStrAt, isStrSpace
+from .state_block import StateBlock
+
+headerLineRe = re.compile(r"^:?-+:?$")
+enclosingPipesRe = re.compile(r"^\||\|$")
+
+
+def getLine(state: StateBlock, line: int) -> str:
+    pos = state.bMarks[line] + state.tShift[line]
+    maximum = state.eMarks[line]
+
+    # return state.src.substr(pos, max - pos)
+    return state.src[pos:maximum]
+
+
+def escapedSplit(string: str) -> list[str]:
+    result: list[str] = []
+    pos = 0
+    max = len(string)
+    isEscaped = False
+    lastPos = 0
+    current = ""
+    ch = charStrAt(string, pos)
+
+    while pos < max:
+        if ch == "|":
+            if not isEscaped:
+                # pipe separating cells, '|'
+                result.append(current + string[lastPos:pos])
+                current = ""
+                lastPos = pos + 1
+            else:
+                # escaped pipe, '\|'
+                current += string[lastPos : pos - 1]
+                lastPos = pos
+
+        isEscaped = ch == "\\"
+        pos += 1
+
+        ch = charStrAt(string, pos)
+
+    result.append(current + string[lastPos:])
+
+    return result
+
+
+def table(state: StateBlock, startLine: int, endLine: int, silent: bool) -> bool:
+    tbodyLines = None
+
+    # should have at least two lines
+    if startLine + 2 > endLine:
+        return False
+
+    nextLine = startLine + 1
+
+    if state.sCount[nextLine] < state.blkIndent:
+        return False
+
+    if state.is_code_block(nextLine):
+        return False
+
+    # first character of the second line should be '|', '-', ':',
+    # and no other characters are allowed but spaces;
+    # basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp
+
+    pos = state.bMarks[nextLine] + state.tShift[nextLine]
+    if pos >= state.eMarks[nextLine]:
+        return False
+    first_ch = state.src[pos]
+    pos += 1
+    if first_ch not in ("|", "-", ":"):
+        return False
+
+    if pos >= state.eMarks[nextLine]:
+        return False
+    second_ch = state.src[pos]
+    pos += 1
+    if second_ch not in ("|", "-", ":") and not isStrSpace(second_ch):
+        return False
+
+    # if first character is '-', then second character must not be a space
+    # (due to parsing ambiguity with list)
+    if first_ch == "-" and isStrSpace(second_ch):
+        return False
+
+    while pos < state.eMarks[nextLine]:
+        ch = state.src[pos]
+
+        if ch not in ("|", "-", ":") and not isStrSpace(ch):
+            return False
+
+        pos += 1
+
+    lineText = getLine(state, startLine + 1)
+
+    columns = lineText.split("|")
+    aligns = []
+    for i in range(len(columns)):
+        t = columns[i].strip()
+        if not t:
+            # allow empty columns before and after table, but not in between columns;
+            # e.g. allow ` |---| `, disallow ` ---||--- `
+            if i == 0 or i == len(columns) - 1:
+                continue
+            else:
+                return False
+
+        if not headerLineRe.search(t):
+            return False
+        if charStrAt(t, len(t) - 1) == ":":
+            aligns.append("center" if charStrAt(t, 0) == ":" else "right")
+        elif charStrAt(t, 0) == ":":
+            aligns.append("left")
+        else:
+            aligns.append("")
+
+    lineText = getLine(state, startLine).strip()
+    if "|" not in lineText:
+        return False
+    if state.is_code_block(startLine):
+        return False
+    columns = escapedSplit(lineText)
+    if columns and columns[0] == "":
+        columns.pop(0)
+    if columns and columns[-1] == "":
+        columns.pop()
+
+    # header row will define an amount of columns in the entire table,
+    # and align row should be exactly the same (the rest of the rows can differ)
+    columnCount = len(columns)
+    if columnCount == 0 or columnCount != len(aligns):
+        return False
+
+    if silent:
+        return True
+
+    oldParentType = state.parentType
+    state.parentType = "table"
+
+    # use 'blockquote' lists for termination because it's
+    # the most similar to tables
+    terminatorRules = state.md.block.ruler.getRules("blockquote")
+
+    token = state.push("table_open", "table", 1)
+    token.map = tableLines = [startLine, 0]
+
+    token = state.push("thead_open", "thead", 1)
+    token.map = [startLine, startLine + 1]
+
+    token = state.push("tr_open", "tr", 1)
+    token.map = [startLine, startLine + 1]
+
+    for i in range(len(columns)):
+        token = state.push("th_open", "th", 1)
+        if aligns[i]:
+            token.attrs = {"style": "text-align:" + aligns[i]}
+
+        token = state.push("inline", "", 0)
+        # note in markdown-it this map was removed in v12.0.0 however, we keep it,
+        # since it is helpful to propagate to children tokens
+        token.map = [startLine, startLine + 1]
+        token.content = columns[i].strip()
+        token.children = []
+
+        token = state.push("th_close", "th", -1)
+
+    token = state.push("tr_close", "tr", -1)
+    token = state.push("thead_close", "thead", -1)
+
+    nextLine = startLine + 2
+    while nextLine < endLine:
+        if state.sCount[nextLine] < state.blkIndent:
+            break
+
+        terminate = False
+        for i in range(len(terminatorRules)):
+            if terminatorRules[i](state, nextLine, endLine, True):
+                terminate = True
+                break
+
+        if terminate:
+            break
+        lineText = getLine(state, nextLine).strip()
+        if not lineText:
+            break
+        if state.is_code_block(nextLine):
+            break
+        columns = escapedSplit(lineText)
+        if columns and columns[0] == "":
+            columns.pop(0)
+        if columns and columns[-1] == "":
+            columns.pop()
+
+        if nextLine == startLine + 2:
+            token = state.push("tbody_open", "tbody", 1)
+            token.map = tbodyLines = [startLine + 2, 0]
+
+        token = state.push("tr_open", "tr", 1)
+        token.map = [nextLine, nextLine + 1]
+
+        for i in range(columnCount):
+            token = state.push("td_open", "td", 1)
+            if aligns[i]:
+                token.attrs = {"style": "text-align:" + aligns[i]}
+
+            token = state.push("inline", "", 0)
+            # note in markdown-it this map was removed in v12.0.0 however, we keep it,
+            # since it is helpful to propagate to children tokens
+            token.map = [nextLine, nextLine + 1]
+            try:
+                token.content = columns[i].strip() if columns[i] else ""
+            except IndexError:
+                token.content = ""
+            token.children = []
+
+            token = state.push("td_close", "td", -1)
+
+        token = state.push("tr_close", "tr", -1)
+
+        nextLine += 1
+
+    if tbodyLines:
+        token = state.push("tbody_close", "tbody", -1)
+        tbodyLines[1] = nextLine
+
+    token = state.push("table_close", "table", -1)
+
+    tableLines[1] = nextLine
+    state.parentType = oldParentType
+    state.line = nextLine
+    return True

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_core/block.py

@@ -0,0 +1,13 @@
+from ..token import Token
+from .state_core import StateCore
+
+
+def block(state: StateCore) -> None:
+    if state.inlineMode:
+        token = Token("inline", "", 0)
+        token.content = state.src
+        token.map = [0, 1]
+        token.children = []
+        state.tokens.append(token)
+    else:
+        state.md.block.parse(state.src, state.md, state.env, state.tokens)

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_core/smartquotes.py

@@ -0,0 +1,202 @@
+"""Convert straight quotation marks to typographic ones
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..common.utils import charCodeAt, isMdAsciiPunct, isPunctChar, isWhiteSpace
+from ..token import Token
+from .state_core import StateCore
+
+QUOTE_TEST_RE = re.compile(r"['\"]")
+QUOTE_RE = re.compile(r"['\"]")
+APOSTROPHE = "\u2019"  # ’
+
+
+def replaceAt(string: str, index: int, ch: str) -> str:
+    # When the index is negative, the behavior is different from the js version.
+    # But basically, the index will not be negative.
+    assert index >= 0
+    return string[:index] + ch + string[index + 1 :]
+
+
+def process_inlines(tokens: list[Token], state: StateCore) -> None:
+    stack: list[dict[str, Any]] = []
+
+    for i, token in enumerate(tokens):
+        thisLevel = token.level
+
+        j = 0
+        for j in range(len(stack))[::-1]:
+            if stack[j]["level"] <= thisLevel:
+                break
+        else:
+            # When the loop is terminated without a "break".
+            # Subtract 1 to get the same index as the js version.
+            j -= 1
+
+        stack = stack[: j + 1]
+
+        if token.type != "text":
+            continue
+
+        text = token.content
+        pos = 0
+        maximum = len(text)
+
+        while pos < maximum:
+            goto_outer = False
+            lastIndex = pos
+            t = QUOTE_RE.search(text[lastIndex:])
+            if not t:
+                break
+
+            canOpen = canClose = True
+            pos = t.start(0) + lastIndex + 1
+            isSingle = t.group(0) == "'"
+
+            # Find previous character,
+            # default to space if it's the beginning of the line
+            lastChar: None | int = 0x20
+
+            if t.start(0) + lastIndex - 1 >= 0:
+                lastChar = charCodeAt(text, t.start(0) + lastIndex - 1)
+            else:
+                for j in range(i)[::-1]:
+                    if tokens[j].type == "softbreak" or tokens[j].type == "hardbreak":
+                        break
+                    # should skip all tokens except 'text', 'html_inline' or 'code_inline'
+                    if not tokens[j].content:
+                        continue
+
+                    lastChar = charCodeAt(tokens[j].content, len(tokens[j].content) - 1)
+                    break
+
+            # Find next character,
+            # default to space if it's the end of the line
+            nextChar: None | int = 0x20
+
+            if pos < maximum:
+                nextChar = charCodeAt(text, pos)
+            else:
+                for j in range(i + 1, len(tokens)):
+                    # nextChar defaults to 0x20
+                    if tokens[j].type == "softbreak" or tokens[j].type == "hardbreak":
+                        break
+                    # should skip all tokens except 'text', 'html_inline' or 'code_inline'
+                    if not tokens[j].content:
+                        continue
+
+                    nextChar = charCodeAt(tokens[j].content, 0)
+                    break
+
+            isLastPunctChar = lastChar is not None and (
+                isMdAsciiPunct(lastChar) or isPunctChar(chr(lastChar))
+            )
+            isNextPunctChar = nextChar is not None and (
+                isMdAsciiPunct(nextChar) or isPunctChar(chr(nextChar))
+            )
+
+            isLastWhiteSpace = lastChar is not None and isWhiteSpace(lastChar)
+            isNextWhiteSpace = nextChar is not None and isWhiteSpace(nextChar)
+
+            if isNextWhiteSpace:  # noqa: SIM114
+                canOpen = False
+            elif isNextPunctChar and not (isLastWhiteSpace or isLastPunctChar):
+                canOpen = False
+
+            if isLastWhiteSpace:  # noqa: SIM114
+                canClose = False
+            elif isLastPunctChar and not (isNextWhiteSpace or isNextPunctChar):
+                canClose = False
+
+            if nextChar == 0x22 and t.group(0) == '"':  # 0x22: "  # noqa: SIM102
+                if (
+                    lastChar is not None and lastChar >= 0x30 and lastChar <= 0x39
+                ):  # 0x30: 0, 0x39: 9
+                    # special case: 1"" - count first quote as an inch
+                    canClose = canOpen = False
+
+            if canOpen and canClose:
+                # Replace quotes in the middle of punctuation sequence, but not
+                # in the middle of the words, i.e.:
+                #
+                # 1. foo " bar " baz - not replaced
+                # 2. foo-"-bar-"-baz - replaced
+                # 3. foo"bar"baz     - not replaced
+                canOpen = isLastPunctChar
+                canClose = isNextPunctChar
+
+            if not canOpen and not canClose:
+                # middle of word
+                if isSingle:
+                    token.content = replaceAt(
+                        token.content, t.start(0) + lastIndex, APOSTROPHE
+                    )
+                continue
+
+            if canClose:
+                # this could be a closing quote, rewind the stack to get a match
+                for j in range(len(stack))[::-1]:
+                    item = stack[j]
+                    if stack[j]["level"] < thisLevel:
+                        break
+                    if item["single"] == isSingle and stack[j]["level"] == thisLevel:
+                        item = stack[j]
+
+                        if isSingle:
+                            openQuote = state.md.options.quotes[2]
+                            closeQuote = state.md.options.quotes[3]
+                        else:
+                            openQuote = state.md.options.quotes[0]
+                            closeQuote = state.md.options.quotes[1]
+
+                        # replace token.content *before* tokens[item.token].content,
+                        # because, if they are pointing at the same token, replaceAt
+                        # could mess up indices when quote length != 1
+                        token.content = replaceAt(
+                            token.content, t.start(0) + lastIndex, closeQuote
+                        )
+                        tokens[item["token"]].content = replaceAt(
+                            tokens[item["token"]].content, item["pos"], openQuote
+                        )
+
+                        pos += len(closeQuote) - 1
+                        if item["token"] == i:
+                            pos += len(openQuote) - 1
+
+                        text = token.content
+                        maximum = len(text)
+
+                        stack = stack[:j]
+                        goto_outer = True
+                        break
+                if goto_outer:
+                    goto_outer = False
+                    continue
+
+            if canOpen:
+                stack.append(
+                    {
+                        "token": i,
+                        "pos": t.start(0) + lastIndex,
+                        "single": isSingle,
+                        "level": thisLevel,
+                    }
+                )
+            elif canClose and isSingle:
+                token.content = replaceAt(
+                    token.content, t.start(0) + lastIndex, APOSTROPHE
+                )
+
+
+def smartquotes(state: StateCore) -> None:
+    if not state.md.options.typographer:
+        return
+
+    for token in state.tokens:
+        if token.type != "inline" or not QUOTE_RE.search(token.content):
+            continue
+        if token.children is not None:
+            process_inlines(token.children, state)

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_core/state_core.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..ruler import StateBase
+from ..token import Token
+from ..utils import EnvType
+
+if TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
+
+class StateCore(StateBase):
+    def __init__(
+        self,
+        src: str,
+        md: MarkdownIt,
+        env: EnvType,
+        tokens: list[Token] | None = None,
+    ) -> None:
+        self.src = src
+        self.md = md  # link to parser instance
+        self.env = env
+        self.tokens: list[Token] = tokens or []
+        self.inlineMode = False

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_inline/__init__.py

@@ -0,0 +1,31 @@
+__all__ = (
+    "StateInline",
+    "text",
+    "fragments_join",
+    "link_pairs",
+    "linkify",
+    "escape",
+    "newline",
+    "backtick",
+    "emphasis",
+    "image",
+    "link",
+    "autolink",
+    "entity",
+    "html_inline",
+    "strikethrough",
+)
+from . import emphasis, strikethrough
+from .autolink import autolink
+from .backticks import backtick
+from .balance_pairs import link_pairs
+from .entity import entity
+from .escape import escape
+from .fragments_join import fragments_join
+from .html_inline import html_inline
+from .image import image
+from .link import link
+from .linkify import linkify
+from .newline import newline
+from .state_inline import StateInline
+from .text import text

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_inline/autolink.py

@@ -0,0 +1,77 @@
+# Process autolinks '<protocol:...>'
+import re
+
+from .state_inline import StateInline
+
+EMAIL_RE = re.compile(
+    r"^([a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$"  # noqa: E501
+)
+AUTOLINK_RE = re.compile(r"^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$")
+
+
+def autolink(state: StateInline, silent: bool) -> bool:
+    pos = state.pos
+
+    if state.src[pos] != "<":
+        return False
+
+    start = state.pos
+    maximum = state.posMax
+
+    while True:
+        pos += 1
+        if pos >= maximum:
+            return False
+
+        ch = state.src[pos]
+
+        if ch == "<":
+            return False
+        if ch == ">":
+            break
+
+    url = state.src[start + 1 : pos]
+
+    if AUTOLINK_RE.search(url) is not None:
+        fullUrl = state.md.normalizeLink(url)
+        if not state.md.validateLink(fullUrl):
+            return False
+
+        if not silent:
+            token = state.push("link_open", "a", 1)
+            token.attrs = {"href": fullUrl}
+            token.markup = "autolink"
+            token.info = "auto"
+
+            token = state.push("text", "", 0)
+            token.content = state.md.normalizeLinkText(url)
+
+            token = state.push("link_close", "a", -1)
+            token.markup = "autolink"
+            token.info = "auto"
+
+        state.pos += len(url) + 2
+        return True
+
+    if EMAIL_RE.search(url) is not None:
+        fullUrl = state.md.normalizeLink("mailto:" + url)
+        if not state.md.validateLink(fullUrl):
+            return False
+
+        if not silent:
+            token = state.push("link_open", "a", 1)
+            token.attrs = {"href": fullUrl}
+            token.markup = "autolink"
+            token.info = "auto"
+
+            token = state.push("text", "", 0)
+            token.content = state.md.normalizeLinkText(url)
+
+            token = state.push("link_close", "a", -1)
+            token.markup = "autolink"
+            token.info = "auto"
+
+        state.pos += len(url) + 2
+        return True
+
+    return False

evalkit_tf446/lib/python3.10/site-packages/markdown_it/rules_inline/backticks.py

@@ -0,0 +1,72 @@
+# Parse backticks
+import re
+
+from .state_inline import StateInline
+
+regex = re.compile("^ (.+) $")
+
+
+def backtick(state: StateInline, silent: bool) -> bool:
+    pos = state.pos
+
+    if state.src[pos] != "`":
+        return False
+
+    start = pos
+    pos += 1
+    maximum = state.posMax
+
+    # scan marker length
+    while pos < maximum and (state.src[pos] == "`"):
+        pos += 1
+
+    marker = state.src[start:pos]
+    openerLength = len(marker)
+
+    if state.backticksScanned and state.backticks.get(openerLength, 0) <= start:
+        if not silent:
+            state.pending += marker
+        state.pos += openerLength
+        return True
+
+    matchStart = matchEnd = pos
+
+    # Nothing found in the cache, scan until the end of the line (or until marker is found)
+    while True:
+        try:
+            matchStart = state.src.index("`", matchEnd)
+        except ValueError:
+            break
+        matchEnd = matchStart + 1
+
+        # scan marker length
+        while matchEnd < maximum and (state.src[matchEnd] == "`"):
+            matchEnd += 1
+
+        closerLength = matchEnd - matchStart
+
+        if closerLength == openerLength:
+            # Found matching closer length.
+            if not silent:
+                token = state.push("code_inline", "code", 0)
+                token.markup = marker
+                token.content = state.src[pos:matchStart].replace("\n", " ")
+                if (
+                    token.content.startswith(" ")
+                    and token.content.endswith(" ")
+                    and len(token.content.strip()) > 0
+                ):
+                    token.content = token.content[1:-1]
+            state.pos = matchEnd
+            return True
+
+        # Some different length found, put it in cache as upper limit of where closer can be found
+        state.backticks[closerLength] = matchStart
+
+    # Scanned through the end, didn't find anything
+    state.backticksScanned = True
+
+    if not silent:
+        state.pending += marker
+    state.pos += openerLength
+    return True