o ñ+óep•ã@sŽdZddlmZddlmZddlmZmZmZm Z ddl Z ddl m m Z ddlmZer5ddlmZdZdd„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,ƒZ.Gd2d3„d3e-ƒZ/Gd4d5„d5e-ƒZ0Gd6d7„d7e,ƒZ1Gd8d9„d9e-ƒZ2Gd:d;„d;e1ƒZ3Gdd?„d?e-ƒZ5Gd@dA„dAe1ƒZ6GdBdC„dCe2ƒZ7GdDdE„dEe-ƒZ8GdFdG„dGe-ƒZ9GdHdI„dIe9ƒZ:GdJdK„dKe-ƒZ;GdLdM„dMe;ƒZGdRdS„dSe=ƒZ?GdTdU„dUe?ƒZ@GdVdW„dWe-ƒZAGdXdY„dYe-ƒZBdS)\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¡| t t |ƒd d ¡| t t|ƒd d ¡| 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. Zbacktické¾Úescapeé´Z referenceéªÚlinké Z image_linké–Zimage_referenceéŒZshort_referenceé‚Zshort_image_refé}ZautolinkéxZautomailénÚbrZ linebreakédÚhtmléZÚentityéPZ not_strongéFz\*Z em_strongé<Ú_Z em_strong2é2)rZRegistryÚ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)r r ZinlinePatterns©rAú7lib/python3.10/site-packages/markdown/inlinepatterns.pyÚbuild_inlinepatterns5s0 ÿ ÿ ÿrCz(?]*)>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)rDrArArBÚdequote«sÿÿ rKc@s*eZdZUdZded<ded<ded<dS)Ú EmStrongItemzEmphasis/strong pattern item.úre.Pattern[str]ÚpatternrEÚbuilderÚtagsN)Ú__name__Ú __module__Ú __qualname__Ú__doc__Ú__annotations__rArArArBrL´s  rLc@sfeZdZUdZeƒZded< ded<ded<ddd d „Zddd„Zddd„Z ddd„Z d dd„Z dS)!Ú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_EXCLUDESrMÚ compiled_reúMarkdown | Noner NrNrEcCs*||_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)rNÚreÚcompileÚDOTALLÚUNICODErXr ©ÚselfrNr rArArBÚ__init__Üs   ÿ zPattern.__init__r ú re.PatterncCs|jS)z' Return a compiled regular expression. )rX©r_rArArBÚ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. NrA©r_rdrArArBÚ handleMatchñs zPattern.handleMatchcCs|jjS)z+ Return class name, to define pattern type )Ú __class__rQrbrArArBÚtypeþsz Pattern.typeÚtextcsDz |jjdj‰Wn ty|YSw‡fdd„}tj ||¡S)ú> Return unescaped text given text with an inline placeholder. Úinlinecs<| d¡}|ˆvrˆ |¡}t|tƒr|Sd | ¡¡SdS)NrÚ)ÚgroupÚgetÚ isinstancerEÚjoinZitertext©rdÚidÚvalue©ÚstashrArBÚ get_stash s   úz#Pattern.unescape..get_stash©r ÚtreeprocessorsZ stashed_nodesÚKeyErrorrZINLINE_PLACEHOLDER_REÚsub©r_rlryrArwrBÚunescapes ÿ  zPattern.unescape©N©rNrEr rY)r ra)rdrer rf)r rE©rlrEr rE) rQrRrSrTÚtuplerWrUr`rcrirkrrArArArBrV¿s     rVc@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. NrNrEr rYcCs,||_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)rNrZr[r\r]rXZ safe_moder r^rArArBr`s  zInlineProcessor.__init__rdreÚdatar ú9tuple[etree.Element | str | None, int | None, int | None]cCrg)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. NrA©r_rdr…rArArBri/szInlineProcessor.handleMatchr€r)rdrer…rEr r†©rQrRrSrTr`rirArArArBr„s r„c@óeZdZdZd dd„ZdS) ÚSimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. rdrer rEcCs | d¡S)z< Return string content of `group(2)` of a matching pattern. é)rprhrArArBriGs zSimpleTextPattern.handleMatchN©rdrer rE©rQrRrSrTrirArArArBrŠEórŠc@óeZdZdZd dd „Zd S) r=z2 Return a simple text of `group(1)` of a Pattern. rdrer…rEr útuple[str, int, int]cCs| d¡| d¡| d¡fS)z< Return string content of `group(1)` of a matching pattern. rr)rpÚstartÚendr‡rArArBriNsz%SimpleTextInlineProcessor.handleMatchN©rdrer…rEr rrrArArArBr=LrŽr=c@r) r(z Return an escaped character. rdrer…rEr ú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) rpr Z ESCAPED_CHARSÚformatrÚSTXÚordÚETXr‘r’)r_rdr…ÚcharrArArBriVs (z!EscapeInlineProcessor.handleMatchN)rdrer…rEr r”rrArArArBr(Sór(c@s$eZdZdZddd„Zdd d „Zd S)ÚSimpleTagPatternz] Return element of type `tag` with a text attribute of `group(3)` of a Pattern. rNrEÚ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)rVr`r©r_rNrrArArBr`ló zSimpleTagPattern.__init__rdrer ú 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ÚElementrrprl)r_rdÚelrArArBriys  zSimpleTagPattern.handleMatchN©rNrErrE©rdrer r¡rˆrArArArBrœfó  rœc@s$eZdZdZddd„Zdd d „ZdS)ÚSimpleTagInlineProcessorz] Return element of type `tag` with a text attribute of `group(2)` of a Pattern. rNrErcCrž)z· Create an instant of an simple tag processor. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)r„r`rrŸrArArBr`‰r z!SimpleTagInlineProcessor.__init__rdrer…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¤rrprlr‘r’©r_rdr…r¥rArArBri–s  z$SimpleTagInlineProcessor.handleMatchNr¦©rdrer…rEr rªrˆrArArArBr©ƒr¨r©c@r‰) ÚSubstituteTagPatternú3 Return an element of type `tag` with no children. rdrer r¡cCs t |j¡S)úH Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )r£r¤rrhrArArBri¢s z SubstituteTagPattern.handleMatchNr§rrArArArBr­ rŽr­c@r) r8r®rdrer…rEr rªcCst |j¡| d¡| d¡fS)r¯r)r£r¤rr‘r’r‡rArArBri©sz(SubstituteTagInlineProcessor.handleMatchNr¬rrArArArBr8§rŽr8c@s$eZdZdZddd„Zdd d „Zd S)r&zA Return a `` element containing the escaped matching text. rNrEcCs.t ||¡d tjtdƒtj¡|_d|_dS)Nr•ú\Úcode) r„r`r–rr—r˜r™ÚESCAPED_BSLASHr)r_rNrArArBr`°s z BacktickInlineProcessor.__init__rdrer…r ú$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\\) rpr£r¤rrÚ AtomicStringZ code_escapeÚstriprlr‘r’Úreplacer²r«rArArBri¶s &z#BacktickInlineProcessor.handleMatchN)rNrE)rdrer…rEr r³rˆrArArArBr&®s r&c@r‰) ÚDoubleTagPatternúfReturn a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. rdrer 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¤Ú SubElementrprlÚlenÚgroupsÚtail)r_rdÚtag1Útag2Úel1Úel2rArArBriÍs    zDoubleTagPattern.handleMatchNr§rrArArArBr·Çór·c@r) ÚDoubleTagInlineProcessorr¸rdrer…rEr 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½rprlr¾r¿rÀr‘r’)r_rdr…rÁrÂrÃrÄrArArBriâs    z$DoubleTagInlineProcessor.handleMatchNr¬rrArArArBrÆÜrÅrÆc@s.eZdZdZddd „Zdd d „Zdd d„ZdS)r:z1 Store raw inline html and return a placeholder. rdrer…rEr rcCs:| | | d¡¡¡}|jj |¡}|| d¡| d¡fS)zL Store the text of `group(1)` of a pattern and return a placeholder string. rr)Úbackslash_unescaperrpr Z htmlStashÚstorer‘r’)r_rdr…ZrawhtmlZ place_holderrArArBriószHtmlInlineProcessor.handleMatchrlcsHz ˆjjdj‰Wn ty|YSwd ‡‡fdd„ }tj ||¡S) rmrnrdrer rEcsJ| d¡}ˆ |¡}|dur#zˆj |¡WSty"d|YSwdS)Nrz\%s)rprqr Z serializerÚ Exceptionrt©r_rxrArBrys    ÿýz/HtmlInlineProcessor.unescape..get_stashNrŒrzr~rArÊrBrùs ÿ zHtmlInlineProcessor.unescapecCs@z |jjdj}Wn ty|YSwd dd„}| ||¡S) zG Return text with backslash escapes undone (backslashes are restored). rrdrer rEcSstt| d¡ƒƒS)Nr)ÚchrÚintrp)rdrArArBÚ _unescapesz9HtmlInlineProcessor.backslash_unescape.._unescapeNrŒ)r r{ÚREr|r})r_rlrÎrÍrArArBrÇ s ÿ  z&HtmlInlineProcessor.backslash_unescapeNr“r‚)rQrRrSrTrirrÇrArArArBr:ñs   r:c @sÔeZdZdZee eejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒgZ d'dd„Zd(dd„Zd(dd„Zd)dd„Zd*d!d"„Zd+d$d%„Zd&S),r?zGEmphasis processor for handling strong and em matches inside asterisks.Údoubleú strong,emú em,strongÚdouble2ÚsingleÚstrongÚemrdrerrEÚidxrÌr r¡cCs(t |¡}| d¡}| ||d|¡|S)zReturn single tag.r‹N)r£r¤rpÚparse_sub_patterns)r_rdrrÖrÃrlrArArBÚ build_single$s  zAsteriskProcessor.build_singlerPc Cst| d¡\}}t |¡}t |¡}| d¡}| ||d|¡| |¡t| ¡ƒdkr8| d¡}| ||||¡|S)zReturn double tag.r¹r‹Nr¢)r¼r£r¤rpr×Úappendr¾r¿© r_rdrPrÖrÁrÂrÃrÄrlrArArBÚ 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¤rpr×rÙrÚrArArBÚ build_double29s     zAsteriskProcessor.build_double2r…ÚparentÚlastúetree.Element | NoneÚ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`: 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¾rXÚmatchÚ enumerateÚPATTERNSrNr‘rÀrlÚ build_elementrOrPrÙr’)r_r…rÝrÞrÖÚoffsetÚposÚlengthZmatchedÚindexÚitemrdrlr¥rArArBr×FsB €€à #  üz$AsteriskProcessor.parse_sub_patternsrOrècCs:|dkr | |||¡S|dkr| |||¡S| |||¡S)zElement builder.rÒrÏ)rÜrÛrØ)r_rdrOrPrèrArArBräƒs zAsteriskProcessor.build_elementú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ãrNrár‘r’rärOrP) r_rdr…r¥r‘r’rèréZm1rArArBris  ü zAsteriskProcessor.handleMatchN)rdrerrErÖrÌr r¡)rdrerPrErÖrÌr r¡) r…rErÝr¡rÞrßrÖrÌr rà) rdrerOrErPrErèrÌr r¡©rdrer…rEr rê)rQrRrSrTrLrZr[Ú EM_STRONG_REr\r]Ú STRONG_EM_REÚ STRONG_EM3_REÚ STRONG_REÚ EMPHASIS_RErãrØrÛrÜr×rärirArArArBr?sû    = r?c @s–eZdZdZee eejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒgZd S) r@zIEmphasis processor for handling strong and em matches inside underscores.rÏrÐrÑrÒrÓrÔrÕN)rQrRrSrTrLrZr[Ú EM_STRONG2_REr\r]Ú STRONG_EM2_REÚSMART_STRONG_EM_REÚSMART_STRONG_REÚSMART_EMPHASIS_RErãrArArArBr@žsûr@c@sLeZdZdZe dejejB¡Ze d¡Z dd d „Z ddd„Z ddd„Z dS)r,z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\srdrer…rEr 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¤rlÚsetr‘) r_rdr…rlrèÚhandledrørùr¥rArArBri°s   zLinkInlineProcessor.handleMatchrèrÌú!tuple[str, str | None, int, bool]cCsÐ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|d kr¦| dkrƒ| |ks‹|dkrŽ||krŽd}nK|s•|d8}nD|dkr¥|d8}|dkr¥|d} n3|d vrÙ| 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 `()`. roNF©rærrHr‹rTú(ú))rGrFú ) ÚRE_LINKrárprµr’Úranger¾rsÚRE_TITLE_CLEANr}rKr)r_r…rèrørùrýrdÚ bracket_countZbacktrack_countÚ start_indexZ last_bracketÚquoteZ start_quoteZ exit_quoteZignore_matchesZ alt_quoteZstart_alt_quoteZexit_alt_quoterÞræÚcrArArBrûÅsœ   €  €     €  zLinkInlineProcessor.getLinkútuple[str, int, bool]cCsxd}g}t|t|ƒƒD]&}||}|dkr|d8}n|dkr"|d7}|d7}|dkr,n| |¡q d |¡||dkfS)zsParse the content between `[]` of the start of an image or link resolving nested square brackets. rú]ú[rro)rr¾rÙrs)r_r…rèrrlrær rArArBrú9s  zLinkInlineProcessor.getTextNrë)r…rErèrÌr rþ)r…rErèrÌr r ) rQrRrSrTrZr[r\r]rrrirûrúrArArArBr,«s   tr,c@r) r.z. Return a `img` element from the given match. rdrer…rEr 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)rúr’rûr£r¤rürr‘) r_rdr…rlrèrýrrùr¥rArArBriPs   z ImageInlineProcessor.handleMatchNrërrArArArBr.Mr›r.c@sPeZdZdZe dej¡Ze dejej B¡Z dd d „Z ddd„Z ddd„Z dS)r*z6 Match to a stored reference and return link element. z\s+z\s?\[([^\]]*)\]rdrer…rEr 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)`. rrörN) rúr’ÚevalIdÚNEWLINE_CLEANUP_REr}r Z referencesr‘ÚmakeTag) r_rdr…rlrèrýrur’rørùrArArBriks z$ReferenceInlineProcessor.handleMatchrèrÌrlútuple[str | None, int, bool]cCsL|jj||d}|sd|dfS| d¡ ¡}| d¡}|s!| ¡}||dfS)z\ Evaluate the id portion of `[ref][id]`. If `[ref][]` use `[ref]`. rÿNFrrT)rrárpÚlowerr’)r_r…rèrlrdrur’rArArBrs   zReferenceInlineProcessor.evalIdrørùr¡cCs0t d¡}| d|¡|r| d|¡||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. r÷rørù)r£r¤rürl©r_rørùrlr¥rArArBr‘s   z ReferenceInlineProcessor.makeTagNrë)r…rErèrÌrlrEr r©rørErùrErlrEr r¡)rQrRrSrTrZr[Ú MULTILINErr\r]rrirrrArArArBr*es  r*c@óeZdZdZd d d „Zd S) r2z%Short form of reference: `[google]`. r…rErèrÌrlr r cCó| ¡|dfS©zEvaluate the id of `[ref]`. T©r©r_r…rèrlrArArBrŸóz$ShortReferenceInlineProcessor.evalIdN©r…rErèrÌrlrEr r ©rQrRrSrTrrArArArBr2rŽr2c@r) r0z7 Match to a stored reference and return `img` element. rørErùrlr r¡cCs<t d¡}| d|¡|r| d|¡| d| |¡¡|S)z= Return an `img` [`Element`][xml.etree.ElementTree.Element]. r rrùr)r£r¤rürrrArArBr§s   z%ImageReferenceInlineProcessor.makeTagNr)rQrRrSrTrrArArArBr0¥rŽr0c@r) r3z* Short form of image reference: `![ref]`. r…rErèrÌrlr r cCrrrrrArArBr³rz)ShortImageReferenceInlineProcessor.evalIdNrrrArArArBr3±rŽr3c@r) r4zD Return a link Element given an auto-link (``). rdrer…rEr rªcCsJt d¡}| d| | d¡¡¡t | d¡¡|_|| d¡|  d¡fS)zI Return an `a` [`Element`][xml.etree.ElementTree.Element] of `group(1)`. r÷rørr) r£r¤rürrprr´rlr‘r’r«rArArBri»s z#AutolinkInlineProcessor.handleMatchNr¬rrArArArBr4¹rŽr4c@r) r6zW Return a `mailto` link Element given an auto-mail link (``). rdrer…rEr rªcs t d¡}| | d¡¡}| d¡r|tdƒd…}dd d „‰‡fd d „|Dƒ}t d  |¡¡|_ d|}d  dd „|Dƒ¡}|  d|¡||  d¡|  d¡fS)za Return an [`Element`][xml.etree.ElementTree.Element] containing a `mailto` link of `group(1)`. r÷rzmailto:Nr±rÌr rEcSs,tj |¡}|rd tj|¡Sdtj|fS)z=Return entity definition by code, or the code if not defined.z{}{};z%s#%d;)r Úcodepoint2namerqr–rÚAMP_SUBSTITUTE)r±rrArArBr Îs z;AutomailInlineProcessor.handleMatch..codepoint2namecsg|]}ˆt|ƒƒ‘qSrA)r˜©Ú.0Zletter©r rArBÚ Ösz7AutomailInlineProcessor.handleMatch..rocSsg|] }tjdt|ƒ‘qS)z#%d;)rr!r˜r"rArArBr%Ús ÿ ÿrør)r±rÌr rE) r£r¤rrprIr¾rr´rsrlrür‘r’)r_rdr…r¥ZemailZlettersÚmailtorAr$rBriÇs    ÿ z#AutomailInlineProcessor.handleMatchNr¬rrArArArBr6Ãsr6)r r r rr r)rDrEr rE)CrTZ __future__rrorÚtypingrrrrrZZxml.etree.ElementTreer£Z ElementTreerr Zmarkdownr rCZNOIMGr'r)rðrïrôrõrórìrñríròrîr-r/r+r1r>r5r7r;r<r9rKrLrVr„rŠr=r(rœr©r­r8r&r·rÆr:r?r@r,r.r*r2r0r3r4r6rArArArBÚs¦     0   V0' #8