o ©i e“ã@sÀdZddlmZddlmZddlmZddlmZm Z m Z ddl Z ddl m mZ zddlmZWn ey@ddlZYnwerIdd lmZd\dd„ZdZ dZ dZ dZ dZ dZ dZ dZ dZ dZ dZ dZ! dZ" edZ# d Z$ e#Z% e$Z& d!Z' d"Z( d#Z) d$Z* d%Z+ d&Z, d]d)d*„Z-Gd+d,„d,ed,gd-¢ƒƒZ.Gd.d/„d/ƒZ/Gd0d1„d1e/ƒZ0Gd2d3„d3e/ƒZ1Gd4d5„d5e0ƒZ2Gd6d7„d7e0ƒZ3Gd8d9„d9e/ƒZ4Gd:d;„d;e0ƒZ5Gdd?„d?e5ƒZ7Gd@dA„dAe0ƒZ8GdBdC„dCe4ƒZ9GdDdE„dEe5ƒZ:GdFdG„dGe0ƒZ;GdHdI„dIe0ƒZGdNdO„dOe>ƒZ?GdPdQ„dQe>ƒZ@GdRdS„dSe@ƒZAGdTdU„dUe@ƒZBGdVdW„dWeBƒZCGdXdY„dYe0ƒZDGdZd[„d[e0ƒZEdS)^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)Ú namedtuple)Ú TYPE_CHECKINGÚMatchÚAnyN)Úentities)ÚMarkdownÚmdr ÚkwargsrÚreturnú util.RegistrycKsDt ¡}| 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úF/var/www/myenv/lib/python3.10/site-packages/markdown/inlinepatterns.pyÚbuild_inlinepatterns9s0 ÿ ÿ ÿ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@seZdZdZdS)Ú EmStrongItemzEmphasis/strong pattern item.N)Ú__name__Ú __module__Ú __qualname__Ú__doc__rOrOrOrPrZ¸srZ)ÚpatternÚbuilderÚtagsc@sLeZdZdZeƒZ dddd„Zdd d „Zddd„Zddd„Z ddd„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. Nr_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_r rOrOrPÚ__init__Ús   ÿ zPattern.__init__r ú re.PatterncCs|jS)z' Return a compiled regular expression. )rh©rjrOrOrPÚgetCompiledRegExpëszPattern.getCompiledRegExpÚmrú etree.ElementcCó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©rjrorOrOrPÚ handleMatchïs zPattern.handleMatchcCs|jjS)z+ Return class name, to define pattern type )Ú __class__r[rmrOrOrPÚ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Ú isinstancerSÚjoinÚitertext©roÚidÚvalue©ÚstashrOrPÚ get_stashs   úz#Pattern.unescape..get_stash©r ÚtreeprocessorsÚ stashed_nodesÚKeyErrorrÚINLINE_PLACEHOLDER_REÚsub©rjrvr„rOr‚rPÚunescapes ÿ  zPattern.unescape©N©r_rSr rc)r rl©rorr rp)r rS)rvrSr rS) r[r\r]r^ÚtupleÚANCESTOR_EXCLUDESrkrnrsrurŒrOrOrOrPrbÀs    rbc@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 rccCs,||_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_rdrerfrgrhÚ safe_moder rirOrOrPrks  zInlineProcessor.__init__rorÚdatar ú9tuple[etree.Element | str | None, int | None, int | None]cCrq)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©rjror”rOrOrPrs-szInlineProcessor.handleMatchrrŽ)rorr”rSr r•©r[r\r]r^rkrsrOrOrOrPr’s r’c@óeZdZdZd dd„ZdS) ÚSimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. rorr rScCs | d¡S)z< Return string content of `group(2)` of a matching pattern. é)rzrrrOrOrPrsEs zSimpleTextPattern.handleMatchN)rorr rS©r[r\r]r^rsrOrOrOrPr™Cór™c@óeZdZdZd dd „Zd S) rJz2 Return a simple text of `group(1)` of a Pattern. rorr”rSr útuple[str, int, int]cCs| d¡| d¡| d¡fS)z< Return string content of `group(1)` of a matching pattern. rr)rzÚstartÚendr–rOrOrPrsLsz%SimpleTextInlineProcessor.handleMatchN©rorr”rSr ržr›rOrOrOrPrJJrœrJc@r) r5z Return an escaped character. rorr”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) rzr Ú ESCAPED_CHARSÚformatrÚSTXÚordÚETXrŸr )rjror”ÚcharrOrOrPrsTs (z!EscapeInlineProcessor.handleMatchN)rorr”rSr r¢r›rOrOrOrPr5Qó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)rbrkr¬©rjr_r¬rOrOrPrkjó zSimpleTagPattern.__init__rorr rpcCst |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¬rzrv)rjroÚelrOrOrPrsws  zSimpleTagPattern.handleMatchN©r_rSr¬rSrr—rOrOrOrPr«dó  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’rkr¬r®rOrOrPrk‡r¯z!SimpleTagInlineProcessor.__init__rorr”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²r¬rzrvrŸr ©rjror”r³rOrOrPrs”s  z$SimpleTagInlineProcessor.handleMatchNr´©rorr”rSr r·r—rOrOrOrPr¶rµr¶c@r˜) ÚSubstituteTagPatternú3 Return an element of type `tag` with no children. rorr rpcCs t |j¡S)úH Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )r±r²r¬rrrOrOrPrs s z SubstituteTagPattern.handleMatchNrr›rOrOrOrPrºžrœrºc@r) rEr»rorr”rSr r·cCst |j¡| d¡| d¡fS)r¼r)r±r²r¬rŸr r–rOrOrPrs§sz(SubstituteTagInlineProcessor.handleMatchNr¹r›rOrOrOrPrE¥rœrEc@s"eZdZdZdd„Zd d d „Zd S)r3zA Return a `` element containing the escaped matching text. cCs.t ||¡d tjtdƒtj¡|_d|_dS)Nr£ú\Úcode) r’rkr¥rr¦r§r¨ÚESCAPED_BSLASHr¬)rjr_rOrOrPrk®s z BacktickInlineProcessor.__init__rorr”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\\) rzr±r²r¬rÚ AtomicStringÚ code_escapeÚstriprvrŸr Úreplacer¿r¸rOrOrPrs´s &z#BacktickInlineProcessor.handleMatchN)rorr”rSr rÀr—rOrOrOrPr3¬sr3c@r˜) ÚDoubleTagPatternúfReturn a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. rorr rpcCsR|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²Ú SubElementrzrvÚlenÚgroupsÚtail)rjroÚtag1Útag2Úel1Úel2rOrOrPrsËs    zDoubleTagPattern.handleMatchNrr›rOrOrOrPrÅÅórÅc@r) ÚDoubleTagInlineProcessorrÆrorr”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) r¬rÊr±r²rËrzrvrÌrÍrÎrŸr )rjror”rÏrÐrÑrÒrOrOrPrsàs    z$DoubleTagInlineProcessor.handleMatchNr¹r›rOrOrOrPrÔÚrÓrÔc@s*eZdZdZddd „Zd d „Zd d „ZdS)rGz1 Store raw inline html and return a placeholder. rorr”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_unescaperŒrzr Ú htmlStashÚstorerŸr )rjror”ÚrawhtmlÚ place_holderrOrOrPrsñszHtmlInlineProcessor.handleMatchcsFz ˆjjdj‰Wn ty|YSw‡‡fdd„}tj ||¡S)rwrxcsJ| d¡}ˆ |¡}|dur#zˆj |¡WSty"d|YSwdS)Nrz\%s)rzr{r Ú serializerÚ Exceptionr©rjrƒrOrPr„þs    ÿýz/HtmlInlineProcessor.unescape..get_stashr…r‹rOrÜrPrŒ÷s ÿ zHtmlInlineProcessor.unescapecCs>z |jjdj}Wn ty|YSwdd„}| ||¡S)zG Return text with backslash escapes undone (backslashes are restored). rŒcSstt| d¡ƒƒS)Nr)ÚchrÚintrz)rorOrOrPÚ _unescapesz9HtmlInlineProcessor.backslash_unescape.._unescape)r r†ÚRErˆrŠ)rjrvràrßrOrOrPrÕ s ÿ z&HtmlInlineProcessor.backslash_unescapeNr¡)r[r\r]r^rsrŒrÕ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 d „Zd d „Zd d„Zdd„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²rzÚparse_sub_patterns)rjror¬ÚidxrÑrvrOrOrPÚ 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²rzrèÚappendrÌrÍ© rjrorarérÏrÐrÑrÒrvrOrOrPÚ 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²rzrèrërìrOrOrPÚ build_double27s     zAsteriskProcessor.build_double2cCsd}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ÌrhÚmatchÚ enumerateÚPATTERNSr_rŸrÎrvÚ build_elementr`rarër )rjr”ÚparentÚlastréÚoffsetÚposÚlengthÚmatchedÚindexÚitemrorvr³rOrOrPrèDsB €€à #  üz$AsteriskProcessor.parse_sub_patternscCs:|dkr | |||¡S|dkr| |||¡S| |||¡S)zElement builder.rärá)rîrírê)rjror`rarùrOrOrPrò„s zAsteriskProcessor.build_elementrorr”rSr r·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`ra) rjror”r³rŸr rùrúÚm1rOrOrPrsŽs  ü zAsteriskProcessor.handleMatchNr¹)r[r\r]r^rZrdreÚ EM_STRONG_RErfrgÚ STRONG_EM_REÚ STRONG_EM3_REÚ STRONG_REÚ EMPHASIS_RErñrêrírîrèròrsrOrOrOrPrLsû @ 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\r]r^rZrdreÚ EM_STRONG2_RErfrgÚ STRONG_EM2_REÚSMART_STRONG_EM_REÚSMART_STRONG_REÚSMART_EMPHASIS_RErñrOrOrOrPrMŸsûrMc@sHeZdZdZe dejejB¡Ze d¡Z dd d „Z d d „Z dd„Z dS)r9z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\srorr”rSr ú3tuple[etree.Element | None, int | None, int | None]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²rvÚsetrŸ) rjror”rvrùÚhandledr r r³rOrOrPrs±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|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 `()`. ryNF©rörrVršrTú(ú))rUrTú ) ÚRE_LINKrïrzrÃr ÚrangerÌr}ÚRE_TITLE_CLEANrŠrYrŒ)rjr”rùr r rroÚ 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| |¡q d |¡||dkfS)zsParse the content between `[]` of the start of an image or link resolving nested square brackets. rú]ú[rry)rrÌrër})rjr”rùrrvrör!rOrOrPr :s  zLinkInlineProcessor.getTextN©rorr”rSr r) r[r\r]r^rdrerfrgrrrsr r rOrOrOrPr9¬s   tr9c@r) r;z. Return a `img` element from the given match. rorr”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)r r r r±r²r rŒrŸ) rjror”rvrùrr&r r³rOrOrPrsQs   z ImageInlineProcessor.handleMatchNr$r›rOrOrOrPr;Nrªr;c@sNeZdZdZe dej¡Ze dejej B¡Z dd d „Z d d „Z ddd„Z dS)r7z6 Match to a stored reference and return link element. z\s+z\s?\[([^\]]*)\]rorr”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) r r ÚevalIdÚNEWLINE_CLEANUP_RErŠr Ú referencesrŸÚmakeTag) rjror”rvrùrr€r r r rOrOrPrsls z$ReferenceInlineProcessor.handleMatchcCsL|jj||d}|sd|dfS| d¡ ¡}| d¡}|s!| ¡}||dfS)z\ Evaluate the id portion of `[ref][id]`. If `[ref][]` use `[ref]`. rNFrrT)rrïrzÚlowerr )rjr”rùrvror€r rOrOrPr(‚s   zReferenceInlineProcessor.evalIdr r rvrpcCs0t d¡}| d|¡|r| d|¡||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. rr r )r±r²r rv©rjr r rvr³rOrOrPr+’s   z ReferenceInlineProcessor.makeTagNr$©r rSr rSrvrSr rp)r[r\r]r^rdreÚ MULTILINEr)rfrgrrsr(r+rOrOrOrPr7fs r7c@óeZdZdZdd„ZdS)r?z%Short form of reference: `[google]`. cCó| ¡|dfS©zEvaluate the id of `[ref]`. T©r,©rjr”rùrvrOrOrPr( óz$ShortReferenceInlineProcessor.evalIdN©r[r\r]r^r(rOrOrOrPr?žó r?c@r) r=z7 Match to a stored reference and return `img` element. r rSr rvr rpcCs<t d¡}| d|¡|r| d|¡| d| |¡¡|S)z= Return an `img` [`Element`][xml.etree.ElementTree.Element]. r%r&r r')r±r²r rŒr-rOrOrPr+¨s   z%ImageReferenceInlineProcessor.makeTagNr.)r[r\r]r^r+rOrOrOrPr=¦rœr=c@r0)r@z* Short form of image reference: `![ref]`. cCr1r2r3r4rOrOrPr(´r5z)ShortImageReferenceInlineProcessor.evalIdNr6rOrOrOrPr@²r7r@c@r) rAzD Return a link Element given an auto-link (``). rorr”rSr r·cCsJt d¡}| d| | d¡¡¡t | d¡¡|_|| d¡|  d¡fS)zI Return an `a` [`Element`][xml.etree.ElementTree.Element] of `group(1)`. rr rr) r±r²r rŒrzrrÁrvrŸr r¸rOrOrPrs¼s z#AutolinkInlineProcessor.handleMatchNr¹r›rOrOrOrPrAºrœrAc@r) rCzW Return a `mailto` link Element given an auto-mail link (``). rorr”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)`. rrzmailto: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(rOrOrPr8Ïs z;AutomailInlineProcessor.handleMatch..codepoint2namecsg|]}ˆt|ƒƒ‘qSrO)r§©Ú.0Úletter©r8rOrPÚ ×sz7AutomailInlineProcessor.handleMatch..rycSsg|] }tjdt|ƒ‘qS)z#%d;)rr9r§r:rOrOrPr>Ûs ÿ ÿr r) r±r²rŒrzrWrÌrrÁr}rvr rŸr )rjror”r³ÚemailÚlettersÚmailtorOr=rPrsÈs   ÿ z#AutomailInlineProcessor.handleMatchNr¹r›rOrOrOrPrCÄsrC)r r r rr r)rRrSr rS)Fr^Ú __future__rryrÚ collectionsrÚtypingrrrrdÚxml.etree.ElementTreer±Ú ElementTreer&r Ú ImportErrorÚhtmlentitydefsÚmarkdownr rQÚNOIMGr4r6rrÿrrrrürrýrrþr:r<r8r>rKrBrDrHrIrFrYrZrbr’r™rJr5r«r¶rºrEr3rÅrÔrGrLrMr9r;r7r?r=r@rArCrOrOrOrPÚs°     ÿ  0  S0'  #8