ó
    "nj…i  ã                  ó¬  • S r SSKJr  SSKrSSKrSSKJs  Jr  SSKJ	r	J
r
  SSKJr  SSKJr  \	(       a  SSKJr  \R"                  " S	5      rS#S
 jr " S S5      r " S S\5      r " S S\5      r " S S\5      r " S S\5      r " S S\5      r " S S\5      r " S S\5      r " S S\5      r " S S\5      r " S S \5      r " S! S"\5      rg)$a;  
A block processor parses blocks of text and adds new elements to the ElementTree. Blocks of text,
separated from other text by blank lines, may have a different syntax and produce a differently
structured tree than other Markdown. Block processors excel at handling code formatting, equation
layouts, tables, etc.
é    )ÚannotationsN)ÚTYPE_CHECKINGÚAnyé   )Úutil)ÚBlockParser)ÚMarkdownÚMARKDOWNc                ó`  • [        U 5      nUR                  R                  [        U5      SS5        UR                  R                  [	        U5      SS5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      S	S
5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      SS5        UR                  R                  [        U5      SS5        U$ )z1Build the default block parser used by Markdown. Úemptyéd   ÚindentéZ   ÚcodeéP   Ú
hashheaderéF   Úsetextheaderé<   Úhré2   Úolisté(   Úulisté   Úquoteé   Ú	referenceé   Ú	paragraphé
   )r   ÚblockprocessorsÚregisterÚEmptyBlockProcessorÚListIndentProcessorÚCodeBlockProcessorÚHashHeaderProcessorÚSetextHeaderProcessorÚHRProcessorÚOListProcessorÚUListProcessorÚBlockQuoteProcessorÚReferenceProcessorÚParagraphProcessor)ÚmdÚkwargsÚparsers      Ú:/usr/lib/python3/dist-packages/markdown/blockprocessors.pyÚbuild_block_parserr3   *   sX  € ä˜‹_€FØ
×Ñ×#Ñ#Ô$7¸Ó$?ÀÈ#ÔNØ
×Ñ×#Ñ#Ô$7¸Ó$?ÀÈ2ÔNØ
×Ñ×#Ñ#Ô$6°vÓ$>ÀÈÔKØ
×Ñ×#Ñ#Ô$7¸Ó$?ÀÈrÔRØ
×Ñ×#Ñ#Ô$9¸&Ó$AÀ>ÐSUÔVØ
×Ñ×#Ñ#¤K°Ó$7¸¸rÔBØ
×Ñ×#Ñ#¤N°6Ó$:¸GÀRÔHØ
×Ñ×#Ñ#¤N°6Ó$:¸GÀRÔHØ
×Ñ×#Ñ#Ô$7¸Ó$?ÀÈ"ÔMØ
×Ñ×#Ñ#Ô$6°vÓ$>ÀÈRÔPØ
×Ñ×#Ñ#Ô$6°vÓ$>ÀÈRÔPØ€Mó    c                  ó\   • \ rS rSrSrSS jrSS jrSSS jjrSSS jjrSS jr	SS	 jr
S
rg)ÚBlockProcessoré;   a4  Base class for block processors.

Each subclass will provide the methods below to work with the source and
tree. Each processor will need to define it's own `test` and `run`
methods. The `test` method should return True or False, to indicate
whether the current block should be processed by this processor. If the
test passes, the parser will call the processors `run` method.

Attributes:
    BlockProcessor.parser (BlockParser): The `BlockParser` instance this is attached to.
    BlockProcessor.tab_length (int): The tab length set on the `Markdown` instance.

c                óF   • Xl         UR                  R                  U l        g ©N)r1   r/   Ú
tab_length)Úselfr1   s     r2   Ú__init__ÚBlockProcessor.__init__J   s   € ØŒØ Ÿ)™)×.Ñ.ˆ�r4   c                ó.   • [        U5      (       a  US   $ g)z-Return the last child of an `etree` element. éÿÿÿÿN)Úlen)r;   Úparents     r2   Ú	lastChildÚBlockProcessor.lastChildN   s   € äˆv�;‰;Ø˜"‘:Ðàr4   Nc                ó`  • Uc  U R                   n/ nUR                  S5      nU HY  nUR                  SU-  5      (       a  UR                  XRS 5        M1  UR	                  5       (       d  UR                  S5        MY    O   SR                  U5      SR                  U[        U5      S 5      4$ )z<Remove a tab from the front of each line of the given text. NÚ
Ú Ú )r:   ÚsplitÚ
startswithÚappendÚstripÚjoinr@   )r;   ÚtextÚlengthÚnewtextÚlinesÚlines         r2   ÚdetabÚBlockProcessor.detabU   s”   € à‰>Ø—_‘_ˆFØˆØ—
‘
˜4Ó ˆÛˆDØ�‰˜s V™|×,Ñ,Ø—‘˜t G˜}Ö-Ø—Z‘Z—\‘\Ø—‘˜rÖ"áñ ð �y‰y˜Ó! 4§9¡9¨U´3°w³<°=Ð-AÓ#BÐBÐBr4   c                óü   • UR                  S5      n[        [        U5      5       HC  nX4   R                  SU R                  -  U-  5      (       d  M-  X4   U R                  U-  S X4'   ME     SR                  U5      $ )z>Remove a tab from front of lines but allowing dedented lines. rE   rF   N)rH   Úranger@   rI   r:   rL   )r;   rM   ÚlevelrP   Úis        r2   Ú
looseDetabÚBlockProcessor.looseDetabd   so   € à—
‘
˜4Ó ˆÜ”s˜5“zÖ"ˆAØ‰x×"Ñ" 3 t§¡Ñ#6°uÑ#<×=Ó=Ø ™8 D§O¡O°EÑ$9Ð$:Ð;�“ñ #ð �y‰y˜ÓÐr4   c                ó   • g)aù  Test for block type. Must be overridden by subclasses.

