Ë
    ¹ÿjÊe  ã                  ój  — d Z ddlmZ ddlZddlmZmZ ddlmZm	Z	m
Z
 ddlmZ ddlmZmZ dd	lmZ dd
lmZmZmZ ddlmZmZ erddlmZ  ej6                  e«      ZdZdZdZ dZ! e"d«      D � cg c]
  } d| z  dz
  ‘Œ c} Z#dZ$dd„Z%dd„Z&dd„Z'	 	 d d„Z(d!d„Z) G d„ d«      Z* G d„ d«      Z+yc c} w )"zL
Implements the HPACK header compression algorithm as detailed by RFC 7541.
é    )ÚannotationsN)ÚTYPE_CHECKINGÚAnyé   )ÚHPACKDecodingErrorÚInvalidTableSizeErrorÚOversizedHeaderListError)ÚHuffmanEncoder)ÚREQUEST_CODESÚREQUEST_CODES_LENGTH)Údecode_huffman)ÚHeaderTupleÚHeaderWeaklyTypedÚNeverIndexedHeaderTuple)ÚHeaderTableÚtable_entry_size)ÚIterableó    ó   ó   @é   é	   é   i   c                óÂ   — t        | d   «      }t        | d   «      }|s0| j                  |j                  d«      |j                  d«      «      S | j                  ||«      S )zj
    Provides a header as a unicode string if raw is False, otherwise returns
    it as a bytestring.
    r   r   úutf-8)ÚbytesÚ	__class__Údecode)ÚheaderÚrawÚnameÚvalues       úE/root/telegram-saas/.venv/lib/python3.12/site-packages/hpack/hpack.pyÚ_unicode_if_neededr$   %   s[   € ô
 �˜‘Ó€DÜ�&˜‘)Ó€EáØ×Ñ §¡¨GÓ 4°e·l±lÀ7Ó6KÓLÐLØ×Ñ˜D %Ó(Ð(ó    c                óX  — t         j                  d| |«       | dk  rd| › �}t        |«      ‚|dk  s|dkD  rd|› �}t        |«      ‚t        |   }| |k  rt	        | g«      S |g}| |z  } | dk\  r"|j                  | dz  dz   «       | d	z  } | dk\  rŒ"|j                  | «       t	        |«      S )
zi
    Encodes an integer according to the wacky integer encoding rules
    defined in the HPACK spec.
    zEncoding %d with %d bitsr   z'Can only encode positive integers, got r   é   ú)Prefix bits must be between 1 and 8, got é€   é   é   )ÚlogÚdebugÚ
ValueErrorÚ_PREFIX_BIT_MAX_NUMBERSÚ	bytearrayÚappend)ÚintegerÚprefix_bitsÚmsgÚ
max_numberÚelementss        r#   Úencode_integerr7   2   sÌ   € ô
 ‡I�IÐ(¨'°;Ô?à�‚{Ø7¸°yÐAˆÜ˜‹oÐà�Q‚˜+¨š/Ø9¸+¸ÐGˆÜ˜‹oÐä(¨Ñ5€Jà�ÒÜ˜'˜Ó#Ð#Øˆ|€HØˆzÑ€Gà
�SŠ.Ø�‰˜ 3™¨#Ñ-Ô.Ø�A‰ˆð �S‹.ð ‡O�O�GÔä�XÓÐr%   c                ó~  — |dk  s|dkD  rd|› �}t        |«      ‚t        |   }d}d}dd|z
  z	  }	 | d   |z  }||k(  rD	 | |   }|dz  }|dk\  r||dz
  |z  z  }n	|||z  z  }n|dz  }|t        kD  rd| ›�}t        |«      ‚ŒCt
        j                  d||«       ||fS # t        $ r}	d	| ›�}t        |«      |	‚d
}	~	ww xY w)zï
    Decodes an integer according to the wacky integer encoding rules
    defined in the HPACK spec. Returns a tuple of the decoded integer and the
    number of bytes that were consumed from ``data`` in order to get that
    integer.
    r   r'   r(   r   éÿ   r)   r+   z-Variable integer representation is too long: z3Unable to decode HPACK integer representation from NzDecoded %d, consumed %d bytes)r.   r/   ÚVARINT_MAX_LENGTHr   Ú
