idZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z m Z ddlZddlmZmZddlmZdZej,d Zej,d ZGd d Zd ddddddZiddddddddddddddddddddd dd!dd"d#d$d%d&d'd(d)d*d+id,d+d-d+d.d+d/d0d1d0d2d0d3d0d4d5d6d5d7d5d8d5d9d:d;d:dd?d@dAidBdCdDdCdEdCdFdCdGdCdHdCdIdJdKdJdLdJdMdJdNdJdOdJdPdQdRdQdSdQdTdQdUdVdVdVdVdWdXdXdYdZd[d\d]d^d^d_ Zd`ZdaZdbZdcZddZ deZ!dfZ"dgZ#ee ze!ze"ze#zZ$dhZ%diZ&djZ'dkZ(dlZ)dmZ*dnZ+doZ,e'e(ze)ze*zZ-dpZ.dqe-drZ/dqe$drZ0dsZ1dqe%drZ2dqe&drZ3dtee-e1e%e&e+drZ4duZ5dve0dwe5dxZ6dtedrZ7dyZ8dzZ9dqe+drZ:d{Z;dve3dwe4dxZdve.d}Z?e6d~Z@dqe,dZAdve;dve7dwe8dwe9dxeAe@d ZBdZCdZDeAe@zeBzZEdve2dwe8dwe9dxeEZFdZGdjgde:d~e3de>de/dwe:de=de?de/dwe:e<de:d~e<de>dwe:de?dweDdweCdwe1deFdZIeeZJeeIZKeeZLejeGZNeje.ZOejdZPddZQdddZRddZSddZTddZUddZVddZWddZXddZYdddZZddZ[ddZ\ddZ]ddZ^ddZ_ddZ`ddZadddZHddZbddZcddZdddZe d ddZfdddZgdddZhdddZidddZjddZkdddZldddZmddZn ddZo d ddZpdddZq d ddZr d ddZs d ddZtddZu d ddZv d ddZwdddZxddZyefddZzddZ{dddZ|ddZ}ddZ~ddZddZddZddZddZddZddZdd„ZddÄZdddĄZdddńZdddƄZ d ddDŽZddȄZddɄZddʄZddd˄Zdd̄Zdؐdd̈́Zd΄ZdτZdЄZ ddфZy(z, String functions. .. versionadded:: 1.1.0 ) annotationsN) parse_qsl urlencodeurlsplit urlunsplit)UNSETUnset)NumberT)B camel_case capitalizechop chop_rightcharsclean count_substrdeburr decapitalize ends_withensure_ends_withensure_starts_withescapeescape_reg_exp has_substr human_case insert_substrjoin kebab_caselines lower_case lower_first number_formatpadpad_end pad_start pascal_case predecessorprunequotereg_exp_js_matchreg_exp_js_replacereg_exp_replacerepeatreplace replace_end replace_startseparator_case series_phraseseries_phrase_serialslugify snake_casesplit start_case starts_with strip_tags substr_leftsubstr_left_end substr_rightsubstr_right_end successorsurround swap_case title_caseto_lowerto_uppertrimtrim_end trim_starttruncateunescapeunquote upper_case upper_firsturlwordsTT2c(eZdZdZddZddZddZy) JSRegExpz Javascript-style regular expression pattern. Converts a Javascript-style regular expression to the equivalent Python version. c|ddjdd\}}d|v|_d|v|_|jrtjnd}tj |||_y)Nr/girflags)rsplit_global _ignore_casereIcompilepattern)selfreg_expr^optionsrWs F/home/Script/Script_env/lib/python3.12/site-packages/pydash/strings.py__init__zJSRegExp.__init__gs["12;--c15g~ 7N))qzz'7 c|jr|jj|}|S|jj|}|r|j g}|Sg}|S)z*Return list of regular expression matches.)rYr^findallsearchgroup)r_textresultsress rbfindz JSRegExp.findps] <<ll**40G ,,%%d+C99;-rdc^|jrdnd}|jj|||S)z8Replace parts of text that match the regular expression.rrcount)rYr^sub)r_rireplros rbr.zJSRegExp.replace|s+\\q||d%88rdN)r`strreturnNone)rirrrs t.List[str])rirrrq.t.Union[str, t.Callable[[re.Match[str]], str]]rsrr)__name__ __module__ __qualname____doc__rcrlr.rdrbrQrQ`s 8 9rdrQz&z<z>z"z'z`)&<>"'`ÀAÁÂÃÄÅàaáâãäåÇCçcÐDðdÈEÉÊËèeéêëÌr\ÍÎÏìrUíîïÑNñnÒOÓÔÕÖØòoóôõöøÙUÚÛÜùuYyAeaeThthss ) úûüÝýÿÆæÞþß×÷z/[^-/:-@[-`{-]+/gu /[À-ÿ]/gz \ud800-\udfffz \u0300-\u036fz \ufe20-\ufe2fz \u20d0-\u20ffz \u1ab0-\u1affz \u1dc0-\u1dffz \u2700-\u27bfza-z\xdf-\xf6\xf8-\xffz\xac\xb1\xd7\xf7z$\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbfz \u2000-\u206fz \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000zA-Z\xc0-\xd6\xd8-\xdez \ufe0e\ufe0fu['’][]z\dz[^z\ud83c[\udffb-\udfff]z(?:|)z(?:\ud83c[\udde6-\uddff]){2}z[\ud800-\udbff][\udc00-\udfff]z\u200dz(?:d|ll|m|re|s|t|ve))?z(?:D|LL|M|RE|S|T|VE))??z]?z)*z-\d*(?:1st|2nd|3rd|(?![123])\dth)(?=\b|[A-Z_])z-\d*(?:1ST|2ND|3RD|(?![123])\dTH)(?=\b|[a-z_])zB[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]rS+z(?=z|$)|z+|z/gz <\/?[^>]+>cvdjdt|D}|ddj|ddzS)a6 Converts `text` to camel case. Args: text: String to convert. Returns: String converted to camel case. Example: >>> camel_case("FOO BAR_bAz") 'fooBarBAz' .. versionadded:: 1.1.0 .. versionchanged:: 5.0.0 Improved unicode word support. rc3<K|]}|jywN)title.0words rb zcamel_case..7s=D4::<=Nrr compounderlowerris rbr r #s;( 77=Jt,<= =D 8>> d12h &&rdctj|}|r|jS|ddj|ddzS)a Capitalizes the first character of `text`. Args: text: String to capitalize. strict: Whether to cast rest of string to lower case. Defaults to ``True``. Returns: Capitalized string. Example: >>> capitalize("once upon a TIME") 'Once upon a time' >>> capitalize("once upon a TIME", False) 'Once upon a TIME' .. versionadded:: 1.1.0 .. versionchanged:: 3.0.0 Added `strict` option. Nr)pyd to_stringr upperristricts rbr r ;s>. == D &4?? GD!HNN,ttj|S)a  Split `text` into a list of single characters. Args: text: String to split up. Returns: List of individual characters. Example: >>> chars("onetwo") ['o', 'n', 'e', 't', 'w', 'o'] .. versionadded:: 3.0.0 )listrrrs rbrrVs"  d# $$rdc|gStj|}|dkr|g}|Stdt||Dcgc] }||||z }}|Scc}w)aR Break up `text` into intervals of length `step`. Args: text: String to chop. step: Interval to chop `text`. Returns: List of chopped characters. If `text` is `None` an empty list is returned. Example: >>> chop("abcdefg", 3) ['abc', 'def', 'g'] .. versionadded:: 3.0.0 r)rrrangelen)ristepchoppedrUs rbrrjsi$ | == D qy& N05QD 4/HI!4AH%II NJsAc|gStj|}|dkr|g}|St|}td||Dcgc]}|||z ||z c}ddd}|Scc}w)a/ Like :func:`chop` except `text` is chopped from right. Args: text: String to chop. step: Interval to chop `text`. Returns: List of chopped characters. Example: >>> chop_right("abcdefg", 3) ['a', 'bcd', 'efg'] .. versionadded:: 3.0.0 Nr)rrrr)rirrtext_lenrUs rbrrs~$ | == D qy& Nt9=B1hPT=UV4!d( hl3VW[Y[W[\ NWsActj|}djtj|j S)z Trim and replace multiple spaces with a single space. Args: text: String to clean. Returns: Cleaned string. Example: >>> clean("a b c d") 'a b c d' .. versionadded:: 3.0.0 r)rrrcompactr6rs rbrrs0" == D 88CKK - ..rdc||ytj|}tj|}|j|S)a< Count the occurrences of `subtext` in `text`. Args: text: Source string to count from. subtext: String to count. Returns: Number of occurrences of `subtext` in `text`. Example: >>> count_substr("aabbccddaabbccdd", "bc") 2 .. versionadded:: 3.0.0 r)rrrorisubtexts rbrrs;$ |w == DmmG$G ::g rdcZtj|}tj|dS)u/ Deburrs `text` by converting latin-1 supplementary letters to basic latin letters. Args: text: String to deburr. Returns: Deburred string. Example: >>> deburr("déjà vu") '... >>> "deja vu" 'deja vu' .. versionadded:: 2.0.0 cftj|j|jSr)DEBURRED_LETTERSgetrh)matchs rbzdeburr..s ,00 Nrd)rr JS_RE_LATIN1r.rs rbrrs+& == D    N rdc^tj|}|ddj|ddzS)z Decaptitalizes the first character of `text`. Args: text: String to decapitalize. Returns: Decapitalized string. Example: >>> decapitalize("FOO BAR") 'fOO BAR' .. versionadded:: 3.0.0 Nrrrrrs rbrrs0" == D 8>> d12h &&rdctj|}tj|}| t|}|d|j|S)a Checks if `text` ends with a given target string. Args: text: String to check. target: String to check for. position: Position to search from. Defaults to end of `text`. Returns: Whether `text` ends with `target`. Example: >>> ends_with("abc def", "def") True >>> ends_with("abc def", 4) False .. versionadded:: 1.1.0 N)rrrendswithritargetpositions rbrrsF*]]6 "F == Dt9  ? # #F ++rdctj|}tj|}|j|r|S||S)a  Append a given suffix to a string, but only if the source string does not end with that suffix. Args: text: Source string to append `suffix` to. suffix: String to append to the source string if the source string does not end with `suffix`. Returns: source string possibly extended by `suffix`. Example: >>> ensure_ends_with("foo bar", "!") 'foo bar!' >>> ensure_ends_with("foo bar!", "!") 'foo bar!' .. versionadded:: 2.4.0 )rrr )risuffixs rbrr%s@* == D ]]6 "F }}V VF8 rdctj|}tj|}|j|r|S||S)a6 Prepend a given prefix to a string, but only if the source string does not start with that prefix. Args: text: Source string to prepend `prefix` to. prefix: String to prepend to the source string if the source string does not start with `prefix`. Returns: source string possibly prefixed by `prefix` Example: >>> ensure_starts_with("foo bar", "Oh my! ") 'Oh my! foo bar' >>> ensure_starts_with("Oh my! foo bar", "Oh my! ") 'Oh my! foo bar' .. versionadded:: 2.4.0 rr startswith)riprefixs rbrrAs@, == D ]]6 "F v XdV rdc\tj|}djd|DS)a Converts the characters ``&``, ``<``, ``>``, ``"``, ``'``, and ``\``` in `text` to their corresponding HTML entities. Args: text: String to escape. Returns: HTML escaped string. Example: >>> escape('"1 > 2 && 3 < 4"') '"1 > 2 && 3 < 4"' .. versionadded:: 1.0.0 .. versionchanged:: 1.1.0 Moved function to :mod:`pydash.strings`. rc3HK|]}tj||ywr) HTML_ESCAPESr)rchars rbrzescape..vsAD<##D$/As ")rrrrs rbrr^s)* == D 77ADA AArdcVtj|}tj|S)a; Escapes the RegExp special characters in `text`. Args: text: String to escape. Returns: RegExp escaped string. Example: >>> escape_reg_exp("[()]") '\\[\\(\\)\\]' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Removed alias ``escape_re`` )rrr[rrs rbrrys ( == D 99T?rdc~tj|}tj|}|j|dk\S)a] Returns whether `subtext` is included in `text`. Args: text: String to search. subtext: String to search for. Returns: Whether `subtext` is found in `text`. Example: >>> has_substr("abcdef", "bc") True >>> has_substr("abcdef", "bb") False .. versionadded:: 3.0.0 r)rrrlrs rbrrs4( == DmmG$G 99W  ""rdctj|jjddj ddj j S)a Converts `text` to human case which has only the first letter capitalized and each word separated by a space. Args: text: String to convert. Returns: String converted to human case. Example: >>> human_case("abc-def_hij lmn") 'Abc def hij lmn' >>> human_case("user_id") 'User' .. versionadded:: 3.0.0 .. versionchanged:: 5.0.0 Improved unicode word support. z_id$r_r)rchainr5r,r.r valuers rbrrsA0 $   $ c    rdcrtj|}tj|}|d||z||dzS)aY Insert `subtext` in `text` starting at position `index`. Args: text: String to add substring to. index: String index to insert into. subtext: String to insert. Returns: Modified string. Example: >>> insert_substr("abcdef", 3, "--") 'abc--def' .. versionadded:: 3.0.0 Nrr)riindexrs rbrrs<& == DmmG$G <' !DL 00rdctj|jtj|xsdtjS)a Joins an iterable into a string using `separator` between each element. Args: array: Iterable to implode. separator: Separator to using when joining. Defaults to ``''``. Returns: Joined string. Example: >>> join(["a", "b", "c"]) == "abc" True >>> join([1, 2, 3, 4], "&") == "1&2&3&4" True >>> join("abcdef", "-") == "a-b-c-d-e-f" True .. versionadded:: 2.0.0 .. versionchanged:: 4.0.0 Removed alias ``implode``. r{)rrrmap_)array separators rbrrs12 == # ( (%+2s}})M NNrdcDdjdt|DS)aM Converts `text` to kebab case (a.k.a. spinal case). Args: text: String to convert. Returns: String converted to kebab case. Example: >>> kebab_case("a b c_d-e!f") 'a-b-c-d-e-f' .. versionadded:: 1.1.0 .. versionchanged:: 5.0.0 Improved unicode word support. -c3BK|]}|s|jywrrrs rbrzkebab_case..FTDJJLFrrrs rbrrs( 88FZ-=F FFrdcLtj|}|jS)z Split lines in `text` into an array. Args: text: String to split. Returns: String split by lines. Example: >>> lines("a\nb\r\nc") ['a', 'b', 'c'] .. versionadded:: 3.0.0 )rr splitlinesrs rbrrs" == D ?? rdcRdjt|jS)a Converts string to lower case as space separated words. Args: text: String to convert. Returns: String converted to lower case as space separated words. Example: >>> lower_case("fooBar") 'foo bar' >>> lower_case("--foo-Bar--") 'foo bar' >>> lower_case('/?*Foo10/;"B*Ar') 'foo 10 b ar' .. versionadded:: 4.0.0 .. versionchanged:: 5.0.0 Improved unicode word support. rrrs rbr r +!0 88Jt$ % + + --rdc4|ddj|ddzS)a Converts the first character of string to lower case. Args: text: String passed in by the user. Returns: String in which the first character is converted to lower case. Example: >>> lower_first("FRED") 'fRED' >>> lower_first("Foo Bar") 'foo Bar' >>> lower_first("1foobar") '1foobar' >>> lower_first(";foobar") ';foobar' .. versionadded:: 4.0.0 Nrr)rs rbr!r!F". 8>> d12h &&rdc0d|dd} |j|jd}|d}|dgzd}|jt|ddd d ddd }|jt j ||g}|S#t $rd}Y|SwxYw) a" Format a number to scale with custom decimal and order separators. Args: number: Number to format. scale: Number of decimals to include. Defaults to ``0``. decimal_separator: Decimal separator to use. Defaults to ``'.'``. order_separator: Order separator to use. Defaults to ``','``. Returns: Number formatted as string. Example: >>> number_format(1234.5678) '1,235' >>> number_format(1234.5678, 2, ",", ".") '1.234,57' .. versionadded:: 3.0.0 z{0:.rzf}.rrrNr)formatr6rrrr ValueError) numberscaledecimal_separatororder_separatorfmt num_partsint_partdec_partris rbr"r"`s2 %# C IJJv&,,S1 Q<$a(#''Xdd^Q(?@2F %%ckk8X2F&GH K  Ks B BBctj|}t|}||k\r|S||z dz }tt j |}tt j |}td||}|d||z|zS)a Pads `text` on the left and right sides if it is shorter than the given padding length. The `chars` string may be truncated if the number of padding characters can't be evenly divided by the padding length. Args: text: String to pad. length: Amount to pad. chars: Characters to pad with. Defaults to ``" "``. Returns: Padded string. Example: >>> pad("abc", 5) ' abc ' >>> pad("abc", 6, "x") 'xabcxx' >>> pad("abc", 5, "...") '.abc.' .. versionadded:: 1.1.0 .. versionchanged:: 3.0.0 Fix handling of multiple `chars` so that padded string isn't over padded. g@rN)rrrintmathfloorceilr$)rilengthrrmidleft_len right_lens rbr#r#s: == D4yH6 H  #C4::c?#HDIIcN#I B 5 )E ( d "U **rdc|tj|}t|t|f}|t ||zd|S)a] Pads `text` on the right side if it is shorter than the given padding length. The `chars` string may be truncated if the number of padding characters can't be evenly divided by the padding length. Args: text: String to pad. length: Amount to pad. chars: Characters to pad with. Defaults to ``" "``. Returns: Padded string. Example: >>> pad_end("abc", 5) 'abc ' >>> pad_end("abc", 5, ".") 'abc..' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Renamed from ``pad_right`` to ``pad_end``. Nrrmaxrr-rirErs rbr$r$s>6 == D &#d)$ %F 6%( ('6 22rdc|tj|}t|t|}t |||z| dS)aa Pads `text` on the left side if it is shorter than the given padding length. The `chars` string may be truncated if the number of padding characters can't be evenly divided by the padding length. Args: text: String to pad. length: Amount to pad. chars: Characters to pad with. Defaults to ``" "``. Returns: Padded string. Example: >>> pad_start("abc", 5) ' abc' >>> pad_start("abc", 5, ".") '..abc' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Renamed from ``pad_left`` to ``pad_start``. NrJrLs rbr%r%s=6 == D T #F 5& !D (6'( 33rdc|tj|}|r|j}tt |dS)a Like :func:`camel_case` except the first letter is capitalized. Args: text: String to convert. strict: Whether to cast rest of string to lower case. Defaults to ``True``. Returns: String converted to class case. Example: >>> pascal_case("FOO BAR_bAz") 'FooBarBaz' >>> pascal_case("FOO BAR_bAz", False) 'FooBarBAz' .. versionadded:: 3.0.0 .. versionchanged:: 5.0.0 Improved unicode word support. Fr)rrrr r rs rbr&r&s2. == D zz| j&u 55rdcZtj|}tt|dz S)aH Return the predecessor character of `char`. Args: char: Character to find the predecessor of. Returns: Predecessor character. Example: >>> predecessor("c") 'b' >>> predecessor("C") 'B' >>> predecessor("3") '2' .. versionadded:: 3.0.0 rrrchrordrs rbr'r'%* == D s4y1} rdc@tj|}t|}t|}||kr|Sd}t|d|dzd|}t j d|ddrt|dd}n|dd j }t|}||z|kr|d||z}|S) a Like :func:`truncate` except it ensures that the pruned string doesn't exceed the original length, i.e., it avoids half-chopped words when truncating. If the pruned text + `omission` text is longer than the original text, then the original text is returned. Args: text: String to prune. length: Target prune length. Defaults to ``0``. omission: Omission text to append to the end of the pruned string. Defaults to ``'...'``. Returns: Pruned string. Example: >>> prune("Fe fi fo fum", 5) 'Fe fi...' >>> prune("Fe fi fo fum", 6) 'Fe fi...' >>> prune("Fe fi fo fum", 7) 'Fe fi...' >>> prune("Fe fi fo fum", 8, ",,,") 'Fe fi fo,,,' .. versionadded:: 3.0.0 cn|jd}|j|jk(rdS|S)Nrr)rhrr)rrs rbrqzprune..replSs-{{1~jjldjjl2s<>> quote("To be or not to be") '"To be or not to be"' >>> quote("To be or not to be", "'") "'To be or not to be'" .. versionadded:: 2.4.0 )r?)ri quote_chars rbr)r)ls( D* %%rdc`tj|}t|j|S)a Return list of matches using Javascript style regular expression. Args: text: String to evaluate. reg_exp: Javascript style regular expression. Returns: List of matches. Example: >>> reg_exp_js_match("aaBBcc", "/bb/") [] >>> reg_exp_js_match("aaBBcc", "/bb/i") ['BB'] >>> reg_exp_js_match("aaBBccbb", "/bb/i") ['BB'] >>> reg_exp_js_match("aaBBccbb", "/bb/gi") ['BB', 'bb'] .. versionadded:: 2.0.0 .. versionchanged:: 3.0.0 Reordered arguments to make `text` first. .. versionchanged:: 4.0.0 Renamed from ``js_match`` to ``reg_exp_js_match``. )rrrQrl)rir`s rbr*r*s(< == D G  ! !$ ''rdctj|}tj|stj|}t|j ||S)a Replace `text` with `repl` using Javascript style regular expression to find matches. Args: text: String to evaluate. reg_exp: Javascript style regular expression. repl: Replacement string or callable. Returns: Modified string. Example: >>> reg_exp_js_replace("aaBBcc", "/bb/", "X") 'aaBBcc' >>> reg_exp_js_replace("aaBBcc", "/bb/i", "X") 'aaXcc' >>> reg_exp_js_replace("aaBBccbb", "/bb/i", "X") 'aaXccbb' >>> reg_exp_js_replace("aaBBccbb", "/bb/gi", "X") 'aaXccX' .. versionadded:: 2.0.0 .. versionchanged:: 3.0.0 Reordered arguments to make `text` first. .. versionchanged:: 4.0.0 Renamed from ``js_replace`` to ``reg_exp_js_replace``. )rr is_functionrQr.)rir`rqs rbr+r+sEB == D ??4 }}T" G  $ $T4 00rdcR|tj|St|||||dS)a Replace occurrences of regex `pattern` with `repl` in `text`. Optionally, ignore case when replacing. Optionally, set `count` to limit number of replacements. Args: text: String to replace. pattern: Pattern to find and replace. repl: String to substitute `pattern` with. ignore_case: Whether to ignore case when replacing. Defaults to ``False``. count: Maximum number of occurrences to replace. Defaults to ``0`` which replaces all. Returns: Replaced string. Example: >>> reg_exp_replace("aabbcc", "b", "X") 'aaXXcc' >>> reg_exp_replace("aabbcc", "B", "X", ignore_case=True) 'aaXXcc' >>> reg_exp_replace("aabbcc", "b", "X", count=1) 'aaXbcc' >>> reg_exp_replace("aabbcc", "[ab]", "X") 'XXXXcc' .. versionadded:: 3.0.0 .. versionchanged:: 4.0.0 Renamed from ``re_replace`` to ``reg_exp_replace``. F) ignore_caseror)rrr.)rir^rqrcros rbr,r,s/L}}T"" 4$KuUZ [[rdcDtj|t|zS)a Repeats the given string `n` times. Args: text: String to repeat. n: Number of times to repeat the string. Returns: Repeated string. Example: >>> repeat(".", 5) '.....' .. versionadded:: 1.1.0 )rrrA)rirs rbr-r-s$ == Q ''rdctj|}||Stj|stj|}|rtjnd}t |t jr|} nstj|}|rtj|}|r|jdsd|z}|r|jds|dz }tj||} | j|||S)a Replace occurrences of `pattern` with `repl` in `text`. Optionally, ignore case when replacing. Optionally, set `count` to limit number of replacements. Args: text: String to replace. pattern: Pattern to find and replace. repl: String to substitute `pattern` with. ignore_case: Whether to ignore case when replacing. Defaults to ``False``. count: Maximum number of occurrences to replace. Defaults to ``0`` which replaces all. escape: Whether to escape `pattern` when searching. This is needed if a literal replacement is desired when `pattern` may contain special regular expression characters. Defaults to ``True``. from_start: Whether to limit replacement to start of string. from_end: Whether to limit replacement to end of string. Returns: Replaced string. Example: >>> replace("aabbcc", "b", "X") 'aaXXcc' >>> replace("aabbcc", "B", "X", ignore_case=True) 'aaXXcc' >>> replace("aabbcc", "b", "X", count=1) 'aaXbcc' >>> replace("aabbcc", "[ab]", "X") 'aabbcc' >>> replace("aabbcc", "[ab]", "X", escape=False) 'XXXXcc' .. versionadded:: 3.0.0 .. versionchanged:: 4.1.0 Added ``from_start`` and ``from_end`` arguments. .. versionchanged:: 5.0.0 Added support for ``pattern`` as ``typing.Pattern`` object. r^$rVrn) rrrar[ IGNORECASE isinstancetypingPatternrrr r]rp) rir^rqrcror from_startfrom_endrWpats rbr.r. sf == D ??4 }}T"(BMMaE'6>>*--( ii(G g005GmG G,,S1 sNGjj. 774U7 ++rdc$t|||||dS)a Like :func:`replace` except it only replaces `text` with `repl` if `pattern` mathces the end of `text`. Args: text: String to replace. pattern: Pattern to find and replace. repl: String to substitute `pattern` with. ignore_case: Whether to ignore case when replacing. Defaults to ``False``. escape: Whether to escape `pattern` when searching. This is needed if a literal replacement is desired when `pattern` may contain special regular expression characters. Defaults to ``True``. Returns: Replaced string. Example: >>> replace_end("aabbcc", "b", "X") 'aabbcc' >>> replace_end("aabbcc", "c", "X") 'aabbcX' .. versionadded:: 4.1.0 T)rcrrmr.rir^rqrcrs rbr/r/]s@ 4$KY] ^^rdc$t|||||dS)a Like :func:`replace` except it only replaces `text` with `repl` if `pattern` mathces the start of `text`. Args: text: String to replace. pattern: Pattern to find and replace. repl: String to substitute `pattern` with. ignore_case: Whether to ignore case when replacing. Defaults to ``False``. escape: Whether to escape `pattern` when searching. This is needed if a literal replacement is desired when `pattern` may contain special regular expression characters. Defaults to ``True``. Returns: Replaced string. Example: >>> replace_start("aabbcc", "b", "X") 'aabbcc' >>> replace_start("aabbcc", "a", "X") 'Xabbcc' .. versionadded:: 4.1.0 T)rcrrlrprqs rbr0r0s@ 4$K[_ ``rdcD|jdt|DS)as Splits `text` on words and joins with `separator`. Args: text: String to convert. separator: Separator to join words with. Returns: Converted string. Example: >>> separator_case("a!!b___c.d", "-") 'a-b-c-d' .. versionadded:: 3.0.0 .. versionchanged:: 5.0.0 Improved unicode word support. c3BK|]}|s|jywrr)rs rbrz!separator_case..sG4$$**,Gr+)rrM)rir%s rbr1r1s* >>G5;G GGrdctj|jtjj j }t |}tj|}tj|}|dkDr|r|j|z}|dk\r|dd|j|ddgz}|j|S)a= Join items into a grammatical series phrase, e.g., ``"item1, item2, item3 and item4"``. Args: items: List of string items to join. separator: Item separator. Defaults to ``', '``. last_separator: Last item separator. Defaults to ``' and '``. serial: Whether to include `separator` with `last_separator` when number of items is greater than 2. Defaults to ``False``. Returns: Joined string. Example: >>> series_phrase(["apples", "bananas", "peaches"]) 'apples, bananas and peaches' >>> series_phrase(["apples", "bananas", "peaches"], serial=True) 'apples, bananas, and peaches' >>> series_phrase(["apples", "bananas", "peaches"], "; ", ", or ") 'apples; bananas, or peaches' .. versionadded:: 3.0.0 NrX) rrmaprrrrrYr)itemsr%last_separatorserial item_counts rbr2r2s> IIe   / 7 7 9 ? ? AEUJ i(I]]>2NA~&"))+n<Qcr n11%*=>> >>%  rdc t|||dS)a Join items into a grammatical series phrase using a serial separator, e.g., ``"item1, item2, item3, and item4"``. Args: items: List of string items to join. separator: Item separator. Defaults to ``', '``. last_separator: Last item separator. Defaults to ``' and '``. Returns: Joined string. Example: >>> series_phrase_serial(["apples", "bananas", "peaches"]) 'apples, bananas, and peaches' .. versionadded:: 3.0.0 T)rz)r2)rxr%rys rbr3r3s,  >$ GGrdctjdtj|j ddj dj dd}t||S)u Convert `text` into an ASCII slug which can be used safely in URLs. Incoming `text` is converted to unicode and noramlzied using the ``NFKD`` form. This results in some accented characters being converted to their ASCII "equivalent" (e.g. ``é`` is converted to ``e``). Leading and trailing whitespace is trimmed and any remaining whitespace or other special characters without an ASCII equivalent are replaced with ``-``. Args: text: String to slugify. separator: Separator to use. Defaults to ``'-'``. Returns: Slugified string. Example: >>> slugify("This is a slug.") == "this-is-a-slug" True >>> slugify("This is a slug.", "+") == "this+is+a+slug" True .. versionadded:: 3.0.0 .. versionchanged:: 5.0.0 Improved unicode word support. .. versionchanged:: 7.0.0 Remove single quotes from output. NFKDasciiignoreutf8rr) unicodedata normalizerrencodedecoder.r1)rir% normalizeds rbr4r4sR> fcmmD&9:  "  b   *i 00rdcDdjdt|DS)a Converts `text` to snake case. Args: text: String to convert. Returns: String converted to snake case. Example: >>> snake_case("This is Snake Case!") 'this_is_snake_case' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Removed alias ``underscore_case``. .. versionchanged:: 5.0.0 Improved unicode word support. rc3BK|]}|s|jywrr)rs rbrzsnake_case..Ar*r+r,rs rbr5r5*s. 88FZ-=F FFrdctj|}|tur|j}|S|r|j|}|St |}|S)a] Splits `text` on `separator`. If `separator` not provided, then `text` is split on whitespace. If `separator` is falsey, then `text` is split on every character. Args: text: String to explode. separator: Separator string to split on. Defaults to ``NoValue``. Returns: Split string. Example: >>> split("one potato, two potatoes, three potatoes, four!") ['one', 'potato,', 'two', 'potatoes,', 'three', 'potatoes,', 'four!'] >>> split("one potato, two potatoes, three potatoes, four!", ",") ['one potato', ' two potatoes', ' three potatoes', ' four!'] .. versionadded:: 2.0.0 .. versionchanged:: 3.0.0 Changed `separator` default to ``NoValue`` and supported splitting on whitespace by default. .. versionchanged:: 4.0.0 Removed alias ``explode``. )rrr r6r)rir%rets rbr6r6DsV6 == DEjjl J jj# JDk JrdcDdjdt|DS)a. Convert `text` to start case. Args: text: String to convert. Returns: String converted to start case. Example: >>> start_case("fooBar") 'Foo Bar' .. versionadded:: 3.1.0 .. versionchanged:: 5.0.0 Improved unicode word support. rc36K|]}t|dyw)FrONr rs rbrzstart_case..sPtJtE22Psr,rs rbr7r7ks( 88Pz$?OP PPrdc~tj|}tj|}||dj|S)a Checks if `text` starts with a given target string. Args: text: String to check. target: String to check for. position: Position to search from. Defaults to beginning of `text`. Returns: Whether `text` starts with `target`. Example: >>> starts_with("abcdef", "a") True >>> starts_with("abcdef", "b") False >>> starts_with("abcdef", "a", 1) False .. versionadded:: 1.1.0 Nrr s rbr8r8s7. == D ]]6 "F  ? % %f --rdcTtjdtj|S)z Removes all HTML tags from `text`. Args: text: String to strip. Returns: String without HTML tags. Example: >>> strip_tags('Some link') 'Some link' .. versionadded:: 3.0.0 r) RE_HTML_TAGSrprrrs rbr9r9s "   B d 3 44rdc\tj|}|r|j|dS|S)a Searches `text` from left-to-right for `subtext` and returns a substring consisting of the characters in `text` that are to the left of `subtext` or all string if no match found. Args: text: String to partition. subtext: String to search for. Returns: Substring to left of `subtext`. Example: >>> substr_left("abcdefcdg", "cd") 'ab' .. versionadded:: 3.0.0 rrr partitionrs rbr:r:s-& == D)04>>' "1 %:d:rdcdtj|}|r|j|dxs|S|S)a Searches `text` from right-to-left for `subtext` and returns a substring consisting of the characters in `text` that are to the left of `subtext` or all string if no match found. Args: text: String to partition. subtext: String to search for. Returns: Substring to left of `subtext`. Example: >>> substr_left_end("abcdefcdg", "cd") 'abcdef' .. versionadded:: 3.0.0 rrr rpartitionrs rbr;r;s2& == D294??7 #A & .$CtCrdcdtj|}|r|j|dxs|S|S)a Searches `text` from right-to-left for `subtext` and returns a substring consisting of the characters in `text` that are to the right of `subtext` or all string if no match found. Args: text: String to partition. subtext: String to search for. Returns: Substring to right of `subtext`. Example: >>> substr_right("abcdefcdg", "cd") 'efcdg' .. versionadded:: 3.0.0 rvrrs rbr<r<s2& == D184>>' "1 % -BdBrdc\tj|}|r|j|dS|S)a Searches `text` from left-to-right for `subtext` and returns a substring consisting of the characters in `text` that are to the right of `subtext` or all string if no match found. Args: text: String to partition. subtext: String to search for. Returns: Substring to right of `subtext`. Example: >>> substr_right_end("abcdefcdg", "cd") 'g' .. versionadded:: 3.0.0 rvrrs rbr=r=s-& == D*14??7 #A &;t;rdcZtj|}tt|dzS)a< Return the successor character of `char`. Args: char: Character to find the successor of. Returns: Successor character. Example: >>> successor("b") 'c' >>> successor("B") 'C' >>> successor("2") '3' .. versionadded:: 3.0.0 rrQrTs rbr>r>rUrdcftj|}tj|}|||S)a` Surround a string with another string. Args: text: String to surround with `wrapper`. wrapper: String by which `text` is to be surrounded. Returns: Surrounded string. Example: >>> surround("abc", '"') '"abc"' >>> surround("abc", "!") '!abc!' .. versionadded:: 2.4.0 r )riwrappers rbr?r?'s3( == DmmG$GYtfWI &&rdcLtj|}|jS)z Swap case of `text` characters. Args: text: String to swap case. Returns: String with swapped case. Example: >>> swap_case("aBcDeF") 'AbCdEf' .. versionadded:: 3.0.0 )rrswapcasers rbr@r@@s" == D ==?rdctj|}djdtjd|DS)z Convert `text` to title case. Args: text: String to convert. Returns: String converted to title case. Example: >>> title_case("bob's shop") "Bob's Shop" .. versionadded:: 3.0.0 rc3<K|]}|jywrrrs rbrztitle_case..hsF$DOO%Fr)rrrr[r6rs rbrArAUs2" == D 88F"((32EF FFrdcHtj|jS)aj Converts the given :attr:`text` to lower text. Args: text: String to convert. Returns: String converted to lower case. Example: >>> to_lower("--Foo-Bar--") '--foo-bar--' >>> to_lower("fooBar") 'foobar' >>> to_lower("__FOO_BAR__") '__foo_bar__' .. versionadded:: 4.0.0 r rs rbrBrBk* ==  $ $ &&rdcHtj|jS)aj Converts the given :attr:`text` to upper text. Args: text: String to convert. Returns: String converted to upper case. Example: >>> to_upper("--Foo-Bar--") '--FOO-BAR--' >>> to_upper("fooBar") 'FOOBAR' >>> to_upper("__FOO_BAR__") '__FOO_BAR__' .. versionadded:: 4.0.0 )rrrrs rbrCrCrrdcNtj|}|j|S)a4 Removes leading and trailing whitespace or specified characters from `text`. Args: text: String to trim. chars: Specific characters to remove. Returns: Trimmed string. Example: >>> trim(" abc efg\r\n ") 'abc efg' .. versionadded:: 1.1.0 )rrstriprirs rbrDrDs!& == D ::e rdcNtj|}|j|S)a Removes trailing whitespace or specified characters from `text`. Args: text: String to trim. chars: Specific characters to remove. Returns: Trimmed string. Example: >>> trim_end(" abc efg\r\n ") ' abc efg' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Renamed from ``trim_right`` to ``trim_end``. )rrrYrs rbrErE!* == D ;;u rdcNtj|}|j|S)a Removes leading whitespace or specified characters from `text`. Args: text: String to trim. chars: Specific characters to remove. Returns: Trimmed string. Example: >>> trim_start(" abc efg\r\n ") 'abc efg\r\n ' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Renamed from ``trim_left`` to ``trim_start``. )rrlstriprs rbrFrFrrdcltj|}t||kr|St|}||z }|d|}t|}tj|r|j |}nAtj |r,d}|j |D]}|}||j}|d||zS)a# Truncates `text` if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the omission string which defaults to ``...``. Args: text: String to truncate. length: Maximum string length. Defaults to ``30``. omission: String to indicate text is omitted. separator: Separator pattern to truncate to. Returns: Truncated string. Example: >>> truncate("hello world", 5) 'he...' >>> truncate("hello world", 5, "..") 'hel..' >>> truncate("hello world", 10) 'hello w...' >>> truncate("hello world", 10, separator=" ") 'hello...' .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Removed alias ``trunc``. N)rrr is_stringrfind is_reg_expfinditerstart) rirErZr%r[r trunc_lenlastrs rbrGrGsF == D 4yF x=L $H  ?DD I }}YJJy)  "''- ED    I   h &&rdcVtj|}tj|S)a The inverse of :func:`escape`. This method converts the HTML entities ``&``, ``<``, ``>``, ``"``, ``'``, and ````` in `text` to their corresponding characters. Args: text: String to unescape. Returns: HTML unescaped string. Example: >>> results = unescape(""1 > 2 && 3 < 4"") >>> results == '"1 > 2 && 3 < 4"' True .. versionadded:: 1.0.0 .. versionchanged:: 1.1.0 Moved to :mod:`pydash.strings`. )rrhtmlrHrs rbrHrHs!, == D == rdcRdjt|jS)a Converts string to upper case, as space separated words. Args: text: String to be converted to uppercase. Returns: String converted to uppercase, as space separated words. Example: >>> upper_case("--foo-bar--") 'FOO BAR' >>> upper_case("fooBar") 'FOO BAR' >>> upper_case('/?*Foo10/;"B*Ar') 'FOO 10 B AR' .. versionadded:: 4.0.0 .. versionchanged:: 5.0.0 Improved unicode word support. r)rrrrs rbrJrJ9r0rdc4|ddj|ddzS)a Converts the first character of string to upper case. Args: text: String passed in by the user. Returns: String in which the first character is converted to upper case. Example: >>> upper_first("fred") 'Fred' >>> upper_first("foo bar") 'Foo bar' >>> upper_first("1foobar") '1foobar' >>> upper_first(";foobar") ';foobar' .. versionadded:: 4.0.0 Nr)rrs rbrKrKTr2rdcTtj|}|dd}||||k(r|}|S)a Unquote `text` by removing `quote_char` if `text` begins and ends with it. Args: text: String to unquote. quote_char: Quote character to remove. Defaults to `"`. Returns: Unquoted string. Example: >>> unquote('"abc"') 'abc' >>> unquote('"abc"', "#") '"abc"' >>> unquote("#abc", "#") '#abc' >>> unquote("#abc#", "#") 'abc' .. versionadded:: 3.0.0 rrr )rir^inners rbrIrIns<0 == D 2JE *eWZL11 Krdc tj|jjtjj }g}t |}|D]B}t|\}}}}}t|}||z }|jt|||d|fDtdg|}t|\}}}}}t|}t|||||fS)a Combines a series of URL paths into a single URL. Optionally, pass in keyword arguments to append query parameters. Args: paths: URL paths to combine. Keyword Args: params: Query parameters. Returns: URL string. Example: >>> link = url("a", "b", ["c", "d"], "/", q="X", y="Z") >>> path, params = link.split("?") >>> path == "a/b/c/d/" True >>> set(params.split("&")) == set(["q=X", "y=Z"]) True .. versionadded:: 2.2.0 rrS) rr flatten_deeprwrrflatten_url_paramsrrappendrdelimitedpathjoinr) pathsparams paths_list params_listpathschemenetlocqueryfragments rbrLrLs4 IIe  ) ) + / / > D D FEJ$V,KL08-eX% u *ffdB%IJK L S .: .D,4TN)FFD% k "E vvtUH= >>rdctj|}|t|rt}nt}n t |}|j |S)a Return list of words contained in `text`. References: https://github.com/lodash/lodash/blob/master/words.js#L30 Args: text: String to split. pattern: Custom pattern to split words on. Defaults to ``None``. Returns: List of words. Example: >>> words("a b, c; d-e") ['a', 'b', 'c', 'd', 'e'] >>> words("fred, barney, & pebbles", "/[^, ]+/g") ['fred', 'barney', '&', 'pebbles'] .. versionadded:: 2.0.0 .. versionchanged:: 3.2.0 Added `pattern` argument. .. versionchanged:: 3.2.0 Improved matching for one character words. .. versionchanged:: 5.0.0 Improved unicode word support. )rrhas_unicode_wordJS_RE_UNICODE_WORDSJS_RE_ASCII_WORDSrQrl)rir^r`s rbrMrMsC@ == D D !)G'G7# << rdc xtttjdt j |S)a Remove single quote before passing into words() to match Lodash-style outputs. Required by certain functions such as kebab_case, camel_case, start_case etc. References: https://github.com/lodash/lodash/blob/4.17.15/lodash.js#L4968 r)rMrRE_APOSrprrrs rbrrs(  B d(;<= >>rdcBtj|}t|S)z Check if the text contains unicode or requires more complex regex to handle. References: https://github.com/lodash/lodash/blob/master/words.js#L3 )RE_HAS_UNICODE_WORDrgbool)riresults rbrrs! ' ' -F <rdctj|Dcgc]}|stj|}}t|dk(r|d}|S|r|dj |r|nd}|r|dj |r|nd}|j |Dcgc]%}|j|s|j|'c}}dj |||g}|Scc}wcc}w)a Join delimited path using specified delimiter. >>> assert delimitedpathjoin(".", "") == "" >>> assert delimitedpathjoin(".", ".") == "." >>> assert delimitedpathjoin(".", ["", ".a"]) == ".a" >>> assert delimitedpathjoin(".", ["a", "."]) == "a." >>> assert delimitedpathjoin(".", ["", ".a", "", "", "b"]) == ".a.b" >>> ret = ".a.b.c.d.e." >>> assert delimitedpathjoin(".", [".a.", "b.", ".c", "d", "e."]) == ret >>> assert delimitedpathjoin(".", ["a", "b", "c"]) == "a.b.c" >>> ret = "a.b.c.d.e.f" >>> assert delimitedpathjoin(".", ["a.b", ".c.d.", ".e.f"]) == ret >>> ret = ".a.b.c.1." >>> assert delimitedpathjoin(".", ".", "a", "b", "c", 1, ".") == ret >>> assert delimitedpathjoin(".", []) == "" rrrr)rrrrrr rr) delimiterrrleadingtrailingmiddles rbrr s$.1-=-=e-D MTS]]4 ME M 5zQQx K %q)<)>> params = [("a", 1), ("a", [2, 3])] >>> assert flatten_url_params(params) == [("a", 1), ("a", 2), ("a", 3)] >>> params = {"a": [1, 2, 3]} >>> assert flatten_url_params(params) == [("a", 1), ("a", 2), ("a", 3)] )ridictrrxtupleziprr)r flattenedparamrs rbrr" sz&$flln%!I- u edE] + eWs5z159 9I   eU^ , - rd)rit.Anyrsrr)T)rirrrrsrr)rirrsru)rirrrArsru)rirrrrsrAr)rirr rrzt.Union[int, None]rsr)rirrrrsrr)rirrrrsrr)rirrrrsr)rirr!rArrrsrr)r)r$zt.Iterable[t.Any]r%rrsrr)rirrrsrr)rr4,) r8r r9rAr:rrr;rrrsrr)r)rirrErArrrsrr)rrrsrr)r...)rirrErArZrrrsrr)r)rirr^rrsrr)rirr`rrrsru)rirr`rrrqrvrsrr)Fr) rirr^rrqrvrcrrorArsrr)r)rirrz t.SupportsIntrsrr)FrTFF)rirr^rrqrvrcrrorArrrlrrmrrsrr)FT) rirr^rrqrvrcrrrrsrr)rirr%rrrsrr),  and F) rx t.List[t.Any]r%rryrrzrrsrr)rr)rxrr%rryrrsrr)r')rirr%zt.Union[str, Unset, None]rsru)rirr rrrArsr)rirrrrrsrr)rirrrrsrr)rirrt.Union[str, None]rsrr)rN) rirrErArZrrr%z#t.Union[str, re.Pattern[str], None]rsrr)rrrrrsrr)rirr^rrsru)rz`t.Union[t.Dict[T, t.Union[T2, t.Iterable[T2]]], t.List[t.Tuple[T, t.Union[T2, t.Iterable[T2]]]]]rszt.List[t.Tuple[T, T2]])rz __future__rrrBr[rjtr urllib.parserrrrpydashrhelpersr r typesr __all__TypeVarrNrOrQrrRS_ASCII_WORDS RS_LATIN1RS_ASTRAL_RANGERS_COMBO_MARKS_RANGERE_COMBO_HALF_MARKS_RANGERS_COMBO_SYMBOLS_RANGERS_COMBO_MARKS_EXTENDED_RANGERS_COMBO_MARKS_SUPPLEMENT_RANGERS_COMBO_RANGERS_DINGBAT_RANGERS_LOWER_RANGERS_MATH_OP_RANGERS_NON_CHAR_RANGERS_PUNCTUATION_RANGERS_SPACE_RANGERS_UPPER_RANGE RS_VAR_RANGERS_BREAK_RANGERS_APOSRS_BREAKRS_COMBORS_DIGIT RS_DINGBATRS_LOWERRS_MISCRS_FITZ RS_MODIFIER RS_NON_ASTRAL RS_REGIONAL RS_SURR_PAIRRS_UPPERRS_ZWJ RS_MISC_LOWER RS_MISC_UPPERRS_OPT_CONTR_LOWERRS_OPT_CONTR_UPPER RE_OPT_MOD RS_OPT_VAR RS_OPT_JOIN RS_ORD_LOWER RS_ORD_UPPERRS_SEQRS_EMOJIRS_HAS_UNICODE_WORDrRS_UNICODE_WORDSrrrr]rrrr r rrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrJrKrIrLrMrrrrr{rdrbrsX  # CC!C JAIIcNQYYt_99D6XGZab A CA CA CA C A  C A  C A CA CA CA CA CA CA CA CA CA  C!A" C#A$ C%A& C'A( C)A* C+A, C-A. C/A0 C1A2 C3A4 C5A6 C7A8 C9A: C;A< C=A> C?A@ CAAB CCAD CEAF CGAH CIAJ CKAL CMAN COAP CQAR CSAT CUAV CWAX CYAZ C[A\ C]A^ C_A` CaAb CcAd CeAf CgAh             AAN?  $(-* 1"3 $$& &%,)B(6 - !$558LL~]  ~a  ~a  !"! $ ~a .)(((8; %H:Qwiq) _%Q' / 3 ~a  hZq + hZq + 7)#9:7)#9:}A  b !  &]O1[M<.*j\Y[\ B A j ; .  Ak]!L>6( CZ   a  j        /0  03  4<:  =>  ?Gj  I      *+  +.  /7j  89  :B  DQ?  S   z    !/  "#  $6"6     z    &&    ~    ~     z     z     ^,/0 "  bjj!45 "**W rzz-( '0H6%(>@/*62'*,<8:B60#2B10O8G.*.6'6[^) ))8;)TW))X(+V3@4@6>2:z&.(D$1 $1$1%S$1$1V )\ )\ )\ 9)\ )\  )\  )\X(2M, M, M, 9M, M,  M,  M,M,M, M,h _  _  _ 9 _ _  _  _N a  a  a 9 a a  a  aFH4# +! +!+!+!  +!  +!^LSH H%*HCHHH2%1PG4?D$NQ..85(;.D.C.<.2'2*G,'0'0.2659 8' 8' 8'8'3 8'  8'v4.6'4B(?V(` ?B   rd