o „¿ÑgÞ“ã@s®dZddlmZddlmZddlmZmZmZm Z ddl Z ddlmm ZzddlmZWn ey<ddlZYnwerEddlmZdZdd„ZdZ dZ dZ dZ dZ dZ dZ dZ dZ dZ dZ dZ dZ! edZ" dZ# e"Z$ e#Z% d Z& d!Z' d"Z( d#Z) d$Z* d%Z+ d[d(d)„Z,Gd*d+„d+e ƒZ-Gd,d-„d-ƒZ.Gd.d/„d/e.ƒZ/Gd0d1„d1e.ƒZ0Gd2d3„d3e/ƒZ1Gd4d5„d5e/ƒZ2Gd6d7„d7e.ƒZ3Gd8d9„d9e/ƒZ4Gd:d;„d;e3ƒZ5Gdd?„d?e/ƒZ7Gd@dA„dAe3ƒZ8GdBdC„dCe4ƒZ9GdDdE„dEe/ƒZ:GdFdG„dGe/ƒZ;GdHdI„dIe;ƒZGdNdO„dOe=ƒZ?GdPdQ„dQe?ƒZ@GdRdS„dSe?ƒZAGdTdU„dUeAƒZBGdVdW„dWe/ƒZCGdXdY„dYe/ƒZDdS)\aB 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)ÚMarkdownÚmdr ÚkwargsrÚreturnúutil.Registry[InlineProcessor]cKsDt ¡}| ttƒdd¡| tt|ƒdd¡| tt|ƒdd¡| t t |ƒdd¡| tt|ƒd d ¡| t t|ƒdd¡| tt|ƒd d¡| tt|ƒdd¡| tt|ƒdd¡| tt|ƒdd¡| ttdƒdd¡| tt|ƒdd¡| tt|ƒdd¡| ttƒdd¡| tdƒdd ¡| td!ƒ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 `` 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)rrÚinlinePatterns©rOúW/var/www/html/bloggers_ems/venv/lib/python3.10/site-packages/markdown/inlinepatterns.pyÚbuild_inlinepatterns8s0ÿÿÿrQz(?]*)>z<([^<> !]+@[^@<> ]+)>z;(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!).)*--)>)z-(&(?:\#[0-9]+|\#x[0-9a-fA-F]+|[a-zA-Z0-9]+);)z \nÚstringÚstrcCs8| d¡r | d¡s| d¡r| d¡r|dd…S|S)z#Remove quotes from around a string.ú"ú'réÿÿÿÿ)Ú startswithÚendswith)rRrOrOrPÚdequote®sÿÿrYc@s*eZdZUdZded<ded<ded<dS)ÚEmStrongItemzEmphasis/strong pattern item.zre.Pattern[str]ÚpatternrSÚbuilderÚtagsN)Ú__name__Ú __module__Ú__qualname__Ú__doc__Ú__annotations__rOrOrOrPrZ·s rZc@sVeZdZUdZeƒZded< ddd d „Zdd d„Zddd„Z ddd„Z ddd„ZdS)Ú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_EXCLUDESNr[rSrúMarkdown | NonecCs*||_t d|tjtjB¡|_||_dS)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ÚUNICODEÚcompiled_rer©Úselfr[rrOrOrPÚ__init__Üs ÿ zPattern.__init__r ú re.PatterncCs|jS)z' Return a compiled regular expression. )rj©rlrOrOrPÚgetCompiledRegExpíszPattern.getCompiledRegExpÚmú re.Match[str]úetree.Element | strcCódS)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. NrO©rlrqrOrOrPÚhandleMatchñszPattern.handleMatchcCs|jjS)z+ Return class name, to define pattern type )Ú __class__r^rorOrOrPÚtypeþszPattern.typeÚtextcsDz |jjdj‰Wnty|YSw‡fdd„}tj ||¡S)ú> Return unescaped text given text with an inline placeholder. Úinlinecs<| d¡}|ˆvrˆ |¡}t|tƒr|Sd | ¡¡SdS)NrÚ)ÚgroupÚgetÚ isinstancerSÚjoinÚitertext©rqÚidÚvalue©ÚstashrOrPÚ get_stash s úz#Pattern.unescape..get_stash©rÚtreeprocessorsÚ stashed_nodesÚKeyErrorrÚINLINE_PLACEHOLDER_REÚsub©rlryr‡rOr…rPÚunescapesÿ zPattern.unescape©N©r[rSrre)r rn)rqrrr rs)r rS)ryrSr rS)r^r_r`raÚtuplerdrbrmrprvrxrrOrOrOrPrcÂs rcc@s&eZdZdZdddd„Zddd„ZdS)ÚInlineProcessorz¡ Base class that inline processors subclass. This is the newer style inline processor that uses a more efficient and flexible search approach. Nr[rSrrecCs,||_t |tjtjB¡|_d|_||_dS)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[rfrgrhrirjÚ safe_moderrkrOrOrPrms zInlineProcessor.__init__rqrrÚdatar ú9tuple[etree.Element | str | None, int | None, int | None]cCrt)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. NrO©rlrqr•rOrOrPrv/szInlineProcessor.handleMatchrr‘)rqrrr•rSr r–©r^r_r`rarmrvrOrOrOrPr“sr“c@óeZdZdZd dd„ZdS) ÚSimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. rqrrr rScCs | d¡S)z< Return string content of `group(2)` of a matching pattern. é)r}rurOrOrPrvGs zSimpleTextPattern.handleMatchN)rqrrr rS©r^r_r`rarvrOrOrOrPršEóršc@óeZdZdZddd „Zd S)rJz2 Return a simple text of `group(1)` of a Pattern. rqrrr•rSr útuple[str, int, int]cCs| d¡| d¡| d¡fS)z< Return string content of `group(1)` of a matching pattern. rr)r}ÚstartÚendr—rOrOrPrvNsz%SimpleTextInlineProcessor.handleMatchN©rqrrr•rSr rŸrœrOrOrOrPrJLrrJc@rž)r5z Return an escaped character. rqrrr•rSr útuple[str | None, int, int]cCsT| d¡}||jjvrd tjt|ƒtj¡| d¡| d¡fSd| d¡| d¡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}rÚ ESCAPED_CHARSÚformatrÚSTXÚordÚETXr r¡)rlrqr•ÚcharrOrOrPrvVs (z!EscapeInlineProcessor.handleMatchN)rqrrr•rSr r£rœrOrOrOrPr5Sór5c@s$eZdZdZddd„Zddd„Zd S)ÚSimpleTagPatternz] Return element of type `tag` with a text attribute of `group(3)` of a Pattern. r[rSÚtagcCót ||¡||_dS)zµ Create an instant of an simple tag pattern. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rcrmr©rlr[rrOrOrPrmló zSimpleTagPattern.__init__rqrrr ú etree.ElementcCst |j¡}| d¡|_|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ÚElementrr}ry)rlrqÚelrOrOrPrvyszSimpleTagPattern.handleMatchN©r[rSrrS©rqrrr r±r˜rOrOrOrPr¬fó r¬c@s$eZdZdZddd„Zddd „ZdS)ÚSimpleTagInlineProcessorz] Return element of type `tag` with a text attribute of `group(2)` of a Pattern. r[rSrcCr®)z· Create an instant of an simple tag processor. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)r“rmrr¯rOrOrPrm‰r°z!SimpleTagInlineProcessor.__init__rqrrr•r útuple[etree.Element, int, int]cCs.t |j¡}| d¡|_|| d¡| 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´rr}ryr r¡©rlrqr•rµrOrOrPrv–sz$SimpleTagInlineProcessor.handleMatchNr¶©rqrrr•rSr rºr˜rOrOrOrPr¹ƒr¸r¹c@r™) ÚSubstituteTagPatternú3 Return an element of type `tag` with no children. rqrrr r±cCst |j¡S)úH Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )r³r´rrurOrOrPrv¢sz SubstituteTagPattern.handleMatchNr·rœrOrOrOrPr½ rr½c@rž)rEr¾rqrrr•rSr rºcCst |j¡| d¡| d¡fS)r¿r)r³r´rr r¡r—rOrOrPrv©sz(SubstituteTagInlineProcessor.handleMatchNr¼rœrOrOrOrPrE§rrEc@s"eZdZdZdd„Zd d d„ZdS)r3zA Return a `

