+
    ~jOY                        ^ RI t ^ RIt^ RIt^ RIt^ RIHtHt ^RIHt ^RI	H
t
 ^	tRt]P                  ! R4      t]! RR04      t]! 0 R9m4      t]! 0 R:m4      t]! 0 R;m4      t]! R	R
04      t]! 0 R<m4      t]! RR
04      t]! ]! R4      ]! R4      04      t]! ]! R4      ]! R4      04      t ! R R]4      t ! R R]4      t ! R R]4      t ! R R]4      tR R ltR R lt R R lt!R R lt"R R lt#R R  lt$R=R! R" llt%R# R$ lt&R% R& lt'R' R( lt(R) R* lt)R=R+ R, llt*R- R. lt+R/ R0 lt,R1 R2 lt-R>R3 R4 llt.R?R5 R6 llt/R@R7 R8 llt0R# )A    N)OptionalUnion)idnadata)intranges_contains   xn--u   [.。．｡]RALANENLDc                       ] tR t^tRtRtR# )	IDNAErrorz5Base exception for all IDNA-encoding related problems N__name__
__module____qualname____firstlineno____doc____static_attributes__r       ^/Users/mitch_tango/dev/rabbit-r1-livekit/agent/.venv/lib/python3.14/site-packages/idna/core.pyr   r      s    ?r   r   c                       ] tR t^tRtRtR# )IDNABidiErrorz;Exception when bidirectional requirements are not satisfiedr   Nr   r   r   r   r   r      s    Er   r   c                       ] tR t^#tRtRtR# )InvalidCodepointz<Exception when a disallowed or unallocated codepoint is usedr   Nr   r   r   r   r   r   #   s    Fr   r   c                       ] tR t^'tRtRtR# )InvalidCodepointContextzCException when the codepoint is not valid in the context it is usedr   Nr   r   r   r   r   r   '   s    Mr   r   c                0    V ^8  d   QhR\         R\         /# )   cpreturn)int)formats   "r   __annotate__r%   +   s        r   c                     \         P                  ! \        V 4      4      pV^ 8X  d1   \         P                  ! \        V 4      4      '       g   \	        R4      hV# )r   z Unknown character in unicodedata)unicodedata	combiningchrname
ValueError)r!   vs   & r   _combining_classr-   +   sB    c"g&AAvk&&s2w//;<<Hr   c                <    V ^8  d   QhR\         R\         R\        /# )r    r!   scriptr"   strbool)r$   s   "r   r%   r%   2   s&     @ @3 @ @ @r   c                 V    \        \        V 4      \        P                  V,          4      # )N)r   ordr   scripts)r!   r/   s   &&r   
_is_scriptr6   2   s    SWh&6&6v&>??r   c                0    V ^8  d   QhR\         R\        /# r    sr"   r1   bytes)r$   s   "r   r%   r%   6   s            r   c                 $    V P                  R 4      # )punycode)encoder9   s   &r   	_punycoder@   6   s    88Jr   c                0    V ^8  d   QhR\         R\        /# r8   )r#   r1   )r$   s   "r   r%   r%   :   s      S S r   c                     R V R 2# )zU+04Xr   r?   s   &r   _unotrD   :   s    #w<r   c                R    V ^8  d   QhR\         \        \        3,          R\        /# r    labelr"   r   r;   r1   r2   )r$   s   "r   r%   r%   >   s#      eE3J/ D r   c                    \        V 4      ^?8*  # )u  Check that a label does not exceed the maximum permitted length.

Per :rfc:`1035` (and :rfc:`5891` §4.2.4) a DNS label must not exceed
63 octets. The argument may be either a :class:`str` (a U-label, where
length is measured in characters) or :class:`bytes` (an A-label, where
length is measured in octets).

:param label: The label to check.
:returns: ``True`` if the label is within the length limit, otherwise
    ``False``.
