pj~SSKJr SSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r Sr Sr S rS urrrr\R&"S 5r\R&"S 5r\"S S15r\"1Sk5r\"1Sk5r\"1Sk5r\"SS15r\"1Sk5r\"SS15r\"SS15r\"S S15rS5Sjr \Sr!"SS\"5r#"SS\#5r$"SS\#5r%"SS \#5r&S6S!jr'S7S"jr(S8S#jr)S9S$jr*S:S%jr+S;S&jr,SS(jr.S>S)jr/S?S*jr0S@S+jr1Sr r AN> r r r BNCSENESETONNSM>r r r rr r>Lr r rrrrrrDcz[RR5Hup[X5(dMUs $ gN)r joining_typesitemsr)cpjtrangess E/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/idna/core.py _joining_typers2,,224  R ( (I5 )input_too_longlabel_too_longdomain_too_long empty_label empty_domainnot_nfc hyphen_3_4hyphen_start_endleading_combinerdisallowed_codepointcontextjcontextounknown_codepoint bidi_rule_1 bidi_rule_2 bidi_rule_3 bidi_rule_4 bidi_rule_5 bidi_rule_6bidi_unknown_directioninvalid_alabelnon_canonical_alabel invalid_ascii invalid_utf8uts46_disallowed uts46_std3unsupported_errorsc~^\rSrSr%SrS\S'S\S'S\S'S\S'S S S S S .S U4S jjjrS rU=r$) IDNAErrorEaBase exception for all IDNA-encoding related problems. ``str(err)`` is a human-readable description of the failure. The exception also carries machine-readable attributes so callers do not need to parse the message: * ``code`` -- a short, stable identifier for the rule that failed, such as ``"disallowed_codepoint"`` or ``"bidi_rule_2"``; the full list is documented in the README. Message wording, by contrast, may change between releases. * ``text`` -- the label (or, for UTS #46 processing, the domain) that was being validated; * ``codepoint`` -- the offending codepoint, as an ``int``; * ``position`` -- the 1-based index of the offending character within ``text``, matching the position quoted in the message. Each is ``None`` when it does not apply. str | Nonecodetext int | None codepointpositionNr>r?rArBcP>[TU]"U6 XlX lX0lX@lgr)super__init__r>r?rArB)selfr>r?rArBargs __class__s rrFIDNAError.__init__^s& $  " r)r>rArBr?) rHobjectr>z_ErrorCode | Noner?r=rAr@rBr@returnNone) __name__ __module__ __qualname____firstlineno____doc____annotations__rF__static_attributes__ __classcell__)rIs@rr;r;Est&   #' $# ! !  ! !  !  !  ! !rr;c\rSrSrSrSrg) IDNABidiErrormz;Exception when bidirectional requirements are not satisfiedNrNrOrPrQrRrTrYrrrWrWmsErrWc\rSrSrSrSrg)InvalidCodepointqz ??rc$URS5$)Npunycode)encodess r _punycoderss 88J rcSUS3$)NzU+04XrYrqs r_unotrvs #w<rc[U5S:*$)uCheck 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``. ?lenlabels rvalid_label_lengthr}s u: rc4[U5U(aS:*$S:*$)aCheck 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``. ry)domain trailing_dots rvalid_string_lengthrs v;,3 88C 88rc [U5[:a [SSS9eSn[US5HLup4[R "U5nUS:Xa[ SU<SU3S U[U5US 9eU[;dMJS nMN U(dU(dg [R "US 5nU[;aS nO'US :XaSnO[ SU<S3SU[US 5SS 9eSnSnSn [US5Hup4[R "U5nU(aqU[;a[ SUS3SU[U5US 9eU[;aS nUnO US:waSnUnU[;a(U (dUn MtX:wa[ SSU[U5US 9eMMU[;a[ SUS3SU[U5US 9eU[;aS nUnMUS:wdMSnUnM U(d$[ SU(aSOSU[XS- 5US 9eg )aValidate 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. Label too longrr>Frz Unknown directionality in label at position r2rCTrrzFirst codepoint in label z" must be directionality L, R or ALr,Nz,Invalid direction for codepoint at position z in a right-to-left labelr-rz2Can not mix numeral types in a right-to-left labelr/z in a left-to-right labelr0z0Label ends with illegal codepoint directionalityr.r1)rz_max_input_lengthr; enumeraterb bidirectionalrWrj_bidi_rtl_categories_bidi_rtl_first_bidi_rtl_allowed_bidi_rtl_valid_ending_bidi_rtl_numeric_bidi_ltr_allowed_bidi_ltr_valid_ending) r| check_ltr bidi_labelidxr directionrtl valid_ending ending_idx number_types r check_bidirs\  5z%%(/?@@JUA&--b1 ?25)=N-b'   , ,J' i))%(3IO# c 'y0R S%(m   LJ"KUA&--b1  11#B3%G`a&!"g 22#  e#$  --""+K -'L*""%b'!$ .. 11#B3%G`a&!"g 22#  e#$  a'd  >"%=%Q/0    rc U(a9[R"US5SS:Xa[SSU[US5SS9eg)uFReject 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. rMz0Label begins with an illegal combining characterr'rrCT)rbcategoryr;rjr{s rcheck_initial_combinerrsK %%eAh/2c9 >#%(m    rcUSSS:Xa [SSS9eURS5(dURS5(a [SS S9eg ) uValidate 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. z--z4Label has disallowed hyphens in 3rd and 4th positionr%r-z)Label must not start or end with a hyphenr&T)r; startswithendswithr{s rcheck_hyphen_okr4sR QqzTNUabb s 3 3CJ\]] rc[U5[:a [SSS9e[R"SU5U:wa [SSS9eg)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. rrrNFCz%Label must be in Normalization Form Cr$N)rzrr;rb normalizer{s r check_nfcrFsH  5z%%(/?@@UE*e3?iPP4rcT[U5[:a [SSS9e[X5nUS:XaUS:a"[ [XS- 55[ :XagSn[ US- S S 5H/n[[X55nUS :XaM!U[;aSn O O U(dgSn[ US-[U55H1n[[X55nUS :XaM!U[;aSn U$ U$ U$US :Xa,US:=(a [ [XS- 55[ :H$g) aValidate 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. :raises IDNAError: If ``label`` exceeds the defensive input length limit. rrri rrTFTi ) rzrr;rjrh_virama_combining_classranger_bidi_joiner_l_or_d_bidi_joiner_r_or_d)r|poscp_valueoki joining_types rvalid_contextjrRs:  5z%%(/?@@5:H6 7'E'N(;<@WW sQwB'A(UX7Ls"22 ( sQwE +A(UX7Ls"22   , 6Qw[+CAg,?@D[[[ rc[U5[:a [SSS9e[X5nUS:XaUSUs=:=(a [U5S- :Os =(a- [XS- 5S:H=(a [XS-5S:H$US:Xa3U[U5S- :a [U5S:a[ XS-S 5$g US ;aUS:a[ XS- S 5$g US :XaGUH@nUS:XaM [ US5(d$[ US5(d[ US5(dM@ g g SUs=::aS::aO O[ SU55(+$SUs=::aS::aO g [ SU55(+$g )aValidate 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). :raises IDNAError: If ``label`` exceeds the defensive input length limit. rrrrrliuGreekF>Hebrewi0u・HiraganaKatakanaHanT`ic3^# UH#nS[U5s=:*=(a S:*Os v M% g7f)Nrj.0rs r !valid_contexto..$BEbuB11611E+-rrc3^# UH#nS[U5s=:*=(a S:*Os v M% g7f)rrNrrs rrrrr)rzrr;rjrmany)r|r exceptionrrs rvalid_contextorsr 5z%%(/?@@5:H63''Ua'kCAg,?6,IkcRW^_X_R`NaekNkk6 Ua CJNe!Gng6 6## 7e!Gnh7 76BX~"j))ZJ-G-G:VXZ_K`K`   !E!BEBBBB !E! BEBBBB rc @[U5[:a [SSS9e[U[[ 45(aUR S5n[U5S:Xa [S S S9e[US S 9(d [SS S9e[U5 [U5 [U5 [U5GHup#[U5n[U[R S5(aM5[U[R S5(a;[#X5nU(d&[)S['U5SUS-SU<3SUUUS-S9eM[U[R S5(a8[+X5(d&[)S['U5SUS-SU<3SUUUS-S9eM[-S['U5SUS-SU<S3SUUUS-S9e [/U5 g![an[SSS9UeSnAff=f![$a,n[S['U5SUS-SU<3SUUUS-S9UeSnAff=f)aRun 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. rrrzutf-8zInvalid UTF-8 in labelr6Nrz Empty Labelr"Trr PVALIDCONTEXTJz%Unknown codepoint adjacent to joiner rr in r+rCzJoiner  not allowed at position r)CONTEXTO Codepoint r*z of z not allowedr()rzrr; isinstancebytes bytearraydecodeUnicodeDecodeErrorrrrrrrjrrcodepoint_classesrrfrvr_rr\r)r|errrrr contextj_oks r check_labelrsp$ 5z%%(/?@@%%+,, TLL)E 5zQ M:: u4 8(/?@@ eE5!U#r7 Xx'A'A('K L L  Xx'A'A*'M N N ,U8 -eHo..GayPTUZT]^#& 1W x)C)CJ)O P P!%--- x 11J3QR7)SWX]W`a#& 1W .#U8_-]37)4yP\]+"q  C$Ruq" T4>JPS S T, ;E(O;LMZ]`aZaYbbfglfop,& 1W    s/G  G' G$ GG$' H1'HHc@[U5[:a [SSS9eURS5n[ U5 [ U5(d [SSS9eU$![ a Of=f[U5 [[U5-n[ U5(d [SSS9eU$)uConvert 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. rrrasciir ) rzrr;rpulabelr}UnicodeEncodeErrorr_alabel_prefixrs)r| label_bytess ralabelr s 5z%%(/?@@ll7+  {!+..,3CD D     9U#33K k * *(/?@@ sA A$#A$c[U5[:a [SSS9e[U[[ 45(dUR S5nO*[ U5nUR5(d [SSS9eUR5nUR[5(aDU[[5SnU(d [SS S9eURS 5(a [S S S9eO[U5 URS5$URS 5n[!U5U:wa [SSS9e[U5 U$![a [U5 Us$f=f![an[S S S9UeSnAff=f)u;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, and is rejected unless it is the canonical A-label for the decoded U-label (:rfc:`5891` §5.3). 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. rrrrInvalid ASCII in A-labelr5Nz5Malformed A-label, no Punycode eligible content foundr3-z"A-label must not end with a hyphenrozInvalid A-labelz=A-label is not the canonical Punycode encoding of its U-labelr4)rzrr;rrrrprrisasciilowerrrrr UnicodeErrorrs)r|rrs rrr-ss 5z%%(/?@@ eeY/ 0 0 ,,w/K El ""$$6_M M##%Kn--!#n"5"78 SZjk k    % %@GWX X & K !!'**K"":.;&W^tuu L?"   L * K)0@AsJKs)D8E8EE E/ E**E/c[RU5nU(aN[UR55nX#R 5-S-n[ S[ U5SUSU<3SUUUS9eg)zRaise if ``text``, a slice of ``domain`` starting at ``offset`` that UTS #46 mapping left unchanged, contains an ASCII character disallowed under ``UseSTD3ASCIIRules``.rrrrr8rCN)_std3_disallowed_researchrjgroupstartr\rv)r?roffsetmatchrArBs r _check_std3rbsw & &t ,E  & KKM)A-y)**CH:TRXQ[ \    rc8[R"S[SS9 g)NzTransitional processing is deprecated in UTS #46 and has no effect. The transitional argument will be removed in a future version.) stacklevel)warningswarnDeprecationWarningrYrr_warn_transitionalrss MM I rc LU(a [5 [U5[:a [SSS9eUR 5(a%UR 5nU(a [ X0S5 U$SSKJnJ nJ n /nSn[U5GH!up[U 5n U S:aU O[R"X[5S- n Xln U [:XaMBU [ :XaXLnO?U [":XaM]U [$:XaSnO&['S [)U 5S U S-S U<3S UU U S-S 9eX:a(XU nU(a [ XU5 UR+U5 U(aXU(a@[,R/U5(a&['S [)U 5S U S-S U<3SUU U S-S 9eUR+U5 U S-nGM$ US:Xa*U(a [ XS5 [0R2"SU5$XSnU(a [ UX5 UR+U5 [0R2"SSR5U55$)uApply the UTS #46 character mapping to a domain string. Implements the mapping table from `UTS #46 §4 `_: each character is kept, replaced, or rejected based on its status (``V``, ``M``, ``D``, ``I``, ``X``). The result is returned in Normalisation Form C. :param domain: The full domain name to remap. :param std3_rules: If ``True``, apply UTS #46's ``UseSTD3ASCIIRules``: after mapping, any ASCII character other than a lowercase letter, digit, hyphen or the label separator ``.`` is rejected, whether it appeared in the input or was produced by a mapping (e.g. U+FF01 FULLWIDTH EXCLAMATION MARK maps to ``!``). If ``False``, such characters are passed through. :param transitional: Deprecated and ignored. UTS #46 deprecated transitional processing in Unicode 15.1 and deviation (status ``D``) codepoints are now always kept, so this has no effect beyond emitting a :class:`DeprecationWarning`. It will be removed in a future version. :returns: The remapped domain, in Normalisation Form C. :raises InvalidCodepoint: If the domain contains a disallowed codepoint under the chosen rules. :raises IDNAError: If ``domain`` exceeds the defensive input length limit. Domain too longrrrr)uts46_replacements uts46_startsuts46_statusesNrrrr7rCr8rr)rrzrr;rrr uts46datarrrrrjbisect bisect_right _STATUS_VALID_STATUS_MAPPED_STATUS_DEVIATION_STATUS_IGNOREDr\rvappendrrrbrjoin)r std3_rules transitionalresultrrroutputrrchar code_pointrstatus replacementruntails r uts46_remapr|s!2 6{&&)0@AA ~~   * KK F Ev& Y $s*J0C0CL0]`a0a" ] "  ^ #,/K ( (   &K"U:.//Hq QUV\U_`'$q   ;s#CC/ MM#  188EE& z!2 33LSSTWIUYZ`Ycd%( 1W  MM+ &aK'N z   *$$UF33 &>DD&( MM$   88rcU(a [5 [U[5(d [US5n[ U5[:a [ SSS9eU(a [X5n[USS 9(d [ SS S9eS n/nU(aURS 5O[RU5nU(aUS /:Xa [ SSS9eUSS :XaUS SnUH0n [U 5nU(aURU5 M([ SSS9e U(aURS5 SRU5n[X5(d [ SS S9eU$![[4an[ SSS9UeSnAff=f)aEncode 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: Deprecated and ignored (see :func:`uts46_remap`): 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. rzGshould pass a unicode string to the function rather than a byte string.r5rNrrTrr!F.r Empty domainr#r Empty labelr"r.)rrstrr TypeErrorr;rzrrrsplit_unicode_dots_rerr r ) rrstrictuts46rrrrrlabelsr|s rrprps_8 a   AwA  1v!!)0@AA  & qt 4)0ABBL F#QWWS\)9)?)?)BF Vt^^<< bzR 2J  5M MM! M > >   c &A q / /)0ABB H?#I. Y`o  s EE. E))E.c [U[5(d [US5n[ U5[ :a [ SSS9eU(a [XS5n[US S 9(d [ SS S9eSn/nU(aURS 5O[RU5nU(aUS /:Xa [ SSS9eUS(dUS S nUH1n [U 5n U (aURU 5 M)[ SSS9e U(aURS 5 S RU5$![[4an[ SSS9UeSnAff=f![a2 U(a)U SSR5S:XaU R5n Nef=f)uyDecode 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``. :param display: If ``True``, any ``xn--`` label that fails IDNA validation is passed through unchanged (lowercased) rather than aborting the whole call. Intended for "decode for display" consumers (e.g. URL libraries, HTTP clients) that want to show the user the label as it appears on the wire when it cannot be rendered as Unicode. Matches the per-label recovery prescribed by UTS #46 §4 and the WHATWG URL "domain to Unicode" algorithm. :returns: The decoded domain as a Unicode string. :raises IDNAError: If the input is not valid ASCII, contains an invalid label, or is empty. rrr5rNrrFTrr!rrrr#rrzxn--rr")rrrrr;rzrrrr r!rrr r ) rrr"r#rdisplayrrrr$r|us rrrso> a   WAwA 1v!!)0@AA u - qt 4)0ABBL F#QWWS\)9)?)?)BF Vt^^<< ": 2J  u A MM! M > > b 88F =#I. W6_MSV V W& 5!9??,6KKM  s) D$ E$E4 D??E8FF)rintrLr=)rr(rLr()rrrlrrLbool)rrrrLr)rrr(rLr)r| bytes | strrLr))rr*rr)rLr))F)r|rrr)rLr))r|rrLr))r|rrLrM)r|rrr(rLr))r|rrr(rr)rLr))r|str | bytes | bytearrayrLrM)r|rrLr)r|r+rLr)r?rrrrr(rLrM)rLrM)TF)rrrr)rr)rLr)FFFF) rrr+r"r)r#r)rr)rr)rLr) rrr+r"r)r#r)rr)r&r)rLr); __future__rrrerbrtypingrrr intrangesrrrrrr r r compiler!r frozensetrrrrrrrrrr _ErrorCoderr;rWr\r_rhrmrsrvr}rrrrrrrrrrrrrrprrYrrr3s/" (DKA ~0/:::;jj!PQS$K( !23Z["#:;tTl+NO"C;/c +c + >%! %!PFIFGyGNiN @   9sl*$ Q3l.bOdD2j "\9B @ @ @  @  @  @  @ J @@ @ @ @  @  @r