§
    
Á³g}  ã                   ó¤  — d Z ddlZddlZddlZddlmZmZ ddlmZ ddl	m
Z
mZmZmZ ddlmZmZmZmZmZmZ ddlmZ g d¢Zg d	¢Z ed
„ ¦  «        Z G d„ de¦  «        Z G d„ de¬¦  «        Z G d„ de¦  «        Z G d„ de¦  «        Z  G d„ d¦  «        Z! e!¦   «         Z" G d„ de#¦  «        Z$ G d„ d¦  «        Z%d„ Z& G d„ d¦  «        Z' e'¦   «         Z(d„ Z) G d„ d¦  «        Z* G d „ d!e¦  «        Z+ G d"„ d#e¦  «        Z, G d$„ d%ee,¬¦  «        Z- G d&„ d'¦  «        Z. G d(„ d)e-¦  «        Z/d*„ Z0 G d+„ d,e,¦  «        Z1 G d-„ d.e-e1¬¦  «        Z2dS )/z´
    pygments.lexer
    ~~~~~~~~~~~~~~

    Base lexer classes.

    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
é    N)Úapply_filtersÚFilter)Úget_filter_by_name)ÚErrorÚTextÚOtherÚ
_TokenType)Úget_bool_optÚget_int_optÚget_list_optÚmake_analysatorÚFutureÚguess_decode)Ú	regex_opt)ÚLexerÚ
RegexLexerÚExtendedRegexLexerÚDelegatingLexerÚLexerContextÚincludeÚinheritÚbygroupsÚusingÚthisÚdefaultÚwords))s   ï»¿úutf-8)s   ÿþ  zutf-32)s     þÿzutf-32be)s   ÿþzutf-16)s   þÿzutf-16bec                 ó   — dS )Nç        © )Úxs    úX/var/www/html/mpstechhub/venv/lib/python3.11/site-packages/pip/_vendor/pygments/lexer.pyú<lambda>r#   !   s   € ¨#€ ó    c                   ó   — e Zd ZdZd„ ZdS )Ú	LexerMetaz‚
    This metaclass automagically converts ``analyse_text`` methods into
    static methods which always return float values.
    c                 ót   — d|v rt          |d         ¦  «        |d<   t                               | |||¦  «        S )NÚanalyse_text)r   ÚtypeÚ__new__)ÚmcsÚnameÚbasesÚds       r"   r*   zLexerMeta.__new__*   s<   € Ø˜QÐÐÝ /°°.Ô0AÑ BÔ BˆAˆnÑÝ�|Š|˜C  u¨aÑ0Ô0Ð0r$   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r*   r    r$   r"   r&   r&   $   s-   € € € € € ðð ð
1ð 1ð 1ð 1ð 1r$   r&   c                   óT   — e Zd ZdZdZdZg Zg Zg Zg Z	dZ
d„ Zd„ Zd„ Zd„ Zdd	„Zd
„ ZdS )r   aÈ  
    Lexer for a specific language.

    Basic options recognized:
    ``stripnl``
        Strip leading and trailing newlines from the input (default: True).
    ``stripall``
        Strip all leading and trailing whitespace from the input
        (default: False).
    ``ensurenl``
        Make sure that the input ends with a newline (default: True).  This
        is required for some lexers that consume input linewise.

        .. versionadded:: 1.3

    ``tabsize``
        If given and greater than 0, expand tabs in the input (default: 0).
    ``encoding``
        If given, must be an encoding name. This encoding will be used to
        convert the input string to Unicode, if it is not already a Unicode
        string (default: ``'guess'``, which uses a simple UTF-8 / Locale /
        Latin1 detection.  Can also be ``'chardet'`` to use the chardet
        library, if it is installed.
    ``inencoding``
        Overrides the ``encoding`` if given.
    Nr   c                 óœ  — || _         t          |dd¦  «        | _        t          |dd¦  «        | _        t          |dd¦  «        | _        t          |dd¦  «        | _        |                     dd	¦  «        | _        |                     d
¦  «        p| j        | _        g | _	        t          |dd¦  «        D ]}|                      |¦  «         Œd S )NÚstripnlTÚstripallFÚensurenlÚtabsizer   ÚencodingÚguessÚ
inencodingÚfiltersr    )Úoptionsr
   r5   r6   r7   r   r8   Úgetr9   r<   r   Ú
add_filter)Úselfr=   Úfilter_s      r"   Ú__init__zLexer.__init__a   sÅ   € ØˆŒÝ# G¨Y¸Ñ=Ô=ˆŒÝ$ W¨j¸%Ñ@Ô@ˆŒÝ$ W¨j¸$Ñ?Ô?ˆŒÝ" 7¨I°qÑ9Ô9ˆŒØŸš J°Ñ8Ô8ˆŒØŸš LÑ1Ô1ÐB°T´]ˆŒØˆŒÝ# G¨Y¸Ñ;Ô;ð 	%ð 	%ˆGØ�OŠO˜GÑ$Ô$Ð$Ð$ð	%ð 	%r$   c                 ó^   — | j         rd| j        j        ›d| j         ›d�S d| j        j        z  S )Nz<pygments.lexers.z with ú>z<pygments.lexers.%s>)r=   Ú	__class__r/   ©r@   s    r"   Ú__repr__zLexer.__repr__m   sH   € ØŒ<ð 	Dð 	DØ59´^Ô5LÐ5LÐ5LØ59´\°\°\ðCð Cð *¨D¬NÔ,CÑCÐCr$   c                 ó~   — t          |t          ¦  «        st          |fi |¤Ž}| j                             |¦  «         dS )z8
        Add a new stream filter to this lexer.
        N)Ú
isinstancer   r   r<   Úappend)r@   rA   r=   s      r"   r?   zLexer.add_filtert   sG   € õ ˜'¥6Ñ*Ô*ð 	=Ý(¨Ð<Ð<°GÐ<Ð<ˆGØŒ×Ò˜GÑ$Ô$Ð$Ð$Ð$r$   c                 ó   — dS )a~  
        Has to return a float between ``0`` and ``1`` that indicates
        if a lexer wants to highlight this text. Used by ``guess_lexer``.
        If this method returns ``0`` it won't highlight it in any case, if
        it returns ``1`` highlighting with this lexer is guaranteed.

        The `LexerMeta` metaclass automatically wraps this function so
        that it works like a static method (no ``self`` or ``cls``
        parameter) and the return value is automatically converted to
        `float`. If the return value is an object that is boolean `False`
        it's the same as if the return values was ``0.0``.
        Nr    )Útexts    r"   r(   zLexer.analyse_text|   s   € € € r$   Fc                 ó¤  ‡ ‡— t          ‰t          ¦  «        �s9‰ j        dk    rt          ‰¦  «        \  Š}�nF‰ j        dk    rÈ	 ddlm} n"# t          $ r}t          d¦  «        |‚d}~ww xY wd}t          D ]G\  }}‰                     |¦  «        r-‰t          |¦  «        d…          
                    |d¦  «        } nŒH|€H|                     ‰dd…         ¦  «        }	‰ 
                    |	                     d	¦  «        pd