` element containing the escaped matching text. cCs.t ||¡d tjtdƒtj¡|_d|_dS)Nr¤ú\Úcode)	r“rmr¦rr§r¨r©ÚESCAPED_BSLASHr)rlr[rOrOrPrm°sz BacktickInlineProcessor.__init__rqrrr•rSr
ú$tuple[etree.Element | str, int, int]cCsn| d¡r$t |j¡}t t | d¡ ¡¡¡|_|| 	d¡| 
d¡fS| d¡ d|j¡| 	d¡| 
d¡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´rrÚAtomicStringÚcode_escapeÚstripryr r¡ÚreplacerÂr»rOrOrPrv¶s

	&z#BacktickInlineProcessor.handleMatchN)rqrrr•rSr
rÃr˜rOrOrOrPr3®sr3c@r™)
ÚDoubleTagPatternúfReturn a ElementTree element nested in tag2 nested in tag1.

    Useful for strong emphasis etc.

    rqrrr
r±cCsR|j d¡\}}t |¡}t ||¡}| d¡|_t| ¡ƒdkr'| d¡|_	|S)z¬
        Return [`Element`][xml.etree.ElementTree.Element] in following format:
        `group(3)group(4)` where `group(4)` is optional.

        ú,r²éé)
rÚsplitr³r´Ú
SubElementr}ryÚlenÚgroupsÚtail)rlrqÚtag1Útag2Úel1Úel2rOrOrPrvÍs
zDoubleTagPattern.handleMatchNr·rœrOrOrOrPrÈÇórÈc@rž)ÚDoubleTagInlineProcessorrÉrqrrr•rSr
rºcCsd|j d¡\}}t |¡}t ||¡}| d¡|_t| ¡ƒdkr'| d¡|_	|| 
d¡| d¡fS)z¬
        Return [`Element`][xml.etree.ElementTree.Element] in following format:
        `group(2)group(3)` where `group(3)` is optional.

        rÊr›r²r)rrÍr³r´rÎr}ryrÏrÐrÑr r¡)rlrqr•rÒrÓrÔrÕrOrOrPrvâs
z$DoubleTagInlineProcessor.handleMatchNr¼rœrOrOrOrPr×ÜrÖr×c@s*eZdZdZddd	„Zd
d„Zdd
„ZdS)rGz1 Store raw inline html and return a placeholder. rqrrr•rSr
rŸcCs:| | | d¡¡¡}|jj |¡}|| d¡| d¡fS)zL Store the text of `group(1)` of a pattern and return a placeholder string. rr)Úbackslash_unescaperr}rÚ	htmlStashÚstorer r¡)rlrqr•ÚrawhtmlÚplace_holderrOrOrPrvószHtmlInlineProcessor.handleMatchcsFz	ˆjjdj‰Wnty|YSw‡‡fdd„}tj ||¡S)rzr{csJ| d¡}ˆ |¡}|dur#zˆj |¡WSty"d|YSwdS)Nrz\%s)r}r~rÚ
serializerÚ	Exceptionr‚©rlr†rOrPr‡s

ÿýz/HtmlInlineProcessor.unescape..get_stashrˆrŽrOrßrPrùsÿ	zHtmlInlineProcessor.unescapecCs>z	|jjdj}Wnty|YSwdd„}| ||¡S)zG Return text with backslash escapes undone (backslashes are restored). rcSstt| d¡ƒƒS)Nr)ÚchrÚintr})rqrOrOrPÚ	_unescapesz9HtmlInlineProcessor.backslash_unescape.._unescape)rr‰ÚREr‹r)rlryrãrârOrOrPrØsÿz&HtmlInlineProcessor.backslash_unescapeNr¢)r^r_r`rarvrrØrOrOrOrPrGñs

