You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1443 lines
56 KiB
1443 lines
56 KiB
/** @license URI.js v4.4.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" || typeof components.port === "string") { |
|
uriTokens.push(":"); |
|
uriTokens.push(String(components.port)); |
|
} |
|
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) { |
|
var secure = String(components.scheme).toLowerCase() === "https"; |
|
//normalize the default port |
|
if (components.port === (secure ? 443 : 80) || 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 |
|
}; |
|
|
|
function isSecure(wsComponents) { |
|
return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss"; |
|
} |
|
//RFC 6455 |
|
var handler$2 = { |
|
scheme: "ws", |
|
domainHost: true, |
|
parse: function parse(components, options) { |
|
var wsComponents = components; |
|
//indicate if the secure flag is set |
|
wsComponents.secure = isSecure(wsComponents); |
|
//construct resouce name |
|
wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : ''); |
|
wsComponents.path = undefined; |
|
wsComponents.query = undefined; |
|
return wsComponents; |
|
}, |
|
serialize: function serialize(wsComponents, options) { |
|
//normalize the default port |
|
if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") { |
|
wsComponents.port = undefined; |
|
} |
|
//ensure scheme matches secure flag |
|
if (typeof wsComponents.secure === 'boolean') { |
|
wsComponents.scheme = wsComponents.secure ? 'wss' : 'ws'; |
|
wsComponents.secure = undefined; |
|
} |
|
//reconstruct path from resource name |
|
if (wsComponents.resourceName) { |
|
var _wsComponents$resourc = wsComponents.resourceName.split('?'), |
|
_wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), |
|
path = _wsComponents$resourc2[0], |
|
query = _wsComponents$resourc2[1]; |
|
|
|
wsComponents.path = path && path !== '/' ? path : undefined; |
|
wsComponents.query = query; |
|
wsComponents.resourceName = undefined; |
|
} |
|
//forbid fragment component |
|
wsComponents.fragment = undefined; |
|
return wsComponents; |
|
} |
|
}; |
|
|
|
var handler$3 = { |
|
scheme: "wss", |
|
domainHost: handler$2.domainHost, |
|
parse: handler$2.parse, |
|
serialize: handler$2.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$4 = { |
|
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$5 = { |
|
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$6 = { |
|
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; |
|
SCHEMES[handler$5.scheme] = handler$5; |
|
SCHEMES[handler$6.scheme] = handler$6; |
|
|
|
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
|
|
|