d¦  «        }|Šns‰ 
                    ‰ j        ¦  «        Š‰                     d¦  «        r‰t          d¦  «        d…         Šn,‰                     d¦  «        r‰t          d¦  «        d…         Š‰                     dd¦  «        Š‰                     dd¦  «        Š‰ j        r‰                     ¦   «         Šn‰ j        r‰                     d¦  «        Š‰ j        dk    r‰                     ‰ j        ¦  «        Š‰ j        r‰                     d¦  «        s‰dz  Šˆ ˆfd„}
 |
¦   «         }|st+          |‰ j        ‰ ¦  «        }|S )a=  
        Return an iterable of (tokentype, value) pairs generated from
        `text`. If `unfiltered` is set to `True`, the filtering mechanism
        is bypassed even if filters are defined.

        Also preprocess the text, i.e. expand tabs and strip it if
        wanted and applies registered filters.
        r:   Úchardetr   )rN   zkTo enable chardet encoding guessing, please install the chardet library from http://chardet.feedparser.org/NÚreplacei   r9   r   u   ï»¿z
ú
úc               3   óP   •K  — ‰                      ‰¦  «        D ]\  } }}||fV — Œd S ©N)Úget_tokens_unprocessed)Ú_ÚtÚvr@   rL   s      €€r"   Ústreamerz"Lexer.get_tokens.<locals>.streamer½   sC   øè è € Ø×6Ò6°tÑ<Ô<ð ð ‘��1�aØ˜�d�
�
�
�
ðð r$   )rI   Ústrr9   r   Úpip._vendorrN   ÚImportErrorÚ_encoding_mapÚ
startswithÚlenÚdecodeÚdetectr>   rO   r6   Ústripr5   r8   Ú
expandtabsr7   Úendswithr   r<   )r@   rL   Ú
unfilteredrU   rN   ÚeÚdecodedÚbomr9   ÚencrX   Ústreams   ``          r"   Ú
get_tokenszLexer.get_tokensŠ   s�  øø€ õ ˜$¥Ñ$Ô$ñ 	,ØŒ} Ò'Ð'Ý& tÑ,Ô,‘��a‘aØ” )Ò+Ð+ðTØ3Ð3Ð3Ð3Ð3Ð3Ð3øÝ"ð Tð Tð TÝ%ð 'Lñ Mô MàRSðTøøøøðTøøøð
 �Ý%2ð ð ‘M�C˜Ø—’ sÑ+Ô+ð Ø"&¥s¨3¡x¤x y y¤/×"8Ò"8¸À9Ñ"MÔ"M˜Ø˜ðð �?Ø!Ÿ.š.¨¨e¨t¨e¬Ñ5Ô5�CØ"Ÿkšk¨#¯'ª'°*Ñ*=Ô*=Ð*HÀØ*3ñ5ô 5�Gà��à—{’{ 4¤=Ñ1Ô1�Ø—?’? 8Ñ,Ô,ð 0Ø¥ H¡¤  Ô/�Døà�Š˜xÑ(Ô(ð ,Ø�C ™MœM˜N˜NÔ+�ð �|Š|˜F DÑ)Ô)ˆØ�|Š|˜D $Ñ'Ô'ˆØŒ=ð 	$Ø—:’:‘<”<ˆDˆDØŒ\ð 	$Ø—:’:˜dÑ#Ô#ˆDØŒ<˜!ÒÐØ—?’? 4¤<Ñ0Ô0ˆDØŒ=ð 	 §¢¨tÑ!4Ô!4ð 	Ø�D‰LˆDð	ð 	ð 	ð 	ð 	ð 	ð �‘”ˆØð 	?Ý" 6¨4¬<¸Ñ>Ô>ˆFØˆs   ÁA Á
A*ÁA%Á%A*c                 ó   — t           ‚)zú
        Return an iterable of (index, tokentype, value) pairs where "index"
        is the starting position of the token within the input text.

        In subclasses, implement this method as a generator to
        maximize effectiveness.
        )ÚNotImplementedError)r@   rL   s     r"   rT   zLexer.get_tokens_unprocessedÅ   s
   € õ "Ð!r$   )F)r/   r0   r1   r2   r,   ÚurlÚaliasesÚ	filenamesÚalias_filenamesÚ	mimetypesÚpriorityrB   rG   r?   r(   rj   rT   r    r$   r"   r   r   0   s²   € € € € € ðð ð8 €Dð €Cð €Gð €Ið €Oð €Ið €Hð
%ð 
%ð 
%ðDð Dð Dð%ð %ð %ðð ð ð9ð 9ð 9ð 9ðv"ð "ð "ð "ð "r$   r   )Ú	metaclassc                   ó"   — e Zd ZdZefd„Zd„ ZdS )r   a   
    This lexer takes two lexer as arguments. A root lexer and
    a language lexer. First everything is scanned using the language
    lexer, afterwards all ``Other`` tokens are lexed using the root
    lexer.

    The lexers from the ``template`` lexer package use this base lexer.
    c                 ól   —  |di |¤Ž| _          |di |¤Ž| _        || _        t          j        | fi |¤Ž d S ©Nr    )Ú
