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

Ë
KÀj—–ã
ó—dZd
dl
mZ
ddlmZ
d
dlmZmZmZm	Z	
d
dl
Z
d
dlmc
m
Z
d
dlmZ
erd
dlmZ
dPd	„Zd
Z	dZ	dZ	d
Z	dZ	dZ	dZ	dZ	dZ	dZ	dZ	dZ	dZ	edzZ 	dZ!	e Z"	e!Z#	dZ$	dZ%	dZ&	dZ'	dZ(	dZ)	dQd„Z*Gd „d!e	«Z+Gd"„d#«Z,Gd$„d%e,«Z-Gd&„d'e,«Z.Gd(„d)e-«Z/Gd*„d+e-«Z0Gd,„d-e,«Z1Gd.„d/e-«Z2Gd0„d1e1«Z3Gd2„d3e2«Z4Gd4„d5e-«Z5Gd6„d7e1«Z6Gd8„d9e2«Z7Gd:„d;e-«Z8Gd<„d=e-«Z9Gd>„d?e9«Z:Gd@„dAe-«Z;GdB„dCe;«Z<GdD„dEe;«Z=GdF„dGe=«Z>GdH„dIe=«Z?GdJ„dKe?«Z@GdL„dMe-«ZAGdN„dOe-«ZBy)RaB
In version 3.0, a new, more flexible inline processor was added, [`markdown.inlinepatterns.InlineProcessor`][].   The
original inline patterns, which inherit from [`markdown.inlinepatterns.Pattern`][] or one of its children are still
supported, though users are encouraged to migrate.

The new `InlineProcessor` provides two major enhancements to `Patterns`:

1. Inline Processors no longer need to match the entire block, so regular expressions no longer need to start with
  `r'^(.*?)'` and end with `r'(.*?)%'`. This runs faster. The returned [`Match`][re.Match] object will only contain
   what is explicitly matched in the pattern, and extension pattern groups now start with `m.group(1)`.

2.  The `handleMatch` method now takes an additional input called `data`, which is the entire block under analysis,
    not just what is matched with the specified pattern. The method now returns the element *and* the indexes relative
    to `data` that the return element is replacing (usually `m.start(0)` and `m.end(0)`).  If the boundaries are
    returned as `None`, it is assumed that the match did not take place, and nothing will be altered in `data`.

    This allows handling of more complex constructs than regular expressions can handle, e.g., matching nested
    brackets, and explicit control of the span "consumed" by the processor.

é)
Úannotationsé
)
Úutil)Ú
TYPE_CHECKINGÚAnyÚ
CollectionÚ
NamedTupleN)
Úentities)
ÚMarkdownc

ó6—t
j«}|jtt«
d
d«
|jtt|«dd«
|jtt|«dd«
|jtt|«dd«
|jtt|«d	d
«
|jtt|«dd«
|jtt|«d
d«
|jt!t|«dd«
|jt#t$|«dd«
|jt't(|«dd«
|jt+t,d«dd«
|jt/t0|«dd«
|jt/t2|«dd«
|jt5t6«
dd«
|jt9d«
dd «
|jt;d!«
d"d#«
|S)$a
    Build the default set of inline patterns for Markdown.

    The order in which processors and/or patterns are applied is very important - e.g. if we first replace
    `http://.../` links with `<a>` tags and _then_ try to replace inline HTML, we would end up with a mess. So, we
    apply the expressions in the following order:

    * backticks and escaped characters have to be handled before everything else so that we can preempt any markdown
      patterns by escaping them;

    * then we handle the various types of links (auto-links must be handled before inline HTML);

    * then we handle inline HTML.  At this point we will simply replace all inline HTML strings with a placeholder
      and add the actual HTML to a stash;

    * finally we apply strong, emphasis, etc.

    Úbacktické¾Úescapeé´Ú	referenceéªÚlinké Ú
