403Webshell
Server IP : 178.105.222.151  /  Your IP : 216.73.216.38
Web Server : nginx/1.28.3
System : Linux MNK 7.0.0-15-generic #15-Ubuntu SMP PREEMPT_DYNAMIC Wed Apr 22 16:06:43 UTC 2026 x86_64
User : www-data ( 33)
PHP Version : 8.5.4
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/pygments/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/pygments/__pycache__/lexer.cpython-314.pyc
+
�4Ui%���Z�Rt^RIt^RIt^RIt^RIHtHt^RIHt^RI	H
t
HtHtH
t
Ht^RIHtHtHtHtHtHt^RIHt.R-Ot]P2!R4t.R.Ot]!R4t!RR]4t!RR]R7t !RR
] 4t!!RR]"4t#!RR4t$]$!4t%!RR]&4t'!RR4t(Rt)!RR4t*]*!4t+R t,!R!R
4t-!R"R]4t.!R#R$]4t/!R%R] ]/R7t0!R&R4t1!R'R	]04t2R(t3!R)R*]/4t4!R+R,]0]4R7t5R#)/z�
pygments.lexer
~~~~~~~~~~~~~~

Base lexer classes.

:copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
N)�
apply_filters�Filter)�get_filter_by_name)�Error�Text�Other�
Whitespace�
_TokenType)�get_bool_opt�get_int_opt�get_list_opt�make_analysator�Future�guess_decode)�	regex_opt�Lexer�
RegexLexer�ExtendedRegexLexer�DelegatingLexer�LexerContext�include�default�wordsz.*?
c��R#)��)�xs&�0/usr/lib/python3/dist-packages/pygments/lexer.py�<lambda>r"s��#�c�*a�]tRt^%toRtRtRtVtR#)�	LexerMetazv
This metaclass automagically converts ``analyse_text`` methods into
static methods which always return float values.
c�f�RV9d\VR,4VR&\PWW#4#)�analyse_text)r
�type�__new__)�mcs�name�bases�ds&&&&rr%�LexerMeta.__new__+s/���Q�� /��.�0A� B�A�n���|�|�C�u�0�0rrN)�__name__�
__module__�__qualname__�__firstlineno__�__doc__r%�__static_attributes__�__classdictcell__��
__classdict__s@rr!r!%s�����
1�1rr!c�va�]tRt^1toRtRt.t.t.t.t	^t
RtRtRt
RtRtRtRtRtRRltR	tR
tVtR#)ran
Lexer for a specific language.

See also :doc:`lexerdevelopment`, a high-level guide to writing
lexers.

Lexer classes have attributes used for choosing the most appropriate
lexer based on various criteria.

.. autoattribute:: name
   :no-value:
.. autoattribute:: aliases
   :no-value:
.. autoattribute:: filenames
   :no-value:
.. autoattribute:: alias_filenames
.. autoattribute:: mimetypes
   :no-value:
.. autoattribute:: priority

Lexers included in Pygments should have two additional attributes:

.. autoattribute:: url
   :no-value:
.. autoattribute:: version_added
   :no-value:

Lexers included in Pygments may have additional attributes:

.. autoattribute:: _example
   :no-value:

You can pass options to the constructor. The basic options recognized
by all lexers and processed by the base `Lexer` class are:

``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.
Nc�|�Wn\VRR4Vn\VRR4Vn\VRR4Vn\VR^4VnVPRR4VnVPR	4;'g
VPVn.Vn	\VR
R4FpVPV4K	R#)
a)
This constructor takes arbitrary options as keyword arguments.
Every subclass must first process its own options and then call
the `Lexer` constructor, since it processes the basic
options like `stripnl`.

An example looks like this:

.. sourcecode:: python

   def __init__(self, **options):
       self.compress = options.get('compress', '')
       Lexer.__init__(self, **options)

