intellecton/venv/lib/python3.12/site-packages/markdown/__pycache__/blockparser.cpython-312.pyc

Ë
KÀj`ã
óŒ—dZd
dl
mZ
d
dlmc
mZ
d
dlmZmZm	Z	
ddl
mZ
erd
dlm
Z

ddlmZ
Gd	„d
e«ZGd„d«Zy)
a•

The block parser handles basic parsing of Markdown blocks.  It doesn't concern
itself with inline elements such as `**bold**` or `*italics*`, but rather just
catches blocks, lists, quotes, etc.

The `BlockParser` is made up of a bunch of `BlockProcessors`, each handling a
different type of block. Extensions may add/replace/remove `BlockProcessors`
as they need to alter how Markdown blocks are parsed.
é)
ÚannotationsN)Ú
TYPE_CHECKINGÚIterableÚAnyé
)
Úutil)
ÚMarkdown)
ÚBlockProcessorc
ó(—eZ
dZd
Zdd„Zdd„Zdd„Zy)	ÚStateaŽ Track the current and nested state of the parser.

    This utility class is used to track the state of the `BlockParser` and
    support multiple levels if nesting. It's just a simple API wrapped around
    a list. Each time a state is set, that state is appended to the end of the
    list. Each time a state is reset, that state is removed from the end of
    the list.

    Therefore, each time a state is set for a nested block, that state must be
    reset when we back out of that level of nesting or the state could be
    corrupted.

    While all the methods of a list object are available, only the three
    defined below need be used.

    c
ó&—|j
|
«

y
)z Set a new state. N)
Úappend©ÚselfÚstates  úW/home/antigravity/intellecton/venv/lib/python3.12/site-packages/markdown/blockparser.pyÚsetz	State.set;s€à�‰�EÕóc

ó$—|j
«
y
)z% Step back one step in nested state. N)
Úpop)
rs
 rÚresetzState.reset?s€à�‰�
rc
ó*—t
|«
r|d
|
k(Sy)z2 Test that top (current) level is of given state. éÿÿÿÿF)
Úlenrs  rÚisstatez
State.isstateCs€äˆtŒ9ؘ‘8˜uÑ$Ð$àrN)rr)ÚreturnÚNone)rrrÚbool)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rrr©rrrr)s„ñó"óôrrc
ó0—eZ
dZd
Zdd„Zdd„Zd	d„Zd
d„Zy)ÚBlockParserzÄ Parse Markdown blocks into an `ElementTree` object.

    A wrapper class that stitches the various `BlockProcessors` together,
    looping through them and creating an `ElementTree` object.

    c
ób—t
j«|_t«|_|
|_y
)a§
 Initialize the block parser.

        Arguments:
            md: A Markdown instance.

        Attributes:
            BlockParser.md (Markdown): A Markdown instance.
            BlockParser.state (State): Tracks the nesting level of current location in document being parsed.
            BlockParser.blockprocessors (util.Registry): A collection of
                [`blockprocessors`][markdown.blockprocessors].

        N)rÚRegistryÚblockprocessorsrrÚmd)rr)s  rÚ__init__zBlockParser.__init__Ss#€ô?C
¿m¹m»oˆÔÜ“WˆŒ
؈�rc
óò—t
j|jj«
|_|j|jd
j
|
«
«
t
j|j«
S)aÅ
 Parse a Markdown document into an `ElementTree`.

        Given a list of lines, an `ElementTree` object (not just a parent
        `Element`) is created and the root element is passed to the parser
        as the parent. The `ElementTree` object is returned.

        This should only be called on an entire document, not pieces.

        Arguments:
            lines: A list of lines (strings).

        Returns:
            An element tree.
        ú

)ÚetreeÚElementr)Údoc_tagÚrootÚ
parseChunkÚjoinÚElementTree)rÚliness  rÚ
parseDocumentzBlockParser.parseDocumentdsL€ô —M‘M $§'¡'§/¡/Ó2ˆŒ	Ø�‰˜Ÿ	™	 4§9¡9¨UÓ#3Ô4Ü× Ñ  §¡Ó+Ð+rc
óF—|j
|
|jd
«
«
y)a Parse a chunk of Markdown text and attach to given `etree` node.

        While the `text` argument is generally assumed to contain multiple
        blocks which will be split on blank lines, it could contain only one
        block. Generally, this method would be called by extensions when
        block parsing is required.

        The `parent` `etree` Element passed in is altered in place.
        Nothing is returned.

        Arguments:
            parent: The parent element.
            text: The text to parse.

        z

N)ÚparseBlocksÚsplit)rÚparentÚtexts   rr1zBlockParser.parseChunkxs€ð 	
×ј §¡¨FÓ!3Õ4rc
óŠ—|rA|jD].}|j|
|d
«s
Œ|j|
|«du
s
Œ.
n
|r
Œ@yy)a\ Process blocks of Markdown text and attach to given `etree` node.

        Given a list of `blocks`, each `blockprocessor` is stepped through
        until there are no blocks left. While an extension could potentially
        call this method directly, it's generally expected to be used
        internally.

        This is a public method as an extension may need to add/alter
        additional `BlockProcessors` which call this method to recursively
        parse a nested block.