lenrG   s   &r   valid_label_lengthrM   >   s     u:r   c                ^    V ^8  d   QhR\         \        \        3,          R\        R\        /# )r    domaintrailing_dotr"   rH   )r$   s   "r   r%   r%   M   s*     9 9eSj 1 9 9$ 9r   c                6    \        V 4      V'       d   ^8*  # ^8*  # )a  Check that a full domain name does not exceed the maximum length.

Per :rfc:`1035`, a domain name is limited to 253 octets when no trailing
dot is present, or 254 octets when one is included.

:param domain: The full (possibly multi-label) domain name.
:param trailing_dot: ``True`` if ``domain`` includes a trailing ``.``.
:returns: ``True`` if the domain is within the length limit, otherwise
    ``False``.
rJ   )rO   rP   s   &&r   valid_string_lengthrR   M   s     v;,388C88r   c                <    V ^8  d   QhR\         R\        R\        /# )r    rG   	check_ltrr"   r0   )r$   s   "r   r%   r%   [   s&     F Fc Fd Ft Fr   c                   Rp\        V ^4       FC  w  r4\        P                  ! V4      pVR8X  d   \        RV : RV 24      hV\        9   g   KA  RpKE  	  V'       g   V'       g   R# \        P                  ! V ^ ,          4      pV\
        9   d   RpMVR8X  d   RpM\        RV : R24      hRpR	p\        V ^4       F  w  r4\        P                  ! V4      pV'       d^   V\        9  d   \        R
V R24      hV\        9   d   RpM	VR8w  d   RpV\        9   d    V'       g   TpKk  W8w  d   \        R4      hK~  K  V\        9  d   \        R
V R24      hV\        9   d   RpK  VR8w  g   K  RpK  	  V'       g   \        R4      hR# )a  Validate the Bidi Rule from :rfc:`5893` for a single label.

The Bidi Rule constrains how bidirectional characters (Hebrew, Arabic,
etc.) may appear within a label. By default the check is only applied
when the label contains at least one right-to-left character (Unicode
bidirectional categories ``R``, ``AL``, or ``AN``); set ``check_ltr``
to ``True`` to apply it to LTR-only labels as well.

:param label: The label to validate, as a Unicode string.
:param check_ltr: If ``True``, apply the rules even when the label
    contains no RTL characters.
:returns: ``True`` if the label satisfies the Bidi Rule.
:raises IDNABidiError: If any of Bidi Rule conditions 1-6 are violated,
    or if the directional category of a codepoint cannot be determined.
F z Unknown directionality in label  at position Tr   zFirst codepoint in label z" must be directionality L, R or ALNz,Invalid direction for codepoint at position z in a right-to-left labelNSMz2Can not mix numeral types in a right-to-left labelz in a left-to-right labelz0Label ends with illegal codepoint directionality)	enumerater'   bidirectionalr   _bidi_rtl_categories_bidi_rtl_first_bidi_rtl_allowed_bidi_rtl_valid_ending_bidi_rtl_numeric_bidi_ltr_allowed_bidi_ltr_valid_ending)	rG   rT   
bidi_labelidxr!   	directionrtlvalid_endingnumber_types	   &&       r   
check_bidirh   [   s   " JUA&--b1	?"B5)=Y\X] ^__,,J ' i ))%(3IO#	c	7y@bcddL!%KUA&--b1	 11#&RSVRWWp$qrr22#e#$--""+K -'(\]] . .  11#&RSVRWWp$qrr22#e#$5 '8 NOOr   c                0    V ^8  d   QhR\         R\        /# rF   r0   )r$   s   "r   r%   r%      s      # $ r   c                n    \         P                  ! V ^ ,          4      ^ ,          R8X  d   \        R4      hR# )uF  Reject labels that begin with a combining mark.

Per :rfc:`5891` §4.2.3.2 a label must not start with a character of
Unicode general category ``M`` (Mark).

