403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/werkzeug/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/werkzeug/__pycache__/urls.cpython-311.pyc
�

��b����
�UdZddlZddlZddlZddlZddlmZddlmZddlm	Z	ddlm
Z
ddlmZejrdd	l
mZejd
��Zeed����ZdZd
�eD��Zd�ed��D��ZGd�dej��ZGd�de��ZGd�de��ZGd�de��Ze��eiZejej e!eje"e!ffe#d<	dZdej$e%e"fdej$e%e"fde"fd�Z&dej$ej'e%e%fej(ej)e%e%ffde%d e*d!ej+ej,ej)e%e%fgej-fdej.e%f
d"�Z/dZd#e%de%de%fd$�Z0	d[d&e%d'ej+e%d(e*defd)�Z1				d\de%d-e%d.ej$e%e"fdej$e%e"fdej,e"ge%ff
d/�Z2e2��Z3e2d0d1�2��Z4de"de%fd3�Z5				d\dej$e%e"fde%d-e%d.ej$e%e"fdej$e%e"fde%fd4�Z6	d]de%de%d-e%d.e%de%f
d5�Z7d6ej)e%e%e%e%e%fde%fd7�Z8			d^d9ej$e%e"fde%d-e%de%de%f
d:�Z9	d_d9ej$e%e"fde%d-e%de%fd;�Z:d`d9e%de%de%fd<�Z;d�<d=�ed>��D����Z=d?e>dej)e%e!ffd@�Z?ej@dAe?��		dadBej$e%ej)e%e%e%e%e%ffde%d-e%de%fdC�ZAdDZB			dbdFej$e%ej)e%e%e%e%e%ffde%d-e%dGe*de%f
dH�ZC					dcd9ejDde%dJe*d-e%dKe%dLej+ejEdMddNfdO�ZF						dddQejGe"de%dJe*d-e%dKe"dLej+ejEdMdRej+e!ddNfdS�ZHdTej(ejDde%dJe*d-e%dej.ej)e%e%ff
dU�ZI				dedej$ej'e%e%fej(ej)e%e%ffde%d e*d!ej+ej,ej)e%e%fgej-fdKe%de%fdV�ZJ					dfdej$ej'e%e%fej(ej)e%e%ffdQej+ejGe%de%d e*d!ej+ej,ej)e%e%fgej-fdKe%ddfdW�ZK	dgdXej$e%ej)e%e%e%e%e%ffd&ej$e%ej)e%e%e%e%e%ffd(e*de%fdY�ZLdS)hz�Functions for working with URLs.

Contains implementations of functions from :mod:`urllib.parse` that
handle bytes and strings.
�N�)�_check_str_tuple)�_decode_idna)�_encode_idna)�_make_encode_wrapper)�_to_str)�datastructuresz^[a-zA-Z0-9+-.]+$sKabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~$!'()*+,;�0123456789ABCDEFabcdefc�z�i|]8}tD].}|�|���d��t|�|��d����/�9S)�ascii�)�
_hexdigits�encode�int)�.0�a�bs   �//usr/lib/python3/dist-packages/werkzeug/urls.py�
<dictcomp>r#si�����	�
���	
�	�I�!�I�I���W���s�a�9��9�9�b�1�1�����c�@�g|]}d|d���d����S)�%�02Xr)r)r�chars  r�
<listcomp>r(s.��
D�
D�
D��n�$�n�n�n�#�#�G�,�,�
D�
D�
Dr�c�B�eZdZUeed<eed<eed<eed<eed<dS)�	_URLTuple�scheme�netloc�path�query�fragmentN)�__name__�
__module__�__qualname__�str�__annotations__�rrrr+s=��������K�K�K��K�K�K�

�I�I�I��J�J�J��M�M�M�M�Mrrc���eZdZUdZdZeed<eed<eed<eed<defd�Zd	ej	ddfd
�Z
edejefd���Z
edejefd���Zedejefd
���Zedejefd���Zedejefd���Zedejefd���Zedejefd���Zedejefd���Zdej	d	ej	ddfd�Zdej	d	ej	ddfd�Zdefd�Zdefd�Zdefd�Zd"d�Zd"d�Z	d#dejedejejeejeffd�Zdejejeeffd�Zdejejeejeffd �Z dejejeejeffd!�Z!dS)$�BaseURLz7Superclass of :py:class:`URL` and :py:class:`BytesURL`.r)�_at�_colon�	_lbracket�	_rbracket�returnc�*�|���S�N)�to_url��selfs r�__str__zBaseURL.__str__<s���{�{�}�}�r�kwargsc��|jdi|��S)z�Return an URL with the same values, except for those parameters
        given new values by whichever keyword arguments are specified.r))�_replace)r5r7s  r�replacezBaseURL.replace?s���t�}�&�&�v�&�&�&rc�6�|���dS)z�The host part of the URL if available, otherwise `None`.  The
        host is either the hostname or the IP address mentioned in the
        URL.  It will not contain the port.
        r)�_split_hostr4s r�hostzBaseURL.hostDs�����!�!�!�$�$rc���|j}|�Lt|t��r7	t|��}n&#t$r|�dd��}YnwxYwt
|dd��S)a Works exactly like :attr:`host` but will return a result that
        is restricted to ASCII.  If it finds a netloc that is not ASCII
        it will attempt to idna decode it.  This is useful for socket
        operations when the URL might include internationalized characters.
        Nr�ignore)r=�
isinstancer'r�UnicodeErrorrr�r5�rvs  r�
ascii_hostzBaseURL.ascii_hostLsv���Y��
�>�j��S�1�1�>�
2�!�"�%�%�����
2�
2�
2��Y�Y�w��1�1����
2�����r�7�H�-�-�-s�0� A�Ac���	tt|���d����}d|cxkrdkrnn|Sn#ttf$rYnwxYwdS)z}The port in the URL as an integer if it was present, `None`
        otherwise.  This does not fill in default ports.
        rri��N)rrr<�
ValueError�	TypeErrorrBs  r�portzBaseURL.port[s��
	��W�T�-�-�/�/��2�3�3�4�4�B��B�����%�������	����I�&�	�	�	��D�	�����ts�AA	�	A�Ac�6�|���dS)zSThe authentication part in the URL if available, `None`
        otherwise.
        r)�
_split_netlocr4s r�authzBaseURL.authhs��
�!�!�#�#�A�&�&rc�\�|���d}|�t|��SdS)z�The username if it was part of the URL, `None` otherwise.
        This undergoes URL decoding and will always be a string.
        rN��_split_auth�_url_unquote_legacyrBs  r�usernamezBaseURL.usernameo�2��
�
�
�
�
��
"��
�>�&�r�*�*�*��trc�6�|���dS)z�The username if it was part of the URL, `None` otherwise.
        Unlike :attr:`username` this one is not being decoded.
        r�rNr4s r�raw_usernamezBaseURL.raw_usernamey���
���!�!�!�$�$rc�\�|���d}|�t|��SdS)z�The password if it was part of the URL, `None` otherwise.
        This undergoes URL decoding and will always be a string.
        rNrMrBs  r�passwordzBaseURL.password�rQrc�6�|���dS)z�The password if it was part of the URL, `None` otherwise.
        Unlike :attr:`password` this one is not being decoded.
        rrSr4s r�raw_passwordzBaseURL.raw_password�rUr�args�ds.MultiDict[str, str]c�,�t|jg|�Ri|��S)z�Decodes the query part of the URL.  Ths is a shortcut for
        calling :func:`url_decode` on the query argument.  The arguments and
        keyword arguments are forwarded to :func:`url_decode` unchanged.
        )�
url_decoder"�r5rZr7s   r�decode_queryzBaseURL.decode_query�s$��
�$�*�6�t�6�6�6�v�6�6�6rc�<�tt|g|�Ri|����S)z�Joins this URL with another one.  This is just a convenience
        function for calling into :meth:`url_join` and then parsing the
        return value again.
        )�	url_parse�url_joinr^s   r�joinzBaseURL.join�s*��
��$�8��8�8�8��8�8�9�9�9rc� �t|��S)z�Returns a URL string or bytes depending on the type of the
        information stored.  This is just a convenience function
        for calling :meth:`url_unparse` for this URL.
        )�url_unparser4s rr3zBaseURL.to_url�s��
�4� � � rc��|jpd}d|vrd|�d�}|j}|�|�d|��}d�tdt	|jpdddd��t	|jpdddd��g����}|r|�d	|��}|S)
z6Encodes the netloc part to an ASCII safe URL as bytes.��:�[�]N�utf-8�strictz/:%�@)rDrHrc�filter�	url_quoterTrY�r5rCrHrKs    r�
encode_netloczBaseURL.encode_netloc�s���
�_�
"����"�9�9��R����B��y����������B��x�x����d�/�5�2�w��%�P�P��d�/�5�2�w��%�P�P��
�
�
�
���	 ����2���B��	rc
��t|jpd��}d|vrd|�d�}|j}|�|�d|��}d�t	dt|jpdd��t|jpdd��g����}|r|�d|��}|S)z&Decodes the netloc part into a string.rgrhrirjNz/:%@rm)rr=rHrcrnrOrTrYrps    r�
decode_netloczBaseURL.decode_netloc�s���
�$�)�/�r�
*�
*���"�9�9��R����B��y����������B��x�x���'��(9�(?�R��H�H�'��(9�(?�R��H�H��
�
�
�
���	 ����2���B��	rc�:�tt|����S)a*Returns a :class:`BytesURL` tuple that holds a URI.  This will
        encode all the information in the URL properly to ASCII using the
        rules a web browser would follow.

        It's usually more interesting to directly call :meth:`iri_to_uri` which
        will return a string.
        )ra�
iri_to_urir4s r�to_uri_tuplezBaseURL.to_uri_tuple�s����D�)�)�*�*�*rc�:�tt|����S)aSReturns a :class:`URL` tuple that holds a IRI.  This will try
        to decode as much information as possible in the URL without
        losing information similar to how a web browser does it for the
        URL bar.

        It's usually more interesting to directly call :meth:`uri_to_iri` which
        will return a string.
        )ra�
uri_to_irir4s r�to_iri_tuplezBaseURL.to_iri_tuple�s����D�)�)�*�*�*rN�
pathformatc��|jdkrdSt|j��}|jpd}|�tjdkrd}nd}|dkr�|dd�dkr?|dd	����r#|d	d
�dvr|dd	��d|d
d���}|dd
�d
v}ddl}|�|��}|rN|�L|�	d���
dd��}t|��d	kr|\}}n=|d}d}n2|dkrddl}|�|��}ntd|�����|dvrd}||fS)a@Returns a tuple with the location of the file in the form
        ``(server, location)``.  If the netloc is empty in the URL or
        points to localhost, it's represented as ``None``.

        The `pathformat` by default is autodetection but needs to be set
        when working with URLs of a specific system.  The supported values
        are ``'windows'`` when working with Windows or DOS paths and
        ``'posix'`` when working with posix paths.

        If the URL does not point to a local file, the server and location
        are both represented as ``None``.

        :param pathformat: The expected format of the path component.
                           Currently ``'windows'`` and ``'posix'`` are
                           supported.  Defaults to ``None`` which is
                           autodetect.
        �file�NNN�nt�windows�posixr�/��z|:rh)z\\\z///r�\rgzInvalid path format )z	127.0.0.1z::1�	localhost)r�url_unquoter!r �os�name�isalpha�ntpath�normpath�lstrip�split�len�	posixpathrG)r5rzr!r=�
windows_sharer��partsr�s        r�get_file_locationzBaseURL.get_file_location�s���(�;�&� � ��:��4�9�%�%���{�"�d�����w�$���&�
�
�$�
���"�"��B�Q�B�x�3���4��!��9�#4�#4�#6�#6��4��!��9��;L�;L��q��s�)�0�0�d�1�2�2�h�0�0�� ��!��H�(;�;�M��M�M�M��?�?�4�(�(�D�
�
������D�)�)�/�/��a�8�8���u�:�:��?�?�!&�J�D�$�$� ��8�D��D��
�7�
"�
"������%�%�d�+�+�D�D��A�:�A�A�B�B�B��4�4�4��D��T�z�rc�~�|j|jvr'|j�|j��\}}}||fSd|jfSr2)r,r �	partition)r5rK�_r s    rrJzBaseURL._split_netloc$sE���8�t�{�"�"�"�k�3�3�D�H�=�=�O�D�!�V���<���T�[� � rc��|���d}|sdS|j|vr|dfS|�|j��\}}}||fS)Nrr})rJr-r�)r5rKrPr�rWs     rrNzBaseURL._split_auth*sa���!�!�#�#�A�&���	��:��;�d�"�"���:�� $���t�{� ;� ;���!�X���!�!rc��|���d}|sdS|�|j��s/|j|vr"|�|j��\}}}||fS|dfS|�|j��}|dkr|dfS|d|�}||dzd�}|�|j��r||dd�fS|dfS)Nrr}r)rJ�
startswithr.r-r��findr/)r5rCr=r�rH�idx�rests       rr<zBaseURL._split_host4s���
�
�
�
!�
!�!�
$���	��:��}�}�T�^�,�,�	��{�b� � � "���T�[� 9� 9�
��a���T�z�!��t�8�O��g�g�d�n�%�%����7�7��t�8�O��!�C�%�y���#��'�)�)�}���?�?�4�;�'�'�	"���a�b�b��>�!��T�z�r)r0r+r2)"r$r%r&�__doc__�	__slots__r'r(r6�t�Anyr:�property�Optionalr=rDrrHrKrPrTrWrYr_rcr3rqrsrvry�Tupler�rJrNr<r)rrr+r+3s��������A�A��I�	�H�H�H��K�K�K��N�N�N��N�N�N�������'���'�)�'�'�'�'�
�%�a�j��o�%�%�%��X�%��.�A�J�s�O�.�.�.��X�.��
�a�j��o�
�
�
��X�
��'�a�j��o�'�'�'��X�'���!�*�S�/�����X���%�a�j��o�%�%�%��X�%���!�*�S�/�����X���%�a�j��o�%�%�%��X�%�7�!�%�7�1�5�7�=U�7�7�7�7�:�!�%�:�1�5�:�Y�:�:�:�:�!��!�!�!�!��s�����*�s�����,+�+�+�+�	+�	+�	+�	+�-1�<�<��*�S�/�<�	
����C��!�*�S�/�1�	2�<�<�<�<�|!�q�w�q�z�#���';�<�!�!�!�!�"�Q�W�Q�Z��_�a�j��o�%E�F�"�"�"�"��Q�W�Q�Z��_�a�j��o�%E�F������rr+c�<�eZdZdZdZdZdZdZdZdd	e	d
e	ddfd
�Z
dS)�URLz�Represents a parsed URL.  This behaves like a regular tuple but
    also has some extra attributes that give further insight into the
    URL.
    r)rmrhrirjrkr:�charset�errorsr0�BytesURLc
��t|j�d��|���|j�||��|j�||��|j�||����S)z�Encodes the URL to a tuple made out of bytes.  The charset is
        only being used for the path, query and fragment.
        r)r�rrrqr!r"r#�r5r�r�s   rrz
URL.encodeVsw����K���w�'�'���� � ��I���W�f�-�-��J���g�v�.�.��M� � ��&�1�1�
�
�	
rN�rkr:)r$r%r&r�r�r,r-r.r/r'rr)rrr�r�Jsg��������
�I�

�C�
�F��I��I�

�

�c�

�S�

��

�

�

�

�

�

rr�c�T�eZdZdZdZdZdZdZdZde	fd�Z
defd	�Zdde	d
e	ddfd�Z
dS)r�z!Represents a parsed URL in bytes.r)�@�:�[�]r0c�R�|����dd��S)Nrkr:)r3�decoder4s rr6zBytesURL.__str__ls ���{�{�}�}�#�#�G�Y�7�7�7rc��|jS)z&Returns the netloc unchanged as bytes.)r r4s rrqzBytesURL.encode_netlocos
���{�rrkr:r�r�r�c
��t|j�d��|���|j�||��|j�||��|j�||����S)z�Decodes the URL to a tuple made out of strings.  The charset is
        only being used for the path, query and fragment.
        r)r�rr�rsr!r"r#r�s   rr�zBytesURL.decodessw����K���w�'�'���� � ��I���W�f�-�-��J���g�v�.�.��M� � ��&�1�1�
�
�	
rNr�)r$r%r&r�r�r,r-r.r/r'r6�bytesrqr�r)rrr�r�cs�������+�+��I�
�C�
�F��I��I�8��8�8�8�8��u�����

�

�c�

�S�

��

�

�

�

�

�

rr��
_unquote_mapsrg�string�unsafer0c���t|t��r|�d��}t�t��r��d���tt	������t|�d����}t	t|d����}	t�}n?#t$r2�fd�t���D��x}t�<YnwxYw|D]s}|dd�}||vr9|�||��|�
|dd����I|�d��|�
|���tt|��S)Nrk�%rc�$��i|]\}}|�v�	||��
Sr)r))r�hrr�s   �rrz%_unquote_to_bytes.<locals>.<dictcomp>�s+���/
�/
�/
��Q��1�F�?�?�A�q�?�?�?rr��%)r@r'r�	frozenset�	bytearray�iterr��nextr��KeyError�
_hextobyte�items�append�extendr�)r�r��groups�result�hex_to_byte�group�codes `     r�_unquote_to_bytesr��s�����&�#���(����w�'�'���&�#���(����w�'�'��
�y��(�(�
)�
)�F�
�&�,�,�t�$�$�
%�
%�F�
�t�F�C�(�(�
)�
)�F�
�#�F�+�����
�
�
�/
�/
�/
�/
�'�-�-�/�/�/
�/
�/
�	
��m�F�+�+�+�
����
�!�!���R�a�R�y���;����M�M�+�d�+�,�,�,��M�M�%����)�$�$�$�$��M�M�"�����M�M�%� � � � ���=�=�s�2
C�9C<�;C<�objr��sort�keyc#�K�ddlm}||��}|rt||���}|D]�\}}|��t|t��s#t|���|��}n|}t|t��s#t|���|��}	n|}	t|���dt|	����V���dS)Nr)�iter_multi_items)r��=)r	r��sortedr@r�r'r�_fast_url_quote_plus)
r�r�r�r�r��iterable�key_str�	value_str�	key_bytes�value_bytess
          r�_url_encode_implr��s����1�0�0�0�0�0�.>�.>�s�.C�.C�H��-��(��,�,�,��&�W�W��������'�5�)�)�	 ��G���+�+�G�4�4�I�I��I��)�U�+�+�	$��i�.�.�/�/��8�8�K�K�#�K�%�i�0�0�V�V�3G��3T�3T�V�V�V�V�V�V�W�Wr�valuec�n�	t|dd|���S#t$rt|d|���cYSwxYw)Nrkrl)r�r�r��latin1)r�r�)r�rA)r�r�s  rrOrO�sY��C��5�'�(�6�R�R�R�R���C�C�C��5�(�6�B�B�B�B�B�B�C���s��4�4T�urlr�allow_fragmentsc�*�
�t|���
t|t��}|��
d��}�
d��x}x}}|��
d����}|dkryt�t
|d|�d�����rH||dzd�}|rt�
fd�|D����r|d|����|}}|dd	��
d
��kr�t|��}	�
d��D].}
|�|
d	��}|dkrt|	|��}	�/|d	|	�||	d�}}�
d��|vr
�
d
��|vs�
d
��|vr�
d��|vrtd���|r/�
d��|vr"|��
d��d��\}}�
d��|vr"|��
d��d��\}}|rtnt}||||||��S)aParses a URL from a string into a :class:`URL` tuple.  If the URL
    is lacking a scheme it can be provided as second argument. Otherwise,
    it is ignored.  Optionally fragments can be stripped from the URL
    by setting `allow_fragments` to `False`.

    The inverse of this function is :func:`url_unparse`.

    :param url: the URL to parse.
    :param scheme: the default schema to use if the URL is schemaless.
    :param allow_fragments: if set to `False` a fragment will be removed
                            from the URL.
    Nrgrhrr:)r�rc3�2�K�|]}|�d��vV��dS)�
0123456789Nr))r�c�ss  �r�	<genexpr>zurl_parse.<locals>.<genexpr>�s0�����B�B��1�A�A�l�O�O�3�B�B�B�B�B�Brr��//z/?#rirjzInvalid IPv6 URL�#�?)rr@r'r��
_scheme_re�matchr�any�lowerr��minrFr�r�r�)r�rr��
is_text_basedr r"r#�ir��delimr��wdelim�result_typer�s             @rrara�sQ���	�S�!�!�A��s�C�(�(�M�
�~���2���� !��"���%�F�%�U�X������3�����A��1�u�u��!�!�'�#�b�q�b�'�)�"D�"D�"D�E�E�u��1�q�5�7�7�|���	0�s�B�B�B�B�T�B�B�B�B�B�	0��b�q�b�'�-�-�/�/�4�C�F�
�2�A�2�w�!�!�D�'�'����C������5���	+�	+�A��X�X�a��^�^�F���{�{��E�6�*�*����!�E�'�l�C����K���
�A�c�F�F�f�����3���v�!5�!5�
�A�c�F�F�f�����3���v�!5�!5��/�0�0�0��-�1�1�S�6�6�S�=�=��	�	�!�!�C�&�&�!�,�,�
��X��q��v�v��}�}��Y�Y�q�q��v�v�q�)�)�
��U�&�4�#�#�H�K��;�v�v�s�E�8�<�<�<rrkrl�/:r��safec����t�t��r��||���t|t��r|�||��}tt	�����t
ztt	|����z
��fd�t
d��D���dtdtf�fd�}|S)a�Precompile the translation table for a URL encoding function.

    Unlike :func:`url_quote`, the generated function only takes the
    string to quote.

    :param charset: The charset to encode the result with.
    :param errors: How to handle encoding errors.
    :param safe: An optional sequence of safe characters to never encode.
    :param unsafe: An optional sequence of unsafe characters to always encode.
    c�B��g|]}|�vrt|��nd|d����S)rr)�chr)rr�r�s  �rrz(_make_fast_url_quote.<locals>.<listcomp>s3���F�F�F�a�q�D�y�y�S��V�V�V�k�!�k�k�k�F�F�Frrr�r0c�F��d��fd�|D����S)Nrgc� ��g|]
}�|��Sr)r))rr��tables  �rrz7_make_fast_url_quote.<locals>.quote.<locals>.<listcomp>s���1�1�1�Q��a��1�1�1r)rc)r�r�s �r�quotez#_make_fast_url_quote.<locals>.quotes*����w�w�1�1�1�1�&�1�1�1�2�2�2r)r@r'rr�r��_always_safe�ranger�)r�r�r�r�r�r�s  `  @r�_make_fast_url_quoter��s����� �$����,��{�{�7�F�+�+���&�#���0����w��/�/���i��o�o�&�&��5��9�V�CT�CT�9U�9U�U�D�F�F�F�F�5��:�:�F�F�F�E�3�e�3��3�3�3�3�3�3��Lr� �+)r�r�c�H�t|���dd��S)Nr�r�)�_fast_quote_plusr:)r�s rr�r�s ���F�#�#�+�+�C��5�5�5rc���t|tttf��st|��}t|t��r|�||��}t|t��r|�||��}t|t��r|�||��}tt|����tztt|����z
}t��}t|��D]<}||vr|�|���|�t|���=t|���
|��S)aDURL encode a single string with a given encoding.

    :param s: the string to quote.
    :param charset: the charset to be used.
    :param safe: an optional sequence of safe characters.
    :param unsafe: an optional sequence of unsafe characters.

    .. versionadded:: 0.9.2
       The `unsafe` parameter was added.
    )r@r'r�r�rr�r�r�r��
_bytetohexr�)r�r�r�r�r�rCrs       rroro#s2��"�f�s�E�9�5�6�6���V�����&�#���0����w��/�/���$����,��{�{�7�F�+�+���&�#���0����w��/�/���i��o�o�&�&��5��9�V�CT�CT�9U�9U�U�D�	���B��&�!�!�(�(���4�<�<��I�I�d�O�O�O�O��I�I�j��&�'�'�'�'���9�9���G�$�$�$rc�V�t||||dzd���dd��S)z�URL encode a single string with the given encoding and convert
    whitespace to "+".

    :param s: The string to quote.
    :param charset: The charset to be used.
    :param safe: An optional sequence of safe characters.
    r�r�)ror:)r�r�r�r�s    r�url_quote_plusrFs.���V�W�f�d�S�j�#�>�>�F�F�s�C�P�P�Pr�
componentsc��t|��|\}}}}}t|��}|d��}|s |rb|�|d����rD|r%|dd�|d��kr|d��|z}|d��|p
|d��z|z}n|r||z
}|r||d��z|z}|r||d��z|z}|r||d��z|z}|S)	z�The reverse operation to :meth:`url_parse`.  This accepts arbitrary
    as well as :class:`URL` tuples and returns a URL as a string.

    :param components: the parsed URL as tuple which should be converted
                       into a URL string.
    rgr�Nrr�rhr�r�)rrr�)rrr r!r"r#r�r�s        rrereSs0���Z� � � �,6�)�F�F�D�%���V�$�$�A�
�!�B�%�%�C���&��T�_�_�Q�Q�s�V�V�4�4���	!�D��!��H���#���&�&��1�S�6�6�D�=�D��a��g�g���1�1�R�5�5�)�D�0���	
���t���
�$��q�q��v�v�o��#���#��A�A�c�F�F�l�U�"���&��A�A�c�F�F�l�X�%���Jrr:r�c�V�t||��}|�|S|�||��S)afURL decode a single string with a given encoding.  If the charset
    is set to `None` no decoding is performed and raw bytes are
    returned.

    :param s: the string to unquote.
    :param charset: the charset of the query string.  If set to `None`
        no decoding will take place.
    :param errors: the error handling for the charset decoding.
    )r�r�)r�r�r�r�rCs     rr�r�rs1��
�1�f�	%�	%�B����	�
�9�9�W�f�%�%�%rc��t|t��r|�dd��}n|�dd��}t|||��S)a�URL decode a single string with the given `charset` and decode "+" to
    whitespace.

    Per default encoding errors are ignored.  If you want a different behavior
    you can set `errors` to ``'replace'`` or ``'strict'``.

    :param s: The string to unquote.
    :param charset: the charset of the query string.  If set to `None`
        no decoding will take place.
    :param errors: The error handling for the `charset` decoding.
    r�r��+� )r@r'r:r�)r�r�r�s   r�url_unquote_plusr�sP���!�S���"�
�I�I�c�3�����
�I�I�d�D�!�!���q�'�6�*�*�*rc���t||d���dd��}|�d��r5|dd����r|dd�dvr
d	|dd
���}t	|��}t|j|d���}t|j|d
���}t|j	|d
���}t|j|���|||f��S)aSometimes you get an URL by a user that just isn't a real URL because
    it contains unsafe characters like ' ' and so on. This function can fix
    some of the problems in a similar way browsers handle data entered by the
    user:

    >>> url_fix('http://de.wikipedia.org/wiki/Elf (Begriffskl\xe4rung)')
    'http://de.wikipedia.org/wiki/Elf%20(Begriffskl%C3%A4rung)'

    :param s: the string with the URL to fix.
    :param charset: The target charset for the URL if the url was given
        as a string.
    r:r�r�zfile://���
)z:/z|/zfile:///Nz
/%+$!*'(),)r�z:&%=+$!*'(),)
rr:r�r�raror!rr"r#rerrq)r�r�r�r!�qs�anchors      r�url_fixr�s��� 	��7�I�&�&�.�.�t�S�9�9�A�	�|�|�I����1�Q�q�S�6�>�>�#3�#3���!�B�$��<�8O�8O��q����u����
�A�,�,�C��S�X�w�\�:�:�:�D�	��	�7��	@�	@�	@�B�
�C�L�'��
G�
G�
G�F���
�C�$5�$5�$7�$7��r�6�J�K�K�Krc�>�g|]}|tv�t|����Sr))r�r�)rr�s  rrr�s(��N�N�N�Q���8M�8M�#�a�&�&�8M�8M�8Mr��ec�`�t|j|j|j���}||jfS)zRUsed in :func:`uri_to_iri` after unquoting to re-quote any
    invalid bytes.
    )�_fast_url_quote�object�start�end)r�outs  r�_codec_error_url_quoter�s,���!�(�1�7�Q�U�?�3�
4�
4�C����:�r�werkzeug.url_quote�uric��t|t��rt|��}tt	||����}t|j||t��}t|j||t��}t|j	||t��}t|j
|���|||f��S)a�Convert a URI to an IRI. All valid UTF-8 characters are unquoted,
    leaving all reserved and invalid characters quoted. If the URL has
    a domain, it is decoded from Punycode.

    >>> uri_to_iri("http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF")
    'http://\u2603.net/p\xe5th?q=\xe8ry%DF'

    :param uri: The URI to convert.
    :param charset: The encoding to encode unquoted bytes with.
    :param errors: Error handler to use during ``bytes.encode``. By
        default, invalid bytes are left quoted.

    .. versionchanged:: 0.15
        All reserved and invalid characters remain quoted. Previously,
        only some reserved characters were preserved, and invalid bytes
        were replaced instead of left quoted.

    .. versionadded:: 0.6
    )r@�tuplererarr�r!�_to_iri_unsafer"r#rrs)rr�r�r!r"r#s      rrxrx�s���0�#�u�����#����
�G�C��)�)�
*�
*�C��s�x��&�.�A�A�D���	�7�F�N�C�C�E��3�<��&�.�I�I�H���
�C�$5�$5�$7�$7��u�h�O�P�P�Prz:/?#[]@!$&'()*+,;=%F�iri�safe_conversionc�B�t|t��rt|��}|r]	t|��}|�d��}t|�����dkr|Sn#t$rYnwxYwtt|||����}t|j
||t��}t|j||t��}t|j
||t��}t|j|���|||f��S)aConvert an IRI to a URI. All non-ASCII and unsafe characters are
    quoted. If the URL has a domain, it is encoded to Punycode.

    >>> iri_to_uri('http://\u2603.net/p\xe5th?q=\xe8ry%DF')
    'http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF'

    :param iri: The IRI to convert.
    :param charset: The encoding of the IRI.
    :param errors: Error handler to use during ``bytes.encode``.
    :param safe_conversion: Return the URL unchanged if it only contains
        ASCII characters and no whitespace. See the explanation below.

    There is a general problem with IRI conversion with some protocols
    that are in violation of the URI specification. Consider the
    following two IRIs::

        magnet:?xt=uri:whatever
        itms-services://?action=download-manifest

    After parsing, we don't know if the scheme requires the ``//``,
    which is dropped if empty, but conveys different meanings in the
    final URL if it's present or not. In this case, you can use
    ``safe_conversion``, which will return the URL unchanged if it only
    contains ASCII characters and no whitespace. This can result in a
    URI with unquoted characters if it was not already quoted correctly,
    but preserves the URL's semantics. Werkzeug uses this for the
    ``Location`` header for redirects.

    .. versionchanged:: 0.15
        All reserved characters remain unquoted. Previously, only some
        reserved characters were left unquoted.

    .. versionchanged:: 0.9.6
       The ``safe_conversion`` parameter was added.

    .. versionadded:: 0.6
    rr)r@r!rerrr�r�rAraror!�_to_uri_safer"r#rrq)	r#r�r�r$�
native_iri�	ascii_irir!r"r#s	         rruru�s��V�#�u�����#������	� ����J�"�)�)�'�2�2�I��9�?�?�$�$�%�%��*�*�!�!�+���	�	�	��D�	�����G�C��&�1�1�
2�
2�C��S�X�w���=�=�D��c�i��&�,�?�?�E����w���E�E�H���
�C�$5�$5�$7�$7��u�h�O�P�P�Ps�A
A4�4
B�B�&�
include_empty�	separator�clszds.MultiDictr[c�x�|�ddlm}|}t|t��r-t|t��s|�|pd��}nAt|t
��r,t|t
��s|�|pd��}|t|�|��|||����S)awParse a query string and return it as a :class:`MultiDict`.

    :param s: The query string to parse.
    :param charset: Decode bytes to string with this charset. If not
        given, bytes are returned as-is.
    :param include_empty: Include keys with empty values in the dict.
    :param errors: Error handling behavior when decoding bytes.
    :param separator: Separator character between pairs.
    :param cls: Container to hold result instead of :class:`MultiDict`.

    .. versionchanged:: 2.0
        The ``decode_keys`` parameter is deprecated and will be removed
        in Werkzeug 2.1.

    .. versionchanged:: 0.5
        In previous versions ";" and "&" could be used for url decoding.
        Now only "&" is supported. If you want to use ";", a different
        ``separator`` can be provided.

    .. versionchanged:: 0.5
        The ``cls`` parameter was added.
    Nr��	MultiDictr)	r	r/r@r'r�r�r�_url_decode_implr�)r�r�r*r�r+r,r/s       rr]r]3s���<�{�-�-�-�-�-�-����!�S���9�*�Y��"<�"<�9��$�$�W�%7��8�8�	�	�	�A�u�	�	�9�j��E�&B�&B�9��$�$�W�%7��8�8�	��3��
�G�G�I������	
�	
���r�&�stream�limitc�v�ddlm}||||��}t||||��}	|�ddlm}
|
}||	��S)a_Works like :func:`url_decode` but decodes a stream.  The behavior
    of stream and limit follows functions like
    :func:`~werkzeug.wsgi.make_line_iter`.  The generator of pairs is
    directly fed to the `cls` so you can consume the data while it's
    parsed.

    :param stream: a stream with the encoded querystring
    :param charset: the charset of the query string.  If set to `None`
        no decoding will take place.
    :param include_empty: Set to `False` if you don't want empty values to
                          appear in the dict.
    :param errors: the decoding error behavior.
    :param separator: the pair separator to be used, defaults to ``&``
    :param cls: an optional dict class to use.  If this is not specified
                       or `None` the default :class:`MultiDict` is used.
    :param limit: the content length of the URL data.  Not necessary if
                  a limited stream is provided.

    .. versionchanged:: 2.0
        The ``decode_keys`` and ``return_iterator`` parameters are
        deprecated and will be removed in Werkzeug 2.1.

    .. versionadded:: 0.8
    r)�make_chunk_iterNr.)�wsgir5r0r	r/)r2r�r*r�r+r,r3r5�	pair_iter�decoderr/s           r�url_decode_streamr9`sg��B&�%�%�%�%�%����	�5�9�9�I��y�'�=�&�I�I�G�
�{�-�-�-�-�-�-����3�w�<�<�rr7c#��K�|D]q}|s�t|��}|d��}||vr|�|d��\}}n|s�@|}|d��}t|||��t|||��fV��rdS)Nr�rrg)rr�r)	r7r�r*r��pairr��equalr�r�s	         rr0r0�s������
�
���	�� ��&�&����#�����D�=�=����E�1�-�-�J�C��� �
���C��A�b�E�E�E��S�'�6�2�2��U�G�V�4�4�
�	
�	
�	
�	
�
�
rc�l�t|d��}|�t||||����S)aURL encode a dict/`MultiDict`.  If a value is `None` it will not appear
    in the result string.  Per default only values are encoded into the target
    charset strings.

    :param obj: the object to encode into a query string.
    :param charset: the charset of the query string.
    :param sort: set to `True` if you want parameters to be sorted by `key`.
    :param separator: the separator to be used for the pairs.
    :param key: an optional function to be used for sorting.  For more details
                check out the :func:`sorted` documentation.

    .. versionchanged:: 2.0
        The ``encode_keys`` parameter is deprecated and will be removed
        in Werkzeug 2.1.

    .. versionchanged:: 0.5
        Added the ``sort``, ``key``, and ``separator`` parameters.
    r)rrcr�)r�r�r�r�r+s     r�
url_encoder>�s4��2�	�7�+�+�I��>�>�*�3���s�C�C�D�D�Drc���t|d��}t||||��}|�|St|��D]1\}}|r|�|��|�|���2dS)a�Like :meth:`url_encode` but writes the results to a stream
    object.  If the stream is `None` a generator over all encoded
    pairs is returned.

    :param obj: the object to encode into a query string.
    :param stream: a stream to write the encoded object into or `None` if
                   an iterator over the encoded pairs should be returned.  In
                   that case the separator argument is ignored.
    :param charset: the charset of the query string.
    :param sort: set to `True` if you want parameters to be sorted by `key`.
    :param separator: the separator to be used for the pairs.
    :param key: an optional function to be used for sorting.  For more details
                check out the :func:`sorted` documentation.

    .. versionchanged:: 2.0
        The ``encode_keys`` parameter is deprecated and will be removed
        in Werkzeug 2.1.

    .. versionadded:: 0.8
    rN)rr��	enumerate�write)	r�r2r�r�r�r+�genr��chunks	         r�url_encode_streamrD�s}��8�	�7�+�+�I�
�3���s�
3�
3�C�
�~��
���n�n���
��U��	$��L�L��#�#�#����U������4r�basec����t|t��rt|��}t|t��rt|��}t||f��t	|���|s|S|s|St||���\}}}}}t|||��\}}	}
}}||kr|S|	rt||	|
||f��S|}	|
dd��d��kr|
��d����}
nj|
s#|��d����}
|s|}nE|��d����dd�|
��d����z}
|
d�d��kr�d��|
d<�fd�|
D��}
	d}t|
��dz
}||krM|
|�d
��kr-|
|dz
�d���d
��fvr|
|dz
|dz�=n|dz
}||k�Mn�i�d���d
��g}|
dd�|kr|
d=|
dd�|k��d���|
��}
t||	|
||f��S)a	Join a base URL and a possibly relative URL to form an absolute
    interpretation of the latter.

    :param base: the base URL for the join operation.
    :param url: the URL to join.
    :param allow_fragments: indicates whether fragments should be allowed.
    )r�Nrr�����.rgc�2��g|]}|�d��k�|��S)rHr))r�segmentr�s  �rrzurl_join.<locals>.<listcomp>s+���E�E�E�G�7�a�a��f�f�3D�3D��3D�3D�3DrTz..r�)	r@r!rerrrar�r�rc)rEr�r��bscheme�bnetloc�bpath�bquery�	bfragmentrr r!r"r#�segmentsr��n�unwanted_markerr�s                 @rrbrb�s�����$����!��4� � ���#�u�����#�����d�C�[�!�!�!��T�"�"�A����
�����1:��o�2�2�2�.�G�W�e�V�Y�-6�c�7�O�,T�,T�)�F�F�D�%��
�����
�
�D��F�F�D�%��B�C�C�C�
�F��B�Q�B�x�1�1�S�6�6����:�:�a�a��f�f�%�%���
�A��;�;�q�q��v�v�&�&���	��E���;�;�q�q��v�v�&�&�s��s�+�d�j�j���3���.@�.@�@����|�q�q��v�v����q��u�u����F�E�E�E�x�E�E�E�H�	�
����M�M�A����!�e�e���{�a�a��g�g�%�%�(�1�q�5�/�!�!�B�%�%���4���AQ�*Q�*Q��Q��U�Q��U�]�+��
��F�A�	�!�e�e�
�	��q��u�u�a�a��g�g�&�O�
�2�A�2�,�/�
)�
)��Q�K��2�A�2�,�/�
)�
)�
�1�S�6�6�;�;�x� � �D�����e�X�>�?�?�?r)rg)NT)rkrlr�rg)rkrlrg)rkr:rgr�)rk)rkr)rkrlF)rkTr:r)N)rkTr:r1NN)rkFNr))NrkFNr))T)Mr��codecsr��re�typingr��	_internalrrrrr�
TYPE_CHECKINGrgr	�ds�compiler�r�r�r�rr�r�r�
NamedTuplerr+r�r�r��Dict�	FrozenSetrr�r(�Unionr'r��Mapping�Iterabler��boolr��Callabler��Iteratorr�rOrar�rrr�rorrer�rrrcr"rAr�register_errorrxr&ru�AnyStr�Typer]�IOr9r0r>rDrbr)rr�<module>rgs�����
�
�
�
�	�	�	�	�	�	�	�	�����'�'�'�'�'�'�#�#�#�#�#�#�#�#�#�#�#�#�+�+�+�+�+�+��������?�'�&�&�&�&�&�&��R�Z�,�
-�
-�
��y�
�I�	������&�
���
����
�
E�
D���s���
D�
D�
D�
�����������T�T�T�T�T�i�T�T�T�n
�
�
�
�
�'�
�
�
�2
�
�
�
�
�w�
�
�
�:@I�y�{�{�J�>W�
�q�v�a�k�#�&���u�c�z�(:�:�;�W�W�W�@B���
�G�C��J���)*���e��)<��
�����BW�	
����3��8�$�a�j����c��1B�&C�C�	D�W�
�W��W�
��A�J����S�� 1�2�A�E�9�:�	;�	W�
�Z��_�W�W�W�W�<C�C�s�C�C�C��C�C�C�C�GK�0=�0=�	�0=��j��o�0=�?C�0=��0=�0=�0=�0=�h�� $�"$�	��
�����'�#�u�*�
��
�G�C��J��	�
�Z����������>'�&�(�(��'�'�S��=�=�=��6��6�3�6�6�6�6��� $�"$� %� %�
�G�C��J�� %�
� %�
� %��'�#�u�*�
�	 %�

�G�C��J�� %�	�
 %� %� %� %�HNP�
Q�
Q��
Q��
Q�14�
Q�GJ�
Q��
Q�
Q�
Q�
Q��A�G�C��c�3��$;�<�������B���	&�&��w�s�E�z��&�
�&�
�&�
�	&�
	�&�&�&�&�,CL�+�+��w�s�E�z��+�%(�+�<?�+��+�+�+�+�*L�L�s�L�S�L�s�L�L�L�L�>���N�N�%�%��*�*�N�N�N�O�O���l��q�w�s�C�x�/@��������*�,B�C�C�C�
�&�Q�Q�	
���a�g�c�3��S�#�5�6�6�	7�Q�
�Q�
�Q�	�	Q�Q�Q�Q�F%��
��!�	?Q�?Q�	
���a�g�c�3��S�#�5�6�6�	7�?Q�
�?Q�
�?Q��	?Q�
	�?Q�?Q�?Q�?Q�H����.2�
*�*��x�*�
�*��*�
�	*�
�*�
��A�F�>�*�	+�
*��*�*�*�*�^����.2�!�+�+�
�D��K�+�
�+��+�
�	+�
�+�
��A�F�>�*�	+�
+�
�:�c�?�+��+�+�+�+�\
��z�!�(�#�
�.1�
�BF�
�PS�
��Z����S��!�"�
�
�
�
�.��>B��E�E�	
����3��8�$�a�j����c��1B�&C�C�	D�E�
�E��E�
��A�J����S�� 1�2�A�E�9�:�	;�	E�
�E�	�
E�E�E�E�>%)���>B��
$�$�	
����3��8�$�a�j����c��1B�&C�C�	D�$�
�J�q�t�C�y�!�$��$��	$�

��A�J����S�� 1�2�A�E�9�:�	;�$��
$�
�$�$�$�$�T!�D@�D@�
�'�#�q�w�s�C��c�3�6�7�7�
8�D@�	
���a�g�c�3��S�#�5�6�6�	7�D@��D@�	�	D@�D@�D@�D@�D@�D@r

Youez - 2016 - github.com/yon3zu
LinuXploit