IndexErrorr,   r-   )
Údatar3   r4   r5   ÚindexÚshiftÚmaskÚnumberÚ	next_byteÚerrs
             r#   Údecode_integerrC   Q   s  € ð �Q‚˜+¨š/Ø9¸+¸ÐGˆÜ˜‹oÐä(¨Ñ5€JØ€EØ€EØ�Q˜‘_Ñ%€Dð/Ø�a‘˜4‘ˆØ�ZÒØØ  ™K�	Ø˜‘
�à Ò#Ø˜y¨3™°5Ñ8Ñ8‘Fà˜i¨5Ñ0Ñ0�FØØ˜‘
�àÔ,Ò,ð JÈ$ÈÐR�CÜ,¨SÓ1Ð1ð) ô4 ‡I�IÐ-¨v°uÔ=à�5ˆ=Ðøô ò /ØCÀDÀ8ÐLˆÜ  Ó%¨3Ð.ûð/ús   ±AB Â	B<Â&B7Â7B<c              #  ó¶   K  — t        | t        «      sdt        | «      › �}t        |«      ‚t	        | j                  «       d„ ¬«      }|D ]  }|| |   f–— Œ y­w)z¯
    Converts a dictionary to an iterable of key-value tuples. This is a
    HPACK-specific function because it pulls "special-headers" out first and
    then emits them.
    zheader_dict not a dict, but c                ó8   — t        | «      j                  d«       S )Nó   :)Ú	_to_bytesÚ
startswith)Úks    r#   ú<lambda>z#_dict_to_iterable.<locals>.<lambda>�   s   € œ) A›,×1Ñ1°$Ó7Ð7€ r%   )ÚkeyN)Ú
isinstanceÚdictÚtypeÚ	TypeErrorÚsortedÚkeys)Úheader_dictr4   rQ   rK   s       r#   Ú_dict_to_iterablerS   ƒ   sh   è ø€ ô �k¤4Ô(Ø,¬T°+Ó->Ð,?Ð@ˆÜ˜‹nÐäØ×ÑÓÙ7ô€Dð ò $ˆØ�;˜sÑ#Ð#Ó#ñ$ùs   ‚AAc                ót   — t        | «      }|t        u r| S |t        urt        | «      } | j                  d«      S )zB
    Convert anything to bytes through a UTF-8 encoded string
    r   )rN   r   ÚstrÚencode)r"   Úts     r#   rG   rG   –   s8   € ô 	ˆU‹€AØŒE�zØˆØ”�|Ü�E“
ˆØ�<‰<˜Ó Ð r%   c                  ó”   — e Zd ZdZdd„Zedd„«       Zej                  dd„«       Z	 d	 	 	 	 	 dd„Zddd„Z	dd„Z
ddd„Zddd	„Zdd
„Zy)ÚEncoderzm
    An HPACK encoder object. This object takes HTTP headers and emits encoded
    HTTP/2 header blocks.
    c                ób   — t        «       | _        t        t        t        «      | _        g | _        y ©N)r   Úheader_tabler
   r   r   Úhuffman_coderÚtable_size_changes©Úselfs    r#   Ú__init__zEncoder.__init__¨   s)   € Ü'›MˆÔÜ+ÜÔ/ó
