| /** @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 |