:param label: The label to check.
:returns: ``True`` if the first character is not a combining mark.
:raises IDNAError: If the label begins with a combining character.
Mz0Label begins with an illegal combining characterT)r'   categoryr   rL   s   &r   check_initial_combinerrm      s/     E!H%a(C/JKKr   c                0    V ^8  d   QhR\         R\        /# rF   r0   )r$   s   "r   r%   r%      s      3 4 r   c                    V R,          R8X  d   \        R4      hV ^ ,          R8X  g   V R,          R8X  d   \        R4      hR# )u  Validate the hyphen restrictions for a label.

Per :rfc:`5891` §4.2.3.1 a label must not start or end with a hyphen
(``U+002D``), and must not have hyphens in both the third and fourth
positions (the prefix reserved for A-labels).

:param label: The label to check.
:returns: ``True`` if the hyphen restrictions are satisfied.
:raises IDNAError: If any of the hyphen restrictions are violated.
:r       Nz--z4Label has disallowed hyphens in 3rd and 4th position-z)Label must not start or end with a hyphenT)r   rL   s   &r   check_hyphen_okrs      sA     SzTNOOQx3%)s*CDDr   c                (    V ^8  d   QhR\         RR/# r    rG   r"   N)r1   )r$   s   "r   r%   r%      s     A AS AT Ar   c                T    \         P                  ! RV 4      V 8w  d   \        R4      hR# )zRequire that a label is in Unicode Normalization Form C.

:param label: The label to check.
:raises IDNAError: If ``label`` differs from its NFC normalisation.
NFCz%Label must be in Normalization Form CN)r'   	normalizer   rL   s   &r   	check_nfcry      s*     UE*e3?@@ 4r   c                <    V ^8  d   QhR\         R\        R\        /# )r    rG   posr"   r1   r#   r2   )r$   s   "r   r%   r%      s!     0 0# 0C 0D 0r   c                   \        W,          4      pVR8X  Ed,   V^ 8  d-   \        \        W^,
          ,          4      4      \        8X  d   R# Rp\        V^,
          RR4       FW  p\        P
                  ! 4       P                  \        W,          4      4      pV\        R4      8X  d   KH  V\        9   d   Rp M M	  V'       g   R# Rp\        V^,           \        V 4      4       FY  p\        P
                  ! 4       P                  \        W,          4      4      pV\        R4      8X  d   KH  V\        9   d   Rp V#  V# 	  V# VR8X  d6   V^ 8  ;'       d)    \        \        W^,
          ,          4      4      \        8H  # R# )as  Validate the CONTEXTJ rules from :rfc:`5892` Appendix A.

These rules govern the contextual use of the joiner codepoints
``U+200C`` (ZERO WIDTH NON-JOINER, Appendix A.1) and ``U+200D``
(ZERO WIDTH JOINER, Appendix A.2) within a label.

:param label: The label containing the codepoint.
:param pos: Index of the joiner codepoint within ``label``.
:returns: ``True`` if the codepoint at ``pos`` satisfies its CONTEXTJ
    rule, ``False`` otherwise (including when the codepoint at
    ``pos`` is not a recognised joiner).
:raises ValueError: If an adjacent codepoint has no Unicode name when
    determining its combining class.