As these options must all be specifiable as strings (due to the
command line usage), there are various utility functions
available to help with that, see `Utilities`_.
�stripnlT�stripallF�ensurenl�tabsize�encoding�guess�
inencoding�filtersNr)�optionsr
r6r7r8rr9�getr:r=r�
add_filter)�selfr>�filter_s&, r�__init__�Lexer.__init__�s���&��#�G�Y��=���$�W�j�%�@��
�$�W�j�$�?��
�"�7�I�q�9������J��8��
����L�1�B�B�T�]�]��
����#�G�Y��;�G��O�O�G�$�<rc��VP'd)RVPPRVP:R2#RVPPR2#)z<pygments.lexers.z with �>)r>�	__class__r+�rAs&r�__repr__�Lexer.__repr__�sK���<�<�<�&�t�~�~�'>�'>�&?�v�d�l�l�EU�UV�W�W�&�t�~�~�'>�'>�&?�q�A�Arc��\V\4'g
\V3/VBpVPP	V4R#)z(
Add a new stream filter to this lexer.
N)�
isinstancerrr=�append)rArBr>s&&,rr@�Lexer.add_filter�s2���'�6�*�*�(��<�G�<�G������G�$rc��R#)aa
A static method which is called for lexer guessing.

It should analyse the text and return a float in the range
from ``0.0`` to ``1.0``.  If it returns ``0.0``, the lexer
will not be selected as the most probable one, if it returns
``1.0``, it will be selected immediately.  This is used by
`guess_lexer`.

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&rr#�Lexer.analyse_text�s�rc�^�\V\4'Eg
VPR8Xd\V4wrEMVPR8Xd�^RIpRp\F<wrgTPT4'gKT\T4RPTR4pM	TfDTPTR,4pTPTPR4;'gRR4pTpMfVPVP4pVPR	4'dV\R	4RpM%VPR	4'dV\R	4RpVPR
R4pVPRR4pVP'dVP4pM#VP'dVPR4pVP ^8�dVP#VP 4pVP$'d!VP'R4'g
VR,
pV# \
dp\R4ThRp?ii;i)
zVApply preprocessing such as decoding the input, removing BOM and normalizing newlines.r;�chardetNzkTo enable chardet encoding guessing, please install the chardet library from http://chardet.feedparser.org/�replace:NiNr:�utf-8uz
�
�
)rL�strr:rrS�ImportError�
_encoding_map�
startswith�len�decode�detectr?rTr7�stripr6r9�
expandtabsr8�endswith)	rArP�_rS�e�decoded�bomr:�encs	&&       r�_preprocess_lexer_input�Lexer._preprocess_lexer_input�s����$��$�$��}�}��'�&�t�,���a����)�+�T�"���%2�M�C����s�+�+�"&�s�3�x�y�/�"8�"8��9�"M���&3�
�?�!�.�.��e��5�C�"�k�k�#�'�'�*�*=�*H�*H��*3�5�G����{�{�4�=�=�1���?�?�8�,�,���H�
��/�D�����x�(�(��C��M�N�+���|�|�F�D�)���|�|�D�$�'���=�=�=��:�:�<�D�
�\�\�\��:�:�d�#�D��<�<�!���?�?�4�<�<�0�D��=�=�=����t�!4�!4��D�L�D����I#�T�%�'L�M�RS�T��T�s�
H�H,�H'�'H,c�aa�SPS4oVV3RlpV!4pV'g\VSPS4pV#)a
This method is the basic interface of a lexer. It is called by
the `highlight()` function. It must process the text and return an
iterable of ``(tokentype, value)`` pairs from `text`.

Normally, you don't need to override this method. The default
implementation processes the options recognized by all lexers
(`stripnl`, `stripall` and so on), and then yields all tokens
from `get_tokens_unprocessed()`, with the ``index`` dropped.

If `unfiltered` is set to `True`, the filtering mechanism is
bypassed even if filters are defined.
c3�P<"�SPS4FwrpW3x�K
	R#5i�N)�get_tokens_unprocessed)rb�t�vrArPs   ��r�streamer�"Lexer.get_tokens.<locals>.streamer
s&�����6�6�t�<���a��d�
�=�s�#&)rgrr=)rArP�
unfilteredro�streamsff&  r�
get_tokens�Lexer.get_tokens�s=����+�+�D�1��	�����"�6�4�<�<��>�F��
rc��\h)a#
This method should process the text and return an iterable of
``(index, tokentype, value)`` tuples where ``index`` is the starting
position of the token within the input text.