image_linké–Úimage_referenceéŒÚshort_referenceé‚Úshort_image_refé}ÚautolinkéxÚautomailénÚbrÚ	linebreakédÚhtmléZÚentityéPÚ
not_strongéFz\*Ú	em_strongé<Ú
_Ú
em_strong2é2)rÚRegistryÚregisterÚBacktickInlineProcessorÚBACKTICK_REÚEscapeInlineProcessorÚ	ESCAPE_REÚReferenceInlineProcessorÚREFERENCE_REÚLinkInlineProcessorÚLINK_REÚImageInlineProcessorÚ
IMAGE_LINK_REÚImageReferenceInlineProcessorÚIMAGE_REFERENCE_REÚShortReferenceInlineProcessorÚ"ShortImageReferenceInlineProcessorÚAutolinkInlineProcessorÚAUTOLINK_REÚAutomailInlineProcessorÚAUTOMAIL_REÚSubstituteTagInlineProcessorÚ
LINE_BREAK_REÚHtmlInlineProcessorÚHTML_REÚ	ENTITY_REÚSimpleTextInlineProcessorÚ
NOT_STRONG_REÚAsteriskProcessorÚUnderscoreProcessor)ÚmdÚkwargsÚinlinePatternss   úZ/home/antigravity/intellecton/venv/lib/python3.12/site-packages/markdown/inlinepatterns.pyÚbuild_inlinepatternsrP5sÆ
€ô&—]‘]“_€NØ×ÑÔ3´KÓ@À*ÈcÔRØ×ÑÔ1´)¸RÓ@À(ÈCÔPØ×ÑÔ4´\À2ÓFÈÐUXÔYØ×ÑÔ/´¸Ó<¸fÀcÔJØ×ÑÔ0´ÀÓCÀ\ÐSVÔWØ×ÑÜ%Ô&8¸"Ó=Ð?PÐRUôð×ÑÜ%¤l°BÓ7Ð9JÈCôð×ÑÜ*Ô+=¸rÓBÐDUÐWZôð×ÑÔ3´KÀÓDÀjÐRUÔVØ×ÑÔ3´KÀÓDÀjÐRUÔVØ×ÑÔ8¼ÈÓMÈ{Ð\_Ô`Ø×ÑÔ/´¸Ó<¸fÀbÔIØ×ÑÔ/´	¸2Ó>ÀÈ"ÔMØ×ÑÔ5´mÓDÀlÐTVÔWØ×ÑÔ-¨eÓ4°kÀ2ÔFØ×ÑÔ/°Ó5°|ÀRÔHØÐóz(?<!\!)z;(?:(?<!\\)((?:\\{2})+)(?=`+)|(?<!\\)(`+)(.+?)(?<!`)\2(?!`))z\\(.)z(\*)([^\*]+)\1z(\*{2})(.+?)\1z%(?<!\w)(_{2})(?!_)(.+?)(?<!_)\1(?!\w)z"(?<!\w)(_)(?!_)(.+?)(?<!_)\1(?!\w)z7(?<!\w)(\_)\1(?!\1)(.+?)(?<!\w)\1(?!\1)(.+?)\1{3}(?!\w)z(\*)\1{2}(.+?)\1(.*?)\1{2}z(_)\1{2}(.+?)\1(.*?)\1{2}z(\*)\1{2}(.+?)\1{2}(.*?)\1z(_)\1{2}(.+?)\1{2}(.*?)\1z&(\*)\1(?!\1)([^*]+?)\1(?!\1)(.+?)\1{3}z\[z\!\[z%((^|(?<=\s))(\*{1,3}|_{1,3})(?=\s|$))z+<((?:[Ff]|[Hh][Tt])[Tt][Pp][Ss]?://[^<>]*)>z<([^<> !]+@[^@<> ]+)>z(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!<!--|-->).)*--|[?](?:(?!<[?]|[?]>).)*[?]|!\[CDATA\[(?:(?!<!\[CDATA\[|\]\]>).)*\]\])>)z-(&(?:\#[0-9]+|\#x[0-9a-fA-F]+|[a-zA-Z0-9]+);)z  \nc

ó˜—|j
d
«
r|jd
«
s"|j
d«
r|jd«
r|ddS|S)z#Remove quotes from around a string.ú
"ú
'réÿÿÿÿ)Ú
startswithÚendswith)
Ústrings
 rOÚdequoterY±sE€à	×	Ñ	˜3Ô	 F§O¡O°CÔ$8Ø×ј#Ô 6§?¡?°3Ô#7Ø�a˜ˆ|Ðàˆ
