U \> ep•ã@sndZddlmZddlmZddlmZmZmZm Z ddl Z ddl m m Z ddlmZerjddlmZd d d d œd d„ZdZdZdZdZdZdZdZdZdZdZdZdZdZedZ dZ!e Z"e!Z#dZ$dZ%d Z&d!Z'd"Z(d#Z)d$d$d%œd&d'„Z*Gd(d)„d)e ƒZ+Gd*d+„d+ƒZ,Gd,d-„d-e,ƒZ-Gd.d/„d/e,ƒZ.Gd0d1„d1e-ƒZ/Gd2d3„d3e-ƒZ0Gd4d5„d5e,ƒZ1Gd6d7„d7e-ƒZ2Gd8d9„d9e1ƒZ3Gd:d;„d;e2ƒZ4Gdd?„d?e1ƒZ6Gd@dA„dAe2ƒZ7GdBdC„dCe-ƒZ8GdDdE„dEe-ƒZ9GdFdG„dGe9ƒZ:GdHdI„dIe-ƒZ;GdJdK„dKe;ƒZGdPdQ„dQe=ƒZ?GdRdS„dSe?ƒZ@GdTdU„dUe-ƒZAGdVdW„dWe-ƒZBdS)XaB 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)ÚMarkdownr rzutil.Registry[InlineProcessor])ÚmdÚkwargsÚreturncKsDt ¡}| 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é 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©rBú;/tmp/pip-unpacked-wheel-wj0og6ym/markdown/inlinepatterns.pyÚbuild_inlinepatterns5s<ÿÿÿrDz(?]*)>z<([^<> !]+@[^@<> ]+)>z;(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!).)*--)>)z-(&(?:\#[0-9]+|\#x[0-9a-fA-F]+|[a-zA-Z0-9]+);)z \nÚstr)Ústringr cCs<| d¡r| d¡s(| d¡r4| d¡r4|dd…S|SdS)z#Remove quotes from around a string.ú"ú'réÿÿÿÿN)Ú startswithÚendswith)rFrBrBrCÚdequote«sÿÿ rLc@s*eZdZUdZded<ded<ded<dS)Ú EmStrongItemzEmphasis/strong pattern item.úre.Pattern[str]ÚpatternrEÚbuilderÚtagsN)Ú__name__Ú __module__Ú __qualname__Ú__doc__Ú__annotations__rBrBrBrCrM´s rMc@s~eZdZUdZeƒZded<ded<ded<dd dd œd d „Zd dœdd„Zdddœdd„Z d dœdd„Z d d 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_EXCLUDESrNÚ compiled_reúMarkdown | Noner NrE©rOr cCs*||_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)rOÚreÚcompileÚDOTALLÚUNICODErYr ©ÚselfrOr rBrBrCÚ__init__Üs   ÿzPattern.__init__z re.Pattern)r cCs|jS)z' Return a compiled regular expression. )rY©rarBrBrCÚgetCompiledRegExpíszPattern.getCompiledRegExpú re.Match[str]zetree.Element | str©Úmr cCsdS)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. NrB©rargrBrBrCÚ handleMatchñs zPattern.handleMatchcCs|jjS)z+ Return class name, to define pattern type )Ú __class__rRrcrBrBrCÚtypeþsz Pattern.type©Útextr csFz|jjdj‰Wntk r*|YSX‡fdd„}tj ||¡S)ú> Return unescaped text given text with an inline placeholder. Úinlinecs<| d¡}|ˆkr8ˆ |¡}t|tƒr*|Sd | ¡¡SdS)NrÚ)ÚgroupÚgetÚ isinstancerEÚjoinÚitertext©rgÚidÚvalue©ÚstashrBrCÚ get_stash s    z#Pattern.unescape..get_stash©r ÚtreeprocessorsZ stashed_nodesÚKeyErrorrZINLINE_PLACEHOLDER_REÚsub©rarmr{rBryrCÚunescapes   zPattern.unescape)N) rRrSrTrUÚtuplerXrVrbrdrirkrrBrBrBrCrW¿s  rWc@s4eZdZdZd dddœdd„Zddd d œd d „ZdS)ÚInlineProcessorz¡ Base class that inline processors subclass. This is the newer style inline processor that uses a more efficient and flexible search approach. NrErZr[cCs,||_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)rOr\r]r^r_rYZ safe_moder r`rBrBrCrbs zInlineProcessor.__init__rez9tuple[etree.Element | str | None, int | None, int | None]©rgÚdatar cCsdS)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. NrB©rargr…rBrBrCri/szInlineProcessor.handleMatch)N©rRrSrTrUrbrirBrBrBrCrƒsrƒc@s eZdZdZdddœdd„ZdS)ÚSimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. rerErfcCs | d¡S)z< Return string content of `group(2)` of a matching pattern. é)rqrhrBrBrCriGszSimpleTextPattern.handleMatchN©rRrSrTrUrirBrBrBrCrˆEsrˆc@s"eZdZdZddddœdd„ZdS) r>z2 Return a simple text of `group(1)` of a Pattern. rerEútuple[str, int, int]r„cCs| d¡| d¡| d¡fS)z< Return string content of `group(1)` of a matching pattern. rr)rqÚstartÚendr†rBrBrCriNsz%SimpleTextInlineProcessor.handleMatchNrŠrBrBrBrCr>Lsr>c@s"eZdZdZddddœdd„ZdS) r)z Return an escaped character. rerEztuple[str | None, int, int]r„cCsX| d¡}||jjkr>d tjt|ƒtj¡| d¡|  d¡fSd| d¡|  d¡fSdS)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) rqr Z ESCAPED_CHARSÚformatrÚSTXÚordÚETXrŒr)rargr…ÚcharrBrBrCriVs  (z!EscapeInlineProcessor.handleMatchNrŠrBrBrBrCr)Ssr)c@s0eZdZdZdddœdd„Zdddœd d „Zd S) ÚSimpleTagPatternz] Return element of type `tag` with a text attribute of `group(3)` of a Pattern. rE©rOÚtagcCst ||¡||_dS)zµ Create an instant of an simple tag pattern. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rWrbr–©rarOr–rBrBrCrbls zSimpleTagPattern.__init__reú etree.ElementrfcCst |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–rqrm)rargÚelrBrBrCriys  zSimpleTagPattern.handleMatchNr‡rBrBrBrCr”fs r”c@s2eZdZdZdddœdd„Zddddœd d „Zd S) ÚSimpleTagInlineProcessorz] Return element of type `tag` with a text attribute of `group(2)` of a Pattern. rEr•cCst ||¡||_dS)z· Create an instant of an simple tag processor. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rƒrbr–r—rBrBrCrb‰s z!SimpleTagInlineProcessor.__init__reútuple[etree.Element, int, int]r„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–rqrmrŒr©rargr…rœrBrBrCri–s  z$SimpleTagInlineProcessor.handleMatchNr‡rBrBrBrCrƒs rc@s eZdZdZdddœdd„ZdS)ÚSubstituteTagPatternú3 Return an element of type `tag` with no children. rer˜rfcCs t |j¡S)úH Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )ršr›r–rhrBrBrCri¢sz SubstituteTagPattern.handleMatchNrŠrBrBrBrCr  sr c@s"eZdZdZddddœdd„ZdS) r9r¡rerEržr„cCst |j¡| d¡| d¡fS)r¢r)ršr›r–rŒrr†rBrBrCri©sz(SubstituteTagInlineProcessor.handleMatchNrŠrBrBrBrCr9§sr9c@s0eZdZdZddœdd„Zddddœd d „Zd S) r'zA Return a `` element containing the escaped matching text. rE)rOcCs.t ||¡d tjtdƒtj¡|_d|_dS)NrŽú\Úcode) rƒrbrrrr‘r’ÚESCAPED_BSLASHr–)rarOrBrBrCrb°s z BacktickInlineProcessor.__init__rez$tuple[etree.Element | str, int, int]r„cCsr| d¡rHt |j¡}t t | d¡ ¡¡¡|_||  d¡|  d¡fS| d¡  d|j ¡|  d¡|  d¡fSdS)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\\N) rqršr›r–rÚ AtomicStringZ code_escapeÚstriprmrŒrÚreplacer¥rŸrBrBrCri¶s  z#BacktickInlineProcessor.handleMatchNr‡rBrBrBrCr'®sr'c@s eZdZdZdddœdd„ZdS)ÚDoubleTagPatternúfReturn a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. rer˜rfcCsR|j d¡\}}t |¡}t ||¡}| d¡|_t| ¡ƒdkrN| 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›Ú SubElementrqrmÚlenÚgroupsÚtail)rargÚtag1Útag2Úel1Úel2rBrBrCriÍs    zDoubleTagPattern.handleMatchNrŠrBrBrBrCr©Çsr©c@s"eZdZdZddddœdd„ZdS) ÚDoubleTagInlineProcessorrªrerEržr„cCsd|j d¡\}}t |¡}t ||¡}| d¡|_t| ¡ƒdkrN| 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¯rqrmr°r±r²rŒr)rargr…r³r´rµr¶rBrBrCriâs    z$DoubleTagInlineProcessor.handleMatchNrŠrBrBrBrCr·Üsr·c@sBeZdZdZddddœdd„Zdddœd d „Zdddœd d „Zd S)r;z1 Store raw inline html and return a placeholder. rerEr‹r„cCs:| | | d¡¡¡}|jj |¡}|| d¡| d¡fS)zL Store the text of `group(1)` of a pattern and return a placeholder string. rr)Úbackslash_unescaperrqr Z htmlStashÚstorerŒr)rargr…ZrawhtmlZ place_holderrBrBrCriószHtmlInlineProcessor.handleMatchrlcsPzˆjjdj‰Wntk r*|YSXdddœ‡‡fdd„ }tj ||¡S)rnrorerErfcsL| d¡}ˆ |¡}|dk rHzˆj |¡WStk rFd|YSXdS)Nrz\%s)rqrrr Ú serializerÚ Exceptionrv©rarzrBrCr{s  z/HtmlInlineProcessor.unescape..get_stashr|r€rBr¼rCrùs   zHtmlInlineProcessor.unescapecCsHz|jjdj}Wntk r*|YSXdddœdd„}| ||¡S)zG Return text with backslash escapes undone (backslashes are restored). rrerErfcSstt| d¡ƒƒS)Nr)ÚchrÚintrq)rgrBrBrCÚ _unescapesz9HtmlInlineProcessor.backslash_unescape.._unescape)r r}ÚREr~r)rarmrÀr¿rBrBrCr¸ s  z&HtmlInlineProcessor.backslash_unescapeN)rRrSrTrUrirr¸rBrBrBrCr;ñsr;c @seZdZdZee eejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒee e ejej B¡ddƒgZd d d d d œdd„Zd d d d dœdd„Zd d d d dœdd„Zd d dd ddœdd„Zd d d d d dœdd„Zd d ddœdd „Zd!S)"r@zGEmphasis processor for handling strong and em matches inside asterisks.Údoubleú strong,emú em,strongÚdouble2ÚsingleÚstrongÚemrerEr¾r˜)rgr–Úidxr cCs(t |¡}| d¡}| ||d|¡|S)zReturn single tag.r‰N)ršr›rqÚparse_sub_patterns)rargr–rÈrµrmrBrBrCÚ build_single$s  zAsteriskProcessor.build_single)rgrQrÈr c Cst| d¡\}}t |¡}t |¡}| d¡}| ||d|¡| |¡t| ¡ƒdkrp| d¡}| ||||¡|S)zReturn double tag.r«r‰Nr™)r®ršr›rqrÉÚappendr°r±© rargrQrÈr³r´rµr¶rmrBrBrCÚ 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›rqrÉrËrÌrBrBrCÚ build_double29s     zAsteriskProcessor.build_double2zetree.Element | NoneÚNone)r…ÚparentÚlastrÈr cCsüd}d}t|ƒ}||krÒ|j ||¡rÈd}t|jƒD]„\} } | |krFq4| j ||¡} | r4|||  d¡…} | r„|dk r~| |_n| |_|  | | j | j | ¡} |  | ¡| }|   d¡}}d}q4|sÐ|d7}q|d7}q||d…} | rø|dk rò| |_n| |_dS)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°rYÚmatchÚ enumerateÚPATTERNSrOrŒr²rmÚ build_elementrPrQrËr)rar…rÐrÑrÈÚoffsetÚposÚlengthÚmatchedÚindexÚitemrgrmrœrBrBrCrÉFs:    z$AsteriskProcessor.parse_sub_patterns)rgrPrQrÚr cCs>|dkr| |||¡S|dkr,| |||¡S| |||¡SdS)zElement builder.rÄrÁN)rÎrÍrÊ)rargrPrQrÚrBrBrCrÕƒs zAsteriskProcessor.build_elementú3tuple[etree.Element | None, int | None, int | None]r„c Csnd}d}d}t|jƒD]L\}}|j || d¡¡}|r| d¡}| d¡}| ||j|j|¡}qdq|||fS)zParse patterns.Nr) rÓrÔrOrÒrŒrrÕrPrQ) rargr…rœrŒrrÚrÛÚm1rBrBrCris  zAsteriskProcessor.handleMatchN)rRrSrTrUrMr\r]Ú EM_STRONG_REr^r_Ú STRONG_EM_REÚ STRONG_EM3_REÚ STRONG_REÚ EMPHASIS_RErÔrÊrÍrÎrÉrÕrirBrBrBrCr@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) rAzIEmphasis processor for handling strong and em matches inside underscores.rÁrÂrÃrÄrÅrÆrÇN)rRrSrTrUrMr\r]Ú EM_STRONG2_REr^r_Ú STRONG_EM2_REÚSMART_STRONG_EM_REÚSMART_STRONG_REÚSMART_EMPHASIS_RErÔrBrBrBrCrAžsûrAc@sdeZdZdZe dejejB¡Ze d¡Z ddddœdd „Z dd d d œd d„Z dd dd œdd„Z dS)r-z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\srerErÜr„c Cs|| || d¡¡\}}}|s dS| ||¡\}}}}|s`). rerErž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îrrqrr¦rmrŒrrŸrBrBrCri»s z#AutolinkInlineProcessor.handleMatchNrŠrBrBrBrCr5¹sr5c@s"eZdZdZddddœdd„ZdS) r7zW Return a `mailto` link Element given an auto-mail link (``). rerEržr„cs¦t d¡}| | d¡¡}| d¡r4|tdƒd…}dddœdd „‰‡fd d „|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:Nr¾rE)r¤r cSs0tj |¡}|rd tj|¡Sdtj|fSdS)z=Return entity definition by code, or the code if not defined.z{}{};z%s#%d;N)r Úcodepoint2namerrrrÚAMP_SUBSTITUTE)r¤r rBrBrCr Îs z;AutomailInlineProcessor.handleMatch..codepoint2namecsg|]}ˆt|ƒƒ‘qSrB)r‘©Ú.0Úletter©r rBrCÚ Ösz7AutomailInlineProcessor.handleMatch..rpcSsg|]}tjdt|ƒ‘qS)z#%d;)rrr‘rrBrBrCrÚsÿÿrêr) ršr›rrqrJr°rr¦rtrmrîrŒr)rargr…rœÚemailÚlettersÚmailtorBrrCriÇs   ÿ z#AutomailInlineProcessor.handleMatchNrŠrBrBrBrCr7Ãsr7)CrUÚ __future__rrprÚtypingrrrrr\Úxml.etree.ElementTreeršÚ ElementTreerr Zmarkdownr rDZNOIMGr(r*rârárærçrårÞrãrßräràr.r0r,r2r?r6r8r<r=r:rLrMrWrƒrˆr>r)r”rr r9r'r©r·r;r@rAr-r/r+r3r1r4r5r7rBrBrBrCÚsv    0  V0' #8