
    @OOf|              	       x   d dl Z d dlZd dlZd dlmZ d dlmZ ed&d       Zedee	z  de	fd       Zddez  e	z  dde	z  fdZed&d	       Z
edee	z  defd
       Z
ddez  e	z  ddez  fdZ
 ed      D  ci c]  } |  ed       c} Z ed      ed<   ej                         ZdD ]  Ze ee      =  ej#                  e      Zej#                  e      Zd'dedefdZ	 d(de	dededefdZdede	fdZde	defdZde	defdZd Zd Zd Zd ZdZdZd Zd!Zded"ee   fd#Z ded"ee   fd$Z!defd%Z"yc c} w ))    N)Iterable)overloadstr_or_bytesreturnc                      y N r   encode_argss     Y/var/www/premiumrankchecker/venv/lib/python3.12/site-packages/mitmproxy/utils/strutils.pyalways_bytesr   
   s    <?    c                      y r   r	   r
   s     r   r   r      s    DGr   c                     | t        | t              r| S t        | t              r | j                  | S t	        dt        |       j                   d      )NExpected str or bytes, but got .)
isinstancebytesstrencode	TypeErrortype__name__r
   s     r   r   r      sY    z,>	L#	&"|""K00-d<.@.I.I-J!L
 	
r   c                      y r   r	   r
   s     r   
always_strr      s    :=r   c                      y r   r	   r
   s     r   r   r   !   s    @Cr   c                     | t        | t              r| S t        | t              r | j                  | S t	        dt        |       j                   d      )z6
    Returns,
        str_or_bytes unmodified, if
    r   r   )r   r   r   decoder   r   r   )r   decode_argss     r   r   r   %   s[    
 z,<	L%	("|""K00-d<.@.I.I-J!L
 	
r       r      )
	textc                     t        | t              s!t        dt        |       j                         |rt
        nt        }| j                  |      S )z
    Replace all unicode C1 control characters from the given text with a single "."

    Args:
        keep_spacing: If True, tabs and newlines will not be replaced.
    z!text type must be unicode but is )r   r   
ValueErrorr   r   _control_char_trans_newline_control_char_trans	translate)r%   keep_spacingtranss      r   escape_control_charactersr-   E   sF     dC <T$Z=P=P<QRSS+7'=PE>>%  r   datar+   escape_single_quotesc                    t        | t              s"t        d| j                  j                         t        d| z         j                  d      dd }|st        j                  dd |      }|rt        j                  dd	 |      }|S )
a8  
    Take bytes and return a safe string that can be displayed to the user.

    Single quotes are always escaped, double quotes are never escaped:
        "'" + bytes_to_escaped_str(...) + "'"
    gives a valid Python string.

    Args:
        keep_spacing: If True, tabs and newlines will not be escaped.
    zdata must be bytes, but is    "b   z(?<!\\)(\\\\)*\\'c                 2    | j                  d      xs ddz   S )N    ')groupms    r   <lambda>z&bytes_to_escaped_str.<locals>.<lambda>g   s    aggaj6FB#5M r   z(?<!\\)(\\\\)*\\([nrt])c                 n    | j                  d      xs dt        ddd      | j                  d         z   S )Nr6   r7   r#   r"   r$   )nrtr3   )r9   dictr:   s    r   r<   z&bytes_to_escaped_str.<locals>.<lambda>k   s/    qwwqz'R4$$$+GPQ
+SS r   )	r   r   r'   	__class__r   reprlstripresub)r.   r+   r/   rets       r   bytes_to_escaped_strrH   S   s     dE"6t~~7N7N6OPQQ td{