rQc
ó0—eZ
dZUd
Zded<ded<ded<y)ÚEmStrongItemzEmphasis/strong pattern item.úre.Pattern[str]ÚpatternÚstrÚbuilderÚtagsN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__©rQrOr[r[ºs…Ù'Ø
ÓØ
ƒLØ

„IrQr[c
ój—eZ
dZUd
Ze«Zded<	ded<ded<ddd	„Zdd
„Zdd„Z	dd„Z
dd
„Zy)ÚPatternaí
    Base class that inline patterns subclass.

    Inline patterns are handled by means of `Pattern` subclasses, one per regular expression.
    Each pattern object uses a single regular expression and must support the following methods:
    [`getCompiledRegExp`][markdown.inlinepatterns.Pattern.getCompiledRegExp] and
    [`handleMatch`][markdown.inlinepatterns.Pattern.handleMatch].

    All the regular expressions used by `Pattern` subclasses must capture the whole block.  For this
    reason, they all start with `^(.*)` and end with `(.*)!`.  When passing a regular expression on
    class initialization, the `^(.*)` and `(.*)!` are added automatically and the regular expression
    is pre-compiled.

    It is strongly suggested that the newer style [`markdown.inlinepatterns.InlineProcessor`][] that
    use a more efficient and flexible search approach be used instead. However, the older style
    `Pattern` remains for backward compatibility with many existing third-party extensions.

    zCollection[str]ÚANCESTOR_EXCLUDESr\Úcompiled_reúMarkdown | NonerLNc
óš—|
|_tjd
|
ztjtjz«|_||_y)a!

        Create an instant of an inline pattern.

        Arguments:
            pattern: A regular expression that matches a pattern.
            md: An optional pointer to the instance of `markdown.Markdown` and is available as
                `self.md` on the class instance.


        z
^(.*?)%s(.*)$N)r]ÚreÚcompileÚDOTALLÚUNICODErjrL©Úselfr]rLs   rOÚ__init__zPattern.__init__âs=€ðˆŒÜŸ:™:Ð&6¸Ñ&@Ü&(§i¡i´"·*±*Ñ&<ó
>ˆÔðˆ�rQc


ó—|jS)
z' Return a compiled regular expression. )
rj©
rrs
 rOÚgetCompiledRegExpzPattern.getCompiledRegExpós€à×ÑÐrQc
ó—y
)zóReturn a ElementTree element from the given match.

        Subclasses should override this method.

        Arguments:
            m: A match object containing a match of the pattern.

        Returns: An ElementTree Element object.

        Nrf©rrÚ
ms  rOÚhandleMatchzPattern.handleMatch÷s€ð	
rQc


ó.—|jjS)
z+ Return class name, to define pattern type )Ú	__class__rarus
 rOÚtypezPattern.type
s€à�~‰~×&Ñ&Ð&rQc
󸇗	|jjd
jŠˆf
d„}tj
j
||
«S#t$r
|
cYSwxYw
)ú> Return unescaped text given text with an inline placeholder. Úinlinec

ó´•
—|j
d
«
}
|
‰vrB‰j|
«
}t|t«r|Sdj	|j««
Sy)NrÚ)ÚgroupÚgetÚ
isinstancer^ÚjoinÚitertext)ryÚidÚvalueÚstashs   €rOÚ	get_stashz#Pattern.unescape.<locals>.get_stash
sPø€Ø—‘˜“ˆBØ�U‰{ØŸ	™	 "›
�ܘe¤SÔ)Ø �LðŸ7™7 5§>¡>Ó#3Ó4Ð4ð
rQ©rLÚtreeprocessorsÚ
stashed_nodesÚKeyErrorrÚINLINE_PLACEHOLDER_REÚsub©rrÚtextr‹rŠs   @rOÚunescapezPattern.unescape
sXø€ð	Ø—G‘G×*Ñ*¨8Ñ4×BÑBˆEô	5ô×)Ñ)×-Ñ-¨i¸Ó>Ð>øôò
	ØŠKð
	úsƒ#AÁAÁ
A©
N©r]r^rLrk)Úreturnz
re.Pattern)ryú
re.Match[str]r—zetree.Element | str)r—r^©r“r^r—r^)rarbrcrdÚtuplerirersrvrzr}r”rfrQrOrhrhÅsB…ññ&*/«Ð�Ó0ðð
!Ó ØÓôó" ó
ó'ô?rQrhc
ó"—eZ
dZd
Zddd„Zdd„Zy)ÚInlineProcessorz¡
    Base class that inline processors subclass.

    This is the newer style inline processor that uses a more
    efficient and flexible search approach.

    Nc
ó¢—|
|_tj|
tjtjz«|_d
|_||_y)a"

        Create an instant of an inline processor.

        Arguments:
            pattern: A regular expression that matches a pattern.
            md: An optional pointer to the instance of `markdown.Markdown` and is available as
                `self.md` on the class instance.

        FN)r]rmrnrorprjÚ	safe_moderLrqs   rOrszInlineProcessor.__init__$
s;€ðˆŒÜŸ:™: g¬r¯y©y¼2¿:¹:Ñ/EÓFˆÔðˆŒØˆ�rQc
ó—y
)a™Return a ElementTree element from the given match and the
        start and end index of the matched text.

        If `start` and/or `end` are returned as `None`, it will be
        assumed that the processor did not find a valid region of text.

        Subclasses should override this method.

        Arguments:
            m: A re match object containing a match of the pattern.
            data: The buffer currently under analysis.

        Returns:
            el: The ElementTree element, text or None.
            start: The start of the region that has been matched or None.
            end: The end of the region that has been matched or None.

        Nrf©rrryÚdatas   rOrzzInlineProcessor.handleMatch5