root_lexerÚlanguage_lexerÚneedler   rB   )r@   Ú_root_lexerÚ_language_lexerÚ_needler=   s        r"   rB   zDelegatingLexer.__init__Ú   sV   € Ø%˜+Ð0Ð0¨Ð0Ð0ˆŒØ-˜oÐ8Ð8°Ð8Ð8ˆÔØˆŒÝŒ�tÐ'Ð'˜wÐ'Ð'Ð'Ð'Ð'r$   c                 óŠ  — d}g }g }| j                              |¦  «        D ]U\  }}}|| j        u r.|r&|                     t	          |¦  «        |f¦  «         g }||z  }Œ=|                     |||f¦  «         ŒV|r$|                     t	          |¦  «        |f¦  «         t          || j                             |¦  «        ¦  «        S )NÚ )rx   rT   ry   rJ   r^   Údo_insertionsrw   )r@   rL   ÚbufferedÚ
insertionsÚ
lng_bufferÚirV   rW   s           r"   rT   z&DelegatingLexer.get_tokens_unprocessedà   sé   € ØˆØˆ
Øˆ
ØÔ*×AÒAÀ$ÑGÔGð 	-ð 	-‰GˆAˆq�!Ø�D”KÐÐØð $Ø×%Ò%¥s¨8¡}¤}°jÐ&AÑBÔBÐBØ!#�JØ˜A‘��à×!Ò! 1 a¨ )Ñ,Ô,Ð,Ð,Øð 	;Ø×Ò�s 8™}œ}¨jÐ9Ñ:Ô:Ð:Ý˜ZØ!œ_×CÒCÀHÑMÔMñOô Oð 	Or$   N)r/   r0   r1   r2   r   rB   rT   r    r$   r"   r   r   Ð   sL   € € € € € ðð ð >Cð (ð (ð (ð (ðOð Oð Oð Oð Or$   r   c                   ó   — e Zd ZdZdS )r   zI
    Indicates that a state should include rules from another state.
    N©r/   r0   r1   r2   r    r$   r"   r   r   ÷   s   € € € € € ðð ð 	€Dr$   r   c                   ó   — e Zd ZdZd„ ZdS )Ú_inheritzC
    Indicates the a state should inherit from its superclass.
    c                 ó   — dS )Nr   r    rF   s    r"   rG   z_inherit.__repr__  s   € Øˆyr$   N)r/   r0   r1   r2   rG   r    r$   r"   r‡   r‡   þ   s-   € € € € € ðð ðð ð ð ð r$   r‡   c                   ó   — e Zd ZdZd„ Zd„ ZdS )Úcombinedz:
    Indicates a state combined from multiple states.
    c                 ó8   — t                                | |¦  «        S rS   )Útupler*   )ÚclsÚargss     r"   r*   zcombined.__new__  s   € Ý�}Š}˜S $Ñ'Ô'Ð'r$   c                 ó   — d S rS   r    )r@   rŽ   s     r"   rB   zcombined.__init__  s   € àˆr$   N)r/   r0   r1   r2   r*   rB   r    r$   r"   rŠ   rŠ     s<   € € € € € ðð ð(ð (ð (ðð ð ð ð r$   rŠ   c                   ó<   — e Zd ZdZd„ Zd	d„Zd	d„Zd	d„Zd„ Zd„ Z	dS )
Ú_PseudoMatchz:
    A pseudo match object constructed from a string.
    c                 ó"   — || _         || _        d S rS   )Ú_textÚ_start)r@   ÚstartrL   s      r"   rB   z_PseudoMatch.__init__  s   € ØˆŒ
ØˆŒˆˆr$   Nc                 ó   — | j         S rS   )r”   ©r@   Úargs     r"   r•   z_PseudoMatch.start  s
   € ØŒ{Ðr$   c                 ó:   — | j         t          | j        ¦  «        z   S rS   )r”   r^   r“   r—   s     r"   Úendz_PseudoMatch.end!  s   € ØŒ{�S ¤™_œ_Ñ,Ð,r$   c                 ó2   — |rt          d¦  «        ‚| j        S )NzNo such group)Ú
IndexErrorr“   r—   s     r"   Úgroupz_PseudoMatch.group$  s    € Øð 	.Ý˜_Ñ-Ô-Ð-ØŒzÐr$   c                 ó   — | j         fS rS   )r“   rF   s    r"   Úgroupsz_PseudoMatch.groups)  s   € Ø”
ˆ}Ðr$   c                 ó   — i S rS   r    rF   s    r"   Ú	groupdictz_PseudoMatch.groupdict,  s   € Øˆ	r$   rS   )
r/   r0   r1   r2   rB   r•   rš   r�   rŸ   r¡   r    r$   r"   r‘   r‘     s‡   € € € € € ðð ðð ð ðð ð ð ð-ð -ð -ð -ðð ð ð ð
ð ð ðð ð ð ð r$   r‘   c                  ó   ‡ — dˆ fd„	}|S )zL
    Callback that yields multiple actions for each group in the match.
    Nc           
   3   óø  •K  — t          ‰¦  «        D ]É\  }}|€Œt          |¦  «        t          u r8|                     |dz   ¦  «        }|r|                     |dz   ¦  «        ||fV — ŒV|                     |dz   ¦  «        }|�Y|r|                     |dz   ¦  «        |_         || t          |                     |dz   ¦  «        |¦  «        |¦  «        D ]}|r|V — Œ	ŒÊ|r|                     ¦   «         |_        d S d S )Né   )Ú	enumerater)   r	   r�   r•   Úposr‘   rš   )ÚlexerÚmatchÚctxrƒ   ÚactionÚdataÚitemrŽ   s          €r"   Úcallbackzbygroups.<locals>.callback4  s*  øè è € Ý" 4™œð 	'ð 	'‰IˆAˆvØˆ~ØÝ�f‘”¥Ð+Ð+Ø—{’{ 1 q¡5Ñ)Ô)�Øð ;ØŸ+š+ a¨!¡eÑ,Ô,¨f°dÐ:Ð:Ð:Ð:øà—{’{ 1 q¡5Ñ)Ô)�ØÐ#Øð 5Ø"'§+¢+¨a°!©eÑ"4Ô"4˜œØ &  uÝ'3°E·K²KÀÀAÁÑ4FÔ4FÈÑ'MÔ'MÈsñ!Tô !Tð 'ð '˜àð 'Ø"&˜J˜J˜JøøØð 	"Ø—i’i‘k”kˆCŒGˆGˆGð	"ð 	"r$   rS   r    )rŽ   r­   s   ` r"   r   r   0  s(   ø€ ð"ð "ð "ð "ð "ð "ð& €Or$   c                   ó   — e Zd ZdZdS )Ú_ThiszX
    Special singleton used for indicating the caller class.
    Used by ``using``.
    Nr…   r    r$   r"   r¯   r¯   J  s   € € € € € ðð ð ð r$   r¯   c                 óÆ   ‡ ‡‡— i Šd‰v r>‰                      d¦  «        }t          |t          t          f¦  «        r|‰d<   nd|f‰d<   ‰ t          u rdˆˆfd„	}ndˆ ˆˆfd„	}|S )aÂ  
    Callback that processes the match with a different lexer.

    The keyword arguments are forwarded to the lexer, except `state` which
    is handled separately.

    `state` specifies the state that the new lexer will start in, and can
    be an enumerable such as ('root', 'inline', 'string') or a simple
    string which is assumed to be on top of the root state.

    Note: For that to work, `_other` must not be an `ExtendedRegexLexer`.
    ÚstateÚstackÚrootNc              3   ó(  •K  — ‰	r(‰	                      | j        ¦  «          | j        di ‰	¤Ž}n| }|                     ¦   «         } |j        |                     ¦   «         fi ‰¤ŽD ]\  }}}||z   ||fV — Œ|r|                     ¦   «         |_        d S d S rv   )Úupdater=   rE   r•   rT   r�   rš   r¦   )
r§   r¨   r©   ÚlxÚsrƒ   rV   rW   Ú	gt_kwargsÚkwargss
           €€r"   r­   zusing.<locals>.callbacki  sÀ   øè è € ð ð à—’˜eœmÑ,Ô,Ð,Ø$�U”_Ð.Ð. vÐ.Ð.��à�Ø—’‘”ˆAØ4˜2Ô4°U·[²[±]´]ÐPÐPÀiÐPÐPð "ð "‘��1�aØ˜!‘e˜Q �kÐ!Ð!Ð!Ð!Øð &ØŸ)š)™+œ+�”��ð&ð &r$   c              3   ó  •K  — ‰
                      | j        ¦  «          ‰di ‰