As the parser loops through processors, it will call the `test`
method on each to determine if the given block of text is of that
type. This method must return a boolean `True` or `False`. The
actual method of testing is left to the needs of that particular
block type. It could be as simple as `block.startswith(some_string)`
or a complex regular expression. As the block type may be different
depending on the parent of the block (i.e. inside a list), the parent
`etree` element is also provided and may be used as part of the test.

Keyword arguments:
    parent: An `etree` element which will be the parent of the block.
    block: A block of text from the source which has been split at blank lines.
N© ©r;   rA   Úblocks      r2   ÚtestÚBlockProcessor.testl   s   € ð  	r4   c                ó   • g)aª  Run processor. Must be overridden by subclasses.

When the parser determines the appropriate type of a block, the parser
will call the corresponding processor's `run` method. This method
should parse the individual lines of the block and append them to
the `etree`.

Note that both the `parent` and `etree` keywords are pointers
to instances of the objects which should be edited in place. Each
processor must make changes to the existing objects as there is no
mechanism to return new/different objects to replace them.

This means that this method should be adding `SubElements` or adding text
to the parent, and should remove (`pop`) or add (`insert`) items to
the list of blocks.

If `False` is returned, this will have the same effect as returning `False`
from the `test` method.

Keyword arguments:
    parent: An `etree` element which is the parent of the current block.
    blocks: A list of all remaining blocks of the document.
Nr[   )r;   rA   Úblockss      r2   ÚrunÚBlockProcessor.run~   s   € ð0 	r4   )r1   r:   ©r1   r   )rA   úetree.ElementÚreturnzetree.Element | Noner9   )rM   ÚstrrN   z
int | Nonerf   ztuple[str, str])r   )rM   rg   rV   Úintrf   rg   ©rA   re   r]   rg   rf   Úbool)rA   re   ra   ú	list[str]rf   zbool | None)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r<   rB   rR   rX   r^   rb   Ú__static_attributes__r[   r4   r2   r6   r6   ;   s&   † ñô/ôöCö ô÷$r4   r6   c                  óf   ^ • \ rS rSrSrS/r SS/r U 4S jrSS jrSS jr	SS	 jr
SS
 jrSrU =r$ )r%   é™   zmProcess children of list items.

Example

    * a list item
        process this part

        or this part