s€ð&	
rQr•r–)ryr˜r¡r^r—z9tuple[etree.Element | str | None, int | None, int | None]©rarbrcrdrsrzrfrQrOrœrœ
s„ñôô"
rQrœc
ó—eZ
dZd
Zdd„Zy)ÚSimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. c
ó$—|
j
d
«
S)z< Return string content of `group(2)` of a matching pattern. é)
rƒrxs  rOrzzSimpleTextPattern.handleMatchM
s€à�w‰w�q‹zÐrQN©ryr˜r—r^©rarbrcrdrzrfrQrOr¤r¤K
s
„Ù<ôrQr¤c
ó—eZ
dZd
Zdd„Zy)rHz2 Return a simple text of `group(1)` of a Pattern. c
óf—|
j
d
«
|
jd«
|
jd«
fS)z< Return string content of `group(1)` of a matching pattern. rr)rƒÚstartÚendr s   rOrzz%SimpleTextInlineProcessor.handleMatchT
s'€à�w‰w�q‹z˜1Ÿ7™7 1›: q§u¡u¨Q£xÐ/Ð/rQN©ryr˜r¡r^r—ztuple[str, int, int]r¨rfrQrOrHrHR
s
„Ù<ô0rQrHc
ó—eZ
dZd
Zdd„Zy)r3z Return an escaped character. c
óL
—|
j
d
«
}||jjvrYdjtj
t
|«
tj«|
jd«
|
jd«
fSd|
jd«
|
jd«
fS)aµ

        If the character matched by `group(1)` of a pattern is in [`ESCAPED_CHARS`][markdown.Markdown.ESCAPED_CHARS]
        then return the integer representing the character's Unicode code point (as returned by [`ord`][]) wrapped
        in [`util.STX`][markdown.util.STX] and [`util.ETX`][markdown.util.ETX].

        If the matched character is not in [`ESCAPED_CHARS`][markdown.Markdown.ESCAPED_CHARS], then return `None`.
        rú{}{}{}rN)
rƒrLÚ
ESCAPED_CHARSÚformatrÚSTXÚordÚETXr«r¬)rrryr¡Úchars    rOrzz!EscapeInlineProcessor.handleMatch\
sw€ð�w‰w�q‹zˆØ�4—7‘7×(Ñ(Ñ(Ø—?‘?¤4§8¡8¬S°«Y¼¿¹ÓAÀ1Ç7Á7È1Ã:ÈqÏuÉuÐUVËxÐWÐWà˜Ÿ™ › Q§U¡U¨1£XÐ-Ð-rQN)ryr˜r¡r^r—ztuple[str | None, int, int]r¨rfrQrOr3r3Y
s
„Ù(ô
.rQr3c
ó —eZ
dZd
Zdd„Zdd„Zy)ÚSimpleTagPatternz]
    Return element of type `tag` with a text attribute of `group(3)`
    of a Pattern.

    c
ó>—tj||
«
||_y
)zµ
        Create an instant of an simple tag pattern.

        Arguments:
            pattern: A regular expression that matches a pattern.
            tag: Tag of element.

        N)rhrsÚtag©rrr]rºs   rOrszSimpleTagPattern.__init__r
s€ô	×ј˜wÔ'؈ŒØ0rQc
óp—t
j|j«
}|
jd
«
|_|S)z¤
        Return [`Element`][xml.etree.ElementTree.Element] of type `tag` with the string in `group(3)` of a
        matching pattern as the Element's text.
        é)ÚetreeÚElementrºrƒr“)rrryÚels   rOrzzSimpleTagPattern.handleMatch
s*€ô
�]‰]˜4Ÿ8™8Ó
$ˆØ—'‘'˜!“*ˆŒØˆ	rQN©r]r^rºr^©ryr˜r—ú
etree.Elementr¢rfrQrOr¸r¸l
s„ñó
1ôrQr¸c
ó —eZ
dZd
Zdd„Zdd„Zy)ÚSimpleTagInlineProcessorz]
    Return element of type `tag` with a text attribute of `group(2)`
    of a Pattern.

    c
ó>—tj||
«
||_y
)z·
        Create an instant of an simple tag processor.

        Arguments:
            pattern: A regular expression that matches a pattern.
            tag: Tag of element.

        N)rœrsrºr»s   rOrsz!SimpleTagInlineProcessor.__init__�
s€ô	× Ñ   wÔ/؈ŒØ0rQc
ó²—t
j|j«
}|
jd
«
|_||
jd«
|
j
d«
fS)z¤
        Return [`Element`][xml.etree.ElementTree.Element] of type `tag` with the string in `group(2)` of a
        matching pattern as the Element's text.
        r¦r)r¾r¿rºrƒr“r«r¬©rrryr¡rÀs    rOrzz$SimpleTagInlineProcessor.handleMatchœ
sB€ô
�]‰]˜4Ÿ8™8Ó
$ˆØ—'‘'˜!“*ˆŒØ�1—7‘7˜1“:˜qŸu™u Q›xÐ'Ð'rQNrÁ©ryr˜r¡r^r—ztuple[etree.Element, int, int]r¢rfrQrOrÅrʼn
s„ñó
1ô(rQrÅc
ó—eZ
dZd
Zdd„Zy)ÚSubstituteTagPatternú3 Return an element of type `tag` with no children. c
ó@—t
j|j«
S)
úH Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )r¾r¿rºrxs  rOrzz SubstituteTagPattern.handleMatch¨
s€ä�}‰}˜TŸX™XÓ&Ð&rQNrÂr¨rfrQrOrËr˦
s
„Ù=ô'rQrËc
ó—eZ
dZd
Zdd„Zy)rCrÌc
ó‚—t
j|j«
|
jd
«
|
j	d
«
fS)rÎr)r¾r¿rºr«r¬r s   rOrzz(SubstituteTagInlineProcessor.handleMatch¯
s,€ä�}‰}˜TŸX™XÓ&¨
¯©°
«
°A·E±E¸!³HÐ<Ð<rQNrÉr¨rfrQrOrCrC­
s
„Ù=ô=rQrCc
ó —eZ
dZd
Zdd„Zdd„Zy)r1zA Return a `<code>` element containing the escaped matching text. c
ó¸—tj||
«
d
jtjtd«
tj«|_d|_y)Nr°ú
\Úcode)	rœrsr²rr³r´rµÚESCAPED_BSLASHrº)rrr]s  rOrsz BacktickInlineProcessor.__init__¶
s=€Ü× Ñ   wÔ/Ø&Ÿo™o¬d¯h©h¼¸D»	Ä4Ç8Á8ÓLˆÔ؈ŒØ0rQc
óÔ
—|
j
d
«
rŒtj|j«
}t	j
t	j|
j
d
«
j««
«
|_||
jd«
|
jd«
fS|
j
d«
jd|j«|
jd«
|
jd«
fS)a€

        If the match contains `group(3)` of a pattern, then return a `code`
        [`Element`][xml.etree.ElementTree.Element] which contains HTML escaped text (with
        [`code_escape`][markdown.util.code_escape]) as an [`AtomicString`][markdown.util.AtomicString].

        If the match does not contain `group(3)` then return the text of `group(1)` backslash escaped.

        r½rrz\\)
rƒr¾r¿rºrÚAtomicStringÚcode_escapeÚstripr“r«r¬ÚreplacerÕrÈs    rOrzz#BacktickInlineProcessor.handleMatch¼
s©€ð
�7‰7�1Œ:Ü—‘˜tŸx™xÓ(ˆBÜ×'Ñ'¬×(8Ñ(8¸¿¹À»×9IÑ9IÓ9KÓ(LÓMˆBŒGØ�q—w‘w˜q“z 1§5¡5¨£8Ð+Ð+à—7‘7˜1“:×%Ñ% f¨d×.AÑ.AÓBÀAÇGÁGÈAÃJÐPQ×PUÑPUÐVWÓPXÐXÐXrQN)r]r^)ryr˜r¡r^r—z$tuple[etree.Element | str, int, int]r¢rfrQrOr1r1´
s„ÙKó1ôY
rQr1c
ó—eZ
dZd
Zdd„Zy)ÚDoubleTagPatternúfReturn a ElementTree element nested in tag2 nested in tag1.

    Useful for strong emphasis etc.

    c
ó(
—|jjd
«
\}}tj|«
}tj||«}|
jd«
|_t|
j««
dk(r|
jd«
|_	|S)z¬
        Return [`Element`][xml.etree.ElementTree.Element] in following format:
        `<tag1><tag2>group(3)</tag2>group(4)</tag2>` where `group(4)` is optional.

        ú
