1(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2module.exports = function (it) {
3 if (typeof it != 'function') {
4 throw TypeError(String(it) + ' is not a function');
5 } return it;
6};
7
8},{}],2:[function(require,module,exports){
9var isObject = require('../internals/is-object');
10
11module.exports = function (it) {
12 if (!isObject(it) && it !== null) {
13 throw TypeError("Can't set " + String(it) + ' as a prototype');
14 } return it;
15};
16
17},{"../internals/is-object":37}],3:[function(require,module,exports){
18var wellKnownSymbol = require('../internals/well-known-symbol');
19var create = require('../internals/object-create');
20var definePropertyModule = require('../internals/object-define-property');
21
22var UNSCOPABLES = wellKnownSymbol('unscopables');
23var ArrayPrototype = Array.prototype;
24
25// Array.prototype[@@unscopables]
26// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
27if (ArrayPrototype[UNSCOPABLES] == undefined) {
28 definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
29 configurable: true,
30 value: create(null)
31 });
32}
33
34// add a key to Array.prototype[@@unscopables]
35module.exports = function (key) {
36 ArrayPrototype[UNSCOPABLES][key] = true;
37};
38
39},{"../internals/object-create":45,"../internals/object-define-property":47,"../internals/well-known-symbol":77}],4:[function(require,module,exports){
40module.exports = function (it, Constructor, name) {
41 if (!(it instanceof Constructor)) {
42 throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
43 } return it;
44};
45
46},{}],5:[function(require,module,exports){
47var isObject = require('../internals/is-object');
48
49module.exports = function (it) {
50 if (!isObject(it)) {
51 throw TypeError(String(it) + ' is not an object');
52 } return it;
53};
54
55},{"../internals/is-object":37}],6:[function(require,module,exports){
56'use strict';
57var bind = require('../internals/function-bind-context');
58var toObject = require('../internals/to-object');
59var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
60var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
61var toLength = require('../internals/to-length');
62var createProperty = require('../internals/create-property');
63var getIteratorMethod = require('../internals/get-iterator-method');
64
65// `Array.from` method implementation
66// https://tc39.github.io/ecma262/#sec-array.from
67module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
68 var O = toObject(arrayLike);
69 var C = typeof this == 'function' ? this : Array;
70 var argumentsLength = arguments.length;
71 var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
72 var mapping = mapfn !== undefined;
73 var iteratorMethod = getIteratorMethod(O);
74 var index = 0;
75 var length, result, step, iterator, next, value;
76 if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
77 // if the target is not iterable or it's an array with the default iterator - use a simple case
78 if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
79 iterator = iteratorMethod.call(O);
80 next = iterator.next;
81 result = new C();
82 for (;!(step = next.call(iterator)).done; index++) {
83 value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
84 createProperty(result, index, value);
85 }
86 } else {
87 length = toLength(O.length);
88 result = new C(length);
89 for (;length > index; index++) {
90 value = mapping ? mapfn(O[index], index) : O[index];
91 createProperty(result, index, value);
92 }
93 }
94 result.length = index;
95 return result;
96};
97
98},{"../internals/call-with-safe-iteration-closing":8,"../internals/create-property":16,"../internals/function-bind-context":23,"../internals/get-iterator-method":25,"../internals/is-array-iterator-method":35,"../internals/to-length":71,"../internals/to-object":72}],7:[function(require,module,exports){
99var toIndexedObject = require('../internals/to-indexed-object');
100var toLength = require('../internals/to-length');
101var toAbsoluteIndex = require('../internals/to-absolute-index');
102
103// `Array.prototype.{ indexOf, includes }` methods implementation
104var createMethod = function (IS_INCLUDES) {
105 return function ($this, el, fromIndex) {
106 var O = toIndexedObject($this);
107 var length = toLength(O.length);
108 var index = toAbsoluteIndex(fromIndex, length);
109 var value;
110 // Array#includes uses SameValueZero equality algorithm
111 // eslint-disable-next-line no-self-compare
112 if (IS_INCLUDES && el != el) while (length > index) {
113 value = O[index++];
114 // eslint-disable-next-line no-self-compare
115 if (value != value) return true;
116 // Array#indexOf ignores holes, Array#includes - not
117 } else for (;length > index; index++) {
118 if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
119 } return !IS_INCLUDES && -1;
120 };
121};
122
123module.exports = {
124 // `Array.prototype.includes` method
125 // https://tc39.github.io/ecma262/#sec-array.prototype.includes
126 includes: createMethod(true),
127 // `Array.prototype.indexOf` method
128 // https://tc39.github.io/ecma262/#sec-array.prototype.indexof
129 indexOf: createMethod(false)
130};
131
132},{"../internals/to-absolute-index":68,"../internals/to-indexed-object":69,"../internals/to-length":71}],8:[function(require,module,exports){
133var anObject = require('../internals/an-object');
134
135// call something on iterator step with safe closing on error
136module.exports = function (iterator, fn, value, ENTRIES) {
137 try {
138 return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
139 // 7.4.6 IteratorClose(iterator, completion)
140 } catch (error) {
141 var returnMethod = iterator['return'];
142 if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
143 throw error;
144 }
145};
146
147},{"../internals/an-object":5}],9:[function(require,module,exports){
148var toString = {}.toString;
149
150module.exports = function (it) {
151 return toString.call(it).slice(8, -1);
152};
153
154},{}],10:[function(require,module,exports){
155var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
156var classofRaw = require('../internals/classof-raw');
157var wellKnownSymbol = require('../internals/well-known-symbol');
158
159var TO_STRING_TAG = wellKnownSymbol('toStringTag');
160// ES3 wrong here
161var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
162
163// fallback for IE11 Script Access Denied error
164var tryGet = function (it, key) {
165 try {
166 return it[key];
167 } catch (error) { /* empty */ }
168};
169
170// getting tag from ES6+ `Object.prototype.toString`
171module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
172 var O, tag, result;
173 return it === undefined ? 'Undefined' : it === null ? 'Null'
174 // @@toStringTag case
175 : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
176 // builtinTag case
177 : CORRECT_ARGUMENTS ? classofRaw(O)
178 // ES3 arguments fallback
179 : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
180};
181
182},{"../internals/classof-raw":9,"../internals/to-string-tag-support":74,"../internals/well-known-symbol":77}],11:[function(require,module,exports){
183var has = require('../internals/has');
184var ownKeys = require('../internals/own-keys');
185var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
186var definePropertyModule = require('../internals/object-define-property');
187
188module.exports = function (target, source) {
189 var keys = ownKeys(source);
190 var defineProperty = definePropertyModule.f;
191 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
192 for (var i = 0; i < keys.length; i++) {
193 var key = keys[i];
194 if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
195 }
196};
197
198},{"../internals/has":28,"../internals/object-define-property":47,"../internals/object-get-own-property-descriptor":48,"../internals/own-keys":56}],12:[function(require,module,exports){
199var fails = require('../internals/fails');
200
201module.exports = !fails(function () {
202 function F() { /* empty */ }
203 F.prototype.constructor = null;
204 return Object.getPrototypeOf(new F()) !== F.prototype;
205});
206
207},{"../internals/fails":22}],13:[function(require,module,exports){
208'use strict';
209var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
210var create = require('../internals/object-create');
211var createPropertyDescriptor = require('../internals/create-property-descriptor');
212var setToStringTag = require('../internals/set-to-string-tag');
213var Iterators = require('../internals/iterators');
214
215var returnThis = function () { return this; };
216
217module.exports = function (IteratorConstructor, NAME, next) {
218 var TO_STRING_TAG = NAME + ' Iterator';
219 IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
220 setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
221 Iterators[TO_STRING_TAG] = returnThis;
222 return IteratorConstructor;
223};
224
225},{"../internals/create-property-descriptor":15,"../internals/iterators":40,"../internals/iterators-core":39,"../internals/object-create":45,"../internals/set-to-string-tag":62}],14:[function(require,module,exports){
226var DESCRIPTORS = require('../internals/descriptors');
227var definePropertyModule = require('../internals/object-define-property');
228var createPropertyDescriptor = require('../internals/create-property-descriptor');
229
230module.exports = DESCRIPTORS ? function (object, key, value) {
231 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
232} : function (object, key, value) {
233 object[key] = value;
234 return object;
235};
236
237},{"../internals/create-property-descriptor":15,"../internals/descriptors":18,"../internals/object-define-property":47}],15:[function(require,module,exports){
238module.exports = function (bitmap, value) {
239 return {
240 enumerable: !(bitmap & 1),
241 configurable: !(bitmap & 2),
242 writable: !(bitmap & 4),
243 value: value
244 };
245};
246
247},{}],16:[function(require,module,exports){
248'use strict';
249var toPrimitive = require('../internals/to-primitive');
250var definePropertyModule = require('../internals/object-define-property');
251var createPropertyDescriptor = require('../internals/create-property-descriptor');
252
253module.exports = function (object, key, value) {
254 var propertyKey = toPrimitive(key);
255 if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
256 else object[propertyKey] = value;
257};
258
259},{"../internals/create-property-descriptor":15,"../internals/object-define-property":47,"../internals/to-primitive":73}],17:[function(require,module,exports){
260'use strict';
261var $ = require('../internals/export');
262var createIteratorConstructor = require('../internals/create-iterator-constructor');
263var getPrototypeOf = require('../internals/object-get-prototype-of');
264var setPrototypeOf = require('../internals/object-set-prototype-of');
265var setToStringTag = require('../internals/set-to-string-tag');
266var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
267var redefine = require('../internals/redefine');
268var wellKnownSymbol = require('../internals/well-known-symbol');
269var IS_PURE = require('../internals/is-pure');
270var Iterators = require('../internals/iterators');
271var IteratorsCore = require('../internals/iterators-core');
272
273var IteratorPrototype = IteratorsCore.IteratorPrototype;
274var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
275var ITERATOR = wellKnownSymbol('iterator');
276var KEYS = 'keys';
277var VALUES = 'values';
278var ENTRIES = 'entries';
279
280var returnThis = function () { return this; };
281
282module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
283 createIteratorConstructor(IteratorConstructor, NAME, next);
284
285 var getIterationMethod = function (KIND) {
286 if (KIND === DEFAULT && defaultIterator) return defaultIterator;
287 if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
288 switch (KIND) {
289 case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
290 case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
291 case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
292 } return function () { return new IteratorConstructor(this); };
293 };
294
295 var TO_STRING_TAG = NAME + ' Iterator';
296 var INCORRECT_VALUES_NAME = false;
297 var IterablePrototype = Iterable.prototype;
298 var nativeIterator = IterablePrototype[ITERATOR]
299 || IterablePrototype['@@iterator']
300 || DEFAULT && IterablePrototype[DEFAULT];
301 var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
302 var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
303 var CurrentIteratorPrototype, methods, KEY;
304
305 // fix native
306 if (anyNativeIterator) {
307 CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
308 if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
309 if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
310 if (setPrototypeOf) {
311 setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
312 } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
313 createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);
314 }
315 }
316 // Set @@toStringTag to native iterators
317 setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
318 if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
319 }
320 }
321
322 // fix Array#{values, @@iterator}.name in V8 / FF
323 if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
324 INCORRECT_VALUES_NAME = true;
325 defaultIterator = function values() { return nativeIterator.call(this); };
326 }
327
328 // define iterator
329 if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
330 createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);
331 }
332 Iterators[NAME] = defaultIterator;
333
334 // export additional methods
335 if (DEFAULT) {
336 methods = {
337 values: getIterationMethod(VALUES),
338 keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
339 entries: getIterationMethod(ENTRIES)
340 };
341 if (FORCED) for (KEY in methods) {
342 if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
343 redefine(IterablePrototype, KEY, methods[KEY]);
344 }
345 } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
346 }
347
348 return methods;
349};
350
351},{"../internals/create-iterator-constructor":13,"../internals/create-non-enumerable-property":14,"../internals/export":21,"../internals/is-pure":38,"../internals/iterators":40,"../internals/iterators-core":39,"../internals/object-get-prototype-of":51,"../internals/object-set-prototype-of":55,"../internals/redefine":59,"../internals/set-to-string-tag":62,"../internals/well-known-symbol":77}],18:[function(require,module,exports){
352var fails = require('../internals/fails');
353
354// Thank's IE8 for his funny defineProperty
355module.exports = !fails(function () {
356 return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
357});
358
359},{"../internals/fails":22}],19:[function(require,module,exports){
360var global = require('../internals/global');
361var isObject = require('../internals/is-object');
362
363var document = global.document;
364// typeof document.createElement is 'object' in old IE
365var EXISTS = isObject(document) && isObject(document.createElement);
366
367module.exports = function (it) {
368 return EXISTS ? document.createElement(it) : {};
369};
370
371},{"../internals/global":27,"../internals/is-object":37}],20:[function(require,module,exports){
372// IE8- don't enum bug keys
373module.exports = [
374 'constructor',
375 'hasOwnProperty',
376 'isPrototypeOf',
377 'propertyIsEnumerable',
378 'toLocaleString',
379 'toString',
380 'valueOf'
381];
382
383},{}],21:[function(require,module,exports){
384var global = require('../internals/global');
385var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
386var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
387var redefine = require('../internals/redefine');
388var setGlobal = require('../internals/set-global');
389var copyConstructorProperties = require('../internals/copy-constructor-properties');
390var isForced = require('../internals/is-forced');
391
392/*
393 options.target - name of the target object
394 options.global - target is the global object
395 options.stat - export as static methods of target
396 options.proto - export as prototype methods of target
397 options.real - real prototype method for the `pure` version
398 options.forced - export even if the native feature is available
399 options.bind - bind methods to the target, required for the `pure` version
400 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
401 options.unsafe - use the simple assignment of property instead of delete + defineProperty
402 options.sham - add a flag to not completely full polyfills
403 options.enumerable - export as enumerable property
404 options.noTargetGet - prevent calling a getter on target
405*/
406module.exports = function (options, source) {
407 var TARGET = options.target;
408 var GLOBAL = options.global;
409 var STATIC = options.stat;
410 var FORCED, target, key, targetProperty, sourceProperty, descriptor;
411 if (GLOBAL) {
412 target = global;
413 } else if (STATIC) {
414 target = global[TARGET] || setGlobal(TARGET, {});
415 } else {
416 target = (global[TARGET] || {}).prototype;
417 }
418 if (target) for (key in source) {
419 sourceProperty = source[key];
420 if (options.noTargetGet) {
421 descriptor = getOwnPropertyDescriptor(target, key);
422 targetProperty = descriptor && descriptor.value;
423 } else targetProperty = target[key];
424 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
425 // contained in target
426 if (!FORCED && targetProperty !== undefined) {
427 if (typeof sourceProperty === typeof targetProperty) continue;
428 copyConstructorProperties(sourceProperty, targetProperty);
429 }
430 // add a flag to not completely full polyfills
431 if (options.sham || (targetProperty && targetProperty.sham)) {
432 createNonEnumerableProperty(sourceProperty, 'sham', true);
433 }
434 // extend global
435 redefine(target, key, sourceProperty, options);
436 }
437};
438
439},{"../internals/copy-constructor-properties":11,"../internals/create-non-enumerable-property":14,"../internals/global":27,"../internals/is-forced":36,"../internals/object-get-own-property-descriptor":48,"../internals/redefine":59,"../internals/set-global":61}],22:[function(require,module,exports){
440module.exports = function (exec) {
441 try {
442 return !!exec();
443 } catch (error) {
444 return true;
445 }
446};
447
448},{}],23:[function(require,module,exports){
449var aFunction = require('../internals/a-function');
450
451// optional / simple context binding
452module.exports = function (fn, that, length) {
453 aFunction(fn);
454 if (that === undefined) return fn;
455 switch (length) {
456 case 0: return function () {
457 return fn.call(that);
458 };
459 case 1: return function (a) {
460 return fn.call(that, a);
461 };
462 case 2: return function (a, b) {
463 return fn.call(that, a, b);
464 };
465 case 3: return function (a, b, c) {
466 return fn.call(that, a, b, c);
467 };
468 }
469 return function (/* ...args */) {
470 return fn.apply(that, arguments);
471 };
472};
473
474},{"../internals/a-function":1}],24:[function(require,module,exports){
475var path = require('../internals/path');
476var global = require('../internals/global');
477
478var aFunction = function (variable) {
479 return typeof variable == 'function' ? variable : undefined;
480};
481
482module.exports = function (namespace, method) {
483 return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])
484 : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
485};
486
487},{"../internals/global":27,"../internals/path":57}],25:[function(require,module,exports){
488var classof = require('../internals/classof');
489var Iterators = require('../internals/iterators');
490var wellKnownSymbol = require('../internals/well-known-symbol');
491
492var ITERATOR = wellKnownSymbol('iterator');
493
494module.exports = function (it) {
495 if (it != undefined) return it[ITERATOR]
496 || it['@@iterator']
497 || Iterators[classof(it)];
498};
499
500},{"../internals/classof":10,"../internals/iterators":40,"../internals/well-known-symbol":77}],26:[function(require,module,exports){
501var anObject = require('../internals/an-object');
502var getIteratorMethod = require('../internals/get-iterator-method');
503
504module.exports = function (it) {
505 var iteratorMethod = getIteratorMethod(it);
506 if (typeof iteratorMethod != 'function') {
507 throw TypeError(String(it) + ' is not iterable');
508 } return anObject(iteratorMethod.call(it));
509};
510
511},{"../internals/an-object":5,"../internals/get-iterator-method":25}],27:[function(require,module,exports){
512(function (global){
513var check = function (it) {
514 return it && it.Math == Math && it;
515};
516
517// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
518module.exports =
519 // eslint-disable-next-line no-undef
520 check(typeof globalThis == 'object' && globalThis) ||
521 check(typeof window == 'object' && window) ||
522 check(typeof self == 'object' && self) ||
523 check(typeof global == 'object' && global) ||
524 // eslint-disable-next-line no-new-func
525 Function('return this')();
526
527}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
528},{}],28:[function(require,module,exports){
529var hasOwnProperty = {}.hasOwnProperty;
530
531module.exports = function (it, key) {
532 return hasOwnProperty.call(it, key);
533};
534
535},{}],29:[function(require,module,exports){
536module.exports = {};
537
538},{}],30:[function(require,module,exports){
539var getBuiltIn = require('../internals/get-built-in');
540
541module.exports = getBuiltIn('document', 'documentElement');
542
543},{"../internals/get-built-in":24}],31:[function(require,module,exports){
544var DESCRIPTORS = require('../internals/descriptors');
545var fails = require('../internals/fails');
546var createElement = require('../internals/document-create-element');
547
548// Thank's IE8 for his funny defineProperty
549module.exports = !DESCRIPTORS && !fails(function () {
550 return Object.defineProperty(createElement('div'), 'a', {
551 get: function () { return 7; }
552 }).a != 7;
553});
554
555},{"../internals/descriptors":18,"../internals/document-create-element":19,"../internals/fails":22}],32:[function(require,module,exports){
556var fails = require('../internals/fails');
557var classof = require('../internals/classof-raw');
558
559var split = ''.split;
560
561// fallback for non-array-like ES3 and non-enumerable old V8 strings
562module.exports = fails(function () {
563 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
564 // eslint-disable-next-line no-prototype-builtins
565 return !Object('z').propertyIsEnumerable(0);
566}) ? function (it) {
567 return classof(it) == 'String' ? split.call(it, '') : Object(it);
568} : Object;
569
570},{"../internals/classof-raw":9,"../internals/fails":22}],33:[function(require,module,exports){
571var store = require('../internals/shared-store');
572
573var functionToString = Function.toString;
574
575// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
576if (typeof store.inspectSource != 'function') {
577 store.inspectSource = function (it) {
578 return functionToString.call(it);
579 };
580}
581
582module.exports = store.inspectSource;
583
584},{"../internals/shared-store":64}],34:[function(require,module,exports){
585var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
586var global = require('../internals/global');
587var isObject = require('../internals/is-object');
588var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
589var objectHas = require('../internals/has');
590var sharedKey = require('../internals/shared-key');
591var hiddenKeys = require('../internals/hidden-keys');
592
593var WeakMap = global.WeakMap;
594var set, get, has;
595
596var enforce = function (it) {
597 return has(it) ? get(it) : set(it, {});
598};
599
600var getterFor = function (TYPE) {
601 return function (it) {
602 var state;
603 if (!isObject(it) || (state = get(it)).type !== TYPE) {
604 throw TypeError('Incompatible receiver, ' + TYPE + ' required');
605 } return state;
606 };
607};
608
609if (NATIVE_WEAK_MAP) {
610 var store = new WeakMap();
611 var wmget = store.get;
612 var wmhas = store.has;
613 var wmset = store.set;
614 set = function (it, metadata) {
615 wmset.call(store, it, metadata);
616 return metadata;
617 };
618 get = function (it) {
619 return wmget.call(store, it) || {};
620 };
621 has = function (it) {
622 return wmhas.call(store, it);
623 };
624} else {
625 var STATE = sharedKey('state');
626 hiddenKeys[STATE] = true;
627 set = function (it, metadata) {
628 createNonEnumerableProperty(it, STATE, metadata);
629 return metadata;
630 };
631 get = function (it) {
632 return objectHas(it, STATE) ? it[STATE] : {};
633 };
634 has = function (it) {
635 return objectHas(it, STATE);
636 };
637}
638
639module.exports = {
640 set: set,
641 get: get,
642 has: has,
643 enforce: enforce,
644 getterFor: getterFor
645};
646
647},{"../internals/create-non-enumerable-property":14,"../internals/global":27,"../internals/has":28,"../internals/hidden-keys":29,"../internals/is-object":37,"../internals/native-weak-map":43,"../internals/shared-key":63}],35:[function(require,module,exports){
648var wellKnownSymbol = require('../internals/well-known-symbol');
649var Iterators = require('../internals/iterators');
650
651var ITERATOR = wellKnownSymbol('iterator');
652var ArrayPrototype = Array.prototype;
653
654// check on default Array iterator
655module.exports = function (it) {
656 return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
657};
658
659},{"../internals/iterators":40,"../internals/well-known-symbol":77}],36:[function(require,module,exports){
660var fails = require('../internals/fails');
661
662var replacement = /#|\.prototype\./;
663
664var isForced = function (feature, detection) {
665 var value = data[normalize(feature)];
666 return value == POLYFILL ? true
667 : value == NATIVE ? false
668 : typeof detection == 'function' ? fails(detection)
669 : !!detection;
670};
671
672var normalize = isForced.normalize = function (string) {
673 return String(string).replace(replacement, '.').toLowerCase();
674};
675
676var data = isForced.data = {};
677var NATIVE = isForced.NATIVE = 'N';
678var POLYFILL = isForced.POLYFILL = 'P';
679
680module.exports = isForced;
681
682},{"../internals/fails":22}],37:[function(require,module,exports){
683module.exports = function (it) {
684 return typeof it === 'object' ? it !== null : typeof it === 'function';
685};
686
687},{}],38:[function(require,module,exports){
688module.exports = false;
689
690},{}],39:[function(require,module,exports){
691'use strict';
692var getPrototypeOf = require('../internals/object-get-prototype-of');
693var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
694var has = require('../internals/has');
695var wellKnownSymbol = require('../internals/well-known-symbol');
696var IS_PURE = require('../internals/is-pure');
697
698var ITERATOR = wellKnownSymbol('iterator');
699var BUGGY_SAFARI_ITERATORS = false;
700
701var returnThis = function () { return this; };
702
703// `%IteratorPrototype%` object
704// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
705var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
706
707if ([].keys) {
708 arrayIterator = [].keys();
709 // Safari 8 has buggy iterators w/o `next`
710 if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
711 else {
712 PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
713 if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
714 }
715}
716
717if (IteratorPrototype == undefined) IteratorPrototype = {};
718
719// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
720if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {
721 createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);
722}
723
724module.exports = {
725 IteratorPrototype: IteratorPrototype,
726 BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
727};
728
729},{"../internals/create-non-enumerable-property":14,"../internals/has":28,"../internals/is-pure":38,"../internals/object-get-prototype-of":51,"../internals/well-known-symbol":77}],40:[function(require,module,exports){
730arguments[4][29][0].apply(exports,arguments)
731},{"dup":29}],41:[function(require,module,exports){
732var fails = require('../internals/fails');
733
734module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
735 // Chrome 38 Symbol has incorrect toString conversion
736 // eslint-disable-next-line no-undef
737 return !String(Symbol());
738});
739
740},{"../internals/fails":22}],42:[function(require,module,exports){
741var fails = require('../internals/fails');
742var wellKnownSymbol = require('../internals/well-known-symbol');
743var IS_PURE = require('../internals/is-pure');
744
745var ITERATOR = wellKnownSymbol('iterator');
746
747module.exports = !fails(function () {
748 var url = new URL('b?a=1&b=2&c=3', 'http://a');
749 var searchParams = url.searchParams;
750 var result = '';
751 url.pathname = 'c%20d';
752 searchParams.forEach(function (value, key) {
753 searchParams['delete']('b');
754 result += key + value;
755 });
756 return (IS_PURE && !url.toJSON)
757 || !searchParams.sort
758 || url.href !== 'http://a/c%20d?a=1&c=3'
759 || searchParams.get('c') !== '3'
760 || String(new URLSearchParams('?a=1')) !== 'a=1'
761 || !searchParams[ITERATOR]
762 // throws in Edge
763 || new URL('https://a@b').username !== 'a'
764 || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
765 // not punycoded in Edge
766 || new URL('http://тест').host !== 'xn--e1aybc'
767 // not escaped in Chrome 62-
768 || new URL('http://a#б').hash !== '#%D0%B1'
769 // fails in Chrome 66-
770 || result !== 'a1c3'
771 // throws in Safari
772 || new URL('http://x', undefined).host !== 'x';
773});
774
775},{"../internals/fails":22,"../internals/is-pure":38,"../internals/well-known-symbol":77}],43:[function(require,module,exports){
776var global = require('../internals/global');
777var inspectSource = require('../internals/inspect-source');
778
779var WeakMap = global.WeakMap;
780
781module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
782
783},{"../internals/global":27,"../internals/inspect-source":33}],44:[function(require,module,exports){
784'use strict';
785var DESCRIPTORS = require('../internals/descriptors');
786var fails = require('../internals/fails');
787var objectKeys = require('../internals/object-keys');
788var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
789var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
790var toObject = require('../internals/to-object');
791var IndexedObject = require('../internals/indexed-object');
792
793var nativeAssign = Object.assign;
794var defineProperty = Object.defineProperty;
795
796// `Object.assign` method
797// https://tc39.github.io/ecma262/#sec-object.assign
798module.exports = !nativeAssign || fails(function () {
799 // should have correct order of operations (Edge bug)
800 if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', {
801 enumerable: true,
802 get: function () {
803 defineProperty(this, 'b', {
804 value: 3,
805 enumerable: false
806 });
807 }
808 }), { b: 2 })).b !== 1) return true;
809 // should work with symbols and should have deterministic property order (V8 bug)
810 var A = {};
811 var B = {};
812 // eslint-disable-next-line no-undef
813 var symbol = Symbol();
814 var alphabet = 'abcdefghijklmnopqrst';
815 A[symbol] = 7;
816 alphabet.split('').forEach(function (chr) { B[chr] = chr; });
817 return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;
818}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
819 var T = toObject(target);
820 var argumentsLength = arguments.length;
821 var index = 1;
822 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
823 var propertyIsEnumerable = propertyIsEnumerableModule.f;
824 while (argumentsLength > index) {
825 var S = IndexedObject(arguments[index++]);
826 var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
827 var length = keys.length;
828 var j = 0;
829 var key;
830 while (length > j) {
831 key = keys[j++];
832 if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];
833 }
834 } return T;
835} : nativeAssign;
836
837},{"../internals/descriptors":18,"../internals/fails":22,"../internals/indexed-object":32,"../internals/object-get-own-property-symbols":50,"../internals/object-keys":53,"../internals/object-property-is-enumerable":54,"../internals/to-object":72}],45:[function(require,module,exports){
838var anObject = require('../internals/an-object');
839var defineProperties = require('../internals/object-define-properties');
840var enumBugKeys = require('../internals/enum-bug-keys');
841var hiddenKeys = require('../internals/hidden-keys');
842var html = require('../internals/html');
843var documentCreateElement = require('../internals/document-create-element');
844var sharedKey = require('../internals/shared-key');
845
846var GT = '>';
847var LT = '<';
848var PROTOTYPE = 'prototype';
849var SCRIPT = 'script';
850var IE_PROTO = sharedKey('IE_PROTO');
851
852var EmptyConstructor = function () { /* empty */ };
853
854var scriptTag = function (content) {
855 return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
856};
857
858// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
859var NullProtoObjectViaActiveX = function (activeXDocument) {
860 activeXDocument.write(scriptTag(''));
861 activeXDocument.close();
862 var temp = activeXDocument.parentWindow.Object;
863 activeXDocument = null; // avoid memory leak
864 return temp;
865};
866
867// Create object with fake `null` prototype: use iframe Object with cleared prototype
868var NullProtoObjectViaIFrame = function () {
869 // Thrash, waste and sodomy: IE GC bug
870 var iframe = documentCreateElement('iframe');
871 var JS = 'java' + SCRIPT + ':';
872 var iframeDocument;
873 iframe.style.display = 'none';
874 html.appendChild(iframe);
875 // https://github.com/zloirock/core-js/issues/475
876 iframe.src = String(JS);
877 iframeDocument = iframe.contentWindow.document;
878 iframeDocument.open();
879 iframeDocument.write(scriptTag('document.F=Object'));
880 iframeDocument.close();
881 return iframeDocument.F;
882};
883
884// Check for document.domain and active x support
885// No need to use active x approach when document.domain is not set
886// see https://github.com/es-shims/es5-shim/issues/150
887// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
888// avoid IE GC bug
889var activeXDocument;
890var NullProtoObject = function () {
891 try {
892 /* global ActiveXObject */
893 activeXDocument = document.domain && new ActiveXObject('htmlfile');
894 } catch (error) { /* ignore */ }
895 NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
896 var length = enumBugKeys.length;
897 while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
898 return NullProtoObject();
899};
900
901hiddenKeys[IE_PROTO] = true;
902
903// `Object.create` method
904// https://tc39.github.io/ecma262/#sec-object.create
905module.exports = Object.create || function create(O, Properties) {
906 var result;
907 if (O !== null) {
908 EmptyConstructor[PROTOTYPE] = anObject(O);
909 result = new EmptyConstructor();
910 EmptyConstructor[PROTOTYPE] = null;
911 // add "__proto__" for Object.getPrototypeOf polyfill
912 result[IE_PROTO] = O;
913 } else result = NullProtoObject();
914 return Properties === undefined ? result : defineProperties(result, Properties);
915};
916
917},{"../internals/an-object":5,"../internals/document-create-element":19,"../internals/enum-bug-keys":20,"../internals/hidden-keys":29,"../internals/html":30,"../internals/object-define-properties":46,"../internals/shared-key":63}],46:[function(require,module,exports){
918var DESCRIPTORS = require('../internals/descriptors');
919var definePropertyModule = require('../internals/object-define-property');
920var anObject = require('../internals/an-object');
921var objectKeys = require('../internals/object-keys');
922
923// `Object.defineProperties` method
924// https://tc39.github.io/ecma262/#sec-object.defineproperties
925module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
926 anObject(O);
927 var keys = objectKeys(Properties);
928 var length = keys.length;
929 var index = 0;
930 var key;
931 while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);
932 return O;
933};
934
935},{"../internals/an-object":5,"../internals/descriptors":18,"../internals/object-define-property":47,"../internals/object-keys":53}],47:[function(require,module,exports){
936var DESCRIPTORS = require('../internals/descriptors');
937var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
938var anObject = require('../internals/an-object');
939var toPrimitive = require('../internals/to-primitive');
940
941var nativeDefineProperty = Object.defineProperty;
942
943// `Object.defineProperty` method
944// https://tc39.github.io/ecma262/#sec-object.defineproperty
945exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
946 anObject(O);
947 P = toPrimitive(P, true);
948 anObject(Attributes);
949 if (IE8_DOM_DEFINE) try {
950 return nativeDefineProperty(O, P, Attributes);
951 } catch (error) { /* empty */ }
952 if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
953 if ('value' in Attributes) O[P] = Attributes.value;
954 return O;
955};
956
957},{"../internals/an-object":5,"../internals/descriptors":18,"../internals/ie8-dom-define":31,"../internals/to-primitive":73}],48:[function(require,module,exports){
958var DESCRIPTORS = require('../internals/descriptors');
959var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
960var createPropertyDescriptor = require('../internals/create-property-descriptor');
961var toIndexedObject = require('../internals/to-indexed-object');
962var toPrimitive = require('../internals/to-primitive');
963var has = require('../internals/has');
964var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
965
966var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
967
968// `Object.getOwnPropertyDescriptor` method
969// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
970exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
971 O = toIndexedObject(O);
972 P = toPrimitive(P, true);
973 if (IE8_DOM_DEFINE) try {
974 return nativeGetOwnPropertyDescriptor(O, P);
975 } catch (error) { /* empty */ }
976 if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
977};
978
979},{"../internals/create-property-descriptor":15,"../internals/descriptors":18,"../internals/has":28,"../internals/ie8-dom-define":31,"../internals/object-property-is-enumerable":54,"../internals/to-indexed-object":69,"../internals/to-primitive":73}],49:[function(require,module,exports){
980var internalObjectKeys = require('../internals/object-keys-internal');
981var enumBugKeys = require('../internals/enum-bug-keys');
982
983var hiddenKeys = enumBugKeys.concat('length', 'prototype');
984
985// `Object.getOwnPropertyNames` method
986// https://tc39.github.io/ecma262/#sec-object.getownpropertynames
987exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
988 return internalObjectKeys(O, hiddenKeys);
989};
990
991},{"../internals/enum-bug-keys":20,"../internals/object-keys-internal":52}],50:[function(require,module,exports){
992exports.f = Object.getOwnPropertySymbols;
993
994},{}],51:[function(require,module,exports){
995var has = require('../internals/has');
996var toObject = require('../internals/to-object');
997var sharedKey = require('../internals/shared-key');
998var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');
999
1000var IE_PROTO = sharedKey('IE_PROTO');
1001var ObjectPrototype = Object.prototype;
1002
1003// `Object.getPrototypeOf` method
1004// https://tc39.github.io/ecma262/#sec-object.getprototypeof
1005module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
1006 O = toObject(O);
1007 if (has(O, IE_PROTO)) return O[IE_PROTO];
1008 if (typeof O.constructor == 'function' && O instanceof O.constructor) {
1009 return O.constructor.prototype;
1010 } return O instanceof Object ? ObjectPrototype : null;
1011};
1012
1013},{"../internals/correct-prototype-getter":12,"../internals/has":28,"../internals/shared-key":63,"../internals/to-object":72}],52:[function(require,module,exports){
1014var has = require('../internals/has');
1015var toIndexedObject = require('../internals/to-indexed-object');
1016var indexOf = require('../internals/array-includes').indexOf;
1017var hiddenKeys = require('../internals/hidden-keys');
1018
1019module.exports = function (object, names) {
1020 var O = toIndexedObject(object);
1021 var i = 0;
1022 var result = [];
1023 var key;
1024 for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
1025 // Don't enum bug & hidden keys
1026 while (names.length > i) if (has(O, key = names[i++])) {
1027 ~indexOf(result, key) || result.push(key);
1028 }
1029 return result;
1030};
1031
1032},{"../internals/array-includes":7,"../internals/has":28,"../internals/hidden-keys":29,"../internals/to-indexed-object":69}],53:[function(require,module,exports){
1033var internalObjectKeys = require('../internals/object-keys-internal');
1034var enumBugKeys = require('../internals/enum-bug-keys');
1035
1036// `Object.keys` method
1037// https://tc39.github.io/ecma262/#sec-object.keys
1038module.exports = Object.keys || function keys(O) {
1039 return internalObjectKeys(O, enumBugKeys);
1040};
1041
1042},{"../internals/enum-bug-keys":20,"../internals/object-keys-internal":52}],54:[function(require,module,exports){
1043'use strict';
1044var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
1045var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1046
1047// Nashorn ~ JDK8 bug
1048var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
1049
1050// `Object.prototype.propertyIsEnumerable` method implementation
1051// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable
1052exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
1053 var descriptor = getOwnPropertyDescriptor(this, V);
1054 return !!descriptor && descriptor.enumerable;
1055} : nativePropertyIsEnumerable;
1056
1057},{}],55:[function(require,module,exports){
1058var anObject = require('../internals/an-object');
1059var aPossiblePrototype = require('../internals/a-possible-prototype');
1060
1061// `Object.setPrototypeOf` method
1062// https://tc39.github.io/ecma262/#sec-object.setprototypeof
1063// Works with __proto__ only. Old v8 can't work with null proto objects.
1064/* eslint-disable no-proto */
1065module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
1066 var CORRECT_SETTER = false;
1067 var test = {};
1068 var setter;
1069 try {
1070 setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
1071 setter.call(test, []);
1072 CORRECT_SETTER = test instanceof Array;
1073 } catch (error) { /* empty */ }
1074 return function setPrototypeOf(O, proto) {
1075 anObject(O);
1076 aPossiblePrototype(proto);
1077 if (CORRECT_SETTER) setter.call(O, proto);
1078 else O.__proto__ = proto;
1079 return O;
1080 };
1081}() : undefined);
1082
1083},{"../internals/a-possible-prototype":2,"../internals/an-object":5}],56:[function(require,module,exports){
1084var getBuiltIn = require('../internals/get-built-in');
1085var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');
1086var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
1087var anObject = require('../internals/an-object');
1088
1089// all object keys, includes non-enumerable and symbols
1090module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
1091 var keys = getOwnPropertyNamesModule.f(anObject(it));
1092 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1093 return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
1094};
1095
1096},{"../internals/an-object":5,"../internals/get-built-in":24,"../internals/object-get-own-property-names":49,"../internals/object-get-own-property-symbols":50}],57:[function(require,module,exports){
1097var global = require('../internals/global');
1098
1099module.exports = global;
1100
1101},{"../internals/global":27}],58:[function(require,module,exports){
1102var redefine = require('../internals/redefine');
1103
1104module.exports = function (target, src, options) {
1105 for (var key in src) redefine(target, key, src[key], options);
1106 return target;
1107};
1108
1109},{"../internals/redefine":59}],59:[function(require,module,exports){
1110var global = require('../internals/global');
1111var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
1112var has = require('../internals/has');
1113var setGlobal = require('../internals/set-global');
1114var inspectSource = require('../internals/inspect-source');
1115var InternalStateModule = require('../internals/internal-state');
1116
1117var getInternalState = InternalStateModule.get;
1118var enforceInternalState = InternalStateModule.enforce;
1119var TEMPLATE = String(String).split('String');
1120
1121(module.exports = function (O, key, value, options) {
1122 var unsafe = options ? !!options.unsafe : false;
1123 var simple = options ? !!options.enumerable : false;
1124 var noTargetGet = options ? !!options.noTargetGet : false;
1125 if (typeof value == 'function') {
1126 if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key);
1127 enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
1128 }
1129 if (O === global) {
1130 if (simple) O[key] = value;
1131 else setGlobal(key, value);
1132 return;
1133 } else if (!unsafe) {
1134 delete O[key];
1135 } else if (!noTargetGet && O[key]) {
1136 simple = true;
1137 }
1138 if (simple) O[key] = value;
1139 else createNonEnumerableProperty(O, key, value);
1140// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
1141})(Function.prototype, 'toString', function toString() {
1142 return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
1143});
1144
1145},{"../internals/create-non-enumerable-property":14,"../internals/global":27,"../internals/has":28,"../internals/inspect-source":33,"../internals/internal-state":34,"../internals/set-global":61}],60:[function(require,module,exports){
1146// `RequireObjectCoercible` abstract operation
1147// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
1148module.exports = function (it) {
1149 if (it == undefined) throw TypeError("Can't call method on " + it);
1150 return it;
1151};
1152
1153},{}],61:[function(require,module,exports){
1154var global = require('../internals/global');
1155var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
1156
1157module.exports = function (key, value) {
1158 try {
1159 createNonEnumerableProperty(global, key, value);
1160 } catch (error) {
1161 global[key] = value;
1162 } return value;
1163};
1164
1165},{"../internals/create-non-enumerable-property":14,"../internals/global":27}],62:[function(require,module,exports){
1166var defineProperty = require('../internals/object-define-property').f;
1167var has = require('../internals/has');
1168var wellKnownSymbol = require('../internals/well-known-symbol');
1169
1170var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1171
1172module.exports = function (it, TAG, STATIC) {
1173 if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
1174 defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
1175 }
1176};
1177
1178},{"../internals/has":28,"../internals/object-define-property":47,"../internals/well-known-symbol":77}],63:[function(require,module,exports){
1179var shared = require('../internals/shared');
1180var uid = require('../internals/uid');
1181
1182var keys = shared('keys');
1183
1184module.exports = function (key) {
1185 return keys[key] || (keys[key] = uid(key));
1186};
1187
1188},{"../internals/shared":65,"../internals/uid":75}],64:[function(require,module,exports){
1189var global = require('../internals/global');
1190var setGlobal = require('../internals/set-global');
1191
1192var SHARED = '__core-js_shared__';
1193var store = global[SHARED] || setGlobal(SHARED, {});
1194
1195module.exports = store;
1196
1197},{"../internals/global":27,"../internals/set-global":61}],65:[function(require,module,exports){
1198var IS_PURE = require('../internals/is-pure');
1199var store = require('../internals/shared-store');
1200
1201(module.exports = function (key, value) {
1202 return store[key] || (store[key] = value !== undefined ? value : {});
1203})('versions', []).push({
1204 version: '3.6.4',
1205 mode: IS_PURE ? 'pure' : 'global',
1206 copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
1207});
1208
1209},{"../internals/is-pure":38,"../internals/shared-store":64}],66:[function(require,module,exports){
1210var toInteger = require('../internals/to-integer');
1211var requireObjectCoercible = require('../internals/require-object-coercible');
1212
1213// `String.prototype.{ codePointAt, at }` methods implementation
1214var createMethod = function (CONVERT_TO_STRING) {
1215 return function ($this, pos) {
1216 var S = String(requireObjectCoercible($this));
1217 var position = toInteger(pos);
1218 var size = S.length;
1219 var first, second;
1220 if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
1221 first = S.charCodeAt(position);
1222 return first < 0xD800 || first > 0xDBFF || position + 1 === size
1223 || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
1224 ? CONVERT_TO_STRING ? S.charAt(position) : first
1225 : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
1226 };
1227};
1228
1229module.exports = {
1230 // `String.prototype.codePointAt` method
1231 // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
1232 codeAt: createMethod(false),
1233 // `String.prototype.at` method
1234 // https://github.com/mathiasbynens/String.prototype.at
1235 charAt: createMethod(true)
1236};
1237
1238},{"../internals/require-object-coercible":60,"../internals/to-integer":70}],67:[function(require,module,exports){
1239'use strict';
1240// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js
1241var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
1242var base = 36;
1243var tMin = 1;
1244var tMax = 26;
1245var skew = 38;
1246var damp = 700;
1247var initialBias = 72;
1248var initialN = 128; // 0x80
1249var delimiter = '-'; // '\x2D'
1250var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars
1251var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
1252var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
1253var baseMinusTMin = base - tMin;
1254var floor = Math.floor;
1255var stringFromCharCode = String.fromCharCode;
1256
1257/**
1258 * Creates an array containing the numeric code points of each Unicode
1259 * character in the string. While JavaScript uses UCS-2 internally,
1260 * this function will convert a pair of surrogate halves (each of which
1261 * UCS-2 exposes as separate characters) into a single code point,
1262 * matching UTF-16.
1263 */
1264var ucs2decode = function (string) {
1265 var output = [];
1266 var counter = 0;
1267 var length = string.length;
1268 while (counter < length) {
1269 var value = string.charCodeAt(counter++);
1270 if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
1271 // It's a high surrogate, and there is a next character.
1272 var extra = string.charCodeAt(counter++);
1273 if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
1274 output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
1275 } else {
1276 // It's an unmatched surrogate; only append this code unit, in case the
1277 // next code unit is the high surrogate of a surrogate pair.
1278 output.push(value);
1279 counter--;
1280 }
1281 } else {
1282 output.push(value);
1283 }
1284 }
1285 return output;
1286};
1287
1288/**
1289 * Converts a digit/integer into a basic code point.
1290 */
1291var digitToBasic = function (digit) {
1292 // 0..25 map to ASCII a..z or A..Z
1293 // 26..35 map to ASCII 0..9
1294 return digit + 22 + 75 * (digit < 26);
1295};
1296
1297/**
1298 * Bias adaptation function as per section 3.4 of RFC 3492.
1299 * https://tools.ietf.org/html/rfc3492#section-3.4
1300 */
1301var adapt = function (delta, numPoints, firstTime) {
1302 var k = 0;
1303 delta = firstTime ? floor(delta / damp) : delta >> 1;
1304 delta += floor(delta / numPoints);
1305 for (; delta > baseMinusTMin * tMax >> 1; k += base) {
1306 delta = floor(delta / baseMinusTMin);
1307 }
1308 return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
1309};
1310
1311/**
1312 * Converts a string of Unicode symbols (e.g. a domain name label) to a
1313 * Punycode string of ASCII-only symbols.
1314 */
1315// eslint-disable-next-line max-statements
1316var encode = function (input) {
1317 var output = [];
1318
1319 // Convert the input in UCS-2 to an array of Unicode code points.
1320 input = ucs2decode(input);
1321
1322 // Cache the length.
1323 var inputLength = input.length;
1324
1325 // Initialize the state.
1326 var n = initialN;
1327 var delta = 0;
1328 var bias = initialBias;
1329 var i, currentValue;
1330
1331 // Handle the basic code points.
1332 for (i = 0; i < input.length; i++) {
1333 currentValue = input[i];
1334 if (currentValue < 0x80) {
1335 output.push(stringFromCharCode(currentValue));
1336 }
1337 }
1338
1339 var basicLength = output.length; // number of basic code points.
1340 var handledCPCount = basicLength; // number of code points that have been handled;
1341
1342 // Finish the basic string with a delimiter unless it's empty.
1343 if (basicLength) {
1344 output.push(delimiter);
1345 }
1346
1347 // Main encoding loop:
1348 while (handledCPCount < inputLength) {
1349 // All non-basic code points < n have been handled already. Find the next larger one:
1350 var m = maxInt;
1351 for (i = 0; i < input.length; i++) {
1352 currentValue = input[i];
1353 if (currentValue >= n && currentValue < m) {
1354 m = currentValue;
1355 }
1356 }
1357
1358 // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.
1359 var handledCPCountPlusOne = handledCPCount + 1;
1360 if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
1361 throw RangeError(OVERFLOW_ERROR);
1362 }
1363
1364 delta += (m - n) * handledCPCountPlusOne;
1365 n = m;
1366
1367 for (i = 0; i < input.length; i++) {
1368 currentValue = input[i];
1369 if (currentValue < n && ++delta > maxInt) {
1370 throw RangeError(OVERFLOW_ERROR);
1371 }
1372 if (currentValue == n) {
1373 // Represent delta as a generalized variable-length integer.
1374 var q = delta;
1375 for (var k = base; /* no condition */; k += base) {
1376 var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
1377 if (q < t) break;
1378 var qMinusT = q - t;
1379 var baseMinusT = base - t;
1380 output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
1381 q = floor(qMinusT / baseMinusT);
1382 }
1383
1384 output.push(stringFromCharCode(digitToBasic(q)));
1385 bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
1386 delta = 0;
1387 ++handledCPCount;
1388 }
1389 }
1390
1391 ++delta;
1392 ++n;
1393 }
1394 return output.join('');
1395};
1396
1397module.exports = function (input) {
1398 var encoded = [];
1399 var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.');
1400 var i, label;
1401 for (i = 0; i < labels.length; i++) {
1402 label = labels[i];
1403 encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label);
1404 }
1405 return encoded.join('.');
1406};
1407
1408},{}],68:[function(require,module,exports){
1409var toInteger = require('../internals/to-integer');
1410
1411var max = Math.max;
1412var min = Math.min;
1413
1414// Helper for a popular repeating case of the spec:
1415// Let integer be ? ToInteger(index).
1416// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1417module.exports = function (index, length) {
1418 var integer = toInteger(index);
1419 return integer < 0 ? max(integer + length, 0) : min(integer, length);
1420};
1421
1422},{"../internals/to-integer":70}],69:[function(require,module,exports){
1423// toObject with fallback for non-array-like ES3 strings
1424var IndexedObject = require('../internals/indexed-object');
1425var requireObjectCoercible = require('../internals/require-object-coercible');
1426
1427module.exports = function (it) {
1428 return IndexedObject(requireObjectCoercible(it));
1429};
1430
1431},{"../internals/indexed-object":32,"../internals/require-object-coercible":60}],70:[function(require,module,exports){
1432var ceil = Math.ceil;
1433var floor = Math.floor;
1434
1435// `ToInteger` abstract operation
1436// https://tc39.github.io/ecma262/#sec-tointeger
1437module.exports = function (argument) {
1438 return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
1439};
1440
1441},{}],71:[function(require,module,exports){
1442var toInteger = require('../internals/to-integer');
1443
1444var min = Math.min;
1445
1446// `ToLength` abstract operation
1447// https://tc39.github.io/ecma262/#sec-tolength
1448module.exports = function (argument) {
1449 return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1450};
1451
1452},{"../internals/to-integer":70}],72:[function(require,module,exports){
1453var requireObjectCoercible = require('../internals/require-object-coercible');
1454
1455// `ToObject` abstract operation
1456// https://tc39.github.io/ecma262/#sec-toobject
1457module.exports = function (argument) {
1458 return Object(requireObjectCoercible(argument));
1459};
1460
1461},{"../internals/require-object-coercible":60}],73:[function(require,module,exports){
1462var isObject = require('../internals/is-object');
1463
1464// `ToPrimitive` abstract operation
1465// https://tc39.github.io/ecma262/#sec-toprimitive
1466// instead of the ES6 spec version, we didn't implement @@toPrimitive case
1467// and the second argument - flag - preferred type is a string
1468module.exports = function (input, PREFERRED_STRING) {
1469 if (!isObject(input)) return input;
1470 var fn, val;
1471 if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
1472 if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
1473 if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
1474 throw TypeError("Can't convert object to primitive value");
1475};
1476
1477},{"../internals/is-object":37}],74:[function(require,module,exports){
1478var wellKnownSymbol = require('../internals/well-known-symbol');
1479
1480var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1481var test = {};
1482
1483test[TO_STRING_TAG] = 'z';
1484
1485module.exports = String(test) === '[object z]';
1486
1487},{"../internals/well-known-symbol":77}],75:[function(require,module,exports){
1488var id = 0;
1489var postfix = Math.random();
1490
1491module.exports = function (key) {
1492 return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
1493};
1494
1495},{}],76:[function(require,module,exports){
1496var NATIVE_SYMBOL = require('../internals/native-symbol');
1497
1498module.exports = NATIVE_SYMBOL
1499 // eslint-disable-next-line no-undef
1500 && !Symbol.sham
1501 // eslint-disable-next-line no-undef
1502 && typeof Symbol.iterator == 'symbol';
1503
1504},{"../internals/native-symbol":41}],77:[function(require,module,exports){
1505var global = require('../internals/global');
1506var shared = require('../internals/shared');
1507var has = require('../internals/has');
1508var uid = require('../internals/uid');
1509var NATIVE_SYMBOL = require('../internals/native-symbol');
1510var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');
1511
1512var WellKnownSymbolsStore = shared('wks');
1513var Symbol = global.Symbol;
1514var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
1515
1516module.exports = function (name) {
1517 if (!has(WellKnownSymbolsStore, name)) {
1518 if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];
1519 else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
1520 } return WellKnownSymbolsStore[name];
1521};
1522
1523},{"../internals/global":27,"../internals/has":28,"../internals/native-symbol":41,"../internals/shared":65,"../internals/uid":75,"../internals/use-symbol-as-uid":76}],78:[function(require,module,exports){
1524'use strict';
1525var toIndexedObject = require('../internals/to-indexed-object');
1526var addToUnscopables = require('../internals/add-to-unscopables');
1527var Iterators = require('../internals/iterators');
1528var InternalStateModule = require('../internals/internal-state');
1529var defineIterator = require('../internals/define-iterator');
1530
1531var ARRAY_ITERATOR = 'Array Iterator';
1532var setInternalState = InternalStateModule.set;
1533var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
1534
1535// `Array.prototype.entries` method
1536// https://tc39.github.io/ecma262/#sec-array.prototype.entries
1537// `Array.prototype.keys` method
1538// https://tc39.github.io/ecma262/#sec-array.prototype.keys
1539// `Array.prototype.values` method
1540// https://tc39.github.io/ecma262/#sec-array.prototype.values
1541// `Array.prototype[@@iterator]` method
1542// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
1543// `CreateArrayIterator` internal method
1544// https://tc39.github.io/ecma262/#sec-createarrayiterator
1545module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
1546 setInternalState(this, {
1547 type: ARRAY_ITERATOR,
1548 target: toIndexedObject(iterated), // target
1549 index: 0, // next index
1550 kind: kind // kind
1551 });
1552// `%ArrayIteratorPrototype%.next` method
1553// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
1554}, function () {
1555 var state = getInternalState(this);
1556 var target = state.target;
1557 var kind = state.kind;
1558 var index = state.index++;
1559 if (!target || index >= target.length) {
1560 state.target = undefined;
1561 return { value: undefined, done: true };
1562 }
1563 if (kind == 'keys') return { value: index, done: false };
1564 if (kind == 'values') return { value: target[index], done: false };
1565 return { value: [index, target[index]], done: false };
1566}, 'values');
1567
1568// argumentsList[@@iterator] is %ArrayProto_values%
1569// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject
1570// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject
1571Iterators.Arguments = Iterators.Array;
1572
1573// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
1574addToUnscopables('keys');
1575addToUnscopables('values');
1576addToUnscopables('entries');
1577
1578},{"../internals/add-to-unscopables":3,"../internals/define-iterator":17,"../internals/internal-state":34,"../internals/iterators":40,"../internals/to-indexed-object":69}],79:[function(require,module,exports){
1579'use strict';
1580var charAt = require('../internals/string-multibyte').charAt;
1581var InternalStateModule = require('../internals/internal-state');
1582var defineIterator = require('../internals/define-iterator');
1583
1584var STRING_ITERATOR = 'String Iterator';
1585var setInternalState = InternalStateModule.set;
1586var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
1587
1588// `String.prototype[@@iterator]` method
1589// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
1590defineIterator(String, 'String', function (iterated) {
1591 setInternalState(this, {
1592 type: STRING_ITERATOR,
1593 string: String(iterated),
1594 index: 0
1595 });
1596// `%StringIteratorPrototype%.next` method
1597// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
1598}, function next() {
1599 var state = getInternalState(this);
1600 var string = state.string;
1601 var index = state.index;
1602 var point;
1603 if (index >= string.length) return { value: undefined, done: true };
1604 point = charAt(string, index);
1605 state.index += point.length;
1606 return { value: point, done: false };
1607});
1608
1609},{"../internals/define-iterator":17,"../internals/internal-state":34,"../internals/string-multibyte":66}],80:[function(require,module,exports){
1610'use strict';
1611// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
1612require('../modules/es.array.iterator');
1613var $ = require('../internals/export');
1614var getBuiltIn = require('../internals/get-built-in');
1615var USE_NATIVE_URL = require('../internals/native-url');
1616var redefine = require('../internals/redefine');
1617var redefineAll = require('../internals/redefine-all');
1618var setToStringTag = require('../internals/set-to-string-tag');
1619var createIteratorConstructor = require('../internals/create-iterator-constructor');
1620var InternalStateModule = require('../internals/internal-state');
1621var anInstance = require('../internals/an-instance');
1622var hasOwn = require('../internals/has');
1623var bind = require('../internals/function-bind-context');
1624var classof = require('../internals/classof');
1625var anObject = require('../internals/an-object');
1626var isObject = require('../internals/is-object');
1627var create = require('../internals/object-create');
1628var createPropertyDescriptor = require('../internals/create-property-descriptor');
1629var getIterator = require('../internals/get-iterator');
1630var getIteratorMethod = require('../internals/get-iterator-method');
1631var wellKnownSymbol = require('../internals/well-known-symbol');
1632
1633var $fetch = getBuiltIn('fetch');
1634var Headers = getBuiltIn('Headers');
1635var ITERATOR = wellKnownSymbol('iterator');
1636var URL_SEARCH_PARAMS = 'URLSearchParams';
1637var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
1638var setInternalState = InternalStateModule.set;
1639var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
1640var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
1641
1642var plus = /\+/g;
1643var sequences = Array(4);
1644
1645var percentSequence = function (bytes) {
1646 return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
1647};
1648
1649var percentDecode = function (sequence) {
1650 try {
1651 return decodeURIComponent(sequence);
1652 } catch (error) {
1653 return sequence;
1654 }
1655};
1656
1657var deserialize = function (it) {
1658 var result = it.replace(plus, ' ');
1659 var bytes = 4;
1660 try {
1661 return decodeURIComponent(result);
1662 } catch (error) {
1663 while (bytes) {
1664 result = result.replace(percentSequence(bytes--), percentDecode);
1665 }
1666 return result;
1667 }
1668};
1669
1670var find = /[!'()~]|%20/g;
1671
1672var replace = {
1673 '!': '%21',
1674 "'": '%27',
1675 '(': '%28',
1676 ')': '%29',
1677 '~': '%7E',
1678 '%20': '+'
1679};
1680
1681var replacer = function (match) {
1682 return replace[match];
1683};
1684
1685var serialize = function (it) {
1686 return encodeURIComponent(it).replace(find, replacer);
1687};
1688
1689var parseSearchParams = function (result, query) {
1690 if (query) {
1691 var attributes = query.split('&');
1692 var index = 0;
1693 var attribute, entry;
1694 while (index < attributes.length) {
1695 attribute = attributes[index++];
1696 if (attribute.length) {
1697 entry = attribute.split('=');
1698 result.push({
1699 key: deserialize(entry.shift()),
1700 value: deserialize(entry.join('='))
1701 });
1702 }
1703 }
1704 }
1705};
1706
1707var updateSearchParams = function (query) {
1708 this.entries.length = 0;
1709 parseSearchParams(this.entries, query);
1710};
1711
1712var validateArgumentsLength = function (passed, required) {
1713 if (passed < required) throw TypeError('Not enough arguments');
1714};
1715
1716var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
1717 setInternalState(this, {
1718 type: URL_SEARCH_PARAMS_ITERATOR,
1719 iterator: getIterator(getInternalParamsState(params).entries),
1720 kind: kind
1721 });
1722}, 'Iterator', function next() {
1723 var state = getInternalIteratorState(this);
1724 var kind = state.kind;
1725 var step = state.iterator.next();
1726 var entry = step.value;
1727 if (!step.done) {
1728 step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
1729 } return step;
1730});
1731
1732// `URLSearchParams` constructor
1733// https://url.spec.whatwg.org/#interface-urlsearchparams
1734var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
1735 anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);
1736 var init = arguments.length > 0 ? arguments[0] : undefined;
1737 var that = this;
1738 var entries = [];
1739 var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;
1740
1741 setInternalState(that, {
1742 type: URL_SEARCH_PARAMS,
1743 entries: entries,
1744 updateURL: function () { /* empty */ },
1745 updateSearchParams: updateSearchParams
1746 });
1747
1748 if (init !== undefined) {
1749 if (isObject(init)) {
1750 iteratorMethod = getIteratorMethod(init);
1751 if (typeof iteratorMethod === 'function') {
1752 iterator = iteratorMethod.call(init);
1753 next = iterator.next;
1754 while (!(step = next.call(iterator)).done) {
1755 entryIterator = getIterator(anObject(step.value));
1756 entryNext = entryIterator.next;
1757 if (
1758 (first = entryNext.call(entryIterator)).done ||
1759 (second = entryNext.call(entryIterator)).done ||
1760 !entryNext.call(entryIterator).done
1761 ) throw TypeError('Expected sequence with length 2');
1762 entries.push({ key: first.value + '', value: second.value + '' });
1763 }
1764 } else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' });
1765 } else {
1766 parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');
1767 }
1768 }
1769};
1770
1771var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
1772
1773redefineAll(URLSearchParamsPrototype, {
1774 // `URLSearchParams.prototype.appent` method
1775 // https://url.spec.whatwg.org/#dom-urlsearchparams-append
1776 append: function append(name, value) {
1777 validateArgumentsLength(arguments.length, 2);
1778 var state = getInternalParamsState(this);
1779 state.entries.push({ key: name + '', value: value + '' });
1780 state.updateURL();
1781 },
1782 // `URLSearchParams.prototype.delete` method
1783 // https://url.spec.whatwg.org/#dom-urlsearchparams-delete
1784 'delete': function (name) {
1785 validateArgumentsLength(arguments.length, 1);
1786 var state = getInternalParamsState(this);
1787 var entries = state.entries;
1788 var key = name + '';
1789 var index = 0;
1790 while (index < entries.length) {
1791 if (entries[index].key === key) entries.splice(index, 1);
1792 else index++;
1793 }
1794 state.updateURL();
1795 },
1796 // `URLSearchParams.prototype.get` method
1797 // https://url.spec.whatwg.org/#dom-urlsearchparams-get
1798 get: function get(name) {
1799 validateArgumentsLength(arguments.length, 1);
1800 var entries = getInternalParamsState(this).entries;
1801 var key = name + '';
1802 var index = 0;
1803 for (; index < entries.length; index++) {
1804 if (entries[index].key === key) return entries[index].value;
1805 }
1806 return null;
1807 },
1808 // `URLSearchParams.prototype.getAll` method
1809 // https://url.spec.whatwg.org/#dom-urlsearchparams-getall
1810 getAll: function getAll(name) {
1811 validateArgumentsLength(arguments.length, 1);
1812 var entries = getInternalParamsState(this).entries;
1813 var key = name + '';
1814 var result = [];
1815 var index = 0;
1816 for (; index < entries.length; index++) {
1817 if (entries[index].key === key) result.push(entries[index].value);
1818 }
1819 return result;
1820 },
1821 // `URLSearchParams.prototype.has` method
1822 // https://url.spec.whatwg.org/#dom-urlsearchparams-has
1823 has: function has(name) {
1824 validateArgumentsLength(arguments.length, 1);
1825 var entries = getInternalParamsState(this).entries;
1826 var key = name + '';
1827 var index = 0;
1828 while (index < entries.length) {
1829 if (entries[index++].key === key) return true;
1830 }
1831 return false;
1832 },
1833 // `URLSearchParams.prototype.set` method
1834 // https://url.spec.whatwg.org/#dom-urlsearchparams-set
1835 set: function set(name, value) {
1836 validateArgumentsLength(arguments.length, 1);
1837 var state = getInternalParamsState(this);
1838 var entries = state.entries;
1839 var found = false;
1840 var key = name + '';
1841 var val = value + '';
1842 var index = 0;
1843 var entry;
1844 for (; index < entries.length; index++) {
1845 entry = entries[index];
1846 if (entry.key === key) {
1847 if (found) entries.splice(index--, 1);
1848 else {
1849 found = true;
1850 entry.value = val;
1851 }
1852 }
1853 }
1854 if (!found) entries.push({ key: key, value: val });
1855 state.updateURL();
1856 },
1857 // `URLSearchParams.prototype.sort` method
1858 // https://url.spec.whatwg.org/#dom-urlsearchparams-sort
1859 sort: function sort() {
1860 var state = getInternalParamsState(this);
1861 var entries = state.entries;
1862 // Array#sort is not stable in some engines
1863 var slice = entries.slice();
1864 var entry, entriesIndex, sliceIndex;
1865 entries.length = 0;
1866 for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {
1867 entry = slice[sliceIndex];
1868 for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {
1869 if (entries[entriesIndex].key > entry.key) {
1870 entries.splice(entriesIndex, 0, entry);
1871 break;
1872 }
1873 }
1874 if (entriesIndex === sliceIndex) entries.push(entry);
1875 }
1876 state.updateURL();
1877 },
1878 // `URLSearchParams.prototype.forEach` method
1879 forEach: function forEach(callback /* , thisArg */) {
1880 var entries = getInternalParamsState(this).entries;
1881 var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);
1882 var index = 0;
1883 var entry;
1884 while (index < entries.length) {
1885 entry = entries[index++];
1886 boundFunction(entry.value, entry.key, this);
1887 }
1888 },
1889 // `URLSearchParams.prototype.keys` method
1890 keys: function keys() {
1891 return new URLSearchParamsIterator(this, 'keys');
1892 },
1893 // `URLSearchParams.prototype.values` method
1894 values: function values() {
1895 return new URLSearchParamsIterator(this, 'values');
1896 },
1897 // `URLSearchParams.prototype.entries` method
1898 entries: function entries() {
1899 return new URLSearchParamsIterator(this, 'entries');
1900 }
1901}, { enumerable: true });
1902
1903// `URLSearchParams.prototype[@@iterator]` method
1904redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);
1905
1906// `URLSearchParams.prototype.toString` method
1907// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
1908redefine(URLSearchParamsPrototype, 'toString', function toString() {
1909 var entries = getInternalParamsState(this).entries;
1910 var result = [];
1911 var index = 0;
1912 var entry;
1913 while (index < entries.length) {
1914 entry = entries[index++];
1915 result.push(serialize(entry.key) + '=' + serialize(entry.value));
1916 } return result.join('&');
1917}, { enumerable: true });
1918
1919setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
1920
1921$({ global: true, forced: !USE_NATIVE_URL }, {
1922 URLSearchParams: URLSearchParamsConstructor
1923});
1924
1925// Wrap `fetch` for correct work with polyfilled `URLSearchParams`
1926// https://github.com/zloirock/core-js/issues/674
1927if (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {
1928 $({ global: true, enumerable: true, forced: true }, {
1929 fetch: function fetch(input /* , init */) {
1930 var args = [input];
1931 var init, body, headers;
1932 if (arguments.length > 1) {
1933 init = arguments[1];
1934 if (isObject(init)) {
1935 body = init.body;
1936 if (classof(body) === URL_SEARCH_PARAMS) {
1937 headers = init.headers ? new Headers(init.headers) : new Headers();
1938 if (!headers.has('content-type')) {
1939 headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
1940 }
1941 init = create(init, {
1942 body: createPropertyDescriptor(0, String(body)),
1943 headers: createPropertyDescriptor(0, headers)
1944 });
1945 }
1946 }
1947 args.push(init);
1948 } return $fetch.apply(this, args);
1949 }
1950 });
1951}
1952
1953module.exports = {
1954 URLSearchParams: URLSearchParamsConstructor,
1955 getState: getInternalParamsState
1956};
1957
1958},{"../internals/an-instance":4,"../internals/an-object":5,"../internals/classof":10,"../internals/create-iterator-constructor":13,"../internals/create-property-descriptor":15,"../internals/export":21,"../internals/function-bind-context":23,"../internals/get-built-in":24,"../internals/get-iterator":26,"../internals/get-iterator-method":25,"../internals/has":28,"../internals/internal-state":34,"../internals/is-object":37,"../internals/native-url":42,"../internals/object-create":45,"../internals/redefine":59,"../internals/redefine-all":58,"../internals/set-to-string-tag":62,"../internals/well-known-symbol":77,"../modules/es.array.iterator":78}],81:[function(require,module,exports){
1959'use strict';
1960// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
1961require('../modules/es.string.iterator');
1962var $ = require('../internals/export');
1963var DESCRIPTORS = require('../internals/descriptors');
1964var USE_NATIVE_URL = require('../internals/native-url');
1965var global = require('../internals/global');
1966var defineProperties = require('../internals/object-define-properties');
1967var redefine = require('../internals/redefine');
1968var anInstance = require('../internals/an-instance');
1969var has = require('../internals/has');
1970var assign = require('../internals/object-assign');
1971var arrayFrom = require('../internals/array-from');
1972var codeAt = require('../internals/string-multibyte').codeAt;
1973var toASCII = require('../internals/string-punycode-to-ascii');
1974var setToStringTag = require('../internals/set-to-string-tag');
1975var URLSearchParamsModule = require('../modules/web.url-search-params');
1976var InternalStateModule = require('../internals/internal-state');
1977
1978var NativeURL = global.URL;
1979var URLSearchParams = URLSearchParamsModule.URLSearchParams;
1980var getInternalSearchParamsState = URLSearchParamsModule.getState;
1981var setInternalState = InternalStateModule.set;
1982var getInternalURLState = InternalStateModule.getterFor('URL');
1983var floor = Math.floor;
1984var pow = Math.pow;
1985
1986var INVALID_AUTHORITY = 'Invalid authority';
1987var INVALID_SCHEME = 'Invalid scheme';
1988var INVALID_HOST = 'Invalid host';
1989var INVALID_PORT = 'Invalid port';
1990
1991var ALPHA = /[A-Za-z]/;
1992var ALPHANUMERIC = /[\d+\-.A-Za-z]/;
1993var DIGIT = /\d/;
1994var HEX_START = /^(0x|0X)/;
1995var OCT = /^[0-7]+$/;
1996var DEC = /^\d+$/;
1997var HEX = /^[\dA-Fa-f]+$/;
1998// eslint-disable-next-line no-control-regex
1999var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/;
2000// eslint-disable-next-line no-control-regex
2001var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/;
2002// eslint-disable-next-line no-control-regex
2003var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g;
2004// eslint-disable-next-line no-control-regex
2005var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g;
2006var EOF;
2007
2008var parseHost = function (url, input) {
2009 var result, codePoints, index;
2010 if (input.charAt(0) == '[') {
2011 if (input.charAt(input.length - 1) != ']') return INVALID_HOST;
2012 result = parseIPv6(input.slice(1, -1));
2013 if (!result) return INVALID_HOST;
2014 url.host = result;
2015 // opaque host
2016 } else if (!isSpecial(url)) {
2017 if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST;
2018 result = '';
2019 codePoints = arrayFrom(input);
2020 for (index = 0; index < codePoints.length; index++) {
2021 result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
2022 }
2023 url.host = result;
2024 } else {
2025 input = toASCII(input);
2026 if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST;
2027 result = parseIPv4(input);
2028 if (result === null) return INVALID_HOST;
2029 url.host = result;
2030 }
2031};
2032
2033var parseIPv4 = function (input) {
2034 var parts = input.split('.');
2035 var partsLength, numbers, index, part, radix, number, ipv4;
2036 if (parts.length && parts[parts.length - 1] == '') {
2037 parts.pop();
2038 }
2039 partsLength = parts.length;
2040 if (partsLength > 4) return input;
2041 numbers = [];
2042 for (index = 0; index < partsLength; index++) {
2043 part = parts[index];
2044 if (part == '') return input;
2045 radix = 10;
2046 if (part.length > 1 && part.charAt(0) == '0') {
2047 radix = HEX_START.test(part) ? 16 : 8;
2048 part = part.slice(radix == 8 ? 1 : 2);
2049 }
2050 if (part === '') {
2051 number = 0;
2052 } else {
2053 if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input;
2054 number = parseInt(part, radix);
2055 }
2056 numbers.push(number);
2057 }
2058 for (index = 0; index < partsLength; index++) {
2059 number = numbers[index];
2060 if (index == partsLength - 1) {
2061 if (number >= pow(256, 5 - partsLength)) return null;
2062 } else if (number > 255) return null;
2063 }
2064 ipv4 = numbers.pop();
2065 for (index = 0; index < numbers.length; index++) {
2066 ipv4 += numbers[index] * pow(256, 3 - index);
2067 }
2068 return ipv4;
2069};
2070
2071// eslint-disable-next-line max-statements
2072var parseIPv6 = function (input) {
2073 var address = [0, 0, 0, 0, 0, 0, 0, 0];
2074 var pieceIndex = 0;
2075 var compress = null;
2076 var pointer = 0;
2077 var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
2078
2079 var char = function () {
2080 return input.charAt(pointer);
2081 };
2082
2083 if (char() == ':') {
2084 if (input.charAt(1) != ':') return;
2085 pointer += 2;
2086 pieceIndex++;
2087 compress = pieceIndex;
2088 }
2089 while (char()) {
2090 if (pieceIndex == 8) return;
2091 if (char() == ':') {
2092 if (compress !== null) return;
2093 pointer++;
2094 pieceIndex++;
2095 compress = pieceIndex;
2096 continue;
2097 }
2098 value = length = 0;
2099 while (length < 4 && HEX.test(char())) {
2100 value = value * 16 + parseInt(char(), 16);
2101 pointer++;
2102 length++;
2103 }
2104 if (char() == '.') {
2105 if (length == 0) return;
2106 pointer -= length;
2107 if (pieceIndex > 6) return;
2108 numbersSeen = 0;
2109 while (char()) {
2110 ipv4Piece = null;
2111 if (numbersSeen > 0) {
2112 if (char() == '.' && numbersSeen < 4) pointer++;
2113 else return;
2114 }
2115 if (!DIGIT.test(char())) return;
2116 while (DIGIT.test(char())) {
2117 number = parseInt(char(), 10);
2118 if (ipv4Piece === null) ipv4Piece = number;
2119 else if (ipv4Piece == 0) return;
2120 else ipv4Piece = ipv4Piece * 10 + number;
2121 if (ipv4Piece > 255) return;
2122 pointer++;
2123 }
2124 address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
2125 numbersSeen++;
2126 if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;
2127 }
2128 if (numbersSeen != 4) return;
2129 break;
2130 } else if (char() == ':') {
2131 pointer++;
2132 if (!char()) return;
2133 } else if (char()) return;
2134 address[pieceIndex++] = value;
2135 }
2136 if (compress !== null) {
2137 swaps = pieceIndex - compress;
2138 pieceIndex = 7;
2139 while (pieceIndex != 0 && swaps > 0) {
2140 swap = address[pieceIndex];
2141 address[pieceIndex--] = address[compress + swaps - 1];
2142 address[compress + --swaps] = swap;
2143 }
2144 } else if (pieceIndex != 8) return;
2145 return address;
2146};
2147
2148var findLongestZeroSequence = function (ipv6) {
2149 var maxIndex = null;
2150 var maxLength = 1;
2151 var currStart = null;
2152 var currLength = 0;
2153 var index = 0;
2154 for (; index < 8; index++) {
2155 if (ipv6[index] !== 0) {
2156 if (currLength > maxLength) {
2157 maxIndex = currStart;
2158 maxLength = currLength;
2159 }
2160 currStart = null;
2161 currLength = 0;
2162 } else {
2163 if (currStart === null) currStart = index;
2164 ++currLength;
2165 }
2166 }
2167 if (currLength > maxLength) {
2168 maxIndex = currStart;
2169 maxLength = currLength;
2170 }
2171 return maxIndex;
2172};
2173
2174var serializeHost = function (host) {
2175 var result, index, compress, ignore0;
2176 // ipv4
2177 if (typeof host == 'number') {
2178 result = [];
2179 for (index = 0; index < 4; index++) {
2180 result.unshift(host % 256);
2181 host = floor(host / 256);
2182 } return result.join('.');
2183 // ipv6
2184 } else if (typeof host == 'object') {
2185 result = '';
2186 compress = findLongestZeroSequence(host);
2187 for (index = 0; index < 8; index++) {
2188 if (ignore0 && host[index] === 0) continue;
2189 if (ignore0) ignore0 = false;
2190 if (compress === index) {
2191 result += index ? ':' : '::';
2192 ignore0 = true;
2193 } else {
2194 result += host[index].toString(16);
2195 if (index < 7) result += ':';
2196 }
2197 }
2198 return '[' + result + ']';
2199 } return host;
2200};
2201
2202var C0ControlPercentEncodeSet = {};
2203var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
2204 ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
2205});
2206var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
2207 '#': 1, '?': 1, '{': 1, '}': 1
2208});
2209var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
2210 '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1
2211});
2212
2213var percentEncode = function (char, set) {
2214 var code = codeAt(char, 0);
2215 return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);
2216};
2217
2218var specialSchemes = {
2219 ftp: 21,
2220 file: null,
2221 http: 80,
2222 https: 443,
2223 ws: 80,
2224 wss: 443
2225};
2226
2227var isSpecial = function (url) {
2228 return has(specialSchemes, url.scheme);
2229};
2230
2231var includesCredentials = function (url) {
2232 return url.username != '' || url.password != '';
2233};
2234
2235var cannotHaveUsernamePasswordPort = function (url) {
2236 return !url.host || url.cannotBeABaseURL || url.scheme == 'file';
2237};
2238
2239var isWindowsDriveLetter = function (string, normalized) {
2240 var second;
2241 return string.length == 2 && ALPHA.test(string.charAt(0))
2242 && ((second = string.charAt(1)) == ':' || (!normalized && second == '|'));
2243};
2244
2245var startsWithWindowsDriveLetter = function (string) {
2246 var third;
2247 return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (
2248 string.length == 2 ||
2249 ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#')
2250 );
2251};
2252
2253var shortenURLsPath = function (url) {
2254 var path = url.path;
2255 var pathSize = path.length;
2256 if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {
2257 path.pop();
2258 }
2259};
2260
2261var isSingleDot = function (segment) {
2262 return segment === '.' || segment.toLowerCase() === '%2e';
2263};
2264
2265var isDoubleDot = function (segment) {
2266 segment = segment.toLowerCase();
2267 return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
2268};
2269
2270// States:
2271var SCHEME_START = {};
2272var SCHEME = {};
2273var NO_SCHEME = {};
2274var SPECIAL_RELATIVE_OR_AUTHORITY = {};
2275var PATH_OR_AUTHORITY = {};
2276var RELATIVE = {};
2277var RELATIVE_SLASH = {};
2278var SPECIAL_AUTHORITY_SLASHES = {};
2279var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
2280var AUTHORITY = {};
2281var HOST = {};
2282var HOSTNAME = {};
2283var PORT = {};
2284var FILE = {};
2285var FILE_SLASH = {};
2286var FILE_HOST = {};
2287var PATH_START = {};
2288var PATH = {};
2289var CANNOT_BE_A_BASE_URL_PATH = {};
2290var QUERY = {};
2291var FRAGMENT = {};
2292
2293// eslint-disable-next-line max-statements
2294var parseURL = function (url, input, stateOverride, base) {
2295 var state = stateOverride || SCHEME_START;
2296 var pointer = 0;
2297 var buffer = '';
2298 var seenAt = false;
2299 var seenBracket = false;
2300 var seenPasswordToken = false;
2301 var codePoints, char, bufferCodePoints, failure;
2302
2303 if (!stateOverride) {
2304 url.scheme = '';
2305 url.username = '';
2306 url.password = '';
2307 url.host = null;
2308 url.port = null;
2309 url.path = [];
2310 url.query = null;
2311 url.fragment = null;
2312 url.cannotBeABaseURL = false;
2313 input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');
2314 }
2315
2316 input = input.replace(TAB_AND_NEW_LINE, '');
2317
2318 codePoints = arrayFrom(input);
2319
2320 while (pointer <= codePoints.length) {
2321 char = codePoints[pointer];
2322 switch (state) {
2323 case SCHEME_START:
2324 if (char && ALPHA.test(char)) {
2325 buffer += char.toLowerCase();
2326 state = SCHEME;
2327 } else if (!stateOverride) {
2328 state = NO_SCHEME;
2329 continue;
2330 } else return INVALID_SCHEME;
2331 break;
2332
2333 case SCHEME:
2334 if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {
2335 buffer += char.toLowerCase();
2336 } else if (char == ':') {
2337 if (stateOverride && (
2338 (isSpecial(url) != has(specialSchemes, buffer)) ||
2339 (buffer == 'file' && (includesCredentials(url) || url.port !== null)) ||
2340 (url.scheme == 'file' && !url.host)
2341 )) return;
2342 url.scheme = buffer;
2343 if (stateOverride) {
2344 if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null;
2345 return;
2346 }
2347 buffer = '';
2348 if (url.scheme == 'file') {
2349 state = FILE;
2350 } else if (isSpecial(url) && base && base.scheme == url.scheme) {
2351 state = SPECIAL_RELATIVE_OR_AUTHORITY;
2352 } else if (isSpecial(url)) {
2353 state = SPECIAL_AUTHORITY_SLASHES;
2354 } else if (codePoints[pointer + 1] == '/') {
2355 state = PATH_OR_AUTHORITY;
2356 pointer++;
2357 } else {
2358 url.cannotBeABaseURL = true;
2359 url.path.push('');
2360 state = CANNOT_BE_A_BASE_URL_PATH;
2361 }
2362 } else if (!stateOverride) {
2363 buffer = '';
2364 state = NO_SCHEME;
2365 pointer = 0;
2366 continue;
2367 } else return INVALID_SCHEME;
2368 break;
2369
2370 case NO_SCHEME:
2371 if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME;
2372 if (base.cannotBeABaseURL && char == '#') {
2373 url.scheme = base.scheme;
2374 url.path = base.path.slice();
2375 url.query = base.query;
2376 url.fragment = '';
2377 url.cannotBeABaseURL = true;
2378 state = FRAGMENT;
2379 break;
2380 }
2381 state = base.scheme == 'file' ? FILE : RELATIVE;
2382 continue;
2383
2384 case SPECIAL_RELATIVE_OR_AUTHORITY:
2385 if (char == '/' && codePoints[pointer + 1] == '/') {
2386 state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
2387 pointer++;
2388 } else {
2389 state = RELATIVE;
2390 continue;
2391 } break;
2392
2393 case PATH_OR_AUTHORITY:
2394 if (char == '/') {
2395 state = AUTHORITY;
2396 break;
2397 } else {
2398 state = PATH;
2399 continue;
2400 }
2401
2402 case RELATIVE:
2403 url.scheme = base.scheme;
2404 if (char == EOF) {
2405 url.username = base.username;
2406 url.password = base.password;
2407 url.host = base.host;
2408 url.port = base.port;
2409 url.path = base.path.slice();
2410 url.query = base.query;
2411 } else if (char == '/' || (char == '\\' && isSpecial(url))) {
2412 state = RELATIVE_SLASH;
2413 } else if (char == '?') {
2414 url.username = base.username;
2415 url.password = base.password;
2416 url.host = base.host;
2417 url.port = base.port;
2418 url.path = base.path.slice();
2419 url.query = '';
2420 state = QUERY;
2421 } else if (char == '#') {
2422 url.username = base.username;
2423 url.password = base.password;
2424 url.host = base.host;
2425 url.port = base.port;
2426 url.path = base.path.slice();
2427 url.query = base.query;
2428 url.fragment = '';
2429 state = FRAGMENT;
2430 } else {
2431 url.username = base.username;
2432 url.password = base.password;
2433 url.host = base.host;
2434 url.port = base.port;
2435 url.path = base.path.slice();
2436 url.path.pop();
2437 state = PATH;
2438 continue;
2439 } break;
2440
2441 case RELATIVE_SLASH:
2442 if (isSpecial(url) && (char == '/' || char == '\\')) {
2443 state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
2444 } else if (char == '/') {
2445 state = AUTHORITY;
2446 } else {
2447 url.username = base.username;
2448 url.password = base.password;
2449 url.host = base.host;
2450 url.port = base.port;
2451 state = PATH;
2452 continue;
2453 } break;
2454
2455 case SPECIAL_AUTHORITY_SLASHES:
2456 state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
2457 if (char != '/' || buffer.charAt(pointer + 1) != '/') continue;
2458 pointer++;
2459 break;
2460
2461 case SPECIAL_AUTHORITY_IGNORE_SLASHES:
2462 if (char != '/' && char != '\\') {
2463 state = AUTHORITY;
2464 continue;
2465 } break;
2466
2467 case AUTHORITY:
2468 if (char == '@') {
2469 if (seenAt) buffer = '%40' + buffer;
2470 seenAt = true;
2471 bufferCodePoints = arrayFrom(buffer);
2472 for (var i = 0; i < bufferCodePoints.length; i++) {
2473 var codePoint = bufferCodePoints[i];
2474 if (codePoint == ':' && !seenPasswordToken) {
2475 seenPasswordToken = true;
2476 continue;
2477 }
2478 var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
2479 if (seenPasswordToken) url.password += encodedCodePoints;
2480 else url.username += encodedCodePoints;
2481 }
2482 buffer = '';
2483 } else if (
2484 char == EOF || char == '/' || char == '?' || char == '#' ||
2485 (char == '\\' && isSpecial(url))
2486 ) {
2487 if (seenAt && buffer == '') return INVALID_AUTHORITY;
2488 pointer -= arrayFrom(buffer).length + 1;
2489 buffer = '';
2490 state = HOST;
2491 } else buffer += char;
2492 break;
2493
2494 case HOST:
2495 case HOSTNAME:
2496 if (stateOverride && url.scheme == 'file') {
2497 state = FILE_HOST;
2498 continue;
2499 } else if (char == ':' && !seenBracket) {
2500 if (buffer == '') return INVALID_HOST;
2501 failure = parseHost(url, buffer);
2502 if (failure) return failure;
2503 buffer = '';
2504 state = PORT;
2505 if (stateOverride == HOSTNAME) return;
2506 } else if (
2507 char == EOF || char == '/' || char == '?' || char == '#' ||
2508 (char == '\\' && isSpecial(url))
2509 ) {
2510 if (isSpecial(url) && buffer == '') return INVALID_HOST;
2511 if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return;
2512 failure = parseHost(url, buffer);
2513 if (failure) return failure;
2514 buffer = '';
2515 state = PATH_START;
2516 if (stateOverride) return;
2517 continue;
2518 } else {
2519 if (char == '[') seenBracket = true;
2520 else if (char == ']') seenBracket = false;
2521 buffer += char;
2522 } break;
2523
2524 case PORT:
2525 if (DIGIT.test(char)) {
2526 buffer += char;
2527 } else if (
2528 char == EOF || char == '/' || char == '?' || char == '#' ||
2529 (char == '\\' && isSpecial(url)) ||
2530 stateOverride
2531 ) {
2532 if (buffer != '') {
2533 var port = parseInt(buffer, 10);
2534 if (port > 0xFFFF) return INVALID_PORT;
2535 url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port;
2536 buffer = '';
2537 }
2538 if (stateOverride) return;
2539 state = PATH_START;
2540 continue;
2541 } else return INVALID_PORT;
2542 break;
2543
2544 case FILE:
2545 url.scheme = 'file';
2546 if (char == '/' || char == '\\') state = FILE_SLASH;
2547 else if (base && base.scheme == 'file') {
2548 if (char == EOF) {
2549 url.host = base.host;
2550 url.path = base.path.slice();
2551 url.query = base.query;
2552 } else if (char == '?') {
2553 url.host = base.host;
2554 url.path = base.path.slice();
2555 url.query = '';
2556 state = QUERY;
2557 } else if (char == '#') {
2558 url.host = base.host;
2559 url.path = base.path.slice();
2560 url.query = base.query;
2561 url.fragment = '';
2562 state = FRAGMENT;
2563 } else {
2564 if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
2565 url.host = base.host;
2566 url.path = base.path.slice();
2567 shortenURLsPath(url);
2568 }
2569 state = PATH;
2570 continue;
2571 }
2572 } else {
2573 state = PATH;
2574 continue;
2575 } break;
2576
2577 case FILE_SLASH:
2578 if (char == '/' || char == '\\') {
2579 state = FILE_HOST;
2580 break;
2581 }
2582 if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
2583 if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]);
2584 else url.host = base.host;
2585 }
2586 state = PATH;
2587 continue;
2588
2589 case FILE_HOST:
2590 if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') {
2591 if (!stateOverride && isWindowsDriveLetter(buffer)) {
2592 state = PATH;
2593 } else if (buffer == '') {
2594 url.host = '';
2595 if (stateOverride) return;
2596 state = PATH_START;
2597 } else {
2598 failure = parseHost(url, buffer);
2599 if (failure) return failure;
2600 if (url.host == 'localhost') url.host = '';
2601 if (stateOverride) return;
2602 buffer = '';
2603 state = PATH_START;
2604 } continue;
2605 } else buffer += char;
2606 break;
2607
2608 case PATH_START:
2609 if (isSpecial(url)) {
2610 state = PATH;
2611 if (char != '/' && char != '\\') continue;
2612 } else if (!stateOverride && char == '?') {
2613 url.query = '';
2614 state = QUERY;
2615 } else if (!stateOverride && char == '#') {
2616 url.fragment = '';
2617 state = FRAGMENT;
2618 } else if (char != EOF) {
2619 state = PATH;
2620 if (char != '/') continue;
2621 } break;
2622
2623 case PATH:
2624 if (
2625 char == EOF || char == '/' ||
2626 (char == '\\' && isSpecial(url)) ||
2627 (!stateOverride && (char == '?' || char == '#'))
2628 ) {
2629 if (isDoubleDot(buffer)) {
2630 shortenURLsPath(url);
2631 if (char != '/' && !(char == '\\' && isSpecial(url))) {
2632 url.path.push('');
2633 }
2634 } else if (isSingleDot(buffer)) {
2635 if (char != '/' && !(char == '\\' && isSpecial(url))) {
2636 url.path.push('');
2637 }
2638 } else {
2639 if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
2640 if (url.host) url.host = '';
2641 buffer = buffer.charAt(0) + ':'; // normalize windows drive letter
2642 }
2643 url.path.push(buffer);
2644 }
2645 buffer = '';
2646 if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {
2647 while (url.path.length > 1 && url.path[0] === '') {
2648 url.path.shift();
2649 }
2650 }
2651 if (char == '?') {
2652 url.query = '';
2653 state = QUERY;
2654 } else if (char == '#') {
2655 url.fragment = '';
2656 state = FRAGMENT;
2657 }
2658 } else {
2659 buffer += percentEncode(char, pathPercentEncodeSet);
2660 } break;
2661
2662 case CANNOT_BE_A_BASE_URL_PATH:
2663 if (char == '?') {
2664 url.query = '';
2665 state = QUERY;
2666 } else if (char == '#') {
2667 url.fragment = '';
2668 state = FRAGMENT;
2669 } else if (char != EOF) {
2670 url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);
2671 } break;
2672
2673 case QUERY:
2674 if (!stateOverride && char == '#') {
2675 url.fragment = '';
2676 state = FRAGMENT;
2677 } else if (char != EOF) {
2678 if (char == "'" && isSpecial(url)) url.query += '%27';
2679 else if (char == '#') url.query += '%23';
2680 else url.query += percentEncode(char, C0ControlPercentEncodeSet);
2681 } break;
2682
2683 case FRAGMENT:
2684 if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet);
2685 break;
2686 }
2687
2688 pointer++;
2689 }
2690};
2691
2692// `URL` constructor
2693// https://url.spec.whatwg.org/#url-class
2694var URLConstructor = function URL(url /* , base */) {
2695 var that = anInstance(this, URLConstructor, 'URL');
2696 var base = arguments.length > 1 ? arguments[1] : undefined;
2697 var urlString = String(url);
2698 var state = setInternalState(that, { type: 'URL' });
2699 var baseState, failure;
2700 if (base !== undefined) {
2701 if (base instanceof URLConstructor) baseState = getInternalURLState(base);
2702 else {
2703 failure = parseURL(baseState = {}, String(base));
2704 if (failure) throw TypeError(failure);
2705 }
2706 }
2707 failure = parseURL(state, urlString, null, baseState);
2708 if (failure) throw TypeError(failure);
2709 var searchParams = state.searchParams = new URLSearchParams();
2710 var searchParamsState = getInternalSearchParamsState(searchParams);
2711 searchParamsState.updateSearchParams(state.query);
2712 searchParamsState.updateURL = function () {
2713 state.query = String(searchParams) || null;
2714 };
2715 if (!DESCRIPTORS) {
2716 that.href = serializeURL.call(that);
2717 that.origin = getOrigin.call(that);
2718 that.protocol = getProtocol.call(that);
2719 that.username = getUsername.call(that);
2720 that.password = getPassword.call(that);
2721 that.host = getHost.call(that);
2722 that.hostname = getHostname.call(that);
2723 that.port = getPort.call(that);
2724 that.pathname = getPathname.call(that);
2725 that.search = getSearch.call(that);
2726 that.searchParams = getSearchParams.call(that);
2727 that.hash = getHash.call(that);
2728 }
2729};
2730
2731var URLPrototype = URLConstructor.prototype;
2732
2733var serializeURL = function () {
2734 var url = getInternalURLState(this);
2735 var scheme = url.scheme;
2736 var username = url.username;
2737 var password = url.password;
2738 var host = url.host;
2739 var port = url.port;
2740 var path = url.path;
2741 var query = url.query;
2742 var fragment = url.fragment;
2743 var output = scheme + ':';
2744 if (host !== null) {
2745 output += '//';
2746 if (includesCredentials(url)) {
2747 output += username + (password ? ':' + password : '') + '@';
2748 }
2749 output += serializeHost(host);
2750 if (port !== null) output += ':' + port;
2751 } else if (scheme == 'file') output += '//';
2752 output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
2753 if (query !== null) output += '?' + query;
2754 if (fragment !== null) output += '#' + fragment;
2755 return output;
2756};
2757
2758var getOrigin = function () {
2759 var url = getInternalURLState(this);
2760 var scheme = url.scheme;
2761 var port = url.port;
2762 if (scheme == 'blob') try {
2763 return new URL(scheme.path[0]).origin;
2764 } catch (error) {
2765 return 'null';
2766 }
2767 if (scheme == 'file' || !isSpecial(url)) return 'null';
2768 return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');
2769};
2770
2771var getProtocol = function () {
2772 return getInternalURLState(this).scheme + ':';
2773};
2774
2775var getUsername = function () {
2776 return getInternalURLState(this).username;
2777};
2778
2779var getPassword = function () {
2780 return getInternalURLState(this).password;
2781};
2782
2783var getHost = function () {
2784 var url = getInternalURLState(this);
2785 var host = url.host;
2786 var port = url.port;
2787 return host === null ? ''
2788 : port === null ? serializeHost(host)
2789 : serializeHost(host) + ':' + port;
2790};
2791
2792var getHostname = function () {
2793 var host = getInternalURLState(this).host;
2794 return host === null ? '' : serializeHost(host);
2795};
2796
2797var getPort = function () {
2798 var port = getInternalURLState(this).port;
2799 return port === null ? '' : String(port);
2800};
2801
2802var getPathname = function () {
2803 var url = getInternalURLState(this);
2804 var path = url.path;
2805 return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
2806};
2807
2808var getSearch = function () {
2809 var query = getInternalURLState(this).query;
2810 return query ? '?' + query : '';
2811};
2812
2813var getSearchParams = function () {
2814 return getInternalURLState(this).searchParams;
2815};
2816
2817var getHash = function () {
2818 var fragment = getInternalURLState(this).fragment;
2819 return fragment ? '#' + fragment : '';
2820};
2821
2822var accessorDescriptor = function (getter, setter) {
2823 return { get: getter, set: setter, configurable: true, enumerable: true };
2824};
2825
2826if (DESCRIPTORS) {
2827 defineProperties(URLPrototype, {
2828 // `URL.prototype.href` accessors pair
2829 // https://url.spec.whatwg.org/#dom-url-href
2830 href: accessorDescriptor(serializeURL, function (href) {
2831 var url = getInternalURLState(this);
2832 var urlString = String(href);
2833 var failure = parseURL(url, urlString);
2834 if (failure) throw TypeError(failure);
2835 getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
2836 }),
2837 // `URL.prototype.origin` getter
2838 // https://url.spec.whatwg.org/#dom-url-origin
2839 origin: accessorDescriptor(getOrigin),
2840 // `URL.prototype.protocol` accessors pair
2841 // https://url.spec.whatwg.org/#dom-url-protocol
2842 protocol: accessorDescriptor(getProtocol, function (protocol) {
2843 var url = getInternalURLState(this);
2844 parseURL(url, String(protocol) + ':', SCHEME_START);
2845 }),
2846 // `URL.prototype.username` accessors pair
2847 // https://url.spec.whatwg.org/#dom-url-username
2848 username: accessorDescriptor(getUsername, function (username) {
2849 var url = getInternalURLState(this);
2850 var codePoints = arrayFrom(String(username));
2851 if (cannotHaveUsernamePasswordPort(url)) return;
2852 url.username = '';
2853 for (var i = 0; i < codePoints.length; i++) {
2854 url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
2855 }
2856 }),
2857 // `URL.prototype.password` accessors pair
2858 // https://url.spec.whatwg.org/#dom-url-password
2859 password: accessorDescriptor(getPassword, function (password) {
2860 var url = getInternalURLState(this);
2861 var codePoints = arrayFrom(String(password));
2862 if (cannotHaveUsernamePasswordPort(url)) return;
2863 url.password = '';
2864 for (var i = 0; i < codePoints.length; i++) {
2865 url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
2866 }
2867 }),
2868 // `URL.prototype.host` accessors pair
2869 // https://url.spec.whatwg.org/#dom-url-host
2870 host: accessorDescriptor(getHost, function (host) {
2871 var url = getInternalURLState(this);
2872 if (url.cannotBeABaseURL) return;
2873 parseURL(url, String(host), HOST);
2874 }),
2875 // `URL.prototype.hostname` accessors pair
2876 // https://url.spec.whatwg.org/#dom-url-hostname
2877 hostname: accessorDescriptor(getHostname, function (hostname) {
2878 var url = getInternalURLState(this);
2879 if (url.cannotBeABaseURL) return;
2880 parseURL(url, String(hostname), HOSTNAME);
2881 }),
2882 // `URL.prototype.port` accessors pair
2883 // https://url.spec.whatwg.org/#dom-url-port
2884 port: accessorDescriptor(getPort, function (port) {
2885 var url = getInternalURLState(this);
2886 if (cannotHaveUsernamePasswordPort(url)) return;
2887 port = String(port);
2888 if (port == '') url.port = null;
2889 else parseURL(url, port, PORT);
2890 }),
2891 // `URL.prototype.pathname` accessors pair
2892 // https://url.spec.whatwg.org/#dom-url-pathname
2893 pathname: accessorDescriptor(getPathname, function (pathname) {
2894 var url = getInternalURLState(this);
2895 if (url.cannotBeABaseURL) return;
2896 url.path = [];
2897 parseURL(url, pathname + '', PATH_START);
2898 }),
2899 // `URL.prototype.search` accessors pair
2900 // https://url.spec.whatwg.org/#dom-url-search
2901 search: accessorDescriptor(getSearch, function (search) {
2902 var url = getInternalURLState(this);
2903 search = String(search);
2904 if (search == '') {
2905 url.query = null;
2906 } else {
2907 if ('?' == search.charAt(0)) search = search.slice(1);
2908 url.query = '';
2909 parseURL(url, search, QUERY);
2910 }
2911 getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
2912 }),
2913 // `URL.prototype.searchParams` getter
2914 // https://url.spec.whatwg.org/#dom-url-searchparams
2915 searchParams: accessorDescriptor(getSearchParams),
2916 // `URL.prototype.hash` accessors pair
2917 // https://url.spec.whatwg.org/#dom-url-hash
2918 hash: accessorDescriptor(getHash, function (hash) {
2919 var url = getInternalURLState(this);
2920 hash = String(hash);
2921 if (hash == '') {
2922 url.fragment = null;
2923 return;
2924 }
2925 if ('#' == hash.charAt(0)) hash = hash.slice(1);
2926 url.fragment = '';
2927 parseURL(url, hash, FRAGMENT);
2928 })
2929 });
2930}
2931
2932// `URL.prototype.toJSON` method
2933// https://url.spec.whatwg.org/#dom-url-tojson
2934redefine(URLPrototype, 'toJSON', function toJSON() {
2935 return serializeURL.call(this);
2936}, { enumerable: true });
2937
2938// `URL.prototype.toString` method
2939// https://url.spec.whatwg.org/#URL-stringification-behavior
2940redefine(URLPrototype, 'toString', function toString() {
2941 return serializeURL.call(this);
2942}, { enumerable: true });
2943
2944if (NativeURL) {
2945 var nativeCreateObjectURL = NativeURL.createObjectURL;
2946 var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
2947 // `URL.createObjectURL` method
2948 // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
2949 // eslint-disable-next-line no-unused-vars
2950 if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) {
2951 return nativeCreateObjectURL.apply(NativeURL, arguments);
2952 });
2953 // `URL.revokeObjectURL` method
2954 // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL
2955 // eslint-disable-next-line no-unused-vars
2956 if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) {
2957 return nativeRevokeObjectURL.apply(NativeURL, arguments);
2958 });
2959}
2960
2961setToStringTag(URLConstructor, 'URL');
2962
2963$({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {
2964 URL: URLConstructor
2965});
2966
2967},{"../internals/an-instance":4,"../internals/array-from":6,"../internals/descriptors":18,"../internals/export":21,"../internals/global":27,"../internals/has":28,"../internals/internal-state":34,"../internals/native-url":42,"../internals/object-assign":44,"../internals/object-define-properties":46,"../internals/redefine":59,"../internals/set-to-string-tag":62,"../internals/string-multibyte":66,"../internals/string-punycode-to-ascii":67,"../modules/es.string.iterator":79,"../modules/web.url-search-params":80}],82:[function(require,module,exports){
2968'use strict';
2969var $ = require('../internals/export');
2970
2971// `URL.prototype.toJSON` method
2972// https://url.spec.whatwg.org/#dom-url-tojson
2973$({ target: 'URL', proto: true, enumerable: true }, {
2974 toJSON: function toJSON() {
2975 return URL.prototype.toString.call(this);
2976 }
2977});
2978
2979},{"../internals/export":21}],83:[function(require,module,exports){
2980require('../modules/web.url');
2981require('../modules/web.url.to-json');
2982require('../modules/web.url-search-params');
2983var path = require('../internals/path');
2984
2985module.exports = path.URL;
2986
2987},{"../internals/path":57,"../modules/web.url":81,"../modules/web.url-search-params":80,"../modules/web.url.to-json":82}]},{},[83]);
2988