{“version”:3,“sources”:,“names”:,“mappings”:“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”,“file”:“dist/es5/uri.all.min.js”,“sourcesContent”:[“export function merge(…sets:Array<string>):string {ntif (sets.length > 1) {nttsets = sets.slice(0, -1);nttconst xl = sets.length - 1;nttfor (let x = 1; x < xl; ++x) {ntttsets = sets.slice(1, -1);ntt}nttsets = sets.slice(1);nttreturn sets.join('');nt} else {nttreturn sets;nt}n}nnexport function subexp(str:string):string {ntreturn "(?:" + str + ")";n}nnexport function typeOf(o:any):string {ntreturn o === undefined ? "undefined" : (o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase());n}nnexport function toUpperCase(str:string):string {ntreturn str.toUpperCase();n}nnexport function toArray(obj:any):Array<any> {ntreturn obj !== undefined && obj !== null ? (obj instanceof Array ? obj : (typeof obj.length !== "number" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj))) : [];n}nnnexport function assign(target: object, source: any): any {ntconst obj = target as any;ntif (source) {nttfor (const key in source) {ntttobj = source;ntt}nt}ntreturn obj;n}”,“import { URIRegExps } from "./uri";nimport { merge, subexp } from "./util";nnexport function buildExps(isIRI:boolean):URIRegExps {ntconstnttALPHA$$ = "[A-Za-z]",nttCR$ = "[\\x0D]",nttDIGIT$$ = "[0-9]",nttDQUOTE$$ = "[\\x22]",nttHEXDIG$$ = merge(DIGIT$$, "[A-Fa-f]"), //case-insensitiventtLF$$ = "[\\x0A]",nttSP$$ = "[\\x20]",nttPCT_ENCODED$ = subexp(subexp("%" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)), //expandednttGEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]",nttSUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\*\+\\,\\;\\=]",nttRESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),nttUCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", //subset, excludes bidi control charactersnttIPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]", //subsetnttUNRESERVED$$ = merge(ALPHA$$, DIGIT$$, "[\\-\\.\_\\~]", UCSCHAR$$),nttSCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\+\\-\\.]") + "*"),nttUSERINFO$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]")) + "*"),nttDEC_OCTET$ = subexp(subexp("25") + "|" + subexp("2" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("" + DIGIT$$) + "|" + DIGIT$$),nttDEC_OCTET_RELAXED$ = subexp(subexp("25") + "|" + subexp("2" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?" + DIGIT$$) + "|0?0?" + DIGIT$$), //relaxed parsing rulesnttIPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$),nttH16$ = subexp(HEXDIG$$ + "{1,4}"),nttLS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$),nttIPV6ADDRESS1$ = subexp( subexp(H16$ + "\\:") + "{6}" + LS32$), // 6( h16 ":" ) ls32nttIPV6ADDRESS2$ = subexp( "\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$), // "::" 5( h16 ":" ) ls32nttIPV6ADDRESS3$ = subexp(subexp( H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$), //[ h16 ] "::" 4( h16 ":" ) ls32nttIPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$), //[ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32nttIPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$), //[ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32nttIPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$), //[ *3( h16 ":" ) h16 ] "::" h16 ":" ls32nttIPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$), //[ *4( h16 ":" ) h16 ] "::" ls32nttIPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$ ), //[ *5( h16 ":" ) h16 ] "::" h16nttIPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:" ), //[ *6( h16 ":" ) h16 ] "::"nttIPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")),nttZONEID$ = subexp(subexp(UNRESERVED$$ + "|" + PCT_ENCODED$) + "+"), //RFC 6874nttIPV6ADDRZ$ = subexp(IPV6ADDRESS$ + "\\%25" + ZONEID$), //RFC 6874nttIPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + ZONEID$), //RFC 6874, with relaxed parsing rulesnttIPVFUTURE$ = subexp("" + HEXDIG$$ + "+\\." + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]") + "+"),nttIP_LITERAL$ = subexp("\\[" + subexp(IPV6ADDRZ_RELAXED$ + "|" + IPV6ADDRESS$ + "|" + IPVFUTURE$) + "\\]"), //RFC 6874nttREG_NAME$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$)) + "*"),nttHOST$ = subexp(IP_LITERAL$ + "|" + IPV4ADDRESS$ + "(?!" + REG_NAME$ + ")" + "|" + REG_NAME$),nttPORT$ = subexp(DIGIT$$ + "*"),nttAUTHORITY$ = subexp(subexp(USERINFO$ + "@") + "?" + HOST$ + subexp("\\:" + PORT$) + "?"),nttPCHAR$ = subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@]")),nttSEGMENT$ = subexp(PCHAR$ + "*"),nttSEGMENT_NZ$ = subexp(PCHAR$ + "+"),nttSEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\@]")) + "+"),nttPATH_ABEMPTY$ = subexp(subexp("\\/" + SEGMENT$) + "*"),nttPATH_ABSOLUTE$ = subexp("\\/" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + "?"), //simplifiednttPATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$), //simplifiednttPATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$), //simplifiednttPATH_EMPTY$ = "(?!" + PCHAR$ + ")",nttPATH$ = subexp(PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$),nttQUERY$ = subexp(subexp(PCHAR$ + "|" + merge("", IPRIVATE$$)) + "*"),nttFRAGMENT$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"),nttHIER_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$),nttURI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"),nttRELATIVE_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$),nttRELATIVE$ = subexp(RELATIVE_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"),nttURI_REFERENCE$ = subexp(URI$ + "|" + RELATIVE$),nttABSOLUTE_URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?"),nnttGENERIC_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$",nttRELATIVE_REF$ = "^(){0}" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$",nttABSOLUTE_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?$",nttSAMEDOC_REF$ = "^" + subexp("\\#(" + FRAGMENT$ + ")") + "?$",nttAUTHORITY_REF$ = "^" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?$"nt;nntreturn {nttNOT_SCHEME : new RegExp(merge("", ALPHA$$, DIGIT$$, "[\+\\-\\.]"), "g"),nttNOT_USERINFO : new RegExp(merge("", UNRESERVED$$, SUB_DELIMS$$), "g"),nttNOT_HOST : new RegExp(merge("[^\\%\\\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"),nttNOT_PATH : new RegExp(merge("", UNRESERVED$$, SUB_DELIMS$$), "g"),nttNOT_PATH_NOSCHEME : new RegExp(merge("", UNRESERVED$$, SUB_DELIMS$$), "g"),nttNOT_QUERY : new RegExp(merge("", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),nttNOT_FRAGMENT : new RegExp(merge("", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),nttESCAPE : new RegExp(merge("", UNRESERVED$$, SUB_DELIMS$$), "g"),nttUNRESERVED : new RegExp(UNRESERVED$$, "g"),nttOTHER_CHARS : new RegExp(merge("", UNRESERVED$$, RESERVED$$), "g"),nttPCT_ENCODED : new RegExp(PCT_ENCODED$, "g"),nttIPV4ADDRESS : new RegExp("^(" + IPV4ADDRESS$ + ")$"),nttIPV6ADDRESS : new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$") //RFC 6874, with relaxed parsing rulesnt};n}nnexport default buildExps(false);n”,“'use strict';nn/** Highest positive signed 32-bit float value */nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1nn/** Bootstring parameters */nconst base = 36;nconst tMin = 1;nconst tMax = 26;nconst skew = 38;nconst damp = 700;nconst initialBias = 72;nconst initialN = 128; // 0x80nconst delimiter = '-'; // '\x2D'nn/** Regular expressions */nconst regexPunycode = /^xn–/;nconst regexNonASCII = /[^\0-\x7E]/; // non-ASCII charsnconst regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separatorsnn/** Error messages */nconst errors = {nt'overflow': 'Overflow: input needs wider integers to process',nt'not-basic': 'Illegal input >= 0x80 (not a basic code point)',nt'invalid-input': 'Invalid input'n};nn/** Convenience shortcuts */nconst baseMinusTMin = base - tMin;nconst floor = Math.floor;nconst stringFromCharCode = String.fromCharCode;nn/————————————————————————–/nn/**n * A generic error utility function.n * @privaten * @param {String} type The error type.n * @returns {Error} Throws a `RangeError` with the applicable error message.n */nfunction error(type) {ntthrow new RangeError(errors);n}nn/**n * A generic `Array#map` utility function.n * @privaten * @param {Array} array The array to iterate over.n * @param {Function} callback The function that gets called for every arrayn * item.n * @returns {Array} A new array of values returned by the callback function.n */nfunction map(array, fn) {ntconst result = [];ntlet length = array.length;ntwhile (length–) {nttresult = fn(array);nt}ntreturn result;n}nn/**n * A simple `Array#map`-like wrapper to work with domain name strings or emailn * addresses.n * @privaten * @param {String} domain The domain name or email address.n * @param {Function} callback The function that gets called for everyn * character.n * @returns {Array} A new string of characters returned by the callbackn * function.n */nfunction mapDomain(string, fn) {ntconst parts = string.split('@');ntlet result = '';ntif (parts.length > 1) {ntt// In email addresses, only the domain name should be punycoded. Leaventt// the local part (i.e. everything up to `@`) intact.nttresult = parts + '@';nttstring = parts;nt}nt// Avoid `split(regex)` for IE8 compatibility. See #17.ntstring = string.replace(regexSeparators, '\x2E');ntconst labels = string.split('.');ntconst encoded = map(labels, fn).join('.');ntreturn result + encoded;n}nn/**n * Creates an array containing the numeric code points of each Unicoden * character in the string. While JavaScript uses UCS-2 internally,n * this function will convert a pair of surrogate halves (each of whichn * UCS-2 exposes as separate characters) into a single code point,n * matching UTF-16.n * @see `punycode.ucs2.encode`n * @see <tools.ietf.org/html/rfc3492#section-3.4n * @privaten */nconst adapt = function(delta, numPoints, firstTime) {ntlet k = 0;ntdelta = firstTime ? floor(delta / damp) : delta >> 1;ntdelta += floor(delta / numPoints);ntfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {nttdelta = floor(delta / baseMinusTMin);nt}ntreturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));n};nn/**n * Converts a Punycode string of ASCII-only symbols to a string of Unicoden * symbols.n * @memberOf punycoden * @param {String} input The Punycode string of ASCII-only symbols.n * @returns {String} The resulting string of Unicode symbols.n */nconst decode = function(input) {nt// Don't use UCS-2.ntconst output = [];ntconst inputLength = input.length;ntlet i = 0;ntlet n = initialN;ntlet bias = initialBias;nnt// Handle the basic code points: let `basic` be the number of input codent// points before the last delimiter, or `0` if there is none, then copynt// the first basic code points to the output.nntlet basic = input.lastIndexOf(delimiter);ntif (basic < 0) {nttbasic = 0;nt}nntfor (let j = 0; j < basic; ++j) {ntt// if it's not a basic code pointnttif (input.charCodeAt(j) >= 0x80) {nttterror('not-basic');ntt}nttoutput.push(input.charCodeAt(j));nt}nnt// Main decoding loop: start just after the last delimiter if any basic codent// points were copied; start at the beginning otherwise.nntfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {nntt// `index` is the index of the next character to be consumed.ntt// Decode a generalized variable-length integer into `delta`,ntt// which gets added to `i`. The overflow checking is easierntt// if we increase `i` as we go, then subtract off its startingntt// value at the end to obtain `delta`.nttlet oldi = i;nttfor (let w = 1, k = base; /* no condition */; k += base) {nntttif (index >= inputLength) {ntttterror('invalid-input');nttt}nntttconst digit = basicToDigit(input.charCodeAt(index++));nntttif (digit >= base || digit > floor((maxInt - i) / w)) {ntttterror('overflow');nttt}nnttti += digit * w;ntttconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);nntttif (digit < t) {nttttbreak;nttt}nntttconst baseMinusT = base - t;ntttif (w > floor(maxInt / baseMinusT)) {ntttterror('overflow');nttt}nntttw *= baseMinusT;nntt}nnttconst out = output.length + 1;nttbias = adapt(i - oldi, out, oldi == 0);nntt// `i` was supposed to wrap around from `out` to `0`,ntt// incrementing `n` each time, so we'll fix that now:nttif (floor(i / out) > maxInt - n) {nttterror('overflow');ntt}nnttn += floor(i / out);ntti %= out;nntt// Insert `n` at position `i` of the output.nttoutput.splice(i++, 0, n);nnt}nntreturn String.fromCodePoint(…output);n};nn/**n * Converts a string of Unicode symbols (e.g. a domain name label) to an * Punycode string of ASCII-only symbols.n * @memberOf punycoden * @param {String} input The string of Unicode symbols.n * @returns {String} The resulting Punycode string of ASCII-only symbols.n */nconst encode = function(input) {ntconst output = [];nnt// Convert the input in UCS-2 to an array of Unicode code points.ntinput = ucs2decode(input);nnt// Cache the length.ntlet inputLength = input.length;nnt// Initialize the state.ntlet n = initialN;ntlet delta = 0;ntlet bias = initialBias;nnt// Handle the basic code points.ntfor (const currentValue of input) {nttif (currentValue < 0x80) {ntttoutput.push(stringFromCharCode(currentValue));ntt}nt}nntlet basicLength = output.length;ntlet handledCPCount = basicLength;nnt// `handledCPCount` is the number of code points that have been handled;nt// `basicLength` is the number of basic code points.nnt// Finish the basic string with a delimiter unless it's empty.ntif (basicLength) {nttoutput.push(delimiter);nt}nnt// Main encoding loop:ntwhile (handledCPCount < inputLength) {nntt// All non-basic code points < n have been handled already. Find the nextntt// larger one:nttlet m = maxInt;nttfor (const currentValue of input) {ntttif (currentValue >= n && currentValue < m) {nttttm = currentValue;nttt}ntt}nntt// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,ntt// but guard against overflow.nttconst handledCPCountPlusOne = handledCPCount + 1;nttif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {nttterror('overflow');ntt}nnttdelta += (m - n) * handledCPCountPlusOne;nttn = m;nnttfor (const currentValue of input) {ntttif (currentValue < n && ++delta > maxInt) {ntttterror('overflow');nttt}ntttif (currentValue == n) {ntttt// Represent delta as a generalized variable-length integer.nttttlet q = delta;nttttfor (let k = base; /* no condition */; k += base) {ntttttconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);ntttttif (q < t) {nttttttbreak;nttttt}ntttttconst qMinusT = q - t;ntttttconst baseMinusT = base - t;ntttttoutput.push(nttttttstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))nttttt);ntttttq = floor(qMinusT / baseMinusT);ntttt}nnttttoutput.push(stringFromCharCode(digitToBasic(q, 0)));nttttbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);nttttdelta = 0;ntttt++handledCPCount;nttt}ntt}nntt++delta;ntt++n;nnt}ntreturn output.join('');n};nn/**n * Converts a Punycode string representing a domain name or an email addressn * to Unicode. Only the Punycoded parts of the input will be converted, i.e.n * it doesn't matter if you call it on a string that has already beenn * converted to Unicode.n * @memberOf punycoden * @param {String} input The Punycoded domain name or email address ton * convert to Unicode.n * @returns {String} The Unicode representation of the given Punycoden * string.n */nconst toUnicode = function(input) {ntreturn mapDomain(input, function(string) {nttreturn regexPunycode.test(string)nttt? decode(string.slice(4).toLowerCase())nttt: string;nt});n};nn/**n * Converts a Unicode string representing a domain name or an email address ton * Punycode. Only the non-ASCII parts of the domain name will be converted,n * i.e. it doesn't matter if you call it with a domain that's already inn * ASCII.n * @memberOf punycoden * @param {String} input The domain name or email address to convert, as an * Unicode string.n * @returns {String} The Punycode representation of the given domain name orn * email address.n */nconst toASCII = function(input) {ntreturn mapDomain(input, function(string) {nttreturn regexNonASCII.test(string)nttt? 'xn–' + encode(string)nttt: string;nt});n};nn/————————————————————————–/nn/** Define the public API */nconst punycode = {nt/**nt * A string representing the current Punycode.js version number.nt * @memberOf punycodent * @type Stringnt */nt'version': '2.1.0',nt/**nt * An object of methods to convert from JavaScript's internal characternt * representation (UCS-2) to Unicode code points, and back.nt * @see <Gary”>gary.court@gmail.com">Gary Court</a>n * @see github.com/garycourt/uri-jsn */nn/**n * Copyright 2011 Gary Court. All rights reserved.n *n * Redistribution and use in source and binary forms, with or without modification, aren * permitted provided that the following conditions are met:n *n * 1. Redistributions of source code must retain the above copyright notice, this list ofn * conditions and the following disclaimer.n *n * 2. Redistributions in binary form must reproduce the above copyright notice, this listn * of conditions and the following disclaimer in the documentation and/or other materialsn * provided with the distribution.n *n * THIS SOFTWARE IS PROVIDED BY GARY COURT “AS IS'' AND ANY EXPRESS OR IMPLIEDn * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY ANDn * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT ORn * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, ORn * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ORn * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ONn * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDINGn * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IFn * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.n *n * The views and conclusions contained in the software and documentation are those of then * authors and should not be interpreted as representing official policies, either expressedn * or implied, of Gary Court.n */nnimport URI_PROTOCOL from "./regexps-uri";nimport IRI_PROTOCOL from "./regexps-iri";nimport punycode from "punycode";nimport { toUpperCase, typeOf, assign } from "./util";nnexport interface URIComponents {ntscheme?:string;ntuserinfo?:string;nthost?:string;ntport?:number|string;ntpath?:string;ntquery?:string;ntfragment?:string;ntreference?:string;nterror?:string;n}nnexport interface URIOptions {ntscheme?:string;ntreference?:string;nttolerant?:boolean;ntabsolutePath?:boolean;ntiri?:boolean;ntunicodeSupport?:boolean;ntdomainHost?:boolean;n}nnexport interface URISchemeHandler<Components extends URIComponents = URIComponents, Options extends URIOptions = URIOptions, ParentComponents extends URIComponents = URIComponents> {ntscheme:string;ntparse(components:ParentComponents, options:Options):Components;ntserialize(components:Components, options:Options):ParentComponents;ntunicodeSupport?:boolean;ntdomainHost?:boolean;ntabsolutePath?:boolean;n}nnexport interface URIRegExps {ntNOT_SCHEME : RegExp,ntNOT_USERINFO : RegExp,ntNOT_HOST : RegExp,ntNOT_PATH : RegExp,ntNOT_PATH_NOSCHEME : RegExp,ntNOT_QUERY : RegExp,ntNOT_FRAGMENT : RegExp,ntESCAPE : RegExp,ntUNRESERVED : RegExp,ntOTHER_CHARS : RegExp,ntPCT_ENCODED : RegExp,ntIPV4ADDRESS : RegExp,ntIPV6ADDRESS : RegExp,n}nnexport const SCHEMES:{[scheme:string]:URISchemeHandler} = {};nnexport function pctEncChar(chr:string):string {ntconst c = chr.charCodeAt(0);ntlet e:string;nntif (c < 16) e = "%0" + c.toString(16).toUpperCase();ntelse if (c < 128) e = "%" + c.toString(16).toUpperCase();ntelse if (c < 2048) e = "%" + ((c >> 6) | 192).toString(16).toUpperCase() + "%" + ((c & 63) | 128).toString(16).toUpperCase();ntelse e = "%" + ((c >> 12) | 224).toString(16).toUpperCase() + "%" + (((c >> 6) & 63) | 128).toString(16).toUpperCase() + "%" + ((c & 63) | 128).toString(16).toUpperCase();nntreturn e;n}nnexport function pctDecChars(str:string):string {ntlet newStr = "";ntlet i = 0;ntconst il = str.length;nntwhile (i < il) {nttconst c = parseInt(str.substr(i + 1, 2), 16);nnttif (c < 128) {ntttnewStr += String.fromCharCode©;nttti += 3;ntt}nttelse if (c >= 194 && c < 224) {ntttif ((il - i) >= 6) {nttttconst c2 = parseInt(str.substr(i + 4, 2), 16);nttttnewStr += String.fromCharCode(((c & 31) << 6) | (c2 & 63));nttt} else {nttttnewStr += str.substr(i, 6);nttt}nttti += 6;ntt}nttelse if (c >= 224) {ntttif ((il - i) >= 9) {nttttconst c2 = parseInt(str.substr(i + 4, 2), 16);nttttconst c3 = parseInt(str.substr(i + 7, 2), 16);nttttnewStr += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));nttt} else {nttttnewStr += str.substr(i, 9);nttt}nttti += 9;ntt}nttelse {ntttnewStr += str.substr(i, 3);nttti += 3;ntt}nt}nntreturn newStr;n}nnfunction _normalizeComponentEncoding(components:URIComponents, protocol:URIRegExps) {ntfunction decodeUnreserved(str:string):string {nttconst decStr = pctDecChars(str);nttreturn (!decStr.match(protocol.UNRESERVED) ? str : decStr);nt}nntif (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, "");ntif (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);ntif (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);ntif (components.path !== undefined) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved).replace((components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME), pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);ntif (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);ntif (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);nntreturn components;n};nnfunction _stripLeadingZeros(str:string):string {ntreturn str.replace(/^0*(.*)/, "$1") || "0";n}nnfunction _normalizeIPv4(host:string, protocol:URIRegExps):string {ntconst matches = host.match(protocol.IPV4ADDRESS) || [];ntconst [, address] = matches;ntntif (address) {nttreturn address.split(".").map(_stripLeadingZeros).join(".");nt} else {nttreturn host;nt}n}nnfunction _normalizeIPv6(host:string, protocol:URIRegExps):string {ntconst matches = host.match(protocol.IPV6ADDRESS) || [];ntconst [, address, zone] = matches;nntif (address) {nttconst [last, first] = address.toLowerCase().split('::').reverse();nttconst firstFields = first ? first.split(":").map(_stripLeadingZeros) : [];nttconst lastFields = last.split(":").map(_stripLeadingZeros);nttconst isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);nttconst fieldCount = isLastFieldIPv4Address ? 7 : 8;nttconst lastFieldsStart = lastFields.length - fieldCount;nttconst fields = Array<string>(fieldCount);nnttfor (let x = 0; x < fieldCount; ++x) {ntttfields = firstFields || lastFields[lastFieldsStart + x] || '';ntt}nnttif (isLastFieldIPv4Address) {ntttfields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);ntt}nnttconst allZeroFields = fields.reduce<Array<{index:number,length:number}>>((acc, field, index) => {ntttif (!field || field === "0") {nttttconst lastLongest = acc[acc.length - 1];nttttif (lastLongest && lastLongest.index + lastLongest.length === index) {ntttttlastLongest.length++;ntttt} else {ntttttacc.push({ index, length : 1 });ntttt}nttt}ntttreturn acc;ntt}, []);nnttconst longestZeroFields = allZeroFields.sort((a, b) => b.length - a.length);nnttlet newHost:string;nttif (longestZeroFields && longestZeroFields.length > 1) {ntttconst newFirst = fields.slice(0, longestZeroFields.index) ;ntttconst newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);ntttnewHost = newFirst.join(":") + "::" + newLast.join(":");ntt} else {ntttnewHost = fields.join(":");ntt}nnttif (zone) {ntttnewHost += "%" + zone;ntt}nnttreturn newHost;nt} else {nttreturn host;nt}n}nnconst URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;nconst NO_MATCH_IS_UNDEFINED = (<RegExpMatchArray>("").match(/(){0}/))[1] === undefined;nnexport function parse(uriString:string, options:URIOptions = {}):URIComponents {ntconst components:URIComponents = {};ntconst protocol = (options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL);nntif (options.reference === "suffix") uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString;nntconst matches = uriString.match(URI_PARSE);nntif (matches) {nttif (NO_MATCH_IS_UNDEFINED) {nttt//store each componentntttcomponents.scheme = matches;ntttcomponents.userinfo = matches;ntttcomponents.host = matches;ntttcomponents.port = parseInt(matches, 10);ntttcomponents.path = matches || "";ntttcomponents.query = matches;ntttcomponents.fragment = matches;nnttt//fix port numberntttif (isNaN(components.port)) {nttttcomponents.port = matches;nttt}ntt} else { //IE FIX for improper RegExp matchingnttt//store each componentntttcomponents.scheme = matches || undefined;ntttcomponents.userinfo = (uriString.indexOf("@") !== -1 ? matches : undefined);ntttcomponents.host = (uriString.indexOf("//") !== -1 ? matches : undefined);ntttcomponents.port = parseInt(matches, 10);ntttcomponents.path = matches || "";ntttcomponents.query = (uriString.indexOf("?") !== -1 ? matches : undefined);ntttcomponents.fragment = (uriString.indexOf("#") !== -1 ? matches : undefined);nnttt//fix port numberntttif (isNaN(components.port)) {nttttcomponents.port = (uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches : undefined);nttt}ntt}nnttif (components.host) {nttt//normalize IP hostsntttcomponents.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);ntt}nntt//determine reference typenttif (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {ntttcomponents.reference = "same-document";ntt} else if (components.scheme === undefined) {ntttcomponents.reference = "relative";ntt} else if (components.fragment === undefined) {ntttcomponents.reference = "absolute";ntt} else {ntttcomponents.reference = "uri";ntt}nntt//check for reference errorsnttif (options.reference && options.reference !== "suffix" && options.reference !== components.reference) {ntttcomponents.error = components.error || "URI is not a " + options.reference + " reference.";ntt}nntt//find scheme handlernttconst schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];nntt//check if scheme can't handle IRIsnttif (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {nttt//if host component is a domain namentttif (components.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost))) {ntttt//convert Unicode IDN -> ASCII IDNntttttry {ntttttcomponents.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());ntttt} catch (e) {ntttttcomponents.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e;ntttt}nttt}nttt//convert IRI -> URInttt_normalizeComponentEncoding(components, URI_PROTOCOL);ntt} else {nttt//normalize encodingsnttt_normalizeComponentEncoding(components, protocol);ntt}nntt//perform scheme specific parsingnttif (schemeHandler && schemeHandler.parse) {ntttschemeHandler.parse(components, options);ntt}nt} else {nttcomponents.error = components.error || "URI can not be parsed.";nt}nntreturn components;n};nnfunction _recomposeAuthority(components:URIComponents, options:URIOptions):string|undefined {ntconst protocol = (options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL);ntconst uriTokens:Array<string> = [];nntif (components.userinfo !== undefined) {ntturiTokens.push(components.userinfo);ntturiTokens.push("@");nt}nntif (components.host !== undefined) {ntt//normalize IP hosts, add brackets and escape zone separator for IPv6ntturiTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, (_, $1, $2) => "[" + $1 + ($2 ? "%25" + $2 : "") + "]"));nt}nntif (typeof components.port === "number") {ntturiTokens.push(":");ntturiTokens.push(components.port.toString(10));nt}nntreturn uriTokens.length ? uriTokens.join("") : undefined;n};nnconst RDS1 = /^\.\.?\//;nconst RDS2 = /^\/\.(\/|$)/;nconst RDS3 = /^\/\.\.(\/|$)/;nconst RDS4 = /^\.\.?$/;nconst RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/;nnexport function removeDotSegments(input:string):string {ntconst output:Array<string> = [];nntwhile (input.length) {nttif (input.match(RDS1)) {ntttinput = input.replace(RDS1, "");ntt} else if (input.match(RDS2)) {ntttinput = input.replace(RDS2, "/");ntt} else if (input.match(RDS3)) {ntttinput = input.replace(RDS3, "/");ntttoutput.pop();ntt} else if (input === "." || input === "..") {ntttinput = "";ntt} else {ntttconst im = input.match(RDS5);ntttif (im) {nttttconst s = im;nttttinput = input.slice(s.length);nttttoutput.push(s);nttt} else {nttttthrow new Error("Unexpected dot segment condition");nttt}ntt}nt}nntreturn output.join("");n};nnexport function serialize(components:URIComponents, options:URIOptions = {}):string {ntconst protocol = (options.iri ? IRI_PROTOCOL : URI_PROTOCOL);ntconst uriTokens:Array<string> = [];nnt//find scheme handlerntconst schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];nnt//perform scheme specific serializationntif (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);nntif (components.host) {ntt//if host component is an IPv6 addressnttif (protocol.IPV6ADDRESS.test(components.host)) {nttt//TODO: normalize IPv6 address as per RFC 5952ntt}nntt//if host component is a domain namenttelse if (options.domainHost || (schemeHandler && schemeHandler.domainHost)) {nttt//convert IDN via punycodenttttry {nttttcomponents.host = (!options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host));nttt} catch (e) {nttttcomponents.error = components.error || "Host's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;nttt}ntt}nt}nnt//normalize encodingnt_normalizeComponentEncoding(components, protocol);nntif (options.reference !== "suffix" && components.scheme) {ntturiTokens.push(components.scheme);ntturiTokens.push(":");nt}nntconst authority = _recomposeAuthority(components, options);ntif (authority !== undefined) {nttif (options.reference !== "suffix") {nttturiTokens.push("//");ntt}nntturiTokens.push(authority);nnttif (components.path && components.path.charAt(0) !== "/") {nttturiTokens.push("/");ntt}nt}nntif (components.path !== undefined) {nttlet s = components.path;nnttif (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {nttts = removeDotSegments(s);ntt}nnttif (authority === undefined) {nttts = s.replace(/^\/\//, "/%2F"); //don't allow the path to start with "//"ntt}nntturiTokens.push(s);nt}nntif (components.query !== undefined) {ntturiTokens.push("?");ntturiTokens.push(components.query);nt}nntif (components.fragment !== undefined) {ntturiTokens.push("#");ntturiTokens.push(components.fragment);nt}nntreturn uriTokens.join(""); //merge tokens into a stringn};nnexport function resolveComponents(base:URIComponents, relative:URIComponents, options:URIOptions = {}, skipNormalization?:boolean):URIComponents {ntconst target:URIComponents = {};nntif (!skipNormalization) {nttbase = parse(serialize(base, options), options); //normalize base componentsnttrelative = parse(serialize(relative, options), options); //normalize relative componentsnt}ntoptions = options || {};nntif (!options.tolerant && relative.scheme) {ntttarget.scheme = relative.scheme;ntt//target.authority = relative.authority;ntttarget.userinfo = relative.userinfo;ntttarget.host = relative.host;ntttarget.port = relative.port;ntttarget.path = removeDotSegments(relative.path || "");ntttarget.query = relative.query;nt} else {nttif (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {nttt//target.authority = relative.authority;nttttarget.userinfo = relative.userinfo;nttttarget.host = relative.host;nttttarget.port = relative.port;nttttarget.path = removeDotSegments(relative.path || "");nttttarget.query = relative.query;ntt} else {ntttif (!relative.path) {ntttttarget.path = base.path;nttttif (relative.query !== undefined) {nttttttarget.query = relative.query;ntttt} else {nttttttarget.query = base.query;ntttt}nttt} else {nttttif (relative.path.charAt(0) === "/") {nttttttarget.path = removeDotSegments(relative.path);ntttt} else {ntttttif ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {ntttttttarget.path = "/" + relative.path;nttttt} else if (!base.path) {ntttttttarget.path = relative.path;nttttt} else {ntttttttarget.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;nttttt}nttttttarget.path = removeDotSegments(target.path);ntttt}ntttttarget.query = relative.query;nttt}nttt//target.authority = base.authority;nttttarget.userinfo = base.userinfo;nttttarget.host = base.host;nttttarget.port = base.port;ntt}ntttarget.scheme = base.scheme;nt}nnttarget.fragment = relative.fragment;nntreturn target;n};nnexport function resolve(baseURI:string, relativeURI:string, options?:URIOptions):string {ntconst schemelessOptions = assign({ scheme : 'null' }, options);ntreturn serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);n};nnexport function normalize(uri:string, options?:URIOptions):string;nexport function normalize(uri:URIComponents, options?:URIOptions):URIComponents;nexport function normalize(uri:any, options?:URIOptions):any {ntif (typeof uri === "string") {ntturi = serialize(parse(uri, options), options);nt} else if (typeOf(uri) === "object") {ntturi = parse(serialize(<URIComponents>uri, options), options);nt}nntreturn uri;n};nnexport function equal(uriA:string, uriB:string, options?: URIOptions):boolean;nexport function equal(uriA:URIComponents, uriB:URIComponents, options?:URIOptions):boolean;nexport function equal(uriA:any, uriB:any, options?:URIOptions):boolean {ntif (typeof uriA === "string") {ntturiA = serialize(parse(uriA, options), options);nt} else if (typeOf(uriA) === "object") {ntturiA = serialize(<URIComponents>uriA, options);nt}nntif (typeof uriB === "string") {ntturiB = serialize(parse(uriB, options), options);nt} else if (typeOf(uriB) === "object") {ntturiB = serialize(<URIComponents>uriB, options);nt}nntreturn uriA === uriB;n};nnexport function escapeComponent(str:string, options?:URIOptions):string {ntreturn str && str.toString().replace((!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE), pctEncChar);n};nnexport function unescapeComponent(str:string, options?:URIOptions):string {ntreturn str && str.toString().replace((!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED), pctDecChars);n};n“,”import { URISchemeHandler, URIComponents, URIOptions } from "../uri";nimport { pctEncChar, pctDecChars, unescapeComponent } from "../uri";nimport punycode from "punycode";nimport { merge, subexp, toUpperCase, toArray } from "../util";nnexport interface MailtoHeaders {nt:stringn}nnexport interface MailtoComponents extends URIComponents {ntto:Array<string>,ntheaders?:MailtoHeaders,ntsubject?:string,ntbody?:stringn}nnconst O:MailtoHeaders = {};nconst isIRI = true;nn//RFC 3986nconst UNRESERVED$$ = "[A-Za-z0-9\\-\\.\_\\~" + (isIRI ? "\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF" : "") + "]";nconst HEXDIG$$ = "[0-9A-Fa-f]"; //case-insensitivenconst PCT_ENCODED$ = subexp(subexp("%" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)); //expandednn//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =n//const ATEXT$$ = "[A-Za-z0-9\\!\\#\\$\\%\\&\\'\*\+\\-\\/\\=\\?\\^\_\\`\\{\\|\\}\\~]";n//const WSP$$ = "[\\x20\\x09]";n//const OBS_QTEXT$$ = "[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]"; //(%d1-8 / %d11-12 / %d14-31 / %d127)n//const QTEXT$$ = merge("", OBS_QTEXT$$); //%d33 / %d35-91 / %d93-126 / obs-qtextn//const VCHAR$$ = "[\\x21-\\x7E]";n//const WSP$$ = "[\\x20\\x09]";n//const OBS_QP$ = subexp("\\\\" + merge("", OBS_QTEXT$$)); //%d0 / CR / LF / obs-qtextn//const FWS$ = subexp(subexp(WSP$$ + "*" + "\\x0D\\x0A") + "?" + WSP$$ + "+");n//const QUOTED_PAIR$ = subexp(subexp("\\\\" + subexp(VCHAR$$ + "|" + WSP$$)) + "|" + OBS_QP$);n//const QUOTED_STRING$ = subexp('\\"' + subexp(FWS$ + "?" + QCONTENT$) + "*" + FWS$ + "?" + '\\"');nconst ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\*\+\\-\\^\_\\`\\{\\|\\}\\~]";nconst QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\*\+\\,\\-\\.0-9\<\\>A-Z\\x5E-\\x7E]";nconst VCHAR$$ = merge(QTEXT$$, "[\\\"\\\\]");nconst DOT_ATOM_TEXT$ = subexp(ATEXT$$ + "+" + subexp("\\." + ATEXT$$ + "+") + "*");nconst QUOTED_PAIR$ = subexp("\\\\" + VCHAR$$);nconst QCONTENT$ = subexp(QTEXT$$ + "|" + QUOTED_PAIR$);nconst QUOTED_STRING$ = subexp('\\"' + QCONTENT$ + "*" + '\\"');nn//RFC 6068nconst DTEXT_NO_OBS$$ = "[\\x21-\\x5A\\x5E-\\x7E]"; //%d33-90 / %d94-126nconst SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\*\+\\,\\;\\:\\@]";nconst QCHAR$ = subexp(UNRESERVED$$ + "|" + PCT_ENCODED$ + "|" + SOME_DELIMS$$);nconst DOMAIN$ = subexp(DOT_ATOM_TEXT$ + "|" + "\\[" + DTEXT_NO_OBS$$ + "*" + "\\]");nconst LOCAL_PART$ = subexp(DOT_ATOM_TEXT$ + "|" + QUOTED_STRING$);nconst ADDR_SPEC$ = subexp(LOCAL_PART$ + "\\@" + DOMAIN$);nconst TO$ = subexp(ADDR_SPEC$ + subexp("\\," + ADDR_SPEC$) + "*");nconst HFNAME$ = subexp(QCHAR$ + "*");nconst HFVALUE$ = HFNAME$;nconst HFIELD$ = subexp(HFNAME$ + "\\=" + HFVALUE$);nconst HFIELDS2$ = subexp(HFIELD$ + subexp("\\&" + HFIELD$) + "*");nconst HFIELDS$ = subexp("\\?" + HFIELDS2$);nconst MAILTO_URI = new RegExp("^mailto\\:" + TO$ + "?" + HFIELDS$ + "?$");nnconst UNRESERVED = new RegExp(UNRESERVED$$, "g");nconst PCT_ENCODED = new RegExp(PCT_ENCODED$, "g");nconst NOT_LOCAL_PART = new RegExp(merge("", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");nconst NOT_DOMAIN = new RegExp(merge("", ATEXT$$, "[\\.]", "[\\[]", DTEXT_NO_OBS$$, "[\\]]"), "g");nconst NOT_HFNAME = new RegExp(merge("", UNRESERVED$$, SOME_DELIMS$$), "g");nconst NOT_HFVALUE = NOT_HFNAME;nconst TO = new RegExp("^" + TO$ + "$");nconst HFIELDS = new RegExp("^" + HFIELDS2$ + "$");nnfunction decodeUnreserved(str:string):string {ntconst decStr = pctDecChars(str);ntreturn (!decStr.match(UNRESERVED) ? str : decStr);n}nnconst handler:URISchemeHandler<MailtoComponents> = {ntscheme : "mailto",nntparse : function (components:URIComponents, options:URIOptions):MailtoComponents {nttconst mailtoComponents = components as MailtoComponents;nttconst to = mailtoComponents.to = (mailtoComponents.path ? mailtoComponents.path.split(",") : []);nttmailtoComponents.path = undefined;nnttif (mailtoComponents.query) {ntttlet unknownHeaders = falsentttconst headers:MailtoHeaders = {};ntttconst hfields = mailtoComponents.query.split("&");nntttfor (let x = 0, xl = hfields.length; x < xl; ++x) {nttttconst hfield = hfields.split("=");nnttttswitch (hfield) {ntttttcase "to":nttttttconst toAddrs = hfield.split(",");nttttttfor (let x = 0, xl = toAddrs.length; x < xl; ++x) {ntttttttto.push(toAddrs);ntttttt}nttttttbreak;ntttttcase "subject":nttttttmailtoComponents.subject = unescapeComponent(hfield, options);nttttttbreak;ntttttcase "body":nttttttmailtoComponents.body = unescapeComponent(hfield, options);nttttttbreak;ntttttdefault:nttttttunknownHeaders = true;nttttttheaders[unescapeComponent(hfield, options)] = unescapeComponent(hfield, options);nttttttbreak;ntttt}nttt}nntttif (unknownHeaders) mailtoComponents.headers = headers;ntt}nnttmailtoComponents.query = undefined;nnttfor (let x = 0, xl = to.length; x < xl; ++x) {ntttconst addr = to.split("@");nntttaddr = unescapeComponent(addr);nntttif (!options.unicodeSupport) {ntttt//convert Unicode IDN -> ASCII IDNntttttry {ntttttaddr = punycode.toASCII(unescapeComponent(addr, options).toLowerCase());ntttt} catch (e) {ntttttmailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e;ntttt}nttt} else {nttttaddr = unescapeComponent(addr, options).toLowerCase();nttt}nntttto = addr.join("@");ntt}nnttreturn mailtoComponents;nt},nntserialize : function (mailtoComponents:MailtoComponents, options:URIOptions):URIComponents {nttconst components = mailtoComponents as URIComponents;nttconst to = toArray(mailtoComponents.to);nttif (to) {ntttfor (let x = 0, xl = to.length; x < xl; ++x) {nttttconst toAddr = String(to);nttttconst atIdx = toAddr.lastIndexOf("@");nttttconst localPart = (toAddr.slice(0, atIdx)).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);nttttlet domain = toAddr.slice(atIdx + 1);nntttt//convert IDN via punycodentttttry {ntttttdomain = (!options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain));ntttt} catch (e) {ntttttcomponents.error = components.error || "Email address's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;ntttt}nnttttto = localPart + "@" + domain;nttt}nntttcomponents.path = to.join(",");ntt}nnttconst headers = mailtoComponents.headers = mailtoComponents.headers || {};nnttif (mailtoComponents.subject) headers = mailtoComponents.subject;nttif (mailtoComponents.body) headers = mailtoComponents.body;nnttconst fields = [];nttfor (const name in headers) {ntttif (headers !== O) {nttttfields.push(ntttttname.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) +nttttt"=" +ntttttheaders.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar)ntttt);nttt}ntt}nttif (fields.length) {ntttcomponents.query = fields.join("&");ntt}nnttreturn components;nt}n}nnexport default handler;“,”import { URIRegExps } from "./uri";nimport { buildExps } from "./regexps-uri";nnexport default buildExps(true);n“,”import { URISchemeHandler, URIComponents, URIOptions } from "../uri";nnconst handler:URISchemeHandler = {ntscheme : "http",nntdomainHost : true,nntparse : function (components:URIComponents, options:URIOptions):URIComponents {ntt//report missing hostnttif (!components.host) {ntttcomponents.error = components.error || "HTTP URIs must have a host.";ntt}nnttreturn components;nt},nntserialize : function (components:URIComponents, options:URIOptions):URIComponents {ntt//normalize the default portnttif (components.port === (String(components.scheme).toLowerCase() !== "https" ? 80 : 443) || components.port === "") {ntttcomponents.port = undefined;ntt}nttntt//normalize the empty pathnttif (!components.path) {ntttcomponents.path = "/";ntt}nntt//NOTE: We do not parse query strings for HTTP URIsntt//as WWW Form Url Encoded query strings are part of the HTML4+ spec,ntt//and not the HTTP spec.nnttreturn components;nt}n};nnexport default handler;“,”import { URISchemeHandler, URIComponents, URIOptions } from "../uri";nimport http from "./http";nnconst handler:URISchemeHandler = {ntscheme : "https",ntdomainHost : http.domainHost,ntparse : http.parse,ntserialize : http.serializen}nnexport default handler;“,”import { URISchemeHandler, URIComponents, URIOptions } from "../uri";nimport { pctEncChar, SCHEMES } from "../uri";nnexport interface URNComponents extends URIComponents {ntnid?:string;ntnss?:string;n}nnexport interface URNOptions extends URIOptions {ntnid?:string;n}nnconst NID$ = "(?:[0-9A-Za-z]{1,31})";nconst PCT_ENCODED$ = "(?:\\%[0-9A-Fa-f]{2})";nconst TRANS$$ = "[0-9A-Za-z\\(\\)\+\\,\\-\\.\\:\\=\\@\\;\\$\_\\!\*\\'\\/\\?\\#]";nconst NSS$ = "(?:(?:" + PCT_ENCODED$ + "|" + TRANS$$ + ")+)";nconst URN_SCHEME = new RegExp("^urn\\:(" + NID$ + ")$");nconst URN_PATH = new RegExp("^(" + NID$ + ")\\:(" + NSS$ + ")$");nconst URN_PARSE = /^([^\:]+)\:(.*)/;nconst URN_EXCLUDED = /[\x00-\x20\\\"\&<\>\\^\`\{\|\}\~\x7F-\xFF]/g;nn//RFC 2141nconst handler:URISchemeHandler<URNComponents,URNOptions> = {ntscheme : "urn",nntparse : function (components:URIComponents, options:URNOptions):URNComponents {nttconst matches = components.path && components.path.match(URN_PARSE);nttlet urnComponents = components as URNComponents;nnttif (matches) {ntttconst scheme = options.scheme || urnComponents.scheme || "urn";ntttconst nid = matches.toLowerCase();ntttconst nss = matches;ntttconst urnScheme = `${scheme}:${options.nid || nid}`;ntttconst schemeHandler = SCHEMES;nnttturnComponents.nid = nid;nttturnComponents.nss = nss;nttturnComponents.path = undefined;nntttif (schemeHandler) {ntttturnComponents = schemeHandler.parse(urnComponents, options) as URNComponents;nttt}ntt} else {nttturnComponents.error = urnComponents.error || "URN can not be parsed.";ntt}nnttreturn urnComponents;nt},nntserialize : function (urnComponents:URNComponents, options:URNOptions):URIComponents {nttconst scheme = options.scheme || urnComponents.scheme || "urn";nttconst nid = urnComponents.nid;nttconst urnScheme = `${scheme}:${options.nid || nid}`;nttconst schemeHandler = SCHEMES;nnttif (schemeHandler) {nttturnComponents = schemeHandler.serialize(urnComponents, options) as URNComponents;ntt}nnttconst uriComponents = urnComponents as URIComponents;nttconst nss = urnComponents.nss;ntturiComponents.path = `${nid || options.nid}:${nss}`;nnttreturn uriComponents;nt},n};nnexport default handler;“,”import { URISchemeHandler, URIComponents, URIOptions } from "../uri";nimport { URNComponents } from "./urn";nimport { SCHEMES } from "../uri";nnexport interface UUIDComponents extends URNComponents {ntuuid?: string;n}nnconst UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/;nconst UUID_PARSE = /^[0-9A-Fa-f\-]{36}/;nn//RFC 4122nconst handler:URISchemeHandler<UUIDComponents, URIOptions, URNComponents> = {ntscheme : "urn:uuid",nntparse : function (urnComponents:URNComponents, options:URIOptions):UUIDComponents {nttconst uuidComponents = urnComponents as UUIDComponents;nttuuidComponents.uuid = uuidComponents.nss;nttuuidComponents.nss = undefined;nnttif (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {ntttuuidComponents.error = uuidComponents.error || "UUID is not valid.";ntt}nnttreturn uuidComponents;nt},nntserialize : function (uuidComponents:UUIDComponents, options:URIOptions):URNComponents {nttconst urnComponents = uuidComponents as URNComponents;ntt//normalize UUIDntturnComponents.nss = (uuidComponents.uuid || "").toLowerCase();nttreturn urnComponents;nt},n};nnexport default handler;“,”import { SCHEMES } from "./uri";nnimport http from "./schemes/http";nSCHEMES = http;nnimport https from "./schemes/https";nSCHEMES = https;nnimport mailto from "./schemes/mailto";nSCHEMES = mailto;nnimport urn from "./schemes/urn";nSCHEMES = urn;nnimport uuid from "./schemes/urn-uuid";nSCHEMES = uuid;nnexport * from "./uri";n“]}