rGc
@sÌeZdZdZee eejej	B¡ddƒee e
ejej	B¡ddƒee eejej	B¡ddƒee eejej	B¡ddƒee e
ejej	B¡ddƒgZ	d	d
„Zdd„Zd
d„Zddd„Zdd„Zddd„ZdS)rLzGEmphasis processor for handling strong and em matches inside asterisks.Údoubleú	strong,emú	em,strongÚdouble2ÚsingleÚstrongÚemcCs(t |¡}| d¡}| ||d|¡|S)zReturn single tag.r›N)r³r´r}Úparse_sub_patterns)rlrqrÚidxrÔryrOrOrPÚbuild_single$s

zAsteriskProcessor.build_singlec	Cst| d¡\}}t |¡}t |¡}| d¡}| ||d|¡| |¡t| ¡ƒdkr8| d¡}| ||||¡|S)zReturn double tag.rÊr›Nr²)rÍr³r´r}rëÚappendrÏrÐ©	rlrqr]rìrÒrÓrÔrÕryrOrOrPÚbuild_double+s




zAsteriskProcessor.build_doublec	Csd| d¡\}}t |¡}t |¡}| d¡}| ||d|¡| d¡}| |¡| ||d|¡|S)zFReturn double tags (variant 2): `text text`.rÊr›Nr²)rÍr³r´r}rërîrïrOrOrPÚ
build_double29s