It must be overridden by subclasses. It is recommended to
implement it as a generator to maximize effectiveness.
)�NotImplementedError)rArPs&&rrl�Lexer.get_tokens_unprocesseds
��"�!r)r:r8r=r>r7r6r9)F)r+r,r-r.r/r'�aliases�	filenames�alias_filenames�	mimetypes�priority�url�
version_added�_examplerCrIr@r#rgrsrlr0r1r2s@rrr1st����8�v�D��G�
�I��O��I��H��C��M��H�%�<B�%��"-�^�0	"�	"r)�	metaclassc�6a�]tRtRtoRt]3RltRtRtVt	R#)ri!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�t�V!R/VBVnV!R/VBVnW0n\P!V3/VBR#�Nr)�
root_lexer�language_lexer�needlerrC)rA�_root_lexer�_language_lexer�_needler>s&&&&,rrC�DelegatingLexer.__init__+s7��%�0��0���-�8��8�����
���t�'�w�'rc��Rp.p.pVPPV4FXwrVpW`PJd1V'dVP\	V4V34.pW',
pKEVPWVV34KZ	V'dVP\	V4V34\VVPPV44#)�)r�rlr�rMr\�
do_insertionsr�)rArP�buffered�
insertions�
lng_buffer�irmrns&&      rrl�&DelegatingLexer.get_tokens_unprocessed1s������
��
��*�*�A�A�$�G�G�A�!��K�K����%�%�s�8�}�j�&A�B�!#�J��
���!�!�1��)�,�H�����s�8�}�j�9�:��Z�!�_�_�C�C�H�M�O�	Or)r�r�r�N)
r+r,r-r.r/rrCrlr0r1r2s@rrr!s!�����>C�(�O�Orc��]tRtRtRtRtR#)riHzA
Indicates that a state should include rules from another state.
rN�r+r,r-r.r/r0rrrrrHs���	rc�*a�]tRtRtoRtRtRtVtR#)�_inheritiOz;
Indicates the a state should inherit from its superclass.
c��R#)�inheritrrHs&rrI�_inherit.__repr__Ss��rrN)r+r,r-r.r/rIr0r1r2s@rr�r�Os������rr�c�0a�]tRtRtoRtRtRtRtVtR#)�combinediYz2
Indicates a state combined from multiple states.
c�,�\PW4#rk)�tupler%)�cls�argss&*rr%�combined.__new__^s���}�}�S�'�'rc��R#rkr)rAr�s&*rrC�combined.__init__as��rrN)	r+r,r-r.r/r%rCr0r1r2s@rr�r�Ys�����(�
�
rr�c�Ta�]tRtRtoRtRtRRltRRltRRltRt	R	t
R
tVtR#)�_PseudoMatchifz2
A pseudo match object constructed from a string.
c��W nWnR#rk)�_text�_start)rA�startrPs&&&rrC�_PseudoMatch.__init__ks���
��rNc��VP#rk)r��rA�args&&rr��_PseudoMatch.startos���{�{�rc�N�VP\VP4,#rk)r�r\r�r�s&&r�end�_PseudoMatch.endrs���{�{�S����_�,�,rc�@�V'd\R4hVP#)z
No such group)�
IndexErrorr�r�s&&r�group�_PseudoMatch.groupus����_�-�-��z�z�rc��VP3#rk)r�rHs&r�groups�_PseudoMatch.groupszs���
�
�}�rc��/#rkrrHs&r�	groupdict�_PseudoMatch.groupdict}s���	r)r�r�rk)
r+r,r-r.r/rCr�r�r�r�r�r0r1r2s@rr�r�fs-�������-��
��rr�c�a�RV3RllpV#)zD
Callback that yields multiple actions for each group in the match.
c
3�,<"�\S4F�wr4VfK\V4\JdAVPV^,4pV'dVP	V^,4WE3x�K\K^VPV^,4pVfK|V'dVP	V^,4VnV!V\
VP	V^,4V4V4FpV'gK
Vx�K	K�	V'dVP4VnR#R#5irk)�	enumerater$r	r�r��posr�r�)�lexer�match�ctxr��action�data�itemr�s&&&    �r�callback�bygroups.<locals>.callback�s�����"�4��I�A��~���f���+��{�{�1�q�5�)����+�+�a�!�e�,�f�:�:���{�{�1�q�5�)���#��"'�+�+�a�!�e�"4��� &�u�'3�E�K�K��A��4F��'M�s�!T���4�"&�J�!T�)� ��i�i�k�C�G��s%�A	D�
9D�D�AD�'D�;Drkr)r�r�sj r�bygroupsr��s���"�&�Orc��]tRtRtRtRtR#)�_Thisi�zL
Special singleton used for indicating the caller class.
Used by ``using``.
rNr�rrrr�r��s��rr�c��aaa�/oRS9d;SPR4p\V\\34'dVSR&MRV3SR&S\JdRVV3RllpV#RVVV3RllpV#)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�rootc3�L<"�S	'd/S	PVP4VP!R/S	BpMTpVP4pVP!VP43/SBFwrVpWT,Wg3x�K	V'dVP
4VnR#R#5ir�)�updater>rGr�rlr�r�r�)
r�r�r��lx�sr�rmrn�	gt_kwargs�kwargss
&&&     ��rr��using.<locals>.callback�s�������
�
�e�m�m�,��_�_�.�v�.�������
�A��4�4�U�[�[�]�P�i�P���a��e�Q�k�!�Q���)�)�+����s�BB$�B$c3�"<"�S
PVP4S!R/S
BpVP4pVP!VP	43/S	BFwrVpWT,Wg3x�K	V'dVP4VnR#R#5ir�)r�r>r�rlr�r�r�)r�r�r�r�r�r�rmrn�_otherr�r�s&&&     ���rr�r��st�����M�M�%�-�-�(��!�&�!�B����
�A��4�4�U�[�[�]�P�i�P���a��e�Q�k�!�Q���)�)�+����s�A2B�6Brk)�poprL�listr��this)r�r�r�r�r�sfl  @r�usingr��sr����I��&���J�J�w����a�$���'�'�!"�I�g��"(�!��I�g��
��~�
	&�
	&�2�O�		&�		&��Orc�*a�]tRtRtoRtRtRtVtR#)ri�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��WnR#rk�r�)rAr�s&&rrC�default.__init__�s���
rr�N)r+r,r-r.r/rCr0r1r2s@rrr�s������rc�4a�]tRtRtoRtRRltRtRtVtR#)ri�z�
Indicates a list of literal words that is transformed into an optimized
regex that matches any of the words.

.. versionadded:: 2.0
c�*�WnW nW0nR#rk)r�prefix�suffix)rArr�r�s&&&&rrC�words.__init__�s���
����rc�Z�\VPVPVPR7#)�r�r�)rrr�r�rHs&rr?�	words.get�s������D�K�K����L�Lr)r�r�rN)r�r�)	r+r,r-r.r/rCr?r0r1r2s@rrr�s������
M�Mrc�Ra�]tRtRtoRtRtRtRtRtRRlt	R	t
R
tRtVt
R#)
�RegexLexerMetai�zk
Metaclass for RegexLexer, creates the self._tokens attribute from
self.tokens on the first instantiation.
c��\V\4'dVP4p\P!W4P
#)zBPreprocess the regular expression component of a token definition.)rLrr?�re�compiler�)r��regex�rflagsr�s&&&&r�_process_regex�RegexLexerMeta._process_regex�s/���e�V�$�$��I�I�K�E��z�z�%�(�.�.�.rc�d�\V4\Jg\V4'gQRV:24hV#)z5Preprocess the token component of a token definition.z0token type must be simple type or callable, not )r$r	�callable)r��tokens&&r�_process_token�RegexLexerMeta._process_token�s4���E�{�j�(�H�U�O�O�	I�>�u�i�H�	I�;��rc�Z�\V\4'dHVR8XdR
#W9dV3#VR8XdV#VR,R8Xd\VR,4)#QRT:24h\V\4'dqRVP,pV;P^,
un.pVF5pWa8wgQRV:24hVPVP
VW644K7	WSV&V3#\V\4'd)VF pWb9dKVR9dKQRV,4h	V#QR	T:24h)z=Preprocess the state transition action of a token definition.�#pop�#push:N�Nz#pop::r�NNzunknown new state z_tmp_%dzcircular state ref zunknown new state def ���)r�r�)rLrX�intr��_tmpname�extend�_process_stater�)r��	new_state�unprocessed�	processed�	tmp_state�itokens�istates&&&&   r�_process_new_state�!RegexLexerMeta._process_new_statesB���i��%�%��F�"��	��)�!�|�#��g�%� � ��2��'�)��I�b�M�*�*�*�@� 2�9�-�@�@�u�
�	�8�
,�
,�!�C�L�L�0�I��L�L�A��L��G�#���*�L�.A�&��,L�L�*����s�1�1�+�2;� E�F�$�$+�i� ��<��
�	�5�
)�
)�#���-��"3�3�2�(�6�1�2�4�$���@�2�9�-�@�@�5rc��\V\4'gQRV:24hV^,R8wgQRV:24hW29d	W#,#.;qBV&VPpW,EFdp\V\4'd>Wc8wgQRV:24hVP	VPW\V444KW\V\4'dKo\V\4'dQVPVPW4pVP\P!R4PRV34K�\V4\JgQRV:24hVP!V^,WS4pTP'T^,4p
\)T4^8XdRpMTPT^,Y4pTPY�T34EKg	V# \"d(p	\%RT^,:R	T:R
T:RT	24T	hRp	?	ii;i)z%Preprocess a single state definition.zwrong state name �#zinvalid state name zcircular state reference r�Nzwrong rule def zuncompilable regex z
 in state z of z: )rLrX�flagsrr�r�r�rrr�rMr�r�r�r$r�r��	Exception�
ValueErrorr�r\)r�r�rr��tokensr��tdefr��rex�errr�s&&&&       rr��RegexLexerMeta._process_state's����%��%�%�D�):�5�)�'D�D�%��Q�x�3��?�"5�e�Y� ?�?�����#�#�$&�&��5�!������&�&�D��$��(�(��}�K�(A�%��&K�K�}��
�
�c�0�0��14�T��<�=���$��)�)���$��(�(��2�2�4�:�:�{�V�	��
�
�r�z�z�"�~�3�3�T�9�E�F����:��&�B�/�$��(B�B�&�
r��(�(��a��&�@���&�&�t�A�w�/�E��4�y�A�~� �	��2�2�4��7�3>�K�	�
�M�M�3�y�1�2�A'�B�
���
r� �#6�t�A�w�k��E�9�TX�Y\�X_�_a�be�af�!g�h�nq�q��
r�s�G�H�"G;�;HNc��/;q0PV&T;'gVPV,p\V4FpVPW#V4K	V#)z-Preprocess a dictionary of token definitions.)�_all_tokensrr�r�)r�r'�	tokendefsrr�s&&&  r�process_tokendef�RegexLexerMeta.process_tokendefRsM��,.�.�	�O�O�D�)��1�1����D�!1�	��)�_�E����y�U�;�%��rc���/p/pVPF�pVPPR/4pVP4F|wrVVPV4pVf!WaV&VP	\
4pY�T&K:VPVR4pVfKRWgW�^,%VP	\
4p	W�,W%&K~	K�	V# \dK�i;i \dK�i;i)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.
rN)�__mro__�__dict__r?�items�indexr�r
r�)
r�r�inheritable�c�toksr�r�curitems�inherit_ndx�new_inh_ndxs
&         r�
get_tokendefs�RegexLexerMeta.get_tokendefsZs����������A��:�:�>�>�(�B�/�D� $�
�
����!�:�:�e�,���#�
%*�5�M�!�&+�k�k�'�&:��*5��&��)�o�o�e�T�:���&��7<���]�3�C�#(�+�+�g�"6�K�*5�)B�K�&�9!-��B�
��)&�!� �!��"����s$�C�C�C�C�C'�&C'c��RVP9dY/Vn^Vn\VR4'dVP'dM%VPRVP
44Vn\P!V.VO5/VB#)z:Instantiate cls after preprocessing its token definitions.�_tokens�token_variantsr�)
rrr��hasattrr$rr r#r$�__call__)r�r��kwdss&*,rr&�RegexLexerMeta.__call__�sn���C�L�L�(� �C�O��C�L��s�,�-�-�#�2D�2D�2D��!�2�2�2�s�7H�7H�7J�K����}�}�S�0�4�0�4�0�0rrrk)r+r,r-r.r/r�r�rr�rr r&r0r1r2s@rr�r��s6�����
/��!A�F)�V�/�b1�1rr�c�Ja�]tRtRtoRt]Pt/tRRlt	Rt
VtR#)ri�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.
c#��"�^pVPp\V4pWER,,pVEFYwrxp	V!W4p
V
'gKVe9\V4\JdW8V
P	43x�MV!W
4Rjx�L
V
P4pV	e�\
V	\4'dhV	F`pVR8Xd%\V4^8�dVP4K,K.VR8XdVPVR,4KOVPV4Kb	Mc\
V	\4'd#\V	4\V48�dVRM0WYR1M+V	R8XdVPVR,4MQRT	:24hWER,,pEK_	W,R8Xd$R.pVR,pV\R3x�V^,
pEK�V\W,3x�V^,
pEK�EL\ \dR#i;i5i)	zf
Split ``text`` into (tokentype, text) pairs.