,r½éé)
rºÚsplitr¾r¿Ú
SubElementrƒr“ÚlenÚgroupsÚtail)rrryÚtag1Útag2Úel1Úel2s      rOrzzDoubleTagPattern.handleMatchÓ
so€ð—X‘X—^‘^ CÓ(‰
ˆˆdÜ�m‰m˜DÓ!ˆÜ×јs DÓ)ˆØ—7‘7˜1“:ˆŒÜˆq�x‰x‹z‹?˜aÒØ—w‘w˜q“zˆCŒH؈
rQNrÂr¨rfrQrOrÜrÜÍ
s„ñô
rQrÜc
ó—eZ
dZd
Zdd„Zy)ÚDoubleTagInlineProcessorrÝc
ój
—|jjd
«
\}}tj|«
}tj||«}|
jd«
|_t|
j««
dk(r|
jd«
|_	||
jd«
|
jd«
fS)z¬
        Return [`Element`][xml.etree.ElementTree.Element] in following format:
        `<tag1><tag2>group(2)</tag2>group(3)</tag2>` where `group(3)` is optional.

        rßr¦r½r)rºrâr¾r¿rãrƒr“rärårær«r¬)rrryr¡rçrèrérês       rOrzz$DoubleTagInlineProcessor.handleMatchè
s‡€ð—X‘X—^‘^ CÓ(‰
ˆˆdÜ�m‰m˜DÓ!ˆÜ×јs DÓ)ˆØ—7‘7˜1“:ˆŒÜˆq�x‰x‹z‹?˜aÒØ—w‘w˜q“zˆCŒHØ�A—G‘G˜A“J 
§¡ a£Ð(Ð(rQNrÉr¨rfrQrOrìrìâ
s„ñô
)rQrìc
ó(—eZ
dZd
Zdd„Zdd„Zdd„Zy)rEz1 Store raw inline html and return a placeholder. c
óð—|j
|j|
jd
«
«
«
}|jjj|«
}||
j
d«
|
jd«
fS)zL Store the text of `group(1)` of a pattern and return a placeholder string. rr)Úbackslash_unescaper”rƒrLÚ	htmlStashÚstorer«r¬)rrryr¡ÚrawhtmlÚplace_holders     rOrzzHtmlInlineProcessor.handleMatchù
sZ€à×)Ñ)¨$¯-©-¸
¿¹À
»
Ó*CÓDˆØ—w‘w×(Ñ(×.Ñ.¨wÓ7ˆؘQŸW™W Q›Z¨¯©¨q«Ð1Ð1rQc
󾇇—	‰jjd
jŠdˆˆfd„}tj
j
||
«S#t$r
|
cYSwxYw
)rr€c

óÌ•—|j
d
«
}
‰j|
«
}|�+	‰j‰jj	|«
«
Sy#t
$r
d|zcYSwxYw
)Nrz\%s)rƒr„r”rLÚ
serializerÚ	Exception)ryrˆr‰rrrŠs   €€rOr‹z/HtmlInlineProcessor.unescape.<locals>.get_stashsfø€Ø—‘˜“ˆBØ—I‘I˜b“MˆEØÐ ð*àŸ=™=¨¯©×);Ñ);¸EÓ)BÓCÐCð!øô!ò
*Ø! E™>Ò)ð
*ús§)AÁA#Á"
A#r§rŒr’s`  @rOr”zHtmlInlineProcessor.unescapeÿ
sXù€ð	Ø—G‘G×*Ñ*¨8Ñ4×BÑBˆEö	*ô×)Ñ)×-Ñ-¨i¸Ó>Ð>øôò
	ØŠKð
	ús„#AÁAÁ
Ac
ó˜—	|jjd
j}dd„}|j	||
«S#t$r
|
cYSwxYw
)zG Return text with backslash escapes undone (backslashes are restored). r”c

óH—t
t|jd
«
«
«
S)Nr)ÚchrÚintrƒ)
rys
 rOÚ	_unescapez9HtmlInlineProcessor.backslash_unescape.<locals>._unescapes€Ü”s˜1Ÿ7™7 1›:“Ó'Ð'rQr§)rLr�ÚREr�r‘)rrr“rþrýs    rOrðz&HtmlInlineProcessor.backslash_unescapesO€ð	Ø—‘×'Ñ'¨