zAsteriskProcessor.build_double2r
ÚNonecCsd}d}t|ƒ}||krl|j ||¡rdd}t|jƒD]B\}	}
|	|kr#q|
j ||¡}|r\||| d¡…}|rB|dur?||_n||_| 	||
j
|
j|	¡}
| |
¡|
}| 
d¡}}d}q|sc|d7}n|d7}||ks||d…}|r‚|dur}||_dS||_dSdS)a”
        Parses sub patterns.

        `data` (`str`):
            text to evaluate.

        `parent` (`etree.Element`):
            Parent to attach text and sub elements to.

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

        `idx` (`int`):
            Current pattern index that was used to evaluate the parent.

        rFNTr)rÏrjÚmatchÚ	enumerateÚPATTERNSr[r rÑryÚ
build_elementr\r]rîr¡)rlr•ÚparentÚlastrìÚoffsetÚposÚlengthÚmatchedÚindexÚitemrqryrµrOrOrPrëFsB
€€à#

üz$AsteriskProcessor.parse_sub_patternscCs:|dkr| |||¡S|dkr| |||¡S| |||¡S)zElement builder.rçrä)rñrðrí)rlrqr\r]rýrOrOrPrö†s
zAsteriskProcessor.build_elementrqrrr•rSú3tuple[etree.Element | None, int | None, int | None]c	Csnd}d}d}t|jƒD]&\}}|j || d¡¡}|r1| d¡}| d¡}| ||j|j|¡}nq|||fS)zParse patterns.Nr)	rôrõr[rór r¡rör\r])	rlrqr•rµr r¡rýrþÚm1rOrOrPrvs

