{"version":3,"sources":["webpack://web/./node_modules/uri-js/dist/es5/uri.all.js"],"names":["exports","merge","_len","arguments","length","sets","Array","_key","slice","xl","x","join","subexp","str","typeOf","o","undefined","Object","prototype","toString","call","split","pop","shift","toLowerCase","toUpperCase","buildExps","isIRI","ALPHA$$","DIGIT$$","HEXDIG$$","PCT_ENCODED$","SUB_DELIMS$$","RESERVED$$","IPRIVATE$$","UNRESERVED$$","SCHEME$","USERINFO$","DEC_OCTET_RELAXED$","IPV4ADDRESS$","H16$","LS32$","IPV6ADDRESS1$","IPV6ADDRESS2$","IPV6ADDRESS3$","IPV6ADDRESS4$","IPV6ADDRESS5$","IPV6ADDRESS6$","IPV6ADDRESS7$","IPV6ADDRESS8$","IPV6ADDRESS9$","IPV6ADDRESS$","ZONEID$","IPV6ADDRZ_RELAXED$","IPVFUTURE$","IP_LITERAL$","REG_NAME$","HOST$","PORT$","AUTHORITY$","PCHAR$","SEGMENT$","SEGMENT_NZ$","SEGMENT_NZ_NC$","PATH_ABEMPTY$","PATH_ABSOLUTE$","PATH_NOSCHEME$","PATH_ROOTLESS$","PATH_EMPTY$","QUERY$","FRAGMENT$","HIER_PART$","URI$","RELATIVE_PART$","RELATIVE$","NOT_SCHEME","RegExp","NOT_USERINFO","NOT_HOST","NOT_PATH","NOT_PATH_NOSCHEME","NOT_QUERY","NOT_FRAGMENT","ESCAPE","UNRESERVED","OTHER_CHARS","PCT_ENCODED","IPV4ADDRESS","IPV6ADDRESS","URI_PROTOCOL","IRI_PROTOCOL","slicedToArray","arr","i","isArray","Symbol","iterator","_arr","_n","_d","_e","_s","_i","next","done","push","value","err","sliceIterator","TypeError","maxInt","base","regexPunycode","regexNonASCII","regexSeparators","errors","floor","Math","stringFromCharCode","String","fromCharCode","error$1","type","RangeError","mapDomain","string","fn","parts","result","array","map","replace","ucs2decode","output","counter","charCodeAt","extra","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","k","baseMinusTMin","decode","input","codePoint","inputLength","n","bias","basic","lastIndexOf","j","index","oldi","w","t","baseMinusT","out","splice","fromCodePoint","apply","encode","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","_currentValue2","return","basicLength","handledCPCount","m","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_step2","_iterator2","currentValue","handledCPCountPlusOne","_iteratorNormalCompletion3","_didIteratorError3","_iteratorError3","_step3","_iterator3","_currentValue","q","qMinusT","punycode","test","SCHEMES","pctEncChar","chr","c","pctDecChars","newStr","il","parseInt","substr","c2","_c","c3","_normalizeComponentEncoding","components","protocol","decodeUnreserved","decStr","match","scheme","userinfo","host","path","query","fragment","_stripLeadingZeros","_normalizeIPv4","matches","address","_normalizeIPv6","_matches2","zone","_address$toLowerCase$","reverse","_address$toLowerCase$2","last","first","firstFields","lastFields","isLastFieldIPv4Address","fieldCount","lastFieldsStart","fields","longestZeroFields","reduce","acc","field","lastLongest","sort","a","b","newHost","newFirst","newLast","URI_PARSE","NO_MATCH_IS_UNDEFINED","parse","uriString","options","iri","reference","port","isNaN","indexOf","error","schemeHandler","unicodeSupport","domainHost","e","_recomposeAuthority","uriTokens","_","$1","$2","RDS1","RDS2","RDS3","RDS5","removeDotSegments","im","Error","s","serialize","authority","charAt","absolutePath","resolveComponents","relative","target","tolerant","unescapeComponent","handler","secure","handler$1","isSecure","wsComponents","handler$2","resourceName","_wsComponents$resourc","_wsComponents$resourc2","handler$3","O","VCHAR$$","NOT_LOCAL_PART","NOT_HFNAME","NOT_HFVALUE","handler$4","mailtoComponents","to","unknownHeaders","headers","hfields","hfield","toAddrs","_x","_xl","subject","body","_x2","_xl2","addr","obj","setInterval","toAddr","atIdx","localPart","domain","name","URN_PARSE","handler$5","urnComponents","nid","nss","urnScheme","uriComponents","UUID","handler$6","uuidComponents","uuid","resolve","baseURI","relativeURI","schemelessOptions","source","key","assign","normalize","uri","equal","uriA","uriB","escapeComponent","defineProperty","factory"],"mappings":"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","file":"npm.uri-js.599a481957a8760d1aca.react.bundle.js","sourcesContent":["/** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(factory((global.URI = global.URI || {})));\n}(this, (function (exports) { 'use strict';\n\nfunction merge() {\n    for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {\n        sets[_key] = arguments[_key];\n    }\n\n    if (sets.length > 1) {\n        sets[0] = sets[0].slice(0, -1);\n        var xl = sets.length - 1;\n        for (var x = 1; x < xl; ++x) {\n            sets[x] = sets[x].slice(1, -1);\n        }\n        sets[xl] = sets[xl].slice(1);\n        return sets.join('');\n    } else {\n        return sets[0];\n    }\n}\nfunction subexp(str) {\n    return \"(?:\" + str + \")\";\n}\nfunction typeOf(o) {\n    return o === undefined ? \"undefined\" : o === null ? \"null\" : Object.prototype.toString.call(o).split(\" \").pop().split(\"]\").shift().toLowerCase();\n}\nfunction toUpperCase(str) {\n    return str.toUpperCase();\n}\nfunction toArray(obj) {\n    return 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}\nfunction assign(target, source) {\n    var obj = target;\n    if (source) {\n        for (var key in source) {\n            obj[key] = source[key];\n        }\n    }\n    return obj;\n}\n\nfunction buildExps(isIRI) {\n    var ALPHA$$ = \"[A-Za-z]\",\n        CR$ = \"[\\\\x0D]\",\n        DIGIT$$ = \"[0-9]\",\n        DQUOTE$$ = \"[\\\\x22]\",\n        HEXDIG$$ = merge(DIGIT$$, \"[A-Fa-f]\"),\n        //case-insensitive\n    LF$$ = \"[\\\\x0A]\",\n        SP$$ = \"[\\\\x20]\",\n        PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)),\n        //expanded\n    GEN_DELIMS$$ = \"[\\\\:\\\\/\\\\?\\\\#\\\\[\\\\]\\\\@]\",\n        SUB_DELIMS$$ = \"[\\\\!\\\\$\\\\&\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\=]\",\n        RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),\n        UCSCHAR$$ = isIRI ? \"[\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF]\" : \"[]\",\n        //subset, excludes bidi control characters\n    IPRIVATE$$ = isIRI ? \"[\\\\uE000-\\\\uF8FF]\" : \"[]\",\n        //subset\n    UNRESERVED$$ = merge(ALPHA$$, DIGIT$$, \"[\\\\-\\\\.\\\\_\\\\~]\", UCSCHAR$$),\n        SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\") + \"*\"),\n        USERINFO$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\")) + \"*\"),\n        DEC_OCTET$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"[1-9]\" + DIGIT$$) + \"|\" + DIGIT$$),\n        DEC_OCTET_RELAXED$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"0?[1-9]\" + DIGIT$$) + \"|0?0?\" + DIGIT$$),\n        //relaxed parsing rules\n    IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$),\n        H16$ = subexp(HEXDIG$$ + \"{1,4}\"),\n        LS32$ = subexp(subexp(H16$ + \"\\\\:\" + H16$) + \"|\" + IPV4ADDRESS$),\n        IPV6ADDRESS1$ = subexp(subexp(H16$ + \"\\\\:\") + \"{6}\" + LS32$),\n        //                           6( h16 \":\" ) ls32\n    IPV6ADDRESS2$ = subexp(\"\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{5}\" + LS32$),\n        //                      \"::\" 5( h16 \":\" ) ls32\n    IPV6ADDRESS3$ = subexp(subexp(H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{4}\" + LS32$),\n        //[               h16 ] \"::\" 4( h16 \":\" ) ls32\n    IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,1}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{3}\" + LS32$),\n        //[ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n    IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,2}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{2}\" + LS32$),\n        //[ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n    IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,3}\" + H16$) + \"?\\\\:\\\\:\" + H16$ + \"\\\\:\" + LS32$),\n        //[ *3( h16 \":\" ) h16 ] \"::\"    h16 \":\"   ls32\n    IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,4}\" + H16$) + \"?\\\\:\\\\:\" + LS32$),\n        //[ *4( h16 \":\" ) h16 ] \"::\"              ls32\n    IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,5}\" + H16$) + \"?\\\\:\\\\:\" + H16$),\n        //[ *5( h16 \":\" ) h16 ] \"::\"              h16\n    IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,6}\" + H16$) + \"?\\\\:\\\\:\"),\n        //[ *6( h16 \":\" ) h16 ] \"::\"\n    IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join(\"|\")),\n        ZONEID$ = subexp(subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$) + \"+\"),\n        //RFC 6874\n    IPV6ADDRZ$ = subexp(IPV6ADDRESS$ + \"\\\\%25\" + ZONEID$),\n        //RFC 6874\n    IPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + ZONEID$),\n        //RFC 6874, with relaxed parsing rules\n    IPVFUTURE$ = subexp(\"[vV]\" + HEXDIG$$ + \"+\\\\.\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\") + \"+\"),\n        IP_LITERAL$ = subexp(\"\\\\[\" + subexp(IPV6ADDRZ_RELAXED$ + \"|\" + IPV6ADDRESS$ + \"|\" + IPVFUTURE$) + \"\\\\]\"),\n        //RFC 6874\n    REG_NAME$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$)) + \"*\"),\n        HOST$ = subexp(IP_LITERAL$ + \"|\" + IPV4ADDRESS$ + \"(?!\" + REG_NAME$ + \")\" + \"|\" + REG_NAME$),\n        PORT$ = subexp(DIGIT$$ + \"*\"),\n        AUTHORITY$ = subexp(subexp(USERINFO$ + \"@\") + \"?\" + HOST$ + subexp(\"\\\\:\" + PORT$) + \"?\"),\n        PCHAR$ = subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@]\")),\n        SEGMENT$ = subexp(PCHAR$ + \"*\"),\n        SEGMENT_NZ$ = subexp(PCHAR$ + \"+\"),\n        SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\@]\")) + \"+\"),\n        PATH_ABEMPTY$ = subexp(subexp(\"\\\\/\" + SEGMENT$) + \"*\"),\n        PATH_ABSOLUTE$ = subexp(\"\\\\/\" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + \"?\"),\n        //simplified\n    PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$),\n        //simplified\n    PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$),\n        //simplified\n    PATH_EMPTY$ = \"(?!\" + PCHAR$ + \")\",\n        PATH$ = subexp(PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n        QUERY$ = subexp(subexp(PCHAR$ + \"|\" + merge(\"[\\\\/\\\\?]\", IPRIVATE$$)) + \"*\"),\n        FRAGMENT$ = subexp(subexp(PCHAR$ + \"|[\\\\/\\\\?]\") + \"*\"),\n        HIER_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n        URI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n        RELATIVE_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$),\n        RELATIVE$ = subexp(RELATIVE_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n        URI_REFERENCE$ = subexp(URI$ + \"|\" + RELATIVE$),\n        ABSOLUTE_URI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\"),\n        GENERIC_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n        RELATIVE_REF$ = \"^(){0}\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n        ABSOLUTE_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?$\",\n        SAMEDOC_REF$ = \"^\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n        AUTHORITY_REF$ = \"^\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?$\";\n    return {\n        NOT_SCHEME: new RegExp(merge(\"[^]\", ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\"), \"g\"),\n        NOT_USERINFO: new RegExp(merge(\"[^\\\\%\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_HOST: new RegExp(merge(\"[^\\\\%\\\\[\\\\]\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_PATH: new RegExp(merge(\"[^\\\\%\\\\/\\\\:\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_PATH_NOSCHEME: new RegExp(merge(\"[^\\\\%\\\\/\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_QUERY: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\", IPRIVATE$$), \"g\"),\n        NOT_FRAGMENT: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\"), \"g\"),\n        ESCAPE: new RegExp(merge(\"[^]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        UNRESERVED: new RegExp(UNRESERVED$$, \"g\"),\n        OTHER_CHARS: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, RESERVED$$), \"g\"),\n        PCT_ENCODED: new RegExp(PCT_ENCODED$, \"g\"),\n        IPV4ADDRESS: new RegExp(\"^(\" + IPV4ADDRESS$ + \")$\"),\n        IPV6ADDRESS: new RegExp(\"^\\\\[?(\" + IPV6ADDRESS$ + \")\" + subexp(subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + \"(\" + ZONEID$ + \")\") + \"?\\\\]?$\") //RFC 6874, with relaxed parsing rules\n    };\n}\nvar URI_PROTOCOL = buildExps(false);\n\nvar IRI_PROTOCOL = buildExps(true);\n\nvar slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar toConsumableArray = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n};\n\n/** Highest positive signed 32-bit float value */\n\nvar maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nvar base = 36;\nvar tMin = 1;\nvar tMax = 26;\nvar skew = 38;\nvar damp = 700;\nvar initialBias = 72;\nvar initialN = 128; // 0x80\nvar delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nvar regexPunycode = /^xn--/;\nvar regexNonASCII = /[^\\0-\\x7E]/; // non-ASCII chars\nvar regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nvar errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nvar baseMinusTMin = base - tMin;\nvar floor = Math.floor;\nvar stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error$1(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, fn) {\n\tvar result = [];\n\tvar length = array.length;\n\twhile (length--) {\n\t\tresult[length] = fn(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {Array} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(string, fn) {\n\tvar parts = string.split('@');\n\tvar result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tstring = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tstring = string.replace(regexSeparators, '\\x2E');\n\tvar labels = string.split('.');\n\tvar encoded = map(labels, fn).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tvar output = [];\n\tvar counter = 0;\n\tvar length = string.length;\n\twhile (counter < length) {\n\t\tvar value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tvar extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) {\n\t\t\t\t// Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nvar ucs2encode = function ucs2encode(array) {\n\treturn String.fromCodePoint.apply(String, toConsumableArray(array));\n};\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nvar basicToDigit = function basicToDigit(codePoint) {\n\tif (codePoint - 0x30 < 0x0A) {\n\t\treturn codePoint - 0x16;\n\t}\n\tif (codePoint - 0x41 < 0x1A) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint - 0x61 < 0x1A) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nvar digitToBasic = function digitToBasic(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nvar adapt = function adapt(delta, numPoints, firstTime) {\n\tvar k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (; /* no initialization */delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nvar decode = function decode(input) {\n\t// Don't use UCS-2.\n\tvar output = [];\n\tvar inputLength = input.length;\n\tvar i = 0;\n\tvar n = initialN;\n\tvar bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tvar basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (var j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror$1('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (var index = basic > 0 ? basic + 1 : 0; index < inputLength;) /* no final expression */{\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tvar oldi = i;\n\t\tfor (var w = 1, k = base;; /* no condition */k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror$1('invalid-input');\n\t\t\t}\n\n\t\t\tvar digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\terror$1('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tvar t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror$1('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\t\t}\n\n\t\tvar out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror$1('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\t}\n\n\treturn String.fromCodePoint.apply(String, output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nvar encode = function encode(input) {\n\tvar output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tvar inputLength = input.length;\n\n\t// Initialize the state.\n\tvar n = initialN;\n\tvar delta = 0;\n\tvar bias = initialBias;\n\n\t// Handle the basic code points.\n\tvar _iteratorNormalCompletion = true;\n\tvar _didIteratorError = false;\n\tvar _iteratorError = undefined;\n\n\ttry {\n\t\tfor (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n\t\t\tvar _currentValue2 = _step.value;\n\n\t\t\tif (_currentValue2 < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(_currentValue2));\n\t\t\t}\n\t\t}\n\t} catch (err) {\n\t\t_didIteratorError = true;\n\t\t_iteratorError = err;\n\t} finally {\n\t\ttry {\n\t\t\tif (!_iteratorNormalCompletion && _iterator.return) {\n\t\t\t\t_iterator.return();\n\t\t\t}\n\t\t} finally {\n\t\t\tif (_didIteratorError) {\n\t\t\t\tthrow _iteratorError;\n\t\t\t}\n\t\t}\n\t}\n\n\tvar basicLength = output.length;\n\tvar handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tvar m = maxInt;\n\t\tvar _iteratorNormalCompletion2 = true;\n\t\tvar _didIteratorError2 = false;\n\t\tvar _iteratorError2 = undefined;\n\n\t\ttry {\n\t\t\tfor (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n\t\t\t\tvar currentValue = _step2.value;\n\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow.\n\t\t} catch (err) {\n\t\t\t_didIteratorError2 = true;\n\t\t\t_iteratorError2 = err;\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\tif (!_iteratorNormalCompletion2 && _iterator2.return) {\n\t\t\t\t\t_iterator2.return();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tif (_didIteratorError2) {\n\t\t\t\t\tthrow _iteratorError2;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tvar handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror$1('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tvar _iteratorNormalCompletion3 = true;\n\t\tvar _didIteratorError3 = false;\n\t\tvar _iteratorError3 = undefined;\n\n\t\ttry {\n\t\t\tfor (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n\t\t\t\tvar _currentValue = _step3.value;\n\n\t\t\t\tif (_currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror$1('overflow');\n\t\t\t\t}\n\t\t\t\tif (_currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\t\tvar q = delta;\n\t\t\t\t\tfor (var k = base;; /* no condition */k += base) {\n\t\t\t\t\t\tvar t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tvar qMinusT = q - t;\n\t\t\t\t\t\tvar baseMinusT = base - t;\n\t\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (err) {\n\t\t\t_didIteratorError3 = true;\n\t\t\t_iteratorError3 = err;\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\tif (!_iteratorNormalCompletion3 && _iterator3.return) {\n\t\t\t\t\t_iterator3.return();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tif (_didIteratorError3) {\n\t\t\t\t\tthrow _iteratorError3;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * 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 been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nvar toUnicode = function toUnicode(input) {\n\treturn mapDomain(input, function (string) {\n\t\treturn regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * 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 in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nvar toASCII = function toASCII(input) {\n\treturn mapDomain(input, function (string) {\n\t\treturn regexNonASCII.test(string) ? 'xn--' + encode(string) : string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nvar punycode = {\n\t/**\n  * A string representing the current Punycode.js version number.\n  * @memberOf punycode\n  * @type String\n  */\n\t'version': '2.1.0',\n\t/**\n  * An object of methods to convert from JavaScript's internal character\n  * representation (UCS-2) to Unicode code points, and back.\n  * @see <https://mathiasbynens.be/notes/javascript-encoding>\n  * @memberOf punycode\n  * @type Object\n  */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\n/**\n * URI.js\n *\n * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/uri-js\n */\n/**\n * Copyright 2011 Gary Court. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are\n * permitted provided that the following conditions are met:\n *\n *    1. Redistributions of source code must retain the above copyright notice, this list of\n *       conditions and the following disclaimer.\n *\n *    2. Redistributions in binary form must reproduce the above copyright notice, this list\n *       of conditions and the following disclaimer in the documentation and/or other materials\n *       provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED\n * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND\n * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * The views and conclusions contained in the software and documentation are those of the\n * authors and should not be interpreted as representing official policies, either expressed\n * or implied, of Gary Court.\n */\nvar SCHEMES = {};\nfunction pctEncChar(chr) {\n    var c = chr.charCodeAt(0);\n    var e = void 0;\n    if (c < 16) e = \"%0\" + c.toString(16).toUpperCase();else if (c < 128) e = \"%\" + c.toString(16).toUpperCase();else if (c < 2048) e = \"%\" + (c >> 6 | 192).toString(16).toUpperCase() + \"%\" + (c & 63 | 128).toString(16).toUpperCase();else e = \"%\" + (c >> 12 | 224).toString(16).toUpperCase() + \"%\" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + \"%\" + (c & 63 | 128).toString(16).toUpperCase();\n    return e;\n}\nfunction pctDecChars(str) {\n    var newStr = \"\";\n    var i = 0;\n    var il = str.length;\n    while (i < il) {\n        var c = parseInt(str.substr(i + 1, 2), 16);\n        if (c < 128) {\n            newStr += String.fromCharCode(c);\n            i += 3;\n        } else if (c >= 194 && c < 224) {\n            if (il - i >= 6) {\n                var c2 = parseInt(str.substr(i + 4, 2), 16);\n                newStr += String.fromCharCode((c & 31) << 6 | c2 & 63);\n            } else {\n                newStr += str.substr(i, 6);\n            }\n            i += 6;\n        } else if (c >= 224) {\n            if (il - i >= 9) {\n                var _c = parseInt(str.substr(i + 4, 2), 16);\n                var c3 = parseInt(str.substr(i + 7, 2), 16);\n                newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63);\n            } else {\n                newStr += str.substr(i, 9);\n            }\n            i += 9;\n        } else {\n            newStr += str.substr(i, 3);\n            i += 3;\n        }\n    }\n    return newStr;\n}\nfunction _normalizeComponentEncoding(components, protocol) {\n    function decodeUnreserved(str) {\n        var decStr = pctDecChars(str);\n        return !decStr.match(protocol.UNRESERVED) ? str : decStr;\n    }\n    if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, \"\");\n    if (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (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);\n    if (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    return components;\n}\n\nfunction _stripLeadingZeros(str) {\n    return str.replace(/^0*(.*)/, \"$1\") || \"0\";\n}\nfunction _normalizeIPv4(host, protocol) {\n    var matches = host.match(protocol.IPV4ADDRESS) || [];\n\n    var _matches = slicedToArray(matches, 2),\n        address = _matches[1];\n\n    if (address) {\n        return address.split(\".\").map(_stripLeadingZeros).join(\".\");\n    } else {\n        return host;\n    }\n}\nfunction _normalizeIPv6(host, protocol) {\n    var matches = host.match(protocol.IPV6ADDRESS) || [];\n\n    var _matches2 = slicedToArray(matches, 3),\n        address = _matches2[1],\n        zone = _matches2[2];\n\n    if (address) {\n        var _address$toLowerCase$ = address.toLowerCase().split('::').reverse(),\n            _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2),\n            last = _address$toLowerCase$2[0],\n            first = _address$toLowerCase$2[1];\n\n        var firstFields = first ? first.split(\":\").map(_stripLeadingZeros) : [];\n        var lastFields = last.split(\":\").map(_stripLeadingZeros);\n        var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);\n        var fieldCount = isLastFieldIPv4Address ? 7 : 8;\n        var lastFieldsStart = lastFields.length - fieldCount;\n        var fields = Array(fieldCount);\n        for (var x = 0; x < fieldCount; ++x) {\n            fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';\n        }\n        if (isLastFieldIPv4Address) {\n            fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);\n        }\n        var allZeroFields = fields.reduce(function (acc, field, index) {\n            if (!field || field === \"0\") {\n                var lastLongest = acc[acc.length - 1];\n                if (lastLongest && lastLongest.index + lastLongest.length === index) {\n                    lastLongest.length++;\n                } else {\n                    acc.push({ index: index, length: 1 });\n                }\n            }\n            return acc;\n        }, []);\n        var longestZeroFields = allZeroFields.sort(function (a, b) {\n            return b.length - a.length;\n        })[0];\n        var newHost = void 0;\n        if (longestZeroFields && longestZeroFields.length > 1) {\n            var newFirst = fields.slice(0, longestZeroFields.index);\n            var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);\n            newHost = newFirst.join(\":\") + \"::\" + newLast.join(\":\");\n        } else {\n            newHost = fields.join(\":\");\n        }\n        if (zone) {\n            newHost += \"%\" + zone;\n        }\n        return newHost;\n    } else {\n        return host;\n    }\n}\nvar URI_PARSE = /^(?:([^:\\/?#]+):)?(?:\\/\\/((?:([^\\/?#@]*)@)?(\\[[^\\/?#\\]]+\\]|[^\\/?#:]*)(?:\\:(\\d*))?))?([^?#]*)(?:\\?([^#]*))?(?:#((?:.|\\n|\\r)*))?/i;\nvar NO_MATCH_IS_UNDEFINED = \"\".match(/(){0}/)[1] === undefined;\nfunction parse(uriString) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var components = {};\n    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;\n    if (options.reference === \"suffix\") uriString = (options.scheme ? options.scheme + \":\" : \"\") + \"//\" + uriString;\n    var matches = uriString.match(URI_PARSE);\n    if (matches) {\n        if (NO_MATCH_IS_UNDEFINED) {\n            //store each component\n            components.scheme = matches[1];\n            components.userinfo = matches[3];\n            components.host = matches[4];\n            components.port = parseInt(matches[5], 10);\n            components.path = matches[6] || \"\";\n            components.query = matches[7];\n            components.fragment = matches[8];\n            //fix port number\n            if (isNaN(components.port)) {\n                components.port = matches[5];\n            }\n        } else {\n            //IE FIX for improper RegExp matching\n            //store each component\n            components.scheme = matches[1] || undefined;\n            components.userinfo = uriString.indexOf(\"@\") !== -1 ? matches[3] : undefined;\n            components.host = uriString.indexOf(\"//\") !== -1 ? matches[4] : undefined;\n            components.port = parseInt(matches[5], 10);\n            components.path = matches[6] || \"\";\n            components.query = uriString.indexOf(\"?\") !== -1 ? matches[7] : undefined;\n            components.fragment = uriString.indexOf(\"#\") !== -1 ? matches[8] : undefined;\n            //fix port number\n            if (isNaN(components.port)) {\n                components.port = uriString.match(/\\/\\/(?:.|\\n)*\\:(?:\\/|\\?|\\#|$)/) ? matches[4] : undefined;\n            }\n        }\n        if (components.host) {\n            //normalize IP hosts\n            components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);\n        }\n        //determine reference type\n        if (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {\n            components.reference = \"same-document\";\n        } else if (components.scheme === undefined) {\n            components.reference = \"relative\";\n        } else if (components.fragment === undefined) {\n            components.reference = \"absolute\";\n        } else {\n            components.reference = \"uri\";\n        }\n        //check for reference errors\n        if (options.reference && options.reference !== \"suffix\" && options.reference !== components.reference) {\n            components.error = components.error || \"URI is not a \" + options.reference + \" reference.\";\n        }\n        //find scheme handler\n        var schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n        //check if scheme can't handle IRIs\n        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n            //if host component is a domain name\n            if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) {\n                //convert Unicode IDN -> ASCII IDN\n                try {\n                    components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());\n                } catch (e) {\n                    components.error = components.error || \"Host's domain name can not be converted to ASCII via punycode: \" + e;\n                }\n            }\n            //convert IRI -> URI\n            _normalizeComponentEncoding(components, URI_PROTOCOL);\n        } else {\n            //normalize encodings\n            _normalizeComponentEncoding(components, protocol);\n        }\n        //perform scheme specific parsing\n        if (schemeHandler && schemeHandler.parse) {\n            schemeHandler.parse(components, options);\n        }\n    } else {\n        components.error = components.error || \"URI can not be parsed.\";\n    }\n    return components;\n}\n\nfunction _recomposeAuthority(components, options) {\n    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;\n    var uriTokens = [];\n    if (components.userinfo !== undefined) {\n        uriTokens.push(components.userinfo);\n        uriTokens.push(\"@\");\n    }\n    if (components.host !== undefined) {\n        //normalize IP hosts, add brackets and escape zone separator for IPv6\n        uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function (_, $1, $2) {\n            return \"[\" + $1 + ($2 ? \"%25\" + $2 : \"\") + \"]\";\n        }));\n    }\n    if (typeof components.port === \"number\" || typeof components.port === \"string\") {\n        uriTokens.push(\":\");\n        uriTokens.push(String(components.port));\n    }\n    return uriTokens.length ? uriTokens.join(\"\") : undefined;\n}\n\nvar RDS1 = /^\\.\\.?\\//;\nvar RDS2 = /^\\/\\.(\\/|$)/;\nvar RDS3 = /^\\/\\.\\.(\\/|$)/;\nvar RDS5 = /^\\/?(?:.|\\n)*?(?=\\/|$)/;\nfunction removeDotSegments(input) {\n    var output = [];\n    while (input.length) {\n        if (input.match(RDS1)) {\n            input = input.replace(RDS1, \"\");\n        } else if (input.match(RDS2)) {\n            input = input.replace(RDS2, \"/\");\n        } else if (input.match(RDS3)) {\n            input = input.replace(RDS3, \"/\");\n            output.pop();\n        } else if (input === \".\" || input === \"..\") {\n            input = \"\";\n        } else {\n            var im = input.match(RDS5);\n            if (im) {\n                var s = im[0];\n                input = input.slice(s.length);\n                output.push(s);\n            } else {\n                throw new Error(\"Unexpected dot segment condition\");\n            }\n        }\n    }\n    return output.join(\"\");\n}\n\nfunction serialize(components) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL;\n    var uriTokens = [];\n    //find scheme handler\n    var schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n    //perform scheme specific serialization\n    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);\n    if (components.host) {\n        //if host component is an IPv6 address\n        if (protocol.IPV6ADDRESS.test(components.host)) {}\n        //TODO: normalize IPv6 address as per RFC 5952\n\n        //if host component is a domain name\n        else if (options.domainHost || schemeHandler && schemeHandler.domainHost) {\n                //convert IDN via punycode\n                try {\n                    components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);\n                } catch (e) {\n                    components.error = components.error || \"Host's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n                }\n            }\n    }\n    //normalize encoding\n    _normalizeComponentEncoding(components, protocol);\n    if (options.reference !== \"suffix\" && components.scheme) {\n        uriTokens.push(components.scheme);\n        uriTokens.push(\":\");\n    }\n    var authority = _recomposeAuthority(components, options);\n    if (authority !== undefined) {\n        if (options.reference !== \"suffix\") {\n            uriTokens.push(\"//\");\n        }\n        uriTokens.push(authority);\n        if (components.path && components.path.charAt(0) !== \"/\") {\n            uriTokens.push(\"/\");\n        }\n    }\n    if (components.path !== undefined) {\n        var s = components.path;\n        if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n            s = removeDotSegments(s);\n        }\n        if (authority === undefined) {\n            s = s.replace(/^\\/\\//, \"/%2F\"); //don't allow the path to start with \"//\"\n        }\n        uriTokens.push(s);\n    }\n    if (components.query !== undefined) {\n        uriTokens.push(\"?\");\n        uriTokens.push(components.query);\n    }\n    if (components.fragment !== undefined) {\n        uriTokens.push(\"#\");\n        uriTokens.push(components.fragment);\n    }\n    return uriTokens.join(\"\"); //merge tokens into a string\n}\n\nfunction resolveComponents(base, relative) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var skipNormalization = arguments[3];\n\n    var target = {};\n    if (!skipNormalization) {\n        base = parse(serialize(base, options), options); //normalize base components\n        relative = parse(serialize(relative, options), options); //normalize relative components\n    }\n    options = options || {};\n    if (!options.tolerant && relative.scheme) {\n        target.scheme = relative.scheme;\n        //target.authority = relative.authority;\n        target.userinfo = relative.userinfo;\n        target.host = relative.host;\n        target.port = relative.port;\n        target.path = removeDotSegments(relative.path || \"\");\n        target.query = relative.query;\n    } else {\n        if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n            //target.authority = relative.authority;\n            target.userinfo = relative.userinfo;\n            target.host = relative.host;\n            target.port = relative.port;\n            target.path = removeDotSegments(relative.path || \"\");\n            target.query = relative.query;\n        } else {\n            if (!relative.path) {\n                target.path = base.path;\n                if (relative.query !== undefined) {\n                    target.query = relative.query;\n                } else {\n                    target.query = base.query;\n                }\n            } else {\n                if (relative.path.charAt(0) === \"/\") {\n                    target.path = removeDotSegments(relative.path);\n                } else {\n                    if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n                        target.path = \"/\" + relative.path;\n                    } else if (!base.path) {\n                        target.path = relative.path;\n                    } else {\n                        target.path = base.path.slice(0, base.path.lastIndexOf(\"/\") + 1) + relative.path;\n                    }\n                    target.path = removeDotSegments(target.path);\n                }\n                target.query = relative.query;\n            }\n            //target.authority = base.authority;\n            target.userinfo = base.userinfo;\n            target.host = base.host;\n            target.port = base.port;\n        }\n        target.scheme = base.scheme;\n    }\n    target.fragment = relative.fragment;\n    return target;\n}\n\nfunction resolve(baseURI, relativeURI, options) {\n    var schemelessOptions = assign({ scheme: 'null' }, options);\n    return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);\n}\n\nfunction normalize(uri, options) {\n    if (typeof uri === \"string\") {\n        uri = serialize(parse(uri, options), options);\n    } else if (typeOf(uri) === \"object\") {\n        uri = parse(serialize(uri, options), options);\n    }\n    return uri;\n}\n\nfunction equal(uriA, uriB, options) {\n    if (typeof uriA === \"string\") {\n        uriA = serialize(parse(uriA, options), options);\n    } else if (typeOf(uriA) === \"object\") {\n        uriA = serialize(uriA, options);\n    }\n    if (typeof uriB === \"string\") {\n        uriB = serialize(parse(uriB, options), options);\n    } else if (typeOf(uriB) === \"object\") {\n        uriB = serialize(uriB, options);\n    }\n    return uriA === uriB;\n}\n\nfunction escapeComponent(str, options) {\n    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);\n}\n\nfunction unescapeComponent(str, options) {\n    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);\n}\n\nvar handler = {\n    scheme: \"http\",\n    domainHost: true,\n    parse: function parse(components, options) {\n        //report missing host\n        if (!components.host) {\n            components.error = components.error || \"HTTP URIs must have a host.\";\n        }\n        return components;\n    },\n    serialize: function serialize(components, options) {\n        var secure = String(components.scheme).toLowerCase() === \"https\";\n        //normalize the default port\n        if (components.port === (secure ? 443 : 80) || components.port === \"\") {\n            components.port = undefined;\n        }\n        //normalize the empty path\n        if (!components.path) {\n            components.path = \"/\";\n        }\n        //NOTE: We do not parse query strings for HTTP URIs\n        //as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n        //and not the HTTP spec.\n        return components;\n    }\n};\n\nvar handler$1 = {\n    scheme: \"https\",\n    domainHost: handler.domainHost,\n    parse: handler.parse,\n    serialize: handler.serialize\n};\n\nfunction isSecure(wsComponents) {\n    return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === \"wss\";\n}\n//RFC 6455\nvar handler$2 = {\n    scheme: \"ws\",\n    domainHost: true,\n    parse: function parse(components, options) {\n        var wsComponents = components;\n        //indicate if the secure flag is set\n        wsComponents.secure = isSecure(wsComponents);\n        //construct resouce name\n        wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');\n        wsComponents.path = undefined;\n        wsComponents.query = undefined;\n        return wsComponents;\n    },\n    serialize: function serialize(wsComponents, options) {\n        //normalize the default port\n        if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === \"\") {\n            wsComponents.port = undefined;\n        }\n        //ensure scheme matches secure flag\n        if (typeof wsComponents.secure === 'boolean') {\n            wsComponents.scheme = wsComponents.secure ? 'wss' : 'ws';\n            wsComponents.secure = undefined;\n        }\n        //reconstruct path from resource name\n        if (wsComponents.resourceName) {\n            var _wsComponents$resourc = wsComponents.resourceName.split('?'),\n                _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2),\n                path = _wsComponents$resourc2[0],\n                query = _wsComponents$resourc2[1];\n\n            wsComponents.path = path && path !== '/' ? path : undefined;\n            wsComponents.query = query;\n            wsComponents.resourceName = undefined;\n        }\n        //forbid fragment component\n        wsComponents.fragment = undefined;\n        return wsComponents;\n    }\n};\n\nvar handler$3 = {\n    scheme: \"wss\",\n    domainHost: handler$2.domainHost,\n    parse: handler$2.parse,\n    serialize: handler$2.serialize\n};\n\nvar O = {};\nvar isIRI = true;\n//RFC 3986\nvar UNRESERVED$$ = \"[A-Za-z0-9\\\\-\\\\.\\\\_\\\\~\" + (isIRI ? \"\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF\" : \"\") + \"]\";\nvar HEXDIG$$ = \"[0-9A-Fa-f]\"; //case-insensitive\nvar PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)); //expanded\n//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(\"[\\\\x21\\\\x23-\\\\x5B\\\\x5D-\\\\x7E]\", OBS_QTEXT$$);  //%d33 / %d35-91 / %d93-126 / obs-qtext\n//const VCHAR$$ = \"[\\\\x21-\\\\x7E]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QP$ = subexp(\"\\\\\\\\\" + merge(\"[\\\\x00\\\\x0D\\\\x0A]\", OBS_QTEXT$$));  //%d0 / CR / LF / obs-qtext\n//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$ + \"?\" + '\\\\\"');\nvar ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\$\\\\%\\\\'\\\\*\\\\+\\\\-\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\nvar QTEXT$$ = \"[\\\\!\\\\$\\\\%\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\-\\\\.0-9\\\\<\\\\>A-Z\\\\x5E-\\\\x7E]\";\nvar VCHAR$$ = merge(QTEXT$$, \"[\\\\\\\"\\\\\\\\]\");\nvar SOME_DELIMS$$ = \"[\\\\!\\\\$\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\:\\\\@]\";\nvar UNRESERVED = new RegExp(UNRESERVED$$, \"g\");\nvar PCT_ENCODED = new RegExp(PCT_ENCODED$, \"g\");\nvar NOT_LOCAL_PART = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", '[\\\\\"]', VCHAR$$), \"g\");\nvar NOT_HFNAME = new RegExp(merge(\"[^]\", UNRESERVED$$, SOME_DELIMS$$), \"g\");\nvar NOT_HFVALUE = NOT_HFNAME;\nfunction decodeUnreserved(str) {\n    var decStr = pctDecChars(str);\n    return !decStr.match(UNRESERVED) ? str : decStr;\n}\nvar handler$4 = {\n    scheme: \"mailto\",\n    parse: function parse$$1(components, options) {\n        var mailtoComponents = components;\n        var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(\",\") : [];\n        mailtoComponents.path = undefined;\n        if (mailtoComponents.query) {\n            var unknownHeaders = false;\n            var headers = {};\n            var hfields = mailtoComponents.query.split(\"&\");\n            for (var x = 0, xl = hfields.length; x < xl; ++x) {\n                var hfield = hfields[x].split(\"=\");\n                switch (hfield[0]) {\n                    case \"to\":\n                        var toAddrs = hfield[1].split(\",\");\n                        for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {\n                            to.push(toAddrs[_x]);\n                        }\n                        break;\n                    case \"subject\":\n                        mailtoComponents.subject = unescapeComponent(hfield[1], options);\n                        break;\n                    case \"body\":\n                        mailtoComponents.body = unescapeComponent(hfield[1], options);\n                        break;\n                    default:\n                        unknownHeaders = true;\n                        headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);\n                        break;\n                }\n            }\n            if (unknownHeaders) mailtoComponents.headers = headers;\n        }\n        mailtoComponents.query = undefined;\n        for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {\n            var addr = to[_x2].split(\"@\");\n            addr[0] = unescapeComponent(addr[0]);\n            if (!options.unicodeSupport) {\n                //convert Unicode IDN -> ASCII IDN\n                try {\n                    addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());\n                } catch (e) {\n                    mailtoComponents.error = mailtoComponents.error || \"Email address's domain name can not be converted to ASCII via punycode: \" + e;\n                }\n            } else {\n                addr[1] = unescapeComponent(addr[1], options).toLowerCase();\n            }\n            to[_x2] = addr.join(\"@\");\n        }\n        return mailtoComponents;\n    },\n    serialize: function serialize$$1(mailtoComponents, options) {\n        var components = mailtoComponents;\n        var to = toArray(mailtoComponents.to);\n        if (to) {\n            for (var x = 0, xl = to.length; x < xl; ++x) {\n                var toAddr = String(to[x]);\n                var atIdx = toAddr.lastIndexOf(\"@\");\n                var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);\n                var domain = toAddr.slice(atIdx + 1);\n                //convert IDN via punycode\n                try {\n                    domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain);\n                } catch (e) {\n                    components.error = components.error || \"Email address's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n                }\n                to[x] = localPart + \"@\" + domain;\n            }\n            components.path = to.join(\",\");\n        }\n        var headers = mailtoComponents.headers = mailtoComponents.headers || {};\n        if (mailtoComponents.subject) headers[\"subject\"] = mailtoComponents.subject;\n        if (mailtoComponents.body) headers[\"body\"] = mailtoComponents.body;\n        var fields = [];\n        for (var name in headers) {\n            if (headers[name] !== O[name]) {\n                fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + \"=\" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar));\n            }\n        }\n        if (fields.length) {\n            components.query = fields.join(\"&\");\n        }\n        return components;\n    }\n};\n\nvar URN_PARSE = /^([^\\:]+)\\:(.*)/;\n//RFC 2141\nvar handler$5 = {\n    scheme: \"urn\",\n    parse: function parse$$1(components, options) {\n        var matches = components.path && components.path.match(URN_PARSE);\n        var urnComponents = components;\n        if (matches) {\n            var scheme = options.scheme || urnComponents.scheme || \"urn\";\n            var nid = matches[1].toLowerCase();\n            var nss = matches[2];\n            var urnScheme = scheme + \":\" + (options.nid || nid);\n            var schemeHandler = SCHEMES[urnScheme];\n            urnComponents.nid = nid;\n            urnComponents.nss = nss;\n            urnComponents.path = undefined;\n            if (schemeHandler) {\n                urnComponents = schemeHandler.parse(urnComponents, options);\n            }\n        } else {\n            urnComponents.error = urnComponents.error || \"URN can not be parsed.\";\n        }\n        return urnComponents;\n    },\n    serialize: function serialize$$1(urnComponents, options) {\n        var scheme = options.scheme || urnComponents.scheme || \"urn\";\n        var nid = urnComponents.nid;\n        var urnScheme = scheme + \":\" + (options.nid || nid);\n        var schemeHandler = SCHEMES[urnScheme];\n        if (schemeHandler) {\n            urnComponents = schemeHandler.serialize(urnComponents, options);\n        }\n        var uriComponents = urnComponents;\n        var nss = urnComponents.nss;\n        uriComponents.path = (nid || options.nid) + \":\" + nss;\n        return uriComponents;\n    }\n};\n\nvar UUID = /^[0-9A-Fa-f]{8}(?:\\-[0-9A-Fa-f]{4}){3}\\-[0-9A-Fa-f]{12}$/;\n//RFC 4122\nvar handler$6 = {\n    scheme: \"urn:uuid\",\n    parse: function parse(urnComponents, options) {\n        var uuidComponents = urnComponents;\n        uuidComponents.uuid = uuidComponents.nss;\n        uuidComponents.nss = undefined;\n        if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {\n            uuidComponents.error = uuidComponents.error || \"UUID is not valid.\";\n        }\n        return uuidComponents;\n    },\n    serialize: function serialize(uuidComponents, options) {\n        var urnComponents = uuidComponents;\n        //normalize UUID\n        urnComponents.nss = (uuidComponents.uuid || \"\").toLowerCase();\n        return urnComponents;\n    }\n};\n\nSCHEMES[handler.scheme] = handler;\nSCHEMES[handler$1.scheme] = handler$1;\nSCHEMES[handler$2.scheme] = handler$2;\nSCHEMES[handler$3.scheme] = handler$3;\nSCHEMES[handler$4.scheme] = handler$4;\nSCHEMES[handler$5.scheme] = handler$5;\nSCHEMES[handler$6.scheme] = handler$6;\n\nexports.SCHEMES = SCHEMES;\nexports.pctEncChar = pctEncChar;\nexports.pctDecChars = pctDecChars;\nexports.parse = parse;\nexports.removeDotSegments = removeDotSegments;\nexports.serialize = serialize;\nexports.resolveComponents = resolveComponents;\nexports.resolve = resolve;\nexports.normalize = normalize;\nexports.equal = equal;\nexports.escapeComponent = escapeComponent;\nexports.unescapeComponent = unescapeComponent;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=uri.all.js.map\n"],"sourceRoot":""}