/Vh: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,Z.Gd(d)e-Z/Gd*d+e-Z0Gd,d-e,Z1Gd.d/e-Z2Gd0d1e1Z3Gd2d3e2Z4Gd4d5e-Z5Gd6d7e1Z6Gd8d9e2Z7Gd:d;e-Z8Gd<d=e-Z9Gd>d?e9Z:Gd@dAe-Z;GdBdCe;Z<GdDdEe;Z=GdFdGe=Z>GdHdIe=Z?GdJdKe?Z@GdLdMe-ZAGdNdOe-ZBy)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 G/home/dcms/DCMS/lib/python3.12/site-packages/markdown/inlinepatterns.pybuild_inlinepatternsrP5s&]]_N3K@*cR1)R@(CP4\2F UXY/"M5mDlTVW-e4k2F/5|RH z(?]*)>z<([^<> !]+@[^@<> ]+)>z(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!).)*--|[?](?:(?!<[?]|[?]>).)*[?]|!\[CDATA\[(?:(?!).)*\]\])>)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.re.Pattern[str]patternstrbuildertagsN)__name__ __module__ __qualname____doc____annotations__rQrOr[r[s'  L IrQr[cjeZdZUdZeZded< ded<ded<ddd Zdd Zdd Z dd Z 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_EXCLUDESr\ compiled_reMarkdown | NonerLNc||_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]recompileDOTALLUNICODErjrLselfr]rLs rO__init__zPattern.__init__s= ::&6&@&(ii"**&<>rQc|jS)z' Return a compiled regular expression. )rjrrs 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. Nrfrrms rO handleMatchzPattern.handleMatchs rQc.|jjS)z+ Return class name, to define pattern type ) __class__rarus 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)ryidvaluestashs rO get_stashz#Pattern.unescape..get_stashsPBU{ " eS) L775>>#344 rQrLtreeprocessors stashed_nodesKeyErrorrINLINE_PLACEHOLDER_REsubrrtextrrs @rOunescapezPattern.unescapesX GG**84BBE 5))--i>> K s#A AANr]r^rLrk)returnz re.Pattern)ry re.Match[str]rzetree.Element | str)rr^rr^rr^) rarbrcrdtuplerirersrvrzr}rrfrQrOrhrhsB&*/0 ! "   '?rQrhc"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]rmrnrorprj safe_moderLrqs rOrszInlineProcessor.__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. Nrfrrrydatas rOrzzInlineProcessor.handleMatch5s& rQrr)ryrrr^rz9tuple[etree.Element | str | None, int | None, int | None]rarbrcrdrsrzrfrQrOrrs" 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. )rrxs rOrzzSimpleTextPattern.handleMatchMswwqzrQNryrrr^rarbrcrdrzrfrQrOrrKs <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 rOrzz%SimpleTextInlineProcessor.handleMatchTs'wwqz1771:quuQx//rQNryrrr^rztuple[str, int, int]rrfrQrOrHrHRs <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)rrryrchars rOrzz!EscapeInlineProcessor.handleMatch\swwwqz 477(( (??488SYA1771:quuUVxW WQUU1X- -rQN)ryrrr^rztuple[str | None, int, int]rrfrQrOr3r3Ys ( .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)rhrstagrrr]rs rOrszSimpleTagPattern.__init__rs 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)rrryels rOrzzSimpleTagPattern.handleMatchs* ]]488 $''!* rQNr]r^rr^ryrr etree.ElementrrfrQrOrrls 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)rrsrrs rOrsz!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)rrrrrrrrrryrrs rOrzz$SimpleTagInlineProcessor.handleMatchsB ]]488 $''!*1771:quuQx''rQNrryrrr^rztuple[etree.Element, int, int]rrfrQrOrrs 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`. )rrrrxs rOrzz SubstituteTagPattern.handleMatchs}}TXX&&rQNrrrfrQrOrrs ='rQrceZdZdZddZy)rCrctj|j|jd|j dfS)rr)rrrrrrs rOrzz(SubstituteTagInlineProcessor.handleMatchs,}}TXX& AEE!H<` element containing the escaped matching text. ctj||djtjt dtj |_d|_y)Nr\code) rrsrrrrrESCAPED_BSLASHr)rrr]s rOrsz 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 rOrzz#BacktickInlineProcessor.handleMatchs 771:txx(B''(8(89I9I9K(LMBGqwwqz1558+ +771:%%fd.A.ABAGGAJPQPUPUVWPXX XrQN)r]r^)ryrrr^rz$tuple[etree.Element | str, int, int]rrfrQrOr1r1sK1 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)rrrytag1tag2el1el2s rOrzzDoubleTagPattern.handleMatchso XX^^C( dmmD!sD)771: qxxz?a wwqzCH rQNrrrfrQrOrrs  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)rrryrrrrrs rOrzz$DoubleTagInlineProcessor.handleMatchs XX^^C( dmmD!sD)771: qxxz?a wwqzCHAGGAJa((rQNrrrfrQrOrrs  )rQrc(eZdZdZddZddZddZy)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)rrryrrawhtml place_holders rOrzzHtmlInlineProcessor.handleMatchsZ))$-- *CDww((..w7 QWWQZq11rQc jjdjdfd }tj j ||S#t$r|cYSwxYw)rrc|jd}j|}| jj|Sy#t$rd|zcYSwxYw)Nrz\%s)rrrL serializer Exception)ryrrrrrs rOrz/HtmlInlineProcessor.unescape..get_stashs]BIIbME *77--e44!!*!E>)*sAAArrrs` @rOrzHtmlInlineProcessor.unescapesX GG**84BBE *))--i>> K s#A AAc |jjdj}dd}|j ||S#t$r|cYSwxYw)zG Return text with backslash escapes undone (backslashes are restored). rcHtt|jdS)Nr)chrintr)rys rO _unescapez9HtmlInlineProcessor.backslash_unescape.._unescapess1771:' 'rQr)rLrRErr)rrrrrs rOrz&HtmlInlineProcessor.backslash_unescapesO '' 366B (vvi&&  K s#; A A Nrr)rarbrcrdrzrrrfrQrOrErEs;2 ?$ 'rQrEc DeZdZdZeej eejejzddeej e ejejzddeej e ejejzddeej e ejejzddeej e ejejzddgZ dd Zdd Zdd Z dd Zdd 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)rrryridxrrs 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 rrryr`r rrrrrs rO build_doublezAsteriskProcessor.build_double1sZZ_ 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)rrrrrr r s rO build_double2zAsteriskProcessor.build_double2?sZZ_ 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`: 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)rrjmatch enumeratePATTERNSr]rrr build_elementr_r`r r)rrrparentlastr offsetposlengthmatchedindexitemryrrs rOrz$AsteriskProcessor.parse_sub_patternsLs8TFl%%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)rrr )rrryr_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`) rrryrrrrrrm1s rOrzzAsteriskProcessor.handleMatchs$T]]3 KE4##D!''!*5B ffQi''DLL$))UK  5#~rQN)ryrrr^r rrr)ryrr`r^r rrr) rr^rrrzetree.Element | Noner rrNone) ryrr_r^r`r^rrrrryrrr^rz3tuple[etree.Element | None, int | None, int | None])rarbrcrdr[rmrn EM_STRONG_RErorp STRONG_EM_RE STRONG_EM3_RE STRONG_RE EMPHASIS_RErr rrrrrzrfrQrOrJrJsQ ZRZZ bii"**.DExQ\]ZRZZ bii"**.DExQ\]ZRZZ ryy2::/EF S^_ZRZZ 299rzz+ABHhWZRZZ RYY-CDhPTU HP  ;#;#!.;#6J;#QT;# ;#z5rQrJc eZdZdZeej eejejzddeej e ejejzddeej e ejejzddeej e ejejzddeej e ejejzddgZy ) rKzIEmphasis processor for handling strong and em matches inside underscores.rrrrrrrN)rarbrcrdr[rmrn EM_STRONG2_RErorp STRONG_EM2_RESMART_STRONG_EM_RESMART_STRONG_RESMART_EMPHASIS_RErrfrQrOrKrKsS ZRZZ ryy2::/EFR]^ZRZZ ryy2::/EFR]^ZRZZ 2BII 4JKYXcdZRZZRZZ1GH(T\]ZRZZ 1299rzz3IJHVZ[ HPrQrKceZdZdZej dej ejzZej dZ ddZ d dZ d 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) rrryrrrhandledr2r3rs rOrzzLinkInlineProcessor.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)rrrrr2r3r7ry bracket_countbacktrack_count start_index last_bracketquote start_quote exit_quoteignore_matches alt_quotestart_alt_quoteexit_alt_quoterrcs rOr5zLinkInlineProcessor.getLinks  LL  t  / 771:a#))+Dwwqz 1R(EE!HEG MO%%'KEL!%EKJ"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>rr r)rrrrr@rrrKs rOr4zLinkInlineProcessor.getText?s  D * CS ACx" c" QJE! KKN wwt}e]a%777rQNr")rr^rrrz!tuple[str, str | None, int, bool])rr^rrrtuple[str, int, bool]) rarbrcrdrmrnrorpr=r?rzr5r4rfrQrOr7r7sL7bjjRTVT]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)`. rr0imgsrcr3alt)r4rr5rrr6rr) rrryrrrr7rSr3rs rOrzz ImageInlineProcessor.handleMatchVs#||D!%%(;eW#%)\\$%>"UE7# ]]5 ! uc   FF7E " udmmD)*1771:u$$rQNr"rrfrQrOr9r9Ss 8%rQr9ceZdZdZej dej Zej dejejzZ ddZ d 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)`. rr0r<N) r4revalIdNEWLINE_CLEANUP_RErrL referencesrmakeTag) rrryrrrr7rrr2r3s rOrzz$ReferenceInlineProcessor.handleMatchqs $||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]`. r9NFrrT)r=rrlowerr)rrrrrryrrs rOrWzReferenceInlineProcessor.evalIdsj LL  t  /% %!!#B%%(CZZ\3}rQctjd}|jd||r|jd|||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. r1r2r3)rrr6rrrr2r3rrs rOrZz ReferenceInlineProcessor.makeTags; ]]3  vt  FF7E " rQNr")rr^rrrr^rztuple[str | None, int, bool]r2r^r3r^rr^rr)rarbrcrdrmrn MULTILINErXrorpr=rzrWrZrfrQrOr5r5ksL@#FBLL9bjj+RYY-CDG@, rQr5ceZdZdZddZy)r=z%Short form of reference: `[google]`. c(|j|dfSzEvaluate the id of `[ref]`. Tr\rrrrrs rOrWz$ShortReferenceInlineProcessor.evalIdzz|UD((rQNrr^rrrr^rrOrarbrcrdrWrfrQrOr=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]. rRrSr3rT)rrr6rr^s rOrZz%ImageReferenceInlineProcessor.makeTagsK ]]5 ! ud  FF7E " udmmD)* rQNr_)rarbrcrdrZrfrQrOr;r;s ArQr;ceZdZdZddZy)r>z* Short form of image reference: `![ref]`. c(|j|dfSrcrdres rOrWz)ShortImageReferenceInlineProcessor.evalIdrfrQNrgrhrfrQrOr>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)`. r1r2rr) rrr6rrrrrrrrs rOrzz#AutolinkInlineProcessor.handleMatchsf ]]3  vt}}QWWQZ01##AGGAJ/1771:quuQx''rQNrrrfrQrOr?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 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)`. r1rzmailto: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 rOrrz;AutomailInlineProcessor.handleMatch..codepoint2namesH,,006F~~d&9&96BB4#6#6"===rQrz#%d;r2r)rrrr^)rrrrrVrrrrrrrsr6rr) rrryrremailrrletterlettersmailtos rOrzz#AutomailInlineProcessor.handleMatchs ]]3  aggaj)   I &#i./*E >>CC6>#f+.CC##BGGG$45U"4:<*0--f+1&&<= vv1771:quuQx''Dr?rArfrQrOr~s5(*#== %%!*` \L M  = 7  5:b9cOB, S, V, ?, B9 ? %-` S 5":8 '< =& ; % < V (:S?S?l- g- `00.O.&w:((:'+'=#;=YoY2'*)7)*$'/$'NCCL P+ P_8/_8D%.%0525p)$<) $< ))F)(o((o(rQ