ü
zAsteriskProcessor.handleMatchN)r
rò©rqrrr•rSr
rÿ)r^r_r`rarZrfrgÚEM_STRONG_RErhriÚSTRONG_EM_REÚ
STRONG_EM3_REÚ	STRONG_REÚEMPHASIS_RErõrírðrñrërörvrOrOrOrPrLsû

@
rLc
@s–eZdZdZee eejej	B¡ddƒee e
ejej	B¡ddƒee eejej	B¡ddƒee eejej	B¡ddƒee e
ejej	B¡ddƒgZd	S)
rMzIEmphasis processor for handling strong and em matches inside underscores.rärårærçrèrérêN)r^r_r`rarZrfrgÚ
EM_STRONG2_RErhriÚ
STRONG_EM2_REÚSMART_STRONG_EM_REÚSMART_STRONG_REÚSMART_EMPHASIS_RErõrOrOrOrPrM¡sûrMc@sHeZdZdZe dejejB¡Ze d¡Z	dd
d„Z
dd
„Zdd„ZdS)r9z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\srqrrr•rSr
rÿc	Cs|| || d¡¡\}}}|sdS| ||¡\}}}}|sdSt d¡}||_| d|¡|dur6| d|¡|| d¡|fS)zS Return an `a` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. r©NNNÚaÚhrefNÚtitle)ÚgetTextr¡ÚgetLinkr³r´ryÚsetr )	rlrqr•ryrýÚhandledrrrµrOrOrPrv³s
zLinkInlineProcessor.handleMatchcCsÐd}d}d}|jj||d}|r7| d¡r7| d¡dd… ¡}| d¡r.| d¡dd…}| d¡}d	}n|rHd}d}| ¡}	|	}d}
d}d}d}
d}d}d}d}d}t|t|ƒƒD]Ð}||}|d
krw|sn|d7}nk|dkrv|d8}nb|dkr¦|
dkrƒ||ks‹|dkrŽ||krŽd}nK|s•|d8}nD|dkr¥|d8}|dkr¥|d}
n3|dvrÙ|s¹d	}|}d}|d}|}n ||krÆ|sÆ|d}|}n||krÏ|d}
n
|rÙ||krÙ|d}|d7}|dkr&|
dkrþ||krþ||	|d…}d |||
d…¡}n&|dkr||kr||	|d…}d |||d…¡}n||	|d…}n|d
kr-|}q]|dkrD|dkrD||	|
d…}|
}d}|dk}|dur[|j 	d
t
| | ¡¡ƒ¡}| |¡ ¡}||||fS)z?Parse data between `()` of `[Text]()` allowing recursive `()`. r|NF©rúrrVr›rTú(ú))rUrTú )ÚRE_LINKrór}rÆr¡ÚrangerÏr€ÚRE_TITLE_CLEANrrYr)rlr•rýrrrrqÚ
bracket_countÚbacktrack_countÚstart_indexÚlast_bracketÚquoteÚstart_quoteÚ
exit_quoteÚignore_matchesÚ	alt_quoteÚstart_alt_quoteÚexit_alt_quoterørúÚcrOrOrPrÈsœ


€ 
€


€
zLinkInlineProcessor.getLinkcCsxd}g}t|t|ƒƒD]&}||}|dkr|d8}n|dkr"|d7}|d7}|dkr,n| |¡qd |¡||dkfS)zsParse the content between `[]` of the start of an image or link
        resolving nested square brackets.

        rú]ú[rr|)rrÏrîr€)rlr•rýrryrúr&rOrOrPr<s
