2iޓ>dZddlmZddlmZddlmZmZmZm Z ddl Z ddl m cm Z  ddlmZerddlmZdPd Zd Z d Z d Z d Z dZ dZ dZ dZ dZ dZ dZ dZ dZ! edzZ" dZ# e"Z$ e#Z% dZ& dZ' dZ( dZ) dZ* dZ+ dQdZ,Gd d!e Z-Gd"d#Z.Gd$d%e.Z/Gd&d'e.Z0Gd(d)e/Z1Gd*d+e/Z2Gd,d-e.Z3Gd.d/e/Z4Gd0d1e3Z5Gd2d3e4Z6Gd4d5e/Z7Gd6d7e3Z8Gd8d9e4Z9Gd:d;e/Z:Gd<d=e/Z;Gd>d?e;Z<Gd@dAe/Z=GdBdCe=Z>GdDdEe=Z?GdFdGe?Z@GdHdIe?ZAGdJdKeAZBGdLdMe/ZCGdNdOe/ZDy#e$rddlZYlwxYw)RaB 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_CHECKINGAny Collection NamedTupleN)entities)Markdownc 6tj}|jttdd|jt t |dd|jtt|dd|jtt|dd|jtt|d d |jtt|d d |jtt|d d|jt!t|dd|jt#t$|dd|jt't(|dd|jt+t,ddd|jt/t0|dd|jt/t2|dd|jt5t6dd|jt9ddd |jt;d!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. backtickescape referencelink image_linkimage_referenceshort_referenceshort_image_ref}autolinkxautomailnbr linebreakdhtmlZentityP not_strongFz\* em_strong<_ em_strong22)rRegistryregisterBacktickInlineProcessor BACKTICK_REEscapeInlineProcessor ESCAPE_REReferenceInlineProcessor REFERENCE_RELinkInlineProcessorLINK_REImageInlineProcessor IMAGE_LINK_REImageReferenceInlineProcessorIMAGE_REFERENCE_REShortReferenceInlineProcessor"ShortImageReferenceInlineProcessorAutolinkInlineProcessor AUTOLINK_REAutomailInlineProcessor AUTOMAIL_RESubstituteTagInlineProcessor LINE_BREAK_REHtmlInlineProcessorHTML_RE ENTITY_RESimpleTextInlineProcessor NOT_STRONG_REAsteriskProcessorUnderscoreProcessor)mdkwargsinlinePatternss N/var/www/html/acx/venv/lib/python3.12/site-packages/markdown/inlinepatterns.pybuild_inlinepatternsrP8s&]]_N3K@*cR1)R@(CP4\2F UXY/"M5mDlTVW-e4k2F/5|RH z(?]*)>z<([^<> !]+@[^@<> ]+)>z;(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!).)*--)>)z-(&(?:\#[0-9]+|\#x[0-9a-fA-F]+|[a-zA-Z0-9]+);)z \nc|jdr|jds"|jdr|jdr|ddS|S)z#Remove quotes from around a string."'r) startswithendswith)strings rOdequoterYsE   3 FOOC$8#6??3#7a| rQc0eZdZUdZded<ded<ded<y) EmStrongItemzEmphasis/strong pattern item.zre.Pattern[str]patternstrbuildertagsN)__name__ __module__ __qualname____doc____annotations__rQrOr[r[s'  L IrQr[cVeZdZUdZeZded< d d dZd dZd dZ ddZ dd Z y)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_EXCLUDESNc||_tjd|ztjtjz|_||_y)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\recompileDOTALLUNICODE compiled_rerLselfr\rLs rO__init__zPattern.__init__s= ::&6&@&(ii"**&<>rQc|jS)z' Return a compiled regular expression. )rnrps rOgetCompiledRegExpzPattern.getCompiledRegExpsrQcy)zReturn 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. Nrerpms rO handleMatchzPattern.handleMatchs rQc.|jjS)z+ Return class name, to define pattern type ) __class__r`rss rOtypez Pattern.types~~&&&rQc |jjdjfd}tj j ||S#t$r|cYSwxYw)> Return unescaped text given text with an inline placeholder. inlinec|jd}|vrBj|}t|tr|Sdj |j Sy)Nr)groupget isinstancer]joinitertext)rwidvaluestashs rO get_stashz#Pattern.unescape..get_stash sPBU{ " eS) L775>>#344 rQrLtreeprocessors stashed_nodesKeyErrorrINLINE_PLACEHOLDER_REsubrptextrrs @rOunescapezPattern.unescapesX GG**84BBE 5))--i>> K s#A AANr\r]rLzMarkdown | None)returnz re.Pattern)rw re.Match[str]rzetree.Element | str)rr])rr]rr]) r`rarbrctuplerhrdrqrtrxr{rrerQrOrgrgs4&*/0 "   '?rQrgc"eZdZdZdddZddZy)InlineProcessorz Base class that inline processors subclass. This is the newer style inline processor that uses a more efficient and flexible search approach. Nc||_tj|tjtjz|_d|_||_y)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\rjrkrlrmrn safe_moderLros rOrqzInlineProcessor.__init__s; ::gryy2::/EFrQcy)aReturn 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. Nrerprwdatas rOrxzInlineProcessor.handleMatch/s& rQrr)rwrrr]rz9tuple[etree.Element | str | None, int | None, int | None]r`rarbrcrqrxrerQrOrrs" rQrceZdZdZddZy)SimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. c$|jdS)z< Return string content of `group(2)` of a matching pattern. )rrvs rOrxzSimpleTextPattern.handleMatchGswwqzrQN)rwrrr]r`rarbrcrxrerQrOrrEs <rQrceZdZdZddZy)rHz2 Return a simple text of `group(1)` of a Pattern. cf|jd|jd|jdfS)z< Return string content of `group(1)` of a matching pattern. rr)rstartendrs rOrxz%SimpleTextInlineProcessor.handleMatchNs'wwqz1771:quuQx//rQNrwrrr]rztuple[str, int, int]rrerQrOrHrHLs <0rQrHceZdZdZddZy)r3z Return an escaped character. cL|jd}||jjvrYdjtj t |tj|jd|jdfSd|jd|jdfS)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) rrL ESCAPED_CHARSformatrSTXordETXrr)rprwrchars rOrxz!EscapeInlineProcessor.handleMatchVswwwqz 477(( (??488SYA1771:quuUVxW WQUU1X- -rQN)rwrrr]rztuple[str | None, int, int]rrerQrOr3r3Ss ( .rQr3c eZdZdZddZddZy)SimpleTagPatternz] Return element of type `tag` with a text attribute of `group(3)` of a Pattern. c>tj||||_y)z Create an instant of an simple tag pattern. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rgrqtagrpr\rs rOrqzSimpleTagPattern.__init__ls w'0rQcptj|j}|jd|_|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. )etreeElementrrr)rprwels rOrxzSimpleTagPattern.handleMatchys* ]]488 $''!* rQNr\r]rr]rwrr etree.ElementrrerQrOrrfs 1rQrc eZdZdZddZddZy)SimpleTagInlineProcessorz] Return element of type `tag` with a text attribute of `group(2)` of a Pattern. c>tj||||_y)z Create an instant of an simple tag processor. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rrqrrs rOrqz!SimpleTagInlineProcessor.__init__s   w/0rQctj|j}|jd|_||j d|j dfS)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)rrrrrrrrprwrrs rOrxz$SimpleTagInlineProcessor.handleMatchsB ]]488 $''!*1771:quuQx''rQNrrwrrr]rztuple[etree.Element, int, int]rrerQrOrrs 1(rQrceZdZdZddZy)SubstituteTagPattern3 Return an element of type `tag` with no children. c@tj|jS)H Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )rrrrvs rOrxz SubstituteTagPattern.handleMatchs}}TXX&&rQNrrrerQrOrrs ='rQrceZdZdZddZy)rCrctj|j|jd|j dfS)rr)rrrrrrs rOrxz(SubstituteTagInlineProcessor.handleMatchs,}}TXX& AEE!H<` element containing the escaped matching text. ctj||djtjt dtj |_d|_y)Nr\code) rrqrrrrrESCAPED_BSLASHr)rpr\s rOrqz BacktickInlineProcessor.__init__s=  w/&oodhhD 488L0rQc|jdrtj|j}t j t j |jdj|_||jd|jdfS|jdjd|j|jd|jdfS)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. rrrz\\) rrrrr AtomicString code_escapestriprrrreplacerrs rOrxz#BacktickInlineProcessor.handleMatchs 771:txx(B''(8(89I9I9K(LMBGqwwqz1558+ +771:%%fd.A.ABAGGAJPQPUPUVWPXX XrQN)rwrrr]rz$tuple[etree.Element | str, int, int]rrerQrOr1r1sK1 YrQr1ceZdZdZddZy)DoubleTagPatternfReturn a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. c(|jjd\}}tj|}tj||}|j d|_t|jdk(r|j d|_ |S)z Return [`Element`][xml.etree.ElementTree.Element] in following format: `group(3)group(4)` where `group(4)` is optional. ,r) rsplitrr SubElementrrlengroupstail)rprwtag1tag2el1el2s rOrxzDoubleTagPattern.handleMatchso XX^^C( dmmD!sD)771: qxxz?a wwqzCH rQNrrrerQrOrrs  rQrceZdZdZddZy)DoubleTagInlineProcessorrcj|jjd\}}tj|}tj||}|j d|_t|jdk(r|j d|_ ||jd|jdfS)z Return [`Element`][xml.etree.ElementTree.Element] in following format: `group(2)group(3)` where `group(3)` is optional. rrrr) rrrrrrrrrrrr)rprwrrrrrs rOrxz$DoubleTagInlineProcessor.handleMatchs XX^^C( dmmD!sD)771: qxxz?a wwqzCHAGGAJa((rQNrrrerQrOrrs  )rQrc$eZdZdZddZdZdZy)rEz1 Store raw inline html and return a placeholder. c|j|j|jd}|jjj |}||j d|jdfS)zL Store the text of `group(1)` of a pattern and return a placeholder string. rr)backslash_unescaperrrL htmlStashstorerr)rprwrrawhtml place_holders rOrxzHtmlInlineProcessor.handleMatchsZ))$-- *CDww((..w7 QWWQZq11rQc jjdjfd}tj j ||S#t$r|cYSwxYw)r}r~c|jd}j|}| jj|Sy#t$rd|zcYSwxYw)Nrz\%s)rrrL serializer Exception)rwrrrprs rOrz/HtmlInlineProcessor.unescape..get_stashs]BIIbME *77--e44!!*!E>)*sAAArrs` @rOrzHtmlInlineProcessor.unescapesX GG**84BBE *))--i>> K s#A AAc |jjdj}d}|j ||S#t$r|cYSwxYw)zG Return text with backslash escapes undone (backslashes are restored). rcHtt|jdS)Nr)chrintr)rws rO _unescapez9HtmlInlineProcessor.backslash_unescape.._unescapess1771:' 'rQ)rLrRErr)rprrrs rOrz&HtmlInlineProcessor.backslash_unescape sO '' 366B (vvi&&  K s#: AANr)r`rarbrcrxrrrerQrOrErEs;2 ?$ 'rQrEc (eZdZdZeej eejejzddeej e ejejzddeej e ejejzddeej e ejejzddeej e ejejzddgZ d Zd Zd Zdd Zd ZddZy)rJzGEmphasis processor for handling strong and em matches inside asterisks.double strong,em em,strongdouble2singlestrongemcztj|}|jd}|j||d||S)zReturn single tag.rN)rrrparse_sub_patterns)rprwridxrrs rO build_singlezAsteriskProcessor.build_single$s6mmC wwqz c45 rQcp|jd\}}tj|}tj|}|jd}|j ||d||j |t |jdk(r%|jd}|j |||||S)zReturn double tag.rrNr)rrrrrappendrr rprwr_rrrrrrs rO build_doublezAsteriskProcessor.build_double+sZZ_ dmmD!mmD!wwqz c45 3 qxxz?a 771:D  # #D#sC 8 rQc8|jd\}}tj|}tj|}|jd}|j ||d||jd}|j ||j ||d||S)zFReturn double tags (variant 2): `text text`.rrNr)rrrrrrr s rO build_double2zAsteriskProcessor.build_double29sZZ_ dmmD!mmD!wwqz c45wwqz 3 c45 rQc2d}d}t|}||kr|jj||rd}t|jD]\} } | |kr | j j||} | s+||| j d} | r|| |_n| |_|j| | j| j| } |j| | }| jdx}}d}|s |dz }n|dz }||kr||d} | r|| |_y| |_yy)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)rrnmatch enumeratePATTERNSr\rrr build_elementr^r_rr)rprparentlastroffsetposlengthmatchedindexitemrwrrs rOrz$AsteriskProcessor.parse_sub_patternsFs8$TFl%%dC0#,T]]#;'KE4|  **45A $F1771:6#/,0 .2 !//4<<ER b)!'(uuQx/"&+',1HCqAFlFFG}   " rQc|dk(r|j|||S|dk(r|j|||S|j|||S)zElement builder.rr)r r r)rprwr^r_rs rOrzAsteriskProcessor.build_elementsS i %%au5 5  $$Qe4 4$$Qe4 4rQcDd}d}d}t|jD]~\}}|jj||j d}|s4|j d}|j d}|j ||j|j|}n|||fS)zParse patterns.Nr) rrr\rrrrr^r_) rprwrrrrrrm1s rOrxzAsteriskProcessor.handleMatchs$T]]3 KE4##D!''!*5B ffQi''DLL$))UK  5#~rQN)rNonerwrrr]rz3tuple[etree.Element | None, int | None, int | None])r`rarbrcr[rjrk EM_STRONG_RErlrm STRONG_EM_RE STRONG_EM3_RE STRONG_RE EMPHASIS_RErrr r rrrxrerQrOrJrJsQ ZRZZ bii"**.DExQ\]ZRZZ bii"**.DExQ\]ZRZZ ryy2::/EF S^_ZRZZ 299rzz+ABHhWZRZZ RYY-CDhPTU HP  >#@5rQrJc eZdZdZeej eejejzddeej e ejejzddeej e ejejzddeej e ejejzddeej e ejejzddgZy ) rKzIEmphasis processor for handling strong and em matches inside underscores.rrrrrrrN)r`rarbrcr[rjrk EM_STRONG2_RErlrm STRONG_EM2_RESMART_STRONG_EM_RESMART_STRONG_RESMART_EMPHASIS_RErrerQrOrKrKsS ZRZZ ryy2::/EFR]^ZRZZ ryy2::/EFR]^ZRZZ 2BII 4JKYXcdZRZZRZZ1GH(T\]ZRZZ 1299rzz3IJHVZ[ HPrQrKceZdZdZej dej ejzZej dZ ddZ dZ dZ y) r7z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\sc2|j||jd\}}}|sy|j||\}}}}|sytjd}||_|j d|||j d|||jd|fS)zS Return an `a` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. rNNNahreftitle)getTextrgetLinkrrrsetr) rprwrrrhandledr.r/rs rOrxzLinkInlineProcessor.handleMatchs#||D!%%(;eW#&*ll4&?#eUG# ]]3  vt   FF7E "1771:u$$rQc d}d}d}|jj||}|rm|jdr\|jdddj}|jdr|jddd}|j d}d }nc|r`d}d}|j } | }d} d} d} d} d}d}d}d}d}t |t |D]}||}|d k(r|s|dz }n~|dkDry|dz}ns|d k(r4| dk7r| |k(s |dk7r||k(rd}nW|s|dz}nO|dkDrJ|dz}|dk(r@|dz} n:|d vr6| sd }|}d}|dz} |} n&|| k7r |s|dz}|}n|| k(r|dz} n |r ||k(r|dz}|dz }|dk(r^| dk\r%| |k(r || | dz }dj|| | dz }n2|dk\r%||k(r || |dz }dj|||dz }n|| |dz }n |d k7s|}|dk7r|dk(r || | dz }| }d}|dk(}|B|jjd t|j|j}|j|j}||||fS)z?Parse data between `()` of `[Text]()` allowing recursive `()`. rNFrrrUrrT())rTrS ) RE_LINKrrrrrangerrRE_TITLE_CLEANrrYr)rprrr.r/r3rw bracket_countbacktrack_count start_index last_bracketquote start_quote exit_quoteignore_matches alt_quotestart_alt_quoteexit_alt_quoterrcs rOr1zLinkInlineProcessor.getLinks LL  t  / 771:a#))+Dwwqz 1R(EE!HEG MO%%'KELEKJ"NI ONDUCI.; I8*%* (1,'1,#X$r)etmSUAUZcgkZk() +%* (1,'1,*a/+019L*_ *.*7() &+ai !eI*/!)$% e%*QY "qI~). !A%!Q5D=#K a@ "[a(H I'1,d1B#K!0CD "_^a=O(P Q#K :8Dw; B!o&:K q(89$ ! #q(G  ''++Cu{{}9U1VWE}}T"((*UE7**rQcd}g}t|t|D]9}||}|dk(r|dz}n |dk(r|dz }|dz }|dk(rn|j|;dj|||dk(fS)zsParse the content between `[]` of the start of an image or link resolving nested square brackets. r][rr)r:rrr)rprrr<rrrGs rOr0zLinkInlineProcessor.getText<s  D * CS ACx" c" QJE! KKN wwt}e]a%777rQNr) r`rarbrcrjrkrlrmr9r;rxr1r0rerQrOr7r7sL7bjjRTVT]T]`b`j`jTjkGRZZ&N%*r+h8rQr7ceZdZdZddZy)r9z. Return a `img` element from the given match. cf|j||jd\}}}|sy|j||\}}}}|sytjd}|j d|||j d||j d|j |||jd|fS)zU Return an `img` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. rr,imgsrcr/alt)r0rr1rrr2rr) rprwrrrr3rNr/rs rOrxz ImageInlineProcessor.handleMatchSs#||D!%%(;eW#%)\\$%>"UE7# ]]5 ! uc   FF7E " udmmD)*1771:u$$rQNrrrerQrOr9r9Ps 8%rQr9ceZdZdZej dej Zej dejejzZ ddZ dZ d dZ y) r5z6 Match to a stored reference and return link element. z\s+z\s?\[([^\]]*)\]c|j||jd\}}}|sy|j|||\}}}|sy|jj d|}||j j vrd|jd|fS|j j |\}} |j|| ||jd|fS)zz Return [`Element`][xml.etree.ElementTree.Element] returned by `makeTag` method or `(None, None, None)`. rr,r8N) r0revalIdNEWLINE_CLEANUP_RErrL referencesrmakeTag) rprwrrrr3rrr.r/s rOrxz$ReferenceInlineProcessor.handleMatchns $||D!%%(;eW#;;tUD9C# $ $ ( (b 1 TWW'' 'S( (gg((, e||D%. C??rQc|jj||}|sd|dfS|jdj}|j d}|s|j}||dfS)z\ Evaluate the id portion of `[ref][id]`. If `[ref][]` use `[ref]`. r5NFrrT)r9rrlowerr)rprrrrwrrs rOrRzReferenceInlineProcessor.evalIdsj LL  t  /% %!!#B%%(CZZ\3}rQctjd}|jd||r|jd|||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. r-r.r/)rrr2rrpr.r/rrs rOrUz ReferenceInlineProcessor.makeTags; ]]3  vt  FF7E " rQNrr.r]r/r]rr]rr)r`rarbrcrjrk MULTILINErSrlrmr9rxrRrUrerQrOr5r5hsL@#FBLL9bjj+RYY-CDG@, rQr5ceZdZdZdZy)r=z%Short form of reference: `[google]`. c(|j|dfSzEvaluate the id of `[ref]`. TrWrprrrs rOrRz$ShortReferenceInlineProcessor.evalIdzz|UD((rQNr`rarbrcrRrerQrOr=r=s /)rQr=ceZdZdZddZy)r;z7 Match to a stored reference and return `img` element. ctjd}|jd||r|jd||jd|j||S)z= Return an `img` [`Element`][xml.etree.ElementTree.Element]. rMrNr/rO)rrr2rrYs rOrUz%ImageReferenceInlineProcessor.makeTagsK ]]5 ! ud  FF7E " udmmD)* rQNrZ)r`rarbrcrUrerQrOr;r;s ArQr;ceZdZdZdZy)r>z* Short form of image reference: `![ref]`. c(|j|dfSr^r_r`s rOrRz)ShortImageReferenceInlineProcessor.evalIdrarQNrbrerQrOr>r>s 4)rQr>ceZdZdZddZy)r?zD Return a link Element given an auto-link (``). c$tjd}|jd|j|j dt j |j d|_||jd|jdfS)zI Return an `a` [`Element`][xml.etree.ElementTree.Element] of `group(1)`. r-r.rr) rrr2rrrrrrrrs rOrxz#AutolinkInlineProcessor.handleMatchsf ]]3  vt}}QWWQZ01##AGGAJ/1771:quuQx''rQNrrrerQrOr?r?s N(rQr?ceZdZdZddZy)rAzW Return a `mailto` link Element given an auto-mail link (``). c >tjd}|j|jd}|j dr|t dd}d}|Dcgc]}|t |}}tjdj||_ d|z}dj|Dcgc]!}tjdt |zz#c}}|jd|||jd |jd fScc}wcc}w) za Return an [`Element`][xml.etree.ElementTree.Element] containing a `mailto` link of `group(1)`. r-rzmailto:Nctjj|}|r djtj |Sdtj |fzS)z=Return entity definition by code, or the code if not defined.z{}{};z%s#%d;)r codepoint2namerrrAMP_SUBSTITUTE)rr&s rOrlz;AutomailInlineProcessor.handleMatch..codepoint2namesH,,006F~~d&9&96BB4#6#6"===rQrz#%d;r.r)rrrrrVrrrrrrrmr2rr) rprwrremailrlletterlettersmailtos rOrxz#AutomailInlineProcessor.handleMatchs ]]3  aggaj)   I &#i./*E >>CC6>#f+.CC##BGGG$45U"4:<*0--f+1&&<= vv1771:quuQx''Dr?rArerQrOrzsJ(*#== %%&!*` \L M  = 7  5:b9cOB, S, V, ?, B9 ? %-` S 5":8 '< =& ; H$ < V (:P?P?f- g- `00.O.&w:((:'+'=#;=YoY2'*)7)*$'/$'NFFR P+ P_8/_8D%.%0525p)$<) $< ))F)(o((o(k&%&sF FF