source: trip-planner-front/node_modules/uri-js/dist/es5/uri.all.js

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 56.0 KB
Line 
1/** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
2(function (global, factory) {
3 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
4 typeof define === 'function' && define.amd ? define(['exports'], factory) :
5 (factory((global.URI = global.URI || {})));
6}(this, (function (exports) { 'use strict';
7
8function merge() {
9 for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
10 sets[_key] = arguments[_key];
11 }
12
13 if (sets.length > 1) {
14 sets[0] = sets[0].slice(0, -1);
15 var xl = sets.length - 1;
16 for (var x = 1; x < xl; ++x) {
17 sets[x] = sets[x].slice(1, -1);
18 }
19 sets[xl] = sets[xl].slice(1);
20 return sets.join('');
21 } else {
22 return sets[0];
23 }
24}
25function subexp(str) {
26 return "(?:" + str + ")";
27}
28function typeOf(o) {
29 return o === undefined ? "undefined" : o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase();
30}
31function toUpperCase(str) {
32 return str.toUpperCase();
33}
34function toArray(obj) {
35 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) : [];
36}
37function assign(target, source) {
38 var obj = target;
39 if (source) {
40 for (var key in source) {
41 obj[key] = source[key];
42 }
43 }
44 return obj;
45}
46
47function buildExps(isIRI) {
48 var ALPHA$$ = "[A-Za-z]",
49 CR$ = "[\\x0D]",
50 DIGIT$$ = "[0-9]",
51 DQUOTE$$ = "[\\x22]",
52 HEXDIG$$ = merge(DIGIT$$, "[A-Fa-f]"),
53 //case-insensitive
54 LF$$ = "[\\x0A]",
55 SP$$ = "[\\x20]",
56 PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)),
57 //expanded
58 GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]",
59 SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]",
60 RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),
61 UCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]",
62 //subset, excludes bidi control characters
63 IPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]",
64 //subset
65 UNRESERVED$$ = merge(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$),
66 SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*"),
67 USERINFO$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]")) + "*"),
68 DEC_OCTET$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("[1-9]" + DIGIT$$) + "|" + DIGIT$$),
69 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$$),
70 //relaxed parsing rules
71 IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$),
72 H16$ = subexp(HEXDIG$$ + "{1,4}"),
73 LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$),
74 IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$),
75 // 6( h16 ":" ) ls32
76 IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$),
77 // "::" 5( h16 ":" ) ls32
78 IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$),
79 //[ h16 ] "::" 4( h16 ":" ) ls32
80 IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$),
81 //[ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
82 IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$),
83 //[ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
84 IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$),
85 //[ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
86 IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$),
87 //[ *4( h16 ":" ) h16 ] "::" ls32
88 IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$),
89 //[ *5( h16 ":" ) h16 ] "::" h16
90 IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"),
91 //[ *6( h16 ":" ) h16 ] "::"
92 IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")),
93 ZONEID$ = subexp(subexp(UNRESERVED$$ + "|" + PCT_ENCODED$) + "+"),
94 //RFC 6874
95 IPV6ADDRZ$ = subexp(IPV6ADDRESS$ + "\\%25" + ZONEID$),
96 //RFC 6874
97 IPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + ZONEID$),
98 //RFC 6874, with relaxed parsing rules
99 IPVFUTURE$ = subexp("[vV]" + HEXDIG$$ + "+\\." + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]") + "+"),
100 IP_LITERAL$ = subexp("\\[" + subexp(IPV6ADDRZ_RELAXED$ + "|" + IPV6ADDRESS$ + "|" + IPVFUTURE$) + "\\]"),
101 //RFC 6874
102 REG_NAME$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$)) + "*"),
103 HOST$ = subexp(IP_LITERAL$ + "|" + IPV4ADDRESS$ + "(?!" + REG_NAME$ + ")" + "|" + REG_NAME$),
104 PORT$ = subexp(DIGIT$$ + "*"),
105 AUTHORITY$ = subexp(subexp(USERINFO$ + "@") + "?" + HOST$ + subexp("\\:" + PORT$) + "?"),
106 PCHAR$ = subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@]")),
107 SEGMENT$ = subexp(PCHAR$ + "*"),
108 SEGMENT_NZ$ = subexp(PCHAR$ + "+"),
109 SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\@]")) + "+"),
110 PATH_ABEMPTY$ = subexp(subexp("\\/" + SEGMENT$) + "*"),
111 PATH_ABSOLUTE$ = subexp("\\/" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + "?"),
112 //simplified
113 PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$),
114 //simplified
115 PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$),
116 //simplified
117 PATH_EMPTY$ = "(?!" + PCHAR$ + ")",
118 PATH$ = subexp(PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$),
119 QUERY$ = subexp(subexp(PCHAR$ + "|" + merge("[\\/\\?]", IPRIVATE$$)) + "*"),
120 FRAGMENT$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"),
121 HIER_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$),
122 URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"),
123 RELATIVE_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$),
124 RELATIVE$ = subexp(RELATIVE_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"),
125 URI_REFERENCE$ = subexp(URI$ + "|" + RELATIVE$),
126 ABSOLUTE_URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?"),
127 GENERIC_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$",
128 RELATIVE_REF$ = "^(){0}" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$",
129 ABSOLUTE_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?$",
130 SAMEDOC_REF$ = "^" + subexp("\\#(" + FRAGMENT$ + ")") + "?$",
131 AUTHORITY_REF$ = "^" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?$";
132 return {
133 NOT_SCHEME: new RegExp(merge("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
134 NOT_USERINFO: new RegExp(merge("[^\\%\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"),
135 NOT_HOST: new RegExp(merge("[^\\%\\[\\]\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"),
136 NOT_PATH: new RegExp(merge("[^\\%\\/\\:\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"),
137 NOT_PATH_NOSCHEME: new RegExp(merge("[^\\%\\/\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"),
138 NOT_QUERY: new RegExp(merge("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),
139 NOT_FRAGMENT: new RegExp(merge("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
140 ESCAPE: new RegExp(merge("[^]", UNRESERVED$$, SUB_DELIMS$$), "g"),
141 UNRESERVED: new RegExp(UNRESERVED$$, "g"),
142 OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$, RESERVED$$), "g"),
143 PCT_ENCODED: new RegExp(PCT_ENCODED$, "g"),
144 IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"),
145 IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$") //RFC 6874, with relaxed parsing rules
146 };
147}
148var URI_PROTOCOL = buildExps(false);
149
150var IRI_PROTOCOL = buildExps(true);
151
152var slicedToArray = function () {
153 function sliceIterator(arr, i) {
154 var _arr = [];
155 var _n = true;
156 var _d = false;
157 var _e = undefined;
158
159 try {
160 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
161 _arr.push(_s.value);
162
163 if (i && _arr.length === i) break;
164 }
165 } catch (err) {
166 _d = true;
167 _e = err;
168 } finally {
169 try {
170 if (!_n && _i["return"]) _i["return"]();
171 } finally {
172 if (_d) throw _e;
173 }
174 }
175
176 return _arr;
177 }
178
179 return function (arr, i) {
180 if (Array.isArray(arr)) {
181 return arr;
182 } else if (Symbol.iterator in Object(arr)) {
183 return sliceIterator(arr, i);
184 } else {
185 throw new TypeError("Invalid attempt to destructure non-iterable instance");
186 }
187 };
188}();
189
190
191
192
193
194
195
196
197
198
199
200
201
202var toConsumableArray = function (arr) {
203 if (Array.isArray(arr)) {
204 for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
205
206 return arr2;
207 } else {
208 return Array.from(arr);
209 }
210};
211
212/** Highest positive signed 32-bit float value */
213
214var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
215
216/** Bootstring parameters */
217var base = 36;
218var tMin = 1;
219var tMax = 26;
220var skew = 38;
221var damp = 700;
222var initialBias = 72;
223var initialN = 128; // 0x80
224var delimiter = '-'; // '\x2D'
225
226/** Regular expressions */
227var regexPunycode = /^xn--/;
228var regexNonASCII = /[^\0-\x7E]/; // non-ASCII chars
229var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
230
231/** Error messages */
232var errors = {
233 'overflow': 'Overflow: input needs wider integers to process',
234 'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
235 'invalid-input': 'Invalid input'
236};
237
238/** Convenience shortcuts */
239var baseMinusTMin = base - tMin;
240var floor = Math.floor;
241var stringFromCharCode = String.fromCharCode;
242
243/*--------------------------------------------------------------------------*/
244
245/**
246 * A generic error utility function.
247 * @private
248 * @param {String} type The error type.
249 * @returns {Error} Throws a `RangeError` with the applicable error message.
250 */
251function error$1(type) {
252 throw new RangeError(errors[type]);
253}
254
255/**
256 * A generic `Array#map` utility function.
257 * @private
258 * @param {Array} array The array to iterate over.
259 * @param {Function} callback The function that gets called for every array
260 * item.
261 * @returns {Array} A new array of values returned by the callback function.
262 */
263function map(array, fn) {
264 var result = [];
265 var length = array.length;
266 while (length--) {
267 result[length] = fn(array[length]);
268 }
269 return result;
270}
271
272/**
273 * A simple `Array#map`-like wrapper to work with domain name strings or email
274 * addresses.
275 * @private
276 * @param {String} domain The domain name or email address.
277 * @param {Function} callback The function that gets called for every
278 * character.
279 * @returns {Array} A new string of characters returned by the callback
280 * function.
281 */
282function mapDomain(string, fn) {
283 var parts = string.split('@');
284 var result = '';
285 if (parts.length > 1) {
286 // In email addresses, only the domain name should be punycoded. Leave
287 // the local part (i.e. everything up to `@`) intact.
288 result = parts[0] + '@';
289 string = parts[1];
290 }
291 // Avoid `split(regex)` for IE8 compatibility. See #17.
292 string = string.replace(regexSeparators, '\x2E');
293 var labels = string.split('.');
294 var encoded = map(labels, fn).join('.');
295 return result + encoded;
296}
297
298/**
299 * Creates an array containing the numeric code points of each Unicode
300 * character in the string. While JavaScript uses UCS-2 internally,
301 * this function will convert a pair of surrogate halves (each of which
302 * UCS-2 exposes as separate characters) into a single code point,
303 * matching UTF-16.
304 * @see `punycode.ucs2.encode`
305 * @see <https://mathiasbynens.be/notes/javascript-encoding>
306 * @memberOf punycode.ucs2
307 * @name decode
308 * @param {String} string The Unicode input string (UCS-2).
309 * @returns {Array} The new array of code points.
310 */
311function ucs2decode(string) {
312 var output = [];
313 var counter = 0;
314 var length = string.length;
315 while (counter < length) {
316 var value = string.charCodeAt(counter++);
317 if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
318 // It's a high surrogate, and there is a next character.
319 var extra = string.charCodeAt(counter++);
320 if ((extra & 0xFC00) == 0xDC00) {
321 // Low surrogate.
322 output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
323 } else {
324 // It's an unmatched surrogate; only append this code unit, in case the
325 // next code unit is the high surrogate of a surrogate pair.
326 output.push(value);
327 counter--;
328 }
329 } else {
330 output.push(value);
331 }
332 }
333 return output;
334}
335
336/**
337 * Creates a string based on an array of numeric code points.
338 * @see `punycode.ucs2.decode`
339 * @memberOf punycode.ucs2
340 * @name encode
341 * @param {Array} codePoints The array of numeric code points.
342 * @returns {String} The new Unicode string (UCS-2).
343 */
344var ucs2encode = function ucs2encode(array) {
345 return String.fromCodePoint.apply(String, toConsumableArray(array));
346};
347
348/**
349 * Converts a basic code point into a digit/integer.
350 * @see `digitToBasic()`
351 * @private
352 * @param {Number} codePoint The basic numeric code point value.
353 * @returns {Number} The numeric value of a basic code point (for use in
354 * representing integers) in the range `0` to `base - 1`, or `base` if
355 * the code point does not represent a value.
356 */
357var basicToDigit = function basicToDigit(codePoint) {
358 if (codePoint - 0x30 < 0x0A) {
359 return codePoint - 0x16;
360 }
361 if (codePoint - 0x41 < 0x1A) {
362 return codePoint - 0x41;
363 }
364 if (codePoint - 0x61 < 0x1A) {
365 return codePoint - 0x61;
366 }
367 return base;
368};
369
370/**
371 * Converts a digit/integer into a basic code point.
372 * @see `basicToDigit()`
373 * @private
374 * @param {Number} digit The numeric value of a basic code point.
375 * @returns {Number} The basic code point whose value (when used for
376 * representing integers) is `digit`, which needs to be in the range
377 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
378 * used; else, the lowercase form is used. The behavior is undefined
379 * if `flag` is non-zero and `digit` has no uppercase form.
380 */
381var digitToBasic = function digitToBasic(digit, flag) {
382 // 0..25 map to ASCII a..z or A..Z
383 // 26..35 map to ASCII 0..9
384 return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
385};
386
387/**
388 * Bias adaptation function as per section 3.4 of RFC 3492.
389 * https://tools.ietf.org/html/rfc3492#section-3.4
390 * @private
391 */
392var adapt = function adapt(delta, numPoints, firstTime) {
393 var k = 0;
394 delta = firstTime ? floor(delta / damp) : delta >> 1;
395 delta += floor(delta / numPoints);
396 for (; /* no initialization */delta > baseMinusTMin * tMax >> 1; k += base) {
397 delta = floor(delta / baseMinusTMin);
398 }
399 return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
400};
401
402/**
403 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
404 * symbols.
405 * @memberOf punycode
406 * @param {String} input The Punycode string of ASCII-only symbols.
407 * @returns {String} The resulting string of Unicode symbols.
408 */
409var decode = function decode(input) {
410 // Don't use UCS-2.
411 var output = [];
412 var inputLength = input.length;
413 var i = 0;
414 var n = initialN;
415 var bias = initialBias;
416
417 // Handle the basic code points: let `basic` be the number of input code
418 // points before the last delimiter, or `0` if there is none, then copy
419 // the first basic code points to the output.
420
421 var basic = input.lastIndexOf(delimiter);
422 if (basic < 0) {
423 basic = 0;
424 }
425
426 for (var j = 0; j < basic; ++j) {
427 // if it's not a basic code point
428 if (input.charCodeAt(j) >= 0x80) {
429 error$1('not-basic');
430 }
431 output.push(input.charCodeAt(j));
432 }
433
434 // Main decoding loop: start just after the last delimiter if any basic code
435 // points were copied; start at the beginning otherwise.
436
437 for (var index = basic > 0 ? basic + 1 : 0; index < inputLength;) /* no final expression */{
438
439 // `index` is the index of the next character to be consumed.
440 // Decode a generalized variable-length integer into `delta`,
441 // which gets added to `i`. The overflow checking is easier
442 // if we increase `i` as we go, then subtract off its starting
443 // value at the end to obtain `delta`.
444 var oldi = i;
445 for (var w = 1, k = base;; /* no condition */k += base) {
446
447 if (index >= inputLength) {
448 error$1('invalid-input');
449 }
450
451 var digit = basicToDigit(input.charCodeAt(index++));
452
453 if (digit >= base || digit > floor((maxInt - i) / w)) {
454 error$1('overflow');
455 }
456
457 i += digit * w;
458 var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
459
460 if (digit < t) {
461 break;
462 }
463
464 var baseMinusT = base - t;
465 if (w > floor(maxInt / baseMinusT)) {
466 error$1('overflow');
467 }
468
469 w *= baseMinusT;
470 }
471
472 var out = output.length + 1;
473 bias = adapt(i - oldi, out, oldi == 0);
474
475 // `i` was supposed to wrap around from `out` to `0`,
476 // incrementing `n` each time, so we'll fix that now:
477 if (floor(i / out) > maxInt - n) {
478 error$1('overflow');
479 }
480
481 n += floor(i / out);
482 i %= out;
483
484 // Insert `n` at position `i` of the output.
485 output.splice(i++, 0, n);
486 }
487
488 return String.fromCodePoint.apply(String, output);
489};
490
491/**
492 * Converts a string of Unicode symbols (e.g. a domain name label) to a
493 * Punycode string of ASCII-only symbols.
494 * @memberOf punycode
495 * @param {String} input The string of Unicode symbols.
496 * @returns {String} The resulting Punycode string of ASCII-only symbols.
497 */
498var encode = function encode(input) {
499 var output = [];
500
501 // Convert the input in UCS-2 to an array of Unicode code points.
502 input = ucs2decode(input);
503
504 // Cache the length.
505 var inputLength = input.length;
506
507 // Initialize the state.
508 var n = initialN;
509 var delta = 0;
510 var bias = initialBias;
511
512 // Handle the basic code points.
513 var _iteratorNormalCompletion = true;
514 var _didIteratorError = false;
515 var _iteratorError = undefined;
516
517 try {
518 for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
519 var _currentValue2 = _step.value;
520
521 if (_currentValue2 < 0x80) {
522 output.push(stringFromCharCode(_currentValue2));
523 }
524 }
525 } catch (err) {
526 _didIteratorError = true;
527 _iteratorError = err;
528 } finally {
529 try {
530 if (!_iteratorNormalCompletion && _iterator.return) {
531 _iterator.return();
532 }
533 } finally {
534 if (_didIteratorError) {
535 throw _iteratorError;
536 }
537 }
538 }
539
540 var basicLength = output.length;
541 var handledCPCount = basicLength;
542
543 // `handledCPCount` is the number of code points that have been handled;
544 // `basicLength` is the number of basic code points.
545
546 // Finish the basic string with a delimiter unless it's empty.
547 if (basicLength) {
548 output.push(delimiter);
549 }
550
551 // Main encoding loop:
552 while (handledCPCount < inputLength) {
553
554 // All non-basic code points < n have been handled already. Find the next
555 // larger one:
556 var m = maxInt;
557 var _iteratorNormalCompletion2 = true;
558 var _didIteratorError2 = false;
559 var _iteratorError2 = undefined;
560
561 try {
562 for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
563 var currentValue = _step2.value;
564
565 if (currentValue >= n && currentValue < m) {
566 m = currentValue;
567 }
568 }
569
570 // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
571 // but guard against overflow.
572 } catch (err) {
573 _didIteratorError2 = true;
574 _iteratorError2 = err;
575 } finally {
576 try {
577 if (!_iteratorNormalCompletion2 && _iterator2.return) {
578 _iterator2.return();
579 }
580 } finally {
581 if (_didIteratorError2) {
582 throw _iteratorError2;
583 }
584 }
585 }
586
587 var handledCPCountPlusOne = handledCPCount + 1;
588 if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
589 error$1('overflow');
590 }
591
592 delta += (m - n) * handledCPCountPlusOne;
593 n = m;
594
595 var _iteratorNormalCompletion3 = true;
596 var _didIteratorError3 = false;
597 var _iteratorError3 = undefined;
598
599 try {
600 for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
601 var _currentValue = _step3.value;
602
603 if (_currentValue < n && ++delta > maxInt) {
604 error$1('overflow');
605 }
606 if (_currentValue == n) {
607 // Represent delta as a generalized variable-length integer.
608 var q = delta;
609 for (var k = base;; /* no condition */k += base) {
610 var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
611 if (q < t) {
612 break;
613 }
614 var qMinusT = q - t;
615 var baseMinusT = base - t;
616 output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
617 q = floor(qMinusT / baseMinusT);
618 }
619
620 output.push(stringFromCharCode(digitToBasic(q, 0)));
621 bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
622 delta = 0;
623 ++handledCPCount;
624 }
625 }
626 } catch (err) {
627 _didIteratorError3 = true;
628 _iteratorError3 = err;
629 } finally {
630 try {
631 if (!_iteratorNormalCompletion3 && _iterator3.return) {
632 _iterator3.return();
633 }
634 } finally {
635 if (_didIteratorError3) {
636 throw _iteratorError3;
637 }
638 }
639 }
640
641 ++delta;
642 ++n;
643 }
644 return output.join('');
645};
646
647/**
648 * Converts a Punycode string representing a domain name or an email address
649 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
650 * it doesn't matter if you call it on a string that has already been
651 * converted to Unicode.
652 * @memberOf punycode
653 * @param {String} input The Punycoded domain name or email address to
654 * convert to Unicode.
655 * @returns {String} The Unicode representation of the given Punycode
656 * string.
657 */
658var toUnicode = function toUnicode(input) {
659 return mapDomain(input, function (string) {
660 return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
661 });
662};
663
664/**
665 * Converts a Unicode string representing a domain name or an email address to
666 * Punycode. Only the non-ASCII parts of the domain name will be converted,
667 * i.e. it doesn't matter if you call it with a domain that's already in
668 * ASCII.
669 * @memberOf punycode
670 * @param {String} input The domain name or email address to convert, as a
671 * Unicode string.
672 * @returns {String} The Punycode representation of the given domain name or
673 * email address.
674 */
675var toASCII = function toASCII(input) {
676 return mapDomain(input, function (string) {
677 return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;
678 });
679};
680
681/*--------------------------------------------------------------------------*/
682
683/** Define the public API */
684var punycode = {
685 /**
686 * A string representing the current Punycode.js version number.
687 * @memberOf punycode
688 * @type String
689 */
690 'version': '2.1.0',
691 /**
692 * An object of methods to convert from JavaScript's internal character
693 * representation (UCS-2) to Unicode code points, and back.
694 * @see <https://mathiasbynens.be/notes/javascript-encoding>
695 * @memberOf punycode
696 * @type Object
697 */
698 'ucs2': {
699 'decode': ucs2decode,
700 'encode': ucs2encode
701 },
702 'decode': decode,
703 'encode': encode,
704 'toASCII': toASCII,
705 'toUnicode': toUnicode
706};
707
708/**
709 * URI.js
710 *
711 * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.
712 * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
713 * @see http://github.com/garycourt/uri-js
714 */
715/**
716 * Copyright 2011 Gary Court. All rights reserved.
717 *
718 * Redistribution and use in source and binary forms, with or without modification, are
719 * permitted provided that the following conditions are met:
720 *
721 * 1. Redistributions of source code must retain the above copyright notice, this list of
722 * conditions and the following disclaimer.
723 *
724 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
725 * of conditions and the following disclaimer in the documentation and/or other materials
726 * provided with the distribution.
727 *
728 * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED
729 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
730 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR
731 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
732 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
733 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
734 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
735 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
736 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
737 *
738 * The views and conclusions contained in the software and documentation are those of the
739 * authors and should not be interpreted as representing official policies, either expressed
740 * or implied, of Gary Court.
741 */
742var SCHEMES = {};
743function pctEncChar(chr) {
744 var c = chr.charCodeAt(0);
745 var e = void 0;
746 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();
747 return e;
748}
749function pctDecChars(str) {
750 var newStr = "";
751 var i = 0;
752 var il = str.length;
753 while (i < il) {
754 var c = parseInt(str.substr(i + 1, 2), 16);
755 if (c < 128) {
756 newStr += String.fromCharCode(c);
757 i += 3;
758 } else if (c >= 194 && c < 224) {
759 if (il - i >= 6) {
760 var c2 = parseInt(str.substr(i + 4, 2), 16);
761 newStr += String.fromCharCode((c & 31) << 6 | c2 & 63);
762 } else {
763 newStr += str.substr(i, 6);
764 }
765 i += 6;
766 } else if (c >= 224) {
767 if (il - i >= 9) {
768 var _c = parseInt(str.substr(i + 4, 2), 16);
769 var c3 = parseInt(str.substr(i + 7, 2), 16);
770 newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63);
771 } else {
772 newStr += str.substr(i, 9);
773 }
774 i += 9;
775 } else {
776 newStr += str.substr(i, 3);
777 i += 3;
778 }
779 }
780 return newStr;
781}
782function _normalizeComponentEncoding(components, protocol) {
783 function decodeUnreserved(str) {
784 var decStr = pctDecChars(str);
785 return !decStr.match(protocol.UNRESERVED) ? str : decStr;
786 }
787 if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, "");
788 if (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
789 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);
790 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);
791 if (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
792 if (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
793 return components;
794}
795
796function _stripLeadingZeros(str) {
797 return str.replace(/^0*(.*)/, "$1") || "0";
798}
799function _normalizeIPv4(host, protocol) {
800 var matches = host.match(protocol.IPV4ADDRESS) || [];
801
802 var _matches = slicedToArray(matches, 2),
803 address = _matches[1];
804
805 if (address) {
806 return address.split(".").map(_stripLeadingZeros).join(".");
807 } else {
808 return host;
809 }
810}
811function _normalizeIPv6(host, protocol) {
812 var matches = host.match(protocol.IPV6ADDRESS) || [];
813
814 var _matches2 = slicedToArray(matches, 3),
815 address = _matches2[1],
816 zone = _matches2[2];
817
818 if (address) {
819 var _address$toLowerCase$ = address.toLowerCase().split('::').reverse(),
820 _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2),
821 last = _address$toLowerCase$2[0],
822 first = _address$toLowerCase$2[1];
823
824 var firstFields = first ? first.split(":").map(_stripLeadingZeros) : [];
825 var lastFields = last.split(":").map(_stripLeadingZeros);
826 var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);
827 var fieldCount = isLastFieldIPv4Address ? 7 : 8;
828 var lastFieldsStart = lastFields.length - fieldCount;
829 var fields = Array(fieldCount);
830 for (var x = 0; x < fieldCount; ++x) {
831 fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';
832 }
833 if (isLastFieldIPv4Address) {
834 fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);
835 }
836 var allZeroFields = fields.reduce(function (acc, field, index) {
837 if (!field || field === "0") {
838 var lastLongest = acc[acc.length - 1];
839 if (lastLongest && lastLongest.index + lastLongest.length === index) {
840 lastLongest.length++;
841 } else {
842 acc.push({ index: index, length: 1 });
843 }
844 }
845 return acc;
846 }, []);
847 var longestZeroFields = allZeroFields.sort(function (a, b) {
848 return b.length - a.length;
849 })[0];
850 var newHost = void 0;
851 if (longestZeroFields && longestZeroFields.length > 1) {
852 var newFirst = fields.slice(0, longestZeroFields.index);
853 var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);
854 newHost = newFirst.join(":") + "::" + newLast.join(":");
855 } else {
856 newHost = fields.join(":");
857 }
858 if (zone) {
859 newHost += "%" + zone;
860 }
861 return newHost;
862 } else {
863 return host;
864 }
865}
866var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;
867var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === undefined;
868function parse(uriString) {
869 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
870
871 var components = {};
872 var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
873 if (options.reference === "suffix") uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString;
874 var matches = uriString.match(URI_PARSE);
875 if (matches) {
876 if (NO_MATCH_IS_UNDEFINED) {
877 //store each component
878 components.scheme = matches[1];
879 components.userinfo = matches[3];
880 components.host = matches[4];
881 components.port = parseInt(matches[5], 10);
882 components.path = matches[6] || "";
883 components.query = matches[7];
884 components.fragment = matches[8];
885 //fix port number
886 if (isNaN(components.port)) {
887 components.port = matches[5];
888 }
889 } else {
890 //IE FIX for improper RegExp matching
891 //store each component
892 components.scheme = matches[1] || undefined;
893 components.userinfo = uriString.indexOf("@") !== -1 ? matches[3] : undefined;
894 components.host = uriString.indexOf("//") !== -1 ? matches[4] : undefined;
895 components.port = parseInt(matches[5], 10);
896 components.path = matches[6] || "";
897 components.query = uriString.indexOf("?") !== -1 ? matches[7] : undefined;
898 components.fragment = uriString.indexOf("#") !== -1 ? matches[8] : undefined;
899 //fix port number
900 if (isNaN(components.port)) {
901 components.port = uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches[4] : undefined;
902 }
903 }
904 if (components.host) {
905 //normalize IP hosts
906 components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);
907 }
908 //determine reference type
909 if (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {
910 components.reference = "same-document";
911 } else if (components.scheme === undefined) {
912 components.reference = "relative";
913 } else if (components.fragment === undefined) {
914 components.reference = "absolute";
915 } else {
916 components.reference = "uri";
917 }
918 //check for reference errors
919 if (options.reference && options.reference !== "suffix" && options.reference !== components.reference) {
920 components.error = components.error || "URI is not a " + options.reference + " reference.";
921 }
922 //find scheme handler
923 var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
924 //check if scheme can't handle IRIs
925 if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
926 //if host component is a domain name
927 if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) {
928 //convert Unicode IDN -> ASCII IDN
929 try {
930 components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
931 } catch (e) {
932 components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e;
933 }
934 }
935 //convert IRI -> URI
936 _normalizeComponentEncoding(components, URI_PROTOCOL);
937 } else {
938 //normalize encodings
939 _normalizeComponentEncoding(components, protocol);
940 }
941 //perform scheme specific parsing
942 if (schemeHandler && schemeHandler.parse) {
943 schemeHandler.parse(components, options);
944 }
945 } else {
946 components.error = components.error || "URI can not be parsed.";
947 }
948 return components;
949}
950
951function _recomposeAuthority(components, options) {
952 var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
953 var uriTokens = [];
954 if (components.userinfo !== undefined) {
955 uriTokens.push(components.userinfo);
956 uriTokens.push("@");
957 }
958 if (components.host !== undefined) {
959 //normalize IP hosts, add brackets and escape zone separator for IPv6
960 uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function (_, $1, $2) {
961 return "[" + $1 + ($2 ? "%25" + $2 : "") + "]";
962 }));
963 }
964 if (typeof components.port === "number" || typeof components.port === "string") {
965 uriTokens.push(":");
966 uriTokens.push(String(components.port));
967 }
968 return uriTokens.length ? uriTokens.join("") : undefined;
969}
970
971var RDS1 = /^\.\.?\//;
972var RDS2 = /^\/\.(\/|$)/;
973var RDS3 = /^\/\.\.(\/|$)/;
974var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/;
975function removeDotSegments(input) {
976 var output = [];
977 while (input.length) {
978 if (input.match(RDS1)) {
979 input = input.replace(RDS1, "");
980 } else if (input.match(RDS2)) {
981 input = input.replace(RDS2, "/");
982 } else if (input.match(RDS3)) {
983 input = input.replace(RDS3, "/");
984 output.pop();
985 } else if (input === "." || input === "..") {
986 input = "";
987 } else {
988 var im = input.match(RDS5);
989 if (im) {
990 var s = im[0];
991 input = input.slice(s.length);
992 output.push(s);
993 } else {
994 throw new Error("Unexpected dot segment condition");
995 }
996 }
997 }
998 return output.join("");
999}
1000
1001function serialize(components) {
1002 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1003
1004 var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL;
1005 var uriTokens = [];
1006 //find scheme handler
1007 var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
1008 //perform scheme specific serialization
1009 if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
1010 if (components.host) {
1011 //if host component is an IPv6 address
1012 if (protocol.IPV6ADDRESS.test(components.host)) {}
1013 //TODO: normalize IPv6 address as per RFC 5952
1014
1015 //if host component is a domain name
1016 else if (options.domainHost || schemeHandler && schemeHandler.domainHost) {
1017 //convert IDN via punycode
1018 try {
1019 components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);
1020 } catch (e) {
1021 components.error = components.error || "Host's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;
1022 }
1023 }
1024 }
1025 //normalize encoding
1026 _normalizeComponentEncoding(components, protocol);
1027 if (options.reference !== "suffix" && components.scheme) {
1028 uriTokens.push(components.scheme);
1029 uriTokens.push(":");
1030 }
1031 var authority = _recomposeAuthority(components, options);
1032 if (authority !== undefined) {
1033 if (options.reference !== "suffix") {
1034 uriTokens.push("//");
1035 }
1036 uriTokens.push(authority);
1037 if (components.path && components.path.charAt(0) !== "/") {
1038 uriTokens.push("/");
1039 }
1040 }
1041 if (components.path !== undefined) {
1042 var s = components.path;
1043 if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
1044 s = removeDotSegments(s);
1045 }
1046 if (authority === undefined) {
1047 s = s.replace(/^\/\//, "/%2F"); //don't allow the path to start with "//"
1048 }
1049 uriTokens.push(s);
1050 }
1051 if (components.query !== undefined) {
1052 uriTokens.push("?");
1053 uriTokens.push(components.query);
1054 }
1055 if (components.fragment !== undefined) {
1056 uriTokens.push("#");
1057 uriTokens.push(components.fragment);
1058 }
1059 return uriTokens.join(""); //merge tokens into a string
1060}
1061
1062function resolveComponents(base, relative) {
1063 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1064 var skipNormalization = arguments[3];
1065
1066 var target = {};
1067 if (!skipNormalization) {
1068 base = parse(serialize(base, options), options); //normalize base components
1069 relative = parse(serialize(relative, options), options); //normalize relative components
1070 }
1071 options = options || {};
1072 if (!options.tolerant && relative.scheme) {
1073 target.scheme = relative.scheme;
1074 //target.authority = relative.authority;
1075 target.userinfo = relative.userinfo;
1076 target.host = relative.host;
1077 target.port = relative.port;
1078 target.path = removeDotSegments(relative.path || "");
1079 target.query = relative.query;
1080 } else {
1081 if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
1082 //target.authority = relative.authority;
1083 target.userinfo = relative.userinfo;
1084 target.host = relative.host;
1085 target.port = relative.port;
1086 target.path = removeDotSegments(relative.path || "");
1087 target.query = relative.query;
1088 } else {
1089 if (!relative.path) {
1090 target.path = base.path;
1091 if (relative.query !== undefined) {
1092 target.query = relative.query;
1093 } else {
1094 target.query = base.query;
1095 }
1096 } else {
1097 if (relative.path.charAt(0) === "/") {
1098 target.path = removeDotSegments(relative.path);
1099 } else {
1100 if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
1101 target.path = "/" + relative.path;
1102 } else if (!base.path) {
1103 target.path = relative.path;
1104 } else {
1105 target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
1106 }
1107 target.path = removeDotSegments(target.path);
1108 }
1109 target.query = relative.query;
1110 }
1111 //target.authority = base.authority;
1112 target.userinfo = base.userinfo;
1113 target.host = base.host;
1114 target.port = base.port;
1115 }
1116 target.scheme = base.scheme;
1117 }
1118 target.fragment = relative.fragment;
1119 return target;
1120}
1121
1122function resolve(baseURI, relativeURI, options) {
1123 var schemelessOptions = assign({ scheme: 'null' }, options);
1124 return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
1125}
1126
1127function normalize(uri, options) {
1128 if (typeof uri === "string") {
1129 uri = serialize(parse(uri, options), options);
1130 } else if (typeOf(uri) === "object") {
1131 uri = parse(serialize(uri, options), options);
1132 }
1133 return uri;
1134}
1135
1136function equal(uriA, uriB, options) {
1137 if (typeof uriA === "string") {
1138 uriA = serialize(parse(uriA, options), options);
1139 } else if (typeOf(uriA) === "object") {
1140 uriA = serialize(uriA, options);
1141 }
1142 if (typeof uriB === "string") {
1143 uriB = serialize(parse(uriB, options), options);
1144 } else if (typeOf(uriB) === "object") {
1145 uriB = serialize(uriB, options);
1146 }
1147 return uriA === uriB;
1148}
1149
1150function escapeComponent(str, options) {
1151 return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);
1152}
1153
1154function unescapeComponent(str, options) {
1155 return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);
1156}
1157
1158var handler = {
1159 scheme: "http",
1160 domainHost: true,
1161 parse: function parse(components, options) {
1162 //report missing host
1163 if (!components.host) {
1164 components.error = components.error || "HTTP URIs must have a host.";
1165 }
1166 return components;
1167 },
1168 serialize: function serialize(components, options) {
1169 var secure = String(components.scheme).toLowerCase() === "https";
1170 //normalize the default port
1171 if (components.port === (secure ? 443 : 80) || components.port === "") {
1172 components.port = undefined;
1173 }
1174 //normalize the empty path
1175 if (!components.path) {
1176 components.path = "/";
1177 }
1178 //NOTE: We do not parse query strings for HTTP URIs
1179 //as WWW Form Url Encoded query strings are part of the HTML4+ spec,
1180 //and not the HTTP spec.
1181 return components;
1182 }
1183};
1184
1185var handler$1 = {
1186 scheme: "https",
1187 domainHost: handler.domainHost,
1188 parse: handler.parse,
1189 serialize: handler.serialize
1190};
1191
1192function isSecure(wsComponents) {
1193 return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
1194}
1195//RFC 6455
1196var handler$2 = {
1197 scheme: "ws",
1198 domainHost: true,
1199 parse: function parse(components, options) {
1200 var wsComponents = components;
1201 //indicate if the secure flag is set
1202 wsComponents.secure = isSecure(wsComponents);
1203 //construct resouce name
1204 wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');
1205 wsComponents.path = undefined;
1206 wsComponents.query = undefined;
1207 return wsComponents;
1208 },
1209 serialize: function serialize(wsComponents, options) {
1210 //normalize the default port
1211 if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
1212 wsComponents.port = undefined;
1213 }
1214 //ensure scheme matches secure flag
1215 if (typeof wsComponents.secure === 'boolean') {
1216 wsComponents.scheme = wsComponents.secure ? 'wss' : 'ws';
1217 wsComponents.secure = undefined;
1218 }
1219 //reconstruct path from resource name
1220 if (wsComponents.resourceName) {
1221 var _wsComponents$resourc = wsComponents.resourceName.split('?'),
1222 _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2),
1223 path = _wsComponents$resourc2[0],
1224 query = _wsComponents$resourc2[1];
1225
1226 wsComponents.path = path && path !== '/' ? path : undefined;
1227 wsComponents.query = query;
1228 wsComponents.resourceName = undefined;
1229 }
1230 //forbid fragment component
1231 wsComponents.fragment = undefined;
1232 return wsComponents;
1233 }
1234};
1235
1236var handler$3 = {
1237 scheme: "wss",
1238 domainHost: handler$2.domainHost,
1239 parse: handler$2.parse,
1240 serialize: handler$2.serialize
1241};
1242
1243var O = {};
1244var isIRI = true;
1245//RFC 3986
1246var UNRESERVED$$ = "[A-Za-z0-9\\-\\.\\_\\~" + (isIRI ? "\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF" : "") + "]";
1247var HEXDIG$$ = "[0-9A-Fa-f]"; //case-insensitive
1248var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)); //expanded
1249//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =
1250//const ATEXT$$ = "[A-Za-z0-9\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\_\\`\\{\\|\\}\\~]";
1251//const WSP$$ = "[\\x20\\x09]";
1252//const OBS_QTEXT$$ = "[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]"; //(%d1-8 / %d11-12 / %d14-31 / %d127)
1253//const QTEXT$$ = merge("[\\x21\\x23-\\x5B\\x5D-\\x7E]", OBS_QTEXT$$); //%d33 / %d35-91 / %d93-126 / obs-qtext
1254//const VCHAR$$ = "[\\x21-\\x7E]";
1255//const WSP$$ = "[\\x20\\x09]";
1256//const OBS_QP$ = subexp("\\\\" + merge("[\\x00\\x0D\\x0A]", OBS_QTEXT$$)); //%d0 / CR / LF / obs-qtext
1257//const FWS$ = subexp(subexp(WSP$$ + "*" + "\\x0D\\x0A") + "?" + WSP$$ + "+");
1258//const QUOTED_PAIR$ = subexp(subexp("\\\\" + subexp(VCHAR$$ + "|" + WSP$$)) + "|" + OBS_QP$);
1259//const QUOTED_STRING$ = subexp('\\"' + subexp(FWS$ + "?" + QCONTENT$) + "*" + FWS$ + "?" + '\\"');
1260var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]";
1261var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]";
1262var VCHAR$$ = merge(QTEXT$$, "[\\\"\\\\]");
1263var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]";
1264var UNRESERVED = new RegExp(UNRESERVED$$, "g");
1265var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g");
1266var NOT_LOCAL_PART = new RegExp(merge("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");
1267var NOT_HFNAME = new RegExp(merge("[^]", UNRESERVED$$, SOME_DELIMS$$), "g");
1268var NOT_HFVALUE = NOT_HFNAME;
1269function decodeUnreserved(str) {
1270 var decStr = pctDecChars(str);
1271 return !decStr.match(UNRESERVED) ? str : decStr;
1272}
1273var handler$4 = {
1274 scheme: "mailto",
1275 parse: function parse$$1(components, options) {
1276 var mailtoComponents = components;
1277 var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(",") : [];
1278 mailtoComponents.path = undefined;
1279 if (mailtoComponents.query) {
1280 var unknownHeaders = false;
1281 var headers = {};
1282 var hfields = mailtoComponents.query.split("&");
1283 for (var x = 0, xl = hfields.length; x < xl; ++x) {
1284 var hfield = hfields[x].split("=");
1285 switch (hfield[0]) {
1286 case "to":
1287 var toAddrs = hfield[1].split(",");
1288 for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {
1289 to.push(toAddrs[_x]);
1290 }
1291 break;
1292 case "subject":
1293 mailtoComponents.subject = unescapeComponent(hfield[1], options);
1294 break;
1295 case "body":
1296 mailtoComponents.body = unescapeComponent(hfield[1], options);
1297 break;
1298 default:
1299 unknownHeaders = true;
1300 headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);
1301 break;
1302 }
1303 }
1304 if (unknownHeaders) mailtoComponents.headers = headers;
1305 }
1306 mailtoComponents.query = undefined;
1307 for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {
1308 var addr = to[_x2].split("@");
1309 addr[0] = unescapeComponent(addr[0]);
1310 if (!options.unicodeSupport) {
1311 //convert Unicode IDN -> ASCII IDN
1312 try {
1313 addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());
1314 } catch (e) {
1315 mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e;
1316 }
1317 } else {
1318 addr[1] = unescapeComponent(addr[1], options).toLowerCase();
1319 }
1320 to[_x2] = addr.join("@");
1321 }
1322 return mailtoComponents;
1323 },
1324 serialize: function serialize$$1(mailtoComponents, options) {
1325 var components = mailtoComponents;
1326 var to = toArray(mailtoComponents.to);
1327 if (to) {
1328 for (var x = 0, xl = to.length; x < xl; ++x) {
1329 var toAddr = String(to[x]);
1330 var atIdx = toAddr.lastIndexOf("@");
1331 var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);
1332 var domain = toAddr.slice(atIdx + 1);
1333 //convert IDN via punycode
1334 try {
1335 domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain);
1336 } catch (e) {
1337 components.error = components.error || "Email address's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;
1338 }
1339 to[x] = localPart + "@" + domain;
1340 }
1341 components.path = to.join(",");
1342 }
1343 var headers = mailtoComponents.headers = mailtoComponents.headers || {};
1344 if (mailtoComponents.subject) headers["subject"] = mailtoComponents.subject;
1345 if (mailtoComponents.body) headers["body"] = mailtoComponents.body;
1346 var fields = [];
1347 for (var name in headers) {
1348 if (headers[name] !== O[name]) {
1349 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));
1350 }
1351 }
1352 if (fields.length) {
1353 components.query = fields.join("&");
1354 }
1355 return components;
1356 }
1357};
1358
1359var URN_PARSE = /^([^\:]+)\:(.*)/;
1360//RFC 2141
1361var handler$5 = {
1362 scheme: "urn",
1363 parse: function parse$$1(components, options) {
1364 var matches = components.path && components.path.match(URN_PARSE);
1365 var urnComponents = components;
1366 if (matches) {
1367 var scheme = options.scheme || urnComponents.scheme || "urn";
1368 var nid = matches[1].toLowerCase();
1369 var nss = matches[2];
1370 var urnScheme = scheme + ":" + (options.nid || nid);
1371 var schemeHandler = SCHEMES[urnScheme];
1372 urnComponents.nid = nid;
1373 urnComponents.nss = nss;
1374 urnComponents.path = undefined;
1375 if (schemeHandler) {
1376 urnComponents = schemeHandler.parse(urnComponents, options);
1377 }
1378 } else {
1379 urnComponents.error = urnComponents.error || "URN can not be parsed.";
1380 }
1381 return urnComponents;
1382 },
1383 serialize: function serialize$$1(urnComponents, options) {
1384 var scheme = options.scheme || urnComponents.scheme || "urn";
1385 var nid = urnComponents.nid;
1386 var urnScheme = scheme + ":" + (options.nid || nid);
1387 var schemeHandler = SCHEMES[urnScheme];
1388 if (schemeHandler) {
1389 urnComponents = schemeHandler.serialize(urnComponents, options);
1390 }
1391 var uriComponents = urnComponents;
1392 var nss = urnComponents.nss;
1393 uriComponents.path = (nid || options.nid) + ":" + nss;
1394 return uriComponents;
1395 }
1396};
1397
1398var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/;
1399//RFC 4122
1400var handler$6 = {
1401 scheme: "urn:uuid",
1402 parse: function parse(urnComponents, options) {
1403 var uuidComponents = urnComponents;
1404 uuidComponents.uuid = uuidComponents.nss;
1405 uuidComponents.nss = undefined;
1406 if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {
1407 uuidComponents.error = uuidComponents.error || "UUID is not valid.";
1408 }
1409 return uuidComponents;
1410 },
1411 serialize: function serialize(uuidComponents, options) {
1412 var urnComponents = uuidComponents;
1413 //normalize UUID
1414 urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
1415 return urnComponents;
1416 }
1417};
1418
1419SCHEMES[handler.scheme] = handler;
1420SCHEMES[handler$1.scheme] = handler$1;
1421SCHEMES[handler$2.scheme] = handler$2;
1422SCHEMES[handler$3.scheme] = handler$3;
1423SCHEMES[handler$4.scheme] = handler$4;
1424SCHEMES[handler$5.scheme] = handler$5;
1425SCHEMES[handler$6.scheme] = handler$6;
1426
1427exports.SCHEMES = SCHEMES;
1428exports.pctEncChar = pctEncChar;
1429exports.pctDecChars = pctDecChars;
1430exports.parse = parse;
1431exports.removeDotSegments = removeDotSegments;
1432exports.serialize = serialize;
1433exports.resolveComponents = resolveComponents;
1434exports.resolve = resolve;
1435exports.normalize = normalize;
1436exports.equal = equal;
1437exports.escapeComponent = escapeComponent;
1438exports.unescapeComponent = unescapeComponent;
1439
1440Object.defineProperty(exports, '__esModule', { value: true });
1441
1442})));
1443//# sourceMappingURL=uri.all.js.map
Note: See TracBrowser for help on using the repository browser.