zLinkInlineProcessor.getTextNr)
r^r_r`rarfrgrhrirrrvrrrOrOrOrPr9®s

tr9c@rž)r;z. Return a `img` element from the given match. rqrrr•rSr
rÿc	Csˆ| || d¡¡\}}}|sdS| ||¡\}}}}|sdSt d¡}| d|¡|dur3| d|¡| d| |¡¡|| d¡|fS)zU Return an `img` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. rrÚimgÚsrcNrÚalt)rr¡rr³r´rrr )	rlrqr•ryrýrr*rrµrOrOrPrvSs
z ImageInlineProcessor.handleMatchNrrœrOrOrOrPr;Pr«r;c@sNeZdZdZe dej¡Ze dejej	B¡Z
dd
d„Zdd
„Zddd„Z
dS)r7z6 Match to a stored reference and return link element. z\s+z\s?\[([^\]]*)\]rqrrr•rSr
rÿc
Cs| || d¡¡\}}}|sdS| |||¡\}}}|sdS|j d|¡}||jjvr3d| d¡|fS|jj|\}}	| ||	|¡| d¡|fS)zz
        Return [`Element`][xml.etree.ElementTree.Element] returned by `makeTag` method or `(None, None, None)`.

        rrrN)	rr¡ÚevalIdÚNEWLINE_CLEANUP_RErrÚ
referencesr ÚmakeTag)
rlrqr•ryrýrrƒr¡rrrOrOrPrvnsz$ReferenceInlineProcessor.handleMatchcCsL|jj||d}|sd|dfS| d¡ ¡}| d¡}|s!| ¡}||dfS)z\
        Evaluate the id portion of `[ref][id]`.

        If `[ref][]` use `[ref]`.
        rNFrrT)rrór}Úlowerr¡)rlr•rýryrqrƒr¡rOrOrPr,„s


zReferenceInlineProcessor.evalIdrrryr±cCs0t d¡}| d|¡|r| d|¡||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. r
rr)r³r´rry©rlrrryrµrOrOrPr/”s
z ReferenceInlineProcessor.makeTagNr©rrSrrSryrSr
r±)r^r_r`rarfrgÚ	MULTILINEr-rhrirrvr,r/rOrOrOrPr7hs
r7c@óeZdZdZdd„ZdS)r?z%Short form of reference: `[google]`. cCó| ¡|dfS©zEvaluate the id of `[ref]`.  T©r0©rlr•rýryrOrOrPr,¢óz$ShortReferenceInlineProcessor.evalIdN©r^r_r`rar,rOrOrOrPr? ór?c@rž)r=z7 Match to a stored reference and return `img` element. rrSrryr
r±cCs<t d¡}| d|¡|r| d|¡| d| |¡¡|S)z= Return an `img` [`Element`][xml.etree.ElementTree.Element]. r)r*rr+)r³r´rrr1rOrOrPr/ªs
z%ImageReferenceInlineProcessor.makeTagNr2)r^r_r`rar/rOrOrOrPr=¨rr=c@r4)r@z* Short form of image reference: `![ref]`. cCr5r6r7r8rOrOrPr,¶r9z)ShortImageReferenceInlineProcessor.evalIdNr:rOrOrOrPr@´r;r@c@rž)rAzD Return a link Element given an auto-link (``). rqrrr•rSr
rºcCsJt d¡}| d| | d¡¡¡t | d¡¡|_|| d¡| 	d¡fS)zI Return an `a` [`Element`][xml.etree.ElementTree.Element] of `group(1)`. r
rrr)
r³r´rrr}rrÄryr r¡r»rOrOrPrv¾s
z#AutolinkInlineProcessor.handleMatchNr¼rœrOrOrOrPrA¼rrAc@rž)rCzW
    Return a `mailto` link Element given an auto-mail link (``).
    rqrrr•rSr
rºcsžt d¡}| | d¡¡}| d¡r|tdƒd…}dd„‰‡fdd„|Dƒ}t d	 |¡¡|_	d|}d	 d
d„|Dƒ¡}| 
d|¡|| d¡| d¡fS)
za Return an [`Element`][xml.etree.ElementTree.Element] containing a `mailto` link  of `group(1)`. r
rzmailto:NcSs,tj |¡}|rd tj|¡Sdtj|fS)z=Return entity definition by code, or the code if not defined.z{}{};z%s#%d;)r	Úcodepoint2namer~r¦rÚAMP_SUBSTITUTE)rÁr(rOrOrPr<Ñsz;AutomailInlineProcessor.handleMatch..codepoint2namecsg|]}ˆt|ƒƒ‘qSrO)r¨©Ú.0Úletter©r<rOrPÚ
Ùsz7AutomailInlineProcessor.handleMatch..r|cSsg|]}tjdt|ƒ‘qS)z#%d;)rr=r¨r>rOrOrPrBÝs
ÿ
ÿrr)
r³r´rr}rWrÏrrÄr€ryrr r¡)rlrqr•rµÚemailÚlettersÚmailtorOrArPrvÊs


ÿz#AutomailInlineProcessor.handleMatchNr¼rœrOrOrOrPrCÆsrC)rr
rrr
r)rRrSr
rS)EraÚ
__future__rr|rÚtypingrrrrrfÚxml.etree.ElementTreer³ÚElementTreer&r	ÚImportErrorÚhtmlentitydefsÚmarkdownr
rQÚNOIMGr4r6rrr
rr	rrrrrr:r<r8r>rKrBrDrHrIrFrYrZrcr“ršrJr5r¬r¹r½rEr3rÈr×rGrLrMr9r;r7r?r=r@rArCrOrOrOrPÚs®ÿ
0
	S0'

#8