Source code for markdown_it.parser_block

"""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

    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"]),
        ["paragraph", "reference", "blockquote", "list"],
    ("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, []),

[docs]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})
[docs] def tokenize(self, state: StateBlock, startLine: int, endLine: int) -> None: """Generate tokens for input range.""" rules = self.ruler.getRules("") line = startLine 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
[docs] 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