ˆÔð .0ˆÕr%   c                ó.   — | j                   j                  S ©z>
        Controls the size of the HPACK header table.
        ©r\   Úmaxsizer_   s    r#   Úheader_table_sizezEncoder.header_table_size¯   ó   € ð
 × Ñ ×(Ñ(Ð(r%   c                óŠ   — || j                   _        | j                   j                  r| j                  j	                  |«       y y r[   )r\   re   Úresizedr^   r1   ©r`   r"   s     r#   rf   zEncoder.header_table_size¶   s8   € à$)ˆ×ÑÔ!Ø×Ñ×$Ò$Ø×#Ñ#×*Ñ*¨5Õ1ð %r%   c                ó$  — g }| j                   j                  r0|j                  | j                  «       «       d| j                   _        t	        |t
        «      rt        |«      }n	 t        |«      }|D ]s  }d}t	        |t        «      r|j                   }nt        |«      dkD  r|d   }t        |d   «      t        |d   «      f}|j                  | j                  |||«      «       Œu dj                  |«      }t        j                  d|«       |S )a€	  
        Takes a set of headers and encodes them into a HPACK-encoded header
        block.

        :param headers: The headers to encode. Must be either an iterable of
                        tuples, an iterable of :class:`HeaderTuple
                        <hpack.HeaderTuple>`, or a ``dict``.

                        If an iterable of tuples, the tuples may be either
                        two-tuples or three-tuples. If they are two-tuples, the
                        tuples must be of the format ``(name, value)``. If they
                        are three-tuples, they must be of the format
                        ``(name, value, sensitive)``, where ``sensitive`` is a
                        boolean value indicating whether the header should be
                        added to header tables anywhere. If not present,
                        ``sensitive`` defaults to ``False``.

                        If an iterable of :class:`HeaderTuple
                        <hpack.HeaderTuple>`, the tuples must always be
                        two-tuples. Instead of using ``sensitive`` as a third
                        tuple entry, use :class:`NeverIndexedHeaderTuple
                        <hpack.NeverIndexedHeaderTuple>` to request that
                        the field never be indexed.

                        .. warning:: HTTP/2 requires that all special headers
                            (headers whose names begin with ``:`` characters)
                            appear at the *start* of the header block. While
                            this method will ensure that happens for ``dict``
                            subclasses, callers using any other iterable of
                            tuples **must** ensure they place their special
                            headers at the start of the iterable.

                            For efficiency reasons users should prefer to use
                            iterables of two-tuples: fixing the ordering of
                            dictionary headers is an expensive operation that
                            should be avoided if possible.

        :param huffman: (optional) Whether to Huffman-encode any header sent as
                        a literal value. Except for use when debugging, it is
                        recommended that this be left enabled.

        :returns: A bytestring containing the HPACK-encoded header block.
        Fr   r   r   r%   zEncoded header block to %s)r\   ri   r1   Ú_encode_table_size_changerL   rM   rS   Úiterr   Ú	indexableÚlenrG   ÚaddÚjoinr,   r-   )	r`   ÚheadersÚhuffmanÚheader_blockÚhpack_headersr   Ú	sensitiveÚ
new_headerÚencodeds	            r#   rV   zEncoder.encode¼   s  € ðp ˆð ×Ñ×$Ò$Ø×Ñ × >Ñ >Ó @ÔAØ(-ˆD×ÑÔ%ä�gœtÔ$ô .¨gÓ6‰Mðô& ! ›MˆMð $ò 		JˆFØˆIÜ˜&¤+Ô.à &× 0Ñ 0Ð0‘	Ü�V“˜q’Ø" 1™I�	ä# F¨1¡IÓ.´	¸&À¹)Ó0DÐEˆJØ×Ñ §¡¨°YÀÓ HÕIð		Jð —(‘(˜<Ó(ˆä�	‰	Ð.°Ô8àˆr%   c                ó¨  — |\  }}|s|nd}t         j                  d||||«       |st        nt        }| j                  j                  ||«      }|€4| j                  ||||«      }	|s| j                  j                  ||«       |	S |\  }
}}|�| j                  |
«      }	|	S | j                  |
|||«      }	|s| j                  j                  ||«       |	S )a}  
        Serializes a header key-value tuple.

        When sensitive is True, the header will not be added to the header table
        (see https://www.rfc-editor.org/rfc/rfc7541.html#section-7.1.3 for details),
        furthermore, the header value will be redacted in debug logs, as "SENSITIVE_REDACTED",
        to prevent accidental exposure of sensitive information.
        s   SENSITIVE_REDACTEDz:Adding %s=%s to the header table, sensitive:%s, huffman:%s)