¤Ž}|                     ¦   «         } |j        |                     ¦   «         fi ‰	¤ŽD ]\  }}}||z   ||fV — Œ|r|                     ¦   «         |_        d S d S rv   )rµ   r=   r•   rT   r�   rš   r¦   )r§   r¨   r©   r¶   r·   rƒ   rV   rW   Ú_otherr¸   r¹   s           €€€r"   r­   zusing.<locals>.callbackx  s­   øè è € à�MŠM˜%œ-Ñ(Ô(Ð(Ø�Ð!Ð!˜&Ð!Ð!ˆBà—’‘”ˆAØ4˜2Ô4°U·[²[±]´]ÐPÐPÀiÐPÐPð "ð "‘��1�aØ˜!‘e˜Q �kÐ!Ð!Ð!Ð!Øð &ØŸ)š)™+œ+�”��ð&ð &r$   rS   )ÚpoprI   ÚlistrŒ   r   )r»   r¹   r·   r­   r¸   s   ``  @r"   r   r   S  s¹   øøø€ ð €IØ�&ÐÐØ�JŠJ�wÑÔˆÝ�a�$¥˜Ñ'Ô'ð 	-Ø!"ˆI�gÑÐà"(¨! ˆI�gÑà•€~€~ð	&ð 	&ð 	&ð 	&ð 	&ð 	&ð 	&ð 	&ð		&ð 		&ð 		&ð 		&ð 		&ð 		&ð 		&ð 		&ð €Or$   c                   ó   — e Zd ZdZd„ ZdS )r   zÑ
    Indicates a state or state action (e.g. #pop) to apply.
    For example default('#pop') is equivalent to ('', Token, '#pop')
    Note that state tuples may be used as well.

    .. versionadded:: 2.0
    c                 ó   — || _         d S rS   )r±   )r@   r±   s     r"   rB   zdefault.__init__�  s   € ØˆŒ
ˆ
ˆ
r$   N)r/   r0   r1   r2   rB   r    r$   r"   r   r   …  s-   € € € € € ðð ðð ð ð ð r$   r   c                   ó    — e Zd ZdZdd„Zd„ ZdS )r   z•
    Indicates a list of literal words that is transformed into an optimized
    regex that matches any of the words.

    .. versionadded:: 2.0
    r~   c                 ó0   — || _         || _        || _        d S rS   )r   ÚprefixÚsuffix)r@   r   rÂ   rÃ   s       r"   rB   zwords.__init__˜  s   € ØˆŒ
ØˆŒØˆŒˆˆr$   c                 óD   — t          | j        | j        | j        ¬¦  «        S )N©rÂ   rÃ   )r   r   rÂ   rÃ   rF   s    r"   r>   z	words.get�  s   € Ý˜œ¨D¬KÀÄÐLÑLÔLÐLr$   N)r~   r~   )r/   r0   r1   r2   rB   r>   r    r$   r"   r   r   ‘  sF   € € € € € ðð ðð ð ð ð
Mð Mð Mð Mð Mr$   r   c                   ó>   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd
d„Zd„ Z	d	„ Z
dS )ÚRegexLexerMetazw
    Metaclass for RegexLexer, creates the self._tokens attribute from
    self.tokens on the first instantiation.
    c                 óˆ   — t          |t          ¦  «        r|                     ¦   «         }t          j        ||¦  «        j        S )zBPreprocess the regular expression component of a token definition.)rI   r   r>   ÚreÚcompiler¨   )r�   ÚregexÚrflagsr±   s       r"   Ú_process_regexzRegexLexerMeta._process_regex§  s6   € å�e�VÑ$Ô$ð 	 Ø—I’I‘K”KˆEÝŒz˜% Ñ(Ô(Ô.Ð.r$   c                 ój   — t          |¦  «        t          u st          |¦  «        sJ d|›�¦   «         ‚|S )z5Preprocess the token component of a token definition.z0token type must be simple type or callable, not )r)   r	   Úcallable)r�   Útokens     r"   Ú_process_tokenzRegexLexerMeta._process_token­  s<   € å�E‰{Œ{�jÐ(Ð(­H°U©O¬OÐ(Ð(Ð(ØDIÀEÐKñ )Ô(Ð(àˆr$   c                 ó2  — t          |t          ¦  «        rJ|dk    rdS ||v r|fS |dk    r|S |dd…         dk    rt          |dd…         ¦  «         S J d|z  ¦   «         ‚t          |t          ¦  «        rfd	| j        z  }| xj        d
z  c_        g }|D ]?}||k    sJ d|z  ¦   «         ‚|                     |                      |||¦  «        ¦  «         Œ@|||<   |fS t          |t          ¦  «        r|D ]}||v s|dv sJ d|z   ¦   «         ‚Œ|S J d|z  ¦   «         ‚)z=Preprocess the state transition action of a token definition.ú#popéÿÿÿÿú#pushNé   z#pop:Fzunknown new state %rz_tmp_%dr¤   zcircular state ref %r)rÓ   rÕ   zunknown new state zunknown new state def %r)rI   rY   ÚintrŠ   Ú_tmpnameÚextendÚ_process_staterŒ   )r�   Ú	new_stateÚunprocessedÚ	processedÚ	tmp_stateÚitokensÚistates          r"   Ú_process_new_statez!RegexLexerMeta._process_new_state³  s£  € å�i¥Ñ%Ô%ð 	Aà˜FÒ"Ð"Ø�rØ˜kÐ)Ð)Ø!�|Ð#Ø˜gÒ%Ð%Ø Ð Ø˜2˜A˜2” 'Ò)Ð)Ý˜I a b bœMÑ*Ô*Ð*Ð*à@Ð4°yÑ@Ñ@Ô@Ð@Ý˜	¥8Ñ,Ô,ð 	Aà! C¤LÑ0ˆIØˆLŒL˜AÑˆLŒLØˆGØ#ð Fð F�Ø Ò*Ð*Ð*Ð,CÀfÑ,LÑ*Ô*Ð*Ø—’˜s×1Ò1°+Ø2;¸Vñ Eô  Eñ Fô Fð Fð Fà#*ˆI�iÑ Ø�<ÐÝ˜	¥5Ñ)Ô)ð 	Aà#ð 2ð 2�Ø +Ð-Ð-ØÐ"3Ð3Ð3Ð3Ø(¨6Ñ1ñ 4Ô3Ð3øàÐà@Ð4°yÑ@Ñ@Ô@Ð@r$   c                 ó2  — t          |¦  «        t          u sJ d|z  ¦   «         ‚|d         dk    sJ d|z  ¦   «         ‚||v r||         S g x}||<   | j        }||         D �]¶}t          |t          ¦  «        rK||k    sJ d|z  ¦   «         ‚|                     |                      ||t          |¦  «        ¦  «        ¦  «         Œct          |t          ¦  «        rŒyt          |t          ¦  «        rL|  	                    |j
        ||¦  «        }|                     t          j        d¦  «        j        d|f¦  «         ŒÚt          |¦  «        t          u sJ d|z  ¦   «         ‚	 |                      |d         ||¦  «        }n4# t"          $ r'}	t%          d	|d         ›d