i   TFTi   rr   )
r4   r-   _virama_combining_classranger   joining_typesget_bidi_joiner_l_or_drK   _bidi_joiner_r_or_d)rG   r{   cp_valueokijoining_types   &&    r   valid_contextjr      sG    5:H67'E'N(;<@WWsQwB'A#11377EHFLs3x'22 ( sQwE
+A#11377EHFLs3x'22	 	 , 	6Qw[[+CAg,?@D[[[r   c                H    V ^8  d   QhR\         R\        R\        R\        /# )r    rG   r{   	exceptionr"   r|   )r$   s   "r   r%   r%     s(     + +# +C +D +T +r   c                   \        W,          4      pV^8X  dm   ^ Tu;8  ;'       d    \        V 4      ^,
          8  Mu ;'       d?    \        W^,
          ,          4      ^l8H  ;'       d    \        W^,           ,          4      ^l8H  # VR8X  dC   V\        V 4      ^,
          8  d*   \        V 4      ^8  d   \        W^,           ,          R4      # R# VR9   d#   V^ 8  d   \        W^,
          ,          R4      # R# VR8X  dN   V  FE  pVR8X  d   K  \        VR4      '       g'   \        VR4      '       g   \        VR	4      '       g   KD   R
# 	  R# RTu;8:  d   R8:  dG   M MC\        ;QJ d&    R V  4       F  '       g   K   R
'       * # 	  R'       * # ! R V  4       4      '       * # RTu;8:  d   R8:  dH   M R# \        ;QJ d&    R V  4       F  '       g   K   R
'       * # 	  R'       * # ! R V  4       4      '       * # R# )ac  Validate the CONTEXTO rules from :rfc:`5892` Appendix A.

Covers the contextual rules for codepoints such as MIDDLE DOT
(``U+00B7``), Greek lower numeral sign, Hebrew punctuation, Katakana
middle dot, and the Arabic-Indic / Extended Arabic-Indic digit ranges.

:param label: The label containing the codepoint.
:param pos: Index of the codepoint within ``label``.
:param exception: Reserved for forward compatibility; currently unused.
:returns: ``True`` if the codepoint at ``pos`` satisfies its CONTEXTO
    rule, ``False`` otherwise (including when the codepoint is not a
    recognised CONTEXTO codepoint).
iu  GreekFHebrewi0  u   ・HiraganaKatakanaHanT`  i  c              3   `   "   T F$  pR \        V4      u;8*  ;'       d    R8*  Mu x  K&  	  R# 5i)    Nr4   .0r!   s   & r   	<genexpr>!valid_contexto.<locals>.<genexpr>(  $     BEbuB11611E   ,.r   r   c              3   `   "   T F$  pR \        V4      u;8*  ;'       d    R8*  Mu x  K&  	  R# 5i)r   r   Nr   r   s   & r   r   r   +  r   r   >       )r4   rK   r6   any)rG   r{   r   r   r!   s   &&&  r   valid_contextor     s    5:H63''Ua'kkCAg,?6,IkkcRW^_X_R`NaekNkk6UaCJNe!Gng66##7e!Gnh776BX~"j))ZJ-G-G:VXZ_K`K`	 
 !E!3BEB33BB3BB3BEBBBB!E!  3BEB33BB3BB3BEBBBBr   c                T    V ^8  d   QhR\         \        \        \        3,          RR/# ru   r   r1   r;   	bytearray)r$   s   "r   r%   r%   0  s&     2 2uS%23 2 2r   c           
        \        V \        \        34      '       d   V P                  R4      p \	        V 4      ^ 8X  d   \        R4      h\        V RR7      '       g   \        R4      h\        V 4       \        V 4       \        V 4       \        V 4       EF  w  r\        V4      p\        V\        P                  R,          4      '       d   K:  \        V\        P                  R,          4      '       d:    \        W4      '       g&   \!        R\#        V4       R	V^,            R
V : 24      hK  \        V\        P                  R,          4      '       d9   \'        W4      '       g&   \!        R\#        V4       R	V^,            R
V : 24      hK  \)        R\#        V4       RV^,            RV : R24      h	  \+        V 4       R#   \$         d,   p\        R\#        T4       RT^,            R
T : 24      ThRp?ii ; i)a   Run the full set of IDNA 2008 validity checks on a single label.

Applies, in order: NFC normalisation (:func:`check_nfc`), hyphen
restrictions (:func:`check_hyphen_ok`), the no-leading-combiner rule
(:func:`check_initial_combiner`), per-codepoint validity (PVALID,
CONTEXTJ, CONTEXTO classes from :rfc:`5892`), and the Bidi Rule
(:func:`check_bidi`).

:param label: The label to validate. ``bytes`` or ``bytearray`` input
    is decoded as UTF-8 first.
:raises IDNAError: If the label is empty or fails a structural rule.
:raises InvalidCodepoint: If the label contains a DISALLOWED or
    UNASSIGNED codepoint.
:raises InvalidCodepointContext: If a CONTEXTJ or CONTEXTO codepoint
    is not valid in its context.
:raises IDNABidiError: If the Bidi Rule is violated.
zutf-8zEmpty LabelTrP   Label too longPVALIDCONTEXTJzJoiner  not allowed at position  in z%Unknown codepoint adjacent to joiner rW   NCONTEXTO
Codepoint z of z not allowed)
isinstancer;   r   decoderK   r   rR   ry   rs   rm   rY   r4   r   r   codepoint_classesr   r   rD   r+   r   r   rh   )rG   r{   r!   r   errs   &    r   check_labelr   0  s   $ %%+,,W%
5zQ&& u488())eE5!U#r7Xx'A'A('KLLXx'A'A*'MNN%e111GE(O;LLefilmfmennrsxr{2|}} 2 x)C)CJ)OPP!%---
5?:KKdehkleldmmqrwqz.{|| . #Zh/@cTUgYVZ[`Zcco#pqq! $$ u  ;E(O;LMZ]`aZaYbbfglfops   56GG7&G22G7c                0    V ^8  d   QhR\         R\        /# rF   r:   )r$   s   "r   r%   r%   e  s      # % r   c                    V P                  R4      p\        V4       \        V4      '       g   \        R4      hV#   \         d     Mi ; i\        T 4       \        \        T 4      ,           p\        T4      '       g   \        R4      hT# )u  Convert a single U-label into its A-label form.

The result is the ASCII-Compatible Encoding (ACE) form per :rfc:`5891`
§4: the label is validated, Punycode-encoded, and prefixed with
``xn--``. Pure ASCII labels that are already valid IDNA labels are
returned unchanged (as :class:`bytes`).

:param label: The label to convert, as a Unicode string.
:returns: The A-label as ASCII-encoded :class:`bytes`.
:raises IDNAError: If the label is invalid or the resulting A-label
    exceeds 63 octets.
asciir   )r>   ulabelrM   r   UnicodeEncodeErrorr   _alabel_prefixr@   )rG   label_bytess   & r   alabelr   e  s    ll7+ 	{!+..,--    9U#33Kk**())s   < A
	A
c                \    V ^8  d   QhR\         \        \        \        3,          R\        /# rF   r   )r$   s   "r   r%   r%     s&     & &%UI-. &3 &r   c                L   \        V \        \        34      '       g    V P                  R4      pM\        V 4      pVP                  4       pVP                  \        4      '       dI   V\        \        4      R pV'       g   \        R4      hVP                  R4      '       d   \        R4      hM\        V4       VP                  R4      #  VP                  R4      p \        T 4       T #   \         d    \        T 4       T u # i ; i  \         d   p\        R4      ThRp?ii ; i)a  Convert a single A-label into its U-label form.

Performs the inverse of :func:`alabel`: an ``xn--``-prefixed label is
Punycode-decoded and validated. Labels that are already Unicode (or
plain ASCII without the ACE prefix) are validated and returned as a
Unicode string.

:param label: The label to convert. ``bytes`` or ``bytearray`` input
    is treated as ASCII.
:returns: The U-label as a Unicode string.
:raises IDNAError: If the label is malformed or fails validation.
r   Nz5Malformed A-label, no Punycode eligible content found   -z"A-label must not end with a hyphenr=   zInvalid A-label)r   r;   r   r>   r   r   lower
startswithr   rK   r   endswithr   UnicodeError)rG   r   r   s   &  r   r   r     s    eeY/00	,,w/K
 El##%Kn--!#n"5"78STT%%@AA & 	K !!'**4"":. L- " 	L	&  4)*34s)   C) D )DDD#DD#c                H    V ^8  d   QhR\         R\        R\        R\         /# )r    rO   
std3_rulestransitionalr"   r0   )r$   s   "r   r%   r%     s)     40 40 40 40D 40UX 40r   c           	        ^RI H p Rp\        V 4       EFH  w  rV\        V4      pY7R8  d   TM\        P                  ! W7R34      ^,
          ,          pV^,          p	Rp