r,   r-   ÚINDEX_INCREMENTALÚINDEX_NEVERr\   ÚsearchÚ_encode_literalrp   Ú_encode_indexedÚ_encode_indexed_literal)r`   Úto_addrv   rs   r!   r"   Údisplay_valueÚindexbitÚmatchrx   r=   Úperfects               r#   rp   zEncoder.add)  sù   € ð ‰ˆˆeá%.™Ð4IˆÜ�	‰	ØHØØØØô	
ñ -6Õ$¼;ˆð ×!Ñ!×(Ñ(¨¨uÓ5ˆàˆ=ð ×*Ñ*¨4°¸À'ÓJˆGÙØ×!Ñ!×%Ñ% d¨EÔ2ØˆNð
  %Ñˆˆt�WàÐà×*Ñ*¨5Ó1ˆGð ˆð ×2Ñ2Ø�u˜h¨óˆGñ Ø×!Ñ!×%Ñ% d¨EÔ2àˆr%   c                óJ   — t        |d«      }|dxx   dz  cc<   t        |«      S )zD
        Encodes a header using the indexed representation.
        r+   r   r)   )r7   r   )r`   r=   Úfields      r#   r~   zEncoder._encode_indexeda  s(   € ô ˜u aÓ(ˆØˆa‹�DÑ‹Ü�U‹|Ðr%   c                óN  — |r6| j                   j                  |«      }| j                   j                  |«      }t        t        |«      d«      }t        t        |«      d«      }|r|dxx   dz  cc<   |dxx   dz  cc<   dj	                  |t        |«      |t        |«      |g«      S )z·
        Encodes a header with a literal name and literal value. If ``indexing``
        is True, the header will be added to the header table: otherwise it
        will not.
        r+   r   r)   r%   )r]   rV   r7   ro   rq   r   )r`   r!   r"   r‚   rs   Úname_lenÚ	value_lens          r#   r}   zEncoder._encode_literali  sš   € ñ Ø×%Ñ%×,Ñ,¨TÓ2ˆDØ×&Ñ&×-Ñ-¨eÓ4ˆEä!¤# d£)¨QÓ/ˆÜ"¤3 u£:¨qÓ1ˆ	áØ�Q‹K˜4Ñ‹KØ�a‹L˜DÑ ‹Là�x‰xØ”u˜X“¨¬e°IÓ.>ÀÐFó
ð 	
r%   c                ó@  — |t         k7  rt        |d«      }nt        |d«      }|dxx   t        |«      z  cc<   |r| j                  j	                  |«      }t        t        |«      d«      }|r|dxx   dz  cc<   dj                  t        |«      t        |«      |g«      S )zv
        Encodes a header with an indexed name and a literal value and performs
        incremental indexing.
        é   é   r   r+   r)   r%   )rz   r7   Úordr]   rV   ro   rq   r   )r`   r=   r"   r‚   rs   Úprefixr‰   s          r#   r   zEncoder._encode_indexed_literal~  s�   € ð
 Ô(Ò(Ü# E¨1Ó-‰Fä# E¨1Ó-ˆFàˆq‹	”S˜“]Ñ"‹	áØ×&Ñ&×-Ñ-¨eÓ4ˆEä"¤3 u£:¨qÓ1ˆ	áØ�a‹L˜DÑ ‹Là�x‰xœ˜v›¬¨iÓ(8¸%Ð@ÓAÐAr%   c                óˆ   — d}| j                   D ])  }t        |d«      }|dxx   dz  cc<   |t        |«      z  }Œ+ g | _         |S )zd
        Produces the encoded form of all header table size change context
        updates.
        r%   r   r   é    )r^   r7   r   )r`   ÚblockÚ
size_bytesÚbs       r#   rl   z!Encoder._encode_table_size_change”  sT   € ð
 ˆØ×1Ñ1ò 	ˆJÜ˜z¨1Ó-ˆAØˆa‹D�D‰L‹DØ”U˜1“XÑ‰Eð	ð #%ˆÔØˆr%   N©ÚreturnÚNone©r•   Úint©r"   r˜   r•   r–   )T)rr   z‡Iterable[HeaderTuple | tuple[bytes | str, bytes | str] | tuple[bytes | str, bytes | str, bool | None]] | dict[bytes | str, bytes | str]rs   Úboolr•   r   ©F)r€   ztuple[bytes, bytes]rv   rš   rs   rš   r•   r   )r=   r˜   r•   r   )
r!   r   r"   r   r‚   r   rs   rš   r•   r   )
r=   r˜   r"   r   r‚   r   rs   rš   r•   r   )r•   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__ra   Úpropertyrf   ÚsetterrV   rp   r~   r}   r   rl   © r%   r#   rY   rY   ¢   s‚   „ ñó
0ð ò)ó ð)ð ×Ñò2ó ð2ð  $ðkð2ðkð ðkð ).ókôZ6ópô
ô*Bô,r%   rY   c                  óŽ   — e Zd ZdZefdd„Zedd„«       Zej                  dd„«       Zddd„Z	dd„Z
dd„Zdd„Zdd	„Zdd
„Zdd„Zy)ÚDecodera  
    An HPACK decoder object.

    .. versionchanged:: 2.3.0
       Added ``max_header_list_size`` argument.

    :param max_header_list_size: The maximum decompressed size we will allow
        for any single header block. This is a protection against DoS attacks
        that attempt to force the application to expand a relatively small
        amount of data into a really large header list, allowing enormous
        amounts of memory to be allocated.

        If this amount of data is exceeded, a `OversizedHeaderListError
        <hpack.OversizedHeaderListError>` exception will be raised. At this
        point the connection should be shut down, as the HPACK state will no
        longer be usable.

        Defaults to 64kB.
    :type max_header_list_size: ``int``
    c                óf   — t        «       | _        || _        | j                  j                  | _        y r[   )r   r\   Úmax_header_list_sizere   Úmax_allowed_table_size)r`   r¦   s     r#   ra   zDecoder.__init__¸  s,   € Ü'›MˆÔð  %9ˆÔ!ð '+×&7Ñ&7×&?Ñ&?ˆÕ#r%   c                ó.   — | j                   j                  S rc   rd   r_   s    r#   rf   zDecoder.header_table_sizeÔ  rg   r%   c                ó&   — || j                   _        y r[   rd   rj   s     r#   rf   zDecoder.header_table_sizeÛ  s   € à$)ˆ×ÑÕ!r%   c                ó  — t         j                  d|«       t        |«      }g }t        |«      }d}d}||k  rÿ||   }t	        |dz  «      }	t	        |dz  «      }