Ñ3×6Ñ6ˆBó
	(ð�v‰v�i Ó&Ð&øô
ò
	ØŠKð
	ús‚#;»A	Á
A	Nr­r™)rarbrcrdrzr”rðrfrQrOrErE÷
s„Ù;ó2ó?ô&
'rQrEc
óD—eZ
dZd
Zeejeejejz«dd«eeje
ejejz«dd«eejeejejz«dd«eejeejejz«dd«eeje
ejejz«dd«gZ	dd	„Zdd
„Zdd„Z										dd„Zdd
„Zdd„Zy)rJzGEmphasis processor for handling strong and em matches inside asterisks.Údoubleú	strong,emú	em,strongÚdouble2ÚsingleÚstrongÚemc
óz—t
j|«
}|
jd
«
}|j||d|«
|S)zReturn single tag.r¦N)r¾r¿rƒÚparse_sub_patterns)rrryrºÚidxrér“s      rOÚbuild_singlezAsteriskProcessor.build_single+s6€ä�m‰m˜CÓ ˆØ�w‰w�q‹zˆØ×Ñ  c¨4°Ô5؈
rQc
óp
—|j
d
«
\}}tj|«
}tj|«
}|
jd«
}|j	||d|«
|j|«

t
|
j««
dk(r%|
jd«
}|j	||||«
|S)zReturn double tag.rßr¦Nr½)râr¾r¿rƒr
Úappendrärå©	rrryr`r	
rçrèrérêr“s	         rOÚbuild_doublezAsteriskProcessor.build_double2s•€ð—Z‘Z “_‰
ˆˆdÜ�m‰m˜DÓ!ˆÜ�m‰m˜DÓ!ˆØ�w‰w�q‹zˆØ×Ñ  c¨4°Ô5Ø�
‰
�3ŒÜˆq�x‰x‹z‹?˜aÒØ—7‘7˜1“:ˆDØ×#Ñ# D¨#¨s°CÔ8؈
rQc
ó8
—|j
d
«
\}}tj|«
}tj|«
}|
jd«
}|j	||d|«
|
jd«
}|j|«

|j	||d|«
|S)zFReturn double tags (variant 2): `<strong>text <em>text</em></strong>`.rßr¦Nr½)râr¾r¿rƒr
r
r

s	         rOÚ
build_double2zAsteriskProcessor.build_double2@sƒ€ð—Z‘Z “_‰
ˆˆdÜ�m‰m˜DÓ!ˆÜ�m‰m˜DÓ!ˆØ�w‰w�q‹zˆØ×Ñ  c¨4°Ô5Ø�w‰w�q‹zˆØ�
‰
�3ŒØ×Ñ  c¨4°Ô5؈
rQc
ó2—d
}d
}t
|
«
}||krê|jj|
|«rÃd}t|j«
D]¡\}	}
|	|kr
Œ|
j
j|
|«}|s
Œ+|
||j
d
«
}|r|�||_n||_|j||
j|
j|	«}
|j|
«

|
}|jd
«
x
}}d}Σ|s|dz
}n|dz
}||kr
ΐ|
|d}|r|�||_y||_yy)a/

        Parses sub patterns.

        `data`: text to evaluate.

        `parent`: Parent to attach text and sub elements to.

        `last`: Last appended child to parent. Can also be None if parent has no children.

        `idx`: Current pattern index that was used to evaluate the parent.
        rFNTr)rärjÚmatchÚ	enumerateÚPATTERNSr]r«rær“Ú
build_elementr_r`r
r¬)rrr¡ÚparentÚlastr	
ÚoffsetÚposÚlengthÚmatchedÚindexÚitemryr“rÀs              rOr
z$AsteriskProcessor.parse_sub_patternsMs8
€ðˆØˆä�T“ˆØ�FŠlà×Ñ×%Ñ% d¨CÔ0Ø�ä#,¨T¯]©]Ó#;ò'‘K�E˜4à ’|Ø ØŸ™×*Ñ*¨4°Ó5�AÚð
 $ F¨1¯7©7°1«:Ð6˜ÙØ#Ð/Ø,0 ¥	à.2 ¤Ø!×/Ñ/°
°4·<±<ÀÇÁÈEÓR˜ØŸ
™
 bÔ)Ø!˜à'(§u¡u¨Q£xÐ/˜ Ø"&™ð+'ñ,à˜1‘H‘Cð�q‘�ðA
�F‹lðF
�F�Gˆ}ˆÙØÐØ �•	à"�•ð	rQc
óˆ—|d
k(r|j
|
||«S|dk(r|j|
||«S|j|
||«S)zElement builder.r
r
)r
r
r

)rrryr_r`r
s     rOr
zAsteriskProcessor.build_elementŠsS€ð�iÒØ×%Ñ% a¨¨uÓ5Ð5Ø
˜Ò
 Ø×$Ñ$ Q¨¨eÓ4Ð4à×$Ñ$ Q¨¨eÓ4Ð4rQc
óD
—d
}d
}d
}t
|j«
D]~\}}|jj||
j	d«
«}|s
Œ4|j	d«
}|jd«
}|j
||j|j|«}
n
|||fS)zParse patterns.Nr)	r
r
r]r
r«r¬r
r_r`)	rrryr¡rÀr«r¬r
r
Úm1s	         rOrzzAsteriskProcessor.handleMatch”s™€ðˆØˆØˆä$ T§]¡]Ó3ò	‰KˆE�4Ø—‘×#Ñ# D¨!¯'©'°!«*Ó5ˆBÚØŸ™ ›�Ø—f‘f˜Q“i�Ø×'Ñ'¨¨D¯L©L¸$¿)¹)ÀUÓK�Ùð
	ð�5˜#ˆ~ÐrQN)ryr˜rºr^r	