\        V4      ^8X  d
   V^,          p
V	R8H  ;'       g=    V	R8H  ;'       d    V'       * ;'       g!    V	R8H  ;'       d    V'       * ;'       d    V
RJ pV
RJ;'       d9    V	R	8H  ;'       g,    V	R8H  ;'       d    V'       * ;'       g    V	R8H  ;'       d    TpV'       d   WF,          pEK  V'       d   V
f   Q hWJ,          pEK  V	R
8X  d   EK&  \        R\        V4       RV^,            RV : 24      h	  \        P                  ! RV4      # )ur  Apply the UTS #46 character mapping to a domain string.

Implements the mapping table from `UTS #46 §4
<https://www.unicode.org/reports/tr46/>`_: each character is kept,
replaced, or rejected based on its status (``V``, ``M``, ``D``, ``3``,
``I``). The result is returned in Normalisation Form C.

:param domain: The full domain name to remap.
:param std3_rules: If ``True``, apply the stricter STD3 ASCII rules
    (status ``3`` codepoints raise instead of being kept or mapped).
:param transitional: If ``True``, use transitional processing (status
    ``D`` codepoints are mapped instead of kept). Transitional
    processing has been removed from UTS #46 and this option is
    retained only for backwards compatibility.
:returns: The remapped domain, in Normalisation Form C.
:raises InvalidCodepoint: If the domain contains a disallowed
    codepoint under the chosen rules.
)	uts46datarV      ZNVr   3rk   Ir   r   r   rw   )
r   rY   r4   bisectbisect_leftrK   r   rD   r'   rx   )rO   r   r   r   outputr{   char
code_pointuts46rowstatusreplacement
keep_as_isuse_replacements   &&&          r   uts46_remapr     s|   & %Fv&	Y
+;ZASAST]lo_pAqtuAuv!%)x=A"1+K
 cMfm@@L0@fPSmF~F~\fXfF~F~kvz~k~ 	
 &T1 
 