"
"3
'"
-Cff)+MsSff&S

 Jr   c                     t        | t              s"t        d| j                  j                         t        j                  |       d   S )z
    Take an escaped string and return the unescaped bytes equivalent.

    Raises:
        ValueError, if the escape sequence is invalid.
    zdata must be str, but is r   )r   r   r'   rB   r   codecsescape_decoder.   s    r   escaped_str_to_bytesrM   q   sD     dC 4T^^5L5L4MNOO %a((r   sc                 r    | rt        |       dk(  ryt        d | d d D              t        | d d       z  dkD  S )Nr   Fc              3   X   K   | ]"  }|d k  xs d|cxk  xr dk  nc xs d|k   $ yw)	      r    ~   Nr	   .0is     r   	<genexpr>z is_mostly_bin.<locals>.<genexpr>   s-     @1q1u.Q.sQw.@s   (*d   g333333?)lensum)rN   s    r   is_mostly_binr[      s>    A!@$3@@3q#w<ORUUUr   c                 (    | D ]  }|dv r|dk(  c S  y)N)rQ   
   r    <   Fr	   )rN   chars     r   is_xmlr`      s+     ;rz r   c                 $    | r| d   dk(  r| dd S | S )a  
    Many editors will silently add a newline to the final line of a
    document (I'm looking at you, Vim). This function fixes this common
    problem at the risk of removing a hanging newline in the rare cases
    where the user actually intends it.
    r4   r#   Nr	   )r@   s    r   clean_hanging_newlinerb      s!     	QrUd]"vHr   c           	   #   $  K   t        dt        |       d      D ]s  }|d}| ||dz    }dj                  d |D              }|j                  d      }t	        t        |j                  dd      j                  d	d
      d            }|||f u yw)zC
    Returns:
        A generator of (offset, hex, str) tuples
    r      z0=10x c              3   $   K   | ]  }|d  
 yw)z0=2xNr	   rT   s     r   rW   zhexdump.<locals>.<genexpr>   s     /Q$x[/s   /   asciireplaceu   �r   FN)rangerY   joinljustr   r-   r   ri   )rN   rV   offsetpartx	part_reprs         r   hexdumprq      s     
 1c!fb! 
%e9QV}HH/$//GGBK%GY/77#F
	
 q)$$
%s   BBc                 N    t        t        | j                  d            dz         S Nr   i   chrordr9   matchobjs    r   _move_to_private_code_planery           s8>>!$%.//r   c                 N    t        t        | j                  d            dz
        S rs   rt   rw   s    r    _restore_from_private_code_planer|      rz   r   z(?<!\\)(?:\\\\)*z[\s\S]*?z.*?z(?:.|(?<=\\)\n)*?area_delimiterc                     t        j                  dj                  dj                  |            | t         j                        S )an  
    Split a string of code into a [code, special area, code, special area, ..., code] list.

    For example,

    >>> split_special_areas(
    >>>     "test /* don't modify me */ foo",
    >>>     [r"/\*[\s\S]*?\*/"])  # (regex matching comments)
    ["test ", "/* don't modify me */", " foo"]

    "".join(split_special_areas(x, ...)) == x always holds true.
    z({})|)flags)rE   splitformatrk   	MULTILINE)r.   r}   s     r   split_special_areasr      s-      88FMM#((>":;TVVr   c                    t        j                         }t        | |      }t        j                  d| d      }t        |      D ]1  \  }}|dz  r|j                  t        |      }|j                  |       3 |j                         S )u  
    Escape all control characters present in special areas with UTF8 symbols
    in the private use plane (U+E000 t+ ord(char)).
    This is useful so that one can then use regex replacements on the resulting string without
    interfering with special areas.

    control_characters must be 0 < ord(x) < 256.

    Example:

    >>> print(x)
    if (true) { console.log('{}'); }
    >>> x = escape_special_areas(x, "{", ["'" + SINGLELINE_CONTENT + "'"])
    >>> print(x)
    if (true) { console.log('�}'); }
    >>> x = re.sub(r"\s*{\s*", " {
    ", x)
    >>> x = unescape_special_areas(x)
    >>> print(x)
    if (true) {
        console.log('{}'); }
    []r3   )
ioStringIOr   rE   compile	enumeraterF   ry   writegetvalue)r.   r}   control_charactersbufpartsrexrV   ro   s           r   escape_special_areasr      s}    4 ++-Cn5E
**,-Q/
0C%  1q53Q7A		! <<>r   c                 8    t        j                  dt        |       S )zs
    Invert escape_special_areas.

    x == unescape_special_areas(escape_special_areas(x)) always holds true.
    z[\ue000-\ue0ff])rE   rF   r|   rL   s    r   unescape_special_areasr      s     66$&FMMr   )r   Nr   N)T)FF)#rJ   r   rE   collections.abcr   typingr   r   r   r   r   rj   rv   r)   copyr(   ro   	maketransr-   boolrH   rM   r[   r`   rb   rq   ry   r|   	NO_ESCAPEMULTILINE_CONTENTSINGLELINE_CONTENT#MULTILINE_CONTENT_LINE_CONTINUATIONr   r   r   )ro   s   0r   <module>r      s&    	 	 $ 
 
 ? 
 ? 
 GsU{ GU G 
 G
tczE1 
D5L 
 
 = 
 = 
 CS5[ C3 C 
 C
TCZ%/ 
$* 
* 2Y	 s3xK  s8 C 1668 	 ,A#CF+, mm$78 !mm,GH !C !s ! KP
#CG<)s )u )VU Vt Ve  	%$00  	  &: #W
WSMW&!
!SM!HN Nus   7D7