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