cMccfm>>JccFcMDbDbVb 	 NF***!Fs]"Zj0A/BB[\_bc\c[ddhiohr#stt7 ':   //r   c                    V ^8  d   QhR\         \        \        \        3,          R\        R\        R\        R\        R\        /# )r    r9   strictuts46r   r   r"   r   r1   r;   r   r2   )r$   s   "r   r%   r%     sX     C CS%"#CC C 	C
 C Cr   c                    V'       d   \         P                  ! R\        ^R7       \        V \        4      '       g    \	        V R4      p V'       d   \        WV4      p \        V RR7      '       g   \        R4      hR	p. pV'       d   V P                  R
4      M\        P                  V 4      pV'       d	   VR.8X  d   \        R4      hVR,          R8X  d   VR RpV F2  p	\        V	4      p V '       d   VP                  V 4       K)  \        R4      h	  V'       d   VP                  R4       RP                  V4      p \        W4      '       g   \        R4      hV #   \
        \        3 d   p\        R4      ThRp?ii ; i)a  Encode a Unicode domain name into its ASCII (A-label) form.

Splits the input on label separators (only ``U+002E`` if ``strict`` is
set; otherwise also IDEOGRAPHIC FULL STOP ``U+3002``, FULLWIDTH FULL
STOP ``U+FF0E``, and HALFWIDTH IDEOGRAPHIC FULL STOP ``U+FF61``),
encodes each label with :func:`alabel`, and rejoins them with ``.``.
Optionally pre-processes the input through :func:`uts46_remap`.

:param s: The domain name to encode.
:param strict: If ``True``, only ``U+002E`` is recognised as a label
    separator.