|›d| ›d|	›�¦  «        |	‚d}	~	ww xY w|                      |d         ¦  «        }
t)          |¦  «        dk    rd}n|  	                    |d         ||¦  «        }|                     ||
|f¦  «         �Œ¸|S )z%Preprocess a single state definition.zwrong state name %rr   ú#zinvalid state name %rzcircular state reference %rr~   Nzwrong rule def %rzuncompilable regex z
 in state z of z: r¤   é   )r)   rY   ÚflagsrI   r   rÙ   rÚ   r‡   r   rá   r±   rJ   rÉ   rÊ   r¨   rŒ   rÍ   Ú	ExceptionÚ
ValueErrorrÑ   r^   )r�   rÜ   rÝ   r±   ÚtokensrÌ   ÚtdefrÛ   ÚrexÚerrrÐ   s              r"   rÚ   zRegexLexerMeta._process_stateÖ  sg  € å�E‰{Œ{�cÐ!Ð!Ð!Ð#8¸5Ñ#@Ñ!Ô!Ð!Ø�QŒx˜3ŠˆˆÐ 7¸%Ñ ?‰ŒˆØ�IÐÐØ˜UÔ#Ð#Ø$&Ð&ˆ�˜5Ñ!Ø”ˆØ Ô&ð !	3ñ !	3ˆDÝ˜$¥Ñ(Ô(ð à˜u’}�}�}Ð&CÀeÑ&K‘}”}�}Ø—’˜c×0Ò0°¸iÝ14°T±´ñ<ô <ñ =ô =ð =àÝ˜$¥Ñ)Ô)ð ð Ý˜$¥Ñ(Ô(ð Ø×2Ò2°4´:¸{ÈIÑVÔV�	Ø—’�rœz¨"™~œ~Ô3°T¸9ÐEÑFÔFÐFØå˜‘:”:¥Ð&Ð&Ð&Ð(;¸dÑ(BÑ&Ô&Ð&ðFØ×(Ò(¨¨a¬°&¸%Ñ@Ô@��øÝð Fð Fð FÝ �jØ"& q¤' ' '¨5¨5¨5°#°#°#°s°sð"<ñ =ô =ØBEðFøøøøðFøøøð ×&Ò& t¨A¤wÑ/Ô/ˆEå�4‰yŒy˜AŠ~ˆ~Ø �	�	à×2Ò2°4¸´7Ø3>À	ñKô K�	ð �MŠM˜3  yÐ1Ñ2Ô2Ð2Ñ2Øˆs   ÅE;Å;
F,Æ"F'Æ'F,Nc                 óŽ   — i x}| j         |<   |p| j        |         }t          |¦  «        D ]}|                      |||¦  «         Œ|S )z-Preprocess a dictionary of token definitions.)Ú_all_tokensrè   r½   rÚ   )r�   r,   Ú	tokendefsrÝ   r±   s        r"   Úprocess_tokendefzRegexLexerMeta.process_tokendef  sZ   € à,.Ð.ˆ	�C”O DÑ)ØÐ1 ¤¨DÔ!1ˆ	Ý˜)‘_”_ð 	<ð 	<ˆEØ×Ò˜y¨)°UÑ;Ô;Ð;Ð;ØÐr$   c                 óÔ  — i }i }| j         D ]Û}|j                             di ¦  «        }|                     ¦   «         D ]©\  }}|                     |¦  «        }|€7|||<   	 |                     t
          ¦  «        }n# t          $ r Y ŒIw xY w|||<   ŒS|                     |d¦  «        }|€Œl||||dz   …<   	 |                     t
          ¦  «        }	||	z   ||<   Œš# t          $ r Y Œ¦w xY wŒÜ|S )a  
        Merge tokens from superclasses in MRO order, returning a single tokendef
        dictionary.

        Any state that is not defined by a subclass will be inherited
        automatically.  States that *are* defined by subclasses will, by
        default, override that state in the superclass.  If a subclass wishes to
        inherit definitions from a superclass, it can use the special value
        "inherit", which will cause the superclass' state definition to be
        included at that point in the state.
        rè   Nr¤   )Ú__mro__Ú__dict__r>   ÚitemsÚindexr   rç   r¼   )
r�   rè   ÚinheritableÚcÚtoksr±   ró   ÚcuritemsÚinherit_ndxÚnew_inh_ndxs
             r"   Úget_tokendefszRegexLexerMeta.get_tokendefs
  sG  € ð ˆØˆØ”ð 	Cð 	CˆAØ”:—>’> (¨BÑ/Ô/ˆDà $§
¢
¡¤ð Cð C‘��uØ!Ÿ:š: eÑ,Ô,�ØÐ#ð
 %*�F˜5‘Mð!Ø&+§k¢kµ'Ñ&:Ô&:˜˜øÝ%ð !ð !ð !Ø ˜ð!øøøà)4�K Ñ&Øà)Ÿošo¨e°TÑ:Ô:�ØÐ&Øð 7<�˜ [°¡]Ð2Ñ3ðCð #(§+¢+­gÑ"6Ô"6�Kð *5°{Ñ)B�K Ñ&Ð&øõ "ð ð ð Ø�Dðøøøð3Cð< ˆs$   ÁA:Á:
BÂBÂ4CÃ
C$Ã#C$c                 óä   — d| j         vrSi | _        d| _        t          | d¦  «        r| j        rn-|                      d|                      ¦   «         ¦  «        | _        t          j	        | g|¢R i |¤ŽS )z:Instantiate cls after preprocessing its token definitions.Ú_tokensr   Útoken_variantsr~   )
rò   rí   rØ   Úhasattrrþ   rï   rû   rý   r)   Ú__call__)r�   rŽ   Úkwdss      r"   r   zRegexLexerMeta.__call__;  s‚   € à˜CœLÐ(Ð(Ø ˆCŒOØˆCŒLÝ�sÐ,Ñ-Ô-ð L°#Ô2Dð Làà!×2Ò2°2°s×7HÒ7HÑ7JÔ7JÑKÔK�”åŒ}˜SÐ0 4Ð0Ð0Ð0¨4Ð0Ð0Ð0r$   rS   )r/   r0   r1   r2   rÍ   rÑ   rá   rÚ   rï   rû   r   r    r$   r"   rÇ   rÇ   ¡  s’   € € € € € ðð ð
/ð /ð /ðð ð ð!Að !Að !AðF*ð *ð *ðXð ð ð ð/ð /ð /ðb1ð 1ð 1ð 1ð 1r$   rÇ   c                   ó,   — e Zd ZdZej        Zi Zdd„ZdS )r   z±
    Base for simple stateful regular expression-based lexers.
    Simplifies the lexing process so that you need only
    provide a list of states and regular expressions.
    ©r³   c              #   óè  K  — d}| j         }t          |¦  «        }||d                  }	 |D �]p\  }}}	 |||¦  «        }
