codekingpro/portable-devtools

1�

2r�j3�����Sr/S
Q
r
SrS'Sj
rS'Sj
rS'Sj
rS'S	j
rS(S3j
rS(Sj
rS(Sj
r	S(S
j
r4S)Sj
rS)Sj
rS'Sj
r
S*Sj
rS+Sj
rSrSqS,Sj
rS-Sj
rS.Sj
rSSKJr SSKJr SSKJr SSKJr SSK7 SSKJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r* SSKJ+r,J-r.J/r0J1r2J3r4 \5Rlq7\8"S5
r9[n\l70r:\"5r;0r<0r=0r>S r?S r@S!rAS"rB\A"S#SS0S5rC\D"\C5
rE\D"\CRS#5
5
rFCC\
R�S$5
 \
R�S%5
 \rHSSKIrJS&rK\JR�"\E\K5 g)/a�0Support for regular expressions (RE).5 6This module provides regular expression matching operations similar to those7found in Perl. It supports both 8-bit and Unicode strings; both the pattern and8the strings being processed can contain null bytes and characters outside the9US ASCII range.10 11Regular expressions can contain both special and ordinary characters. Most12ordinary characters, like "A", "a", or "0", are the simplest regular13expressions; they simply match themselves. You can concatenate ordinary14characters, so last matches the string 'last'.15 16There are a few differences between the old (legacy) behaviour and the new17(enhanced) behaviour, which are indicated by VERSION0 or VERSION1.18 19The special characters are:20    "."                 Matches any character except a newline.21    "^"                 Matches the start of the string.22    "$"                 Matches the end of the string or just before the23                        newline at the end of the string.24    "*"                 Matches 0 or more (greedy) repetitions of the preceding25                        RE. Greedy means that it will match as many repetitions26                        as possible.27    "+"                 Matches 1 or more (greedy) repetitions of the preceding28                        RE.29    "?"                 Matches 0 or 1 (greedy) of the preceding RE.30    *?,+?,??            Non-greedy versions of the previous three special31                        characters.32    *+,++,?+            Possessive versions of the previous three special33                        characters.34    {m,n}               Matches from m to n repetitions of the preceding RE.35    {m,n}?              Non-greedy version of the above.36    {m,n}+              Possessive version of the above.37    {...}               Fuzzy matching constraints.38    "\\"                Either escapes special characters or signals a special39                        sequence.40    [...]               Indicates a set of characters. A "^" as the first41                        character indicates a complementing set.42    "|"                 A|B, creates an RE that will match either A or B.43    (...)               Matches the RE inside the parentheses. The contents are44                        captured and can be retrieved or matched later in the45                        string.46    (?flags-flags)      VERSION1: Sets/clears the flags for the remainder of47                        the group or pattern; VERSION0: Sets the flags for the48                        entire pattern.49    (?:...)             Non-capturing version of regular parentheses.50    (?>...)             Atomic non-capturing version of regular parentheses.51    (?flags-flags:...)  Non-capturing version of regular parentheses with local52                        flags.53    (?P<name>...)       The substring matched by the group is accessible by54                        name.55    (?<name>...)        The substring matched by the group is accessible by56                        name.57    (?P=name)           Matches the text matched earlier by the group named58                        name.59    (?#...)             A comment; ignored.60    (?=...)             Matches if ... matches next, but doesn't consume the61                        string.62    (?!...)             Matches if ... doesn't match next.63    (?<=...)            Matches if preceded by ....64    (?<!...)            Matches if not preceded by ....65    (?(id)yes|no)       Matches yes pattern if group id matched, the (optional)66                        no pattern otherwise.67    (?(DEFINE)...)      If there's no group called "DEFINE", then ... will be68                        ignored, but any group definitions will be available.69    (?|...|...)         (?|A|B), creates an RE that will match either A or B,70                        but reuses capture group numbers across the71                        alternatives.72    (*FAIL)             Forces matching to fail, which means immediate73                        backtracking.74    (*F)                Abbreviation for (*FAIL).75    (*PRUNE)            Discards the current backtracking information. Its76                        effect doesn't extend outside an atomic group or a77                        lookaround.78    (*SKIP)             Similar to (*PRUNE), except that it also sets where in79                        the text the next attempt at matching the entire80                        pattern will start. Its effect doesn't extend outside81                        an atomic group or a lookaround.82 83The fuzzy matching constraints are: "i" to permit insertions, "d" to permit84deletions, "s" to permit substitutions, "e" to permit any of these. Limits are85optional with "<=" and "<". If any type of error is provided then any type not86provided is not permitted.87 88A cost equation may be provided.89 90Examples:91    (?:fuzzy){i<=2}92    (?:fuzzy){i<=1,s<=2,d<=1,1i+1s+1d<3}93 94VERSION1: Set operators are supported, and a set can include nested sets. The95set operators, in order of increasing precedence, are:96    ||  Set union ("x||y" means "x or y").97    ~~  (double tilde) Symmetric set difference ("x~~y" means "x or y, but not98        both").99    &&  Set intersection ("x&&y" means "x and y").100    --  (double dash) Set difference ("x--y" means "x but not y").101 102Implicit union, ie, simple juxtaposition like in [ab], has the highest103precedence.104 105VERSION0 and VERSION1:106The special sequences consist of "\\" and a character from the list below. If107the ordinary character is not on the list, then the resulting RE will match the108second character.109    \number         Matches the contents of the group of the same number if110                    number is no more than 2 digits, otherwise the character111                    with the 3-digit octal code.112    \a              Matches the bell character.113    \A              Matches only at the start of the string.114    \b              Matches the empty string, but only at the start or end of a115                    word.116    \B              Matches the empty string, but not at the start or end of a117                    word.118    \d              Matches any decimal digit; equivalent to the set [0-9] when119                    matching a bytestring or a Unicode string with the ASCII120                    flag, or the whole range of Unicode digits when matching a121                    Unicode string.122    \D              Matches any non-digit character; equivalent to [^\d].123    \f              Matches the formfeed character.124    \g<name>        Matches the text matched by the group named name.125    \G              Matches the empty string, but only at the position where126                    the search started.127    \h              Matches horizontal whitespace.128    \K              Keeps only what follows for the entire match.129    \L<name>        Named list. The list is provided as a keyword argument.130    \m              Matches the empty string, but only at the start of a word.131    \M              Matches the empty string, but only at the end of a word.132    \n              Matches the newline character.133    \N{name}        Matches the named character.134    \p{name=value}  Matches the character if its property has the specified135                    value.136    \P{name=value}  Matches the character if its property hasn't the specified137                    value.138    \r              Matches the carriage-return character.139    \s              Matches any whitespace character; equivalent to140                    [ \t\n\r\f\v].141    \S              Matches any non-whitespace character; equivalent to [^\s].142    \t              Matches the tab character.143    \uXXXX          Matches the Unicode codepoint with 4-digit hex code XXXX.144    \UXXXXXXXX      Matches the Unicode codepoint with 8-digit hex code145                    XXXXXXXX.146    \v              Matches the vertical tab character.147    \w              Matches any alphanumeric character; equivalent to148                    [a-zA-Z0-9_] when matching a bytestring or a Unicode string149                    with the ASCII flag, or the whole range of Unicode150                    alphanumeric characters (letters plus digits plus151                    underscore) when matching a Unicode string. With LOCALE, it152                    will match the set [0-9_] plus characters defined as153                    letters for the current locale.154    \W              Matches the complement of \w; equivalent to [^\w].155    \xXX            Matches the character with 2-digit hex code XX.156    \X              Matches a grapheme.157    \Z              Matches only at the end of the string.158    \z              Matches only at the end of the string. Alias of \Z.159    \\              Matches a literal backslash.160 161This module exports the following functions:162    match        Match a regular expression pattern at the beginning of a string.163    prefixmatch  Match a regular expression pattern at the beginning of a string.164                 Alias of match.165    fullmatch    Match a regular expression pattern against all of a string.166    search       Search a string for the presence of a pattern.167    sub          Substitute occurrences of a pattern found in a string using a168                 template string.169    subf         Substitute occurrences of a pattern found in a string using a170                 format string.171    subn         Same as sub, but also return the number of substitutions made.172    subfn        Same as subf, but also return the number of substitutions made.173    split        Split a string by the occurrences of a pattern. VERSION1: will174                 split at zero-width match; VERSION0: won't split at zero-width175                 match.176    splititer    Return an iterator yielding the parts of a split string.177    findall      Find all occurrences of a pattern in a string.178    finditer     Return an iterator yielding a match object for each match.179    compile      Compile a pattern into a Pattern object.180    purge        Clear the regular expression cache.181    escape       Backslash all non-alphanumerics or special characters in a182                 string.183 184Most of the functions support a concurrent parameter: if True, the GIL will be185released during matching, allowing other Python threads to run concurrently. If186the string changes during matching, the behaviour is undefined. This parameter187is not needed when working on the builtin (immutable) string classes.188 189Some of the functions in this module take flags as optional parameters. Most of190these flags can also be set within an RE:191    A   a   ASCII         Make \w, \W, \b, \B, \d, and \D match the192                          corresponding ASCII character categories. Default193                          when matching a bytestring.194    B   b   BESTMATCH     Find the best fuzzy match (default is first).195    D       DEBUG         Print the parsed pattern.196    E   e   ENHANCEMATCH  Attempt to improve the fit after finding the first197                          fuzzy match.198    F   f   FULLCASE      Use full case-folding when performing199                          case-insensitive matching in Unicode.200    I   i   IGNORECASE    Perform case-insensitive matching.201    L   L   LOCALE        Make \w, \W, \b, \B, \d, and \D dependent on the202                          current locale. (One byte per character only.)203    M   m   MULTILINE     "^" matches the beginning of lines (after a newline)204                          as well as the string. "$" matches the end of lines205                          (before a newline) as well as the end of the string.206    P   p   POSIX         Perform POSIX-standard matching (leftmost longest).207    R   r   REVERSE       Searches backwards.208    S   s   DOTALL        "." matches any character at all, including the209                          newline.210    U   u   UNICODE       Make \w, \W, \b, \B, \d, and \D dependent on the211                          Unicode locale. Default when matching a Unicode212                          string.213    V0  V0  VERSION0      Turn on the old legacy behaviour.214    V1  V1  VERSION1      Turn on the new enhanced behaviour. This flag215                          includes the FULLCASE flag.216    W   w   WORD          Make \b and \B work with default Unicode word breaks217                          and make ".", "^" and "$" work with Unicode line218                          breaks.219    X   x   VERBOSE       Ignore whitespace and comments for nicer looking REs.220 221This module also defines an exception 'error'.222 223):�	cache_all�compile�DEFAULT_VERSION�escape�findall�finditer�	fullmatch�match�prefixmatch�purge�search�split�	splititer�sub�subf�subfn�subn�template�Scanner�
A�ASCII�
B�	BESTMATCH�
D�DEBUG�
E�ENHANCEMATCH�
S�DOTALL�
F�FULLCASE�
I�224IGNORECASE�
L�LOCALE�
M�	MULTILINE�
P�POSIX�
R�REVERSE�
T�TEMPLATE�
U�UNICODE�V0�VERSION0�V1�VERSION1�
X�VERBOSE�
W�WORD�error�Regex�__version__�__doc__�	RegexFlagz2026.5.9�NFc	�B�[
XX�S
5n225U226RXXFXW5$)zmTry to apply the pattern at the start of the string, returning a match227object, or None if no match was found.T��_compiler	��pattern�string�flags�pos�endpos�partial�228concurrent�timeout�
ignore_unused�kwargs�pats           �QD:\code\apps\devtools\python\user_packages\Python313\site-packages\regex/_main.pyr	r	��%���7�=�$�229?�C��9�9�V�&�g�G�G�c	�B�[
XX�S
5n230U231RXXFXW5$)zTry to apply the pattern at the start of the string, returning a match232object, or None if no match was found. Alias of match().Tr>r@s           rLr233r234
rMrNc	�B�[
XX�S
5n235U236RXXFXW5$)zlTry to apply the pattern against all of the string, returning a match237object, or None if no match was found.T)r?rr@s           rLrr238
s%���7�=�$�239?�C��=�=��f�'�K�KrNc	�B�[
XX�S
5n240U241RXXFXW5$)zrSearch through string looking for a match to the pattern, returning a242match object, or None if no match was found.T)r?rr@s           rLrr
s%���7�=�$�243?�C��:�:�f�6�w�H�HrNc244	�D�[
XX�S
5nURXX5XgU5$)ad
Return the string obtained by replacing the leftmost (or rightmost with a245reverse pattern) non-overlapping occurrences of the pattern in string by the246replacement repl. repl can be either a string or a callable; if a string,247backslash escapes in it are processed; if a callable, it's passed the match248object and must return a replacement string to be used.T)r?r�rA�replrB�countrCrDrErGrHrIrJrKs            rLrr
s'���7�=�$�249?�C��7�7�4��V��I�IrNc250	�D�[
XX�S
5nURXX5XgU5$)ab
Return the string obtained by replacing the leftmost (or rightmost with a251reverse pattern) non-overlapping occurrences of the pattern in string by the252replacement format. format can be either a string or a callable; if a string,253it's treated as a format string; if a callable, it's passed the match object254and must return a replacement string to be used.T)r?r�rA�formatrBrUrCrDrErGrHrIrJrKs            rLrr"
s'���7�=�$�255?�C��8�8�F�E��G�L�LrNc256	�D�[
XX�S
5nURXX5XgU5$)a�
Return a 2-tuple containing (new_string, number). new_string is the string257obtained by replacing the leftmost (or rightmost with a reverse pattern)258non-overlapping occurrences of the pattern in the source string by the259replacement repl. number is the number of substitutions that were made. repl260can be either a string or a callable; if a string, backslash escapes in it261are processed; if a callable, it's passed the match object and must return a262replacement string to be used.T)r?rrSs            rLrr,
s'���7�=�$�263?�C��8�8�D�%�f�'�J�JrNc264	�D�[
XX�S
5nURXX5XgU5$)a�
Return a 2-tuple containing (new_string, number). new_string is the string265obtained by replacing the leftmost (or rightmost with a reverse pattern)266non-overlapping occurrences of the pattern in the source string by the267replacement format. number is the number of substitutions that were made. format268can be either a string or a callable; if a string, it's treated as a format269string; if a callable, it's passed the match object and must return a270replacement string to be used.T)r?rrWs            rLrr8
s'���7�=�$�271?�C��9�9�V�U��W�M�MrNc�@�[
XXgS
5nURXXE5$)a�
Split the source string by the occurrences of the pattern, returning a272list containing the resulting substrings.  If capturing parentheses are used273in pattern, then the text of all groups in the pattern are also returned as274part of the resulting list.  If maxsplit is nonzero, at most maxsplit splits275occur, and the remainder of the string is returned as the final element of276the list.T)r?r
�	rArB�maxsplitrCrGrHrIrJrKs	         rLr
r
D
s#���7�=�$�277?�C��9�9�V�z�;�;rNc�@�[
XXgS
5nURXXE5$)z8Return an iterator yielding the parts of a split string.T)r?rr\s	         rLrrO
s#���7�=�$�278?�C��=�=��:�?�?rNc	�B�[
XX�S
5n279U280RXXEXg5$)a
Return a list of all matches in the string. The matches may be overlapped281if overlapped is True. If one or more groups are present in the pattern,282return a list of groups; this will be a list of tuples if the pattern has283more than one group. Empty matches are included in the result.T)r?r)rArBrCrDrE�284overlappedrGrHrIrJrKs           rLrrU
s%���7�=�$�285?�C��;�;�v�F�286�L�LrNc287	�D�[
XX�S
5nURXXEXvU5$)z�Return an iterator over all matches in the string. The matches may be288overlapped if overlapped is True. For each match, the iterator returns a289match object. Empty matches are included in the result.T)r?r)rArBrCrDrEr`rFrGrHrIrJrKs            rLrr^
s,��290�7�=�$�291?�C��<�<��V��
�
�
rNc�.�Uc[n[X
X$U5$)
zACompile a regular expression pattern, returning a pattern object.)�292_cache_allr?)rArCrI�
cache_patternrJs     rLrrg
s����"�
��G�M�=�I�IrNc�T�[R5 [R5 g
)z"Clear the regular expression cacheN)�_cache�clear�_locale_sensitive�rNrLrrm
s��293�L�L�N����rNTc

��Uc[$Uqg
)z�Sets whether to cache all patterns, even those are compiled explicitly.294Passing None has no effect, but returns the current setting.N)
rc)
�values
 rLrru
s��295
�}����JrNc�,�[
X
[-S
0S
5$)z7Compile a template pattern, returning a pattern object.F)r?r,)rArCs  rLrr
s���G�X�-�u�b�%�@�@rNc��[
U[5(aURS
5
nOUn/nU
(a~UHwnUS:XaU(aURU5
 M#U[;dUR5(a$URS5
 URU5
 MfURU5
 My OhUHbnUS:XaU(aURU5
 M#U[;aURU5
 M@URS5
 URU5
 Md SRU5
n[
U[5(aURS
5
nU$)z�Escape a string for use as a literal in a pattern. If special_only is296True, escape only special characters, else escape all non-alphanumeric297characters. If literal_spaces is True, don't escape spaces.zlatin-1�
 �
\�)	�298isinstance�bytes�decode�append�299_METACHARS�isspace�_ALNUM�join�encode)rA�special_only�literal_spaces�
p�
s�
c�
rs       rLrr�
s���300�'�5�!�!��N�N�9�%�
��
�301�A���A��C�x�N�������j��A�I�I�K�K������������������A��C�x�N�������f������������������	���
�302�A��'�5�!�!�
�H�H�Y��
��HrN)
�_regex_core)
�_regex)
�RLock)
�getpreferredencoding)
�
*)�
_ALL_VERSIONS�_ALL_ENCODINGS�_FirstSetError�_UnscopedFlagSet�_check_group_features�_compile_firstset�_compile_replacement�
_flatten_code�303_fold_case�_get_required_string�_parse_pattern�
_shrink_cache)�ALNUM�Info�OP�Source�Fuzzyz()[]{}?*+|^$\.-#&~i�
c
�^^^)^*�S
SKJ
q
 U
[-
S
:waSn[	U5
U4n[304R
US5(d
U
[-
S
:wa[5nOSnU)UU4SjnU(a�U[	U5
U
4n[Um)[5n	T)(a+T)H%up�U	RU305[TU3065
45
 M' U"5 [U	5
n	U[	U5
X[U4n[ U$[#U[$5(a[&n
OP[#U[(5(a[*n
O4[#U[,5(aU
(a[/S5
e
U$[1S	5
e
[[2l
U
nSn[5U5
n[7UUR8T5m*U
T*l[=T*R>[@-
5
Ul![EUT*5nURQ5(d[S307UURN5e
T*R>[R-
=
(d [nUS
[T[V4;
a[/S5
e
T*R>[X-
S
[*[[&4;
a[/S5
e
[#U[(5(a#T*R>[&-
(a[/S
5
e
T*R>[X-
(dH[#U[$5(aT*=
R>[&-slOT*=
R>[*-sl[=T*R>[Z-
5
n[#U[\5nT*R^[308U'SnURaUUS5 U(a+[URJURLURN5e
U
[-
(aURcS
US9 UReT*U5nURgT*5
n[iUT*R>5unnn0nS/
[kT*Rl5
-n[5m)T*RlRo5HUunnUunn[TU5
nU(a[U*4
SjU55
n OUn UUU'U UU'T)RUU45
 MW U"5 [qT*U5 URsU5
n!S
UU4nT*RtR
U5
n"U"b)[vRxU"4/
U!-[vRz4
/
-n!U![vR|4
/
-
n!T*R~Hun#n$n%U!U#RsU$U%5-
n!M [�U!5
n!UR�5(d,[�T*UR�U5
5n&[�U&5
n&U&U!-n![�ST*R�Ro555
n'[�Rr"UT*R>U-U!T*R�U'UUUUUT*R�5n([k[ 5
[�:�a-[� [�[ [[309[�5 SSS5 U(aKT*R>[-
S
:XaSn[T)5
m)U[	U5
U
T)[U4nU([ U'T)[W'U($![a GNtf=f
![a [SRU3105
5
e
f=f
![a GN�f=f
![Fa T*RHnO[anUnSnAOSnAf
f=f
U(a+[URJURLURN5e
GM�![a
nUnSnAGN�SnAf
f=f
![�a G
N�f=f
!,(d
f   G
N==f
)z1Compiles a regular expression to a PatternObject.r<)
rFTNc��>�T(a
g[
T5
TVV
s1sHup
UiM	 sn
n-311nU(a.[[U5
5
n[S
R	U5
5
e
gs sn
nf)Nzunused keyword argument {!a})�set�next�iter�312ValueErrorrX)�
k�
v�
unused_kwargs�any_one�args_neededrIrJs    ���rL�complain_unused_args�&_compile.<locals>.complain_unused_args�
s^������F��[�&A�[�T�Q�q�[�&A�A�
���4�
�.�/�G��;�B�B�7�K�L�L���'B
s�A#zmissing named list: {!r}z5cannot process flags argument with a compiled patternz3first argument must be a string or compiled patternzunbalanced parenthesisz5VERSION0 and VERSION1 flags are mutually incompatiblez9ASCII, LOCALE and UNICODE flags are mutually incompatiblez,cannot use UNICODE flag with a bytes pattern)�indent�reversec
3�<>
# �UHn
[
TU
5v� M g7f
�
N)
r�)�.0r��infos  �rL�	<genexpr>�_compile.<locals>.<genexpr>cs����B�6�a�j��q�1�1�6�s�
c
3�,# �UH313upX!4v� M g7f
r�ri)r��
nr�s   rLr�r��s���C�*B�$�!�
�v�*B�s�
)L�regexr�ImportErrorr�typerh�getr$�_getpreferredencoding�_named_argsr��add�	frozenset�KeyErrorr7rXrfrq�strr.rrr�Patternr��	TypeErrorr��_Source�_Info�	char_type�guess_encoding�boolrCr4�ignore_spacer�r��global_flags�msgrArD�at_endr�r0r2r�r*�_Fuzzy�
inline_locale�314fix_groups�dump�optimise�pack_charactersr��len�named_lists_used�itemsr�r�	call_refs�_OP�CALL_REF�END�SUCCESS�additional_groupsr��has_simple_startr��get_firstsetr��dict�group_indexr��group_count�	_MAXCACHE�_cache_lockr�)+rArCrIrJ�cache_it�315locale_key�pattern_localer��args_key�
args_suppliedr�r��pattern_keyr�r��caught_exception�source�parsed�
e�versionr��fuzzy�316req_offset�	req_chars�	req_flags�named_lists�named_list_indexes�key�index�name�317case_flags�valuesr��code�ref�group�rev�fuz�fs_code�index_group�compiled_patternr�r�s+  ``                                     @@rLr?r?�
s����
�)�318	��
�!�����w�-��)�J����Z��.�.�5�6�>�a�2G�.�0����M
��	���W�
�u�4�H�%�h�/�K� �E�M��'�D�A�J
�%�)�)�1�i��q�	�.B�*C�D�(�
!�"�%�m�4�M�#�D��M�5��~�
/�K��+�&�&��'�3��� ��	�G�U�	#�	#���	�G�W�	%�	%���T�U�U����M�N�N�#2�K���L�319���	!��W�%�F���v�'7�'7��@�D�"0�D��"&�t�z�z�G�';�"<�F��#�F�D�1�F���=�=�?�?��,�g�v�z�z�B�B��z�z�M�)�=�o�G��q�(�H�-�-��P�Q�Q��320�321�^�#�Q��v�w�,G�G��T�U�U��'�5�!�!�t�z�z�G�';��G�H�H��J�J��'��g�s�#�#��J�J�'�!�J��J�J�%��J��4�:�:��'�(�G��v�v�&�E�%)�$6�$6��j�!�������'�7�E�2���$�(�(�*:�*B�*B�322�323�324�
 �
	 �
�u�}����1�g��.��_�_�T�7�
+�F�
�
#�
#�D�
)�F�(<�F�D�J�J�'O�$�J�	�9��K���#�d�&;�&;�"<�<���%�K��+�+�1�1�3�325��U����j��6�$�<�(����B�6�B�B�E��E�"��D��$)��5�!�����v��'�4����$��'��>�>�'�"�D�
�g�u�326�C�327�.�.�328�329�S�330!�C�331�����s�#�$�t�+����{�m�;��	�c�k�k�_���D� �1�1���s�C���
�
�c�3�'�'��2����D��"�"�$�$�	�'��f�.A�.A�'�.J�K�G�#�G�,�G��T�>�D�332�C�$�*:�*:�*@�*@�*B�C�C�K��~�~�g�t�z�z�G�/C�T�333����[�2D��)�Y��(8�(8�:��334�6�{�i��
��&�+�/@�)�L����J�J���A�%�!�N���,����W�
�u�k�335�>�
+��.��{��!,��H�����s�

��

��L
$�
J
�#�$>�$E�$E�a�$H�I�I�
J
���	��	��> �	-��,�,�L��
	!� ���
	!����(�,�,�.>�.F�.F��"�"�
$�

$�!��b
�
����
��~
�
	��
	��"�[�s��Y3�-/Z,�Z�<2Z,�0AZ=�;\"�+\<�8]
�3336Z
�
Z
�%Z)�)Z,�,337Z:�9
Z:�=[*�	[*�[%�%[*�"338\9�,\4�4\9�<339]340�	
]341�
342]c��URURU
4n[RU5
nUbU$[	[5
[343:�a[R
5 [U
[5n[U
5
nU(aS
nOSn/n/nUR5nU(d
O{US:XaY[XPU5up�U	(a2U(aURU"U5
5
 /nURU3445
 O,URU3455
 OUR[U5
5
 M�U(aURU"U5
5
 U[U'U$)z Compiles a replacement template.c
�2�S
R
SU55
$)Nrpc
3�8# �UHn
[
U
5
v� M g7f
r�)
�chr)r�r~s  rLr��C_compile_replacement_helper.<locals>.make_string.<locals>.<genexpr>�s���6�:�a�3�q�6�6�:�s�
)
rx�
�346char_codess
 rL�make_string�0_compile_replacement_helper.<locals>.make_string�s���7�7�6�:�6�6�6rNc
��[
U5
$r�)
rrr�s
 rLr�r��s
����$�$rNro)rArC�_replacement_cacher�r��_MAXREPCACHErgrqr�r�r�rt�extend�ord)rArr��compiled�347is_unicoder�r��literal�ch�is_groupr�s           rL�_compile_replacement_helperr	
�s
��348�/�/�7�=�=�(�3492�C�!�%�%�c�*�H�����350���,�.�� � �"��H�c�*�J�
�X�
�F��
	7�
	%��H��G�351�
�Z�Z�\����
��:�3�6�J�O�O�H����O�O�K��$8�9� �G�����&����u�%��N�N�3�r�7�#�%�*�����G�,�-�&��s���OrNrpr��Matchc
�:�[RUR4$r�)r�r�
_pickled_data)
rAs
 rL�_pickler

�s���>�>�7�0�0�0�0rN)r<NNFNNF)r<r<NNNNF)r<r<NNF)r<NNFFNNF)r<FN)
T)
r<)TF)Mr:�__all__r9r	r352rrrrrrr
rrrrrrcrrrr�r�r��	threadingr��_RLock�localer�r��regex._regex_corer�r�r�r�r�r�r�r�r�r�r�r�r�rwr�r�r�r�r�r�r�r�r;r0rr�rurfr�r�r
rhr�r

r?r	
�_patr�r�r353
rtr8�copyreg�	_copy_regr

�picklerirNrL�<module>r

s�
�


� [
�|����354D
I
�/4�
H
�J
O
�/4�
H
�H
M
�/4�
L
�E
J
�/4�
I
�C
G
�/4�
J
�F
J
�/4�
M
�D
H
�/4�355
K
�G
K
�/4�356
N
�J
N
��	
<�@
D
�#�
@
�I
N
�/4�
M
�J
O
�>C�
�
J
�
��357�
�
A
�#

�P

��%�@��
!�
!�
!�
!�

�

��$�$��
�,�
-�358�-���359���h��������
�	���_
�B2
�j
��A�u�b�%�(��360�t�*���T�Z�Z��^����
���y�����w��	��
�

1�
361����'�"rN