:param uts46: If ``True``, apply UTS #46 mapping before encoding.
:param std3_rules: Forwarded to :func:`uts46_remap` when ``uts46`` is
    ``True``.
:param transitional: Forwarded to :func:`uts46_remap` when ``uts46``
    is ``True``. Deprecated: emits a :class:`DeprecationWarning` and
    will be removed in a future version.
:returns: The encoded domain as ASCII :class:`bytes`.
:raises IDNAError: If the domain is empty, contains an invalid label,
    or exceeds the maximum domain length.
zuTransitional processing has been removed from UTS #46. The transitional argument will be removed in a future version.)
stacklevelr   zGshould pass a unicode string to the function rather than a byte string.NTr   Domain too longF.rV   Empty domainEmpty labelr      .rr   )warningswarnDeprecationWarningr   r1   UnicodeDecodeError	TypeErrorr   r   rR   split_unicode_dots_rer   appendjoin)
r9   r   r   r   r   r   rP   resultlabelsrG   s
   &&&&&     r   r>   r>     sP   8 M		
 a	pAwA |4 qt44)**LF#QWWS\)9)?)?)BFVt^''bzR2J5MMM!M**  c		&Aq//)**H; #I. 	pefloo	ps   E E=,E88E=c          
          V ^8  d   QhR\         \        \        \        3,          R\        R\        R\        R\        /# )r    r9   r   r   r   r"   r   )r$   s   "r   r%   r%   +  sF     2 2S%"#22 2 	2
 	2r   c                |   \        V \        4      '       g    \        V R4      p V'       d   \        WR4      p \        V RR7      '       g   \	        R4      hRp. pV'       d   V P                  R4      M\        P                  V 4      pV'       d	   VR	.8X  d   \	        R
4      hVR,          '       g   VR RpV F2  p\        V4      p V '       d   VP                  V 4       K)  \	        R4      h	  V'       d   VP                  R	4       RP                  V4      #   \        \        3 d   p\	        R4      ThRp?ii ; i)a  Decode an A-label-encoded domain name back to Unicode.

Splits the input on label separators (see :func:`encode` for the
rules), decodes each label with :func:`ulabel`, and rejoins them
with ``.``. Optionally pre-processes the input through
:func:`uts46_remap`.

:param s: The domain name to decode.
:param strict: If ``True``, only ``U+002E`` is recognised as a label
    separator.
:param uts46: If ``True``, apply UTS #46 mapping before decoding.
:param std3_rules: Forwarded to :func:`uts46_remap` when ``uts46`` is
    ``True``.
:returns: The decoded domain as a Unicode string.
:raises IDNAError: If the input is not valid ASCII, contains an
    invalid label, or is empty.
r   zInvalid ASCII in A-labelNFTr   r   r   rV   r   r   rr   )r   r1   r   r   r   r   rR   r   r   r   r   r   )	r9   r   r   r   r   rP   r   r   rG   s	   &&&&     r   r   r   +  s   . a	AAwA u- qt44)**LF#QWWS\)9)?)?)BFVt^''"::2J5MMM!M**  b88F1 #I. 	A67S@	As   D D;*D66D;>   r   r   r	   >
   r   r   r	   BNCSr
   ESETONrX   >   r   r   r	   r
   >   r   r   r   r
   r   r   r   rX   )F)TF)FFFF)FFF)1r   rer'   r   typingr   r   rV   r   	intrangesr   r   r   compiler   	frozensetr\   r[   r]   r^   r_   r`   ra   r4   r   r   r   r   r   r   r   r-   r6   r@   rD   rM   rR   rh   rm   rs   ry   r   r   r   r   r   r   r>   r   r   r   r   <module>r      sf    	   "  ( :::;  S$K( !23 Z[ "#:; tTl+ NO "C;/ S3s8 45 S3s8 45 @ @FI FGy GNi N@ 9FR$A0f+\2j@&R40nCL2 2r   