o mĎi@sdZddlmZddlmZddlmZmZmZm Z ddl Z ddl m m Z ddlmZer5ddlmZdZddZdZ 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-Gd0d1d1e,Z.Gd2d3d3e-Z/Gd4d5d5e-Z0Gd6d7d7e,Z1Gd8d9d9e-Z2Gd:d;d;e1Z3Gdd?d?e-Z5Gd@dAdAe1Z6GdBdCdCe2Z7GdDdEdEe-Z8GdFdGdGe-Z9GdHdIdIe9Z:GdJdKdKe-Z;GdLdMdMe;ZGdRdSdSe=Z?GdTdUdUe?Z@GdVdWdWe-ZAGdXdYdYe-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_CHECKINGAny Collection NamedTupleN)entities)Markdownmdr kwargsrreturnutil.Registry[InlineProcessor]cKsDt}|ttdd|tt|dd|tt|dd|t t |dd|t t |d d |t t|d d |tt|d d|tt|dd|tt|dd|tt|dd|ttddd|tt|dd|tt|dd|ttdd|tddd |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. 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)r r inlinePatternsrOS/home/jeff/fluffinator/venv/lib/python3.10/site-packages/markdown/inlinepatterns.pybuild_inlinepatterns5s0   rQz(?]*)>z<([^<> !]+@[^@<> ]+)>z(<(\/?[a-zA-Z][^<>@ ]*( [^<>]*)?|!--(?:(?!).)*--|[?](?:(?!<[?]|[?]>).)*[?]|!\[CDATA\[(?:(?!).)*\]\])>)z-(&(?:\#[0-9]+|\#x[0-9a-fA-F]+|[a-zA-Z0-9]+);)z \nstringstrcCs8|dr |ds|dr|dr|ddS|S)z#Remove quotes from around a string."'r) startswithendswith)rRrOrOrPdequotes rYc@s*eZdZUdZded<ded<ded<dS) EmStrongItemzEmphasis/strong pattern item.re.Pattern[str]patternrSbuildertagsN)__name__ __module__ __qualname____doc____annotations__rOrOrOrPrZs  rZc@sfeZdZUdZeZded< ded<ded<ddd d ZdddZdddZ dddZ d ddZ 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_reMarkdown | Noner Nr\rScCs*||_td|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\recompileDOTALLUNICODErfr selfr\r rOrOrP__init__s    zPattern.__init__r re.PatterncCs|jS)z' Return a compiled regular expression. )rfrmrOrOrPgetCompiledRegExpszPattern.getCompiledRegExpm re.Match[str]etree.Element | strcCdS)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. NrOrmrrrOrOrP handleMatchs zPattern.handleMatchcCs|jjS)z+ Return class name, to define pattern type ) __class__r_rprOrOrPtypesz Pattern.typetextcsDz |jjdjWn ty|YSwfdd}tj||S)> Return unescaped text given text with an inline placeholder. inlinecs<|d}|vr|}t|tr|Sd|SdS)Nr)groupget isinstancerSjoinitertextrridvaluestashrOrP get_stashs   z#Pattern.unescape..get_stashr treeprocessors stashed_nodesKeyErrorrINLINE_PLACEHOLDER_REsubrmrzrrOrrPunescapes   zPattern.unescapeNr\rSr rg)r ro)rrrsr rt)r rSrzrSr rS) r_r`rarbtuplerercrnrqrwryrrOrOrOrPrds     rdc@s&eZdZdZddddZdddZdS)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__rrrsdatar 9tuple[etree.Element | str | None, int | None, int | None]cCru)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. NrOrmrrrrOrOrPrw5szInlineProcessor.handleMatchrr)rrrsrrSr rr_r`rarbrnrwrOrOrOrPrs rc@eZdZdZd ddZdS) SimpleTextPatternz2 Return a simple text of `group(2)` of a Pattern. rrrsr rScCs |dS)z< Return string content of `group(2)` of a matching pattern. )r~rvrOrOrPrwMs zSimpleTextPattern.handleMatchNrrrsr rSr_r`rarbrwrOrOrOrPrKrc@eZdZdZd dd Zd S) rJz2 Return a simple text of `group(1)` of a Pattern. rrrsrrSr tuple[str, int, int]cCs|d|d|dfS)z< Return string content of `group(1)` of a matching pattern. rr)r~startendrrOrOrPrwTsz%SimpleTextInlineProcessor.handleMatchNrrrsrrSr rrrOrOrOrPrJRrrJc@r) r5z Return an escaped character. rrrsrrSr tuple[str | None, int, int]cCsT|d}||jjvrdtjt|tj|d| dfSd|d| dfS)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_CHARSformatrSTXordETXrr)rmrrrcharrOrOrPrw\s (z!EscapeInlineProcessor.handleMatchN)rrrsrrSr rrrOrOrOrPr5Yr5c@s$eZdZdZdddZdd d Zd S)SimpleTagPatternz] Return element of type `tag` with a text attribute of `group(3)` of a Pattern. r\rStagcCt||||_dS)z Create an instant of an simple tag pattern. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rdrnrrmr\rrOrOrPrnr 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. )etreeElementrr~rz)rmrrelrOrOrPrws  zSimpleTagPattern.handleMatchNr\rSrrSrrrsr rrrOrOrOrPrl  rc@s$eZdZdZdddZdd d ZdS)SimpleTagInlineProcessorz] Return element of type `tag` with a text attribute of `group(2)` of a Pattern. r\rSrcCr)z Create an instant of an simple tag processor. Arguments: pattern: A regular expression that matches a pattern. tag: Tag of element. N)rrnrrrOrOrPrnrz!SimpleTagInlineProcessor.__init__rrrsrr tuple[etree.Element, int, int]cCs.t|j}|d|_||d|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)rrrr~rzrrrmrrrrrOrOrPrws  z$SimpleTagInlineProcessor.handleMatchNrrrrsrrSr rrrOrOrOrPrrrc@r) SubstituteTagPattern3 Return an element of type `tag` with no children. rrrsr rcCs t|jS)H Return empty [`Element`][xml.etree.ElementTree.Element] of type `tag`. )rrrrvrOrOrPrws z SubstituteTagPattern.handleMatchNrrrOrOrOrPrrrc@r) rErrrrsrrSr rcCst|j|d|dfS)rr)rrrrrrrOrOrPrwsz(SubstituteTagInlineProcessor.handleMatchNrrrOrOrOrPrErrEc@s$eZdZdZdddZdd d Zd S)r3zA Return a `` element containing the escaped matching text. r\rScCs.t||dtjtdtj|_d|_dS)Nr\code) rrnrrrrrESCAPED_BSLASHr)rmr\rOrOrPrns z BacktickInlineProcessor.__init__rrrsrr $tuple[etree.Element | str, int, int]cCsn|dr$t|j}tt|d|_|| d| dfS|d d|j | d| dfS)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\\) r~rrrr AtomicString code_escapestriprzrrreplacerrrOrOrPrws &z#BacktickInlineProcessor.handleMatchN)r\rS)rrrsrrSr rrrOrOrOrPr3s r3c@r) DoubleTagPatternfReturn a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. rrrsr rcCsR|jd\}}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) rsplitrr SubElementr~rzlengroupstail)rmrrtag1tag2el1el2rOrOrPrws    zDoubleTagPattern.handleMatchNrrrOrOrOrPrrc@r) DoubleTagInlineProcessorrrrrsrrSr rcCsd|jd\}}t|}t||}|d|_t|dkr'|d|_ || d| dfS)z Return [`Element`][xml.etree.ElementTree.Element] in following format: `group(2)group(3)` where `group(3)` is optional. rrrr) rrrrrr~rzrrrrr)rmrrrrrrrrOrOrPrws    z$DoubleTagInlineProcessor.handleMatchNrrrOrOrOrPrrrc@s.eZdZdZddd Zdd d Zdd dZdS)rGz1 Store raw inline html and return a placeholder. rrrsrrSr rcCs:|||d}|jj|}||d|dfS)zL Store the text of `group(1)` of a pattern and return a placeholder string. rr)backslash_unescaperr~r htmlStashstorerr)rmrrrrawhtml place_holderrOrOrPrwszHtmlInlineProcessor.handleMatchrzcsHz jjdjWn ty|YSwd fdd }tj||S) r{r|rrrsr rScsP|d}|}|dur&z j|WSty%d|YSwdS)Nrz\%s)r~rrr serializer ExceptionrrmrrOrPrs    z/HtmlInlineProcessor.unescape..get_stashNrrrrOrrPrs  zHtmlInlineProcessor.unescapecCs@z |jjdj}Wn ty|YSwd dd}|||S) zG Return text with backslash escapes undone (backslashes are restored). rrrrsr rScSstt|dS)Nr)chrintr~)rrrOrOrP _unescapesz9HtmlInlineProcessor.backslash_unescape.._unescapeNr)r rRErr)rmrzrrrOrOrPrs   z&HtmlInlineProcessor.backslash_unescapeNrr)r_r`rarbrwrrrOrOrOrPrGs   rGc @seZdZdZeeeejej Bddeee ejej Bddeee ejej Bddeee ejej Bddeee ejej BddgZ d'ddZd(ddZd(ddZd)ddZd*d!d"Zd+d$d%Zd&S),rLzGEmphasis processor for handling strong and em matches inside asterisks.double strong,em em,strongdouble2singlestrongemrrrsrrSidxrr rcCs(t|}|d}|||d||S)zReturn single tag.rN)rrr~parse_sub_patterns)rmrrrrrrzrOrOrP build_single+s  zAsteriskProcessor.build_singler^c Cst|d\}}t|}t|}|d}|||d|||t|dkr8|d}||||||S)zReturn double tag.rrNr)rrrr~rappendrr rmrrr^rrrrrrzrOrOrP build_double2s     zAsteriskProcessor.build_doublec Csd|d\}}t|}t|}|d}|||d||d}|||||d||S)zFReturn double tags (variant 2): `text text`.rrNr)rrrr~rrrrOrOrP build_double2@s     zAsteriskProcessor.build_double2rparentlastetree.Element | NoneNonecCsd}d}t|}||krl|j||rdd}t|jD]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)rrfmatch enumeratePATTERNSr\rrrz build_elementr]r^rr)rmrrrroffsetposlengthmatchedindexitemrrrzrrOrOrPrMsB  #  z$AsteriskProcessor.parse_sub_patternsr]rcCs:|dkr ||||S|dkr||||S||||S)zElement builder.rr)rrr)rmrrr]r^rrOrOrPrs zAsteriskProcessor.build_element3tuple[etree.Element | None, int | None, int | None]c Csnd}d}d}t|jD]&\}}|j||d}|r1|d}|d}|||j|j|}nq |||fS)zParse patterns.Nr) rrr\rrrrr]r^) rmrrrrrrrrm1rOrOrPrws   zAsteriskProcessor.handleMatchN)rrrsrrSrrr r)rrrsr^rSrrr r) rrSrrrrrrr r) rrrsr]rSr^rSrrr rrrrsrrSr r)r_r`rarbrZrhri EM_STRONG_RErjrk STRONG_EM_RE STRONG_EM3_RE STRONG_RE EMPHASIS_RErrrrrrrwrOrOrOrPrLs    = rLc @seZdZdZeeeejej Bddeee ejej Bddeee ejej Bddeee ejej Bddeee ejej BddgZd S) rMzIEmphasis processor for handling strong and em matches inside underscores.rrrrrrrN)r_r`rarbrZrhri EM_STRONG2_RErjrk STRONG_EM2_RESMART_STRONG_EM_RESMART_STRONG_RESMART_EMPHASIS_RErrOrOrOrPrMsrMc@sLeZdZdZedejejBZedZ dd d Z dddZ dddZ dS)r9z- Return a link element from the given match. z2\(\s*(?:(<[^<>]*>)\s*(?:('[^']*'|"[^"]*")\s*)?\))?z\srrrsrrSr rc Cs||||d\}}}|sdS|||\}}}}|sdStd}||_|d||dur6|d|||d|fS)zS Return an `a` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. rNNNahrefNtitle)getTextrgetLinkrrrzsetr) rmrrrrzrhandledrrrrOrOrPrws   zLinkInlineProcessor.handleMatchrr!tuple[str, str | None, int, bool]cCsd}d}d}|jj||d}|r7|dr7|ddd}|dr.|ddd}|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||krd}nK|s|d8}nD|dkr|d8}|dkr|d} n3|d vr| sd }|}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}NFrrrVrrT())rUrT ) RE_LINKrr~rrrangerrRE_TITLE_CLEANrrYr)rmrrrrrrr bracket_countbacktrack_count start_index last_bracketquote start_quote exit_quoteignore_matches alt_quotestart_alt_quoteexit_alt_quoterrcrOrOrPrs            zLinkInlineProcessor.getLinktuple[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})rrrr)rmrrr rzrr+rOrOrPr@s  zLinkInlineProcessor.getTextNr)rrSrrr r)rrSrrr r,) r_r`rarbrhrirjrkrrrwrrrOrOrOrPr9s   tr9c@r) r;z. Return a `img` element from the given match. rrrsrrSr rc Cs|||d\}}}|sdS|||\}}}}|sdStd}|d||dur3|d||d||||d|fS)zU Return an `img` [`Element`][xml.etree.ElementTree.Element] or `(None, None, None)`. rrimgsrcNralt)rrrrrrrr) rmrrrrzrrr0rrrOrOrPrwWs   z ImageInlineProcessor.handleMatchNrrrOrOrOrPr;Trr;c@sPeZdZdZedejZedejej BZ dd d Z dddZ dddZ dS)r7z6 Match to a stored reference and return link element. z\s+z\s?\[([^\]]*)\]rrrsrrSr rc Cs|||d\}}}|sdS||||\}}}|sdS|jd|}||jjvr3d|d|fS|jj|\}} ||| ||d|fS)zz Return [`Element`][xml.etree.ElementTree.Element] returned by `makeTag` method or `(None, None, None)`. rrrN) rrevalIdNEWLINE_CLEANUP_RErr referencesrmakeTag) rmrrrrzrrrrrrrOrOrPrwrs z$ReferenceInlineProcessor.handleMatchrrrztuple[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)rrr~lowerr)rmrrrzrrrrrOrOrPr2s   zReferenceInlineProcessor.evalIdrrrcCs0td}|d||r|d|||_|S)z; Return an `a` [`Element`][xml.etree.ElementTree.Element]. rrr)rrrrzrmrrrzrrOrOrPr5s   z ReferenceInlineProcessor.makeTagNr)rrSrrrzrSr r6rrSrrSrzrSr r)r_r`rarbrhri MULTILINEr3rjrkrrwr2r5rOrOrOrPr7ls  r7c@eZdZdZd d d Zd S) r?z%Short form of reference: `[google]`. rrSrrrzr r,cC||dfSzEvaluate the id of `[ref]`. Tr7rmrrrzrOrOrPr2z$ShortReferenceInlineProcessor.evalIdNrrSrrrzrSr r,r_r`rarbr2rOrOrOrPr?rr?c@r) r=z7 Match to a stored reference and return `img` element. rrSrrzr rcCs<td}|d||r|d||d|||S)z= Return an `img` [`Element`][xml.etree.ElementTree.Element]. r/r0rr1)rrrrr8rOrOrPr5s   z%ImageReferenceInlineProcessor.makeTagNr9)r_r`rarbr5rOrOrOrPr=rr=c@r;) r@z* Short form of image reference: `![ref]`. rrSrrrzr r,cCr<r=r>r?rOrOrPr2r@z)ShortImageReferenceInlineProcessor.evalIdNrArBrOrOrOrPr@rr@c@r) rAzD Return a link Element given an auto-link (``). rrrsrrSr rcCsJtd}|d||dt|d|_||d| dfS)zI Return an `a` [`Element`][xml.etree.ElementTree.Element] of `group(1)`. rrrr) rrrrr~rrrzrrrrOrOrPrws z#AutolinkInlineProcessor.handleMatchNrrrOrOrOrPrArrAc@r) rCzW Return a `mailto` link Element given an auto-mail link (``). rrrsrrSr rcstd}||d}|dr|tdd}dd d fd d |D}td ||_ d|}d dd |D}| d||| d| dfS)za Return an [`Element`][xml.etree.ElementTree.Element] containing a `mailto` link of `group(1)`. rrzmailto:Nrrr rScSs,tj|}|rdtj|Sdtj|fS)z=Return entity definition by code, or the code if not defined.z{}{};z%s#%d;)r codepoint2namerrrAMP_SUBSTITUTE)rr(rOrOrPrCs z;AutomailInlineProcessor.handleMatch..codepoint2namecsg|]}t|qSrO)r.0letterrCrOrP sz7AutomailInlineProcessor.handleMatch..r}cSsg|] }tjdt|qS)z#%d;)rrDrrErOrOrPrIs  rr)rrr rS) rrrr~rWrrrrrzrrr)rmrrrremaillettersmailtorOrHrPrws     z#AutomailInlineProcessor.handleMatchNrrrOrOrOrPrCsrC)r r r rr r)rRrSr rS)Crb __future__rr}rtypingrrrrrhxml.etree.ElementTreer ElementTreer&r markdownr rQNOIMGr4r6r r rrr rr rr rr:r<r8r>rKrBrDrHrIrFrYrZrdrrrJr5rrrrEr3rrrGrLrMr9r;r7r?r=r@rArCrOrOrOrPs     0   V0( #8