t	        |dz  «      }|	r| j                  ||d «      \  }}nY|
r| j                  ||d «      \  }}n?|r&|rd}t        |«      ‚| j                  ||d «      }d}n| j                  ||d «      \  }}|rP|j                  |«       |t        |d   |d   «      z  }|| j                  kD  rd	| j                  › d
�}t        |«      ‚||z  }||k  rŒÿ| j                  «        	 |D �cg c]  }t        ||«      ‘Œ c}S c c}w # t         $ r}d}t        |«      |‚d}~ww xY w)aê  
        Takes an HPACK-encoded header block and decodes it into a header set.

        :param data: A bytestring representing a complete HPACK-encoded header
                     block.
        :param raw: (optional) Whether to return the headers as tuples of raw
                    byte strings or to decode them as UTF-8 before returning
                    them. The default value is False, which returns tuples of
                    Unicode strings
        :returns: A list of two-tuples of ``(name, value)`` representing the
                  HPACK-encoded headers, in the order they were decoded.
        :raises HPACKDecodingError: If an error is encountered while decoding
                                    the header block.
        zDecoding %sr   r)   é@   r�   Nz/Table size update not at the start of the blockr   zA header list larger than z has been receivedz!Unable to decode headers as UTF-8)r,   r-   Ú
memoryviewro   rš   Ú_decode_indexedÚ_decode_literal_indexr   Ú_update_encoding_contextÚ_decode_literal_no_indexr1   r   r¦   r	   Ú_assert_valid_table_sizer$   ÚUnicodeDecodeError)r`   r<   r    Údata_memrr   Údata_lenÚinflated_sizeÚcurrent_indexÚcurrentÚindexedÚliteral_indexÚencoding_updater   Úconsumedr4   ÚhrB   s                    r#   r   zDecoder.decodeß  sÙ  € ô 	�	‰	�- Ô&ä˜dÓ#ˆØ%'ˆÜ�t“9ˆØˆØˆà˜hÒ&ð ˜=Ñ)ˆGÜ˜7 T™>Ó*ˆGô ! ¨4¡Ó0ˆMô # 7¨T¡>Ó2ˆOáØ#'×#7Ñ#7Ø˜]˜^Ð,ó$Ñ �™ñ à#'×#=Ñ#=Ø˜]˜^Ð,ó$Ñ �™ñ !ñ ØK�CÜ,¨SÓ1Ð1Ø×8Ñ8Ø˜]˜^Ð,ó�ð ‘ð $(×#@Ñ#@Ø˜]˜^Ð,ó$Ñ �˜ñ Ø—‘˜vÔ&ØÔ!1°&¸±)¸VÀA¹YÓ!GÑG�à  4×#<Ñ#<Ò<Ø6°t×7PÑ7PÐ6QÐQcÐd�CÜ2°3Ó7Ð7à˜XÑ%ˆMð_ ˜hÓ&ðh 	×%Ñ%Ô'ð	3Ø8?Ö@°1Ô& q¨#Õ.Ò@Ð@ùÒ@øÜ!ò 	3Ø5ˆCÜ$ SÓ)¨sÐ2ûð	3ús*   ÅE' ÅE"ÅE' Å"E' Å'	FÅ0E>Å>Fc                óP   — | j                   | j                  kD  rd}t        |«      ‚y)zs
        Check that the table size set by the encoder is lower than the maximum
        we expect to have.
        z3Encoder did not shrink table size to within the maxN)rf   r§   r   )r`   r4   s     r#   r±   z Decoder._assert_valid_table_size2  s.   € ð
 ×!Ñ! D×$?Ñ$?Ò?ØGˆCÜ'¨Ó,Ð,ð @r%   c                ój   — t        |d«      \  }}|| j                  kD  rd}t        |«      ‚|| _        |S )zC
        Handles a byte that updates the encoding context.
        r   z)Encoder exceeded max allowable table size)rC   r§   r   rf   )r`   r<   Únew_sizer»   r4   s        r#   r¯   z Decoder._update_encoding_context;  s@   € ô
 ,¨D°!Ó4Ñˆ�(Ø�d×1Ñ1Ò1Ø=ˆCÜ'¨Ó,Ð,Ø!)ˆÔØˆr%   c                ó˜   — t        |d«      \  }}t        | j                  j                  |«      Ž }t        j                  d||«       ||fS )zP
        Decodes a header represented using the indexed representation.
        r+   zDecoded %s, consumed %d)rC   r   r\   Úget_by_indexr,   r-   )r`   r<   r=   r»   r   s        r#   r­   zDecoder._decode_indexedG  sK   € ô )¨¨qÓ1‰ˆˆxÜ˜d×/Ñ/×<Ñ<¸UÓCÐDˆÜ�	‰	Ð+¨V°XÔ>Ø�xÐÐr%   c                ó(   — | j                  |d¬«      S )NF©Úshould_index©Ú_decode_literal©r`   r<   s     r#   r°   z Decoder._decode_literal_no_indexP  s   € Ø×#Ñ# D°uÐ#Ó=Ð=r%   c                ó(   — | j                  |d¬«      S )NTrÃ   rÅ   rÇ   s     r#   r®   zDecoder._decode_literal_indexS  s   € Ø×#Ñ# D°tÐ#Ó<Ð<r%   c                óø  — t        |t        «      r|j                  «       }d}|r|d   dz  }d}d}n|d   }|dz  }d}t        |dz  «      }|r2t	        ||«      \  }}	| j
                  j                  |«      d   }
