enmi-conf.org: comparison wp/wp-includes/js/dist/vendor/wp-polyfill-url.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/dist/vendor/wp-polyfill-url.js

changeset 16

a86126ab1dd4

equal deleted inserted replaced

-:3d4e9c994f10
+:a86126ab1dd4
+(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){
+module.exports = function (it) {
+if (typeof it != 'function') {
+throw TypeError(String(it) + ' is not a function');
+} return it;
+};
+},{}],2:[function(require,module,exports){
+var isObject = require('../internals/is-object');
+module.exports = function (it) {
+if (!isObject(it) && it !== null) {
+throw TypeError("Can't set " + String(it) + ' as a prototype');
+} return it;
+};
+},{"../internals/is-object":37}],3:[function(require,module,exports){
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var create = require('../internals/object-create');
+var definePropertyModule = require('../internals/object-define-property');
+var UNSCOPABLES = wellKnownSymbol('unscopables');
+var ArrayPrototype = Array.prototype;
+// Array.prototype[@@unscopables]
+// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype[UNSCOPABLES] == undefined) {
+definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
+configurable: true,
+value: create(null)
+});
+}
+// add a key to Array.prototype[@@unscopables]
+module.exports = function (key) {
+ArrayPrototype[UNSCOPABLES][key] = true;
+};
+},{"../internals/object-create":45,"../internals/object-define-property":47,"../internals/well-known-symbol":77}],4:[function(require,module,exports){
+module.exports = function (it, Constructor, name) {
+if (!(it instanceof Constructor)) {
+throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
+} return it;
+};
+},{}],5:[function(require,module,exports){
+var isObject = require('../internals/is-object');
+module.exports = function (it) {
+if (!isObject(it)) {
+throw TypeError(String(it) + ' is not an object');
+} return it;
+};
+},{"../internals/is-object":37}],6:[function(require,module,exports){
+'use strict';
+var bind = require('../internals/function-bind-context');
+var toObject = require('../internals/to-object');
+var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
+var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
+var toLength = require('../internals/to-length');
+var createProperty = require('../internals/create-property');
+var getIteratorMethod = require('../internals/get-iterator-method');
+// `Array.from` method implementation
+// https://tc39.github.io/ecma262/#sec-array.from
+module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+var O = toObject(arrayLike);
+var C = typeof this == 'function' ? this : Array;
+var argumentsLength = arguments.length;
+var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
+var mapping = mapfn !== undefined;
+var iteratorMethod = getIteratorMethod(O);
+var index = 0;
+var length, result, step, iterator, next, value;
+if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
+// if the target is not iterable or it's an array with the default iterator - use a simple case
+if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
+iterator = iteratorMethod.call(O);
+next = iterator.next;
+result = new C();
+for (;!(step = next.call(iterator)).done; index++) {
+value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
+createProperty(result, index, value);
+}
+} else {
+length = toLength(O.length);
+result = new C(length);
+for (;length > index; index++) {
+value = mapping ? mapfn(O[index], index) : O[index];
+createProperty(result, index, value);
+}
+}
+result.length = index;
+return result;
+};
+},{"../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){
+var toIndexedObject = require('../internals/to-indexed-object');
+var toLength = require('../internals/to-length');
+var toAbsoluteIndex = require('../internals/to-absolute-index');
+// `Array.prototype.{ indexOf, includes }` methods implementation
+var createMethod = function (IS_INCLUDES) {
+return function ($this, el, fromIndex) {
+var O = toIndexedObject($this);
+var length = toLength(O.length);
+var index = toAbsoluteIndex(fromIndex, length);
+var value;
+// Array#includes uses SameValueZero equality algorithm
+// eslint-disable-next-line no-self-compare
+if (IS_INCLUDES && el != el) while (length > index) {
+value = O[index++];
+// eslint-disable-next-line no-self-compare
+if (value != value) return true;
+// Array#indexOf ignores holes, Array#includes - not
+} else for (;length > index; index++) {
+if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+} return !IS_INCLUDES && -1;
+};
+};
+module.exports = {
+// `Array.prototype.includes` method
+// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+includes: createMethod(true),
+// `Array.prototype.indexOf` method
+// https://tc39.github.io/ecma262/#sec-array.prototype.indexof
+indexOf: createMethod(false)
+};
+},{"../internals/to-absolute-index":68,"../internals/to-indexed-object":69,"../internals/to-length":71}],8:[function(require,module,exports){
+var anObject = require('../internals/an-object');
+// call something on iterator step with safe closing on error
+module.exports = function (iterator, fn, value, ENTRIES) {
+try {
+return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+// 7.4.6 IteratorClose(iterator, completion)
+} catch (error) {
+var returnMethod = iterator['return'];
+if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
+throw error;
+}
+};
+},{"../internals/an-object":5}],9:[function(require,module,exports){
+var toString = {}.toString;
+module.exports = function (it) {
+return toString.call(it).slice(8, -1);
+};
+},{}],10:[function(require,module,exports){
+var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
+var classofRaw = require('../internals/classof-raw');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+try {
+return it[key];
+} catch (error) { /* empty */ }
+};
+// getting tag from ES6+ `Object.prototype.toString`
+module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+var O, tag, result;
+return it === undefined ? 'Undefined' : it === null ? 'Null'
+// @@toStringTag case
+: typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
+// builtinTag case
+: CORRECT_ARGUMENTS ? classofRaw(O)
+// ES3 arguments fallback
+: (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
+};
+},{"../internals/classof-raw":9,"../internals/to-string-tag-support":74,"../internals/well-known-symbol":77}],11:[function(require,module,exports){
+var has = require('../internals/has');
+var ownKeys = require('../internals/own-keys');
+var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
+var definePropertyModule = require('../internals/object-define-property');
+module.exports = function (target, source) {
+var keys = ownKeys(source);
+var defineProperty = definePropertyModule.f;
+var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+for (var i = 0; i < keys.length; i++) {
+var key = keys[i];
+if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+}
+};
+},{"../internals/has":28,"../internals/object-define-property":47,"../internals/object-get-own-property-descriptor":48,"../internals/own-keys":56}],12:[function(require,module,exports){
+var fails = require('../internals/fails');
+module.exports = !fails(function () {
+function F() { /* empty */ }
+F.prototype.constructor = null;
+return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+},{"../internals/fails":22}],13:[function(require,module,exports){
+'use strict';
+var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
+var create = require('../internals/object-create');
+var createPropertyDescriptor = require('../internals/create-property-descriptor');
+var setToStringTag = require('../internals/set-to-string-tag');
+var Iterators = require('../internals/iterators');
+var returnThis = function () { return this; };
+module.exports = function (IteratorConstructor, NAME, next) {
+var TO_STRING_TAG = NAME + ' Iterator';
+IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
+setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
+Iterators[TO_STRING_TAG] = returnThis;
+return IteratorConstructor;
+};
+},{"../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){
+var DESCRIPTORS = require('../internals/descriptors');
+var definePropertyModule = require('../internals/object-define-property');
+var createPropertyDescriptor = require('../internals/create-property-descriptor');
+module.exports = DESCRIPTORS ? function (object, key, value) {
+return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+object[key] = value;
+return object;
+};
+},{"../internals/create-property-descriptor":15,"../internals/descriptors":18,"../internals/object-define-property":47}],15:[function(require,module,exports){
+module.exports = function (bitmap, value) {
+return {
+enumerable: !(bitmap & 1),
+configurable: !(bitmap & 2),
+writable: !(bitmap & 4),
+value: value
+};
+};
+},{}],16:[function(require,module,exports){
+'use strict';
+var toPrimitive = require('../internals/to-primitive');
+var definePropertyModule = require('../internals/object-define-property');
+var createPropertyDescriptor = require('../internals/create-property-descriptor');
+module.exports = function (object, key, value) {
+var propertyKey = toPrimitive(key);
+if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
+else object[propertyKey] = value;
+};
+},{"../internals/create-property-descriptor":15,"../internals/object-define-property":47,"../internals/to-primitive":73}],17:[function(require,module,exports){
+'use strict';
+var $ = require('../internals/export');
+var createIteratorConstructor = require('../internals/create-iterator-constructor');
+var getPrototypeOf = require('../internals/object-get-prototype-of');
+var setPrototypeOf = require('../internals/object-set-prototype-of');
+var setToStringTag = require('../internals/set-to-string-tag');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var redefine = require('../internals/redefine');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var IS_PURE = require('../internals/is-pure');
+var Iterators = require('../internals/iterators');
+var IteratorsCore = require('../internals/iterators-core');
+var IteratorPrototype = IteratorsCore.IteratorPrototype;
+var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+var ITERATOR = wellKnownSymbol('iterator');
+var KEYS = 'keys';
+var VALUES = 'values';
+var ENTRIES = 'entries';
+var returnThis = function () { return this; };
+module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+createIteratorConstructor(IteratorConstructor, NAME, next);
+var getIterationMethod = function (KIND) {
+if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
+switch (KIND) {
+case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
+case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
+case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
+} return function () { return new IteratorConstructor(this); };
+};
+var TO_STRING_TAG = NAME + ' Iterator';
+var INCORRECT_VALUES_NAME = false;
+var IterablePrototype = Iterable.prototype;
+var nativeIterator = IterablePrototype[ITERATOR]
+|| IterablePrototype['@@iterator']
+|| DEFAULT && IterablePrototype[DEFAULT];
+var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
+var CurrentIteratorPrototype, methods, KEY;
+// fix native
+if (anyNativeIterator) {
+CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
+if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+if (setPrototypeOf) {
+setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
+} else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
+createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);
+}
+}
+// Set @@toStringTag to native iterators
+setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
+if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
+}
+}
+// fix Array#{values, @@iterator}.name in V8 / FF
+if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+INCORRECT_VALUES_NAME = true;
+defaultIterator = function values() { return nativeIterator.call(this); };
+}
+// define iterator
+if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
+createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);
+}
+Iterators[NAME] = defaultIterator;
+// export additional methods
+if (DEFAULT) {
+methods = {
+values: getIterationMethod(VALUES),
+keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+entries: getIterationMethod(ENTRIES)
+};
+if (FORCED) for (KEY in methods) {
+if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+redefine(IterablePrototype, KEY, methods[KEY]);
+}
+} else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+}
+return methods;
+};
+},{"../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){
+var fails = require('../internals/fails');
+// Thank's IE8 for his funny defineProperty
+module.exports = !fails(function () {
+return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
+});
+},{"../internals/fails":22}],19:[function(require,module,exports){
+var global = require('../internals/global');
+var isObject = require('../internals/is-object');
+var document = global.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS = isObject(document) && isObject(document.createElement);
+module.exports = function (it) {
+return EXISTS ? document.createElement(it) : {};
+};
+},{"../internals/global":27,"../internals/is-object":37}],20:[function(require,module,exports){
+// IE8- don't enum bug keys
+module.exports = [
+'constructor',
+'hasOwnProperty',
+'isPrototypeOf',
+'propertyIsEnumerable',
+'toLocaleString',
+'toString',
+'valueOf'
+];
+},{}],21:[function(require,module,exports){
+var global = require('../internals/global');
+var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var redefine = require('../internals/redefine');
+var setGlobal = require('../internals/set-global');
+var copyConstructorProperties = require('../internals/copy-constructor-properties');
+var isForced = require('../internals/is-forced');
+/*
+options.target      - name of the target object
+options.global      - target is the global object
+options.stat        - export as static methods of target
+options.proto       - export as prototype methods of target
+options.real        - real prototype method for the `pure` version
+options.forced      - export even if the native feature is available
+options.bind        - bind methods to the target, required for the `pure` version
+options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
+options.unsafe      - use the simple assignment of property instead of delete + defineProperty
+options.sham        - add a flag to not completely full polyfills
+options.enumerable  - export as enumerable property
+options.noTargetGet - prevent calling a getter on target
+*/
+module.exports = function (options, source) {
+var TARGET = options.target;
+var GLOBAL = options.global;
+var STATIC = options.stat;
+var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+if (GLOBAL) {
+target = global;
+} else if (STATIC) {
+target = global[TARGET] || setGlobal(TARGET, {});
+} else {
+target = (global[TARGET] || {}).prototype;
+}
+if (target) for (key in source) {
+sourceProperty = source[key];
+if (options.noTargetGet) {
+descriptor = getOwnPropertyDescriptor(target, key);
+targetProperty = descriptor && descriptor.value;
+} else targetProperty = target[key];
+FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+// contained in target
+if (!FORCED && targetProperty !== undefined) {
+if (typeof sourceProperty === typeof targetProperty) continue;
+copyConstructorProperties(sourceProperty, targetProperty);
+}
+// add a flag to not completely full polyfills
+if (options.sham || (targetProperty && targetProperty.sham)) {
+createNonEnumerableProperty(sourceProperty, 'sham', true);
+}
+// extend global
+redefine(target, key, sourceProperty, options);
+}
+};
+},{"../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){
+module.exports = function (exec) {
+try {
+return !!exec();
+} catch (error) {
+return true;
+}
+};
+},{}],23:[function(require,module,exports){
+var aFunction = require('../internals/a-function');
+// optional / simple context binding
+module.exports = function (fn, that, length) {
+aFunction(fn);
+if (that === undefined) return fn;
+switch (length) {
+case 0: return function () {
+return fn.call(that);
+};
+case 1: return function (a) {
+return fn.call(that, a);
+};
+case 2: return function (a, b) {
+return fn.call(that, a, b);
+};
+case 3: return function (a, b, c) {
+return fn.call(that, a, b, c);
+};
+}
+return function (/* ...args */) {
+return fn.apply(that, arguments);
+};
+};
+},{"../internals/a-function":1}],24:[function(require,module,exports){
+var path = require('../internals/path');
+var global = require('../internals/global');
+var aFunction = function (variable) {
+return typeof variable == 'function' ? variable : undefined;
+};
+module.exports = function (namespace, method) {
+return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])
+: path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
+};
+},{"../internals/global":27,"../internals/path":57}],25:[function(require,module,exports){
+var classof = require('../internals/classof');
+var Iterators = require('../internals/iterators');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var ITERATOR = wellKnownSymbol('iterator');
+module.exports = function (it) {
+if (it != undefined) return it[ITERATOR]
+|| it['@@iterator']
+|| Iterators[classof(it)];
+};
+},{"../internals/classof":10,"../internals/iterators":40,"../internals/well-known-symbol":77}],26:[function(require,module,exports){
+var anObject = require('../internals/an-object');
+var getIteratorMethod = require('../internals/get-iterator-method');
+module.exports = function (it) {
+var iteratorMethod = getIteratorMethod(it);
+if (typeof iteratorMethod != 'function') {
+throw TypeError(String(it) + ' is not iterable');
+} return anObject(iteratorMethod.call(it));
+};
+},{"../internals/an-object":5,"../internals/get-iterator-method":25}],27:[function(require,module,exports){
+(function (global){
+var check = function (it) {
+return it && it.Math == Math && it;
+};
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+module.exports =
+// eslint-disable-next-line no-undef
+check(typeof globalThis == 'object' && globalThis) ||
+check(typeof window == 'object' && window) ||
+check(typeof self == 'object' && self) ||
+check(typeof global == 'object' && global) ||
+// eslint-disable-next-line no-new-func
+Function('return this')();
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],28:[function(require,module,exports){
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function (it, key) {
+return hasOwnProperty.call(it, key);
+};
+},{}],29:[function(require,module,exports){
+module.exports = {};
+},{}],30:[function(require,module,exports){
+var getBuiltIn = require('../internals/get-built-in');
+module.exports = getBuiltIn('document', 'documentElement');
+},{"../internals/get-built-in":24}],31:[function(require,module,exports){
+var DESCRIPTORS = require('../internals/descriptors');
+var fails = require('../internals/fails');
+var createElement = require('../internals/document-create-element');
+// Thank's IE8 for his funny defineProperty
+module.exports = !DESCRIPTORS && !fails(function () {
+return Object.defineProperty(createElement('div'), 'a', {
+get: function () { return 7; }
+}).a != 7;
+});
+},{"../internals/descriptors":18,"../internals/document-create-element":19,"../internals/fails":22}],32:[function(require,module,exports){
+var fails = require('../internals/fails');
+var classof = require('../internals/classof-raw');
+var split = ''.split;
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+module.exports = fails(function () {
+// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+// eslint-disable-next-line no-prototype-builtins
+return !Object('z').propertyIsEnumerable(0);
+}) ? function (it) {
+return classof(it) == 'String' ? split.call(it, '') : Object(it);
+} : Object;
+},{"../internals/classof-raw":9,"../internals/fails":22}],33:[function(require,module,exports){
+var store = require('../internals/shared-store');
+var functionToString = Function.toString;
+// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
+if (typeof store.inspectSource != 'function') {
+store.inspectSource = function (it) {
+return functionToString.call(it);
+};
+}
+module.exports = store.inspectSource;
+},{"../internals/shared-store":64}],34:[function(require,module,exports){
+var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
+var global = require('../internals/global');
+var isObject = require('../internals/is-object');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var objectHas = require('../internals/has');
+var sharedKey = require('../internals/shared-key');
+var hiddenKeys = require('../internals/hidden-keys');
+var WeakMap = global.WeakMap;
+var set, get, has;
+var enforce = function (it) {
+return has(it) ? get(it) : set(it, {});
+};
+var getterFor = function (TYPE) {
+return function (it) {
+var state;
+if (!isObject(it) || (state = get(it)).type !== TYPE) {
+throw TypeError('Incompatible receiver, ' + TYPE + ' required');
+} return state;
+};
+};
+if (NATIVE_WEAK_MAP) {
+var store = new WeakMap();
+var wmget = store.get;
+var wmhas = store.has;
+var wmset = store.set;
+set = function (it, metadata) {
+wmset.call(store, it, metadata);
+return metadata;
+};
+get = function (it) {
+return wmget.call(store, it) || {};
+};
+has = function (it) {
+return wmhas.call(store, it);
+};
+} else {
+var STATE = sharedKey('state');
+hiddenKeys[STATE] = true;
+set = function (it, metadata) {
+createNonEnumerableProperty(it, STATE, metadata);
+return metadata;
+};
+get = function (it) {
+return objectHas(it, STATE) ? it[STATE] : {};
+};
+has = function (it) {
+return objectHas(it, STATE);
+};
+}
+module.exports = {
+set: set,
+get: get,
+has: has,
+enforce: enforce,
+getterFor: getterFor
+};
+},{"../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){
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var Iterators = require('../internals/iterators');
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
+// check on default Array iterator
+module.exports = function (it) {
+return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+};
+},{"../internals/iterators":40,"../internals/well-known-symbol":77}],36:[function(require,module,exports){
+var fails = require('../internals/fails');
+var replacement = /#|\.prototype\./;
+var isForced = function (feature, detection) {
+var value = data[normalize(feature)];
+return value == POLYFILL ? true
+: value == NATIVE ? false
+: typeof detection == 'function' ? fails(detection)
+: !!detection;
+};
+var normalize = isForced.normalize = function (string) {
+return String(string).replace(replacement, '.').toLowerCase();
+};
+var data = isForced.data = {};
+var NATIVE = isForced.NATIVE = 'N';
+var POLYFILL = isForced.POLYFILL = 'P';
+module.exports = isForced;
+},{"../internals/fails":22}],37:[function(require,module,exports){
+module.exports = function (it) {
+return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+},{}],38:[function(require,module,exports){
+module.exports = false;
+},{}],39:[function(require,module,exports){
+'use strict';
+var getPrototypeOf = require('../internals/object-get-prototype-of');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var has = require('../internals/has');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var IS_PURE = require('../internals/is-pure');
+var ITERATOR = wellKnownSymbol('iterator');
+var BUGGY_SAFARI_ITERATORS = false;
+var returnThis = function () { return this; };
+// `%IteratorPrototype%` object
+// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
+var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+if ([].keys) {
+arrayIterator = [].keys();
+// Safari 8 has buggy iterators w/o `next`
+if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
+else {
+PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+}
+}
+if (IteratorPrototype == undefined) IteratorPrototype = {};
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {
+createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);
+}
+module.exports = {
+IteratorPrototype: IteratorPrototype,
+BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
+};
+},{"../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){
+arguments[4][29][0].apply(exports,arguments)
+},{"dup":29}],41:[function(require,module,exports){
+var fails = require('../internals/fails');
+module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
+// Chrome 38 Symbol has incorrect toString conversion
+// eslint-disable-next-line no-undef
+return !String(Symbol());
+});
+},{"../internals/fails":22}],42:[function(require,module,exports){
+var fails = require('../internals/fails');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var IS_PURE = require('../internals/is-pure');
+var ITERATOR = wellKnownSymbol('iterator');
+module.exports = !fails(function () {
+var url = new URL('b?a=1&b=2&c=3', 'http://a');
+var searchParams = url.searchParams;
+var result = '';
+url.pathname = 'c%20d';
+searchParams.forEach(function (value, key) {
+searchParams['delete']('b');
+result += key + value;
+});
+return (IS_PURE && !url.toJSON)
+|| !searchParams.sort
+|| url.href !== 'http://a/c%20d?a=1&c=3'
+|| searchParams.get('c') !== '3'
+|| String(new URLSearchParams('?a=1')) !== 'a=1'
+|| !searchParams[ITERATOR]
+// throws in Edge
+|| new URL('https://a@b').username !== 'a'
+|| new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
+// not punycoded in Edge
+|| new URL('http://тест').host !== 'xn--e1aybc'
+// not escaped in Chrome 62-
+|| new URL('http://a#б').hash !== '#%D0%B1'
+// fails in Chrome 66-
+|| result !== 'a1c3'
+// throws in Safari
+|| new URL('http://x', undefined).host !== 'x';
+});
+},{"../internals/fails":22,"../internals/is-pure":38,"../internals/well-known-symbol":77}],43:[function(require,module,exports){
+var global = require('../internals/global');
+var inspectSource = require('../internals/inspect-source');
+var WeakMap = global.WeakMap;
+module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
+},{"../internals/global":27,"../internals/inspect-source":33}],44:[function(require,module,exports){
+'use strict';
+var DESCRIPTORS = require('../internals/descriptors');
+var fails = require('../internals/fails');
+var objectKeys = require('../internals/object-keys');
+var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
+var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
+var toObject = require('../internals/to-object');
+var IndexedObject = require('../internals/indexed-object');
+var nativeAssign = Object.assign;
+var defineProperty = Object.defineProperty;
+// `Object.assign` method
+// https://tc39.github.io/ecma262/#sec-object.assign
+module.exports = !nativeAssign || fails(function () {
+// should have correct order of operations (Edge bug)
+if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', {
+enumerable: true,
+get: function () {
+defineProperty(this, 'b', {
+value: 3,
+enumerable: false
+});
+}
+}), { b: 2 })).b !== 1) return true;
+// should work with symbols and should have deterministic property order (V8 bug)
+var A = {};
+var B = {};
+// eslint-disable-next-line no-undef
+var symbol = Symbol();
+var alphabet = 'abcdefghijklmnopqrst';
+A[symbol] = 7;
+alphabet.split('').forEach(function (chr) { B[chr] = chr; });
+return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;
+}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
+var T = toObject(target);
+var argumentsLength = arguments.length;
+var index = 1;
+var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+var propertyIsEnumerable = propertyIsEnumerableModule.f;
+while (argumentsLength > index) {
+var S = IndexedObject(arguments[index++]);
+var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
+var length = keys.length;
+var j = 0;
+var key;
+while (length > j) {
+key = keys[j++];
+if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];
+}
+} return T;
+} : nativeAssign;
+},{"../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){
+var anObject = require('../internals/an-object');
+var defineProperties = require('../internals/object-define-properties');
+var enumBugKeys = require('../internals/enum-bug-keys');
+var hiddenKeys = require('../internals/hidden-keys');
+var html = require('../internals/html');
+var documentCreateElement = require('../internals/document-create-element');
+var sharedKey = require('../internals/shared-key');
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO = sharedKey('IE_PROTO');
+var EmptyConstructor = function () { /* empty */ };
+var scriptTag = function (content) {
+return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+};
+// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+var NullProtoObjectViaActiveX = function (activeXDocument) {
+activeXDocument.write(scriptTag(''));
+activeXDocument.close();
+var temp = activeXDocument.parentWindow.Object;
+activeXDocument = null; // avoid memory leak
+return temp;
+};
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var NullProtoObjectViaIFrame = function () {
+// Thrash, waste and sodomy: IE GC bug
+var iframe = documentCreateElement('iframe');
+var JS = 'java' + SCRIPT + ':';
+var iframeDocument;
+iframe.style.display = 'none';
+html.appendChild(iframe);
+// https://github.com/zloirock/core-js/issues/475
+iframe.src = String(JS);
+iframeDocument = iframe.contentWindow.document;
+iframeDocument.open();
+iframeDocument.write(scriptTag('document.F=Object'));
+iframeDocument.close();
+return iframeDocument.F;
+};
+// Check for document.domain and active x support
+// No need to use active x approach when document.domain is not set
+// see https://github.com/es-shims/es5-shim/issues/150
+// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+// avoid IE GC bug
+var activeXDocument;
+var NullProtoObject = function () {
+try {
+/* global ActiveXObject */
+activeXDocument = document.domain && new ActiveXObject('htmlfile');
+} catch (error) { /* ignore */ }
+NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
+var length = enumBugKeys.length;
+while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+return NullProtoObject();
+};
+hiddenKeys[IE_PROTO] = true;
+// `Object.create` method
+// https://tc39.github.io/ecma262/#sec-object.create
+module.exports = Object.create || function create(O, Properties) {
+var result;
+if (O !== null) {
+EmptyConstructor[PROTOTYPE] = anObject(O);
+result = new EmptyConstructor();
+EmptyConstructor[PROTOTYPE] = null;
+// add "__proto__" for Object.getPrototypeOf polyfill
+result[IE_PROTO] = O;
+} else result = NullProtoObject();
+return Properties === undefined ? result : defineProperties(result, Properties);
+};
+},{"../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){
+var DESCRIPTORS = require('../internals/descriptors');
+var definePropertyModule = require('../internals/object-define-property');
+var anObject = require('../internals/an-object');
+var objectKeys = require('../internals/object-keys');
+// `Object.defineProperties` method
+// https://tc39.github.io/ecma262/#sec-object.defineproperties
+module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
+anObject(O);
+var keys = objectKeys(Properties);
+var length = keys.length;
+var index = 0;
+var key;
+while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);
+return O;
+};
+},{"../internals/an-object":5,"../internals/descriptors":18,"../internals/object-define-property":47,"../internals/object-keys":53}],47:[function(require,module,exports){
+var DESCRIPTORS = require('../internals/descriptors');
+var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
+var anObject = require('../internals/an-object');
+var toPrimitive = require('../internals/to-primitive');
+var nativeDefineProperty = Object.defineProperty;
+// `Object.defineProperty` method
+// https://tc39.github.io/ecma262/#sec-object.defineproperty
+exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
+anObject(O);
+P = toPrimitive(P, true);
+anObject(Attributes);
+if (IE8_DOM_DEFINE) try {
+return nativeDefineProperty(O, P, Attributes);
+} catch (error) { /* empty */ }
+if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
+if ('value' in Attributes) O[P] = Attributes.value;
+return O;
+};
+},{"../internals/an-object":5,"../internals/descriptors":18,"../internals/ie8-dom-define":31,"../internals/to-primitive":73}],48:[function(require,module,exports){
+var DESCRIPTORS = require('../internals/descriptors');
+var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
+var createPropertyDescriptor = require('../internals/create-property-descriptor');
+var toIndexedObject = require('../internals/to-indexed-object');
+var toPrimitive = require('../internals/to-primitive');
+var has = require('../internals/has');
+var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
+var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
+exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+O = toIndexedObject(O);
+P = toPrimitive(P, true);
+if (IE8_DOM_DEFINE) try {
+return nativeGetOwnPropertyDescriptor(O, P);
+} catch (error) { /* empty */ }
+if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
+};
+},{"../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){
+var internalObjectKeys = require('../internals/object-keys-internal');
+var enumBugKeys = require('../internals/enum-bug-keys');
+var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+// `Object.getOwnPropertyNames` method
+// https://tc39.github.io/ecma262/#sec-object.getownpropertynames
+exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+return internalObjectKeys(O, hiddenKeys);
+};
+},{"../internals/enum-bug-keys":20,"../internals/object-keys-internal":52}],50:[function(require,module,exports){
+exports.f = Object.getOwnPropertySymbols;
+},{}],51:[function(require,module,exports){
+var has = require('../internals/has');
+var toObject = require('../internals/to-object');
+var sharedKey = require('../internals/shared-key');
+var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');
+var IE_PROTO = sharedKey('IE_PROTO');
+var ObjectPrototype = Object.prototype;
+// `Object.getPrototypeOf` method
+// https://tc39.github.io/ecma262/#sec-object.getprototypeof
+module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
+O = toObject(O);
+if (has(O, IE_PROTO)) return O[IE_PROTO];
+if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+return O.constructor.prototype;
+} return O instanceof Object ? ObjectPrototype : null;
+};
+},{"../internals/correct-prototype-getter":12,"../internals/has":28,"../internals/shared-key":63,"../internals/to-object":72}],52:[function(require,module,exports){
+var has = require('../internals/has');
+var toIndexedObject = require('../internals/to-indexed-object');
+var indexOf = require('../internals/array-includes').indexOf;
+var hiddenKeys = require('../internals/hidden-keys');
+module.exports = function (object, names) {
+var O = toIndexedObject(object);
+var i = 0;
+var result = [];
+var key;
+for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
+// Don't enum bug & hidden keys
+while (names.length > i) if (has(O, key = names[i++])) {
+~indexOf(result, key) || result.push(key);
+}
+return result;
+};
+},{"../internals/array-includes":7,"../internals/has":28,"../internals/hidden-keys":29,"../internals/to-indexed-object":69}],53:[function(require,module,exports){
+var internalObjectKeys = require('../internals/object-keys-internal');
+var enumBugKeys = require('../internals/enum-bug-keys');
+// `Object.keys` method
+// https://tc39.github.io/ecma262/#sec-object.keys
+module.exports = Object.keys || function keys(O) {
+return internalObjectKeys(O, enumBugKeys);
+};
+},{"../internals/enum-bug-keys":20,"../internals/object-keys-internal":52}],54:[function(require,module,exports){
+'use strict';
+var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
+// `Object.prototype.propertyIsEnumerable` method implementation
+// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable
+exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+var descriptor = getOwnPropertyDescriptor(this, V);
+return !!descriptor && descriptor.enumerable;
+} : nativePropertyIsEnumerable;
+},{}],55:[function(require,module,exports){
+var anObject = require('../internals/an-object');
+var aPossiblePrototype = require('../internals/a-possible-prototype');
+// `Object.setPrototypeOf` method
+// https://tc39.github.io/ecma262/#sec-object.setprototypeof
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+/* eslint-disable no-proto */
+module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+var CORRECT_SETTER = false;
+var test = {};
+var setter;
+try {
+setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
+setter.call(test, []);
+CORRECT_SETTER = test instanceof Array;
+} catch (error) { /* empty */ }
+return function setPrototypeOf(O, proto) {
+anObject(O);
+aPossiblePrototype(proto);
+if (CORRECT_SETTER) setter.call(O, proto);
+else O.__proto__ = proto;
+return O;
+};
+}() : undefined);
+},{"../internals/a-possible-prototype":2,"../internals/an-object":5}],56:[function(require,module,exports){
+var getBuiltIn = require('../internals/get-built-in');
+var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');
+var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
+var anObject = require('../internals/an-object');
+// all object keys, includes non-enumerable and symbols
+module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+var keys = getOwnPropertyNamesModule.f(anObject(it));
+var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
+};
+},{"../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){
+var global = require('../internals/global');
+module.exports = global;
+},{"../internals/global":27}],58:[function(require,module,exports){
+var redefine = require('../internals/redefine');
+module.exports = function (target, src, options) {
+for (var key in src) redefine(target, key, src[key], options);
+return target;
+};
+},{"../internals/redefine":59}],59:[function(require,module,exports){
+var global = require('../internals/global');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var has = require('../internals/has');
+var setGlobal = require('../internals/set-global');
+var inspectSource = require('../internals/inspect-source');
+var InternalStateModule = require('../internals/internal-state');
+var getInternalState = InternalStateModule.get;
+var enforceInternalState = InternalStateModule.enforce;
+var TEMPLATE = String(String).split('String');
+(module.exports = function (O, key, value, options) {
+var unsafe = options ? !!options.unsafe : false;
+var simple = options ? !!options.enumerable : false;
+var noTargetGet = options ? !!options.noTargetGet : false;
+if (typeof value == 'function') {
+if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key);
+enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
+}
+if (O === global) {
+if (simple) O[key] = value;
+else setGlobal(key, value);
+return;
+} else if (!unsafe) {
+delete O[key];
+} else if (!noTargetGet && O[key]) {
+simple = true;
+}
+if (simple) O[key] = value;
+else createNonEnumerableProperty(O, key, value);
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+})(Function.prototype, 'toString', function toString() {
+return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
+});
+},{"../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){
+// `RequireObjectCoercible` abstract operation
+// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
+module.exports = function (it) {
+if (it == undefined) throw TypeError("Can't call method on " + it);
+return it;
+};
+},{}],61:[function(require,module,exports){
+var global = require('../internals/global');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+module.exports = function (key, value) {
+try {
+createNonEnumerableProperty(global, key, value);
+} catch (error) {
+global[key] = value;
+} return value;
+};
+},{"../internals/create-non-enumerable-property":14,"../internals/global":27}],62:[function(require,module,exports){
+var defineProperty = require('../internals/object-define-property').f;
+var has = require('../internals/has');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+module.exports = function (it, TAG, STATIC) {
+if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
+defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
+}
+};
+},{"../internals/has":28,"../internals/object-define-property":47,"../internals/well-known-symbol":77}],63:[function(require,module,exports){
+var shared = require('../internals/shared');
+var uid = require('../internals/uid');
+var keys = shared('keys');
+module.exports = function (key) {
+return keys[key] || (keys[key] = uid(key));
+};
+},{"../internals/shared":65,"../internals/uid":75}],64:[function(require,module,exports){
+var global = require('../internals/global');
+var setGlobal = require('../internals/set-global');
+var SHARED = '__core-js_shared__';
+var store = global[SHARED] || setGlobal(SHARED, {});
+module.exports = store;
+},{"../internals/global":27,"../internals/set-global":61}],65:[function(require,module,exports){
+var IS_PURE = require('../internals/is-pure');
+var store = require('../internals/shared-store');
+(module.exports = function (key, value) {
+return store[key] || (store[key] = value !== undefined ? value : {});
+})('versions', []).push({
+version: '3.6.4',
+mode: IS_PURE ? 'pure' : 'global',
+copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
+});
+},{"../internals/is-pure":38,"../internals/shared-store":64}],66:[function(require,module,exports){
+var toInteger = require('../internals/to-integer');
+var requireObjectCoercible = require('../internals/require-object-coercible');
+// `String.prototype.{ codePointAt, at }` methods implementation
+var createMethod = function (CONVERT_TO_STRING) {
+return function ($this, pos) {
+var S = String(requireObjectCoercible($this));
+var position = toInteger(pos);
+var size = S.length;
+var first, second;
+if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
+first = S.charCodeAt(position);
+return first < 0xD800 || first > 0xDBFF || position + 1 === size
+|| (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
+? CONVERT_TO_STRING ? S.charAt(position) : first
+: CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
+};
+};
+module.exports = {
+// `String.prototype.codePointAt` method
+// https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
+codeAt: createMethod(false),
+// `String.prototype.at` method
+// https://github.com/mathiasbynens/String.prototype.at
+charAt: createMethod(true)
+};
+},{"../internals/require-object-coercible":60,"../internals/to-integer":70}],67:[function(require,module,exports){
+'use strict';
+// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js
+var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
+var base = 36;
+var tMin = 1;
+var tMax = 26;
+var skew = 38;
+var damp = 700;
+var initialBias = 72;
+var initialN = 128; // 0x80
+var delimiter = '-'; // '\x2D'
+var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars
+var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
+var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
+var baseMinusTMin = base - tMin;
+var floor = Math.floor;
+var stringFromCharCode = String.fromCharCode;
+/**
+* Creates an array containing the numeric code points of each Unicode
+* character in the string. While JavaScript uses UCS-2 internally,
+* this function will convert a pair of surrogate halves (each of which
+* UCS-2 exposes as separate characters) into a single code point,
+* matching UTF-16.
+*/
+var ucs2decode = function (string) {
+var output = [];
+var counter = 0;
+var length = string.length;
+while (counter < length) {
+var value = string.charCodeAt(counter++);
+if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+// It's a high surrogate, and there is a next character.
+var extra = string.charCodeAt(counter++);
+if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
+output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+} else {
+// It's an unmatched surrogate; only append this code unit, in case the
+// next code unit is the high surrogate of a surrogate pair.
+output.push(value);
+counter--;
+}
+} else {
+output.push(value);
+}
+}
+return output;
+};
+/**
+* Converts a digit/integer into a basic code point.
+*/
+var digitToBasic = function (digit) {
+//  0..25 map to ASCII a..z or A..Z
+// 26..35 map to ASCII 0..9
+return digit + 22 + 75 * (digit < 26);
+};
+/**
+* Bias adaptation function as per section 3.4 of RFC 3492.
+* https://tools.ietf.org/html/rfc3492#section-3.4
+*/
+var adapt = function (delta, numPoints, firstTime) {
+var k = 0;
+delta = firstTime ? floor(delta / damp) : delta >> 1;
+delta += floor(delta / numPoints);
+for (; delta > baseMinusTMin * tMax >> 1; k += base) {
+delta = floor(delta / baseMinusTMin);
+}
+return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+};
+/**
+* Converts a string of Unicode symbols (e.g. a domain name label) to a
+* Punycode string of ASCII-only symbols.
+*/
+// eslint-disable-next-line  max-statements
+var encode = function (input) {
+var output = [];
+// Convert the input in UCS-2 to an array of Unicode code points.
+input = ucs2decode(input);
+// Cache the length.
+var inputLength = input.length;
+// Initialize the state.
+var n = initialN;
+var delta = 0;
+var bias = initialBias;
+var i, currentValue;
+// Handle the basic code points.
+for (i = 0; i < input.length; i++) {
+currentValue = input[i];
+if (currentValue < 0x80) {
+output.push(stringFromCharCode(currentValue));
+}
+}
+var basicLength = output.length; // number of basic code points.
+var handledCPCount = basicLength; // number of code points that have been handled;
+// Finish the basic string with a delimiter unless it's empty.
+if (basicLength) {
+output.push(delimiter);
+}
+// Main encoding loop:
+while (handledCPCount < inputLength) {
+// All non-basic code points < n have been handled already. Find the next larger one:
+var m = maxInt;
+for (i = 0; i < input.length; i++) {
+currentValue = input[i];
+if (currentValue >= n && currentValue < m) {
+m = currentValue;
+}
+}
+// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.
+var handledCPCountPlusOne = handledCPCount + 1;
+if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+throw RangeError(OVERFLOW_ERROR);
+}
+delta += (m - n) * handledCPCountPlusOne;
+n = m;
+for (i = 0; i < input.length; i++) {
+currentValue = input[i];
+if (currentValue < n && ++delta > maxInt) {
+throw RangeError(OVERFLOW_ERROR);
+}
+if (currentValue == n) {
+// Represent delta as a generalized variable-length integer.
+var q = delta;
+for (var k = base; /* no condition */; k += base) {
+var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+if (q < t) break;
+var qMinusT = q - t;
+var baseMinusT = base - t;
+output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
+q = floor(qMinusT / baseMinusT);
+}
+output.push(stringFromCharCode(digitToBasic(q)));
+bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+delta = 0;
+++handledCPCount;
+}
+}
+++delta;
+++n;
+}
+return output.join('');
+};
+module.exports = function (input) {
+var encoded = [];
+var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.');
+var i, label;
+for (i = 0; i < labels.length; i++) {
+label = labels[i];
+encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label);
+}
+return encoded.join('.');
+};
+},{}],68:[function(require,module,exports){
+var toInteger = require('../internals/to-integer');
+var max = Math.max;
+var min = Math.min;
+// Helper for a popular repeating case of the spec:
+// Let integer be ? ToInteger(index).
+// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+module.exports = function (index, length) {
+var integer = toInteger(index);
+return integer < 0 ? max(integer + length, 0) : min(integer, length);
+};
+},{"../internals/to-integer":70}],69:[function(require,module,exports){
+// toObject with fallback for non-array-like ES3 strings
+var IndexedObject = require('../internals/indexed-object');
+var requireObjectCoercible = require('../internals/require-object-coercible');
+module.exports = function (it) {
+return IndexedObject(requireObjectCoercible(it));
+};
+},{"../internals/indexed-object":32,"../internals/require-object-coercible":60}],70:[function(require,module,exports){
+var ceil = Math.ceil;
+var floor = Math.floor;
+// `ToInteger` abstract operation
+// https://tc39.github.io/ecma262/#sec-tointeger
+module.exports = function (argument) {
+return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
+};
+},{}],71:[function(require,module,exports){
+var toInteger = require('../internals/to-integer');
+var min = Math.min;
+// `ToLength` abstract operation
+// https://tc39.github.io/ecma262/#sec-tolength
+module.exports = function (argument) {
+return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+},{"../internals/to-integer":70}],72:[function(require,module,exports){
+var requireObjectCoercible = require('../internals/require-object-coercible');
+// `ToObject` abstract operation
+// https://tc39.github.io/ecma262/#sec-toobject
+module.exports = function (argument) {
+return Object(requireObjectCoercible(argument));
+};
+},{"../internals/require-object-coercible":60}],73:[function(require,module,exports){
+var isObject = require('../internals/is-object');
+// `ToPrimitive` abstract operation
+// https://tc39.github.io/ecma262/#sec-toprimitive
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+module.exports = function (input, PREFERRED_STRING) {
+if (!isObject(input)) return input;
+var fn, val;
+if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
+if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
+if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
+throw TypeError("Can't convert object to primitive value");
+};
+},{"../internals/is-object":37}],74:[function(require,module,exports){
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var test = {};
+test[TO_STRING_TAG] = 'z';
+module.exports = String(test) === '[object z]';
+},{"../internals/well-known-symbol":77}],75:[function(require,module,exports){
+var id = 0;
+var postfix = Math.random();
+module.exports = function (key) {
+return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
+};
+},{}],76:[function(require,module,exports){
+var NATIVE_SYMBOL = require('../internals/native-symbol');
+module.exports = NATIVE_SYMBOL
+// eslint-disable-next-line no-undef
+&& !Symbol.sham
+// eslint-disable-next-line no-undef
+&& typeof Symbol.iterator == 'symbol';
+},{"../internals/native-symbol":41}],77:[function(require,module,exports){
+var global = require('../internals/global');
+var shared = require('../internals/shared');
+var has = require('../internals/has');
+var uid = require('../internals/uid');
+var NATIVE_SYMBOL = require('../internals/native-symbol');
+var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');
+var WellKnownSymbolsStore = shared('wks');
+var Symbol = global.Symbol;
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
+module.exports = function (name) {
+if (!has(WellKnownSymbolsStore, name)) {
+if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];
+else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
+} return WellKnownSymbolsStore[name];
+};
+},{"../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){
+'use strict';
+var toIndexedObject = require('../internals/to-indexed-object');
+var addToUnscopables = require('../internals/add-to-unscopables');
+var Iterators = require('../internals/iterators');
+var InternalStateModule = require('../internals/internal-state');
+var defineIterator = require('../internals/define-iterator');
+var ARRAY_ITERATOR = 'Array Iterator';
+var setInternalState = InternalStateModule.set;
+var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
+// `Array.prototype.entries` method
+// https://tc39.github.io/ecma262/#sec-array.prototype.entries
+// `Array.prototype.keys` method
+// https://tc39.github.io/ecma262/#sec-array.prototype.keys
+// `Array.prototype.values` method
+// https://tc39.github.io/ecma262/#sec-array.prototype.values
+// `Array.prototype[@@iterator]` method
+// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
+// `CreateArrayIterator` internal method
+// https://tc39.github.io/ecma262/#sec-createarrayiterator
+module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
+setInternalState(this, {
+type: ARRAY_ITERATOR,
+target: toIndexedObject(iterated), // target
+index: 0,                          // next index
+kind: kind                         // kind
+});
+// `%ArrayIteratorPrototype%.next` method
+// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
+}, function () {
+var state = getInternalState(this);
+var target = state.target;
+var kind = state.kind;
+var index = state.index++;
+if (!target || index >= target.length) {
+state.target = undefined;
+return { value: undefined, done: true };
+}
+if (kind == 'keys') return { value: index, done: false };
+if (kind == 'values') return { value: target[index], done: false };
+return { value: [index, target[index]], done: false };
+}, 'values');
+// argumentsList[@@iterator] is %ArrayProto_values%
+// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject
+// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject
+Iterators.Arguments = Iterators.Array;
+// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+},{"../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){
+'use strict';
+var charAt = require('../internals/string-multibyte').charAt;
+var InternalStateModule = require('../internals/internal-state');
+var defineIterator = require('../internals/define-iterator');
+var STRING_ITERATOR = 'String Iterator';
+var setInternalState = InternalStateModule.set;
+var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
+// `String.prototype[@@iterator]` method
+// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
+defineIterator(String, 'String', function (iterated) {
+setInternalState(this, {
+type: STRING_ITERATOR,
+string: String(iterated),
+index: 0
+});
+// `%StringIteratorPrototype%.next` method
+// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
+}, function next() {
+var state = getInternalState(this);
+var string = state.string;
+var index = state.index;
+var point;
+if (index >= string.length) return { value: undefined, done: true };
+point = charAt(string, index);
+state.index += point.length;
+return { value: point, done: false };
+});
+},{"../internals/define-iterator":17,"../internals/internal-state":34,"../internals/string-multibyte":66}],80:[function(require,module,exports){
+'use strict';
+// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
+require('../modules/es.array.iterator');
+var $ = require('../internals/export');
+var getBuiltIn = require('../internals/get-built-in');
+var USE_NATIVE_URL = require('../internals/native-url');
+var redefine = require('../internals/redefine');
+var redefineAll = require('../internals/redefine-all');
+var setToStringTag = require('../internals/set-to-string-tag');
+var createIteratorConstructor = require('../internals/create-iterator-constructor');
+var InternalStateModule = require('../internals/internal-state');
+var anInstance = require('../internals/an-instance');
+var hasOwn = require('../internals/has');
+var bind = require('../internals/function-bind-context');
+var classof = require('../internals/classof');
+var anObject = require('../internals/an-object');
+var isObject = require('../internals/is-object');
+var create = require('../internals/object-create');
+var createPropertyDescriptor = require('../internals/create-property-descriptor');
+var getIterator = require('../internals/get-iterator');
+var getIteratorMethod = require('../internals/get-iterator-method');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var $fetch = getBuiltIn('fetch');
+var Headers = getBuiltIn('Headers');
+var ITERATOR = wellKnownSymbol('iterator');
+var URL_SEARCH_PARAMS = 'URLSearchParams';
+var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
+var setInternalState = InternalStateModule.set;
+var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
+var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
+var plus = /\+/g;
+var sequences = Array(4);
+var percentSequence = function (bytes) {
+return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
+};
+var percentDecode = function (sequence) {
+try {
+return decodeURIComponent(sequence);
+} catch (error) {
+return sequence;
+}
+};
+var deserialize = function (it) {
+var result = it.replace(plus, ' ');
+var bytes = 4;
+try {
+return decodeURIComponent(result);
+} catch (error) {
+while (bytes) {
+result = result.replace(percentSequence(bytes--), percentDecode);
+}
+return result;
+}
+};
+var find = /[!'()~]|%20/g;
+var replace = {
+'!': '%21',
+"'": '%27',
+'(': '%28',
+')': '%29',
+'~': '%7E',
+'%20': '+'
+};
+var replacer = function (match) {
+return replace[match];
+};
+var serialize = function (it) {
+return encodeURIComponent(it).replace(find, replacer);
+};
+var parseSearchParams = function (result, query) {
+if (query) {
+var attributes = query.split('&');
+var index = 0;
+var attribute, entry;
+while (index < attributes.length) {
+attribute = attributes[index++];
+if (attribute.length) {
+entry = attribute.split('=');
+result.push({
+key: deserialize(entry.shift()),
+value: deserialize(entry.join('='))
+});
+}
+}
+}
+};
+var updateSearchParams = function (query) {
+this.entries.length = 0;
+parseSearchParams(this.entries, query);
+};
+var validateArgumentsLength = function (passed, required) {
+if (passed < required) throw TypeError('Not enough arguments');
+};
+var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
+setInternalState(this, {
+type: URL_SEARCH_PARAMS_ITERATOR,
+iterator: getIterator(getInternalParamsState(params).entries),
+kind: kind
+});
+}, 'Iterator', function next() {
+var state = getInternalIteratorState(this);
+var kind = state.kind;
+var step = state.iterator.next();
+var entry = step.value;
+if (!step.done) {
+step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
+} return step;
+});
+// `URLSearchParams` constructor
+// https://url.spec.whatwg.org/#interface-urlsearchparams
+var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
+anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);
+var init = arguments.length > 0 ? arguments[0] : undefined;
+var that = this;
+var entries = [];
+var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;
+setInternalState(that, {
+type: URL_SEARCH_PARAMS,
+entries: entries,
+updateURL: function () { /* empty */ },
+updateSearchParams: updateSearchParams
+});
+if (init !== undefined) {
+if (isObject(init)) {
+iteratorMethod = getIteratorMethod(init);
+if (typeof iteratorMethod === 'function') {
+iterator = iteratorMethod.call(init);
+next = iterator.next;
+while (!(step = next.call(iterator)).done) {
+entryIterator = getIterator(anObject(step.value));
+entryNext = entryIterator.next;
+if (
+(first = entryNext.call(entryIterator)).done ||
+(second = entryNext.call(entryIterator)).done ||
+!entryNext.call(entryIterator).done
+) throw TypeError('Expected sequence with length 2');
+entries.push({ key: first.value + '', value: second.value + '' });
+}
+} else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' });
+} else {
+parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');
+}
+}
+};
+var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
+redefineAll(URLSearchParamsPrototype, {
+// `URLSearchParams.prototype.appent` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-append
+append: function append(name, value) {
+validateArgumentsLength(arguments.length, 2);
+var state = getInternalParamsState(this);
+state.entries.push({ key: name + '', value: value + '' });
+state.updateURL();
+},
+// `URLSearchParams.prototype.delete` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
+'delete': function (name) {
+validateArgumentsLength(arguments.length, 1);
+var state = getInternalParamsState(this);
+var entries = state.entries;
+var key = name + '';
+var index = 0;
+while (index < entries.length) {
+if (entries[index].key === key) entries.splice(index, 1);
+else index++;
+}
+state.updateURL();
+},
+// `URLSearchParams.prototype.get` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-get
+get: function get(name) {
+validateArgumentsLength(arguments.length, 1);
+var entries = getInternalParamsState(this).entries;
+var key = name + '';
+var index = 0;
+for (; index < entries.length; index++) {
+if (entries[index].key === key) return entries[index].value;
+}
+return null;
+},
+// `URLSearchParams.prototype.getAll` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
+getAll: function getAll(name) {
+validateArgumentsLength(arguments.length, 1);
+var entries = getInternalParamsState(this).entries;
+var key = name + '';
+var result = [];
+var index = 0;
+for (; index < entries.length; index++) {
+if (entries[index].key === key) result.push(entries[index].value);
+}
+return result;
+},
+// `URLSearchParams.prototype.has` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-has
+has: function has(name) {
+validateArgumentsLength(arguments.length, 1);
+var entries = getInternalParamsState(this).entries;
+var key = name + '';
+var index = 0;
+while (index < entries.length) {
+if (entries[index++].key === key) return true;
+}
+return false;
+},
+// `URLSearchParams.prototype.set` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-set
+set: function set(name, value) {
+validateArgumentsLength(arguments.length, 1);
+var state = getInternalParamsState(this);
+var entries = state.entries;
+var found = false;
+var key = name + '';
+var val = value + '';
+var index = 0;
+var entry;
+for (; index < entries.length; index++) {
+entry = entries[index];
+if (entry.key === key) {
+if (found) entries.splice(index--, 1);
+else {
+found = true;
+entry.value = val;
+}
+}
+}
+if (!found) entries.push({ key: key, value: val });
+state.updateURL();
+},
+// `URLSearchParams.prototype.sort` method
+// https://url.spec.whatwg.org/#dom-urlsearchparams-sort
+sort: function sort() {
+var state = getInternalParamsState(this);
+var entries = state.entries;
+// Array#sort is not stable in some engines
+var slice = entries.slice();
+var entry, entriesIndex, sliceIndex;
+entries.length = 0;
+for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {
+entry = slice[sliceIndex];
+for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {
+if (entries[entriesIndex].key > entry.key) {
+entries.splice(entriesIndex, 0, entry);
+break;
+}
+}
+if (entriesIndex === sliceIndex) entries.push(entry);
+}
+state.updateURL();
+},
+// `URLSearchParams.prototype.forEach` method
+forEach: function forEach(callback /* , thisArg */) {
+var entries = getInternalParamsState(this).entries;
+var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);
+var index = 0;
+var entry;
+while (index < entries.length) {
+entry = entries[index++];
+boundFunction(entry.value, entry.key, this);
+}
+},
+// `URLSearchParams.prototype.keys` method
+keys: function keys() {
+return new URLSearchParamsIterator(this, 'keys');
+},
+// `URLSearchParams.prototype.values` method
+values: function values() {
+return new URLSearchParamsIterator(this, 'values');
+},
+// `URLSearchParams.prototype.entries` method
+entries: function entries() {
+return new URLSearchParamsIterator(this, 'entries');
+}
+}, { enumerable: true });
+// `URLSearchParams.prototype[@@iterator]` method
+redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);
+// `URLSearchParams.prototype.toString` method
+// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
+redefine(URLSearchParamsPrototype, 'toString', function toString() {
+var entries = getInternalParamsState(this).entries;
+var result = [];
+var index = 0;
+var entry;
+while (index < entries.length) {
+entry = entries[index++];
+result.push(serialize(entry.key) + '=' + serialize(entry.value));
+} return result.join('&');
+}, { enumerable: true });
+setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
+$({ global: true, forced: !USE_NATIVE_URL }, {
+URLSearchParams: URLSearchParamsConstructor
+});
+// Wrap `fetch` for correct work with polyfilled `URLSearchParams`
+// https://github.com/zloirock/core-js/issues/674
+if (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {
+$({ global: true, enumerable: true, forced: true }, {
+fetch: function fetch(input /* , init */) {
+var args = [input];
+var init, body, headers;
+if (arguments.length > 1) {
+init = arguments[1];
+if (isObject(init)) {
+body = init.body;
+if (classof(body) === URL_SEARCH_PARAMS) {
+headers = init.headers ? new Headers(init.headers) : new Headers();
+if (!headers.has('content-type')) {
+headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+}
+init = create(init, {
+body: createPropertyDescriptor(0, String(body)),
+headers: createPropertyDescriptor(0, headers)
+});
+}
+}
+args.push(init);
+} return $fetch.apply(this, args);
+}
+});
+}
+module.exports = {
+URLSearchParams: URLSearchParamsConstructor,
+getState: getInternalParamsState
+};
+},{"../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){
+'use strict';
+// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
+require('../modules/es.string.iterator');
+var $ = require('../internals/export');
+var DESCRIPTORS = require('../internals/descriptors');
+var USE_NATIVE_URL = require('../internals/native-url');
+var global = require('../internals/global');
+var defineProperties = require('../internals/object-define-properties');
+var redefine = require('../internals/redefine');
+var anInstance = require('../internals/an-instance');
+var has = require('../internals/has');
+var assign = require('../internals/object-assign');
+var arrayFrom = require('../internals/array-from');
+var codeAt = require('../internals/string-multibyte').codeAt;
+var toASCII = require('../internals/string-punycode-to-ascii');
+var setToStringTag = require('../internals/set-to-string-tag');
+var URLSearchParamsModule = require('../modules/web.url-search-params');
+var InternalStateModule = require('../internals/internal-state');
+var NativeURL = global.URL;
+var URLSearchParams = URLSearchParamsModule.URLSearchParams;
+var getInternalSearchParamsState = URLSearchParamsModule.getState;
+var setInternalState = InternalStateModule.set;
+var getInternalURLState = InternalStateModule.getterFor('URL');
+var floor = Math.floor;
+var pow = Math.pow;
+var INVALID_AUTHORITY = 'Invalid authority';
+var INVALID_SCHEME = 'Invalid scheme';
+var INVALID_HOST = 'Invalid host';
+var INVALID_PORT = 'Invalid port';
+var ALPHA = /[A-Za-z]/;
+var ALPHANUMERIC = /[\d+\-.A-Za-z]/;
+var DIGIT = /\d/;
+var HEX_START = /^(0x|0X)/;
+var OCT = /^[0-7]+$/;
+var DEC = /^\d+$/;
+var HEX = /^[\dA-Fa-f]+$/;
+// eslint-disable-next-line no-control-regex
+var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/;
+// eslint-disable-next-line no-control-regex
+var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/;
+// eslint-disable-next-line no-control-regex
+var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g;
+// eslint-disable-next-line no-control-regex
+var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g;
+var EOF;
+var parseHost = function (url, input) {
+var result, codePoints, index;
+if (input.charAt(0) == '[') {
+if (input.charAt(input.length - 1) != ']') return INVALID_HOST;
+result = parseIPv6(input.slice(1, -1));
+if (!result) return INVALID_HOST;
+url.host = result;
+// opaque host
+} else if (!isSpecial(url)) {
+if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST;
+result = '';
+codePoints = arrayFrom(input);
+for (index = 0; index < codePoints.length; index++) {
+result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
+}
+url.host = result;
+} else {
+input = toASCII(input);
+if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST;
+result = parseIPv4(input);
+if (result === null) return INVALID_HOST;
+url.host = result;
+}
+};
+var parseIPv4 = function (input) {
+var parts = input.split('.');
+var partsLength, numbers, index, part, radix, number, ipv4;
+if (parts.length && parts[parts.length - 1] == '') {
+parts.pop();
+}
+partsLength = parts.length;
+if (partsLength > 4) return input;
+numbers = [];
+for (index = 0; index < partsLength; index++) {
+part = parts[index];
+if (part == '') return input;
+radix = 10;
+if (part.length > 1 && part.charAt(0) == '0') {
+radix = HEX_START.test(part) ? 16 : 8;
+part = part.slice(radix == 8 ? 1 : 2);
+}
+if (part === '') {
+number = 0;
+} else {
+if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input;
+number = parseInt(part, radix);
+}
+numbers.push(number);
+}
+for (index = 0; index < partsLength; index++) {
+number = numbers[index];
+if (index == partsLength - 1) {
+if (number >= pow(256, 5 - partsLength)) return null;
+} else if (number > 255) return null;
+}
+ipv4 = numbers.pop();
+for (index = 0; index < numbers.length; index++) {
+ipv4 += numbers[index] * pow(256, 3 - index);
+}
+return ipv4;
+};
+// eslint-disable-next-line max-statements
+var parseIPv6 = function (input) {
+var address = [0, 0, 0, 0, 0, 0, 0, 0];
+var pieceIndex = 0;
+var compress = null;
+var pointer = 0;
+var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
+var char = function () {
+return input.charAt(pointer);
+};
+if (char() == ':') {
+if (input.charAt(1) != ':') return;
+pointer += 2;
+pieceIndex++;
+compress = pieceIndex;
+}
+while (char()) {
+if (pieceIndex == 8) return;
+if (char() == ':') {
+if (compress !== null) return;
+pointer++;
+pieceIndex++;
+compress = pieceIndex;
+continue;
+}
+value = length = 0;
+while (length < 4 && HEX.test(char())) {
+value = value * 16 + parseInt(char(), 16);
+pointer++;
+length++;
+}
+if (char() == '.') {
+if (length == 0) return;
+pointer -= length;
+if (pieceIndex > 6) return;
+numbersSeen = 0;
+while (char()) {
+ipv4Piece = null;
+if (numbersSeen > 0) {
+if (char() == '.' && numbersSeen < 4) pointer++;
+else return;
+}
+if (!DIGIT.test(char())) return;
+while (DIGIT.test(char())) {
+number = parseInt(char(), 10);
+if (ipv4Piece === null) ipv4Piece = number;
+else if (ipv4Piece == 0) return;
+else ipv4Piece = ipv4Piece * 10 + number;
+if (ipv4Piece > 255) return;
+pointer++;
+}
+address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
+numbersSeen++;
+if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;
+}
+if (numbersSeen != 4) return;
+break;
+} else if (char() == ':') {
+pointer++;
+if (!char()) return;
+} else if (char()) return;
+address[pieceIndex++] = value;
+}
+if (compress !== null) {
+swaps = pieceIndex - compress;
+pieceIndex = 7;
+while (pieceIndex != 0 && swaps > 0) {
+swap = address[pieceIndex];
+address[pieceIndex--] = address[compress + swaps - 1];
+address[compress + --swaps] = swap;
+}
+} else if (pieceIndex != 8) return;
+return address;
+};
+var findLongestZeroSequence = function (ipv6) {
+var maxIndex = null;
+var maxLength = 1;
+var currStart = null;
+var currLength = 0;
+var index = 0;
+for (; index < 8; index++) {
+if (ipv6[index] !== 0) {
+if (currLength > maxLength) {
+maxIndex = currStart;
+maxLength = currLength;
+}
+currStart = null;
+currLength = 0;
+} else {
+if (currStart === null) currStart = index;
+++currLength;
+}
+}
+if (currLength > maxLength) {
+maxIndex = currStart;
+maxLength = currLength;
+}
+return maxIndex;
+};
+var serializeHost = function (host) {
+var result, index, compress, ignore0;
+// ipv4
+if (typeof host == 'number') {
+result = [];
+for (index = 0; index < 4; index++) {
+result.unshift(host % 256);
+host = floor(host / 256);
+} return result.join('.');
+// ipv6
+} else if (typeof host == 'object') {
+result = '';
+compress = findLongestZeroSequence(host);
+for (index = 0; index < 8; index++) {
+if (ignore0 && host[index] === 0) continue;
+if (ignore0) ignore0 = false;
+if (compress === index) {
+result += index ? ':' : '::';
+ignore0 = true;
+} else {
+result += host[index].toString(16);
+if (index < 7) result += ':';
+}
+}
+return '[' + result + ']';
+} return host;
+};
+var C0ControlPercentEncodeSet = {};
+var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
+' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
+});
+var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
+'#': 1, '?': 1, '{': 1, '}': 1
+});
+var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
+'/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1
+});
+var percentEncode = function (char, set) {
+var code = codeAt(char, 0);
+return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);
+};
+var specialSchemes = {
+ftp: 21,
+file: null,
+http: 80,
+https: 443,
+ws: 80,
+wss: 443
+};
+var isSpecial = function (url) {
+return has(specialSchemes, url.scheme);
+};
+var includesCredentials = function (url) {
+return url.username != '' || url.password != '';
+};
+var cannotHaveUsernamePasswordPort = function (url) {
+return !url.host || url.cannotBeABaseURL || url.scheme == 'file';
+};
+var isWindowsDriveLetter = function (string, normalized) {
+var second;
+return string.length == 2 && ALPHA.test(string.charAt(0))
+&& ((second = string.charAt(1)) == ':' || (!normalized && second == '|'));
+};
+var startsWithWindowsDriveLetter = function (string) {
+var third;
+return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (
+string.length == 2 ||
+((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#')
+);
+};
+var shortenURLsPath = function (url) {
+var path = url.path;
+var pathSize = path.length;
+if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {
+path.pop();
+}
+};
+var isSingleDot = function (segment) {
+return segment === '.' || segment.toLowerCase() === '%2e';
+};
+var isDoubleDot = function (segment) {
+segment = segment.toLowerCase();
+return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
+};
+// States:
+var SCHEME_START = {};
+var SCHEME = {};
+var NO_SCHEME = {};
+var SPECIAL_RELATIVE_OR_AUTHORITY = {};
+var PATH_OR_AUTHORITY = {};
+var RELATIVE = {};
+var RELATIVE_SLASH = {};
+var SPECIAL_AUTHORITY_SLASHES = {};
+var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
+var AUTHORITY = {};
+var HOST = {};
+var HOSTNAME = {};
+var PORT = {};
+var FILE = {};
+var FILE_SLASH = {};
+var FILE_HOST = {};
+var PATH_START = {};
+var PATH = {};
+var CANNOT_BE_A_BASE_URL_PATH = {};
+var QUERY = {};
+var FRAGMENT = {};
+// eslint-disable-next-line max-statements
+var parseURL = function (url, input, stateOverride, base) {
+var state = stateOverride || SCHEME_START;
+var pointer = 0;
+var buffer = '';
+var seenAt = false;
+var seenBracket = false;
+var seenPasswordToken = false;
+var codePoints, char, bufferCodePoints, failure;
+if (!stateOverride) {
+url.scheme = '';
+url.username = '';
+url.password = '';
+url.host = null;
+url.port = null;
+url.path = [];
+url.query = null;
+url.fragment = null;
+url.cannotBeABaseURL = false;
+input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');
+}
+input = input.replace(TAB_AND_NEW_LINE, '');
+codePoints = arrayFrom(input);
+while (pointer <= codePoints.length) {
+char = codePoints[pointer];
+switch (state) {
+case SCHEME_START:
+if (char && ALPHA.test(char)) {
+buffer += char.toLowerCase();
+state = SCHEME;
+} else if (!stateOverride) {
+state = NO_SCHEME;
+continue;
+} else return INVALID_SCHEME;
+break;
+case SCHEME:
+if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {
+buffer += char.toLowerCase();
+} else if (char == ':') {
+if (stateOverride && (
+(isSpecial(url) != has(specialSchemes, buffer)) ||
+(buffer == 'file' && (includesCredentials(url) || url.port !== null)) ||
+(url.scheme == 'file' && !url.host)
+)) return;
+url.scheme = buffer;
+if (stateOverride) {
+if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null;
+return;
+}
+buffer = '';
+if (url.scheme == 'file') {
+state = FILE;
+} else if (isSpecial(url) && base && base.scheme == url.scheme) {
+state = SPECIAL_RELATIVE_OR_AUTHORITY;
+} else if (isSpecial(url)) {
+state = SPECIAL_AUTHORITY_SLASHES;
+} else if (codePoints[pointer + 1] == '/') {
+state = PATH_OR_AUTHORITY;
+pointer++;
+} else {
+url.cannotBeABaseURL = true;
+url.path.push('');
+state = CANNOT_BE_A_BASE_URL_PATH;
+}
+} else if (!stateOverride) {
+buffer = '';
+state = NO_SCHEME;
+pointer = 0;
+continue;
+} else return INVALID_SCHEME;
+break;
+case NO_SCHEME:
+if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME;
+if (base.cannotBeABaseURL && char == '#') {
+url.scheme = base.scheme;
+url.path = base.path.slice();
+url.query = base.query;
+url.fragment = '';
+url.cannotBeABaseURL = true;
+state = FRAGMENT;
+break;
+}
+state = base.scheme == 'file' ? FILE : RELATIVE;
+continue;
+case SPECIAL_RELATIVE_OR_AUTHORITY:
+if (char == '/' && codePoints[pointer + 1] == '/') {
+state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+pointer++;
+} else {
+state = RELATIVE;
+continue;
+} break;
+case PATH_OR_AUTHORITY:
+if (char == '/') {
+state = AUTHORITY;
+break;
+} else {
+state = PATH;
+continue;
+}
+case RELATIVE:
+url.scheme = base.scheme;
+if (char == EOF) {
+url.username = base.username;
+url.password = base.password;
+url.host = base.host;
+url.port = base.port;
+url.path = base.path.slice();
+url.query = base.query;
+} else if (char == '/' || (char == '\\' && isSpecial(url))) {
+state = RELATIVE_SLASH;
+} else if (char == '?') {
+url.username = base.username;
+url.password = base.password;
+url.host = base.host;
+url.port = base.port;
+url.path = base.path.slice();
+url.query = '';
+state = QUERY;
+} else if (char == '#') {
+url.username = base.username;
+url.password = base.password;
+url.host = base.host;
+url.port = base.port;
+url.path = base.path.slice();
+url.query = base.query;
+url.fragment = '';
+state = FRAGMENT;
+} else {
+url.username = base.username;
+url.password = base.password;
+url.host = base.host;
+url.port = base.port;
+url.path = base.path.slice();
+url.path.pop();
+state = PATH;
+continue;
+} break;
+case RELATIVE_SLASH:
+if (isSpecial(url) && (char == '/' || char == '\\')) {
+state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+} else if (char == '/') {
+state = AUTHORITY;
+} else {
+url.username = base.username;
+url.password = base.password;
+url.host = base.host;
+url.port = base.port;
+state = PATH;
+continue;
+} break;
+case SPECIAL_AUTHORITY_SLASHES:
+state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+if (char != '/' || buffer.charAt(pointer + 1) != '/') continue;
+pointer++;
+break;
+case SPECIAL_AUTHORITY_IGNORE_SLASHES:
+if (char != '/' && char != '\\') {
+state = AUTHORITY;
+continue;
+} break;
+case AUTHORITY:
+if (char == '@') {
+if (seenAt) buffer = '%40' + buffer;
+seenAt = true;
+bufferCodePoints = arrayFrom(buffer);
+for (var i = 0; i < bufferCodePoints.length; i++) {
+var codePoint = bufferCodePoints[i];
+if (codePoint == ':' && !seenPasswordToken) {
+seenPasswordToken = true;
+continue;
+}
+var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
+if (seenPasswordToken) url.password += encodedCodePoints;
+else url.username += encodedCodePoints;
+}
+buffer = '';
+} else if (
+char == EOF || char == '/' || char == '?' || char == '#' ||
+(char == '\\' && isSpecial(url))
+) {
+if (seenAt && buffer == '') return INVALID_AUTHORITY;
+pointer -= arrayFrom(buffer).length + 1;
+buffer = '';
+state = HOST;
+} else buffer += char;
+break;
+case HOST:
+case HOSTNAME:
+if (stateOverride && url.scheme == 'file') {
+state = FILE_HOST;
+continue;
+} else if (char == ':' && !seenBracket) {
+if (buffer == '') return INVALID_HOST;
+failure = parseHost(url, buffer);
+if (failure) return failure;
+buffer = '';
+state = PORT;
+if (stateOverride == HOSTNAME) return;
+} else if (
+char == EOF || char == '/' || char == '?' || char == '#' ||
+(char == '\\' && isSpecial(url))
+) {
+if (isSpecial(url) && buffer == '') return INVALID_HOST;
+if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return;
+failure = parseHost(url, buffer);
+if (failure) return failure;
+buffer = '';
+state = PATH_START;
+if (stateOverride) return;
+continue;
+} else {
+if (char == '[') seenBracket = true;
+else if (char == ']') seenBracket = false;
+buffer += char;
+} break;
+case PORT:
+if (DIGIT.test(char)) {
+buffer += char;
+} else if (
+char == EOF || char == '/' || char == '?' || char == '#' ||
+(char == '\\' && isSpecial(url)) ||
+stateOverride
+) {
+if (buffer != '') {
+var port = parseInt(buffer, 10);
+if (port > 0xFFFF) return INVALID_PORT;
+url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port;
+buffer = '';
+}
+if (stateOverride) return;
+state = PATH_START;
+continue;
+} else return INVALID_PORT;
+break;
+case FILE:
+url.scheme = 'file';
+if (char == '/' || char == '\\') state = FILE_SLASH;
+else if (base && base.scheme == 'file') {
+if (char == EOF) {
+url.host = base.host;
+url.path = base.path.slice();
+url.query = base.query;
+} else if (char == '?') {
+url.host = base.host;
+url.path = base.path.slice();
+url.query = '';
+state = QUERY;
+} else if (char == '#') {
+url.host = base.host;
+url.path = base.path.slice();
+url.query = base.query;
+url.fragment = '';
+state = FRAGMENT;
+} else {
+if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
+url.host = base.host;
+url.path = base.path.slice();
+shortenURLsPath(url);
+}
+state = PATH;
+continue;
+}
+} else {
+state = PATH;
+continue;
+} break;
+case FILE_SLASH:
+if (char == '/' || char == '\\') {
+state = FILE_HOST;
+break;
+}
+if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
+if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]);
+else url.host = base.host;
+}
+state = PATH;
+continue;
+case FILE_HOST:
+if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') {
+if (!stateOverride && isWindowsDriveLetter(buffer)) {
+state = PATH;
+} else if (buffer == '') {
+url.host = '';
+if (stateOverride) return;
+state = PATH_START;
+} else {
+failure = parseHost(url, buffer);
+if (failure) return failure;
+if (url.host == 'localhost') url.host = '';
+if (stateOverride) return;
+buffer = '';
+state = PATH_START;
+} continue;
+} else buffer += char;
+break;
+case PATH_START:
+if (isSpecial(url)) {
+state = PATH;
+if (char != '/' && char != '\\') continue;
+} else if (!stateOverride && char == '?') {
+url.query = '';
+state = QUERY;
+} else if (!stateOverride && char == '#') {
+url.fragment = '';
+state = FRAGMENT;
+} else if (char != EOF) {
+state = PATH;
+if (char != '/') continue;
+} break;
+case PATH:
+if (
+char == EOF || char == '/' ||
+(char == '\\' && isSpecial(url)) ||
+(!stateOverride && (char == '?' || char == '#'))
+) {
+if (isDoubleDot(buffer)) {
+shortenURLsPath(url);
+if (char != '/' && !(char == '\\' && isSpecial(url))) {
+url.path.push('');
+}
+} else if (isSingleDot(buffer)) {
+if (char != '/' && !(char == '\\' && isSpecial(url))) {
+url.path.push('');
+}
+} else {
+if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
+if (url.host) url.host = '';
+buffer = buffer.charAt(0) + ':'; // normalize windows drive letter
+}
+url.path.push(buffer);
+}
+buffer = '';
+if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {
+while (url.path.length > 1 && url.path[0] === '') {
+url.path.shift();
+}
+}
+if (char == '?') {
+url.query = '';
+state = QUERY;
+} else if (char == '#') {
+url.fragment = '';
+state = FRAGMENT;
+}
+} else {
+buffer += percentEncode(char, pathPercentEncodeSet);
+} break;
+case CANNOT_BE_A_BASE_URL_PATH:
+if (char == '?') {
+url.query = '';
+state = QUERY;
+} else if (char == '#') {
+url.fragment = '';
+state = FRAGMENT;
+} else if (char != EOF) {
+url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);
+} break;
+case QUERY:
+if (!stateOverride && char == '#') {
+url.fragment = '';
+state = FRAGMENT;
+} else if (char != EOF) {
+if (char == "'" && isSpecial(url)) url.query += '%27';
+else if (char == '#') url.query += '%23';
+else url.query += percentEncode(char, C0ControlPercentEncodeSet);
+} break;
+case FRAGMENT:
+if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet);
+break;
+}
+pointer++;
+}
+};
+// `URL` constructor
+// https://url.spec.whatwg.org/#url-class
+var URLConstructor = function URL(url /* , base */) {
+var that = anInstance(this, URLConstructor, 'URL');
+var base = arguments.length > 1 ? arguments[1] : undefined;
+var urlString = String(url);
+var state = setInternalState(that, { type: 'URL' });
+var baseState, failure;
+if (base !== undefined) {
+if (base instanceof URLConstructor) baseState = getInternalURLState(base);
+else {
+failure = parseURL(baseState = {}, String(base));
+if (failure) throw TypeError(failure);
+}
+}
+failure = parseURL(state, urlString, null, baseState);
+if (failure) throw TypeError(failure);
+var searchParams = state.searchParams = new URLSearchParams();
+var searchParamsState = getInternalSearchParamsState(searchParams);
+searchParamsState.updateSearchParams(state.query);
+searchParamsState.updateURL = function () {
+state.query = String(searchParams) || null;
+};
+if (!DESCRIPTORS) {
+that.href = serializeURL.call(that);
+that.origin = getOrigin.call(that);
+that.protocol = getProtocol.call(that);
+that.username = getUsername.call(that);
+that.password = getPassword.call(that);
+that.host = getHost.call(that);
+that.hostname = getHostname.call(that);
+that.port = getPort.call(that);
+that.pathname = getPathname.call(that);
+that.search = getSearch.call(that);
+that.searchParams = getSearchParams.call(that);
+that.hash = getHash.call(that);
+}
+};
+var URLPrototype = URLConstructor.prototype;
+var serializeURL = function () {
+var url = getInternalURLState(this);
+var scheme = url.scheme;
+var username = url.username;
+var password = url.password;
+var host = url.host;
+var port = url.port;
+var path = url.path;
+var query = url.query;
+var fragment = url.fragment;
+var output = scheme + ':';
+if (host !== null) {
+output += '//';
+if (includesCredentials(url)) {
+output += username + (password ? ':' + password : '') + '@';
+}
+output += serializeHost(host);
+if (port !== null) output += ':' + port;
+} else if (scheme == 'file') output += '//';
+output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
+if (query !== null) output += '?' + query;
+if (fragment !== null) output += '#' + fragment;
+return output;
+};
+var getOrigin = function () {
+var url = getInternalURLState(this);
+var scheme = url.scheme;
+var port = url.port;
+if (scheme == 'blob') try {
+return new URL(scheme.path[0]).origin;
+} catch (error) {
+return 'null';
+}
+if (scheme == 'file' || !isSpecial(url)) return 'null';
+return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');
+};
+var getProtocol = function () {
+return getInternalURLState(this).scheme + ':';
+};
+var getUsername = function () {
+return getInternalURLState(this).username;
+};
+var getPassword = function () {
+return getInternalURLState(this).password;
+};
+var getHost = function () {
+var url = getInternalURLState(this);
+var host = url.host;
+var port = url.port;
+return host === null ? ''
+: port === null ? serializeHost(host)
+: serializeHost(host) + ':' + port;
+};
+var getHostname = function () {
+var host = getInternalURLState(this).host;
+return host === null ? '' : serializeHost(host);
+};
+var getPort = function () {
+var port = getInternalURLState(this).port;
+return port === null ? '' : String(port);
+};
+var getPathname = function () {
+var url = getInternalURLState(this);
+var path = url.path;
+return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
+};
+var getSearch = function () {
+var query = getInternalURLState(this).query;
+return query ? '?' + query : '';
+};
+var getSearchParams = function () {
+return getInternalURLState(this).searchParams;
+};
+var getHash = function () {
+var fragment = getInternalURLState(this).fragment;
+return fragment ? '#' + fragment : '';
+};
+var accessorDescriptor = function (getter, setter) {
+return { get: getter, set: setter, configurable: true, enumerable: true };
+};
+if (DESCRIPTORS) {
+defineProperties(URLPrototype, {
+// `URL.prototype.href` accessors pair
+// https://url.spec.whatwg.org/#dom-url-href
+href: accessorDescriptor(serializeURL, function (href) {
+var url = getInternalURLState(this);
+var urlString = String(href);
+var failure = parseURL(url, urlString);
+if (failure) throw TypeError(failure);
+getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
+}),
+// `URL.prototype.origin` getter
+// https://url.spec.whatwg.org/#dom-url-origin
+origin: accessorDescriptor(getOrigin),
+// `URL.prototype.protocol` accessors pair
+// https://url.spec.whatwg.org/#dom-url-protocol
+protocol: accessorDescriptor(getProtocol, function (protocol) {
+var url = getInternalURLState(this);
+parseURL(url, String(protocol) + ':', SCHEME_START);
+}),
+// `URL.prototype.username` accessors pair
+// https://url.spec.whatwg.org/#dom-url-username
+username: accessorDescriptor(getUsername, function (username) {
+var url = getInternalURLState(this);
+var codePoints = arrayFrom(String(username));
+if (cannotHaveUsernamePasswordPort(url)) return;
+url.username = '';
+for (var i = 0; i < codePoints.length; i++) {
+url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
+}
+}),
+// `URL.prototype.password` accessors pair
+// https://url.spec.whatwg.org/#dom-url-password
+password: accessorDescriptor(getPassword, function (password) {
+var url = getInternalURLState(this);
+var codePoints = arrayFrom(String(password));
+if (cannotHaveUsernamePasswordPort(url)) return;
+url.password = '';
+for (var i = 0; i < codePoints.length; i++) {
+url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
+}
+}),
+// `URL.prototype.host` accessors pair
+// https://url.spec.whatwg.org/#dom-url-host
+host: accessorDescriptor(getHost, function (host) {
+var url = getInternalURLState(this);
+if (url.cannotBeABaseURL) return;
+parseURL(url, String(host), HOST);
+}),
+// `URL.prototype.hostname` accessors pair
+// https://url.spec.whatwg.org/#dom-url-hostname
+hostname: accessorDescriptor(getHostname, function (hostname) {
+var url = getInternalURLState(this);
+if (url.cannotBeABaseURL) return;
+parseURL(url, String(hostname), HOSTNAME);
+}),
+// `URL.prototype.port` accessors pair
+// https://url.spec.whatwg.org/#dom-url-port
+port: accessorDescriptor(getPort, function (port) {
+var url = getInternalURLState(this);
+if (cannotHaveUsernamePasswordPort(url)) return;
+port = String(port);
+if (port == '') url.port = null;
+else parseURL(url, port, PORT);
+}),
+// `URL.prototype.pathname` accessors pair
+// https://url.spec.whatwg.org/#dom-url-pathname
+pathname: accessorDescriptor(getPathname, function (pathname) {
+var url = getInternalURLState(this);
+if (url.cannotBeABaseURL) return;
+url.path = [];
+parseURL(url, pathname + '', PATH_START);
+}),
+// `URL.prototype.search` accessors pair
+// https://url.spec.whatwg.org/#dom-url-search
+search: accessorDescriptor(getSearch, function (search) {
+var url = getInternalURLState(this);
+search = String(search);
+if (search == '') {
+url.query = null;
+} else {
+if ('?' == search.charAt(0)) search = search.slice(1);
+url.query = '';
+parseURL(url, search, QUERY);
+}
+getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
+}),
+// `URL.prototype.searchParams` getter
+// https://url.spec.whatwg.org/#dom-url-searchparams
+searchParams: accessorDescriptor(getSearchParams),
+// `URL.prototype.hash` accessors pair
+// https://url.spec.whatwg.org/#dom-url-hash
+hash: accessorDescriptor(getHash, function (hash) {
+var url = getInternalURLState(this);
+hash = String(hash);
+if (hash == '') {
+url.fragment = null;
+return;
+}
+if ('#' == hash.charAt(0)) hash = hash.slice(1);
+url.fragment = '';
+parseURL(url, hash, FRAGMENT);
+})
+});
+}
+// `URL.prototype.toJSON` method
+// https://url.spec.whatwg.org/#dom-url-tojson
+redefine(URLPrototype, 'toJSON', function toJSON() {
+return serializeURL.call(this);
+}, { enumerable: true });
+// `URL.prototype.toString` method
+// https://url.spec.whatwg.org/#URL-stringification-behavior
+redefine(URLPrototype, 'toString', function toString() {
+return serializeURL.call(this);
+}, { enumerable: true });
+if (NativeURL) {
+var nativeCreateObjectURL = NativeURL.createObjectURL;
+var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
+// `URL.createObjectURL` method
+// https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
+// eslint-disable-next-line no-unused-vars
+if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) {
+return nativeCreateObjectURL.apply(NativeURL, arguments);
+});
+// `URL.revokeObjectURL` method
+// https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL
+// eslint-disable-next-line no-unused-vars
+if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) {
+return nativeRevokeObjectURL.apply(NativeURL, arguments);
+});
+}
+setToStringTag(URLConstructor, 'URL');
+$({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {
+URL: URLConstructor
+});
+},{"../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){
+'use strict';
+var $ = require('../internals/export');
+// `URL.prototype.toJSON` method
+// https://url.spec.whatwg.org/#dom-url-tojson
+$({ target: 'URL', proto: true, enumerable: true }, {
+toJSON: function toJSON() {
+return URL.prototype.toString.call(this);
+}
+});
+},{"../internals/export":21}],83:[function(require,module,exports){
+require('../modules/web.url');
+require('../modules/web.url.to-json');
+require('../modules/web.url-search-params');
+var path = require('../internals/path');
+module.exports = path.URL;
+},{"../internals/path":57,"../modules/web.url":81,"../modules/web.url-search-params":80,"../modules/web.url.to-json":82}]},{},[83]);

enmi-conf.org