|
�rZ|�Bt          |¦  «        t          u r|||
                     ¦   «         fV — n || |
¦  «        E d{V —† |
                     ¦   «         }|	�þt          |	t          ¦  «        rk|	D ]g}|dk    r(t          |¦  «        dk    r| 	                    ¦   «          Œ0|dk    r| 
                    |d         ¦  «         ŒR| 
                    |¦  «         Œhnpt          |	t          ¦  «        r,t          |	¦  «        t          |¦  «        k    r|dd…= n5||	d…= n/|	dk    r| 
                    |d         ¦  «         nJ d|	z  ¦   «         ‚||d                  } nV�Œr	 ||         d	k    rd
g}|d
         }|t          d	fV — |dz  }�Œ |t          ||         fV — |dz  }n# t          $ r Y dS w xY w�ŒÊ)z~
        Split ``text`` into (tokentype, text) pairs.

        ``stack`` is the initial stack (default: ``['root']``)
        r   rÔ   r¤   NrÓ   rÕ   Fúwrong state def: %rrP   r³   )rý   r½   r)   r	   r�   rš   rI   rŒ   r^   r¼   rJ   r×   Úabsr   r   rœ   )r@   rL   r²   r¦   rî   Ú
statestackÚstatetokensÚrexmatchrª   rÛ   Úmr±   s               r"   rT   z!RegexLexer.get_tokens_unprocessedl  s„  è è € ð ˆØ”Lˆ	Ý˜%‘[”[ˆ
Ø 
¨2¤Ô/ˆð1	Ø/:ð 0ñ 0Ñ+�˜& )Ø�H˜T 3Ñ'Ô'�Øñ ØÐ)Ý ™<œ<­:Ð5Ð5Ø"% v¨q¯wªw©y¬yÐ"8Ð8Ð8Ð8Ð8à'- v¨d°A¡¤Ð6Ð6Ð6Ð6Ð6Ð6Ð6ØŸ%š%™'œ'�CØ Ð,å% iµÑ7Ô7ð LØ)2ð =ð = Ø#(¨F¢? ?Ý'*¨:¡¤¸Ò':Ð':Ø(2¯ªÑ(8Ô(8Ð(8øØ%*¨gÒ%5Ð%5Ø$.×$5Ò$5°jÀ´nÑ$EÔ$EÐ$EÐ$Eà$.×$5Ò$5°eÑ$<Ô$<Ð$<Ð$<ð=õ (¨	µ3Ñ7Ô7ð Lõ  # 9™~œ~µ°Z±´Ò@Ð@Ø$.¨q¨r¨r N Nà$.¨y¨z¨zÐ$:Ð$:Ø&¨'Ò1Ð1Ø&×-Ò-¨j¸¬nÑ=Ô=Ð=Ð=àKÐ*?À)Ñ*KÑKÔKÐKØ&/°
¸2´Ô&?˜Ø�Eñ?ðFØ˜C”y DÒ(Ð(à&, X˜
Ø&/°Ô&7˜Ø!¥4¨˜oÐ-Ð-Ð-Ø˜q™˜Ù Ø�u d¨3¤iÐ/Ð/Ð/Ð/Ø˜1‘H�C�CøÝ!ð ð ð Ø�E�Eðøøøña1	s   Æ(G! Ç	G! Ç!
G/Ç.G/N©r  )	r/   r0   r1   r2   rÉ   Ú	MULTILINErå   rè   rT   r    r$   r"   r   r   I  sB   € € € € € ðð ð ŒL€Eð0 €Fð;ð ;ð ;ð ;ð ;ð ;r$   r   c                   ó    — e Zd ZdZdd„Zd„ ZdS )r   z9
    A helper object that holds lexer position data.
    Nc                 ób   — || _         || _        |pt          |¦  «        | _        |pdg| _        d S )Nr³   )rL   r¦   r^   rš   r²   )r@   rL   r¦   r²   rš   s        r"   rB   zLexerContext.__init__¯  s4   € ØˆŒ	ØˆŒØÐ#�#˜d™)œ)ˆŒØÐ&˜v˜hˆŒ
ˆ
ˆ
r$   c                 ó8   — d| j         ›d| j        ›d| j        ›d�S )NzLexerContext(z, ú))rL   r¦   r²   rF   s    r"   rG   zLexerContext.__repr__µ  s'   € € àŒIˆIˆI�t”x�x�x ¤  ð-ð 	-r$   ©NN)r/   r0   r1   r2   rB   rG   r    r$   r"   r   r   ª  sA   € € € € € ðð ð'ð 'ð 'ð 'ð-ð -ð -ð -ð -r$   r   c                   ó   — e Zd ZdZdd„ZdS )r   zE
    A RegexLexer that uses a context object to store its state.
    Nc              #   ó`  K  — | j         }|st          |d¦  «        }|d         }n|}||j        d                  }|j        }	 |D �]Ó\  }}} |||j        |j        ¦  «        }	|	�r²|�vt          |¦  «        t          u r8|j        ||	                     ¦   «         fV — |	                     ¦   «         |_        n( || |	|¦  «        E d{V —† |s||j        d                  }|��5t          |t          ¦  «        r„|D ]€}
|
dk    r2t          |j        ¦  «        dk    r|j                             ¦   «          Œ:|
dk    r&|j                             |j        d         ¦  «         Œf|j                             |
¦  «         Œ�n‰t          |t          ¦  «        r;t          |¦  «        t          |j        ¦  «        k    r|j        dd…= nD|j        |d…= n9|dk    r&|j                             |j        d         ¦  «         nJ d	|z  ¦   «         ‚||j        d                  } n—�ŒÕ	 |j        |j        k    rdS ||j                 d
k    r3dg|_        |d         }|j        t           d
fV — |xj        dz  c_        �Œ/|j        t"          ||j                 fV — |xj        dz  c_        n# t$          $ r Y dS w xY w�Œn)z
        Split ``text`` into (tokentype, text) pairs.
        If ``context`` is given, use this lexer context instead.
        r   r³   rÔ   r¤   NrÓ   rÕ   Fr  rP   )rý   r   r²   rL   r¦   rš   r)   r	   r�   rI   rŒ   r^   r¼   rJ   r×   r  r   r   rœ   )r@   rL   Úcontextrî   r©   r  r	  rª   rÛ   r
  r±   s              r"   rT   z)ExtendedRegexLexer.get_tokens_unprocessed¿  s  è è € ð
 ”Lˆ	Øð 	Ý˜t QÑ'Ô'ˆCØ# FÔ+ˆKˆKàˆCØ# C¤I¨b¤MÔ2ˆKØ”8ˆDð3	Ø/:ð 2ñ 2Ñ+�˜& )Ø�H˜T 3¤7¨C¬GÑ4Ô4�Øñ !ØÐ)Ý ™<œ<­:Ð5Ð5Ø"%¤'¨6°1·7²7±9´9Ð"<Ð<Ð<Ð<Ø&'§e¢e¡g¤g˜CœG˜Gà'- v¨d°A°sÑ';Ô';Ð;Ð;Ð;Ð;Ð;Ð;Ð;Ø#,ð Gà.7¸¼	À"¼Ô.F à Ñ,å% iµÑ7Ô7ð LØ)2ð <ð < Ø#(¨F¢? ?Ý'*¨3¬9¡~¤~¸Ò'9Ð'9Ø(+¬	¯ª©¬¨øØ%*¨gÒ%5Ð%5Ø$'¤I×$4Ò$4°S´Y¸r´]Ñ$CÔ$CÐ$CÐ$Cà$'¤I×$4Ò$4°UÑ$;Ô$;Ð$;Ð$;ð<õ (¨	µ3Ñ7Ô7ð 	Lå" 9™~œ~µ°S´Y±´Ò?Ð?Ø$'¤I¨a¨b¨b M Mà$'¤I¨i¨j¨jÐ$9Ð$9Ø&¨'Ò1Ð1ØœI×,Ò,¨S¬Y°r¬]Ñ;Ô;Ð;Ð;àKÐ*?À)Ñ*KÑKÔKÐKØ&/°´	¸"´Ô&>˜Ø�EñC!ðFØ”w #¤'Ò)Ð)Ø˜Ø˜CœG”}¨Ò,Ð,à%+ H˜œ	Ø&/°Ô&7˜Ø!œg¥t¨TÐ1Ð1Ð1Ð1Ø˜œ 1™˜œÙ Øœ'¥5¨$¨s¬w¬-Ð7Ð7Ð7Ð7Ø�G”G˜q‘L�G”G�GøÝ!ð ð ð Ø�E�Eðøøøñe3	s   ÈJ È,AJ É0,J Ê
