From bb14b5b1d5f6ba6935c0fdf8efd822e2e5f1bc14 Mon Sep 17 00:00:00 2001 From: ssl <414027602@qq.com> Date: Tue, 16 Dec 2025 10:29:23 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E7=A7=BB=E9=99=A4=20browserslist=20?= =?UTF-8?q?=E4=B8=AD=E7=9A=84=20not=20dead=20=E9=85=8D=E7=BD=AE=EF=BC=8C?= =?UTF-8?q?=E5=85=BC=E5=AE=B9=E6=97=A7=E7=89=88=20autoprefixer?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/json-schema-editor-vue.common.js | 4571 ++++++++++++++++++++++++- lib/json-schema-editor-vue.css | 2 +- lib/json-schema-editor-vue.umd.js | 4571 ++++++++++++++++++++++++- lib/json-schema-editor-vue.umd.min.js | 6 +- package.json | 3 +- 5 files changed, 8803 insertions(+), 350 deletions(-) diff --git a/lib/json-schema-editor-vue.common.js b/lib/json-schema-editor-vue.common.js index fb9a8b3..51747f1 100644 --- a/lib/json-schema-editor-vue.common.js +++ b/lib/json-schema-editor-vue.common.js @@ -221,6 +221,37 @@ exports.uvCounters = function() {}; exports.features = {}; +/***/ }), + +/***/ "0490": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isArray = __webpack_require__("d4f4"); +var isConstructor = __webpack_require__("5dc0"); +var isObject = __webpack_require__("09ef"); +var wellKnownSymbol = __webpack_require__("dabc"); + +var SPECIES = wellKnownSymbol('species'); +var $Array = Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array : C; +}; + + /***/ }), /***/ "060c": @@ -321,6 +352,85 @@ module.exports = function (it) { }; +/***/ }), + +/***/ "07d0": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var path = __webpack_require__("73e6"); +var hasOwn = __webpack_require__("45a0"); +var wrappedWellKnownSymbolModule = __webpack_require__("68a8"); +var defineProperty = __webpack_require__("390f").f; + +module.exports = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, { + value: wrappedWellKnownSymbolModule.f(NAME) + }); +}; + + +/***/ }), + +/***/ "08f4": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var getBuiltIn = __webpack_require__("c87d"); +var hasOwn = __webpack_require__("45a0"); +var toString = __webpack_require__("9dad"); +var shared = __webpack_require__("8700"); +var NATIVE_SYMBOL_REGISTRY = __webpack_require__("9213"); + +var StringToSymbolRegistry = shared('string-to-symbol-registry'); +var SymbolToStringRegistry = shared('symbol-to-string-registry'); + +// `Symbol.for` method +// https://tc39.es/ecma262/#sec-symbol.for +$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, { + 'for': function (key) { + var string = toString(key); + if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; + var symbol = getBuiltIn('Symbol')(string); + StringToSymbolRegistry[string] = symbol; + SymbolToStringRegistry[symbol] = string; + return symbol; + } +}); + + +/***/ }), + +/***/ "08fe": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__("78e6"); +var wellKnownSymbol = __webpack_require__("dabc"); +var V8_VERSION = __webpack_require__("219b"); + +var SPECIES = wellKnownSymbol('species'); + +module.exports = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION >= 51 || !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + + /***/ }), /***/ "09ef": @@ -375,6 +485,45 @@ module.exports = function (target, source, exceptions) { }; +/***/ }), + +/***/ "0c4e": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var charAt = __webpack_require__("a600").charAt; +var toString = __webpack_require__("9dad"); +var InternalStateModule = __webpack_require__("a262"); +var defineIterator = __webpack_require__("2b61"); +var createIterResultObject = __webpack_require__("3e25"); + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/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 createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject(point, false); +}); + + /***/ }), /***/ "0c59": @@ -424,6 +573,30 @@ function createFind(findIndexFunc) { module.exports = createFind; +/***/ }), + +/***/ "0e34": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__("dabc"); + +var MATCH = wellKnownSymbol('match'); + +module.exports = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; +}; + + /***/ }), /***/ "0f05": @@ -622,6 +795,22 @@ ClassList.prototype.contains = function(name){ }; +/***/ }), + +/***/ "0fb0": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var arraySpeciesConstructor = __webpack_require__("0490"); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + + /***/ }), /***/ "0fed": @@ -746,6 +935,120 @@ $({ global: true, constructor: true, forced: FORCED }, { module.exports = { "default": __webpack_require__("d34b"), __esModule: true }; +/***/ }), + +/***/ "10a1": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var globalThis = __webpack_require__("b7a1"); +var uncurryThis = __webpack_require__("d74d"); +var isForced = __webpack_require__("241f"); +var defineBuiltIn = __webpack_require__("78e5"); +var InternalMetadataModule = __webpack_require__("727d"); +var iterate = __webpack_require__("da56"); +var anInstance = __webpack_require__("f824"); +var isCallable = __webpack_require__("2985"); +var isNullOrUndefined = __webpack_require__("06c4"); +var isObject = __webpack_require__("09ef"); +var fails = __webpack_require__("78e6"); +var checkCorrectnessOfIteration = __webpack_require__("4d9b"); +var setToStringTag = __webpack_require__("49ff"); +var inheritIfRequired = __webpack_require__("6dd5"); + +module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = globalThis[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]); + defineBuiltIn(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + + /***/ }), /***/ "119a": @@ -834,6 +1137,110 @@ function mergeFn (a, b) { module.exports = { "default": __webpack_require__("d7ec"), __esModule: true }; +/***/ }), + +/***/ "12cc": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var toObject = __webpack_require__("9a80"); +var toAbsoluteIndex = __webpack_require__("c6dd"); +var toIntegerOrInfinity = __webpack_require__("6a2d"); +var lengthOfArrayLike = __webpack_require__("d3c2"); +var setArrayLength = __webpack_require__("a01e"); +var doesNotExceedSafeInteger = __webpack_require__("f1f1"); +var arraySpeciesCreate = __webpack_require__("0fb0"); +var createProperty = __webpack_require__("6f9d"); +var deletePropertyOrThrow = __webpack_require__("744c"); +var arrayMethodHasSpeciesSupport = __webpack_require__("08fe"); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('splice'); + +var max = Math.max; +var min = Math.min; + +// `Array.prototype.splice` method +// https://tc39.es/ecma262/#sec-array.prototype.splice +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + splice: function splice(start, deleteCount /* , ...items */) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var insertCount, actualDeleteCount, A, k, from, to; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart); + } + doesNotExceedSafeInteger(len + insertCount - actualDeleteCount); + A = arraySpeciesCreate(O, actualDeleteCount); + for (k = 0; k < actualDeleteCount; k++) { + from = actualStart + k; + if (from in O) createProperty(A, k, O[from]); + } + A.length = actualDeleteCount; + if (insertCount < actualDeleteCount) { + for (k = actualStart; k < len - actualDeleteCount; k++) { + from = k + actualDeleteCount; + to = k + insertCount; + if (from in O) O[to] = O[from]; + else deletePropertyOrThrow(O, to); + } + for (k = len; k > len - actualDeleteCount + insertCount; k--) deletePropertyOrThrow(O, k - 1); + } else if (insertCount > actualDeleteCount) { + for (k = len - actualDeleteCount; k > actualStart; k--) { + from = k + actualDeleteCount - 1; + to = k + insertCount - 1; + if (from in O) O[to] = O[from]; + else deletePropertyOrThrow(O, to); + } + } + for (k = 0; k < insertCount; k++) { + O[k + actualStart] = arguments[k + 2]; + } + setArrayLength(O, len - actualDeleteCount + insertCount); + return A; + } +}); + + +/***/ }), + +/***/ "13bf": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var uncurryThis = __webpack_require__("d74d"); +var notARegExp = __webpack_require__("d6a2"); +var requireObjectCoercible = __webpack_require__("fdab"); +var toString = __webpack_require__("9dad"); +var correctIsRegExpLogic = __webpack_require__("0e34"); + +var stringIndexOf = uncurryThis(''.indexOf); + +// `String.prototype.includes` method +// https://tc39.es/ecma262/#sec-string.prototype.includes +$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, { + includes: function includes(searchString /* , position = 0 */) { + return !!~stringIndexOf( + toString(requireObjectCoercible(this)), + toString(notARegExp(searchString)), + arguments.length > 1 ? arguments[1] : undefined + ); + } +}); + + /***/ }), /***/ "13cb": @@ -914,6 +1321,30 @@ $export.R = 128; // real proto method for `library` module.exports = $export; +/***/ }), + +/***/ "1512": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__("d74d"); + +var $Error = Error; +var replace = uncurryThis(''.replace); + +var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd'); +// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe +var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/; +var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST); + +module.exports = function (stack, dropEntries) { + if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) { + while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, ''); + } return stack; +}; + + /***/ }), /***/ "152a": @@ -1018,6 +1449,24 @@ module.exports = function (bitmap, value) { }; +/***/ }), + +/***/ "15be": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var assign = __webpack_require__("dfc8"); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + + /***/ }), /***/ "18d0": @@ -1061,6 +1510,20 @@ module.exports = function (name) { }; +/***/ }), + +/***/ "1a0f": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__("07d0"); + +// `Symbol.iterator` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.iterator +defineWellKnownSymbol('iterator'); + + /***/ }), /***/ "1b7a": @@ -1093,6 +1556,79 @@ module.exports = function (argument) { }; +/***/ }), + +/***/ "1cc1": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__("c87d"); +var hasOwn = __webpack_require__("45a0"); +var createNonEnumerableProperty = __webpack_require__("82d4"); +var isPrototypeOf = __webpack_require__("3be5"); +var setPrototypeOf = __webpack_require__("e746"); +var copyConstructorProperties = __webpack_require__("0abe"); +var proxyAccessor = __webpack_require__("92a3"); +var inheritIfRequired = __webpack_require__("6dd5"); +var normalizeStringArgument = __webpack_require__("6b6b"); +var installErrorCause = __webpack_require__("d6ff"); +var installErrorStack = __webpack_require__("28f3"); +var DESCRIPTORS = __webpack_require__("6d80"); +var IS_PURE = __webpack_require__("6149"); + +module.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) { + var STACK_TRACE_LIMIT = 'stackTraceLimit'; + var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1; + var path = FULL_NAME.split('.'); + var ERROR_NAME = path[path.length - 1]; + var OriginalError = getBuiltIn.apply(null, path); + + if (!OriginalError) return; + + var OriginalErrorPrototype = OriginalError.prototype; + + // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006 + if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause; + + if (!FORCED) return OriginalError; + + var BaseError = getBuiltIn('Error'); + + var WrappedError = wrapper(function (a, b) { + var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined); + var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError(); + if (message !== undefined) createNonEnumerableProperty(result, 'message', message); + installErrorStack(result, WrappedError, result.stack, 2); + if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError); + if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]); + return result; + }); + + WrappedError.prototype = OriginalErrorPrototype; + + if (ERROR_NAME !== 'Error') { + if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError); + else copyConstructorProperties(WrappedError, BaseError, { name: true }); + } else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) { + proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT); + proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace'); + } + + copyConstructorProperties(WrappedError, OriginalError); + + if (!IS_PURE) try { + // Safari 13- bug: WebAssembly errors does not have a proper `.name` + if (OriginalErrorPrototype.name !== ERROR_NAME) { + createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME); + } + OriginalErrorPrototype.constructor = WrappedError; + } catch (error) { /* empty */ } + + return WrappedError; +}; + + /***/ }), /***/ "1da5": @@ -5102,6 +5638,88 @@ module.exports = isForced; // extracted by mini-css-extract-plugin +/***/ }), + +/***/ "2578": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__("3b5c"); +var uncurryThis = __webpack_require__("d74d"); +var IndexedObject = __webpack_require__("a42f"); +var toObject = __webpack_require__("9a80"); +var lengthOfArrayLike = __webpack_require__("d3c2"); +var arraySpeciesCreate = __webpack_require__("0fb0"); + +var push = uncurryThis([].push); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var length = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +module.exports = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) +}; + + /***/ }), /***/ "2657": @@ -5195,6 +5813,72 @@ function baseSet(object, path, value, customizer) { module.exports = baseSet; +/***/ }), + +/***/ "28b9": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` since it's moved to entry points +__webpack_require__("c166"); +var $ = __webpack_require__("9ee3"); +var call = __webpack_require__("3e61"); +var isCallable = __webpack_require__("2985"); +var anObject = __webpack_require__("1c13"); +var toString = __webpack_require__("9dad"); + +var DELEGATES_TO_EXEC = function () { + var execCalled = false; + var re = /[ac]/; + re.exec = function () { + execCalled = true; + return /./.exec.apply(this, arguments); + }; + return re.test('abc') === true && execCalled; +}(); + +var nativeTest = /./.test; + +// `RegExp.prototype.test` method +// https://tc39.es/ecma262/#sec-regexp.prototype.test +$({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, { + test: function (S) { + var R = anObject(this); + var string = toString(S); + var exec = R.exec; + if (!isCallable(exec)) return call(nativeTest, R, string); + var result = call(exec, R, string); + if (result === null) return false; + anObject(result); + return true; + } +}); + + +/***/ }), + +/***/ "28f3": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createNonEnumerableProperty = __webpack_require__("82d4"); +var clearErrorStack = __webpack_require__("1512"); +var ERROR_STACK_INSTALLABLE = __webpack_require__("ea37"); + +// non-standard V8 +// eslint-disable-next-line es/no-nonstandard-error-properties -- safe +var captureStackTrace = Error.captureStackTrace; + +module.exports = function (error, C, stack, dropEntries) { + if (ERROR_STACK_INSTALLABLE) { + if (captureStackTrace) captureStackTrace(error, C); + else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries)); + } +}; + + /***/ }), /***/ "292a": @@ -5244,6 +5928,74 @@ module.exports = typeof documentAll == 'undefined' && documentAll !== undefined }; +/***/ }), + +/***/ "29c1": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// `Symbol.prototype.description` getter +// https://tc39.es/ecma262/#sec-symbol.prototype.description + +var $ = __webpack_require__("9ee3"); +var DESCRIPTORS = __webpack_require__("6d80"); +var globalThis = __webpack_require__("b7a1"); +var uncurryThis = __webpack_require__("d74d"); +var hasOwn = __webpack_require__("45a0"); +var isCallable = __webpack_require__("2985"); +var isPrototypeOf = __webpack_require__("3be5"); +var toString = __webpack_require__("9dad"); +var defineBuiltInAccessor = __webpack_require__("4edf"); +var copyConstructorProperties = __webpack_require__("0abe"); + +var NativeSymbol = globalThis.Symbol; +var SymbolPrototype = NativeSymbol && NativeSymbol.prototype; + +if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) || + // Safari 12 bug + NativeSymbol().description !== undefined +)) { + var EmptyStringDescriptionStore = {}; + // wrap Symbol constructor for correct work with undefined description + var SymbolWrapper = function Symbol() { + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]); + var result = isPrototypeOf(SymbolPrototype, this) + // eslint-disable-next-line sonarjs/inconsistent-function-call -- ok + ? new NativeSymbol(description) + // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' + : description === undefined ? NativeSymbol() : NativeSymbol(description); + if (description === '') EmptyStringDescriptionStore[result] = true; + return result; + }; + + copyConstructorProperties(SymbolWrapper, NativeSymbol); + SymbolWrapper.prototype = SymbolPrototype; + SymbolPrototype.constructor = SymbolWrapper; + + var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)'; + var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf); + var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString); + var regexp = /^Symbol\((.*)\)[^)]+$/; + var replace = uncurryThis(''.replace); + var stringSlice = uncurryThis(''.slice); + + defineBuiltInAccessor(SymbolPrototype, 'description', { + configurable: true, + get: function description() { + var symbol = thisSymbolValue(this); + if (hasOwn(EmptyStringDescriptionStore, symbol)) return ''; + var string = symbolDescriptiveString(symbol); + var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1'); + return desc === '' ? undefined : desc; + } + }); + + $({ global: true, constructor: true, forced: true }, { + Symbol: SymbolWrapper + }); +} + + /***/ }), /***/ "2a09": @@ -5486,6 +6238,116 @@ module.exports = function (obj) { }; +/***/ }), + +/***/ "2b61": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var call = __webpack_require__("3e61"); +var IS_PURE = __webpack_require__("6149"); +var FunctionName = __webpack_require__("017e"); +var isCallable = __webpack_require__("2985"); +var createIteratorConstructor = __webpack_require__("7877"); +var getPrototypeOf = __webpack_require__("b29a"); +var setPrototypeOf = __webpack_require__("e746"); +var setToStringTag = __webpack_require__("49ff"); +var createNonEnumerableProperty = __webpack_require__("82d4"); +var defineBuiltIn = __webpack_require__("78e5"); +var wellKnownSymbol = __webpack_require__("dabc"); +var Iterators = __webpack_require__("5e4e"); +var IteratorsCore = __webpack_require__("386f"); + +var PROPER_FUNCTION_NAME = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +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 && 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 (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) { + defineBuiltIn(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.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // 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)) { + defineBuiltIn(IterablePrototype, KEY, methods[KEY]); + } + } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT }); + } + Iterators[NAME] = defaultIterator; + + return methods; +}; + + /***/ }), /***/ "2bb2": @@ -5499,6 +6361,29 @@ module.exports = function (it) { }; +/***/ }), + +/***/ "2bc8": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var from = __webpack_require__("dc77"); +var checkCorrectnessOfIteration = __webpack_require__("4d9b"); + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.es/ecma262/#sec-array.from +$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from +}); + + /***/ }), /***/ "2bf4": @@ -5709,6 +6594,51 @@ module.exports = function (it) { }; +/***/ }), + +/***/ "3103": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__("09ef"); + +module.exports = function (argument) { + return isObject(argument) || argument === null; +}; + + +/***/ }), + +/***/ "3185": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__("b7a1"); +var DOMIterables = __webpack_require__("76fe"); +var DOMTokenListPrototype = __webpack_require__("831f"); +var forEach = __webpack_require__("e1fb"); +var createNonEnumerableProperty = __webpack_require__("82d4"); + +var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype); + } +} + +handlePrototype(DOMTokenListPrototype); + + /***/ }), /***/ "3282": @@ -5747,6 +6677,57 @@ exports.default = function (obj, key, value) { return obj; }; +/***/ }), + +/***/ "32ff": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__("d74d"); +var requireObjectCoercible = __webpack_require__("fdab"); +var toString = __webpack_require__("9dad"); +var whitespaces = __webpack_require__("3339"); + +var replace = uncurryThis(''.replace); +var ltrim = RegExp('^[' + whitespaces + ']+'); +var rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod = function (TYPE) { + return function ($this) { + var string = toString(requireObjectCoercible($this)); + if (TYPE & 1) string = replace(string, ltrim, ''); + if (TYPE & 2) string = replace(string, rtrim, '$1'); + return string; + }; +}; + +module.exports = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod(3) +}; + + +/***/ }), + +/***/ "3339": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// a string of all valid unicode whitespaces +module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + /***/ }), /***/ "33e0": @@ -6196,6 +7177,51 @@ module.exports = function (methodName, argument) { }; +/***/ }), + +/***/ "3b40": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__("b7a1"); +var DOMIterables = __webpack_require__("76fe"); +var DOMTokenListPrototype = __webpack_require__("831f"); +var ArrayIteratorMethods = __webpack_require__("3d22"); +var createNonEnumerableProperty = __webpack_require__("82d4"); +var setToStringTag = __webpack_require__("49ff"); +var wellKnownSymbol = __webpack_require__("dabc"); + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayValues = ArrayIteratorMethods.values; + +var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype, COLLECTION_NAME); +} + +handlePrototype(DOMTokenListPrototype, 'DOMTokenList'); + + /***/ }), /***/ "3b5c": @@ -6276,6 +7302,76 @@ function objectToString(value) { module.exports = objectToString; +/***/ }), + +/***/ "3d22": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__("a011"); +var addToUnscopables = __webpack_require__("fbe1"); +var Iterators = __webpack_require__("5e4e"); +var InternalStateModule = __webpack_require__("a262"); +var defineProperty = __webpack_require__("390f").f; +var defineIterator = __webpack_require__("2b61"); +var createIterResultObject = __webpack_require__("3e25"); +var IS_PURE = __webpack_require__("6149"); +var DESCRIPTORS = __webpack_require__("6d80"); + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/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.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = null; + return createIterResultObject(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject(index, false); + case 'values': return createIterResultObject(target[index], false); + } return createIterResultObject([index, target[index]], false); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +var values = Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +// V8 ~ Chrome 45- bug +if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try { + defineProperty(values, 'name', { value: 'values' }); +} catch (error) { /* empty */ } + + /***/ }), /***/ "3d38": @@ -6305,6 +7401,24 @@ module.exports = [ ]; +/***/ }), + +/***/ "3d6a": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isPossiblePrototype = __webpack_require__("3103"); + +var $String = String; +var $TypeError = TypeError; + +module.exports = function (argument) { + if (isPossiblePrototype(argument)) return argument; + throw new $TypeError("Can't set " + $String(argument) + ' as a prototype'); +}; + + /***/ }), /***/ "3d6c": @@ -7521,6 +8635,74 @@ module.exports = Object.hasOwn || function hasOwn(it, key) { }; +/***/ }), + +/***/ "4603": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable no-unused-vars -- required for functions `.length` */ +var $ = __webpack_require__("9ee3"); +var globalThis = __webpack_require__("b7a1"); +var apply = __webpack_require__("560c"); +var wrapErrorConstructorWithCause = __webpack_require__("1cc1"); + +var WEB_ASSEMBLY = 'WebAssembly'; +var WebAssembly = globalThis[WEB_ASSEMBLY]; + +// eslint-disable-next-line es/no-error-cause -- feature detection +var FORCED = new Error('e', { cause: 7 }).cause !== 7; + +var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) { + var O = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED); + $({ global: true, constructor: true, arity: 1, forced: FORCED }, O); +}; + +var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) { + if (WebAssembly && WebAssembly[ERROR_NAME]) { + var O = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED); + $({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O); + } +}; + +// https://tc39.es/ecma262/#sec-nativeerror +exportGlobalErrorCauseWrapper('Error', function (init) { + return function Error(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('EvalError', function (init) { + return function EvalError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('RangeError', function (init) { + return function RangeError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('ReferenceError', function (init) { + return function ReferenceError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('SyntaxError', function (init) { + return function SyntaxError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('TypeError', function (init) { + return function TypeError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('URIError', function (init) { + return function URIError(message) { return apply(init, this, arguments); }; +}); +exportWebAssemblyErrorCauseWrapper('CompileError', function (init) { + return function CompileError(message) { return apply(init, this, arguments); }; +}); +exportWebAssemblyErrorCauseWrapper('LinkError', function (init) { + return function LinkError(message) { return apply(init, this, arguments); }; +}); +exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) { + return function RuntimeError(message) { return apply(init, this, arguments); }; +}); + + /***/ }), /***/ "4660": @@ -7626,6 +8808,27 @@ module.exports = shouldUseNative() ? Object.assign : function (target, source) { }; +/***/ }), + +/***/ "49ff": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineProperty = __webpack_require__("390f").f; +var hasOwn = __webpack_require__("45a0"); +var wellKnownSymbol = __webpack_require__("dabc"); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +module.exports = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn(target, TO_STRING_TAG)) { + defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + + /***/ }), /***/ "4a17": @@ -7800,6 +9003,57 @@ QueryHandler.prototype = { module.exports = QueryHandler; +/***/ }), + +/***/ "4d9b": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__("dabc"); + +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +module.exports = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + + /***/ }), /***/ "4d9d": @@ -7842,6 +9096,29 @@ module.exports = assignValue; // extracted by mini-css-extract-plugin +/***/ }), + +/***/ "4ed3": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var toObject = __webpack_require__("9a80"); +var nativeKeys = __webpack_require__("dcea"); +var fails = __webpack_require__("78e6"); + +var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); }); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys(toObject(it)); + } +}); + + /***/ }), /***/ "4edf": @@ -8163,6 +9440,27 @@ module.exports = function (iterator, fn, value, entries) { }; +/***/ }), + +/***/ "5928": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__("09ef"); +var classof = __webpack_require__("3c5b"); +var wellKnownSymbol = __webpack_require__("dabc"); + +var MATCH = wellKnownSymbol('match'); + +// `IsRegExp` abstract operation +// https://tc39.es/ecma262/#sec-isregexp +module.exports = function (it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp'); +}; + + /***/ }), /***/ "593d": @@ -8385,6 +9683,25 @@ module.exports = function (exec, skipClosing) { }; +/***/ }), + +/***/ "5b6a": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__("78e6"); +var globalThis = __webpack_require__("b7a1"); + +// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError +var $RegExp = globalThis.RegExp; + +module.exports = fails(function () { + var re = $RegExp('.', 's'); + return !(re.dotAll && re.test('\n') && re.flags === 's'); +}); + + /***/ }), /***/ "5ba5": @@ -8453,6 +9770,66 @@ module.exports = function (IS_INCLUDES) { }; +/***/ }), + +/***/ "5dc0": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__("d74d"); +var fails = __webpack_require__("78e6"); +var isCallable = __webpack_require__("2985"); +var classof = __webpack_require__("f81e"); +var getBuiltIn = __webpack_require__("c87d"); +var inspectSource = __webpack_require__("774c"); + +var noop = function () { /* empty */ }; +var construct = getBuiltIn('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable(argument)) return false; + try { + construct(noop, [], argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable(argument)) return false; + switch (classof(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +module.exports = !construct || fails(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + + /***/ }), /***/ "5e03": @@ -8481,6 +9858,25 @@ module.exports = {}; module.exports = {}; +/***/ }), + +/***/ "6043": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it +var fails = __webpack_require__("78e6"); + +module.exports = fails(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } +}); + + /***/ }), /***/ "606c": @@ -8560,6 +9956,220 @@ module.exports = function (it, S) { // extracted by mini-css-extract-plugin +/***/ }), + +/***/ "62d3": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var create = __webpack_require__("5abc"); +var defineBuiltInAccessor = __webpack_require__("4edf"); +var defineBuiltIns = __webpack_require__("aee1"); +var bind = __webpack_require__("3b5c"); +var anInstance = __webpack_require__("f824"); +var isNullOrUndefined = __webpack_require__("06c4"); +var iterate = __webpack_require__("da56"); +var defineIterator = __webpack_require__("2b61"); +var createIterResultObject = __webpack_require__("3e25"); +var setSpecies = __webpack_require__("92c8"); +var DESCRIPTORS = __webpack_require__("6d80"); +var fastKey = __webpack_require__("727d").fastKey; +var InternalStateModule = __webpack_require__("a262"); + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; + +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: null, + last: null, + size: 0 + }); + if (!DESCRIPTORS) that.size = 0; + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: null, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key === key) return entry; + } + }; + + defineBuiltIns(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = null; + entry = entry.next; + } + state.first = state.last = null; + state.index = create(null); + if (DESCRIPTORS) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first === entry) state.first = next; + if (state.last === entry) state.last = prev; + if (DESCRIPTORS) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', { + configurable: true, + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: null + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = null; + return createIterResultObject(undefined, true); + } + // return step by kind + if (kind === 'keys') return createIterResultObject(entry.key, false); + if (kind === 'values') return createIterResultObject(entry.value, false); + return createIterResultObject([entry.key, entry.value], false); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } +}; + + /***/ }), /***/ "6362": @@ -8630,6 +10240,40 @@ module.exports = function (key) { }; +/***/ }), + +/***/ "64dd": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var PROPER_FUNCTION_NAME = __webpack_require__("017e").PROPER; +var defineBuiltIn = __webpack_require__("78e5"); +var anObject = __webpack_require__("1c13"); +var $toString = __webpack_require__("9dad"); +var fails = __webpack_require__("78e6"); +var getRegExpFlags = __webpack_require__("911c"); + +var TO_STRING = 'toString'; +var RegExpPrototype = RegExp.prototype; +var nativeToString = RegExpPrototype[TO_STRING]; + +var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; }); +// FF44- RegExp#toString has a wrong name +var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING; + +// `RegExp.prototype.toString` method +// https://tc39.es/ecma262/#sec-regexp.prototype.tostring +if (NOT_GENERIC || INCORRECT_NAME) { + defineBuiltIn(RegExpPrototype, TO_STRING, function toString() { + var R = anObject(this); + var pattern = $toString(R.source); + var flags = $toString(getRegExpFlags(R)); + return '/' + pattern + '/' + flags; + }, { unsafe: true }); +} + + /***/ }), /***/ "6535": @@ -8740,6 +10384,37 @@ module.exports = function (iterator, fn, value, ENTRIES) { }; +/***/ }), + +/***/ "68a8": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__("dabc"); + +exports.f = wellKnownSymbol; + + +/***/ }), + +/***/ "68d5": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var $values = __webpack_require__("cac1").values; + +// `Object.values` method +// https://tc39.es/ecma262/#sec-object.values +$({ target: 'Object', stat: true }, { + values: function values(O) { + return $values(O); + } +}); + + /***/ }), /***/ "6964": @@ -8823,6 +10498,20 @@ function identity(value) { module.exports = identity; +/***/ }), + +/***/ "6b6b": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toString = __webpack_require__("9dad"); + +module.exports = function (argument, $default) { + return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument); +}; + + /***/ }), /***/ "6cf6": @@ -9006,6 +10695,33 @@ module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { }; +/***/ }), + +/***/ "6dd5": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__("2985"); +var isObject = __webpack_require__("09ef"); +var setPrototypeOf = __webpack_require__("e746"); + +// makes subclassing work correct for wrapped built-ins +module.exports = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + + /***/ }), /***/ "6f9d": @@ -9073,6 +10789,105 @@ function getValue(object, key) { module.exports = getValue; +/***/ }), + +/***/ "727d": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var uncurryThis = __webpack_require__("d74d"); +var hiddenKeys = __webpack_require__("5e82"); +var isObject = __webpack_require__("09ef"); +var hasOwn = __webpack_require__("45a0"); +var defineProperty = __webpack_require__("390f").f; +var getOwnPropertyNamesModule = __webpack_require__("060c"); +var getOwnPropertyNamesExternalModule = __webpack_require__("d286"); +var isExtensible = __webpack_require__("da95"); +var uid = __webpack_require__("8ebd"); +var FREEZING = __webpack_require__("f173"); + +var REQUIRED = false; +var METADATA = uid('meta'); +var id = 0; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!hasOwn(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis([].splice); + var test = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = module.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + + /***/ }), /***/ "7307": @@ -9087,6 +10902,57 @@ module.exports = function (it) { }; +/***/ }), + +/***/ "73e6": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__("b7a1"); + +module.exports = globalThis; + + +/***/ }), + +/***/ "744c": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var tryToString = __webpack_require__("606c"); + +var $TypeError = TypeError; + +module.exports = function (O, P) { + if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O)); +}; + + +/***/ }), + +/***/ "7559": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var $map = __webpack_require__("2578").map; +var arrayMethodHasSpeciesSupport = __webpack_require__("08fe"); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map'); + +// `Array.prototype.map` method +// https://tc39.es/ecma262/#sec-array.prototype.map +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + /***/ }), /***/ "757f": @@ -9105,6 +10971,91 @@ var $exports = module.exports = function (name) { $exports.store = store; +/***/ }), + +/***/ "76e9": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__("9ee3"); +var fails = __webpack_require__("78e6"); +var toIndexedObject = __webpack_require__("a011"); +var nativeGetOwnPropertyDescriptor = __webpack_require__("998b").f; +var DESCRIPTORS = __webpack_require__("6d80"); + +var FORCED = !DESCRIPTORS || fails(function () { nativeGetOwnPropertyDescriptor(1); }); + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { + return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key); + } +}); + + +/***/ }), + +/***/ "76fe": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +module.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + + +/***/ }), + +/***/ "7724": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__("ac7d"); +var classof = __webpack_require__("f81e"); + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; + + /***/ }), /***/ "774c": @@ -9173,6 +11124,30 @@ module.exports = function (bitmap, value) { }; +/***/ }), + +/***/ "7877": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var IteratorPrototype = __webpack_require__("386f").IteratorPrototype; +var create = __webpack_require__("5abc"); +var createPropertyDescriptor = __webpack_require__("7865"); +var setToStringTag = __webpack_require__("49ff"); +var Iterators = __webpack_require__("5e4e"); + +var returnThis = function () { return this; }; + +module.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; +}; + + /***/ }), /***/ "78e5": @@ -9265,6 +11240,91 @@ var isArray = Array.isArray; module.exports = isArray; +/***/ }), + +/***/ "7da5": +/***/ (function(module, exports, __webpack_require__) { + +var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// addapted from the document.currentScript polyfill by Adam Miller +// MIT license +// source: https://github.com/amiller-gh/currentScript-polyfill + +// added support for Firefox https://bugzilla.mozilla.org/show_bug.cgi?id=1620505 + +(function (root, factory) { + if (true) { + !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), + __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else {} +}(typeof self !== 'undefined' ? self : this, function () { + function getCurrentScript () { + var descriptor = Object.getOwnPropertyDescriptor(document, 'currentScript') + // for chrome + if (!descriptor && 'currentScript' in document && document.currentScript) { + return document.currentScript + } + + // for other browsers with native support for currentScript + if (descriptor && descriptor.get !== getCurrentScript && document.currentScript) { + return document.currentScript + } + + // IE 8-10 support script readyState + // IE 11+ & Firefox support stack trace + try { + throw new Error(); + } + catch (err) { + // Find the second match for the "at" string to get file src url from stack. + var ieStackRegExp = /.*at [^(]*\((.*):(.+):(.+)\)$/ig, + ffStackRegExp = /@([^@]*):(\d+):(\d+)\s*$/ig, + stackDetails = ieStackRegExp.exec(err.stack) || ffStackRegExp.exec(err.stack), + scriptLocation = (stackDetails && stackDetails[1]) || false, + line = (stackDetails && stackDetails[2]) || false, + currentLocation = document.location.href.replace(document.location.hash, ''), + pageSource, + inlineScriptSourceRegExp, + inlineScriptSource, + scripts = document.getElementsByTagName('script'); // Live NodeList collection + + if (scriptLocation === currentLocation) { + pageSource = document.documentElement.outerHTML; + inlineScriptSourceRegExp = new RegExp('(?:[^\\n]+?\\n){0,' + (line - 2) + '}[^<]*