Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:58
📄 __init__.py """A Python port of Markdown-It""" __all__ = ("MarkdownIt",) __version__ = "3.0.0" from .main import MarkdownIt	113 B	2025-05-25 12:26
📁 __pycache__	-	2025-05-25 12:26
📄 _compat.py from __future__ import annotations from collections.abc import Mapping import sys from typing import Any DATACLASS_KWARGS: Mapping[str, Any] if sys.version_info >= (3, 10): DATACLASS_KWARGS = {"slots": True} else: DATACLASS_KWARGS = {}	246 B	2025-05-25 12:26
📄 _punycode.py # Copyright 2014 Mathias Bynens <https://mathiasbynens.be/> # Copyright 2021 Taneli Hukkinen # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. import codecs import re from typing import Callable REGEX_SEPARATORS = re.compile(r"[\x2E\u3002\uFF0E\uFF61]") REGEX_NON_ASCII = re.compile(r"[^\0-\x7E]") def encode(uni: str) -> str: return codecs.encode(uni, encoding="punycode").decode() def decode(ascii: str) -> str: return codecs.decode(ascii, encoding="punycode") # type: ignore def map_domain(string: str, fn: Callable[[str], str]) -> str: parts = string.split("@") result = "" if len(parts) > 1: # In email addresses, only the domain name should be punycoded. Leave # the local part (i.e. everything up to `@`) intact. result = parts[0] + "@" string = parts[1] labels = REGEX_SEPARATORS.split(string) encoded = ".".join(fn(label) for label in labels) return result + encoded def to_unicode(obj: str) -> str: def mapping(obj: str) -> str: if obj.startswith("xn--"): return decode(obj[4:].lower()) return obj return map_domain(obj, mapping) def to_ascii(obj: str) -> str: def mapping(obj: str) -> str: if REGEX_NON_ASCII.search(obj): return "xn--" + encode(obj) return obj return map_domain(obj, mapping)	2.31 KB	2025-05-25 12:26
📁 cli	-	2025-05-25 12:26
📁 common	-	2025-05-25 12:26
📁 helpers	-	2025-05-25 12:26
📄 main.py 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(), } 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) # type: ignore 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)	12.47 KB	2025-05-25 12:26
📄 parser_block.py """Block-level tokenizer.""" from __future__ import annotations import logging from typing import TYPE_CHECKING, Callable 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	3.82 KB	2025-05-25 12:26
📄 parser_core.py """ * 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)	1010 B	2025-05-25 12:26
📄 parser_inline.py """Tokenizes paragraph content. """ from __future__ import annotations from typing import TYPE_CHECKING, Callable 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 # 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) 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	4.88 KB	2025-05-25 12:26
📄 port.yaml - package: markdown-it/markdown-it version: 13.0.1 commit: e843acc9edad115cbf8cf85e676443f01658be08 date: May 3, 2022 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)	2.39 KB	2025-05-25 12:26
📁 presets	-	2025-05-25 12:26
📄 py.typed # Marker file for PEP 561	26 B	2025-05-25 12:26
📄 renderer.py """ 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	9.74 KB	2025-05-25 12:26
📄 ruler.py """ 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 markdown_it._compat import DATACLASS_KWARGS 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(**DATACLASS_KWARGS) 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]	8.98 KB	2025-05-25 12:26
📁 rules_block	-	2025-05-25 12:26
📁 rules_core	-	2025-05-25 12:26
📁 rules_inline	-	2025-05-25 12:26
📄 token.py from __future__ import annotations from collections.abc import Callable, MutableMapping import dataclasses as dc from typing import Any, Literal import warnings from markdown_it._compat import DATACLASS_KWARGS def convert_attrs(value: Any) -> Any: """Convert Token.attrs set as ``None`` or ``[[key, value], ...]`` to a dict. This improves compatibility with upstream markdown-it. """ if not value: return {} if isinstance(value, list): return dict(value) return value @dc.dataclass(*DATACLASS_KWARGS) class Token: type: str """Type of the token (string, e.g. "paragraph_open")""" tag: str """HTML tag name, e.g. 'p'""" nesting: Literal[-1, 0, 1] """Level change (number in {-1, 0, 1} set), where: - `1` means the tag is opening - `0` means the tag is self-closing - `-1` means the tag is closing """ attrs: dict[str, str \| int \| float] = dc.field(default_factory=dict) """HTML attributes. Note this differs from the upstream "list of lists" format, although than an instance can still be initialised with this format. """ map: list[int] \| None = None """Source map info. Format: `[ line_begin, line_end ]`""" level: int = 0 """Nesting level, the same as `state.level`""" children: list[Token] \| None = None """Array of child nodes (inline and img tokens).""" content: str = "" """Inner content, in the case of a self-closing tag (code, html, fence, etc.),""" markup: str = "" """'' or '_' for emphasis, fence string for fence, etc.""" info: str = "" """Additional information: - Info string for "fence" tokens - The value "auto" for autolink "link_open" and "link_close" tokens - The string value of the item marker for ordered-list "list_item_open" tokens """ meta: dict[Any, Any] = dc.field(default_factory=dict) """A place for plugins to store any arbitrary data""" block: bool = False """True for block-level tokens, false for inline tokens. Used in renderer to calculate line breaks """ hidden: bool = False """If true, ignore this element when rendering. Used for tight lists to hide paragraphs. """ def __post_init__(self) -> None: self.attrs = convert_attrs(self.attrs) def attrIndex(self, name: str) -> int: warnings.warn( # noqa: B028 "Token.attrIndex should not be used, since Token.attrs is a dictionary", UserWarning, ) if name not in self.attrs: return -1 return list(self.attrs.keys()).index(name) def attrItems(self) -> list[tuple[str, str \| int \| float]]: """Get (key, value) list of attrs.""" return list(self.attrs.items()) def attrPush(self, attrData: tuple[str, str \| int \| float]) -> None: """Add `[ name, value ]` attribute to list. Init attrs if necessary.""" name, value = attrData self.attrSet(name, value) def attrSet(self, name: str, value: str \| int \| float) -> None: """Set `name` attribute to `value`. Override old value if exists.""" self.attrs[name] = value def attrGet(self, name: str) -> None \| str \| int \| float: """Get the value of attribute `name`, or null if it does not exist.""" return self.attrs.get(name, None) def attrJoin(self, name: str, value: str) -> None: """Join value to existing attribute via space. Or create new attribute if not exists. Useful to operate with token classes. """ if name in self.attrs: current = self.attrs[name] if not isinstance(current, str): raise TypeError( f"existing attr 'name' is not a str: {self.attrs[name]}" ) self.attrs[name] = f"{current} {value}" else: self.attrs[name] = value def copy(self, changes: Any) -> Token: """Return a shallow copy of the instance.""" return dc.replace(self, changes) def as_dict( self, , children: bool = True, as_upstream: bool = True, meta_serializer: Callable[[dict[Any, Any]], Any] \| None = None, filter: Callable[[str, Any], bool] \| None = None, dict_factory: Callable[..., MutableMapping[str, Any]] = dict, ) -> MutableMapping[str, Any]: """Return the token as a dictionary. :param children: Also convert children to dicts :param as_upstream: Ensure the output dictionary is equal to that created by markdown-it For example, attrs are converted to null or lists :param meta_serializer: hook for serializing ``Token.meta`` :param filter: A callable whose return code determines whether an attribute or element is included (``True``) or dropped (``False``). Is called with the (key, value) pair. :param dict_factory: A callable to produce dictionaries from. For example, to produce ordered dictionaries instead of normal Python dictionaries, pass in ``collections.OrderedDict``. """ mapping = dict_factory((f.name, getattr(self, f.name)) for f in dc.fields(self)) if filter: mapping = dict_factory((k, v) for k, v in mapping.items() if filter(k, v)) if as_upstream and "attrs" in mapping: mapping["attrs"] = ( None if not mapping["attrs"] else [[k, v] for k, v in mapping["attrs"].items()] ) if meta_serializer and "meta" in mapping: mapping["meta"] = meta_serializer(mapping["meta"]) if children and mapping.get("children", None): mapping["children"] = [ child.as_dict( children=children, filter=filter, dict_factory=dict_factory, as_upstream=as_upstream, meta_serializer=meta_serializer, ) for child in mapping["children"] ] return mapping @classmethod def from_dict(cls, dct: MutableMapping[str, Any]) -> Token: """Convert a dict to a Token.""" token = cls(*dct) if token.children: token.children = [cls.from_dict(c) for c in token.children] # type: ignore[arg-type] return token	6.29 KB	2025-05-25 12:26
📄 tree.py """A tree representation of a linear markdown-it token stream. This module is not part of upstream JavaScript markdown-it. """ from __future__ import annotations from collections.abc import Generator, Sequence import textwrap from typing import Any, NamedTuple, TypeVar, overload from .token import Token class _NesterTokens(NamedTuple): opening: Token closing: Token _NodeType = TypeVar("_NodeType", bound="SyntaxTreeNode") class SyntaxTreeNode: """A Markdown syntax tree node. A class that can be used to construct a tree representation of a linear `markdown-it-py` token stream. Each node in the tree represents either: - root of the Markdown document - a single unnested `Token` - a `Token` "_open" and "_close" token pair, and the tokens nested in between """ def __init__( self, tokens: Sequence[Token] = (), , create_root: bool = True ) -> None: """Initialize a `SyntaxTreeNode` from a token stream. If `create_root` is True, create a root node for the document. """ # Only nodes representing an unnested token have self.token self.token: Token \| None = None # Only containers have nester tokens self.nester_tokens: _NesterTokens \| None = None # Root node does not have self.parent self._parent: Any = None # Empty list unless a non-empty container, or unnested token that has # children (i.e. inline or img) self._children: list[Any] = [] if create_root: self._set_children_from_tokens(tokens) return if not tokens: raise ValueError( "Can only create root from empty token sequence." " Set `create_root=True`." ) elif len(tokens) == 1: inline_token = tokens[0] if inline_token.nesting: raise ValueError( "Unequal nesting level at the start and end of token stream." ) self.token = inline_token if inline_token.children: self._set_children_from_tokens(inline_token.children) else: self.nester_tokens = _NesterTokens(tokens[0], tokens[-1]) self._set_children_from_tokens(tokens[1:-1]) def __repr__(self) -> str: return f"{type(self).__name__}({self.type})" @overload def __getitem__(self: _NodeType, item: int) -> _NodeType: ... @overload def __getitem__(self: _NodeType, item: slice) -> list[_NodeType]: ... def __getitem__(self: _NodeType, item: int \| slice) -> _NodeType \| list[_NodeType]: return self.children[item] def to_tokens(self: _NodeType) -> list[Token]: """Recover the linear token stream.""" def recursive_collect_tokens(node: _NodeType, token_list: list[Token]) -> None: if node.type == "root": for child in node.children: recursive_collect_tokens(child, token_list) elif node.token: token_list.append(node.token) else: assert node.nester_tokens token_list.append(node.nester_tokens.opening) for child in node.children: recursive_collect_tokens(child, token_list) token_list.append(node.nester_tokens.closing) tokens: list[Token] = [] recursive_collect_tokens(self, tokens) return tokens @property def children(self: _NodeType) -> list[_NodeType]: return self._children @children.setter def children(self: _NodeType, value: list[_NodeType]) -> None: self._children = value @property def parent(self: _NodeType) -> _NodeType \| None: return self._parent # type: ignore @parent.setter def parent(self: _NodeType, value: _NodeType \| None) -> None: self._parent = value @property def is_root(self) -> bool: """Is the node a special root node?""" return not (self.token or self.nester_tokens) @property def is_nested(self) -> bool: """Is this node nested?. Returns `True` if the node represents a `Token` pair and tokens in the sequence between them, where `Token.nesting` of the first `Token` in the pair is 1 and nesting of the other `Token` is -1. """ return bool(self.nester_tokens) @property def siblings(self: _NodeType) -> Sequence[_NodeType]: """Get siblings of the node. Gets the whole group of siblings, including self. """ if not self.parent: return [self] return self.parent.children @property def type(self) -> str: """Get a string type of the represented syntax. - "root" for root nodes - `Token.type` if the node represents an unnested token - `Token.type` of the opening token, with "_open" suffix stripped, if the node represents a nester token pair """ if self.is_root: return "root" if self.token: return self.token.type assert self.nester_tokens return _removesuffix(self.nester_tokens.opening.type, "_open") @property def next_sibling(self: _NodeType) -> _NodeType \| None: """Get the next node in the sequence of siblings. Returns `None` if this is the last sibling. """ self_index = self.siblings.index(self) if self_index + 1 < len(self.siblings): return self.siblings[self_index + 1] return None @property def previous_sibling(self: _NodeType) -> _NodeType \| None: """Get the previous node in the sequence of siblings. Returns `None` if this is the first sibling. """ self_index = self.siblings.index(self) if self_index - 1 >= 0: return self.siblings[self_index - 1] return None def _add_child( self, tokens: Sequence[Token], ) -> None: """Make a child node for `self`.""" child = type(self)(tokens, create_root=False) child.parent = self self.children.append(child) def _set_children_from_tokens(self, tokens: Sequence[Token]) -> None: """Convert the token stream to a tree structure and set the resulting nodes as children of `self`.""" reversed_tokens = list(reversed(tokens)) while reversed_tokens: token = reversed_tokens.pop() if not token.nesting: self._add_child([token]) continue if token.nesting != 1: raise ValueError("Invalid token nesting") nested_tokens = [token] nesting = 1 while reversed_tokens and nesting: token = reversed_tokens.pop() nested_tokens.append(token) nesting += token.nesting if nesting: raise ValueError(f"unclosed tokens starting {nested_tokens[0]}") self._add_child(nested_tokens) def pretty( self, , indent: int = 2, show_text: bool = False, _current: int = 0 ) -> str: """Create an XML style string of the tree.""" prefix = " " * _current text = prefix + f"<{self.type}" if not self.is_root and self.attrs: text += " " + " ".join(f"{k}={v!r}" for k, v in self.attrs.items()) text += ">" if ( show_text and not self.is_root and self.type in ("text", "text_special") and self.content ): text += "\n" + textwrap.indent(self.content, prefix + " " * indent) for child in self.children: text += "\n" + child.pretty( indent=indent, show_text=show_text, _current=_current + indent ) return text def walk( self: _NodeType, , include_self: bool = True ) -> Generator[_NodeType, None, None]: """Recursively yield all descendant nodes in the tree starting at self. The order mimics the order of the underlying linear token stream (i.e. depth first). """ if include_self: yield self for child in self.children: yield from child.walk(include_self=True) # NOTE: # The values of the properties defined below directly map to properties # of the underlying `Token`s. A root node does not translate to a `Token` # object, so calling these property getters on a root node will raise an # `AttributeError`. # # There is no mapping for `Token.nesting` because the `is_nested` property # provides that data, and can be called on any node type, including root. def _attribute_token(self) -> Token: """Return the `Token` that is used as the data source for the properties defined below.""" if self.token: return self.token if self.nester_tokens: return self.nester_tokens.opening raise AttributeError("Root node does not have the accessed attribute") @property def tag(self) -> str: """html tag name, e.g. \"p\" """ return self._attribute_token().tag @property def attrs(self) -> dict[str, str \| int \| float]: """Html attributes.""" return self._attribute_token().attrs def attrGet(self, name: str) -> None \| str \| int \| float: """Get the value of attribute `name`, or null if it does not exist.""" return self._attribute_token().attrGet(name) @property def map(self) -> tuple[int, int] \| None: """Source map info. Format: `tuple[ line_begin, line_end ]`""" map_ = self._attribute_token().map if map_: # Type ignore because `Token`s attribute types are not perfect return tuple(map_) # type: ignore return None @property def level(self) -> int: """nesting level, the same as `state.level`""" return self._attribute_token().level @property def content(self) -> str: """In a case of self-closing tag (code, html, fence, etc.), it has contents of this tag.""" return self._attribute_token().content @property def markup(self) -> str: """'' or '_' for emphasis, fence string for fence, etc.""" return self._attribute_token().markup @property def info(self) -> str: """fence infostring""" return self._attribute_token().info @property def meta(self) -> dict[Any, Any]: """A place for plugins to store an arbitrary data.""" return self._attribute_token().meta @property def block(self) -> bool: """True for block-level tokens, false for inline tokens.""" return self._attribute_token().block @property def hidden(self) -> bool: """If it's true, ignore this element when rendering. Used for tight lists to hide paragraphs.""" return self._attribute_token().hidden def _removesuffix(string: str, suffix: str) -> str: """Remove a suffix from a string. Replace this with str.removesuffix() from stdlib when minimum Python version is 3.9. """ if suffix and string.endswith(suffix): return string[: -len(suffix)] return string	11.15 KB	2025-05-25 12:26
📄 utils.py from __future__ import annotations from collections.abc import MutableMapping as MutableMappingABC from pathlib import Path from typing import Any, Callable, Iterable, MutableMapping, TypedDict, cast EnvType = MutableMapping[str, Any] # note: could use TypeAlias in python 3.10 """Type for the environment sandbox used in parsing and rendering, which stores mutable variables for use by plugins and rules. """ class OptionsType(TypedDict): """Options for parsing.""" maxNesting: int """Internal protection, recursion limit.""" html: bool """Enable HTML tags in source.""" linkify: bool """Enable autoconversion of URL-like texts to links.""" typographer: bool """Enable smartquotes and replacements.""" quotes: str """Quote characters.""" xhtmlOut: bool """Use '/' to close single tags (<br />).""" breaks: bool """Convert newlines in paragraphs into <br>.""" langPrefix: str """CSS language prefix for fenced blocks.""" highlight: Callable[[str, str, str], str] \| None """Highlighter function: (content, lang, attrs) -> str.""" class PresetType(TypedDict): """Preset configuration for markdown-it.""" options: OptionsType """Options for parsing.""" components: MutableMapping[str, MutableMapping[str, list[str]]] """Components for parsing and rendering.""" class OptionsDict(MutableMappingABC): # type: ignore """A dictionary, with attribute access to core markdownit configuration options.""" # Note: ideally we would probably just remove attribute access entirely, # but we keep it for backwards compatibility. def __init__(self, options: OptionsType) -> None: self._options = cast(OptionsType, dict(options)) def __getitem__(self, key: str) -> Any: return self._options[key] # type: ignore[literal-required] def __setitem__(self, key: str, value: Any) -> None: self._options[key] = value # type: ignore[literal-required] def __delitem__(self, key: str) -> None: del self._options[key] # type: ignore def __iter__(self) -> Iterable[str]: # type: ignore return iter(self._options) def __len__(self) -> int: return len(self._options) def __repr__(self) -> str: return repr(self._options) def __str__(self) -> str: return str(self._options) @property def maxNesting(self) -> int: """Internal protection, recursion limit.""" return self._options["maxNesting"] @maxNesting.setter def maxNesting(self, value: int) -> None: self._options["maxNesting"] = value @property def html(self) -> bool: """Enable HTML tags in source.""" return self._options["html"] @html.setter def html(self, value: bool) -> None: self._options["html"] = value @property def linkify(self) -> bool: """Enable autoconversion of URL-like texts to links.""" return self._options["linkify"] @linkify.setter def linkify(self, value: bool) -> None: self._options["linkify"] = value @property def typographer(self) -> bool: """Enable smartquotes and replacements.""" return self._options["typographer"] @typographer.setter def typographer(self, value: bool) -> None: self._options["typographer"] = value @property def quotes(self) -> str: """Quote characters.""" return self._options["quotes"] @quotes.setter def quotes(self, value: str) -> None: self._options["quotes"] = value @property def xhtmlOut(self) -> bool: """Use '/' to close single tags (<br />).""" return self._options["xhtmlOut"] @xhtmlOut.setter def xhtmlOut(self, value: bool) -> None: self._options["xhtmlOut"] = value @property def breaks(self) -> bool: """Convert newlines in paragraphs into <br>.""" return self._options["breaks"] @breaks.setter def breaks(self, value: bool) -> None: self._options["breaks"] = value @property def langPrefix(self) -> str: """CSS language prefix for fenced blocks.""" return self._options["langPrefix"] @langPrefix.setter def langPrefix(self, value: str) -> None: self._options["langPrefix"] = value @property def highlight(self) -> Callable[[str, str, str], str] \| None: """Highlighter function: (content, langName, langAttrs) -> escaped HTML.""" return self._options["highlight"] @highlight.setter def highlight(self, value: Callable[[str, str, str], str] \| None) -> None: self._options["highlight"] = value def read_fixture_file(path: str \| Path) -> list[list[Any]]: text = Path(path).read_text(encoding="utf-8") tests = [] section = 0 last_pos = 0 lines = text.splitlines(keepends=True) for i in range(len(lines)): if lines[i].rstrip() == ".": if section == 0: tests.append([i, lines[i - 1].strip()]) section = 1 elif section == 1: tests[-1].append("".join(lines[last_pos + 1 : i])) section = 2 elif section == 2: tests[-1].append("".join(lines[last_pos + 1 : i])) section = 0 last_pos = i return tests	5.24 KB	2025-05-25 12:26

Edit File:

Terminal