ÚliÚulÚolc                óp   >• [         TU ]  " U6   [        R                  " SU R                  -  5      U l        g )Nz^(([ ]{%s})+))Úsuperr<   ÚreÚcompiler:   Ú	INDENT_RE)r;   ÚargsÚ	__class__s     €r2   r<   ÚListIndentProcessor.__init__ª   s*   ø€ Ü‰Ò˜$ÑÜŸšÐ$4°t·±Ñ$FÓGˆ�r4   c                óf  • UR                  SU R                  -  5      =(       a�    U R                  R                  R	                  S5      (       + =(       a\    UR
                  U R                  ;   =(       d<    [        U5      =(       a*    US   S L=(       a    US   R
                  U R                  ;   $ )NrF   Údetabbedr?   )	rI   r:   r1   ÚstateÚisstateÚtagÚ
ITEM_TYPESr@   Ú
LIST_TYPESr\   s      r2   r^   ÚListIndentProcessor.test®   sˆ   € Ø×Ñ  D§O¡OÑ 3Ó4÷ :Ø—‘×!Ñ!×)Ñ)¨*Ó5Ô5÷:à�Z‰Z˜4Ÿ?™?Ñ*÷ 9Ü�V“÷ 8 ¨¡°4Ð!7÷ 8Ø˜B‘Z—^‘^ t§¡Ñ6ð		:r4   c                óð  • UR                  S5      nU R                  X5      u  pEU R                  X45      nU R                  R                  R                  S5        UR                  U R                  ;   al  [        U5      (       a?  US   R                  U R                  ;   a"  U R                  R                  US   U/5        GOU R                  R                  X/5        OòUR                  U R                  ;   a  U R                  R                  XS/5        O»[        U5      (       aš  US   R                  U R                  ;   a}  US   R                  (       aI  [        R                  " S5      nUS   R                  Ul        SUS   l        US   R                  SU5        U R                  R                  US   U5        OU R!                  XS5        U R                  R                  R#                  5         g )Nr   r€   r?   ÚprG   )ÚpopÚ	get_levelrX   r1   r�   Úsetrƒ   r„   r@   r…   ÚparseBlocksrM   ÚetreeÚElementÚinsertÚ
parseChunkÚcreate_itemÚreset)r;   rA   ra   r]   rV   Úsiblingrˆ   s          r2   rb   ÚListIndentProcessor.runµ   so  € Ø—
‘
˜1“ˆØŸ™¨Ó6‰ˆØ—‘ Ó-ˆà�‰×Ñ×Ñ˜jÔ)Ø�:‰:˜Ÿ™Ó(ô �6�{‰{˜v b™zŸ~™~°·±Ó@Ø—‘×'Ñ'¨¨r©
°U°GÖ<ð —‘×'Ñ'¨°Õ8Ø�[‰[˜DŸO™OÓ+à�K‰K×#Ñ# G¨WÕ5Ü��\‰\˜g b™kŸo™o°·±Ó@ð �r‰{××ô —M’M #Ó&�Ø  ™×)Ñ)�”Ø#%�˜‘Ô Ø˜‘×"Ñ" 1 aÔ(Ø�K‰K×"Ñ" 7¨2¡;°Õ6à×Ñ˜WÔ,Ø�‰×Ñ×ÑÕ!r4   c                ój   • [         R                  " US5      nU R                  R                  X2/5        g)z=Create a new `li` and parse the block with it as the parent. rt   N)r�   Ú
SubElementr1   rŒ   )r;   rA   r]   rt   s       r2   r‘   ÚListIndentProcessor.create_itemÙ   s(   € ä×Ò˜f dÓ+ˆØ�‰×Ñ  GÕ,r4   c                óò  • U R                   R                  U5      nU(       a(  [        UR                  S5      5      U R                  -  nOSnU R
                  R                  R                  S5      (       a  SnOSnXE:”  au  U R                  U5      nUbV  UR                  U R                  ;   d  UR                  U R                  ;   a"  UR                  U R                  ;   a  US-  nUnO XQ4$ XE:”  a  Mu  XQ4$ )z.Get level of indentation based on list level. r   r   Úlist)r{   Úmatchr@   Úgroupr:   r1   r�   r‚   rB   rƒ   r…   r„   )r;   rA   r]   ÚmÚindent_levelrV   Úchilds          r2   rŠ   ÚListIndentProcessor.get_levelÞ   s×   € ð �N‰N× Ñ  Ó'ˆÞÜ˜qŸw™w q›z›?¨4¯?©?Ñ:‰LàˆLØ�;‰;×Ñ×$Ñ$ V×,Ñ,à‰Eð ˆEàÓ"Ø—N‘N 6Ó*ˆEØÑ!Ø—	‘	˜TŸ_™_Ó,°·	±	¸T¿_¹_Ó0LØ—9‘9 §¡Ó/Ø˜Q‘J�EØ‘ð Øˆ}Ðð Õ"ð ˆ}Ðr4   )r{   ri   ©rA   re   ra   rk   rf   ÚNone)rA   re   r]   rg   rf   r¡   )rA   re   r]   rg   rf   ztuple[int, etree.Element])rl   rm   rn   ro   rp   r„   r…   r<   r^   rb   r‘   rŠ   rq   Ú__classcell__©r}   s   @r2   r%   r%   ™   s@   ø† ñ	ð �€JØ-Ø˜�€JØ9õHô:ô""ôH-÷
ò r4   r%   c                  ó,   • \ rS rSrSrSS jrSS jrSrg)	r&   éû   zProcess code blocks. c                ó>   • UR                  SU R                  -  5      $ )NrF   )rI   r:   r\   s      r2   r^   ÚCodeBlockProcessor.testþ   s   € Ø×Ñ  D§O¡OÑ 3Ó4Ð4r4   c           	     óÎ  • U R                  U5      nUR                  S5      nSnUb£  UR                  S:X  a“  [        U5      (       aƒ  US   R                  S:X  ap  US   nU R	                  U5      u  pE[
        R                  " SR                  UR                  [
        R                  " UR                  5       5      5      5      Ul        O�[        R                  " US5      n[        R                  " US5      nU R	                  U5      u  pE[
        R                  " S[
        R                  " UR                  5       5      -  5      Ul        U(       a  UR                  SU5        g g )Nr   rG   Úprer   z{}
{}
z%s
)rB   r‰   rƒ   r@   rR   r   ÚAtomicStringÚformatrM   Úcode_escapeÚrstripr�   r–   r�   )r;   rA   ra   r“   r]   ÚtheRestr   r©   s           r2   rb   ÚCodeBlockProcessor.run  s  € Ø—.‘. Ó(ˆØ—
‘
˜1“ˆØˆØÑ G§K¡K°5Ó$8Üˆw�<‰<˜G A™JŸN™N¨fÓ4ð ˜1‘:ˆDØ!ŸZ™Z¨Ó.‰NˆEÜ×)Ò)Ø×!Ñ! $§)¡)¬T×-=Ò-=¸e¿l¹l»nÓ-MÓNóˆD�Iô
 ×"Ò" 6¨5Ó1ˆCÜ×#Ò# C¨Ó0ˆDØ!ŸZ™Z¨Ó.‰NˆEÜ×)Ò)¨&´4×3CÒ3CÀEÇLÁLÃNÓ3SÑ*SÓTˆDŒIÞð �M‰M˜!˜WÕ%ð	 r4   r[   Nri   r    ©rl   rm   rn   ro   rp   r^   rb   rq   r[   r4   r2   r&   r&   û   s   † Ù ô5÷&r4   r&   c                  óZ   • \ rS rSrSr\R                  " S5      rS	S jrS
S jr	SS jr
Srg)r,   i  zProcess blockquotes. z(^|\n)[ ]{0,3}>[ ]?(.*)c                óŒ   • [        U R                  R                  U5      5      =(       a    [        R                  " 5       (       + $ r9   )rj   ÚREÚsearchr   Únearing_recursion_limitr\   s      r2   r^   ÚBlockQuoteProcessor.test!  s+   € Ü�D—G‘G—N‘N 5Ó)Ó*×Q´4×3OÒ3OÓ3QÔ/QÐQr4   c                ó´  • UR                  S5      nU R                  R                  U5      nU(       a~  US UR                  5        nU R                  R                  X/5        SR                  X4R                  5       S  R                  S5       Vs/ s H  o`R                  U5      PM     sn5      nU R                  U5      nUb  UR                  S:X  a  UnO[        R                  " US5      nU R                  R                  R                  S5        U R                  R                  Xƒ5        U R                  R                  R!                  5         g s  snf )Nr   rE   Ú
blockquote)r‰   r³   r´   Ústartr1   rŒ   rL   rH   ÚcleanrB   rƒ   r�   r–   r�   r‹   r�   r’   )	r;   rA   ra   r]   rœ   ÚbeforerQ   r“   r   s	            r2   rb   ÚBlockQuoteProcessor.run$  s  € Ø—
‘
˜1“ˆØ�G‰G�N‰N˜5Ó!ˆÞØ˜:˜AŸG™G›IÐ&ˆFà�K‰K×#Ñ# F¨HÔ5à—I‘IØ.3·G±G³I°JÐ.?×.EÑ.EÀdÔ.KÓLÒ.K d—‘˜DÖ!Ñ.KÑLóˆEð —.‘. Ó(ˆØÑ 7§;¡;°,Ó#>à‰Eô ×$Ò$ V¨\Ó:ˆEð 	�‰×Ñ×Ñ˜lÔ+Ø�‰×Ñ˜uÔ,Ø�‰×Ñ×ÑÕ!ùò Ms   ÂEc                ó–   • U R                   R                  U5      nUR                  5       S:X  a  gU(       a  UR                  S5      $ U$ )z%Remove `>` from beginning of a line. Ú>rG   é   )r³   rš   rK   r›   )r;   rQ   rœ   s      r2   rº   ÚBlockQuoteProcessor.clean<  s;   € à�G‰G�M‰M˜$ÓˆØ�:‰:‹<˜3ÓØÞØ—7‘7˜1“:ÐàˆKr4   r[   Nri   r    )rQ   rg   rf   rg   )rl   rm   rn   ro   rp   ry   rz   r³   r^   rb   rº   rq   r[   r4   r2   r,   r,     s$   † Ù à	�ŠÐ.Ó	/€BôRô"÷0r4   r,   c                  ó”   ^ • \ rS rSr% SrSrS\S'    SrS\S'    SrS	\S
'    SS/r	S\S'    SU 4S jjr
SS jrSS jrSS jrSrU =r$ )r*   iG  zProcess ordered list blocks. rv   rg   ÚTAGÚ1Ú
STARTSWITHTrj   ÚLAZY_OLru   rk   ÚSIBLING_TAGSc                óD  >• [         TU ]  U5        [        R                  " SU R                  S-
  -  5      U l        [        R                  " SU R                  S-
  -  5      U l        [        R                  " SU R                  U R                  S-  S-
  4-  5      U l        g )Nz^[ ]{0,%d}\d+\.[ ]+(.*)r   z!^[ ]{0,%d}((\d+\.)|[*+-])[ ]+(.*)z ^[ ]{%d,%d}((\d+\.)|[*+-])[ ]+.*r¿   )rx   r<   ry   rz   r:   r³   ÚCHILD_REr{   ©r;   r1   r}   s     €r2   r<   ÚOListProcessor.__init__Y  s‰   ø€ Ü‰Ñ˜Ô ä—*’*Ð7¸4¿?¹?ÈQÑ;NÑOÓPˆŒäŸ
š
Ð#GØ$(§O¡O°aÑ$7ñ$9ó :ˆŒô ŸšÐ$GØ%)§_¡_°d·o±oÈÑ6IÈAÑ6MÐ$Nñ%Oó Pˆ�r4   c                óJ   • [        U R                  R                  U5      5      $ r9   ©rj   r³   rš   r\   s      r2   r^   ÚOListProcessor.testd  ó   € Ü�D—G‘G—M‘M %Ó(Ó)Ð)r4   c                ó¼  • U R                  UR                  S5      5      nU R                  U5      nUGbp  UR                  U R                  ;   GaU  UnUS   R
                  (       aI  [        R                  " S5      nUS   R
                  Ul        SUS   l        US   R                  SU5        U R                  US   5      nUbQ  UR                  (       a@  [        R                  " US   S5      nUR                  R                  5       Ul        SUl	        [        R                  " US5      nU R                  R                  R                  S5        UR                  S5      n	U R                  R                  X‰/5        U R                  R                  R!                  5         OmUR                  S;   a  UnOZ[        R                  " XR"                  5      nU R$                  (       d)  U R&                  S:w  a  U R&                  UR(                  S	'   U R                  R                  R                  S
5        U H{  n
U
R+                  SU R,                  -  5      (       a"  U R                  R                  US   U
/5        MH  [        R                  " US5      nU R                  R                  XŠ/5        M}     U R                  R                  R!                  5         g )Nr   r?   rˆ   rG   rt   Ú	looselist)rv   ru   rÃ   r¹   r™   rF   )Ú	get_itemsr‰   rB   rƒ   rÆ   rM   r�   rŽ   r�   Útailr–   Úlstripr1   r�   r‹   rŒ   r’   rÂ   rÅ   rÄ   ÚattribrI   r:   )r;   rA   ra   Úitemsr“   Úlstrˆ   Úlchrt   Ú	firstitemÚitems              r2   rb   ÚOListProcessor.rung  s  € à—‘˜vŸz™z¨!›}Ó-ˆØ—.‘. Ó(ˆàÒ 7§;¡;°$×2CÑ2CÔ#CàˆCð �2‰w�|�|ô —M’M #Ó&�Ø˜R™Ÿ™�”Ø!��B‘”Ø�B‘—‘˜q !Ô$ð —.‘.  R¡Ó)ˆCØ‰ 3§8§8Ü×$Ò$ S¨¡W¨cÓ2�ØŸ™Ÿ™Ó*�”Ø�”ô ×!Ò! # tÓ,ˆBØ�K‰K×Ñ×!Ñ! +Ô.ØŸ	™	 !›ˆIØ�K‰K×#Ñ# B¨Ô4Ø�K‰K×Ñ×#Ñ#Õ%Ø�Z‰Z˜<Ó'ð ‰Cô ×"Ò" 6¯8©8Ó4ˆCà—<—< D§O¡O°sÓ$:Ø&*§o¡o�—
‘
˜7Ñ#à�‰×Ñ×Ñ˜fÔ%ó ˆDØ�‰˜s 4§?¡?Ñ2×3Ñ3à—‘×'Ñ'¨¨B©°$°Ö8ô ×%Ò% c¨4Ó0�Ø—‘×'Ñ'¨¨FÖ3ñ ð 	�‰×Ñ×ÑÕ!r4   c                ó   • / nUR                  S5       GH5  nU R                  R                  U5      nU(       a‚  U(       dY  U R                  S:X  aI  [        R
                  " S5      nUR                  UR                  S5      5      R                  5       U l        UR                  UR                  S5      5        M¨  U R                  R                  U5      (       aU  US   R                  SU R                  -  5      (       a  SR                  US   U5      US'   GM	  UR                  U5        GM  SR                  US   U5      US'   GM8     U$ )	zBreak a block into list items. rE   rv   z(\d+)r   é   r?   rF   ú{}
{})rH   rÈ   rš   rÂ   ry   rz   r›   rÄ   rJ   r{   rI   r:   r«   )r;   r]   rÕ   rQ   rœ   Ú
INTEGER_REs         r2   rÑ   ÚOListProcessor.get_items¢  sþ   € àˆØ—K‘K ×%ˆDØ—‘×#Ñ# DÓ)ˆAÞö  §¡¨TÓ!1ä!#§¢¨HÓ!5�JØ&0×&6Ñ&6°q·w±w¸q³zÓ&B×&HÑ&HÓ&J�D”Oà—‘˜QŸW™W Q›ZÖ(Ø—‘×%Ñ% d×+Ñ+à˜‘9×'Ñ'¨¨D¯O©OÑ(;×<Ñ<à (§¡°°b±	¸4Ó @�E˜"”Ià—L‘L ×&ð %ŸO™O¨E°"©I°tÓ<��b”	ñ) &ð* ˆr4   )rÈ   r{   r³   rÄ   rd   ri   r    )r]   rg   rf   rk   )rl   rm   rn   ro   rp   rÂ   Ú__annotations__rÄ   rÅ   rÆ   r<   r^   rb   rÑ   rq   r¢   r£   s   @r2   r*   r*   G  s^   ø‡ Ù(à€CˆƒOØ6Ø€J�Óðð €GˆTÓØ*Ø# T˜l€L�)Ó*ð÷
	Pô*ô9"÷vò r4   r*   c                  óB   ^ • \ rS rSr% SrSrS\S'    SU 4S jjrSrU =r	$ )	r+   i½  zProcess unordered list blocks. ru   rg   rÂ   c                óz   >• [         TU ]  U5        [        R                  " SU R                  S-
  -  5      U l        g )Nz^[ ]{0,%d}[*+-][ ]+(.*)r   )rx   r<   ry   rz   r:   r³   rÉ   s     €r2   r<   ÚUListProcessor.__init__Ã  s/   ø€ Ü‰Ñ˜Ô ä—*’*Ð7¸4¿?¹?ÈQÑ;NÑOÓPˆ�r4   )r³   rd   )
rl   rm   rn   ro   rp   rÂ   rà   r<   rq   r¢   r£   s   @r2   r+   r+   ½  s   ø‡ Ù*à€CˆƒOØ6÷Qõ Qr4   r+   c                  óP   • \ rS rSrSr\R                  " S5      rSS jrS	S jr	Sr
g)
r'   iÉ  zProcess Hash Headers. z>(?:^|\n)(?P<level>#{1,6})(?P<header>(?:\\.|[^\\])*?)#*(?:\n|$)c                óJ   • [        U R                  R                  U5      5      $ r9   )rj   r³   r´   r\   s      r2   r^   ÚHashHeaderProcessor.testÏ  s   € Ü�D—G‘G—N‘N 5Ó)Ó*Ð*r4   c           	     ó‚  • UR                  S5      nU R                  R                  U5      nU(       aô  US UR                  5        nX4R	                  5       S  nU(       a  U R
                  R                  X/5        [        R                  " US[        UR                  S5      5      -  5      nUR                  S5      R                  5       Ul        U(       aN  U R
                  R                  R                  S5      (       a  U R                  U5      nUR!                  SU5        g g ["        R%                  SU-  5        g )Nr   úh%drV   ÚheaderrÐ   zWe've got a problem header: %r)r‰   r³   r´   r¹   Úendr1   rŒ   r�   r–   r@   r›   rK   rM   r�   r‚   rX   r�   ÚloggerÚwarn)r;   rA   ra   r]   rœ   r»   ÚafterÚhs           r2   rb   ÚHashHeaderProcessor.runÒ  sñ   € Ø—
‘
˜1“ˆØ�G‰G�N‰N˜5Ó!ˆÞØ˜:˜AŸG™G›IÐ&ˆFØŸ%™%›'˜(�OˆEÞð —‘×'Ñ'¨°Ô9ä× Ò  ¨´°Q·W±W¸WÓ5EÓ1FÑ)FÓGˆAØ—W‘W˜XÓ&×,Ñ,Ó.ˆAŒFÞà—;‘;×$Ñ$×,Ñ,¨[×9Ñ9ð !ŸO™O¨EÓ2�EØ—‘˜a Õ'ð ô �K‰KÐ8¸5Ñ@ÕAr4   r[   Nri   r    )rl   rm   rn   ro   rp   ry   rz   r³   r^   rb   rq   r[   r4   r2   r'   r'   É  s!   † Ù!ð 
�ŠÐUÓ	V€Bô+÷Br4   r'   c                  óf   • \ rS rSrSr\R                  " S\R                  5      rSS jr	S	S jr
Srg)
r(   ií  zProcess Setext-style Headers. z^.*?\n[=-]+[ ]*(\n|$)c                óJ   • [        U R                  R                  U5      5      $ r9   rÌ   r\   s      r2   r^   ÚSetextHeaderProcessor.testó  rÎ   r4   c                óL  • UR                  S5      R                  S5      nUS   R                  S5      (       a  SnOSn[        R                  " USU-  5      nUS   R                  5       Ul        [        U5      S:”  a%  UR                  SSR                  USS  5      5        g g )Nr   rE   r   Ú=r¿   rè   )
r‰   rH   rI   r�   r–   rK   rM   r@   r�   rL   )r;   rA   ra   rP   rV   rî   s         r2   rb   ÚSetextHeaderProcessor.runö  sŽ   € Ø—
‘
˜1“×#Ñ# DÓ)ˆà�‰8×Ñ˜s×#Ñ#Ø‰EàˆEÜ×Ò˜V U¨U¡]Ó3ˆØ�q‘—‘Ó!ˆŒÜˆu‹:˜‹>à�M‰M˜!˜TŸY™Y u¨Q¨R yÓ1Õ2ð r4   r[   Nri   r    ©rl   rm   rn   ro   rp   ry   rz   Ú	MULTILINEr³   r^   rb   rq   r[   r4   r2   r(   r(   í  s&   † Ù)ð 
�ŠÐ,¨b¯l©lÓ	;€Bô*÷3r4   r(   c                  ój   • \ rS rSrSrSr\R                  " \\R                  5      r	SS jr
S	S jrSrg)
r)   i  zProcess Horizontal Rules. zf^[ ]{0,3}(?=(?P<atomicgroup>(-+[ ]{0,2}){3,}|(_+[ ]{0,2}){3,}|(\*+[ ]{0,2}){3,}))(?P=atomicgroup)[ ]*$c                óV   • U R                   R                  U5      nU(       a  X0l        gg)NTF)Ú	SEARCH_REr´   rš   )r;   rA   r]   rœ   s       r2   r^   ÚHRProcessor.test  s$   € Ø�N‰N×!Ñ! %Ó(ˆÞàŒJØØr4   c                ól  • UR                  S5      nU R                  nUS UR                  5        R                  S5      nU(       a  U R                  R                  X/5        [        R                  " US5        X4R                  5       S  R                  S5      nU(       a  UR                  SU5        g g )Nr   rE   r   )r‰   rš   r¹   r­   r1   rŒ   r�   r–   rê   rÓ   r�   )r;   rA   ra   r]   rš   ÚprelinesÚ	postliness          r2   rb   ÚHRProcessor.run  s�   € Ø—
‘
˜1“ˆØ—
‘
ˆà˜˜%Ÿ+™+›-Ð(×/Ñ/°Ó5ˆÞà�K‰K×#Ñ# F¨JÔ7ä×Ò˜ Ô&àŸ)™)›+˜,Ð'×.Ñ.¨tÓ4ˆ	Þà�M‰M˜!˜YÕ'ð r4   )rš   Nri   r    )rl   rm   rn   ro   rp   r³   ry   rz   r÷   rú   r^   rb   rq   r[   r4   r2   r)   r)     s+   † Ù%ð 
s€Bà—
’
˜2˜rŸ|™|Ó,€Iô÷(r4   r)   c                  ó,   • \ rS rSrSrSS jrSS jrSrg)	r$   i&  z;Process blocks that are empty or start with an empty line. c                ó@   • U(       + =(       d    UR                  S5      $ )NrE   )rI   r\   s      r2   r^   ÚEmptyBlockProcessor.test)  s   € ØŒy×2˜E×,Ñ,¨TÓ2Ð2r4   c                ó„  • UR                  S5      nSnU(       a   SnUSS  nU(       a  UR                  SU5        U R                  U5      nUbr  UR                  S:X  aa  [	        U5      (       aP  US   R                  S:X  a<  [
        R                  " SR                  US   R                  U5      5      US   l        g g g g g )Nr   z

rE   r   r©   r   z{}{})	r‰   r�   rB   rƒ   r@   r   rª   r«   rM   )r;   rA   ra   r]   Úfillerr®   r“   s          r2   rb   ÚEmptyBlockProcessor.run,  s¬   € Ø—
‘
˜1“ˆØˆÞð ˆFà˜A˜B�iˆGÞà—‘˜a Ô)Ø—.‘. Ó(ˆØÑ G§K¡K°5Ó$8Üˆw�<‰<˜G A™JŸN™N¨fÓ4ä"×/Ò/Ø—‘˜g a™jŸo™o¨vÓ6óˆG�A‰J�Oð 5ˆ<ð %9Ðr4   r[   Nri   r    r°   r[   r4   r2   r$   r$   &  s   † ÙFô3÷r4   r$   c                  óf   • \ rS rSrSr\R                  " S\R                  5      rSS jr	S	S jr
Srg)
r-   iA  zProcess link references. z\^[ ]{0,3}\[([^\[\]]*)\]:[ ]*\n?[ ]*([^\s]+)[ ]*(?:\n[ ]*)?((["\'])(.*)\4[ ]*|\((.*)\)[ ]*)?$c                ó   • g©NTr[   r\   s      r2   r^   ÚReferenceProcessor.testG  ó   € Ør4   c                ó@  • UR                  S5      nU R                  R                  U5      nU(       GaX  UR                  S5      R	                  5       R                  5       nUR                  S5      R                  S5      R                  S5      nUR                  S5      =(       d    UR                  S5      nXg4U R                  R                  R                  U'   X4R                  5       S  R	                  5       (       a1  UR                  SX4R                  5       S  R                  S5      5        US UR                  5        R	                  5       (       a2  UR                  SUS UR                  5        R                  S5      5        g	UR                  SU5        g
)Nr   r   r¿   Ú<r¾   é   é   rE   TF)r‰   r³   r´   r›   rK   ÚlowerrÓ   r­   r1   r/   Ú
referencesrê   r�   r¹   )r;   rA   ra   r]   rœ   ÚidÚlinkÚtitles           r2   rb   ÚReferenceProcessor.runJ  s,  € Ø—
‘
˜1“ˆØ�G‰G�N‰N˜5Ó!ˆßØ—‘˜“×!Ñ!Ó#×)Ñ)Ó+ˆBØ—7‘7˜1“:×$Ñ$ SÓ)×0Ñ0°Ó5ˆDØ—G‘G˜A“J×, !§'¡'¨!£*ˆEØ-1¨MˆD�K‰K�N‰N×%Ñ% bÑ)Ø—U‘U“W�Xˆ×$Ñ$×&Ñ&à—‘˜a §u¡u£w x ×!7Ñ!7¸Ó!=Ô>Ø�Z�a—g‘g“iÐ ×&Ñ&×(Ñ(à—‘˜a  z¨¯©«	Ð!2×!9Ñ!9¸$Ó!?Ô@Øà�‰�a˜ÔØr4   r[   Nri   )rA   re   ra   rk   rf   rj   rö   r[   r4   r2   r-   r-   A  s)   † Ù$Ø	�ŠØgÐik×iuÑiuó
€Bô÷r4   r-   c                  ó,   • \ rS rSrSrSS jrSS jrSrg)	r.   i^  zProcess Paragraph blocks. c                ó   • gr  r[   r\   s      r2   r^   ÚParagraphProcessor.testa  r
  r4   c                ó4  • UR                  S5      nUR                  5       (       aò  U R                  R                  R	                  S5      (       a›  U R                  U5      nUb>  UR                  (       a"  SR                  UR                  U5      Ul        g SU-  Ul        g UR                  (       a"  SR                  UR                  U5      Ul        g UR                  5       Ul        g [        R                  " US5      nUR                  5       Ul        g g )Nr   r™   rÝ   z
%srˆ   )r‰   rK   r1   r�   r‚   rB   rÒ   r«   rM   rÓ   r�   r–   )r;   rA   ra   r]   r“   rˆ   s         r2   rb   ÚParagraphProcessor.rund  sÅ   € Ø—
‘
˜1“ˆØ�;‰;�=‰=à�{‰{× Ñ ×(Ñ(¨×0Ñ0ð Ÿ.™.¨Ó0�ØÑ&à—|—|Ø'/§¡°w·|±|ÀUÓ'K˜�à'-°¡~˜�ð —{—{Ø&.§o¡o°f·k±kÀ5Ó&I˜�à&+§l¡l£n˜�ô ×$Ò$ V¨SÓ1�ØŸ™›�•ð7 r4   r[   Nri   r    r°   r[   r4   r2   r.   r.   ^  s   † Ù%ô÷(r4   r.   )r/   r	   r0   r   rf   r   ) rp   Ú
__future__r   Úloggingry   Úxml.etree.ElementTreer�   ÚElementTreeÚtypingr   r   rG   r   Úblockparserr   Úmarkdownr	   Ú	getLoggerrë   r3   r6   r%   r&   r,   r*   r+   r'   r(   r)   r$   r-   r.   r[   r4   r2   Ú<module>r"     sÞ   ðñ(õ #ã Û 	ß %Ð %ß %Ý Ý $æÝ!à	×	Ò	˜:Ó	&€ô÷"[ñ [ô|_˜.ô _ôD&˜ô &ôB(˜.ô (ôVs�^ô sôl	Q�^ô 	Qô!B˜.ô !BôH3˜Nô 3ô.(�.ô (ôD˜.ô ô6˜ô ô:#(˜õ #(r4   