|	}d}nR|dd	 }t	        |d
«      \  }}	||	|	|z    }
t        |
«      |k7  rd}t        |«      ‚|d   dz  rt        |
«      }
|	|z   dz   }||	|z   d	 }t	        |d
«      \  }}	||	|	|z    }t        |«      |k7  rd}t        |«      ‚|d   dz  rt        |«      }|||	z   z  }|rt        |
|«      }nt        |
|«      }|r| j
                  j                  |
|«       t        j                  d|||«       ||fS )z>
        Decodes a header represented with a literal.
        r   é?   rŒ   Fé   r‹   é   r   Nr+   zTruncated header blockr)   z/Decoded %s, total consumed %d bytes, indexed %s)rL   r¬   Útobytesrš   rC   r\   rÁ   ro   r   r   r   r   rp   r,   r-   )r`   r<   rÄ   Útotal_consumedÚindexed_namerˆ   Únot_indexableÚ	high_byter=   r»   r!   Úlengthr4   r"   r   s                  r#   rÆ   zDecoder._decode_literalV  sÝ  € ô �dœJÔ'Ø—<‘<“>ˆDàˆñ Ø ™7 T™>ˆLØˆHØ!‰Mà˜Q™ˆIØ$ tÑ+ˆLØˆHÜ  ¨TÑ!1Ó2ˆMáä,¨T°8Ó<‰OˆE�8Ø×$Ñ$×1Ñ1°%Ó8¸Ñ;ˆDà%ˆNØ‰Fð ˜˜�8ˆDä-¨d°AÓ6ÑˆF�HØ˜ ¨FÑ!2Ð3ˆDÜ�4‹y˜FÒ"Ø.�Ü(¨Ó-Ð-à�A‰w˜Š~Ü% dÓ+�Ø%¨Ñ.°Ñ2ˆNà�H˜vÑ%Ð&Ð'ˆô *¨$°Ó2Ñˆ�Ø�X˜h¨Ñ/Ð0ˆÜˆu‹:˜ÒØ*ˆCÜ$ SÓ)Ð)à�‰7�TŠ>Ü" 5Ó)ˆEð 	˜& 8Ñ+Ñ+ˆñ
 Ü,¨T°5Ó9‰Fä   uÓ-ˆFñ Ø×Ñ×!Ñ! $¨Ô.ä�	‰	Ø=ØØØô		
ð �~Ð%Ð%r%   N)r¦   r˜   r•   r–   r—   r™   r›   )r<   r   r    rš   r•   zIterable[HeaderTuple]r”   )r<   úbytes | memoryviewr•   r˜   )r<   rÓ   r•   útuple[HeaderTuple, int])r<   rÓ   rÄ   rš   r•   rÔ   )rœ   r�   rž   rŸ   ÚDEFAULT_MAX_HEADER_LIST_SIZEra   r    rf   r¡   r   r±   r¯   r­   r°   r®   rÆ   r¢   r%   r#   r¤   r¤   ¢  sg   „ ñð* 4Pô @ð8 ò)ó ð)ð ×Ñò*ó ð*ôQ3óf-ó
ó ó>ó=ôO&r%   r¤   )r   r   r    rš   r•   r   )r2   r˜   r3   r˜   r•   r0   )r<   rÓ   r3   r˜   r•   ztuple[int, int])rR   zdict[bytes | str, bytes | str]r•   z)Iterable[tuple[bytes | str, bytes | str]])r"   zbytes | str | Anyr•   r   ),rŸ   Ú
__future__r   ÚloggingÚtypingr   r   Ú
exceptionsr   r   r	   rs   r
   Úhuffman_constantsr   r   Úhuffman_tabler   Ústructr   r   r   Útabler   r   Úcollections.abcr   Ú	getLoggerrœ   r,   Ú
INDEX_NONEr{   rz   r:   Úranger/   rÕ   r$   r7   rC   rS   rG   rY   r¤   )Úis   0r#   ú<module>rã      sÃ   ðñõ #ã ß %ç [Ñ [Ý #ß BÝ )ß KÑ Kß 0áÝ(à€g×Ñ˜Ó!€à€
Ø€ØÐ àÐ ñ
 27°q³Ö:¨A˜A ™F a›<Ò:Ð ð  'Ð ó
)óó>/ðd$Ø4ó$ó&	!÷}ñ }÷@C&ò C&ùòI ;s   Á1B0