Gutenberg / 8.5.1

Gutenberg v8.5.1

gutenberg / vendor / wp-polyfill-url.db0b5454.js

wp-polyfill-url.db0b5454.js in Gutenberg 8.5.1, at vendor/wp-polyfill-url.db0b5454.js

2,988 lines 107.7 KB

Raw Download Zip

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){
2	module.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){
9	var isObject = require('../internals/is-object');
10
11	module.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){
18	var wellKnownSymbol = require('../internals/well-known-symbol');
19	var create = require('../internals/object-create');
20	var definePropertyModule = require('../internals/object-define-property');
21
22	var UNSCOPABLES = wellKnownSymbol('unscopables');
23	var ArrayPrototype = Array.prototype;
24
25	// Array.prototype[@@unscopables]
26	// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
27	if (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]
35	module.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){
40	module.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){
47	var isObject = require('../internals/is-object');
48
49	module.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';
57	var bind = require('../internals/function-bind-context');
58	var toObject = require('../internals/to-object');
59	var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
60	var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
61	var toLength = require('../internals/to-length');
62	var createProperty = require('../internals/create-property');
63	var getIteratorMethod = require('../internals/get-iterator-method');
64
65	// `Array.from` method implementation
66	// https://tc39.github.io/ecma262/#sec-array.from
67	module.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){
99	var toIndexedObject = require('../internals/to-indexed-object');
100	var toLength = require('../internals/to-length');
101	var toAbsoluteIndex = require('../internals/to-absolute-index');
102
103	// `Array.prototype.{ indexOf, includes }` methods implementation
104	var 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
123	module.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){
133	var anObject = require('../internals/an-object');
134
135	// call something on iterator step with safe closing on error
136	module.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){
148	var toString = {}.toString;
149
150	module.exports = function (it) {
151	return toString.call(it).slice(8, -1);
152	};
153
154	},{}],10:[function(require,module,exports){
155	var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
156	var classofRaw = require('../internals/classof-raw');
157	var wellKnownSymbol = require('../internals/well-known-symbol');
158
159	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
160	// ES3 wrong here
161	var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
162
163	// fallback for IE11 Script Access Denied error
164	var tryGet = function (it, key) {
165	try {
166	return it[key];
167	} catch (error) { /* empty */ }
168	};
169
170	// getting tag from ES6+ `Object.prototype.toString`
171	module.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){
183	var has = require('../internals/has');
184	var ownKeys = require('../internals/own-keys');
185	var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
186	var definePropertyModule = require('../internals/object-define-property');
187
188	module.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){
199	var fails = require('../internals/fails');
200
201	module.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';
209	var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
210	var create = require('../internals/object-create');
211	var createPropertyDescriptor = require('../internals/create-property-descriptor');
212	var setToStringTag = require('../internals/set-to-string-tag');
213	var Iterators = require('../internals/iterators');
214
215	var returnThis = function () { return this; };
216
217	module.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){
226	var DESCRIPTORS = require('../internals/descriptors');
227	var definePropertyModule = require('../internals/object-define-property');
228	var createPropertyDescriptor = require('../internals/create-property-descriptor');
229
230	module.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){
238	module.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';
249	var toPrimitive = require('../internals/to-primitive');
250	var definePropertyModule = require('../internals/object-define-property');
251	var createPropertyDescriptor = require('../internals/create-property-descriptor');
252
253	module.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';
261	var $ = require('../internals/export');
262	var createIteratorConstructor = require('../internals/create-iterator-constructor');
263	var getPrototypeOf = require('../internals/object-get-prototype-of');
264	var setPrototypeOf = require('../internals/object-set-prototype-of');
265	var setToStringTag = require('../internals/set-to-string-tag');
266	var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
267	var redefine = require('../internals/redefine');
268	var wellKnownSymbol = require('../internals/well-known-symbol');
269	var IS_PURE = require('../internals/is-pure');
270	var Iterators = require('../internals/iterators');
271	var IteratorsCore = require('../internals/iterators-core');
272
273	var IteratorPrototype = IteratorsCore.IteratorPrototype;
274	var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
275	var ITERATOR = wellKnownSymbol('iterator');
276	var KEYS = 'keys';
277	var VALUES = 'values';
278	var ENTRIES = 'entries';
279
280	var returnThis = function () { return this; };
281
282	module.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){
352	var fails = require('../internals/fails');
353
354	// Thank's IE8 for his funny defineProperty
355	module.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){
360	var global = require('../internals/global');
361	var isObject = require('../internals/is-object');
362
363	var document = global.document;
364	// typeof document.createElement is 'object' in old IE
365	var EXISTS = isObject(document) && isObject(document.createElement);
366
367	module.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
373	module.exports = [
374	'constructor',
375	'hasOwnProperty',
376	'isPrototypeOf',
377	'propertyIsEnumerable',
378	'toLocaleString',
379	'toString',
380	'valueOf'
381	];
382
383	},{}],21:[function(require,module,exports){
384	var global = require('../internals/global');
385	var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
386	var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
387	var redefine = require('../internals/redefine');
388	var setGlobal = require('../internals/set-global');
389	var copyConstructorProperties = require('../internals/copy-constructor-properties');
390	var 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	*/
406	module.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){
440	module.exports = function (exec) {
441	try {
442	return !!exec();
443	} catch (error) {
444	return true;
445	}
446	};
447
448	},{}],23:[function(require,module,exports){
449	var aFunction = require('../internals/a-function');
450
451	// optional / simple context binding
452	module.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){
475	var path = require('../internals/path');
476	var global = require('../internals/global');
477
478	var aFunction = function (variable) {
479	return typeof variable == 'function' ? variable : undefined;
480	};
481
482	module.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){
488	var classof = require('../internals/classof');
489	var Iterators = require('../internals/iterators');
490	var wellKnownSymbol = require('../internals/well-known-symbol');
491
492	var ITERATOR = wellKnownSymbol('iterator');
493
494	module.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){
501	var anObject = require('../internals/an-object');
502	var getIteratorMethod = require('../internals/get-iterator-method');
503
504	module.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){
513	var check = function (it) {
514	return it && it.Math == Math && it;
515	};
516
517	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
518	module.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){
529	var hasOwnProperty = {}.hasOwnProperty;
530
531	module.exports = function (it, key) {
532	return hasOwnProperty.call(it, key);
533	};
534
535	},{}],29:[function(require,module,exports){
536	module.exports = {};
537
538	},{}],30:[function(require,module,exports){
539	var getBuiltIn = require('../internals/get-built-in');
540
541	module.exports = getBuiltIn('document', 'documentElement');
542
543	},{"../internals/get-built-in":24}],31:[function(require,module,exports){
544	var DESCRIPTORS = require('../internals/descriptors');
545	var fails = require('../internals/fails');
546	var createElement = require('../internals/document-create-element');
547
548	// Thank's IE8 for his funny defineProperty
549	module.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){
556	var fails = require('../internals/fails');
557	var classof = require('../internals/classof-raw');
558
559	var split = ''.split;
560
561	// fallback for non-array-like ES3 and non-enumerable old V8 strings
562	module.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){
571	var store = require('../internals/shared-store');
572
573	var functionToString = Function.toString;
574
575	// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
576	if (typeof store.inspectSource != 'function') {
577	store.inspectSource = function (it) {
578	return functionToString.call(it);
579	};
580	}
581
582	module.exports = store.inspectSource;
583
584	},{"../internals/shared-store":64}],34:[function(require,module,exports){
585	var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
586	var global = require('../internals/global');
587	var isObject = require('../internals/is-object');
588	var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
589	var objectHas = require('../internals/has');
590	var sharedKey = require('../internals/shared-key');
591	var hiddenKeys = require('../internals/hidden-keys');
592
593	var WeakMap = global.WeakMap;
594	var set, get, has;
595
596	var enforce = function (it) {
597	return has(it) ? get(it) : set(it, {});
598	};
599
600	var 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
609	if (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
639	module.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){
648	var wellKnownSymbol = require('../internals/well-known-symbol');
649	var Iterators = require('../internals/iterators');
650
651	var ITERATOR = wellKnownSymbol('iterator');
652	var ArrayPrototype = Array.prototype;
653
654	// check on default Array iterator
655	module.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){
660	var fails = require('../internals/fails');
661
662	var replacement = /#\|\.prototype\./;
663
664	var 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
672	var normalize = isForced.normalize = function (string) {
673	return String(string).replace(replacement, '.').toLowerCase();
674	};
675
676	var data = isForced.data = {};
677	var NATIVE = isForced.NATIVE = 'N';
678	var POLYFILL = isForced.POLYFILL = 'P';
679
680	module.exports = isForced;
681
682	},{"../internals/fails":22}],37:[function(require,module,exports){
683	module.exports = function (it) {
684	return typeof it === 'object' ? it !== null : typeof it === 'function';
685	};
686
687	},{}],38:[function(require,module,exports){
688	module.exports = false;
689
690	},{}],39:[function(require,module,exports){
691	'use strict';
692	var getPrototypeOf = require('../internals/object-get-prototype-of');
693	var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
694	var has = require('../internals/has');
695	var wellKnownSymbol = require('../internals/well-known-symbol');
696	var IS_PURE = require('../internals/is-pure');
697
698	var ITERATOR = wellKnownSymbol('iterator');
699	var BUGGY_SAFARI_ITERATORS = false;
700
701	var returnThis = function () { return this; };
702
703	// `%IteratorPrototype%` object
704	// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
705	var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
706
707	if ([].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
717	if (IteratorPrototype == undefined) IteratorPrototype = {};
718
719	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
720	if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {
721	createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);
722	}
723
724	module.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){
730	arguments[4][29][0].apply(exports,arguments)
731	},{"dup":29}],41:[function(require,module,exports){
732	var fails = require('../internals/fails');
733
734	module.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){
741	var fails = require('../internals/fails');
742	var wellKnownSymbol = require('../internals/well-known-symbol');
743	var IS_PURE = require('../internals/is-pure');
744
745	var ITERATOR = wellKnownSymbol('iterator');
746
747	module.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){
776	var global = require('../internals/global');
777	var inspectSource = require('../internals/inspect-source');
778
779	var WeakMap = global.WeakMap;
780
781	module.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';
785	var DESCRIPTORS = require('../internals/descriptors');
786	var fails = require('../internals/fails');
787	var objectKeys = require('../internals/object-keys');
788	var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
789	var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
790	var toObject = require('../internals/to-object');
791	var IndexedObject = require('../internals/indexed-object');
792
793	var nativeAssign = Object.assign;
794	var defineProperty = Object.defineProperty;
795
796	// `Object.assign` method
797	// https://tc39.github.io/ecma262/#sec-object.assign
798	module.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){
838	var anObject = require('../internals/an-object');
839	var defineProperties = require('../internals/object-define-properties');
840	var enumBugKeys = require('../internals/enum-bug-keys');
841	var hiddenKeys = require('../internals/hidden-keys');
842	var html = require('../internals/html');
843	var documentCreateElement = require('../internals/document-create-element');
844	var sharedKey = require('../internals/shared-key');
845
846	var GT = '>';
847	var LT = '<';
848	var PROTOTYPE = 'prototype';
849	var SCRIPT = 'script';
850	var IE_PROTO = sharedKey('IE_PROTO');
851
852	var EmptyConstructor = function () { /* empty */ };
853
854	var 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
859	var 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
868	var 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
889	var activeXDocument;
890	var 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
901	hiddenKeys[IE_PROTO] = true;
902
903	// `Object.create` method
904	// https://tc39.github.io/ecma262/#sec-object.create
905	module.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){
918	var DESCRIPTORS = require('../internals/descriptors');
919	var definePropertyModule = require('../internals/object-define-property');
920	var anObject = require('../internals/an-object');
921	var objectKeys = require('../internals/object-keys');
922
923	// `Object.defineProperties` method
924	// https://tc39.github.io/ecma262/#sec-object.defineproperties
925	module.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){
936	var DESCRIPTORS = require('../internals/descriptors');
937	var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
938	var anObject = require('../internals/an-object');
939	var toPrimitive = require('../internals/to-primitive');
940
941	var nativeDefineProperty = Object.defineProperty;
942
943	// `Object.defineProperty` method
944	// https://tc39.github.io/ecma262/#sec-object.defineproperty
945	exports.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){
958	var DESCRIPTORS = require('../internals/descriptors');
959	var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
960	var createPropertyDescriptor = require('../internals/create-property-descriptor');
961	var toIndexedObject = require('../internals/to-indexed-object');
962	var toPrimitive = require('../internals/to-primitive');
963	var has = require('../internals/has');
964	var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
965
966	var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
967
968	// `Object.getOwnPropertyDescriptor` method
969	// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
970	exports.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){
980	var internalObjectKeys = require('../internals/object-keys-internal');
981	var enumBugKeys = require('../internals/enum-bug-keys');
982
983	var hiddenKeys = enumBugKeys.concat('length', 'prototype');
984
985	// `Object.getOwnPropertyNames` method
986	// https://tc39.github.io/ecma262/#sec-object.getownpropertynames
987	exports.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){
992	exports.f = Object.getOwnPropertySymbols;
993
994	},{}],51:[function(require,module,exports){
995	var has = require('../internals/has');
996	var toObject = require('../internals/to-object');
997	var sharedKey = require('../internals/shared-key');
998	var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');
999
1000	var IE_PROTO = sharedKey('IE_PROTO');
1001	var ObjectPrototype = Object.prototype;
1002
1003	// `Object.getPrototypeOf` method
1004	// https://tc39.github.io/ecma262/#sec-object.getprototypeof
1005	module.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){
1014	var has = require('../internals/has');
1015	var toIndexedObject = require('../internals/to-indexed-object');
1016	var indexOf = require('../internals/array-includes').indexOf;
1017	var hiddenKeys = require('../internals/hidden-keys');
1018
1019	module.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){
1033	var internalObjectKeys = require('../internals/object-keys-internal');
1034	var enumBugKeys = require('../internals/enum-bug-keys');
1035
1036	// `Object.keys` method
1037	// https://tc39.github.io/ecma262/#sec-object.keys
1038	module.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';
1044	var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
1045	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1046
1047	// Nashorn ~ JDK8 bug
1048	var 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
1052	exports.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){
1058	var anObject = require('../internals/an-object');
1059	var 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 */
1065	module.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){
1084	var getBuiltIn = require('../internals/get-built-in');
1085	var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');
1086	var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
1087	var anObject = require('../internals/an-object');
1088
1089	// all object keys, includes non-enumerable and symbols
1090	module.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){
1097	var global = require('../internals/global');
1098
1099	module.exports = global;
1100
1101	},{"../internals/global":27}],58:[function(require,module,exports){
1102	var redefine = require('../internals/redefine');
1103
1104	module.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){
1110	var global = require('../internals/global');
1111	var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
1112	var has = require('../internals/has');
1113	var setGlobal = require('../internals/set-global');
1114	var inspectSource = require('../internals/inspect-source');
1115	var InternalStateModule = require('../internals/internal-state');
1116
1117	var getInternalState = InternalStateModule.get;
1118	var enforceInternalState = InternalStateModule.enforce;
1119	var 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
1148	module.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){
1154	var global = require('../internals/global');
1155	var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
1156
1157	module.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){
1166	var defineProperty = require('../internals/object-define-property').f;
1167	var has = require('../internals/has');
1168	var wellKnownSymbol = require('../internals/well-known-symbol');
1169
1170	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1171
1172	module.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){
1179	var shared = require('../internals/shared');
1180	var uid = require('../internals/uid');
1181
1182	var keys = shared('keys');
1183
1184	module.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){
1189	var global = require('../internals/global');
1190	var setGlobal = require('../internals/set-global');
1191
1192	var SHARED = '__core-js_shared__';
1193	var store = global[SHARED] \|\| setGlobal(SHARED, {});
1194
1195	module.exports = store;
1196
1197	},{"../internals/global":27,"../internals/set-global":61}],65:[function(require,module,exports){
1198	var IS_PURE = require('../internals/is-pure');
1199	var 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){
1210	var toInteger = require('../internals/to-integer');
1211	var requireObjectCoercible = require('../internals/require-object-coercible');
1212
1213	// `String.prototype.{ codePointAt, at }` methods implementation
1214	var 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
1229	module.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
1241	var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
1242	var base = 36;
1243	var tMin = 1;
1244	var tMax = 26;
1245	var skew = 38;
1246	var damp = 700;
1247	var initialBias = 72;
1248	var initialN = 128; // 0x80
1249	var delimiter = '-'; // '\x2D'
1250	var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars
1251	var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
1252	var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
1253	var baseMinusTMin = base - tMin;
1254	var floor = Math.floor;
1255	var 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	*/
1264	var 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	*/
1291	var 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	*/
1301	var 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
1316	var 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
1397	module.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){
1409	var toInteger = require('../internals/to-integer');
1410
1411	var max = Math.max;
1412	var 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).
1417	module.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
1424	var IndexedObject = require('../internals/indexed-object');
1425	var requireObjectCoercible = require('../internals/require-object-coercible');
1426
1427	module.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){
1432	var ceil = Math.ceil;
1433	var floor = Math.floor;
1434
1435	// `ToInteger` abstract operation
1436	// https://tc39.github.io/ecma262/#sec-tointeger
1437	module.exports = function (argument) {
1438	return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
1439	};
1440
1441	},{}],71:[function(require,module,exports){
1442	var toInteger = require('../internals/to-integer');
1443
1444	var min = Math.min;
1445
1446	// `ToLength` abstract operation
1447	// https://tc39.github.io/ecma262/#sec-tolength
1448	module.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){
1453	var requireObjectCoercible = require('../internals/require-object-coercible');
1454
1455	// `ToObject` abstract operation
1456	// https://tc39.github.io/ecma262/#sec-toobject
1457	module.exports = function (argument) {
1458	return Object(requireObjectCoercible(argument));
1459	};
1460
1461	},{"../internals/require-object-coercible":60}],73:[function(require,module,exports){
1462	var 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
1468	module.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){
1478	var wellKnownSymbol = require('../internals/well-known-symbol');
1479
1480	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1481	var test = {};
1482
1483	test[TO_STRING_TAG] = 'z';
1484
1485	module.exports = String(test) === '[object z]';
1486
1487	},{"../internals/well-known-symbol":77}],75:[function(require,module,exports){
1488	var id = 0;
1489	var postfix = Math.random();
1490
1491	module.exports = function (key) {
1492	return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
1493	};
1494
1495	},{}],76:[function(require,module,exports){
1496	var NATIVE_SYMBOL = require('../internals/native-symbol');
1497
1498	module.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){
1505	var global = require('../internals/global');
1506	var shared = require('../internals/shared');
1507	var has = require('../internals/has');
1508	var uid = require('../internals/uid');
1509	var NATIVE_SYMBOL = require('../internals/native-symbol');
1510	var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');
1511
1512	var WellKnownSymbolsStore = shared('wks');
1513	var Symbol = global.Symbol;
1514	var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter \|\| uid;
1515
1516	module.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';
1525	var toIndexedObject = require('../internals/to-indexed-object');
1526	var addToUnscopables = require('../internals/add-to-unscopables');
1527	var Iterators = require('../internals/iterators');
1528	var InternalStateModule = require('../internals/internal-state');
1529	var defineIterator = require('../internals/define-iterator');
1530
1531	var ARRAY_ITERATOR = 'Array Iterator';
1532	var setInternalState = InternalStateModule.set;
1533	var 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
1545	module.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
1571	Iterators.Arguments = Iterators.Array;
1572
1573	// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
1574	addToUnscopables('keys');
1575	addToUnscopables('values');
1576	addToUnscopables('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';
1580	var charAt = require('../internals/string-multibyte').charAt;
1581	var InternalStateModule = require('../internals/internal-state');
1582	var defineIterator = require('../internals/define-iterator');
1583
1584	var STRING_ITERATOR = 'String Iterator';
1585	var setInternalState = InternalStateModule.set;
1586	var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
1587
1588	// `String.prototype[@@iterator]` method
1589	// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
1590	defineIterator(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`
1612	require('../modules/es.array.iterator');
1613	var $ = require('../internals/export');
1614	var getBuiltIn = require('../internals/get-built-in');
1615	var USE_NATIVE_URL = require('../internals/native-url');
1616	var redefine = require('../internals/redefine');
1617	var redefineAll = require('../internals/redefine-all');
1618	var setToStringTag = require('../internals/set-to-string-tag');
1619	var createIteratorConstructor = require('../internals/create-iterator-constructor');
1620	var InternalStateModule = require('../internals/internal-state');
1621	var anInstance = require('../internals/an-instance');
1622	var hasOwn = require('../internals/has');
1623	var bind = require('../internals/function-bind-context');
1624	var classof = require('../internals/classof');
1625	var anObject = require('../internals/an-object');
1626	var isObject = require('../internals/is-object');
1627	var create = require('../internals/object-create');
1628	var createPropertyDescriptor = require('../internals/create-property-descriptor');
1629	var getIterator = require('../internals/get-iterator');
1630	var getIteratorMethod = require('../internals/get-iterator-method');
1631	var wellKnownSymbol = require('../internals/well-known-symbol');
1632
1633	var $fetch = getBuiltIn('fetch');
1634	var Headers = getBuiltIn('Headers');
1635	var ITERATOR = wellKnownSymbol('iterator');
1636	var URL_SEARCH_PARAMS = 'URLSearchParams';
1637	var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
1638	var setInternalState = InternalStateModule.set;
1639	var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
1640	var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
1641
1642	var plus = /\+/g;
1643	var sequences = Array(4);
1644
1645	var percentSequence = function (bytes) {
1646	return sequences[bytes - 1] \|\| (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
1647	};
1648
1649	var percentDecode = function (sequence) {
1650	try {
1651	return decodeURIComponent(sequence);
1652	} catch (error) {
1653	return sequence;
1654	}
1655	};
1656
1657	var 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
1670	var find = /[!'()~]\|%20/g;
1671
1672	var replace = {
1673	'!': '%21',
1674	"'": '%27',
1675	'(': '%28',
1676	')': '%29',
1677	'~': '%7E',
1678	'%20': '+'
1679	};
1680
1681	var replacer = function (match) {
1682	return replace[match];
1683	};
1684
1685	var serialize = function (it) {
1686	return encodeURIComponent(it).replace(find, replacer);
1687	};
1688
1689	var 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
1707	var updateSearchParams = function (query) {
1708	this.entries.length = 0;
1709	parseSearchParams(this.entries, query);
1710	};
1711
1712	var validateArgumentsLength = function (passed, required) {
1713	if (passed < required) throw TypeError('Not enough arguments');
1714	};
1715
1716	var 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
1734	var 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
1771	var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
1772
1773	redefineAll(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
1904	redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);
1905
1906	// `URLSearchParams.prototype.toString` method
1907	// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
1908	redefine(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
1919	setToStringTag(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
1927	if (!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
1953	module.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`
1961	require('../modules/es.string.iterator');
1962	var $ = require('../internals/export');
1963	var DESCRIPTORS = require('../internals/descriptors');
1964	var USE_NATIVE_URL = require('../internals/native-url');
1965	var global = require('../internals/global');
1966	var defineProperties = require('../internals/object-define-properties');
1967	var redefine = require('../internals/redefine');
1968	var anInstance = require('../internals/an-instance');
1969	var has = require('../internals/has');
1970	var assign = require('../internals/object-assign');
1971	var arrayFrom = require('../internals/array-from');
1972	var codeAt = require('../internals/string-multibyte').codeAt;
1973	var toASCII = require('../internals/string-punycode-to-ascii');
1974	var setToStringTag = require('../internals/set-to-string-tag');
1975	var URLSearchParamsModule = require('../modules/web.url-search-params');
1976	var InternalStateModule = require('../internals/internal-state');
1977
1978	var NativeURL = global.URL;
1979	var URLSearchParams = URLSearchParamsModule.URLSearchParams;
1980	var getInternalSearchParamsState = URLSearchParamsModule.getState;
1981	var setInternalState = InternalStateModule.set;
1982	var getInternalURLState = InternalStateModule.getterFor('URL');
1983	var floor = Math.floor;
1984	var pow = Math.pow;
1985
1986	var INVALID_AUTHORITY = 'Invalid authority';
1987	var INVALID_SCHEME = 'Invalid scheme';
1988	var INVALID_HOST = 'Invalid host';
1989	var INVALID_PORT = 'Invalid port';
1990
1991	var ALPHA = /[A-Za-z]/;
1992	var ALPHANUMERIC = /[\d+\-.A-Za-z]/;
1993	var DIGIT = /\d/;
1994	var HEX_START = /^(0x\|0X)/;
1995	var OCT = /^[0-7]+$/;
1996	var DEC = /^\d+$/;
1997	var HEX = /^[\dA-Fa-f]+$/;
1998	// eslint-disable-next-line no-control-regex
1999	var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/;
2000	// eslint-disable-next-line no-control-regex
2001	var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/;
2002	// eslint-disable-next-line no-control-regex
2003	var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+\|[\u0000-\u001F ]+$/g;
2004	// eslint-disable-next-line no-control-regex
2005	var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g;
2006	var EOF;
2007
2008	var 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
2033	var 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
2072	var 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
2148	var 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
2174	var 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
2202	var C0ControlPercentEncodeSet = {};
2203	var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
2204	' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
2205	});
2206	var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
2207	'#': 1, '?': 1, '{': 1, '}': 1
2208	});
2209	var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
2210	'/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '\|': 1
2211	});
2212
2213	var percentEncode = function (char, set) {
2214	var code = codeAt(char, 0);
2215	return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);
2216	};
2217
2218	var specialSchemes = {
2219	ftp: 21,
2220	file: null,
2221	http: 80,
2222	https: 443,
2223	ws: 80,
2224	wss: 443
2225	};
2226
2227	var isSpecial = function (url) {
2228	return has(specialSchemes, url.scheme);
2229	};
2230
2231	var includesCredentials = function (url) {
2232	return url.username != '' \|\| url.password != '';
2233	};
2234
2235	var cannotHaveUsernamePasswordPort = function (url) {
2236	return !url.host \|\| url.cannotBeABaseURL \|\| url.scheme == 'file';
2237	};
2238
2239	var 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
2245	var 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
2253	var 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
2261	var isSingleDot = function (segment) {
2262	return segment === '.' \|\| segment.toLowerCase() === '%2e';
2263	};
2264
2265	var isDoubleDot = function (segment) {
2266	segment = segment.toLowerCase();
2267	return segment === '..' \|\| segment === '%2e.' \|\| segment === '.%2e' \|\| segment === '%2e%2e';
2268	};
2269
2270	// States:
2271	var SCHEME_START = {};
2272	var SCHEME = {};
2273	var NO_SCHEME = {};
2274	var SPECIAL_RELATIVE_OR_AUTHORITY = {};
2275	var PATH_OR_AUTHORITY = {};
2276	var RELATIVE = {};
2277	var RELATIVE_SLASH = {};
2278	var SPECIAL_AUTHORITY_SLASHES = {};
2279	var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
2280	var AUTHORITY = {};
2281	var HOST = {};
2282	var HOSTNAME = {};
2283	var PORT = {};
2284	var FILE = {};
2285	var FILE_SLASH = {};
2286	var FILE_HOST = {};
2287	var PATH_START = {};
2288	var PATH = {};
2289	var CANNOT_BE_A_BASE_URL_PATH = {};
2290	var QUERY = {};
2291	var FRAGMENT = {};
2292
2293	// eslint-disable-next-line max-statements
2294	var 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
2694	var 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
2731	var URLPrototype = URLConstructor.prototype;
2732
2733	var 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
2758	var 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
2771	var getProtocol = function () {
2772	return getInternalURLState(this).scheme + ':';
2773	};
2774
2775	var getUsername = function () {
2776	return getInternalURLState(this).username;
2777	};
2778
2779	var getPassword = function () {
2780	return getInternalURLState(this).password;
2781	};
2782
2783	var 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
2792	var getHostname = function () {
2793	var host = getInternalURLState(this).host;
2794	return host === null ? '' : serializeHost(host);
2795	};
2796
2797	var getPort = function () {
2798	var port = getInternalURLState(this).port;
2799	return port === null ? '' : String(port);
2800	};
2801
2802	var getPathname = function () {
2803	var url = getInternalURLState(this);
2804	var path = url.path;
2805	return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
2806	};
2807
2808	var getSearch = function () {
2809	var query = getInternalURLState(this).query;
2810	return query ? '?' + query : '';
2811	};
2812
2813	var getSearchParams = function () {
2814	return getInternalURLState(this).searchParams;
2815	};
2816
2817	var getHash = function () {
2818	var fragment = getInternalURLState(this).fragment;
2819	return fragment ? '#' + fragment : '';
2820	};
2821
2822	var accessorDescriptor = function (getter, setter) {
2823	return { get: getter, set: setter, configurable: true, enumerable: true };
2824	};
2825
2826	if (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
2934	redefine(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
2940	redefine(URLPrototype, 'toString', function toString() {
2941	return serializeURL.call(this);
2942	}, { enumerable: true });
2943
2944	if (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
2961	setToStringTag(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';
2969	var $ = 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){
2980	require('../modules/web.url');
2981	require('../modules/web.url.to-json');
2982	require('../modules/web.url-search-params');
2983	var path = require('../internals/path');
2984
2985	module.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