o ¼>h:–ã@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. Ú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)r r ÚinlinePatterns©rOúw/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/markdown/inlinepatterns.pyÚbuild_inlinepatterns5s0 ÿ ÿ ÿrQz(?]*)>z<([^<> !]+@[^@<> ]+)>z(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!).)*--|[?](?:(?!<[?]|[?]>).)*[?]|!\[CDATA\[(?:(?!).)*\]\])>)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.úre.Pattern[str]ÚpatternrSÚbuilderÚtagsN)Ú__name__Ú __module__Ú __qualname__Ú__doc__Ú__annotations__rOrOrOrPrZºs  rZc@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_EXCLUDESr[Ú compiled_reúMarkdown | Noner Nr\rScCs*||_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ÚUNICODErfr ©Úselfr\r rOrOrPÚ__init__âs   ÿ zPattern.__init__r ú re.PatterncCs|jS)z' Return a compiled regular expression. )rf©rmrOrOrPÚ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©rmrrrOrOrPÚ handleMatch÷s zPattern.handleMatchcCs|jjS)z+ Return class name, to define pattern type )Ú __class__r_rprOrOrPÚtypesz 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Ú isinstancerSÚjoinÚitertext©rrÚidÚvalue©ÚstashrOrPÚ get_stashs   úz#Pattern.unescape..get_stash©r ÚtreeprocessorsÚ stashed_nodesÚKeyErrorrÚINLINE_PLACEHOLDER_REÚsub©rmrzrˆrOr†rPÚunescapes ÿ  zPattern.unescape©N©r\rSr rg)r ro)rrrsr rt)r rS©rzrSr rS) r_r`rarbÚtuplerercrnrqrwryrrOrOrOrPrdÅs     rdc@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\rSr rgcCs,||_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\rhrirjrkrfÚ safe_moder rlrOrOrPrn$s  zInlineProcessor.__init__rrrsÚdatar ú9tuple[etree.Element | str | None, int | None, int | None]cCru)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©rmrrr—rOrOrPrw5szInlineProcessor.handleMatchr‘r’)rrrsr—rSr r˜©r_r`rarbrnrwrOrOrOrPr•s r•c@óeZdZdZd dd„ZdS) ÚSimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. rrrsr rScCs | d¡S)z< Return string content of `group(2)` of a matching pattern. é)r~rvrOrOrPrwMs zSimpleTextPattern.handleMatchN©rrrsr rS©r_r`rarbrwrOrOrOrPrœKórœc@óeZdZdZd dd „Zd S) rJz2 Return a simple text of `group(1)` of a Pattern. rrrsr—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™rOrOrPrwTsz%SimpleTextInlineProcessor.handleMatchN©rrrsr—rSr r¢rŸrOrOrOrPrJRr rJc@r¡) r5z Return an escaped character. rrrsr—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¤)rmrrr—ÚcharrOrOrPrw\s (z!EscapeInlineProcessor.handleMatchN)rrrsr—rSr r¦rŸrOrOrOrPr5Yór5c@s$eZdZdZddd„Zdd d „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)rdrnr°©rmr\r°rOrOrPrnró zSimpleTagPattern.__init__rrrsr ú 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ÚElementr°r~rz)rmrrÚelrOrOrPrws  zSimpleTagPattern.handleMatchN©r\rSr°rS©rrrsr r´ršrOrOrOrPr¯ló  r¯c@s$eZdZdZddd„Zdd d „ZdS)ÚSimpleTagInlineProcessorz] Return element of type `tag` with a text attribute of `group(2)` of a Pattern. r\rSr°cCr±)z· Create an instant of an simple tag processor. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)r•rnr°r²rOrOrPrnr³z!SimpleTagInlineProcessor.__init__rrrsr—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. rr)r¶r·r°r~rzr£r¤©rmrrr—r¸rOrOrPrwœs  z$SimpleTagInlineProcessor.handleMatchNr¹©rrrsr—rSr r½ršrOrOrOrPr¼‰r»r¼c@r›) ÚSubstituteTagPatternú3 Return an element of type `tag` with no children. rrrsr r´cCs t |j¡S)úH Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )r¶r·r°rvrOrOrPrw¨s z SubstituteTagPattern.handleMatchNrºrŸrOrOrOrPrÀ¦r rÀc@r¡) rErÁrrrsr—rSr r½cCst |j¡| d¡| d¡fS)rÂr)r¶r·r°r£r¤r™rOrOrPrw¯sz(SubstituteTagInlineProcessor.handleMatchNr¿rŸrOrOrOrPrE­r rEc@s$eZdZdZddd„Zdd d „Zd S)r3zA Return a `` element containing the escaped matching text. r\rScCs.t ||¡d tjtdƒtj¡|_d|_dS)Nr§ú\Úcode) r•rnr©rrªr«r¬ÚESCAPED_BSLASHr°)rmr\rOrOrPrn¶s z BacktickInlineProcessor.__init__rrrsr—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\\) r~r¶r·r°rÚ AtomicStringÚ code_escapeÚstriprzr£r¤ÚreplacerÅr¾rOrOrPrw¼s &z#BacktickInlineProcessor.handleMatchN)r\rS)rrrsr—rSr rÆršrOrOrOrPr3´s r3c@r›) ÚDoubleTagPatternúfReturn a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. rrrsr 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~rzÚlenÚgroupsÚtail)rmrrÚtag1Útag2Úel1Úel2rOrOrPrwÓs    zDoubleTagPattern.handleMatchNrºrŸrOrOrOrPrËÍórËc@r¡) ÚDoubleTagInlineProcessorrÌrrrsr—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Írrµr) r°rÐr¶r·rÑr~rzrÒrÓrÔr£r¤)rmrrr—rÕrÖr×rØrOrOrPrwès    z$DoubleTagInlineProcessor.handleMatchNr¿rŸrOrOrOrPrÚârÙrÚc@s.eZdZdZddd „Zdd d „Zdd d„ZdS)rGz1 Store raw inline html and return a placeholder. rrrsr—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¤)rmrrr—ÚrawhtmlÚ place_holderrOrOrPrwùszHtmlInlineProcessor.handleMatchrzcsHz ˆjjdj‰Wn ty|YSwd ‡‡fdd„ }tj ||¡S) r{r|rrrsr rScsJ| d¡}ˆ |¡}|dur#zˆj |¡WSty"d|YSwdS)Nrz\%s)r~rr Ú serializerÚ Exceptionrƒ©rmr‡rOrPrˆs    ÿýz/HtmlInlineProcessor.unescape..get_stashNržr‰rrOrârPrÿs ÿ zHtmlInlineProcessor.unescapecCs@z |jjdj}Wn ty|YSwd dd„}| ||¡S) zG Return text with backslash escapes undone (backslashes are restored). rrrrsr rScSstt| d¡ƒƒS)Nr)ÚchrÚintr~)rrrOrOrPÚ _unescapesz9HtmlInlineProcessor.backslash_unescape.._unescapeNrž)r rŠÚRErŒrŽ)rmrzrærårOrOrPrÛs ÿ  z&HtmlInlineProcessor.backslash_unescapeNr¥r“)r_r`rarbrwrrÛrOrOrOrPrG÷s   rGc @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),rLzGEmphasis processor for handling strong and em matches inside asterisks.Údoubleú strong,emú em,strongÚdouble2ÚsingleÚstrongÚemrrrsr°rSÚidxrär r´cCs(t |¡}| d¡}| ||d|¡|S)zReturn single tag.rN)r¶r·r~Úparse_sub_patterns)rmrrr°rîr×rzrOrOrPÚ build_single*s  zAsteriskProcessor.build_singler^c Cst| d¡\}}t |¡}t |¡}| d¡}| ||d|¡| |¡t| ¡ƒdkr8| d¡}| ||||¡|S)zReturn double tag.rÍrNrµ)rÐr¶r·r~rïÚappendrÒrÓ© rmrrr^rîrÕrÖr×rØrzrOrOrPÚ build_double1s     zAsteriskProcessor.build_doublec Csd| d¡\}}t |¡}t |¡}| d¡}| ||d|¡| d¡}| |¡| ||d|¡|S)zFReturn double tags (variant 2): `text text`.rÍrNrµ)rÐr¶r·r~rïrñròrOrOrPÚ build_double2?s     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ÒrfÚmatchÚ enumerateÚPATTERNSr\r£rÔrzÚ build_elementr]r^rñr¤)rmr—rõrörîÚoffsetÚposÚlengthÚmatchedÚindexÚitemrrrzr¸rOrOrPrïLsB €€à #  üz$AsteriskProcessor.parse_sub_patternsr]rcCs:|dkr | |||¡S|dkr| |||¡S| |||¡S)zElement builder.rêrç)rôrórð)rmrrr]r^rrOrOrPrü‰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ûr\rùr£r¤rür]r^) rmrrr—r¸r£r¤rrÚm1rOrOrPrw“s  ü zAsteriskProcessor.handleMatchN)rrrsr°rSrîrär r´)rrrsr^rSrîrär r´) r—rSrõr´rör÷rîrär rø) rrrsr]rSr^rSrrär r´©rrrsr—rSr r)r_r`rarbrZrhriÚ EM_STRONG_RErjrkÚ STRONG_EM_REÚ STRONG_EM3_REÚ STRONG_REÚ EMPHASIS_RErûrðrórôrïrürwrOrOrOrPrLsû    = rLc @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) rMzIEmphasis processor for handling strong and em matches inside underscores.rçrèrérêrërìríN)r_r`rarbrZrhriÚ EM_STRONG2_RErjrkÚ STRONG_EM2_REÚSMART_STRONG_EM_REÚSMART_STRONG_REÚSMART_EMPHASIS_RErûrOrOrOrPrM¤sûrMc@sLeZdZdZe dejejB¡Ze d¡Z dd d „Z ddd„Z ddd„Z dS)r9z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\srrrsr—rSr rc 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·rzÚsetr£) rmrrr—rzrÚhandledrrr¸rOrOrPrw¶s   zLinkInlineProcessor.handleMatchrräú!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 `()`. r}NF©rþrrVrrTú(ú))rUrTú ) ÚRE_LINKrùr~rÉr¤ÚrangerÒrÚRE_TITLE_CLEANrŽrYr)rmr—rrrrrrÚ 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.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ú]ú[rr})rrÒrñr)rmr—rr rzrþr+rOrOrPr?s  zLinkInlineProcessor.getTextNr)r—rSrrär r)r—rSrrär r,) r_r`rarbrhrirjrkrrrwrrrOrOrOrPr9±s   tr9c@r¡) r;z. Return a `img` element from the given match. rrrsr—rSr rc 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£) rmrrr—rzrrr0rr¸rOrOrPrwVs   z ImageInlineProcessor.handleMatchNrrŸrOrOrOrPr;Sr®r;c@sPeZdZdZe dej¡Ze dejej B¡Z dd d „Z ddd„Z ddd„Z dS)r7z6 Match to a stored reference and return link element. z\s+z\s?\[([^\]]*)\]rrrsr—rSr rc 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_RErŽr Ú referencesr£ÚmakeTag) rmrrr—rzrrr„r¤rrrOrOrPrwqs z$ReferenceInlineProcessor.handleMatchrrärzú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]`. rNFrrT)rrùr~Úlowerr¤)rmr—rrzrrr„r¤rOrOrPr2‡s   zReferenceInlineProcessor.evalIdrrr´cCs0t d¡}| d|¡|r| d|¡||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. rrr)r¶r·rrz©rmrrrzr¸rOrOrPr5—s   z ReferenceInlineProcessor.makeTagNr)r—rSrrärzrSr r6©rrSrrSrzrSr r´)r_r`rarbrhriÚ MULTILINEr3rjrkrrwr2r5rOrOrOrPr7ks  r7c@óeZdZdZd d d „Zd S) r?z%Short form of reference: `[google]`. r—rSrrärzr r,cCó| ¡|dfS©zEvaluate the id of `[ref]`. T©r7©rmr—rrzrOrOrPr2¥óz$ShortReferenceInlineProcessor.evalIdN©r—rSrrärzrSr r,©r_r`rarbr2rOrOrOrPr?£r r?c@r¡) r=z7 Match to a stored reference and return `img` element. rrSrrzr r´cCs<t d¡}| d|¡|r| d|¡| d| |¡¡|S)z= Return an `img` [`Element`][xml.etree.ElementTree.Element]. r/r0rr1)r¶r·rrr8rOrOrPr5­s   z%ImageReferenceInlineProcessor.makeTagNr9)r_r`rarbr5rOrOrOrPr=«r r=c@r;) r@z* Short form of image reference: `![ref]`. r—rSrrärzr r,cCr<r=r>r?rOrOrPr2¹r@z)ShortImageReferenceInlineProcessor.evalIdNrArBrOrOrOrPr@·r r@c@r¡) rAzD Return a link Element given an auto-link (``). rrrsr—rSr r½cCsJt d¡}| d| | d¡¡¡t | d¡¡|_|| d¡|  d¡fS)zI Return an `a` [`Element`][xml.etree.ElementTree.Element] of `group(1)`. rrrr) r¶r·rrr~rrÇrzr£r¤r¾rOrOrPrwÁs z#AutolinkInlineProcessor.handleMatchNr¿rŸrOrOrOrPrA¿r rAc@r¡) rCzW Return a `mailto` link Element given an auto-mail link (``). rrrsr—rSr 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)`. rrzmailto:NrÄrär rScSs,tj |¡}|rd tj|¡Sdtj|fS)z=Return entity definition by code, or the code if not defined.z{}{};z%s#%d;)r Úcodepoint2namerr©rÚAMP_SUBSTITUTE)rÄr(rOrOrPrCÔs z;AutomailInlineProcessor.handleMatch..codepoint2namecsg|]}ˆt|ƒƒ‘qSrO)r«©Ú.0Úletter©rCrOrPÚ Üsz7AutomailInlineProcessor.handleMatch..r}cSsg|] }tjdt|ƒ‘qS)z#%d;)rrDr«rErOrOrPrIàs ÿ ÿrr)rÄrär rS) r¶r·rr~rWrÒrrÇrrzrr£r¤)rmrrr—r¸ÚemailÚlettersÚmailtorOrHrPrwÍs    ÿ z#AutomailInlineProcessor.handleMatchNr¿rŸrOrOrOrPrCÉsrC)r r r rr r)rRrSr rS)CrbÚ __future__rr}rÚtypingrrrrrhÚxml.etree.ElementTreer¶Ú ElementTreer&r Úmarkdownr rQÚNOIMGr4r6r r rrr rr rr rr:r<r8r>rKrBrDrHrIrFrYrZrdr•rœrJr5r¯r¼rÀrEr3rËrÚrGrLrMr9r;r7r?r=r@rArCrOrOrOrPÚs¨     0ÿ   V0' #8