J+Ê*J+r  )r/   r0   r1   r2   rT   r    r$   r"   r   r   º  s8   € € € € € ðð ð@ð @ð @ð @ð @ð @r$   r   c              #   ó  K  — t          | ¦  «        } 	 t          | ¦  «        \  }}n# t          $ r |E d{V —† Y dS w xY wd}d}|D ]è\  }}}|€|}d}	|r£|t          |¦  «        z   |k    r�||	||z
  …         }
|
r|||
fV — |t          |
¦  «        z  }|D ]\  }}}|||fV — |t          |¦  «        z  }Œ ||z
  }		 t          | ¦  «        \  }}n# t          $ r d}Y nw xY w|r|t          |¦  «        z   |k    °�|	t          |¦  «        k     r$||||	d…         fV — |t          |¦  «        |	z
  z  }Œé|rQ|pd}|D ]\  }}}|||fV — |t          |¦  «        z  }Œ 	 t          | ¦  «        \  }}n# t          $ r d}Y dS w xY w|°OdS dS )ag  
    Helper for lexers which must combine the results of several
    sublexers.

    ``insertions`` is a list of ``(index, itokens)`` pairs.
    Each ``itokens`` iterable should be inserted at position
    ``index`` into the token stream given by the ``tokens``
    argument.

    The result is a combined token stream.

    TODO: clean up the code here.
    NTr   F)ÚiterÚnextÚStopIterationr^   )r�   rè   rô   rß   ÚrealposÚinsleftrƒ   rV   rW   ÚoldiÚtmpvalÚit_indexÚit_tokenÚit_valueÚps                  r"   r   r     s{  è è € õ �jÑ!Ô!€JðÝ˜jÑ)Ô)‰ˆˆwˆwøÝð ð ð àÐÐÐÐÐÐÐØˆˆðøøøð
 €GØ€Gð ð %ð %‰ˆˆ1ˆaàˆ?ØˆGØˆØð 	˜!�c !™fœf™*¨Ò-Ð-Ø�t˜E A™I�~Ô&ˆFØð 'Ø˜q &Ð(Ð(Ð(Ð(Ø�3˜v™;œ;Ñ&�Ø07ð )ð )Ñ,�˜( HØ˜x¨Ð1Ð1Ð1Ð1Ø�3˜x™=œ=Ñ(��Ø˜1‘9ˆDðÝ!% jÑ!1Ô!1‘��w�wøÝ ð ð ð Ø�Ø�ðøøøð ð 	˜!�c !™fœf™*¨Ò-Ð-ð •#�a‘&”&Š=ˆ=Ø˜1˜a   œhÐ&Ð&Ð&Ð&Ø•s˜1‘v”v ‘}Ñ$ˆGøð ð 
à�,˜QˆØð 	ð 	‰GˆAˆq�!Ø˜1˜a�-ÐÐÐØ•s˜1‘v”vÑˆGˆGð	Ý! *Ñ-Ô-‰NˆE�7�7øÝð 	ð 	ð 	ØˆGØˆEˆEð	øøøð ð 
ð 
ð 
ð 
ð 
s0   “& ¦<»<Â9CÃCÃCÅE* Å*E:Å9E:c                   ó   — e Zd ZdZd„ ZdS )ÚProfilingRegexLexerMetaz>Metaclass for ProfilingRegexLexer, collects regex timing info.c                 óÒ   ‡ ‡‡‡— t          |t          ¦  «        r"t          |j        |j        |j        ¬¦  «        Šn|Št          j        ‰|¦  «        Št          j        fˆ ˆˆˆfd„	}|S )NrÅ   c                 ó  •— ‰j         d                              ‰
‰	fddg¦  «        }t          j        ¦   «         }‰                     | ||¦  «        }t          j        ¦   «         }|dxx         dz  cc<   |dxx         ||z
  z  cc<   |S )NrÔ   r   r   r¤   )Ú