rür—rÃ)ryr˜r`r^r	
rür—rÃ)
r¡r^r
rÃr
zetree.Element | Noner	
rür—ÚNone)
ryr˜r_r^r`r^r
rür—réryr˜r¡r^r—z3tuple[etree.Element | None, int | None, int | None])rarbrcrdr[rmrnÚEM_STRONG_RErorpÚSTRONG_EM_REÚ
STRONG_EM3_REÚ	STRONG_REÚEMPHASIS_REr
r

r
r
r
r
rzrfrQrOrJrJs
„ÙQñ	�Z�R—Z‘Z ¨b¯i©i¸"¿*¹*Ñ.DÓEÀxÐQ\Ó]Ù�Z�R—Z‘Z ¨b¯i©i¸"¿*¹*Ñ.DÓEÀxÐQ\Ó]Ù�Z�R—Z‘Z 
¨r¯y©y¸2¿:¹:Ñ/EÓFÈ	ÐS^Ó_Ù�Z�R—Z‘Z 	¨2¯9©9°r·z±zÑ+AÓBÀHÈhÓWÙ�Z�R—Z‘Z ¨R¯Y©Y¸¿¹Ñ-CÓDÀhÐPTÓUð€HðP
óóóð;#Øð;#Ø!.ð;#Ø6Jð;#ØQTð;#à	
ó;#óz
5ôrQrJc
óþ
—eZ
dZd
Zeejeejejz«dd«eeje
ejejz«dd«eejeejejz«dd«eejeejejz«dd«eeje
ejejz«dd«gZy	)
rKzIEmphasis processor for handling strong and em matches inside underscores.r
r

r
r
r
r
r
N)rarbrcrdr[rmrnÚ
EM_STRONG2_RErorpÚ
STRONG_EM2_REÚSMART_STRONG_EM_REÚSMART_STRONG_REÚSMART_EMPHASIS_REr
rfrQrOrKrK¥sÙ„ÙSñ	�Z�R—Z‘Z 
¨r¯y©y¸2¿:¹:Ñ/EÓFÈÐR]Ó^Ù�Z�R—Z‘Z 
¨r¯y©y¸2¿:¹:Ñ/EÓFÈÐR]Ó^Ù�Z�R—Z‘ZÐ 2°B·I±IÀÇ
Á
Ñ4JÓKÈYÐXcÓdÙ�Z�R—Z‘Z °·±¸R¿Z¹ZÑ1GÓHÈ(ÐT\Ó]Ù�Z�R—Z‘ZÐ 1°2·9±9¸r¿z¹zÑ3IÓJÈHÐVZÓ[ð€HðP
rQrKc
ó —eZ
dZd
Zej
dejejz«Zej
d«
Z	dd„Z
d	d„Zd
d„Zy)r7z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\sc
ó2
—|j
||
jd
«
«\}}}|s
y|j||«\}}}}|s
ytjd«
}||_|j
d|«
|�|j
d|«
||
jd
«
|fS)zS Return an `a` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. r©NNNÚ
aÚhrefÚtitle)ÚgetTextr¬ÚgetLinkr¾r¿r“Úsetr«)	rrryr¡r“r
Úhandledr2
r3
rÀs	         rOrzzLinkInlineProcessor.handleMatch·s’€à#Ÿ|™|¨D°!·%±%¸
³(Ó;шˆe�WáØ#à&*§l¡l°4¸Ó&?Ñ#ˆˆe�U˜GÙØ#ä
�]‰]˜3Ó
ˆØˆŒà
�‰ˆv�tÔàÐØ�F‰F�7˜EÔ"à�1—7‘7˜1“:˜uÐ$Ð$rQc	
ó¾—d
}d}d}|jj|
|¬«}|rm|jd«
r\|jd«
ddj«}|jd«
r|jd«
dd}|j	d«
}d	}�
nc|�
r`d}d}|j	«}	|	}d}
d}d}d}
d}d}d}d}d
}t|t
|
«
«D�
]}|
|}|d
k(r|s|dz