``stack`` is the initial stack (default: ``['root']``)
Nr�r���NN�wrong state def: rVr�r�)r#r�r$r	r�r�rLr�r\r�rMr��absrrr�)rArPr�r�r�
statestack�statetokens�rexmatchr�r��mr�s&&&         rrl�!RegexLexer.get_tokens_unprocessed�s�������L�L�	��%�[�
��2��/���/:�+��)��T�'���1��)���<�:�5�"%�q�w�w�y�"8�8�'-�d��6�6��%�%�'�C� �,�%�i��7�7�)2��#(�F�?�'*�:���':�(2���(8�(;�%*�g�%5�$.�$5�$5�j��n�$E�$.�$5�$5�e�$<�*3�(�	�3�7�7� #�9�~��Z��@�$.�r�N�$.�z�$:�&�'�1�&�-�-�j��n�=�K�,=�i�]�*K�K�5�&/�2��&?���C0;�J��y�D�(�&,�X�
�&/��&7��!�:�t�3�3��q��� ��u�d�i�/�/��1�H�C�O7��P"����sI�AG/�7G/�>G�?D
G/�
-G�:G/�=G�G/�G,�(G/�+G,�,G/rN�)r�)r+r,r-r.r/r��	MULTILINErrrlr0r1r2s@rrr�s&�����
�L�L�E�0�F�;�;rc�4a�]tRtRtoRtRRltRtRtVtR#)ri�z1
A helper object that holds lexer position data.
Nc�v�WnW nT;'g\V4VnT;'gR.VnR#)r�N)rPr�r\r�r�)rArPr�r�r�s&&&&&rrC�LexerContext.__init__�s0���	����#�#�#�d�)����&�&�v�h��
rc�\�RVP:RVP:RVP:R2#)z
LexerContext(z, �))rPr�r�rHs&rrI�LexerContext.__repr__s)���t�y�y�m�2�d�h�h�\��D�J�J�>��K�Kr)r�r�r�rP�NN)	r+r,r-r.r/rCrIr0r1r2s@rrr�s�����'�L�Lrc�.a�]tRtRtoRtRRltRtVtR#)ri	z=
A RegexLexer that uses a context object to store its state.
Nc#�t"�VPpV'g\V^4pVR,pM'TpW4PR,,pVPpVEFwrgpV!WPVP
4p	V	'gK.Vez\
V4\Jd5VPWyP43x�V	P4VnM2V!W	V4Rjx�L
V'gW4PR,,pVEe_\V\4'd�VF�p
V
R8Xd9\VP4^8�dVPP4K@KBV
R8Xd/VPPVPR,4KwVPPV
4K�	M�\V\4'dB\V4\VP48�dVPRMOVPVR1M?VR8Xd.VPPVPR,4MQRT:24hW4PR,,pEK	VPVP
8�dR#WP,R8XdCR.VnVR,pVP\ R3x�V;P^,
unEK�VP\"WP,3x�V;P^,
unEK�ELG \$dR#i;i5i)	zg
Split ``text`` into (tokentype, text) pairs.
If ``context`` is given, use this lexer context instead.
r�Nr�r�r+r-rVr�)r#rr�rPr�r�r$r	r�rLr�r\r�rMr�r.rrr�)rArP�contextrr�r0r1r�r�r2r�s&&&        rrl�)ExtendedRegexLexer.get_tokens_unprocessedsb���
�L�L�	���t�Q�'�C�#�F�+�K��C�#�I�I�b�M�2�K��8�8�D��/:�+��)��T�7�7�C�G�G�4���1��)���<�:�5�"%�'�'�6�7�7�9�"<�<�&'�e�e�g�C�G�'-�d�s�';�;�;�#,�.7�	�	�"�
�.F�� �,�%�i��7�7�)2��#(�F�?�'*�3�9�9�~��'9�(+�	�	�
�
��(:�%*�g�%5�$'�I�I�$4�$4�S�Y�Y�r�]�$C�$'�I�I�$4�$4�U�$;�*3�(�	�3�7�7�"�9�~��S�Y�Y��?�$'�I�I�b�M�$'�I�I�i�j�$9�&�'�1��I�I�,�,�S�Y�Y�r�]�;�K�,=�i�]�*K�K�5�&/�	�	�"�
�&>���G0;�J
��w�w�#�'�'�)���G�G�}��,�%+�H��	�&/��&7��!�g�g�t�T�1�1����1��� ��'�'�5�$�w�w�-�7�7��G�G�q�L�G�G�Q<��R"����s]�A>L8�AL8�L#�L8�)FL8�,L&�L8�	AL&�L8�">L&� L8�&L5�1L8�4L5�5L8rr<)r+r,r-r.r/rlr0r1r2s@rrr	s�����@�@rc#�"�\V4p\V4wr#RpRpTF�wrgpTfTp^p	T'd~T\T4,T8�dgY�Y&,
p
T
'dYGT
3x�T\T
4,
pTFwr�p
YLT
3x�T\T
4,
pK 	Y&,
p	\T4wr#K�T	\T48gK�YGY�R3x�T\T4T	,
,
pK�	T'dAT;'g^pTFwr�pYGT3x�T\T4,
pK 	\T4wr#KHR# \dTRjx�L
R#i;i \dRpK�i;i \dRpR#i;i5i)aC
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.
NTF)�iter�next�
StopIterationr\)r�rrr�realpos�insleftr�rmrn�oldi�tmpval�it_index�it_token�it_value�ps&&             rr�r�Qs�����j�!�J���j�)����G��G����a��?��G����!�c�!�f�*��-��E�I�&�F���&�(�(��3�v�;�&��07�,��H���1�1��3�x�=�(��18��9�D�
�!%�j�!1���w��#�a�&�=��a��h�&�&��s�1�v��}�$�G�+�0��,�,�Q���G�A�!��a�-���s�1�v��G��	�!�*�-�N�E�7���E��������4!�
����
�� �	��G��	�s��E;�
D6�E;�A-E;�&
E�3E;�,E;�4E;�='E;�%
E'�2E;�6E�E	�E�E;�E�E;�
E$� E;�#E$�$E;�'
E8�4E;�7E8�8E;c�*a�]tRtRtoRtRtRtVtR#)�ProfilingRegexLexerMetai�z>Metaclass for ProfilingRegexLexer, collects regex timing info.c�aaaa�\V\4'd.\VPVPVPR7oMVo\
P!SV4o\P3VVVV3RllpV#)r�c�.<�SPR,PS
S	3^R.4p\P!4pSPWV4p\P!4pV^;;,^,
uu&V^;;,Wd,
,
uu&V#)r,rr�)�
_prof_data�
setdefault�timer�)rPr��endpos�info�t0�res�t1r��compiledr
r�s&&&    ����r�
match_func�:ProfilingRegexLexerMeta._process_regex.<locals>.match_func�sn����>�>�"�%�0�0�%����3�x�H�D�����B��.�.��F�3�C�����B���G�q�L�G���G�r�w��G��Jr)	rLrrr�r�r�r��sys�maxsize)r�r�r�r�rZrYr
sf&&f @@rr��&ProfilingRegexLexerMeta._process_regex�s]����e�U�#�#��E�K�K����#(�<�<�1�C��C��:�:�c�6�*��),���	�	��rrN)r+r,r-r.r/r�r0r1r2s@rrNrN�s����H��rrNc�6a�]tRtRtoRt.t^tRRltRtVt	R#)�ProfilingRegexLexeri�zFDrop-in replacement for RegexLexer that does profiling of its regexes.c#�na"�SPPP/4\P	SW4Rjx�L
SPPP4p\
RVP44V3RlRR7p\RV44p\4\RSPP\V4V3,4\R4\R:R
R	R
:R
R24\R4VFp\R
V,4K	\R4R#L�5i)Nc3��"�TFWwwrwr4V\V4PR4PRR4R,VRV,RV,V,3x�KY	R#5i)zu'z\\�\:N�ANi�N)�reprr_rT)�.0r��r�nrms&    r�	<genexpr>�=ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<genexpr>�sZ���@�/>�+�F�Q�F�Q��4��7�=�=��/�7�7���E�c�J��4�!�8�T�A�X��\�3�/>�s�AA!c�*<�VSP,#rk)�_prof_sort_index)rrAs&�rr�<ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<lambda>�s���A�d�&;�&;�$<rT)�key�reversec3�2"�TF
q^,x�K	R#5i)�Nr)rfrs& rrirj�s���+�d��!���d�s�z2Profiling result for %s lexing %d chars in %.3f msr��20� r��64z ncalls  tottime  percallz%-20s %-65s %5d %8.4f %8.4fzn==============================================================================================================zn--------------------------------------------------------------------------------------------------------------)rGrQrMrrlr��sortedr�sum�printr+r\)rArPr��rawdatar��	sum_totalr)sf&&    rrl�*ProfilingRegexLexer.get_tokens_unprocessed�s��������!�!�(�(��,��4�4�T�4�G�G�G��.�.�+�+�/�/�1���@�/6�}�}��@�=�"�	$��
�+�d�+�+�	�
��
�B��~�~�&�&��D�	�9�=�>�	?�
�i��
���I�J�
�i���A��/�!�3�4��
�i��#	H�s�?D5�D3�C1D5rNr4)
r+r,r-r.r/rQrlrlr0r1r2s@rr`r`�s����P��J����rr`)
rrrrrrr�r�r�r�rr�line_re))srU)s��zutf-32)s��zutf-32be)s��zutf-16)s��zutf-16be)6r/r�r\rS�pygments.filterrr�pygments.filtersr�pygments.tokenrrrrr	�
pygments.utilr
rrr
rr�pygments.regexoptr�__all__r�r{rZ�staticmethod�_default_analyser$r!rrrXrr�r�r�r�r�r�r�r�r�rrr�rrrr�rNr`rrr�<module>r�sJ���
�
��1�/�E�E�*�*�'�*��
�*�*�W�
��,�
� �
�.��	1��	1�m"�i�m"�`O�e�O�N	�c�	����*��

�u�

���6�4��
�w��/�d	�	�
M�F�
M� d1�Y�d1�N^��.�^�BL�L�E��E�P=�@�n��,�*�0G�r

Youez - 2016 - github.com/yon3zu
LinuXploit