o d@sUdZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z ej r:dd l mZed Zeed Zd Zd deDZddedDZGdddejZGdddeZGdddeZGdddeZeeiZejej e!eje"e!ffe#d< dqdej$e%e"fdej$e%e"fde"fdd Z&d!ej$ej'e%e%fej(ej)e%e%ffd"e%d#e*d$ej+ej,ej)e%e%fgej-fdej.e%f d%d&Z/dqd'e%de%de%fd(d)Z0 *drd+e%d,ej+e%d-e*defd.d/Z1 0 1 2 dsd"e%d3e%d4ej$e%e"fdej$e%e"fdej,e"ge%ff d5d6Z2e2Z3e2d7d8d9Z4de"de%fd:d;Z5 0 1 2 dsdej$e%e"fd"e%d3e%d4ej$e%e"fdej$e%e"fde%f dd?Z7d@ej)e%e%e%e%e%fde%fdAdBZ8 0 C dudDej$e%e"fd"e%d3e%de%de%f dEdFZ9 CdvdDej$e%e"fd"e%d3e%de%fdGdHZ:dwdDe%d"e%de%fdIdJZ;ddej)e%e!ffdNdOZ?e@dPe? 0 PdxdQej$e%ej)e%e%e%e%e%ffd"e%d3e%de%fdRdSZAdTZB 0 1 UdydVej$e%ej)e%e%e%e%e%ffd"e%d3e%dWe*de%f dXdYZC 0 * C Z dzdDejDd"e%d[e*d3e%d\e%d]ej+ejEd^dd_fd`daZF 0 * C b  d{dcejGe"d"e%d[e*d3e%d\e"d]ej+ejEd^ddej+e!dd_fdedfZHdgej(ejDd"e%d[e*d3e%dej.ej)e%e%ff dhdiZI 0 U  Zd|d!ej$ej'e%e%fej(ej)e%e%ffd"e%d#e*d$ej+ej,ej)e%e%fgej-fd\e%de%f djdkZJ  0 U  Zd}d!ej$ej'e%e%fej(ej)e%e%ffdcej+ejGe%d"e%d#e*d$ej+ej,ej)e%e%fgej-fd\e%ddfdldmZK *d~dnej$e%ej)e%e%e%e%e%ffd+ej$e%ej)e%e%e%e%e%ffd-e*de%fdodpZLdS)zFunctions for working with URLs. Contains implementations of functions from :mod:`urllib.parse` that handle bytes and strings. N)_check_str_tuple) _decode_idna) _encode_idna)_make_encode_wrapper)_to_str)datastructuresz^[a-zA-Z0-9+-.]+$sKabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~$!'()*+,;0123456789ABCDEFabcdefcCs8i|]}tD]}||dt||dqqS)ascii) _hexdigitsencodeint).0abrR/var/www/html/visualizacion-main/env/lib/python3.10/site-packages/werkzeug/urls.py #s rcCsg|] }d|ddqS)%02Xr )r )rcharrrr (src@s6eZdZUeed<eed<eed<eed<eed<dS) _URLTupleschemenetlocpathqueryfragmentN)__name__ __module__ __qualname__str__annotations__rrrrr+s  rc@s"eZdZUdZdZeed<eed<eed<eed<defdd Zd ej ddfd d Z e dej efd dZ e dej efddZe dej efddZe dej efddZe dej efddZe dej efddZe dej efddZe dej efddZdej d ej ddfdd Zdej d ej ddfd!d"Zdefd#d$Zdefd%d&Zdefd'd(Zd7d)d*Zd7d+d,Z -d8d.ej edejej eej effd/d0Zdejej eeffd1d2Zdejej eej effd3d4Z dejej eej effd5d6Z!d-S)9BaseURLz7Superclass of :py:class:`URL` and :py:class:`BytesURL`.r_at_colon _lbracket _rbracketreturncCs|SN)to_urlselfrrr__str__<szBaseURL.__str__kwargscKs|jdi|S)zReturn an URL with the same values, except for those parameters given new values by whichever keyword arguments are specified.Nr)_replace)r.r0rrrreplace?szBaseURL.replacecC |dS)zThe host part of the URL if available, otherwise `None`. The host is either the hostname or the IP address mentioned in the URL. It will not contain the port. r) _split_hostr-rrrhostDs z BaseURL.hostcCsP|j}|dur"t|tr"zt|}Wnty!|dd}Ynwt|ddS)a Works exactly like :attr:`host` but will return a result that is restricted to ASCII. If it finds a netloc that is not ASCII it will attempt to idna decode it. This is useful for socket operations when the URL might include internationalized characters. Nr ignore)r5 isinstancer#r UnicodeErrorr rr.rvrrr ascii_hostLs   zBaseURL.ascii_hostc CsTztt|d}d|krdkr|WSWdSWdSttfy)YdSw)z}The port in the URL as an integer if it was present, `None` otherwise. This does not fill in default ports. rriN)rrr4 ValueError TypeErrorr9rrrport[sz BaseURL.portcCr3)zSThe authentication part in the URL if available, `None` otherwise. r) _split_netlocr-rrrauthh z BaseURL.authcC |d}|durt|SdS)zThe username if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a string. rN _split_auth_url_unquote_legacyr9rrrusernameo zBaseURL.usernamecCr3)zThe username if it was part of the URL, `None` otherwise. Unlike :attr:`username` this one is not being decoded. rrDr-rrr raw_usernameyrAzBaseURL.raw_usernamecCrB)zThe password if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a string. rNrCr9rrrpasswordrGzBaseURL.passwordcCr3)zThe password if it was part of the URL, `None` otherwise. Unlike :attr:`password` this one is not being decoded. rrHr-rrr raw_passwordrAzBaseURL.raw_passwordargsds.MultiDict[str, str]cOst|jg|Ri|S)zDecodes the query part of the URL. Ths is a shortcut for calling :func:`url_decode` on the query argument. The arguments and keyword arguments are forwarded to :func:`url_decode` unchanged. ) url_decoderr.rLr0rrr decode_queryszBaseURL.decode_querycOstt|g|Ri|S)zJoins this URL with another one. This is just a convenience function for calling into :meth:`url_join` and then parsing the return value again. ) url_parseurl_joinrOrrrjoinsz BaseURL.joincCst|S)zReturns a URL string or bytes depending on the type of the information stored. This is just a convenience function for calling :meth:`url_unparse` for this URL. ) url_unparser-rrrr,szBaseURL.to_urlc Cs|jpd}d|vrd|d}|j}|dur|d|}dtdt|jp&ddddt|jp/ddddg}|r@|d |}|S) z6Encodes the netloc part to an ASCII safe URL as bytes.:[]Nutf-8strictz/:%@)r;r>rSfilter url_quoterIrKr.r:r>r@rrr encode_netlocs"   zBaseURL.encode_netloccCst|jpd}d|vrd|d}|j}|dur|d|}dtdt|jp(ddt|jp/ddg}|r>|d|}|S)z&Decodes the netloc part into a string.rUrVrWrXNz/:%@r[)rr5r>rSr\rErIrKr^rrr decode_netlocs"  zBaseURL.decode_netloccC tt|S)a*Returns a :class:`BytesURL` tuple that holds a URI. This will encode all the information in the URL properly to ASCII using the rules a web browser would follow. It's usually more interesting to directly call :meth:`iri_to_uri` which will return a string. )rQ iri_to_urir-rrr to_uri_tuples zBaseURL.to_uri_tuplecCra)aSReturns a :class:`URL` tuple that holds a IRI. This will try to decode as much information as possible in the URL without losing information similar to how a web browser does it for the URL bar. It's usually more interesting to directly call :meth:`uri_to_iri` which will return a string. )rQ uri_to_irir-rrr to_iri_tuples zBaseURL.to_iri_tupleN pathformatcCs6|jdkrdSt|j}|jpd}|durtjdkrd}nd}|dkr||dddkrJ|dd rJ|d d d vrJ|dd d |d d}|dd d v}ddl}||}|r{|dur{| d dd}t |d kru|\}}n|d}d}n|dkrddl }||}nt d||dvrd}||fS)a@Returns a tuple with the location of the file in the form ``(server, location)``. If the netloc is empty in the URL or points to localhost, it's represented as ``None``. The `pathformat` by default is autodetection but needs to be set when working with URLs of a specific system. The supported values are ``'windows'`` when working with Windows or DOS paths and ``'posix'`` when working with posix paths. If the URL does not point to a local file, the server and location are both represented as ``None``. :param pathformat: The expected format of the path component. Currently ``'windows'`` and ``'posix'`` are supported. Defaults to ``None`` which is autodetect. fileNNNntwindowsposixr/z|:rV)z\\\z///r\rUzInvalid path format )z 127.0.0.1z::1 localhost)r url_unquoterrosnameisalphantpathnormpathlstripsplitlen posixpathr=)r.rfrr5 windows_sharerupartsrzrrrget_file_locations8    0     zBaseURL.get_file_locationcCs2|j|jvr|j|j\}}}||fSd|jfSr+)r&r partition)r.r@_rrrrr?$s  zBaseURL._split_netloccCs@|d}|s dS|j|vr|dfS||j\}}}||fS)Nrrh)r?r'r~)r.r@rFrrJrrrrD*s  zBaseURL._split_authcCs|d}|s dS||js&|j|vr"||j\}}}||fS|dfS||j}|dkr4|dfS|d|}||dd}||jrP||ddfS|dfS)Nrrhr)r? startswithr(r'r~findr))r.r:r5rr>idxrestrrrr44s      zBaseURL._split_host)r*r%r+)"r r!r"__doc__ __slots__r#r$r/tAnyr2propertyOptionalr5r;rr>r@rFrIrJrKrPrSr,r_r`rcreTupler}r?rDr4rrrrr%3sR        >$( r%c@s<eZdZdZdZdZdZdZdZdd e d e d d fd dZ dS)URLzRepresents a parsed URL. This behaves like a regular tuple but also has some extra attributes that give further insight into the URL. rr[rVrWrXrYr2charseterrorsr*BytesURLc C:t|jd||j|||j|||j||S)zEncodes the URL to a tuple made out of bytes. The charset is only being used for the path, query and fragment. r )rrr r_rrrr.rrrrrr V    z URL.encodeNrYr2) r r!r"rrr&r'r(r)r#r rrrrrJsrc@sXeZdZdZdZdZdZdZdZde fdd Z de fd d Z dde de ddfddZ dS)rz!Represents a parsed URL in bytes.r@:[]r*cCs|ddS)NrYr2)r,decoder-rrrr/lzBytesURL.__str__cCs|jS)z&Returns the netloc unchanged as bytes.)rr-rrrr_oszBytesURL.encode_netlocrYr2rrrc Cr)zDecodes the URL to a tuple made out of strings. The charset is only being used for the path, query and fragment. r )rrrr`rrrrrrrrsrzBytesURL.decodeNr)r r!r"rrr&r'r(r)r#r/bytesr_rrrrrrcsr _unquote_mapsrUstringunsafer*cst|tr |d}ttrdttt|d}tt|d}zt}Wnt yFfddt D}t<Ynw|D]'}|dd}||vrf| ||| |ddqI| d| |qIt|S)NrY%csi|] \}}|vr||qSrr)rhrrrrrs  z%_unquote_to_bytes..rm%)r7r#r frozenset bytearrayiterrxnextrKeyError _hextobyteitemsappendextendr)rrgroupsresult hex_to_bytegroupcoderrr_unquote_to_bytess,           robjrsortkeyc csddlm}||}|rt||d}|D]3\}}|durqt|ts+t||}n|}t|ts:t||} n|} t|dt| VqdS)Nr)iter_multi_items)r=)rrsortedr7rr#r _fast_url_quote_plus) rrrrriterablekey_str value_str key_bytes value_bytesrrr_url_encode_impls      rvaluecCs4z t|dd|dWStyt|d|dYSw)NrYrZ)rrrlatin1)rr)rqr8)rrrrrrEs  rETurlrallow_fragmentsc st|t|t}|durd}d}}}|d}|dkrQtt|d|ddrQ||dd}|rFtfdd |DrQ|d||}}|dd d krt |} d D]} || d } | dkrtt | | } qc|d | || d}}d |vrd|vsd|vrd |vrt d|rd|vr| dd\}}d|vr| dd\}}|rt nt} | |||||S)aParses a URL from a string into a :class:`URL` tuple. If the URL is lacking a scheme it can be provided as second argument. Otherwise, it is ignored. Optionally fragments can be stripped from the URL by setting `allow_fragments` to `False`. The inverse of this function is :func:`url_unparse`. :param url: the URL to parse. :param scheme: the default schema to use if the URL is schemaless. :param allow_fragments: if set to `False` a fragment will be removed from the URL. NrUrVrr2)rrc3s|] }|dvVqdS) 0123456789Nrrcsrr szurl_parse..rm//z/?#rWrXzInvalid IPv6 URL#?)rr7r#r _scheme_rematchranylowerryminr<rxrr) rrr is_text_basedrrrirdelimrwdelim result_typerrrrQs< "       rQrYrZ/:rsafecsxttr ||t|tr|||}tttBtt|fddtdDdtdtffdd }|S)aPrecompile the translation table for a URL encoding function. Unlike :func:`url_quote`, the generated function only takes the string to quote. :param charset: The charset to encode the result with. :param errors: How to handle encoding errors. :param safe: An optional sequence of safe characters to never encode. :param unsafe: An optional sequence of unsafe characters to always encode. cs(g|]}|vr t|nd|dqS)rr)chrrrrrrs(z(_make_fast_url_quote..rrr*csdfdd|DS)NrUcsg|]}|qSrrrtablerrrsz7_make_fast_url_quote..quote..)rSrrrrquotesz#_make_fast_url_quote..quote)r7r#r rr _always_saferanger)rrrrrr)rrr_make_fast_url_quotes    r +)rrcCst|ddS)Nrr)_fast_quote_plusr2rrrrrrrcCst|tttfs t|}t|tr|||}t|tr"|||}t|tr-|||}tt|tBtt|}t}t|D]}||vrN||qB|t |qBt| |S)aDURL encode a single string with a given encoding. :param s: the string to quote. :param charset: the charset to be used. :param safe: an optional sequence of safe characters. :param unsafe: an optional sequence of unsafe characters. .. versionadded:: 0.9.2 The `unsafe` parameter was added. ) r7r#rrr rrrr _bytetohexr)rrrrrr:rrrrr]#s        r]cCst||||ddddS)zURL encode a single string with the given encoding and convert whitespace to "+". :param s: The string to quote. :param charset: The charset to be used. :param safe: An optional sequence of safe characters. rr)r]r2)rrrrrrrurl_quote_plusFs r componentscCst||\}}}}}t|}|d}|s|r=||dr=|r0|dd|dkr0|d|}|d|p8|d|}n|rC||7}|rM||d|}|rW||d|}|ra||d|}|S) zThe reverse operation to :meth:`url_parse`. This accepts arbitrary as well as :class:`URL` tuples and returns a URL as a string. :param components: the parsed URL as tuple which should be converted into a URL string. rUrlNrrrVrr)rrr)rrrrrrrrrrrrTSs" rTr2rcCs"t||}|dur |S|||S)afURL decode a single string with a given encoding. If the charset is set to `None` no decoding is performed and raw bytes are returned. :param s: the string to unquote. :param charset: the charset of the query string. If set to `None` no decoding will take place. :param errors: the error handling for the charset decoding. N)rr)rrrrr:rrrrqrs  rqcCs0t|tr |dd}n|dd}t|||S)aURL decode a single string with the given `charset` and decode "+" to whitespace. Per default encoding errors are ignored. If you want a different behavior you can set `errors` to ``'replace'`` or ``'strict'``. :param s: The string to unquote. :param charset: the charset of the query string. If set to `None` no decoding will take place. :param errors: The error handling for the `charset` decoding. rr+ )r7r#r2rq)rrrrrrurl_unquote_pluss   rcCst||ddd}|dr(|ddr(|dddvr(d |dd }t|}t|j|d d }t|j|d d }t|j |d d }t |j | |||fS)aSometimes you get an URL by a user that just isn't a real URL because it contains unsafe characters like ' ' and so on. This function can fix some of the problems in a similar way browsers handle data entered by the user: >>> url_fix('http://de.wikipedia.org/wiki/Elf (Begriffskl\xe4rung)') 'http://de.wikipedia.org/wiki/Elf%20(Begriffskl%C3%A4rung)' :param s: the string with the URL to fix. :param charset: The target charset for the URL if the url was given as a string. r2rorlzfile:// )z:/z|/zfile:///Nz /%+$!*'(),rz :&%=+$!*'(),) rr2rrtrQr]rrrrrTrr_)rrrrqsanchorrrrurl_fixs*rcCsg|] }|tvrt|qSr)rrrrrrrecCs t|j|j|j}||jfS)zRUsed in :func:`uri_to_iri` after unquoting to re-quote any invalid bytes. )_fast_url_quoteobjectstartend)routrrr_codec_error_url_quotes rwerkzeug.url_quoteuricCsht|tr t|}tt||}t|j||t}t|j||t}t|j ||t}t|j | |||fS)aConvert a URI to an IRI. All valid UTF-8 characters are unquoted, leaving all reserved and invalid characters quoted. If the URL has a domain, it is decoded from Punycode. >>> uri_to_iri("http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF") 'http://\u2603.net/p\xe5th?q=\xe8ry%DF' :param uri: The URI to convert. :param charset: The encoding to encode unquoted bytes with. :param errors: Error handler to use during ``bytes.encode``. By default, invalid bytes are left quoted. .. versionchanged:: 0.15 All reserved and invalid characters remain quoted. Previously, only some reserved characters were preserved, and invalid bytes were replaced instead of left quoted. .. versionadded:: 0.6 ) r7tuplerTrQrrqr_to_iri_unsaferrrr`)rrrrrrrrrrds rdz:/?#[]@!$&'()*+,;=%Firisafe_conversionc Cst|tr t|}|r+zt|}|d}t|dkr |WSWn ty*Ynwtt|||}t |j ||t }t |j ||t }t |j ||t }t|j||||fS)aConvert an IRI to a URI. All non-ASCII and unsafe characters are quoted. If the URL has a domain, it is encoded to Punycode. >>> iri_to_uri('http://\u2603.net/p\xe5th?q=\xe8ry%DF') 'http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF' :param iri: The IRI to convert. :param charset: The encoding of the IRI. :param errors: Error handler to use during ``bytes.encode``. :param safe_conversion: Return the URL unchanged if it only contains ASCII characters and no whitespace. See the explanation below. There is a general problem with IRI conversion with some protocols that are in violation of the URI specification. Consider the following two IRIs:: magnet:?xt=uri:whatever itms-services://?action=download-manifest After parsing, we don't know if the scheme requires the ``//``, which is dropped if empty, but conveys different meanings in the final URL if it's present or not. In this case, you can use ``safe_conversion``, which will return the URL unchanged if it only contains ASCII characters and no whitespace. This can result in a URI with unquoted characters if it was not already quoted correctly, but preserves the URL's semantics. Werkzeug uses this for the ``Location`` header for redirects. .. versionchanged:: 0.15 All reserved characters remain unquoted. Previously, only some reserved characters were left unquoted. .. versionchanged:: 0.9.6 The ``safe_conversion`` parameter was added. .. versionadded:: 0.6 r r)r7rrTrr ryrxr8rQr]r _to_uri_saferrrr_) rrrr native_iri ascii_irirrrrrrrbs" +  rb& include_empty separatorclsz ds.MultiDictrMcCsv|dur ddlm}|}t|trt|ts||pd}nt|tr/t|ts/||p-d}|t|||||S)awParse a query string and return it as a :class:`MultiDict`. :param s: The query string to parse. :param charset: Decode bytes to string with this charset. If not given, bytes are returned as-is. :param include_empty: Include keys with empty values in the dict. :param errors: Error handling behavior when decoding bytes. :param separator: Separator character between pairs. :param cls: Container to hold result instead of :class:`MultiDict`. .. versionchanged:: 2.0 The ``decode_keys`` parameter is deprecated and will be removed in Werkzeug 2.1. .. versionchanged:: 0.5 In previous versions ";" and "&" could be used for url decoding. Now only "&" is supported. If you want to use ";", a different ``separator`` can be provided. .. versionchanged:: 0.5 The ``cls`` parameter was added. Nr MultiDictr ) rrr7r#rrr _url_decode_implrx)rrrrrrrrrrrN3s rN&streamlimitc CsFddlm}||||}t||||} |durddlm} | }|| S)a_Works like :func:`url_decode` but decodes a stream. The behavior of stream and limit follows functions like :func:`~werkzeug.wsgi.make_line_iter`. The generator of pairs is directly fed to the `cls` so you can consume the data while it's parsed. :param stream: a stream with the encoded querystring :param charset: the charset of the query string. If set to `None` no decoding will take place. :param include_empty: Set to `False` if you don't want empty values to appear in the dict. :param errors: the decoding error behavior. :param separator: the pair separator to be used, defaults to ``&`` :param cls: an optional dict class to use. If this is not specified or `None` the default :class:`MultiDict` is used. :param limit: the content length of the URL data. Not necessary if a limited stream is provided. .. versionchanged:: 2.0 The ``decode_keys`` and ``return_iterator`` parameters are deprecated and will be removed in Werkzeug 2.1. .. versionadded:: 0.8 r)make_chunk_iterNr)wsgir rrr) r rrrrrr r  pair_iterdecoderrrrrurl_decode_stream`s !  rr c csl|D]0}|sqt|}|d}||vr||d\}}n |s q|}|d}t|||t|||fVqdS)NrrrU)rrxr) r rrrpairrequalrrrrrrs   rcCst|d}|t||||S)aURL encode a dict/`MultiDict`. If a value is `None` it will not appear in the result string. Per default only values are encoded into the target charset strings. :param obj: the object to encode into a query string. :param charset: the charset of the query string. :param sort: set to `True` if you want parameters to be sorted by `key`. :param separator: the separator to be used for the pairs. :param key: an optional function to be used for sorting. For more details check out the :func:`sorted` documentation. .. versionchanged:: 2.0 The ``encode_keys`` parameter is deprecated and will be removed in Werkzeug 2.1. .. versionchanged:: 0.5 Added the ``sort``, ``key``, and ``separator`` parameters. r )rrSr)rrrrrrrr url_encodes rc CsRt|d}t||||}|dur|St|D]\}}|r!||||qdS)aLike :meth:`url_encode` but writes the results to a stream object. If the stream is `None` a generator over all encoded pairs is returned. :param obj: the object to encode into a query string. :param stream: a stream to write the encoded object into or `None` if an iterator over the encoded pairs should be returned. In that case the separator argument is ignored. :param charset: the charset of the query string. :param sort: set to `True` if you want parameters to be sorted by `key`. :param separator: the separator to be used for the pairs. :param key: an optional function to be used for sorting. For more details check out the :func:`sorted` documentation. .. versionchanged:: 2.0 The ``encode_keys`` parameter is deprecated and will be removed in Werkzeug 2.1. .. versionadded:: 0.8 r N)rr enumeratewrite) rr rrrrgenrchunkrrrurl_encode_streams   rbasecst|tr t|}t|trt|}t||ft||s |S|s$|St||d\}}}}}t|||\}} } } } ||kr@|S| rKt|| | | | fS|} | dddkr_| d} n | sm|d} | sl|} n|ddd| d} | ddkrd| d<fdd | D} d}t| d}||kr| |d kr| |ddd fvr| |d|d=n |d7}||ksnqdd g}| dd |kr| d=| dd |ks݈d| } t|| | | | fS) a Join a base URL and a possibly relative URL to form an absolute interpretation of the latter. :param base: the base URL for the join operation. :param url: the URL to join. :param allow_fragments: indicates whether fragments should be allowed. )rNrrl.rUcsg|] }|dkr|qS)rr)rsegmentrrrrrzurl_join..Tz..rm) r7rrTrrrQrxryrS)rrrbschemebnetlocbpathbquery bfragmentrrrrrsegmentsrnunwanted_markerrrrrRs^   $  , rR)rU)NT)rYrZrrU)rYrZrU)rYr2rUr)rY)rYr)rYrZF)rYTr2rN)rYTr2rNN)rYFNr)NrYFNr)T)Mrcodecsrrretypingr _internalrrrrr TYPE_CHECKINGrUrdscompilerrrrr rrr NamedTuplerr%rrrDict FrozenSetrrr$Unionr#rMappingIterablerboolrCallablerIteratorrrErQrrrrr]rrTrqrrrSrr8rregister_errorrdrrbAnyStrTyperNIOrrrrrRrrrrs        ,   !&   4        $ " !      # D / .  &  &  *