_prof_dataÚ
setdefaultÚtimer¨   )rL   r¦   ÚendposÚinfoÚt0ÚresÚt1r�   Úcompiledrê   r±   s          €€€€r"   Ú
match_funcz:ProfilingRegexLexerMeta._process_regex.<locals>.match_funcM  s†   ø€ Ø”> "Ô%×0Ò0°%¸°ÀÀ3¸xÑHÔHˆDÝ”‘”ˆBØ—.’.  s¨FÑ3Ô3ˆCÝ”‘”ˆBØ�ˆGˆGŒG�q‰LˆGˆG‰GØ�ˆGˆGŒG�r˜B‘wÑˆGˆG‰GØˆJr$   )	rI   r   r   rÂ   rÃ   rÉ   rÊ   ÚsysÚmaxsize)r�   rË   rÌ   r±   r.  r-  rê   s   `  ` @@r"   rÍ   z&ProfilingRegexLexerMeta._process_regexE  s�   øøøø€ Ý�e�UÑ#Ô#ð 	Ý˜EœK°´Ø#(¤<ð1ñ 1ô 1ˆCˆCð ˆCÝ”:˜c 6Ñ*Ô*ˆå),¬ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð Ðr$   N)r/   r0   r1   r2   rÍ   r    r$   r"   r"  r"  B  s)   € € € € € ØHÐHðð ð ð ð r$   r"  c                   ó"   — e Zd ZdZg ZdZdd„ZdS )ÚProfilingRegexLexerzFDrop-in replacement for RegexLexer that does profiling of its regexes.é   r  c              #   ó~  ‡ K  — ‰ j         j                             i ¦  «         t                               ‰ ||¦  «        E d {V —† ‰ j         j                             ¦   «         }t          d„ |                     ¦   «         D ¦   «         ˆ fd„d¬¦  «        }t          d„ |D ¦   «         ¦  «        }t          ¦   «          t          d‰ j         j
        t          |¦  «        |fz  ¦  «         t          d¦  «         t          dd	z  ¦  «         t          d
¦  «         |D ]}t          d|z  ¦  «         Œt          d¦  «         d S )Nc              3   óÀ   K  — | ]Y\  \  }}\  }}|t          |¦  «                             d ¦  «                             dd¦  «        dd…         |d|z  d|z  |z  fV — ŒZdS )zu'z\\ú\NéA   iè  )Úreprra   rO   )Ú.0r·   ÚrÚnrV   s        r"   ú	<genexpr>z=ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<genexpr>c  s�   è è € ð @ð @á+™F˜Q ¡F Q¨ð �4 ™7œ7Ÿ=š=¨Ñ/Ô/×7Ò7¸ÀÑEÔEÀcÀrÀcÔJØ˜4 !™8 T¨A¡X°¡\ð3ð @ð @ð @ð @ð @ð @r$   c                 ó   •— | ‰j                  S rS   )Ú_prof_sort_index)r!   r@   s    €r"   r#   z<ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<lambda>f  s   ø€  A dÔ&;Ô$<€ r$   T)ÚkeyÚreversec              3   ó&   K  — | ]}|d          V — ŒdS )é   Nr    )r9  r!   s     r"   r<  z=ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<genexpr>h  s&   è è € Ð+Ð+ ˜˜!œÐ+Ð+Ð+Ð+Ð+Ð+r$   z2Profiling result for %s lexing %d chars in %.3f mszn==============================================================================================================z$%-20s %-64s ncalls  tottime  percall)r±   rË   zn--------------------------------------------------------------------------------------------------------------z%-20s %-65s %5d %8.4f %8.4f)rE   r%  rJ   r   rT   r¼   Úsortedró   ÚsumÚprintr/   r^   )r@   rL   r²   Úrawdatar«   Ú	sum_totalr.   s   `      r"   rT   z*ProfilingRegexLexer.get_tokens_unprocessed^  so  øè è € àŒÔ!×(Ò(¨Ñ,Ô,Ð,Ý×4Ò4°T¸4ÀÑGÔGÐGÐGÐGÐGÐGÐGÐGØ”.Ô+×/Ò/Ñ1Ô1ˆÝð @ð @à/6¯}ª}©¬ð@ñ @ô @ð =Ð<Ð<Ð<Ø"ð	$ñ $ô $ˆõ
 Ð+Ð+ dÐ+Ñ+Ô+Ñ+Ô+ˆ	å‰ŒˆÝÐBØŒ~Ô&­¨D©	¬	°9Ð=ñ>ñ 	?ô 	?ð 	?åˆiÑÔÐÝÐ4Ð7IÑIÑJÔJÐJÝˆiÑÔÐØð 	5ð 	5ˆAÝÐ/°!Ñ3Ñ4Ô4Ð4Ð4ÝˆiÑÔÐÐÐr$   Nr  )r/   r0   r1   r2   r%  r>  rT   r    r$   r"   r2  r2  X  s9   € € € € € ØPÐPà€JØÐðð ð ð ð ð r$   r2  )3r2   rÉ   r/  r'  Úpip._vendor.pygments.filterr   r   Úpip._vendor.pygments.filtersr   Úpip._vendor.pygments.tokenr   r   r   r	   Úpip._vendor.pygments.utilr
   r   r   r   r   r   Úpip._vendor.pygments.regexoptr   Ú__all__r\   ÚstaticmethodÚ_default_analyser)   r&   r   r   rY   r   r‡   r   rŒ   rŠ   r‘   r   r¯   r   r   r   r   rÇ   r   r   r   r   r"  r2  r    r$   r"   ú<module>rP     sF  ððð ð 
€	€	€	Ø 
€
€
€
Ø €€€à =Ð =Ð =Ð =Ð =Ð =Ð =Ð =Ø ;Ð ;Ð ;Ð ;Ð ;Ð ;Ø EÐ EÐ EÐ EÐ EÐ EÐ EÐ EÐ EÐ EÐ EÐ Eð*ð *ð *ð *ð *ð *ð *ð *ð *ð *ð *ð *ð *ð *ð *ð *à 3Ð 3Ð 3Ð 3Ð 3Ð 3ðð ð €ð
,ð ,ð ,€ð  �<  Ñ.Ô.Ð ð	1ð 	1ð 	1ð 	1ð 	1�ñ 	1ô 	1ð 	1ð]"ð ]"ð ]"ð ]"ð ]"�ið ]"ñ ]"ô ]"ð ]"ð@Oð Oð Oð Oð O�eñ Oô Oð OðN	ð 	ð 	ð 	ð 	ˆcñ 	ô 	ð 	ðð ð ð ð ñ ô ð ð ˆ(‰*Œ*€ð
ð 
ð 
ð 
ð 
ˆuñ 
ô 
ð 
ðð ð ð ð ñ ô ð ð6ð ð ð4ð ð ð ð ñ ô ð ð €u�w„w€ð/ð /ð /ðd	ð 	ð 	ð 	ð 	ñ 	ô 	ð 	ðMð Mð Mð Mð MˆFñ Mô Mð Mð e1ð e1ð e1ð e1ð e1�Yñ e1ô e1ð e1ðP^ð ^ð ^ð ^ð ^� .ð ^ñ ^ô ^ð ^ðB-ð -ð -ð -ð -ñ -ô -ð -ð Eð Eð Eð Eð E˜ñ Eô Eð EðP=ð =ð =ð@ð ð ð ð ˜nñ ô ð ð,ð ð ð ð ˜*Ð0Gð ñ ô ð ð ð r$   