4936 lines
865 KiB
JavaScript
4936 lines
865 KiB
JavaScript
/**
|
||
* @licstart The following is the entire license notice for the
|
||
* JavaScript code in this page
|
||
*
|
||
* Copyright 2024 Mozilla Foundation
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*
|
||
* @licend The above is the entire license notice for the
|
||
* JavaScript code in this page
|
||
*/
|
||
|
||
/**
|
||
* pdfjsVersion = 5.6.205
|
||
* pdfjsBuild = ada343803
|
||
*/
|
||
/******/ var __webpack_modules__ = ({
|
||
|
||
/***/ 9306
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isCallable = __webpack_require__(4901);
|
||
var tryToString = __webpack_require__(6823);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
// `Assert: IsCallable(argument) is true`
|
||
module.exports = function (argument) {
|
||
if (isCallable(argument)) return argument;
|
||
throw new $TypeError(tryToString(argument) + ' is not a function');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6194
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var has = (__webpack_require__(2248).has);
|
||
|
||
// Perform ? RequireInternalSlot(M, [[MapData]])
|
||
module.exports = function (it) {
|
||
has(it);
|
||
return it;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3506
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isPossiblePrototype = __webpack_require__(3925);
|
||
|
||
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');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3463
|
||
(module) {
|
||
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (argument) {
|
||
if (typeof argument == 'string') return argument;
|
||
throw new $TypeError('Argument is not a string');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 679
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isPrototypeOf = __webpack_require__(1625);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (it, Prototype) {
|
||
if (isPrototypeOf(Prototype, it)) return it;
|
||
throw new $TypeError('Incorrect invocation');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3972
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isObject = __webpack_require__(34);
|
||
|
||
var $String = String;
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (argument) {
|
||
if (argument === undefined || isObject(argument)) return argument;
|
||
throw new $TypeError($String(argument) + ' is not an object or undefined');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8551
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isObject = __webpack_require__(34);
|
||
|
||
var $String = String;
|
||
var $TypeError = TypeError;
|
||
|
||
// `Assert: Type(argument) is Object`
|
||
module.exports = function (argument) {
|
||
if (isObject(argument)) return argument;
|
||
throw new $TypeError($String(argument) + ' is not an object');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4154
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var classof = __webpack_require__(6955);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
// Perform ? RequireInternalSlot(argument, [[TypedArrayName]])
|
||
// If argument.[[TypedArrayName]] is not "Uint8Array", throw a TypeError exception
|
||
module.exports = function (argument) {
|
||
if (classof(argument) === 'Uint8Array') return argument;
|
||
throw new $TypeError('Argument is not an Uint8Array');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7811
|
||
(module) {
|
||
|
||
|
||
// eslint-disable-next-line es/no-typed-arrays -- safe
|
||
module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7394
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var uncurryThisAccessor = __webpack_require__(6706);
|
||
var classof = __webpack_require__(2195);
|
||
|
||
var ArrayBuffer = globalThis.ArrayBuffer;
|
||
var TypeError = globalThis.TypeError;
|
||
|
||
// Includes
|
||
// - Perform ? RequireInternalSlot(O, [[ArrayBufferData]]).
|
||
// - If IsSharedArrayBuffer(O) is true, throw a TypeError exception.
|
||
module.exports = ArrayBuffer && uncurryThisAccessor(ArrayBuffer.prototype, 'byteLength', 'get') || function (O) {
|
||
if (classof(O) !== 'ArrayBuffer') throw new TypeError('ArrayBuffer expected');
|
||
return O.byteLength;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3238
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var NATIVE_ARRAY_BUFFER = __webpack_require__(7811);
|
||
var arrayBufferByteLength = __webpack_require__(7394);
|
||
|
||
var DataView = globalThis.DataView;
|
||
|
||
module.exports = function (O) {
|
||
if (!NATIVE_ARRAY_BUFFER || arrayBufferByteLength(O) !== 0) return false;
|
||
try {
|
||
// eslint-disable-next-line no-new -- thrower
|
||
new DataView(O);
|
||
return false;
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5169
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isDetached = __webpack_require__(3238);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (it) {
|
||
if (isDetached(it)) throw new $TypeError('ArrayBuffer is detached');
|
||
return it;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5636
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var uncurryThisAccessor = __webpack_require__(6706);
|
||
var toIndex = __webpack_require__(7696);
|
||
var notDetached = __webpack_require__(5169);
|
||
var arrayBufferByteLength = __webpack_require__(7394);
|
||
var detachTransferable = __webpack_require__(4483);
|
||
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(1548);
|
||
|
||
var structuredClone = globalThis.structuredClone;
|
||
var ArrayBuffer = globalThis.ArrayBuffer;
|
||
var DataView = globalThis.DataView;
|
||
var min = Math.min;
|
||
var ArrayBufferPrototype = ArrayBuffer.prototype;
|
||
var DataViewPrototype = DataView.prototype;
|
||
var slice = uncurryThis(ArrayBufferPrototype.slice);
|
||
var isResizable = uncurryThisAccessor(ArrayBufferPrototype, 'resizable', 'get');
|
||
var maxByteLength = uncurryThisAccessor(ArrayBufferPrototype, 'maxByteLength', 'get');
|
||
var getInt8 = uncurryThis(DataViewPrototype.getInt8);
|
||
var setInt8 = uncurryThis(DataViewPrototype.setInt8);
|
||
|
||
module.exports = (PROPER_STRUCTURED_CLONE_TRANSFER || detachTransferable) && function (arrayBuffer, newLength, preserveResizability) {
|
||
var byteLength = arrayBufferByteLength(arrayBuffer);
|
||
var newByteLength = newLength === undefined ? byteLength : toIndex(newLength);
|
||
var fixedLength = !isResizable || !isResizable(arrayBuffer);
|
||
var newBuffer;
|
||
notDetached(arrayBuffer);
|
||
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
||
arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
|
||
if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer;
|
||
}
|
||
if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) {
|
||
newBuffer = slice(arrayBuffer, 0, newByteLength);
|
||
} else {
|
||
var options = preserveResizability && !fixedLength && maxByteLength ? { maxByteLength: maxByteLength(arrayBuffer) } : undefined;
|
||
newBuffer = new ArrayBuffer(newByteLength, options);
|
||
var a = new DataView(arrayBuffer);
|
||
var b = new DataView(newBuffer);
|
||
var copyLength = min(newByteLength, byteLength);
|
||
for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i));
|
||
}
|
||
if (!PROPER_STRUCTURED_CLONE_TRANSFER) detachTransferable(arrayBuffer);
|
||
return newBuffer;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4644
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var NATIVE_ARRAY_BUFFER = __webpack_require__(7811);
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var globalThis = __webpack_require__(4576);
|
||
var isCallable = __webpack_require__(4901);
|
||
var isObject = __webpack_require__(34);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var classof = __webpack_require__(6955);
|
||
var tryToString = __webpack_require__(6823);
|
||
var createNonEnumerableProperty = __webpack_require__(6699);
|
||
var defineBuiltIn = __webpack_require__(6840);
|
||
var defineBuiltInAccessor = __webpack_require__(2106);
|
||
var isPrototypeOf = __webpack_require__(1625);
|
||
var getPrototypeOf = __webpack_require__(2787);
|
||
var setPrototypeOf = __webpack_require__(2967);
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
var uid = __webpack_require__(3392);
|
||
var InternalStateModule = __webpack_require__(1181);
|
||
|
||
var enforceInternalState = InternalStateModule.enforce;
|
||
var getInternalState = InternalStateModule.get;
|
||
var Int8Array = globalThis.Int8Array;
|
||
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
|
||
var Uint8ClampedArray = globalThis.Uint8ClampedArray;
|
||
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
|
||
var TypedArray = Int8Array && getPrototypeOf(Int8Array);
|
||
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
|
||
var ObjectPrototype = Object.prototype;
|
||
var TypeError = globalThis.TypeError;
|
||
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
|
||
var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';
|
||
// Fixing native typed arrays in Opera Presto crashes the browser, see #595
|
||
var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera';
|
||
var TYPED_ARRAY_TAG_REQUIRED = false;
|
||
var NAME, Constructor, Prototype;
|
||
|
||
var TypedArrayConstructorsList = {
|
||
Int8Array: 1,
|
||
Uint8Array: 1,
|
||
Uint8ClampedArray: 1,
|
||
Int16Array: 2,
|
||
Uint16Array: 2,
|
||
Int32Array: 4,
|
||
Uint32Array: 4,
|
||
Float32Array: 4,
|
||
Float64Array: 8
|
||
};
|
||
|
||
var BigIntArrayConstructorsList = {
|
||
BigInt64Array: 8,
|
||
BigUint64Array: 8
|
||
};
|
||
|
||
var isView = function isView(it) {
|
||
if (!isObject(it)) return false;
|
||
var klass = classof(it);
|
||
return klass === 'DataView'
|
||
|| hasOwn(TypedArrayConstructorsList, klass)
|
||
|| hasOwn(BigIntArrayConstructorsList, klass);
|
||
};
|
||
|
||
var getTypedArrayConstructor = function (it) {
|
||
var proto = getPrototypeOf(it);
|
||
if (!isObject(proto)) return;
|
||
var state = getInternalState(proto);
|
||
return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);
|
||
};
|
||
|
||
var isTypedArray = function (it) {
|
||
if (!isObject(it)) return false;
|
||
var klass = classof(it);
|
||
return hasOwn(TypedArrayConstructorsList, klass)
|
||
|| hasOwn(BigIntArrayConstructorsList, klass);
|
||
};
|
||
|
||
var aTypedArray = function (it) {
|
||
if (isTypedArray(it)) return it;
|
||
throw new TypeError('Target is not a typed array');
|
||
};
|
||
|
||
var aTypedArrayConstructor = function (C) {
|
||
if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
|
||
throw new TypeError(tryToString(C) + ' is not a typed array constructor');
|
||
};
|
||
|
||
var exportTypedArrayMethod = function (KEY, property, forced, options) {
|
||
if (!DESCRIPTORS) return;
|
||
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
|
||
var TypedArrayConstructor = globalThis[ARRAY];
|
||
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
|
||
delete TypedArrayConstructor.prototype[KEY];
|
||
} catch (error) {
|
||
// old WebKit bug - some methods are non-configurable
|
||
try {
|
||
TypedArrayConstructor.prototype[KEY] = property;
|
||
} catch (error2) { /* empty */ }
|
||
}
|
||
}
|
||
if (!TypedArrayPrototype[KEY] || forced) {
|
||
defineBuiltIn(TypedArrayPrototype, KEY, forced ? property
|
||
: NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
|
||
}
|
||
};
|
||
|
||
var exportTypedArrayStaticMethod = function (KEY, property, forced) {
|
||
var ARRAY, TypedArrayConstructor;
|
||
if (!DESCRIPTORS) return;
|
||
if (setPrototypeOf) {
|
||
if (forced) for (ARRAY in TypedArrayConstructorsList) {
|
||
TypedArrayConstructor = globalThis[ARRAY];
|
||
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
|
||
delete TypedArrayConstructor[KEY];
|
||
} catch (error) { /* empty */ }
|
||
}
|
||
if (!TypedArray[KEY] || forced) {
|
||
// V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
|
||
try {
|
||
return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
|
||
} catch (error) { /* empty */ }
|
||
} else return;
|
||
}
|
||
for (ARRAY in TypedArrayConstructorsList) {
|
||
TypedArrayConstructor = globalThis[ARRAY];
|
||
if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
|
||
defineBuiltIn(TypedArrayConstructor, KEY, property);
|
||
}
|
||
}
|
||
};
|
||
|
||
for (NAME in TypedArrayConstructorsList) {
|
||
Constructor = globalThis[NAME];
|
||
Prototype = Constructor && Constructor.prototype;
|
||
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
||
else NATIVE_ARRAY_BUFFER_VIEWS = false;
|
||
}
|
||
|
||
for (NAME in BigIntArrayConstructorsList) {
|
||
Constructor = globalThis[NAME];
|
||
Prototype = Constructor && Constructor.prototype;
|
||
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
||
}
|
||
|
||
// WebKit bug - typed arrays constructors prototype is Object.prototype
|
||
if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
|
||
// eslint-disable-next-line no-shadow -- safe
|
||
TypedArray = function TypedArray() {
|
||
throw new TypeError('Incorrect invocation');
|
||
};
|
||
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
||
if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray);
|
||
}
|
||
}
|
||
|
||
if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
|
||
TypedArrayPrototype = TypedArray.prototype;
|
||
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
||
if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype);
|
||
}
|
||
}
|
||
|
||
// WebKit bug - one more object in Uint8ClampedArray prototype chain
|
||
if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
|
||
setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
|
||
}
|
||
|
||
if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
|
||
TYPED_ARRAY_TAG_REQUIRED = true;
|
||
defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {
|
||
configurable: true,
|
||
get: function () {
|
||
return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
|
||
}
|
||
});
|
||
for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) {
|
||
createNonEnumerableProperty(globalThis[NAME], TYPED_ARRAY_TAG, NAME);
|
||
}
|
||
}
|
||
|
||
module.exports = {
|
||
NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
|
||
TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
|
||
aTypedArray: aTypedArray,
|
||
aTypedArrayConstructor: aTypedArrayConstructor,
|
||
exportTypedArrayMethod: exportTypedArrayMethod,
|
||
exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
|
||
getTypedArrayConstructor: getTypedArrayConstructor,
|
||
isView: isView,
|
||
isTypedArray: isTypedArray,
|
||
TypedArray: TypedArray,
|
||
TypedArrayPrototype: TypedArrayPrototype
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9617
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toIndexedObject = __webpack_require__(5397);
|
||
var toAbsoluteIndex = __webpack_require__(5610);
|
||
var lengthOfArrayLike = __webpack_require__(6198);
|
||
|
||
// `Array.prototype.{ indexOf, includes }` methods implementation
|
||
var createMethod = function (IS_INCLUDES) {
|
||
return function ($this, el, fromIndex) {
|
||
var O = toIndexedObject($this);
|
||
var length = lengthOfArrayLike(O);
|
||
if (length === 0) return !IS_INCLUDES && -1;
|
||
var index = toAbsoluteIndex(fromIndex, length);
|
||
var value;
|
||
// Array#includes uses SameValueZero equality algorithm
|
||
// eslint-disable-next-line no-self-compare -- NaN check
|
||
if (IS_INCLUDES && el !== el) while (length > index) {
|
||
value = O[index++];
|
||
// eslint-disable-next-line no-self-compare -- NaN check
|
||
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.es/ecma262/#sec-array.prototype.includes
|
||
includes: createMethod(true),
|
||
// `Array.prototype.indexOf` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.indexof
|
||
indexOf: createMethod(false)
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4527
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var isArray = __webpack_require__(4376);
|
||
|
||
var $TypeError = TypeError;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
|
||
// Safari < 13 does not throw an error in this case
|
||
var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
|
||
// makes no sense without proper strict mode support
|
||
if (this !== undefined) return true;
|
||
try {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
Object.defineProperty([], 'length', { writable: false }).length = 1;
|
||
} catch (error) {
|
||
return error instanceof TypeError;
|
||
}
|
||
}();
|
||
|
||
module.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
|
||
if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
|
||
throw new $TypeError('Cannot set read only .length');
|
||
} return O.length = length;
|
||
} : function (O, length) {
|
||
return O.length = length;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7680
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
module.exports = uncurryThis([].slice);
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2804
|
||
(module) {
|
||
|
||
|
||
var commonAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
||
var base64Alphabet = commonAlphabet + '+/';
|
||
var base64UrlAlphabet = commonAlphabet + '-_';
|
||
|
||
var inverse = function (characters) {
|
||
// TODO: use `Object.create(null)` in `core-js@4`
|
||
var result = {};
|
||
var index = 0;
|
||
for (; index < 64; index++) result[characters.charAt(index)] = index;
|
||
return result;
|
||
};
|
||
|
||
module.exports = {
|
||
i2c: base64Alphabet,
|
||
c2i: inverse(base64Alphabet),
|
||
i2cUrl: base64UrlAlphabet,
|
||
c2iUrl: inverse(base64UrlAlphabet)
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2195
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
var toString = uncurryThis({}.toString);
|
||
var stringSlice = uncurryThis(''.slice);
|
||
|
||
module.exports = function (it) {
|
||
return stringSlice(toString(it), 8, -1);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6955
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var TO_STRING_TAG_SUPPORT = __webpack_require__(2140);
|
||
var isCallable = __webpack_require__(4901);
|
||
var classofRaw = __webpack_require__(2195);
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
var $Object = Object;
|
||
|
||
// 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' && isCallable(O.callee) ? 'Arguments' : result;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7740
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var hasOwn = __webpack_require__(9297);
|
||
var ownKeys = __webpack_require__(5031);
|
||
var getOwnPropertyDescriptorModule = __webpack_require__(7347);
|
||
var definePropertyModule = __webpack_require__(4913);
|
||
|
||
module.exports = function (target, source, exceptions) {
|
||
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 (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
|
||
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2211
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var fails = __webpack_require__(9039);
|
||
|
||
module.exports = !fails(function () {
|
||
function F() { /* empty */ }
|
||
F.prototype.constructor = null;
|
||
// eslint-disable-next-line es/no-object-getprototypeof -- required for testing
|
||
return Object.getPrototypeOf(new F()) !== F.prototype;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6699
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var definePropertyModule = __webpack_require__(4913);
|
||
var createPropertyDescriptor = __webpack_require__(6980);
|
||
|
||
module.exports = DESCRIPTORS ? function (object, key, value) {
|
||
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
||
} : function (object, key, value) {
|
||
object[key] = value;
|
||
return object;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6980
|
||
(module) {
|
||
|
||
|
||
module.exports = function (bitmap, value) {
|
||
return {
|
||
enumerable: !(bitmap & 1),
|
||
configurable: !(bitmap & 2),
|
||
writable: !(bitmap & 4),
|
||
value: value
|
||
};
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4659
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var definePropertyModule = __webpack_require__(4913);
|
||
var createPropertyDescriptor = __webpack_require__(6980);
|
||
|
||
module.exports = function (object, key, value) {
|
||
if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
|
||
else object[key] = value;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2106
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var makeBuiltIn = __webpack_require__(283);
|
||
var defineProperty = __webpack_require__(4913);
|
||
|
||
module.exports = function (target, name, descriptor) {
|
||
if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
|
||
if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
|
||
return defineProperty.f(target, name, descriptor);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6840
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isCallable = __webpack_require__(4901);
|
||
var definePropertyModule = __webpack_require__(4913);
|
||
var makeBuiltIn = __webpack_require__(283);
|
||
var defineGlobalProperty = __webpack_require__(9433);
|
||
|
||
module.exports = function (O, key, value, options) {
|
||
if (!options) options = {};
|
||
var simple = options.enumerable;
|
||
var name = options.name !== undefined ? options.name : key;
|
||
if (isCallable(value)) makeBuiltIn(value, name, options);
|
||
if (options.global) {
|
||
if (simple) O[key] = value;
|
||
else defineGlobalProperty(key, value);
|
||
} else {
|
||
try {
|
||
if (!options.unsafe) delete O[key];
|
||
else if (O[key]) simple = true;
|
||
} catch (error) { /* empty */ }
|
||
if (simple) O[key] = value;
|
||
else definePropertyModule.f(O, key, {
|
||
value: value,
|
||
enumerable: false,
|
||
configurable: !options.nonConfigurable,
|
||
writable: !options.nonWritable
|
||
});
|
||
} return O;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9433
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var defineProperty = Object.defineProperty;
|
||
|
||
module.exports = function (key, value) {
|
||
try {
|
||
defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
|
||
} catch (error) {
|
||
globalThis[key] = value;
|
||
} return value;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3724
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var fails = __webpack_require__(9039);
|
||
|
||
// Detect IE8's incomplete defineProperty implementation
|
||
module.exports = !fails(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4483
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var getBuiltInNodeModule = __webpack_require__(9429);
|
||
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(1548);
|
||
|
||
var structuredClone = globalThis.structuredClone;
|
||
var $ArrayBuffer = globalThis.ArrayBuffer;
|
||
var $MessageChannel = globalThis.MessageChannel;
|
||
var detach = false;
|
||
var WorkerThreads, channel, buffer, $detach;
|
||
|
||
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
||
detach = function (transferable) {
|
||
structuredClone(transferable, { transfer: [transferable] });
|
||
};
|
||
} else if ($ArrayBuffer) try {
|
||
if (!$MessageChannel) {
|
||
WorkerThreads = getBuiltInNodeModule('worker_threads');
|
||
if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
|
||
}
|
||
|
||
if ($MessageChannel) {
|
||
channel = new $MessageChannel();
|
||
buffer = new $ArrayBuffer(2);
|
||
|
||
$detach = function (transferable) {
|
||
channel.port1.postMessage(null, [transferable]);
|
||
};
|
||
|
||
if (buffer.byteLength === 2) {
|
||
$detach(buffer);
|
||
if (buffer.byteLength === 0) detach = $detach;
|
||
}
|
||
}
|
||
} catch (error) { /* empty */ }
|
||
|
||
module.exports = detach;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4055
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var isObject = __webpack_require__(34);
|
||
|
||
var document = globalThis.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) : {};
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6837
|
||
(module) {
|
||
|
||
|
||
var $TypeError = TypeError;
|
||
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
|
||
|
||
module.exports = function (it) {
|
||
if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
|
||
return it;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8727
|
||
(module) {
|
||
|
||
|
||
// IE8- don't enum bug keys
|
||
module.exports = [
|
||
'constructor',
|
||
'hasOwnProperty',
|
||
'isPrototypeOf',
|
||
'propertyIsEnumerable',
|
||
'toLocaleString',
|
||
'toString',
|
||
'valueOf'
|
||
];
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6193
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var ENVIRONMENT = __webpack_require__(4215);
|
||
|
||
module.exports = ENVIRONMENT === 'NODE';
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2839
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
|
||
var navigator = globalThis.navigator;
|
||
var userAgent = navigator && navigator.userAgent;
|
||
|
||
module.exports = userAgent ? String(userAgent) : '';
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9519
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var userAgent = __webpack_require__(2839);
|
||
|
||
var process = globalThis.process;
|
||
var Deno = globalThis.Deno;
|
||
var versions = process && process.versions || Deno && Deno.version;
|
||
var v8 = versions && versions.v8;
|
||
var match, version;
|
||
|
||
if (v8) {
|
||
match = v8.split('.');
|
||
// in old Chrome, versions of V8 isn't V8 = Chrome / 10
|
||
// but their correct versions are not interesting for us
|
||
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
|
||
}
|
||
|
||
// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
|
||
// so check `userAgent` even if `.v8` exists, but 0
|
||
if (!version && userAgent) {
|
||
match = userAgent.match(/Edge\/(\d+)/);
|
||
if (!match || match[1] >= 74) {
|
||
match = userAgent.match(/Chrome\/(\d+)/);
|
||
if (match) version = +match[1];
|
||
}
|
||
}
|
||
|
||
module.exports = version;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4215
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
/* global Bun, Deno -- detection */
|
||
var globalThis = __webpack_require__(4576);
|
||
var userAgent = __webpack_require__(2839);
|
||
var classof = __webpack_require__(2195);
|
||
|
||
var userAgentStartsWith = function (string) {
|
||
return userAgent.slice(0, string.length) === string;
|
||
};
|
||
|
||
module.exports = (function () {
|
||
if (userAgentStartsWith('Bun/')) return 'BUN';
|
||
if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
|
||
if (userAgentStartsWith('Deno/')) return 'DENO';
|
||
if (userAgentStartsWith('Node.js/')) return 'NODE';
|
||
if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN';
|
||
if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO';
|
||
if (classof(globalThis.process) === 'process') return 'NODE';
|
||
if (globalThis.window && globalThis.document) return 'BROWSER';
|
||
return 'REST';
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6518
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var getOwnPropertyDescriptor = (__webpack_require__(7347).f);
|
||
var createNonEnumerableProperty = __webpack_require__(6699);
|
||
var defineBuiltIn = __webpack_require__(6840);
|
||
var defineGlobalProperty = __webpack_require__(9433);
|
||
var copyConstructorProperties = __webpack_require__(7740);
|
||
var isForced = __webpack_require__(2796);
|
||
|
||
/*
|
||
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.dontCallGetSet - prevent calling a getter on target
|
||
options.name - the .name of the function if it does not match the key
|
||
*/
|
||
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 = globalThis;
|
||
} else if (STATIC) {
|
||
target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
|
||
} else {
|
||
target = globalThis[TARGET] && globalThis[TARGET].prototype;
|
||
}
|
||
if (target) for (key in source) {
|
||
sourceProperty = source[key];
|
||
if (options.dontCallGetSet) {
|
||
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);
|
||
}
|
||
defineBuiltIn(target, key, sourceProperty, options);
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9039
|
||
(module) {
|
||
|
||
|
||
module.exports = function (exec) {
|
||
try {
|
||
return !!exec();
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8745
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var NATIVE_BIND = __webpack_require__(616);
|
||
|
||
var FunctionPrototype = Function.prototype;
|
||
var apply = FunctionPrototype.apply;
|
||
var call = FunctionPrototype.call;
|
||
|
||
// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
|
||
module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
|
||
return call.apply(apply, arguments);
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6080
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(7476);
|
||
var aCallable = __webpack_require__(9306);
|
||
var NATIVE_BIND = __webpack_require__(616);
|
||
|
||
var bind = uncurryThis(uncurryThis.bind);
|
||
|
||
// optional / simple context binding
|
||
module.exports = function (fn, that) {
|
||
aCallable(fn);
|
||
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
|
||
return fn.apply(that, arguments);
|
||
};
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 616
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var fails = __webpack_require__(9039);
|
||
|
||
module.exports = !fails(function () {
|
||
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
||
var test = (function () { /* empty */ }).bind();
|
||
// eslint-disable-next-line no-prototype-builtins -- safe
|
||
return typeof test != 'function' || test.hasOwnProperty('prototype');
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9565
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var NATIVE_BIND = __webpack_require__(616);
|
||
|
||
var call = Function.prototype.call;
|
||
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
||
module.exports = NATIVE_BIND ? call.bind(call) : function () {
|
||
return call.apply(call, arguments);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 350
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var hasOwn = __webpack_require__(9297);
|
||
|
||
var FunctionPrototype = Function.prototype;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
|
||
|
||
var EXISTS = hasOwn(FunctionPrototype, 'name');
|
||
// additional protection from minified / mangled / dropped function names
|
||
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
|
||
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
|
||
|
||
module.exports = {
|
||
EXISTS: EXISTS,
|
||
PROPER: PROPER,
|
||
CONFIGURABLE: CONFIGURABLE
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6706
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var aCallable = __webpack_require__(9306);
|
||
|
||
module.exports = function (object, key, method) {
|
||
try {
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
|
||
} catch (error) { /* empty */ }
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7476
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var classofRaw = __webpack_require__(2195);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
module.exports = function (fn) {
|
||
// Nashorn bug:
|
||
// https://github.com/zloirock/core-js/issues/1128
|
||
// https://github.com/zloirock/core-js/issues/1130
|
||
if (classofRaw(fn) === 'Function') return uncurryThis(fn);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9504
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var NATIVE_BIND = __webpack_require__(616);
|
||
|
||
var FunctionPrototype = Function.prototype;
|
||
var call = FunctionPrototype.call;
|
||
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
||
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
|
||
|
||
module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
|
||
return function () {
|
||
return call.apply(fn, arguments);
|
||
};
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 944
|
||
(module) {
|
||
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (options) {
|
||
var alphabet = options && options.alphabet;
|
||
if (alphabet === undefined || alphabet === 'base64' || alphabet === 'base64url') return alphabet || 'base64';
|
||
throw new $TypeError('Incorrect `alphabet` option');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9429
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var IS_NODE = __webpack_require__(6193);
|
||
|
||
module.exports = function (name) {
|
||
if (IS_NODE) {
|
||
try {
|
||
return globalThis.process.getBuiltinModule(name);
|
||
} catch (error) { /* empty */ }
|
||
try {
|
||
// eslint-disable-next-line no-new-func -- safe
|
||
return Function('return require("' + name + '")')();
|
||
} catch (error) { /* empty */ }
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7751
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var isCallable = __webpack_require__(4901);
|
||
|
||
var aFunction = function (argument) {
|
||
return isCallable(argument) ? argument : undefined;
|
||
};
|
||
|
||
module.exports = function (namespace, method) {
|
||
return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1767
|
||
(module) {
|
||
|
||
|
||
// `GetIteratorDirect(obj)` abstract operation
|
||
// https://tc39.es/ecma262/#sec-getiteratordirect
|
||
module.exports = function (obj) {
|
||
return {
|
||
iterator: obj,
|
||
next: obj.next,
|
||
done: false
|
||
};
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 851
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var classof = __webpack_require__(6955);
|
||
var getMethod = __webpack_require__(5966);
|
||
var isNullOrUndefined = __webpack_require__(4117);
|
||
var Iterators = __webpack_require__(6269);
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
|
||
var ITERATOR = wellKnownSymbol('iterator');
|
||
|
||
module.exports = function (it) {
|
||
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
|
||
|| getMethod(it, '@@iterator')
|
||
|| Iterators[classof(it)];
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 81
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var call = __webpack_require__(9565);
|
||
var aCallable = __webpack_require__(9306);
|
||
var anObject = __webpack_require__(8551);
|
||
var tryToString = __webpack_require__(6823);
|
||
var getIteratorMethod = __webpack_require__(851);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (argument, usingIterator) {
|
||
var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
|
||
if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
|
||
throw new $TypeError(tryToString(argument) + ' is not iterable');
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5966
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var aCallable = __webpack_require__(9306);
|
||
var isNullOrUndefined = __webpack_require__(4117);
|
||
|
||
// `GetMethod` abstract operation
|
||
// https://tc39.es/ecma262/#sec-getmethod
|
||
module.exports = function (V, P) {
|
||
var func = V[P];
|
||
return isNullOrUndefined(func) ? undefined : aCallable(func);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4576
|
||
(module) {
|
||
|
||
|
||
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 es/no-global-this -- safe
|
||
check(typeof globalThis == 'object' && globalThis) ||
|
||
check(typeof window == 'object' && window) ||
|
||
// eslint-disable-next-line no-restricted-globals -- safe
|
||
check(typeof self == 'object' && self) ||
|
||
check(typeof global == 'object' && global) ||
|
||
check(typeof this == 'object' && this) ||
|
||
// eslint-disable-next-line no-new-func -- fallback
|
||
(function () { return this; })() || Function('return this')();
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9297
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var toObject = __webpack_require__(8981);
|
||
|
||
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
|
||
|
||
// `HasOwnProperty` abstract operation
|
||
// https://tc39.es/ecma262/#sec-hasownproperty
|
||
// eslint-disable-next-line es/no-object-hasown -- safe
|
||
module.exports = Object.hasOwn || function hasOwn(it, key) {
|
||
return hasOwnProperty(toObject(it), key);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 421
|
||
(module) {
|
||
|
||
|
||
module.exports = {};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 397
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var getBuiltIn = __webpack_require__(7751);
|
||
|
||
module.exports = getBuiltIn('document', 'documentElement');
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5917
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var fails = __webpack_require__(9039);
|
||
var createElement = __webpack_require__(4055);
|
||
|
||
// Thanks to IE8 for its funny defineProperty
|
||
module.exports = !DESCRIPTORS && !fails(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty(createElement('div'), 'a', {
|
||
get: function () { return 7; }
|
||
}).a !== 7;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7055
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var fails = __webpack_require__(9039);
|
||
var classof = __webpack_require__(2195);
|
||
|
||
var $Object = Object;
|
||
var split = uncurryThis(''.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 -- safe
|
||
return !$Object('z').propertyIsEnumerable(0);
|
||
}) ? function (it) {
|
||
return classof(it) === 'String' ? split(it, '') : $Object(it);
|
||
} : $Object;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3706
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var isCallable = __webpack_require__(4901);
|
||
var store = __webpack_require__(7629);
|
||
|
||
var functionToString = uncurryThis(Function.toString);
|
||
|
||
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
|
||
if (!isCallable(store.inspectSource)) {
|
||
store.inspectSource = function (it) {
|
||
return functionToString(it);
|
||
};
|
||
}
|
||
|
||
module.exports = store.inspectSource;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1181
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var NATIVE_WEAK_MAP = __webpack_require__(8622);
|
||
var globalThis = __webpack_require__(4576);
|
||
var isObject = __webpack_require__(34);
|
||
var createNonEnumerableProperty = __webpack_require__(6699);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var shared = __webpack_require__(7629);
|
||
var sharedKey = __webpack_require__(6119);
|
||
var hiddenKeys = __webpack_require__(421);
|
||
|
||
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
||
var TypeError = globalThis.TypeError;
|
||
var WeakMap = globalThis.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 new TypeError('Incompatible receiver, ' + TYPE + ' required');
|
||
} return state;
|
||
};
|
||
};
|
||
|
||
if (NATIVE_WEAK_MAP || shared.state) {
|
||
var store = shared.state || (shared.state = new WeakMap());
|
||
/* eslint-disable no-self-assign -- prototype methods protection */
|
||
store.get = store.get;
|
||
store.has = store.has;
|
||
store.set = store.set;
|
||
/* eslint-enable no-self-assign -- prototype methods protection */
|
||
set = function (it, metadata) {
|
||
if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
||
metadata.facade = it;
|
||
store.set(it, metadata);
|
||
return metadata;
|
||
};
|
||
get = function (it) {
|
||
return store.get(it) || {};
|
||
};
|
||
has = function (it) {
|
||
return store.has(it);
|
||
};
|
||
} else {
|
||
var STATE = sharedKey('state');
|
||
hiddenKeys[STATE] = true;
|
||
set = function (it, metadata) {
|
||
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
||
metadata.facade = it;
|
||
createNonEnumerableProperty(it, STATE, metadata);
|
||
return metadata;
|
||
};
|
||
get = function (it) {
|
||
return hasOwn(it, STATE) ? it[STATE] : {};
|
||
};
|
||
has = function (it) {
|
||
return hasOwn(it, STATE);
|
||
};
|
||
}
|
||
|
||
module.exports = {
|
||
set: set,
|
||
get: get,
|
||
has: has,
|
||
enforce: enforce,
|
||
getterFor: getterFor
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4209
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
var Iterators = __webpack_require__(6269);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4376
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var classof = __webpack_require__(2195);
|
||
|
||
// `IsArray` abstract operation
|
||
// https://tc39.es/ecma262/#sec-isarray
|
||
// eslint-disable-next-line es/no-array-isarray -- safe
|
||
module.exports = Array.isArray || function isArray(argument) {
|
||
return classof(argument) === 'Array';
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1108
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var classof = __webpack_require__(6955);
|
||
|
||
module.exports = function (it) {
|
||
var klass = classof(it);
|
||
return klass === 'BigInt64Array' || klass === 'BigUint64Array';
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4901
|
||
(module) {
|
||
|
||
|
||
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
|
||
var documentAll = typeof document == 'object' && document.all;
|
||
|
||
// `IsCallable` abstract operation
|
||
// https://tc39.es/ecma262/#sec-iscallable
|
||
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
|
||
module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
|
||
return typeof argument == 'function' || argument === documentAll;
|
||
} : function (argument) {
|
||
return typeof argument == 'function';
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2796
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var fails = __webpack_require__(9039);
|
||
var isCallable = __webpack_require__(4901);
|
||
|
||
var replacement = /#|\.prototype\./;
|
||
|
||
var isForced = function (feature, detection) {
|
||
var value = data[normalize(feature)];
|
||
return value === POLYFILL ? true
|
||
: value === NATIVE ? false
|
||
: isCallable(detection) ? 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;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4117
|
||
(module) {
|
||
|
||
|
||
// we can't use just `it == null` since of `document.all` special case
|
||
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
|
||
module.exports = function (it) {
|
||
return it === null || it === undefined;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 34
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isCallable = __webpack_require__(4901);
|
||
|
||
module.exports = function (it) {
|
||
return typeof it == 'object' ? it !== null : isCallable(it);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3925
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isObject = __webpack_require__(34);
|
||
|
||
module.exports = function (argument) {
|
||
return isObject(argument) || argument === null;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6395
|
||
(module) {
|
||
|
||
|
||
module.exports = false;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5810
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isObject = __webpack_require__(34);
|
||
var getInternalState = (__webpack_require__(1181).get);
|
||
|
||
module.exports = function isRawJSON(O) {
|
||
if (!isObject(O)) return false;
|
||
var state = getInternalState(O);
|
||
return !!state && state.type === 'RawJSON';
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 757
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var getBuiltIn = __webpack_require__(7751);
|
||
var isCallable = __webpack_require__(4901);
|
||
var isPrototypeOf = __webpack_require__(1625);
|
||
var USE_SYMBOL_AS_UID = __webpack_require__(7040);
|
||
|
||
var $Object = Object;
|
||
|
||
module.exports = USE_SYMBOL_AS_UID ? function (it) {
|
||
return typeof it == 'symbol';
|
||
} : function (it) {
|
||
var $Symbol = getBuiltIn('Symbol');
|
||
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2652
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var bind = __webpack_require__(6080);
|
||
var call = __webpack_require__(9565);
|
||
var anObject = __webpack_require__(8551);
|
||
var tryToString = __webpack_require__(6823);
|
||
var isArrayIteratorMethod = __webpack_require__(4209);
|
||
var lengthOfArrayLike = __webpack_require__(6198);
|
||
var isPrototypeOf = __webpack_require__(1625);
|
||
var getIterator = __webpack_require__(81);
|
||
var getIteratorMethod = __webpack_require__(851);
|
||
var iteratorClose = __webpack_require__(9539);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
var Result = function (stopped, result) {
|
||
this.stopped = stopped;
|
||
this.result = result;
|
||
};
|
||
|
||
var ResultPrototype = Result.prototype;
|
||
|
||
module.exports = function (iterable, unboundFunction, options) {
|
||
var that = options && options.that;
|
||
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
|
||
var IS_RECORD = !!(options && options.IS_RECORD);
|
||
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
|
||
var INTERRUPTED = !!(options && options.INTERRUPTED);
|
||
var fn = bind(unboundFunction, that);
|
||
var iterator, iterFn, index, length, result, next, step;
|
||
|
||
var stop = function (condition) {
|
||
if (iterator) iteratorClose(iterator, 'normal');
|
||
return new Result(true, condition);
|
||
};
|
||
|
||
var callFn = function (value) {
|
||
if (AS_ENTRIES) {
|
||
anObject(value);
|
||
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
|
||
} return INTERRUPTED ? fn(value, stop) : fn(value);
|
||
};
|
||
|
||
if (IS_RECORD) {
|
||
iterator = iterable.iterator;
|
||
} else if (IS_ITERATOR) {
|
||
iterator = iterable;
|
||
} else {
|
||
iterFn = getIteratorMethod(iterable);
|
||
if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
|
||
// optimisation for array iterators
|
||
if (isArrayIteratorMethod(iterFn)) {
|
||
for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
|
||
result = callFn(iterable[index]);
|
||
if (result && isPrototypeOf(ResultPrototype, result)) return result;
|
||
} return new Result(false);
|
||
}
|
||
iterator = getIterator(iterable, iterFn);
|
||
}
|
||
|
||
next = IS_RECORD ? iterable.next : iterator.next;
|
||
while (!(step = call(next, iterator)).done) {
|
||
try {
|
||
result = callFn(step.value);
|
||
} catch (error) {
|
||
iteratorClose(iterator, 'throw', error);
|
||
}
|
||
if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
|
||
} return new Result(false);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9539
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var call = __webpack_require__(9565);
|
||
var anObject = __webpack_require__(8551);
|
||
var getMethod = __webpack_require__(5966);
|
||
|
||
module.exports = function (iterator, kind, value) {
|
||
var innerResult, innerError;
|
||
anObject(iterator);
|
||
try {
|
||
innerResult = getMethod(iterator, 'return');
|
||
if (!innerResult) {
|
||
if (kind === 'throw') throw value;
|
||
return value;
|
||
}
|
||
innerResult = call(innerResult, iterator);
|
||
} catch (error) {
|
||
innerError = true;
|
||
innerResult = error;
|
||
}
|
||
if (kind === 'throw') throw value;
|
||
if (innerError) throw innerResult;
|
||
anObject(innerResult);
|
||
return value;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4549
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
|
||
// https://github.com/tc39/ecma262/pull/3467
|
||
module.exports = function (METHOD_NAME, ExpectedError) {
|
||
var Iterator = globalThis.Iterator;
|
||
var IteratorPrototype = Iterator && Iterator.prototype;
|
||
var method = IteratorPrototype && IteratorPrototype[METHOD_NAME];
|
||
|
||
var CLOSED = false;
|
||
|
||
if (method) try {
|
||
method.call({
|
||
next: function () { return { done: true }; },
|
||
'return': function () { CLOSED = true; }
|
||
}, -1);
|
||
} catch (error) {
|
||
// https://bugs.webkit.org/show_bug.cgi?id=291195
|
||
if (!(error instanceof ExpectedError)) CLOSED = false;
|
||
}
|
||
|
||
if (!CLOSED) return method;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7657
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var fails = __webpack_require__(9039);
|
||
var isCallable = __webpack_require__(4901);
|
||
var isObject = __webpack_require__(34);
|
||
var create = __webpack_require__(2360);
|
||
var getPrototypeOf = __webpack_require__(2787);
|
||
var defineBuiltIn = __webpack_require__(6840);
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
var IS_PURE = __webpack_require__(6395);
|
||
|
||
var ITERATOR = wellKnownSymbol('iterator');
|
||
var BUGGY_SAFARI_ITERATORS = false;
|
||
|
||
// `%IteratorPrototype%` object
|
||
// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
|
||
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
|
||
|
||
/* eslint-disable es/no-array-prototype-keys -- safe */
|
||
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;
|
||
}
|
||
}
|
||
|
||
var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
|
||
var test = {};
|
||
// FF44- legacy iterators case
|
||
return IteratorPrototype[ITERATOR].call(test) !== test;
|
||
});
|
||
|
||
if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
|
||
else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
|
||
|
||
// `%IteratorPrototype%[@@iterator]()` method
|
||
// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
|
||
if (!isCallable(IteratorPrototype[ITERATOR])) {
|
||
defineBuiltIn(IteratorPrototype, ITERATOR, function () {
|
||
return this;
|
||
});
|
||
}
|
||
|
||
module.exports = {
|
||
IteratorPrototype: IteratorPrototype,
|
||
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6269
|
||
(module) {
|
||
|
||
|
||
module.exports = {};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6198
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toLength = __webpack_require__(8014);
|
||
|
||
// `LengthOfArrayLike` abstract operation
|
||
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
||
module.exports = function (obj) {
|
||
return toLength(obj.length);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 283
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var fails = __webpack_require__(9039);
|
||
var isCallable = __webpack_require__(4901);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(350).CONFIGURABLE);
|
||
var inspectSource = __webpack_require__(3706);
|
||
var InternalStateModule = __webpack_require__(1181);
|
||
|
||
var enforceInternalState = InternalStateModule.enforce;
|
||
var getInternalState = InternalStateModule.get;
|
||
var $String = String;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var defineProperty = Object.defineProperty;
|
||
var stringSlice = uncurryThis(''.slice);
|
||
var replace = uncurryThis(''.replace);
|
||
var join = uncurryThis([].join);
|
||
|
||
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
|
||
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
|
||
});
|
||
|
||
var TEMPLATE = String(String).split('String');
|
||
|
||
var makeBuiltIn = module.exports = function (value, name, options) {
|
||
if (stringSlice($String(name), 0, 7) === 'Symbol(') {
|
||
name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
|
||
}
|
||
if (options && options.getter) name = 'get ' + name;
|
||
if (options && options.setter) name = 'set ' + name;
|
||
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
|
||
if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
|
||
else value.name = name;
|
||
}
|
||
if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
|
||
defineProperty(value, 'length', { value: options.arity });
|
||
}
|
||
try {
|
||
if (options && hasOwn(options, 'constructor') && options.constructor) {
|
||
if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
|
||
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
|
||
} else if (value.prototype) value.prototype = undefined;
|
||
} catch (error) { /* empty */ }
|
||
var state = enforceInternalState(value);
|
||
if (!hasOwn(state, 'source')) {
|
||
state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
|
||
} return value;
|
||
};
|
||
|
||
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
|
||
// eslint-disable-next-line no-extend-native -- required
|
||
Function.prototype.toString = makeBuiltIn(function toString() {
|
||
return isCallable(this) && getInternalState(this).source || inspectSource(this);
|
||
}, 'toString');
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2248
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
// eslint-disable-next-line es/no-map -- safe
|
||
var MapPrototype = Map.prototype;
|
||
|
||
module.exports = {
|
||
// eslint-disable-next-line es/no-map -- safe
|
||
Map: Map,
|
||
set: uncurryThis(MapPrototype.set),
|
||
get: uncurryThis(MapPrototype.get),
|
||
has: uncurryThis(MapPrototype.has),
|
||
remove: uncurryThis(MapPrototype['delete']),
|
||
proto: MapPrototype
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 741
|
||
(module) {
|
||
|
||
|
||
var ceil = Math.ceil;
|
||
var floor = Math.floor;
|
||
|
||
// `Math.trunc` method
|
||
// https://tc39.es/ecma262/#sec-math.trunc
|
||
// eslint-disable-next-line es/no-math-trunc -- safe
|
||
module.exports = Math.trunc || function trunc(x) {
|
||
var n = +x;
|
||
return (n > 0 ? floor : ceil)(n);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7819
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
/* eslint-disable es/no-json -- safe */
|
||
var fails = __webpack_require__(9039);
|
||
|
||
module.exports = !fails(function () {
|
||
var unsafeInt = '9007199254740993';
|
||
// eslint-disable-next-line es/no-json-rawjson -- feature detection
|
||
var raw = JSON.rawJSON(unsafeInt);
|
||
// eslint-disable-next-line es/no-json-israwjson -- feature detection
|
||
return !JSON.isRawJSON(raw) || JSON.stringify(raw) !== unsafeInt;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2360
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
/* global ActiveXObject -- old IE, WSH */
|
||
var anObject = __webpack_require__(8551);
|
||
var definePropertiesModule = __webpack_require__(6801);
|
||
var enumBugKeys = __webpack_require__(8727);
|
||
var hiddenKeys = __webpack_require__(421);
|
||
var html = __webpack_require__(397);
|
||
var documentCreateElement = __webpack_require__(4055);
|
||
var sharedKey = __webpack_require__(6119);
|
||
|
||
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;
|
||
// eslint-disable-next-line no-useless-assignment -- avoid memory leak
|
||
activeXDocument = null;
|
||
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 {
|
||
activeXDocument = new ActiveXObject('htmlfile');
|
||
} catch (error) { /* ignore */ }
|
||
NullProtoObject = typeof document != 'undefined'
|
||
? document.domain && activeXDocument
|
||
? NullProtoObjectViaActiveX(activeXDocument) // old IE
|
||
: NullProtoObjectViaIFrame()
|
||
: NullProtoObjectViaActiveX(activeXDocument); // WSH
|
||
var length = enumBugKeys.length;
|
||
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
|
||
return NullProtoObject();
|
||
};
|
||
|
||
hiddenKeys[IE_PROTO] = true;
|
||
|
||
// `Object.create` method
|
||
// https://tc39.es/ecma262/#sec-object.create
|
||
// eslint-disable-next-line es/no-object-create -- safe
|
||
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 : definePropertiesModule.f(result, Properties);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6801
|
||
(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(8686);
|
||
var definePropertyModule = __webpack_require__(4913);
|
||
var anObject = __webpack_require__(8551);
|
||
var toIndexedObject = __webpack_require__(5397);
|
||
var objectKeys = __webpack_require__(1072);
|
||
|
||
// `Object.defineProperties` method
|
||
// https://tc39.es/ecma262/#sec-object.defineproperties
|
||
// eslint-disable-next-line es/no-object-defineproperties -- safe
|
||
exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
||
anObject(O);
|
||
var props = toIndexedObject(Properties);
|
||
var keys = objectKeys(Properties);
|
||
var length = keys.length;
|
||
var index = 0;
|
||
var key;
|
||
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
|
||
return O;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4913
|
||
(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var IE8_DOM_DEFINE = __webpack_require__(5917);
|
||
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(8686);
|
||
var anObject = __webpack_require__(8551);
|
||
var toPropertyKey = __webpack_require__(6969);
|
||
|
||
var $TypeError = TypeError;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var $defineProperty = Object.defineProperty;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
var ENUMERABLE = 'enumerable';
|
||
var CONFIGURABLE = 'configurable';
|
||
var WRITABLE = 'writable';
|
||
|
||
// `Object.defineProperty` method
|
||
// https://tc39.es/ecma262/#sec-object.defineproperty
|
||
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
|
||
anObject(O);
|
||
P = toPropertyKey(P);
|
||
anObject(Attributes);
|
||
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
||
var current = $getOwnPropertyDescriptor(O, P);
|
||
if (current && current[WRITABLE]) {
|
||
O[P] = Attributes.value;
|
||
Attributes = {
|
||
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
|
||
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
|
||
writable: false
|
||
};
|
||
}
|
||
} return $defineProperty(O, P, Attributes);
|
||
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
||
anObject(O);
|
||
P = toPropertyKey(P);
|
||
anObject(Attributes);
|
||
if (IE8_DOM_DEFINE) try {
|
||
return $defineProperty(O, P, Attributes);
|
||
} catch (error) { /* empty */ }
|
||
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
|
||
if ('value' in Attributes) O[P] = Attributes.value;
|
||
return O;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7347
|
||
(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var call = __webpack_require__(9565);
|
||
var propertyIsEnumerableModule = __webpack_require__(8773);
|
||
var createPropertyDescriptor = __webpack_require__(6980);
|
||
var toIndexedObject = __webpack_require__(5397);
|
||
var toPropertyKey = __webpack_require__(6969);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var IE8_DOM_DEFINE = __webpack_require__(5917);
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
|
||
// `Object.getOwnPropertyDescriptor` method
|
||
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
||
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
||
O = toIndexedObject(O);
|
||
P = toPropertyKey(P);
|
||
if (IE8_DOM_DEFINE) try {
|
||
return $getOwnPropertyDescriptor(O, P);
|
||
} catch (error) { /* empty */ }
|
||
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8480
|
||
(__unused_webpack_module, exports, __webpack_require__) {
|
||
|
||
|
||
var internalObjectKeys = __webpack_require__(1828);
|
||
var enumBugKeys = __webpack_require__(8727);
|
||
|
||
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
|
||
|
||
// `Object.getOwnPropertyNames` method
|
||
// https://tc39.es/ecma262/#sec-object.getownpropertynames
|
||
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
|
||
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
|
||
return internalObjectKeys(O, hiddenKeys);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3717
|
||
(__unused_webpack_module, exports) {
|
||
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
|
||
exports.f = Object.getOwnPropertySymbols;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2787
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var hasOwn = __webpack_require__(9297);
|
||
var isCallable = __webpack_require__(4901);
|
||
var toObject = __webpack_require__(8981);
|
||
var sharedKey = __webpack_require__(6119);
|
||
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(2211);
|
||
|
||
var IE_PROTO = sharedKey('IE_PROTO');
|
||
var $Object = Object;
|
||
var ObjectPrototype = $Object.prototype;
|
||
|
||
// `Object.getPrototypeOf` method
|
||
// https://tc39.es/ecma262/#sec-object.getprototypeof
|
||
// eslint-disable-next-line es/no-object-getprototypeof -- safe
|
||
module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
|
||
var object = toObject(O);
|
||
if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
|
||
var constructor = object.constructor;
|
||
if (isCallable(constructor) && object instanceof constructor) {
|
||
return constructor.prototype;
|
||
} return object instanceof $Object ? ObjectPrototype : null;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1625
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
module.exports = uncurryThis({}.isPrototypeOf);
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1828
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var toIndexedObject = __webpack_require__(5397);
|
||
var indexOf = (__webpack_require__(9617).indexOf);
|
||
var hiddenKeys = __webpack_require__(421);
|
||
|
||
var push = uncurryThis([].push);
|
||
|
||
module.exports = function (object, names) {
|
||
var O = toIndexedObject(object);
|
||
var i = 0;
|
||
var result = [];
|
||
var key;
|
||
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
|
||
// Don't enum bug & hidden keys
|
||
while (names.length > i) if (hasOwn(O, key = names[i++])) {
|
||
~indexOf(result, key) || push(result, key);
|
||
}
|
||
return result;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1072
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var internalObjectKeys = __webpack_require__(1828);
|
||
var enumBugKeys = __webpack_require__(8727);
|
||
|
||
// `Object.keys` method
|
||
// https://tc39.es/ecma262/#sec-object.keys
|
||
// eslint-disable-next-line es/no-object-keys -- safe
|
||
module.exports = Object.keys || function keys(O) {
|
||
return internalObjectKeys(O, enumBugKeys);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8773
|
||
(__unused_webpack_module, exports) {
|
||
|
||
|
||
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
|
||
// Nashorn ~ JDK8 bug
|
||
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
|
||
|
||
// `Object.prototype.propertyIsEnumerable` method implementation
|
||
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
|
||
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
||
var descriptor = getOwnPropertyDescriptor(this, V);
|
||
return !!descriptor && descriptor.enumerable;
|
||
} : $propertyIsEnumerable;
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2967
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
/* eslint-disable no-proto -- safe */
|
||
var uncurryThisAccessor = __webpack_require__(6706);
|
||
var isObject = __webpack_require__(34);
|
||
var requireObjectCoercible = __webpack_require__(7750);
|
||
var aPossiblePrototype = __webpack_require__(3506);
|
||
|
||
// `Object.setPrototypeOf` method
|
||
// https://tc39.es/ecma262/#sec-object.setprototypeof
|
||
// Works with __proto__ only. Old v8 can't work with null proto objects.
|
||
// eslint-disable-next-line es/no-object-setprototypeof -- safe
|
||
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
|
||
var CORRECT_SETTER = false;
|
||
var test = {};
|
||
var setter;
|
||
try {
|
||
setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
|
||
setter(test, []);
|
||
CORRECT_SETTER = test instanceof Array;
|
||
} catch (error) { /* empty */ }
|
||
return function setPrototypeOf(O, proto) {
|
||
requireObjectCoercible(O);
|
||
aPossiblePrototype(proto);
|
||
if (!isObject(O)) return O;
|
||
if (CORRECT_SETTER) setter(O, proto);
|
||
else O.__proto__ = proto;
|
||
return O;
|
||
};
|
||
}() : undefined);
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4270
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var call = __webpack_require__(9565);
|
||
var isCallable = __webpack_require__(4901);
|
||
var isObject = __webpack_require__(34);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
// `OrdinaryToPrimitive` abstract operation
|
||
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
|
||
module.exports = function (input, pref) {
|
||
var fn, val;
|
||
if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
||
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
|
||
if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
||
throw new $TypeError("Can't convert object to primitive value");
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5031
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var getBuiltIn = __webpack_require__(7751);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var getOwnPropertyNamesModule = __webpack_require__(8480);
|
||
var getOwnPropertySymbolsModule = __webpack_require__(3717);
|
||
var anObject = __webpack_require__(8551);
|
||
|
||
var concat = uncurryThis([].concat);
|
||
|
||
// 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 ? concat(keys, getOwnPropertySymbols(it)) : keys;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8235
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var hasOwn = __webpack_require__(9297);
|
||
|
||
var $SyntaxError = SyntaxError;
|
||
var $parseInt = parseInt;
|
||
var fromCharCode = String.fromCharCode;
|
||
var at = uncurryThis(''.charAt);
|
||
var slice = uncurryThis(''.slice);
|
||
var exec = uncurryThis(/./.exec);
|
||
|
||
var codePoints = {
|
||
'\\"': '"',
|
||
'\\\\': '\\',
|
||
'\\/': '/',
|
||
'\\b': '\b',
|
||
'\\f': '\f',
|
||
'\\n': '\n',
|
||
'\\r': '\r',
|
||
'\\t': '\t'
|
||
};
|
||
|
||
var IS_4_HEX_DIGITS = /^[\da-f]{4}$/i;
|
||
// eslint-disable-next-line regexp/no-control-character -- safe
|
||
var IS_C0_CONTROL_CODE = /^[\u0000-\u001F]$/;
|
||
|
||
module.exports = function (source, i) {
|
||
var unterminated = true;
|
||
var value = '';
|
||
while (i < source.length) {
|
||
var chr = at(source, i);
|
||
if (chr === '\\') {
|
||
var twoChars = slice(source, i, i + 2);
|
||
if (hasOwn(codePoints, twoChars)) {
|
||
value += codePoints[twoChars];
|
||
i += 2;
|
||
} else if (twoChars === '\\u') {
|
||
i += 2;
|
||
var fourHexDigits = slice(source, i, i + 4);
|
||
if (!exec(IS_4_HEX_DIGITS, fourHexDigits)) throw new $SyntaxError('Bad Unicode escape at: ' + i);
|
||
value += fromCharCode($parseInt(fourHexDigits, 16));
|
||
i += 4;
|
||
} else throw new $SyntaxError('Unknown escape sequence: "' + twoChars + '"');
|
||
} else if (chr === '"') {
|
||
unterminated = false;
|
||
i++;
|
||
break;
|
||
} else {
|
||
if (exec(IS_C0_CONTROL_CODE, chr)) throw new $SyntaxError('Bad control character in string literal at: ' + i);
|
||
value += chr;
|
||
i++;
|
||
}
|
||
}
|
||
if (unterminated) throw new $SyntaxError('Unterminated string at: ' + i);
|
||
return { value: value, end: i };
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7750
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var isNullOrUndefined = __webpack_require__(4117);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
// `RequireObjectCoercible` abstract operation
|
||
// https://tc39.es/ecma262/#sec-requireobjectcoercible
|
||
module.exports = function (it) {
|
||
if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
|
||
return it;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6119
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var shared = __webpack_require__(5745);
|
||
var uid = __webpack_require__(3392);
|
||
|
||
var keys = shared('keys');
|
||
|
||
module.exports = function (key) {
|
||
return keys[key] || (keys[key] = uid(key));
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7629
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var IS_PURE = __webpack_require__(6395);
|
||
var globalThis = __webpack_require__(4576);
|
||
var defineGlobalProperty = __webpack_require__(9433);
|
||
|
||
var SHARED = '__core-js_shared__';
|
||
var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
|
||
|
||
(store.versions || (store.versions = [])).push({
|
||
version: '3.48.0',
|
||
mode: IS_PURE ? 'pure' : 'global',
|
||
copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.',
|
||
license: 'https://github.com/zloirock/core-js/blob/v3.48.0/LICENSE',
|
||
source: 'https://github.com/zloirock/core-js'
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5745
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var store = __webpack_require__(7629);
|
||
|
||
module.exports = function (key, value) {
|
||
return store[key] || (store[key] = value || {});
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1548
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var fails = __webpack_require__(9039);
|
||
var V8 = __webpack_require__(9519);
|
||
var ENVIRONMENT = __webpack_require__(4215);
|
||
|
||
var structuredClone = globalThis.structuredClone;
|
||
|
||
module.exports = !!structuredClone && !fails(function () {
|
||
// prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation
|
||
// https://github.com/zloirock/core-js/issues/679
|
||
if ((ENVIRONMENT === 'DENO' && V8 > 92) || (ENVIRONMENT === 'NODE' && V8 > 94) || (ENVIRONMENT === 'BROWSER' && V8 > 97)) return false;
|
||
var buffer = new ArrayBuffer(8);
|
||
var clone = structuredClone(buffer, { transfer: [buffer] });
|
||
return buffer.byteLength !== 0 || clone.byteLength !== 8;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4495
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
/* eslint-disable es/no-symbol -- required for testing */
|
||
var V8_VERSION = __webpack_require__(9519);
|
||
var fails = __webpack_require__(9039);
|
||
var globalThis = __webpack_require__(4576);
|
||
|
||
var $String = globalThis.String;
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
|
||
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
|
||
var symbol = Symbol('symbol detection');
|
||
// Chrome 38 Symbol has incorrect toString conversion
|
||
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
|
||
// nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
|
||
// of course, fail.
|
||
return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
|
||
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
||
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5610
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toIntegerOrInfinity = __webpack_require__(1291);
|
||
|
||
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 = toIntegerOrInfinity(index);
|
||
return integer < 0 ? max(integer + length, 0) : min(integer, length);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5854
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toPrimitive = __webpack_require__(2777);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
// `ToBigInt` abstract operation
|
||
// https://tc39.es/ecma262/#sec-tobigint
|
||
module.exports = function (argument) {
|
||
var prim = toPrimitive(argument, 'number');
|
||
if (typeof prim == 'number') throw new $TypeError("Can't convert number to bigint");
|
||
// eslint-disable-next-line es/no-bigint -- safe
|
||
return BigInt(prim);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7696
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toIntegerOrInfinity = __webpack_require__(1291);
|
||
var toLength = __webpack_require__(8014);
|
||
|
||
var $RangeError = RangeError;
|
||
|
||
// `ToIndex` abstract operation
|
||
// https://tc39.es/ecma262/#sec-toindex
|
||
module.exports = function (it) {
|
||
if (it === undefined) return 0;
|
||
var number = toIntegerOrInfinity(it);
|
||
var length = toLength(number);
|
||
if (number !== length) throw new $RangeError('Wrong length or index');
|
||
return length;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5397
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
// toObject with fallback for non-array-like ES3 strings
|
||
var IndexedObject = __webpack_require__(7055);
|
||
var requireObjectCoercible = __webpack_require__(7750);
|
||
|
||
module.exports = function (it) {
|
||
return IndexedObject(requireObjectCoercible(it));
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1291
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var trunc = __webpack_require__(741);
|
||
|
||
// `ToIntegerOrInfinity` abstract operation
|
||
// https://tc39.es/ecma262/#sec-tointegerorinfinity
|
||
module.exports = function (argument) {
|
||
var number = +argument;
|
||
// eslint-disable-next-line no-self-compare -- NaN check
|
||
return number !== number || number === 0 ? 0 : trunc(number);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8014
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toIntegerOrInfinity = __webpack_require__(1291);
|
||
|
||
var min = Math.min;
|
||
|
||
// `ToLength` abstract operation
|
||
// https://tc39.es/ecma262/#sec-tolength
|
||
module.exports = function (argument) {
|
||
var len = toIntegerOrInfinity(argument);
|
||
return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8981
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var requireObjectCoercible = __webpack_require__(7750);
|
||
|
||
var $Object = Object;
|
||
|
||
// `ToObject` abstract operation
|
||
// https://tc39.es/ecma262/#sec-toobject
|
||
module.exports = function (argument) {
|
||
return $Object(requireObjectCoercible(argument));
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2777
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var call = __webpack_require__(9565);
|
||
var isObject = __webpack_require__(34);
|
||
var isSymbol = __webpack_require__(757);
|
||
var getMethod = __webpack_require__(5966);
|
||
var ordinaryToPrimitive = __webpack_require__(4270);
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
|
||
var $TypeError = TypeError;
|
||
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
|
||
|
||
// `ToPrimitive` abstract operation
|
||
// https://tc39.es/ecma262/#sec-toprimitive
|
||
module.exports = function (input, pref) {
|
||
if (!isObject(input) || isSymbol(input)) return input;
|
||
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
|
||
var result;
|
||
if (exoticToPrim) {
|
||
if (pref === undefined) pref = 'default';
|
||
result = call(exoticToPrim, input, pref);
|
||
if (!isObject(result) || isSymbol(result)) return result;
|
||
throw new $TypeError("Can't convert object to primitive value");
|
||
}
|
||
if (pref === undefined) pref = 'number';
|
||
return ordinaryToPrimitive(input, pref);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6969
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var toPrimitive = __webpack_require__(2777);
|
||
var isSymbol = __webpack_require__(757);
|
||
|
||
// `ToPropertyKey` abstract operation
|
||
// https://tc39.es/ecma262/#sec-topropertykey
|
||
module.exports = function (argument) {
|
||
var key = toPrimitive(argument, 'string');
|
||
return isSymbol(key) ? key : key + '';
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2140
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
var test = {};
|
||
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
|
||
test[TO_STRING_TAG] = 'z';
|
||
|
||
module.exports = String(test) === '[object z]';
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 655
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var classof = __webpack_require__(6955);
|
||
|
||
var $String = String;
|
||
|
||
module.exports = function (argument) {
|
||
if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
|
||
return $String(argument);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6823
|
||
(module) {
|
||
|
||
|
||
var $String = String;
|
||
|
||
module.exports = function (argument) {
|
||
try {
|
||
return $String(argument);
|
||
} catch (error) {
|
||
return 'Object';
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3392
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
var id = 0;
|
||
var postfix = Math.random();
|
||
var toString = uncurryThis(1.1.toString);
|
||
|
||
module.exports = function (key) {
|
||
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9143
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var anObjectOrUndefined = __webpack_require__(3972);
|
||
var aString = __webpack_require__(3463);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var base64Map = __webpack_require__(2804);
|
||
var getAlphabetOption = __webpack_require__(944);
|
||
var notDetached = __webpack_require__(5169);
|
||
|
||
var base64Alphabet = base64Map.c2i;
|
||
var base64UrlAlphabet = base64Map.c2iUrl;
|
||
|
||
var SyntaxError = globalThis.SyntaxError;
|
||
var TypeError = globalThis.TypeError;
|
||
var at = uncurryThis(''.charAt);
|
||
|
||
var skipAsciiWhitespace = function (string, index) {
|
||
var length = string.length;
|
||
for (;index < length; index++) {
|
||
var chr = at(string, index);
|
||
if (chr !== ' ' && chr !== '\t' && chr !== '\n' && chr !== '\f' && chr !== '\r') break;
|
||
} return index;
|
||
};
|
||
|
||
var decodeBase64Chunk = function (chunk, alphabet, throwOnExtraBits) {
|
||
var chunkLength = chunk.length;
|
||
|
||
if (chunkLength < 4) {
|
||
chunk += chunkLength === 2 ? 'AA' : 'A';
|
||
}
|
||
|
||
var triplet = (alphabet[at(chunk, 0)] << 18)
|
||
+ (alphabet[at(chunk, 1)] << 12)
|
||
+ (alphabet[at(chunk, 2)] << 6)
|
||
+ alphabet[at(chunk, 3)];
|
||
|
||
var chunkBytes = [
|
||
(triplet >> 16) & 255,
|
||
(triplet >> 8) & 255,
|
||
triplet & 255
|
||
];
|
||
|
||
if (chunkLength === 2) {
|
||
if (throwOnExtraBits && chunkBytes[1] !== 0) {
|
||
throw new SyntaxError('Extra bits');
|
||
}
|
||
return [chunkBytes[0]];
|
||
}
|
||
|
||
if (chunkLength === 3) {
|
||
if (throwOnExtraBits && chunkBytes[2] !== 0) {
|
||
throw new SyntaxError('Extra bits');
|
||
}
|
||
return [chunkBytes[0], chunkBytes[1]];
|
||
}
|
||
|
||
return chunkBytes;
|
||
};
|
||
|
||
var writeBytes = function (bytes, elements, written) {
|
||
var elementsLength = elements.length;
|
||
for (var index = 0; index < elementsLength; index++) {
|
||
bytes[written + index] = elements[index];
|
||
}
|
||
return written + elementsLength;
|
||
};
|
||
|
||
/* eslint-disable max-statements, max-depth -- TODO */
|
||
module.exports = function (string, options, into, maxLength) {
|
||
aString(string);
|
||
anObjectOrUndefined(options);
|
||
var alphabet = getAlphabetOption(options) === 'base64' ? base64Alphabet : base64UrlAlphabet;
|
||
var lastChunkHandling = options ? options.lastChunkHandling : undefined;
|
||
|
||
if (lastChunkHandling === undefined) lastChunkHandling = 'loose';
|
||
|
||
if (lastChunkHandling !== 'loose' && lastChunkHandling !== 'strict' && lastChunkHandling !== 'stop-before-partial') {
|
||
throw new TypeError('Incorrect `lastChunkHandling` option');
|
||
}
|
||
|
||
if (into) notDetached(into.buffer);
|
||
|
||
var stringLength = string.length;
|
||
var bytes = into || [];
|
||
var written = 0;
|
||
var read = 0;
|
||
var chunk = '';
|
||
var index = 0;
|
||
|
||
if (maxLength) while (true) {
|
||
index = skipAsciiWhitespace(string, index);
|
||
if (index === stringLength) {
|
||
if (chunk.length > 0) {
|
||
if (lastChunkHandling === 'stop-before-partial') {
|
||
break;
|
||
}
|
||
if (lastChunkHandling === 'loose') {
|
||
if (chunk.length === 1) {
|
||
throw new SyntaxError('Malformed padding: exactly one additional character');
|
||
}
|
||
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
|
||
} else {
|
||
throw new SyntaxError('Missing padding');
|
||
}
|
||
}
|
||
read = stringLength;
|
||
break;
|
||
}
|
||
var chr = at(string, index);
|
||
++index;
|
||
if (chr === '=') {
|
||
if (chunk.length < 2) {
|
||
throw new SyntaxError('Padding is too early');
|
||
}
|
||
index = skipAsciiWhitespace(string, index);
|
||
if (chunk.length === 2) {
|
||
if (index === stringLength) {
|
||
if (lastChunkHandling === 'stop-before-partial') {
|
||
break;
|
||
}
|
||
throw new SyntaxError('Malformed padding: only one =');
|
||
}
|
||
if (at(string, index) === '=') {
|
||
++index;
|
||
index = skipAsciiWhitespace(string, index);
|
||
}
|
||
}
|
||
if (index < stringLength) {
|
||
throw new SyntaxError('Unexpected character after padding');
|
||
}
|
||
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, lastChunkHandling === 'strict'), written);
|
||
read = stringLength;
|
||
break;
|
||
}
|
||
if (!hasOwn(alphabet, chr)) {
|
||
throw new SyntaxError('Unexpected character');
|
||
}
|
||
var remainingBytes = maxLength - written;
|
||
if (remainingBytes === 1 && chunk.length === 2 || remainingBytes === 2 && chunk.length === 3) {
|
||
// special case: we can fit exactly the number of bytes currently represented by chunk, so we were just checking for `=`
|
||
break;
|
||
}
|
||
|
||
chunk += chr;
|
||
if (chunk.length === 4) {
|
||
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
|
||
chunk = '';
|
||
read = index;
|
||
if (written === maxLength) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return { bytes: bytes, read: read, written: written };
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2303
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
|
||
var Uint8Array = globalThis.Uint8Array;
|
||
var SyntaxError = globalThis.SyntaxError;
|
||
var parseInt = globalThis.parseInt;
|
||
var min = Math.min;
|
||
var NOT_HEX = /[^\da-f]/i;
|
||
var exec = uncurryThis(NOT_HEX.exec);
|
||
var stringSlice = uncurryThis(''.slice);
|
||
|
||
module.exports = function (string, into) {
|
||
var stringLength = string.length;
|
||
if (stringLength % 2 !== 0) throw new SyntaxError('String should be an even number of characters');
|
||
var maxLength = into ? min(into.length, stringLength / 2) : stringLength / 2;
|
||
var bytes = into || new Uint8Array(maxLength);
|
||
var read = 0;
|
||
var written = 0;
|
||
while (written < maxLength) {
|
||
var hexits = stringSlice(string, read, read += 2);
|
||
if (exec(NOT_HEX, hexits)) throw new SyntaxError('String should only contain hex characters');
|
||
bytes[written++] = parseInt(hexits, 16);
|
||
}
|
||
return { bytes: bytes, read: read };
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7040
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
/* eslint-disable es/no-symbol -- required for testing */
|
||
var NATIVE_SYMBOL = __webpack_require__(4495);
|
||
|
||
module.exports = NATIVE_SYMBOL &&
|
||
!Symbol.sham &&
|
||
typeof Symbol.iterator == 'symbol';
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8686
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var fails = __webpack_require__(9039);
|
||
|
||
// V8 ~ Chrome 36-
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
||
module.exports = DESCRIPTORS && fails(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
|
||
value: 42,
|
||
writable: false
|
||
}).prototype !== 42;
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2812
|
||
(module) {
|
||
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (passed, required) {
|
||
if (passed < required) throw new $TypeError('Not enough arguments');
|
||
return passed;
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8622
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var isCallable = __webpack_require__(4901);
|
||
|
||
var WeakMap = globalThis.WeakMap;
|
||
|
||
module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8227
|
||
(module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var globalThis = __webpack_require__(4576);
|
||
var shared = __webpack_require__(5745);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var uid = __webpack_require__(3392);
|
||
var NATIVE_SYMBOL = __webpack_require__(4495);
|
||
var USE_SYMBOL_AS_UID = __webpack_require__(7040);
|
||
|
||
var Symbol = globalThis.Symbol;
|
||
var WellKnownSymbolsStore = shared('wks');
|
||
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
|
||
|
||
module.exports = function (name) {
|
||
if (!hasOwn(WellKnownSymbolsStore, name)) {
|
||
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
|
||
? Symbol[name]
|
||
: createWellKnownSymbol('Symbol.' + name);
|
||
} return WellKnownSymbolsStore[name];
|
||
};
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6573
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var defineBuiltInAccessor = __webpack_require__(2106);
|
||
var isDetached = __webpack_require__(3238);
|
||
|
||
var ArrayBufferPrototype = ArrayBuffer.prototype;
|
||
|
||
// `ArrayBuffer.prototype.detached` getter
|
||
// https://tc39.es/ecma262/#sec-get-arraybuffer.prototype.detached
|
||
if (DESCRIPTORS && !('detached' in ArrayBufferPrototype)) {
|
||
defineBuiltInAccessor(ArrayBufferPrototype, 'detached', {
|
||
configurable: true,
|
||
get: function detached() {
|
||
return isDetached(this);
|
||
}
|
||
});
|
||
}
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7936
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var $transfer = __webpack_require__(5636);
|
||
|
||
// `ArrayBuffer.prototype.transferToFixedLength` method
|
||
// https://tc39.es/ecma262/#sec-arraybuffer.prototype.transfertofixedlength
|
||
if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
|
||
transferToFixedLength: function transferToFixedLength() {
|
||
return $transfer(this, arguments.length ? arguments[0] : undefined, false);
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8100
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var $transfer = __webpack_require__(5636);
|
||
|
||
// `ArrayBuffer.prototype.transfer` method
|
||
// https://tc39.es/ecma262/#sec-arraybuffer.prototype.transfer
|
||
if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
|
||
transfer: function transfer() {
|
||
return $transfer(this, arguments.length ? arguments[0] : undefined, true);
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4114
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var toObject = __webpack_require__(8981);
|
||
var lengthOfArrayLike = __webpack_require__(6198);
|
||
var setArrayLength = __webpack_require__(4527);
|
||
var doesNotExceedSafeInteger = __webpack_require__(6837);
|
||
var fails = __webpack_require__(9039);
|
||
|
||
var INCORRECT_TO_LENGTH = fails(function () {
|
||
return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
|
||
});
|
||
|
||
// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=12681
|
||
var properErrorOnNonWritableLength = function () {
|
||
try {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
Object.defineProperty([], 'length', { writable: false }).push();
|
||
} catch (error) {
|
||
return error instanceof TypeError;
|
||
}
|
||
};
|
||
|
||
var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
|
||
|
||
// `Array.prototype.push` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.push
|
||
$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
|
||
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
||
push: function push(item) {
|
||
var O = toObject(this);
|
||
var len = lengthOfArrayLike(O);
|
||
var argCount = arguments.length;
|
||
doesNotExceedSafeInteger(len + argCount);
|
||
for (var i = 0; i < argCount; i++) {
|
||
O[len] = arguments[i];
|
||
len++;
|
||
}
|
||
setArrayLength(O, len);
|
||
return len;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8111
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var globalThis = __webpack_require__(4576);
|
||
var anInstance = __webpack_require__(679);
|
||
var anObject = __webpack_require__(8551);
|
||
var isCallable = __webpack_require__(4901);
|
||
var getPrototypeOf = __webpack_require__(2787);
|
||
var defineBuiltInAccessor = __webpack_require__(2106);
|
||
var createProperty = __webpack_require__(4659);
|
||
var fails = __webpack_require__(9039);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var wellKnownSymbol = __webpack_require__(8227);
|
||
var IteratorPrototype = (__webpack_require__(7657).IteratorPrototype);
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var IS_PURE = __webpack_require__(6395);
|
||
|
||
var CONSTRUCTOR = 'constructor';
|
||
var ITERATOR = 'Iterator';
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
|
||
var $TypeError = TypeError;
|
||
var NativeIterator = globalThis[ITERATOR];
|
||
|
||
// FF56- have non-standard global helper `Iterator`
|
||
var FORCED = IS_PURE
|
||
|| !isCallable(NativeIterator)
|
||
|| NativeIterator.prototype !== IteratorPrototype
|
||
// FF44- non-standard `Iterator` passes previous tests
|
||
|| !fails(function () { NativeIterator({}); });
|
||
|
||
var IteratorConstructor = function Iterator() {
|
||
anInstance(this, IteratorPrototype);
|
||
if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError('Abstract class Iterator not directly constructable');
|
||
};
|
||
|
||
var defineIteratorPrototypeAccessor = function (key, value) {
|
||
if (DESCRIPTORS) {
|
||
defineBuiltInAccessor(IteratorPrototype, key, {
|
||
configurable: true,
|
||
get: function () {
|
||
return value;
|
||
},
|
||
set: function (replacement) {
|
||
anObject(this);
|
||
if (this === IteratorPrototype) throw new $TypeError("You can't redefine this property");
|
||
if (hasOwn(this, key)) this[key] = replacement;
|
||
else createProperty(this, key, replacement);
|
||
}
|
||
});
|
||
} else IteratorPrototype[key] = value;
|
||
};
|
||
|
||
if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR);
|
||
|
||
if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) {
|
||
defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
|
||
}
|
||
|
||
IteratorConstructor.prototype = IteratorPrototype;
|
||
|
||
// `Iterator` constructor
|
||
// https://tc39.es/ecma262/#sec-iterator
|
||
$({ global: true, constructor: true, forced: FORCED }, {
|
||
Iterator: IteratorConstructor
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 1148
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var call = __webpack_require__(9565);
|
||
var iterate = __webpack_require__(2652);
|
||
var aCallable = __webpack_require__(9306);
|
||
var anObject = __webpack_require__(8551);
|
||
var getIteratorDirect = __webpack_require__(1767);
|
||
var iteratorClose = __webpack_require__(9539);
|
||
var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
|
||
|
||
var everyWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('every', TypeError);
|
||
|
||
// `Iterator.prototype.every` method
|
||
// https://tc39.es/ecma262/#sec-iterator.prototype.every
|
||
$({ target: 'Iterator', proto: true, real: true, forced: everyWithoutClosingOnEarlyError }, {
|
||
every: function every(predicate) {
|
||
anObject(this);
|
||
try {
|
||
aCallable(predicate);
|
||
} catch (error) {
|
||
iteratorClose(this, 'throw', error);
|
||
}
|
||
|
||
if (everyWithoutClosingOnEarlyError) return call(everyWithoutClosingOnEarlyError, this, predicate);
|
||
|
||
var record = getIteratorDirect(this);
|
||
var counter = 0;
|
||
return !iterate(record, function (value, stop) {
|
||
if (!predicate(value, counter++)) return stop();
|
||
}, { IS_RECORD: true, INTERRUPTED: true }).stopped;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9112
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var globalThis = __webpack_require__(4576);
|
||
var getBuiltIn = __webpack_require__(7751);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var call = __webpack_require__(9565);
|
||
var isCallable = __webpack_require__(4901);
|
||
var isObject = __webpack_require__(34);
|
||
var isArray = __webpack_require__(4376);
|
||
var hasOwn = __webpack_require__(9297);
|
||
var toString = __webpack_require__(655);
|
||
var lengthOfArrayLike = __webpack_require__(6198);
|
||
var createProperty = __webpack_require__(4659);
|
||
var fails = __webpack_require__(9039);
|
||
var parseJSONString = __webpack_require__(8235);
|
||
var NATIVE_SYMBOL = __webpack_require__(4495);
|
||
|
||
var JSON = globalThis.JSON;
|
||
var Number = globalThis.Number;
|
||
var SyntaxError = globalThis.SyntaxError;
|
||
var nativeParse = JSON && JSON.parse;
|
||
var enumerableOwnProperties = getBuiltIn('Object', 'keys');
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
var at = uncurryThis(''.charAt);
|
||
var slice = uncurryThis(''.slice);
|
||
var exec = uncurryThis(/./.exec);
|
||
var push = uncurryThis([].push);
|
||
|
||
var IS_DIGIT = /^\d$/;
|
||
var IS_NON_ZERO_DIGIT = /^[1-9]$/;
|
||
var IS_NUMBER_START = /^[\d-]$/;
|
||
var IS_WHITESPACE = /^[\t\n\r ]$/;
|
||
|
||
var PRIMITIVE = 0;
|
||
var OBJECT = 1;
|
||
|
||
var $parse = function (source, reviver) {
|
||
source = toString(source);
|
||
var context = new Context(source, 0, '');
|
||
var root = context.parse();
|
||
var value = root.value;
|
||
var endIndex = context.skip(IS_WHITESPACE, root.end);
|
||
if (endIndex < source.length) {
|
||
throw new SyntaxError('Unexpected extra character: "' + at(source, endIndex) + '" after the parsed data at: ' + endIndex);
|
||
}
|
||
return isCallable(reviver) ? internalize({ '': value }, '', reviver, root) : value;
|
||
};
|
||
|
||
var internalize = function (holder, name, reviver, node) {
|
||
var val = holder[name];
|
||
var unmodified = node && val === node.value;
|
||
var context = unmodified && typeof node.source == 'string' ? { source: node.source } : {};
|
||
var elementRecordsLen, keys, len, i, P;
|
||
if (isObject(val)) {
|
||
var nodeIsArray = isArray(val);
|
||
var nodes = unmodified ? node.nodes : nodeIsArray ? [] : {};
|
||
if (nodeIsArray) {
|
||
elementRecordsLen = nodes.length;
|
||
len = lengthOfArrayLike(val);
|
||
for (i = 0; i < len; i++) {
|
||
internalizeProperty(val, i, internalize(val, '' + i, reviver, i < elementRecordsLen ? nodes[i] : undefined));
|
||
}
|
||
} else {
|
||
keys = enumerableOwnProperties(val);
|
||
len = lengthOfArrayLike(keys);
|
||
for (i = 0; i < len; i++) {
|
||
P = keys[i];
|
||
internalizeProperty(val, P, internalize(val, P, reviver, hasOwn(nodes, P) ? nodes[P] : undefined));
|
||
}
|
||
}
|
||
}
|
||
return call(reviver, holder, name, val, context);
|
||
};
|
||
|
||
var internalizeProperty = function (object, key, value) {
|
||
if (DESCRIPTORS) {
|
||
var descriptor = getOwnPropertyDescriptor(object, key);
|
||
if (descriptor && !descriptor.configurable) return;
|
||
}
|
||
if (value === undefined) delete object[key];
|
||
else createProperty(object, key, value);
|
||
};
|
||
|
||
var Node = function (value, end, source, nodes) {
|
||
this.value = value;
|
||
this.end = end;
|
||
this.source = source;
|
||
this.nodes = nodes;
|
||
};
|
||
|
||
var Context = function (source, index) {
|
||
this.source = source;
|
||
this.index = index;
|
||
};
|
||
|
||
// https://www.json.org/json-en.html
|
||
Context.prototype = {
|
||
fork: function (nextIndex) {
|
||
return new Context(this.source, nextIndex);
|
||
},
|
||
parse: function () {
|
||
var source = this.source;
|
||
var i = this.skip(IS_WHITESPACE, this.index);
|
||
var fork = this.fork(i);
|
||
var chr = at(source, i);
|
||
if (exec(IS_NUMBER_START, chr)) return fork.number();
|
||
switch (chr) {
|
||
case '{':
|
||
return fork.object();
|
||
case '[':
|
||
return fork.array();
|
||
case '"':
|
||
return fork.string();
|
||
case 't':
|
||
return fork.keyword(true);
|
||
case 'f':
|
||
return fork.keyword(false);
|
||
case 'n':
|
||
return fork.keyword(null);
|
||
} throw new SyntaxError('Unexpected character: "' + chr + '" at: ' + i);
|
||
},
|
||
node: function (type, value, start, end, nodes) {
|
||
return new Node(value, end, type ? null : slice(this.source, start, end), nodes);
|
||
},
|
||
object: function () {
|
||
var source = this.source;
|
||
var i = this.index + 1;
|
||
var expectKeypair = false;
|
||
var object = {};
|
||
var nodes = {};
|
||
while (i < source.length) {
|
||
i = this.until(['"', '}'], i);
|
||
if (at(source, i) === '}' && !expectKeypair) {
|
||
i++;
|
||
break;
|
||
}
|
||
// Parsing the key
|
||
var result = this.fork(i).string();
|
||
var key = result.value;
|
||
i = result.end;
|
||
i = this.until([':'], i) + 1;
|
||
// Parsing value
|
||
i = this.skip(IS_WHITESPACE, i);
|
||
result = this.fork(i).parse();
|
||
createProperty(nodes, key, result);
|
||
createProperty(object, key, result.value);
|
||
i = this.until([',', '}'], result.end);
|
||
var chr = at(source, i);
|
||
if (chr === ',') {
|
||
expectKeypair = true;
|
||
i++;
|
||
} else if (chr === '}') {
|
||
i++;
|
||
break;
|
||
}
|
||
}
|
||
return this.node(OBJECT, object, this.index, i, nodes);
|
||
},
|
||
array: function () {
|
||
var source = this.source;
|
||
var i = this.index + 1;
|
||
var expectElement = false;
|
||
var array = [];
|
||
var nodes = [];
|
||
while (i < source.length) {
|
||
i = this.skip(IS_WHITESPACE, i);
|
||
if (at(source, i) === ']' && !expectElement) {
|
||
i++;
|
||
break;
|
||
}
|
||
var result = this.fork(i).parse();
|
||
push(nodes, result);
|
||
push(array, result.value);
|
||
i = this.until([',', ']'], result.end);
|
||
if (at(source, i) === ',') {
|
||
expectElement = true;
|
||
i++;
|
||
} else if (at(source, i) === ']') {
|
||
i++;
|
||
break;
|
||
}
|
||
}
|
||
return this.node(OBJECT, array, this.index, i, nodes);
|
||
},
|
||
string: function () {
|
||
var index = this.index;
|
||
var parsed = parseJSONString(this.source, this.index + 1);
|
||
return this.node(PRIMITIVE, parsed.value, index, parsed.end);
|
||
},
|
||
number: function () {
|
||
var source = this.source;
|
||
var startIndex = this.index;
|
||
var i = startIndex;
|
||
if (at(source, i) === '-') i++;
|
||
if (at(source, i) === '0') i++;
|
||
else if (exec(IS_NON_ZERO_DIGIT, at(source, i))) i = this.skip(IS_DIGIT, i + 1);
|
||
else throw new SyntaxError('Failed to parse number at: ' + i);
|
||
if (at(source, i) === '.') i = this.skip(IS_DIGIT, i + 1);
|
||
if (at(source, i) === 'e' || at(source, i) === 'E') {
|
||
i++;
|
||
if (at(source, i) === '+' || at(source, i) === '-') i++;
|
||
var exponentStartIndex = i;
|
||
i = this.skip(IS_DIGIT, i);
|
||
if (exponentStartIndex === i) throw new SyntaxError("Failed to parse number's exponent value at: " + i);
|
||
}
|
||
return this.node(PRIMITIVE, Number(slice(source, startIndex, i)), startIndex, i);
|
||
},
|
||
keyword: function (value) {
|
||
var keyword = '' + value;
|
||
var index = this.index;
|
||
var endIndex = index + keyword.length;
|
||
if (slice(this.source, index, endIndex) !== keyword) throw new SyntaxError('Failed to parse value at: ' + index);
|
||
return this.node(PRIMITIVE, value, index, endIndex);
|
||
},
|
||
skip: function (regex, i) {
|
||
var source = this.source;
|
||
for (; i < source.length; i++) if (!exec(regex, at(source, i))) break;
|
||
return i;
|
||
},
|
||
until: function (array, i) {
|
||
i = this.skip(IS_WHITESPACE, i);
|
||
var chr = at(this.source, i);
|
||
for (var j = 0; j < array.length; j++) if (array[j] === chr) return i;
|
||
throw new SyntaxError('Unexpected character: "' + chr + '" at: ' + i);
|
||
}
|
||
};
|
||
|
||
var NO_SOURCE_SUPPORT = fails(function () {
|
||
var unsafeInt = '9007199254740993';
|
||
var source;
|
||
nativeParse(unsafeInt, function (key, value, context) {
|
||
source = context.source;
|
||
});
|
||
return source !== unsafeInt;
|
||
});
|
||
|
||
var PROPER_BASE_PARSE = NATIVE_SYMBOL && !fails(function () {
|
||
// Safari 9 bug
|
||
return 1 / nativeParse('-0 \t') !== -Infinity;
|
||
});
|
||
|
||
// `JSON.parse` method
|
||
// https://tc39.es/ecma262/#sec-json.parse
|
||
// https://github.com/tc39/proposal-json-parse-with-source
|
||
$({ target: 'JSON', stat: true, forced: NO_SOURCE_SUPPORT }, {
|
||
parse: function parse(text, reviver) {
|
||
return PROPER_BASE_PARSE && !isCallable(reviver) ? nativeParse(text) : $parse(text, reviver);
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 3110
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var getBuiltIn = __webpack_require__(7751);
|
||
var apply = __webpack_require__(8745);
|
||
var call = __webpack_require__(9565);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var fails = __webpack_require__(9039);
|
||
var isArray = __webpack_require__(4376);
|
||
var isCallable = __webpack_require__(4901);
|
||
var isRawJSON = __webpack_require__(5810);
|
||
var isSymbol = __webpack_require__(757);
|
||
var classof = __webpack_require__(2195);
|
||
var toString = __webpack_require__(655);
|
||
var arraySlice = __webpack_require__(7680);
|
||
var parseJSONString = __webpack_require__(8235);
|
||
var uid = __webpack_require__(3392);
|
||
var NATIVE_SYMBOL = __webpack_require__(4495);
|
||
var NATIVE_RAW_JSON = __webpack_require__(7819);
|
||
|
||
var $String = String;
|
||
var $stringify = getBuiltIn('JSON', 'stringify');
|
||
var exec = uncurryThis(/./.exec);
|
||
var charAt = uncurryThis(''.charAt);
|
||
var charCodeAt = uncurryThis(''.charCodeAt);
|
||
var replace = uncurryThis(''.replace);
|
||
var slice = uncurryThis(''.slice);
|
||
var push = uncurryThis([].push);
|
||
var numberToString = uncurryThis(1.1.toString);
|
||
|
||
var surrogates = /[\uD800-\uDFFF]/g;
|
||
var lowSurrogates = /^[\uD800-\uDBFF]$/;
|
||
var hiSurrogates = /^[\uDC00-\uDFFF]$/;
|
||
|
||
var MARK = uid();
|
||
var MARK_LENGTH = MARK.length;
|
||
|
||
var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails(function () {
|
||
var symbol = getBuiltIn('Symbol')('stringify detection');
|
||
// MS Edge converts symbol values to JSON as {}
|
||
return $stringify([symbol]) !== '[null]'
|
||
// WebKit converts symbol values to JSON as null
|
||
|| $stringify({ a: symbol }) !== '{}'
|
||
// V8 throws on boxed symbols
|
||
|| $stringify(Object(symbol)) !== '{}';
|
||
});
|
||
|
||
// https://github.com/tc39/proposal-well-formed-stringify
|
||
var ILL_FORMED_UNICODE = fails(function () {
|
||
return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"'
|
||
|| $stringify('\uDEAD') !== '"\\udead"';
|
||
});
|
||
|
||
var stringifyWithProperSymbolsConversion = WRONG_SYMBOLS_CONVERSION ? function (it, replacer) {
|
||
var args = arraySlice(arguments);
|
||
var $replacer = getReplacerFunction(replacer);
|
||
if (!isCallable($replacer) && (it === undefined || isSymbol(it))) return; // IE8 returns string on undefined
|
||
args[1] = function (key, value) {
|
||
// some old implementations (like WebKit) could pass numbers as keys
|
||
if (isCallable($replacer)) value = call($replacer, this, $String(key), value);
|
||
if (!isSymbol(value)) return value;
|
||
};
|
||
return apply($stringify, null, args);
|
||
} : $stringify;
|
||
|
||
var fixIllFormedJSON = function (match, offset, string) {
|
||
var prev = charAt(string, offset - 1);
|
||
var next = charAt(string, offset + 1);
|
||
if ((exec(lowSurrogates, match) && !exec(hiSurrogates, next)) || (exec(hiSurrogates, match) && !exec(lowSurrogates, prev))) {
|
||
return '\\u' + numberToString(charCodeAt(match, 0), 16);
|
||
} return match;
|
||
};
|
||
|
||
var getReplacerFunction = function (replacer) {
|
||
if (isCallable(replacer)) return replacer;
|
||
if (!isArray(replacer)) return;
|
||
var rawLength = replacer.length;
|
||
var keys = [];
|
||
for (var i = 0; i < rawLength; i++) {
|
||
var element = replacer[i];
|
||
if (typeof element == 'string') push(keys, element);
|
||
else if (typeof element == 'number' || classof(element) === 'Number' || classof(element) === 'String') push(keys, toString(element));
|
||
}
|
||
var keysLength = keys.length;
|
||
var root = true;
|
||
return function (key, value) {
|
||
if (root) {
|
||
root = false;
|
||
return value;
|
||
}
|
||
if (isArray(this)) return value;
|
||
for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
|
||
};
|
||
};
|
||
|
||
// `JSON.stringify` method
|
||
// https://tc39.es/ecma262/#sec-json.stringify
|
||
// https://github.com/tc39/proposal-json-parse-with-source
|
||
if ($stringify) $({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE || !NATIVE_RAW_JSON }, {
|
||
stringify: function stringify(text, replacer, space) {
|
||
var replacerFunction = getReplacerFunction(replacer);
|
||
var rawStrings = [];
|
||
|
||
var json = stringifyWithProperSymbolsConversion(text, function (key, value) {
|
||
// some old implementations (like WebKit) could pass numbers as keys
|
||
var v = isCallable(replacerFunction) ? call(replacerFunction, this, $String(key), value) : value;
|
||
return !NATIVE_RAW_JSON && isRawJSON(v) ? MARK + (push(rawStrings, v.rawJSON) - 1) : v;
|
||
}, space);
|
||
|
||
if (typeof json != 'string') return json;
|
||
|
||
if (ILL_FORMED_UNICODE) json = replace(json, surrogates, fixIllFormedJSON);
|
||
|
||
if (NATIVE_RAW_JSON) return json;
|
||
|
||
var result = '';
|
||
var length = json.length;
|
||
|
||
for (var i = 0; i < length; i++) {
|
||
var chr = charAt(json, i);
|
||
if (chr === '"') {
|
||
var end = parseJSONString(json, ++i).end - 1;
|
||
var string = slice(json, i, end);
|
||
result += slice(string, 0, MARK_LENGTH) === MARK
|
||
? rawStrings[slice(string, MARK_LENGTH)]
|
||
: '"' + string + '"';
|
||
i = end;
|
||
} else result += chr;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 2731
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var aCallable = __webpack_require__(9306);
|
||
var aMap = __webpack_require__(6194);
|
||
var MapHelpers = __webpack_require__(2248);
|
||
var IS_PURE = __webpack_require__(6395);
|
||
|
||
var get = MapHelpers.get;
|
||
var has = MapHelpers.has;
|
||
var set = MapHelpers.set;
|
||
|
||
// `Map.prototype.getOrInsertComputed` method
|
||
// https://github.com/tc39/proposal-upsert
|
||
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
|
||
getOrInsertComputed: function getOrInsertComputed(key, callbackfn) {
|
||
aMap(this);
|
||
aCallable(callbackfn);
|
||
if (has(this, key)) return get(this, key);
|
||
// CanonicalizeKeyedCollectionKey
|
||
if (key === 0 && 1 / key === -Infinity) key = 0;
|
||
var value = callbackfn(key);
|
||
set(this, key, value);
|
||
return value;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 5367
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var aMap = __webpack_require__(6194);
|
||
var MapHelpers = __webpack_require__(2248);
|
||
var IS_PURE = __webpack_require__(6395);
|
||
|
||
var get = MapHelpers.get;
|
||
var has = MapHelpers.has;
|
||
var set = MapHelpers.set;
|
||
|
||
// `Map.prototype.getOrInsert` method
|
||
// https://github.com/tc39/proposal-upsert
|
||
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
|
||
getOrInsert: function getOrInsert(key, value) {
|
||
if (has(aMap(this), key)) return get(this, key);
|
||
set(this, key, value);
|
||
return value;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9577
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var ArrayBufferViewCore = __webpack_require__(4644);
|
||
var isBigIntArray = __webpack_require__(1108);
|
||
var lengthOfArrayLike = __webpack_require__(6198);
|
||
var toIntegerOrInfinity = __webpack_require__(1291);
|
||
var toBigInt = __webpack_require__(5854);
|
||
|
||
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
||
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
||
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
||
|
||
var $RangeError = RangeError;
|
||
|
||
var PROPER_ORDER = function () {
|
||
try {
|
||
// eslint-disable-next-line no-throw-literal, es/no-typed-arrays, es/no-array-prototype-with -- required for testing
|
||
new Int8Array(1)['with'](2, { valueOf: function () { throw 8; } });
|
||
} catch (error) {
|
||
// some early implementations, like WebKit, does not follow the final semantic
|
||
// https://github.com/tc39/proposal-change-array-by-copy/pull/86
|
||
return error === 8;
|
||
}
|
||
}();
|
||
|
||
// Bug in WebKit. It should truncate a negative fractional index to zero, but instead throws an error
|
||
var THROW_ON_NEGATIVE_FRACTIONAL_INDEX = PROPER_ORDER && function () {
|
||
try {
|
||
// eslint-disable-next-line es/no-typed-arrays, es/no-array-prototype-with -- required for testing
|
||
new Int8Array(1)['with'](-0.5, 1);
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
}();
|
||
|
||
// `%TypedArray%.prototype.with` method
|
||
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.with
|
||
exportTypedArrayMethod('with', { 'with': function (index, value) {
|
||
var O = aTypedArray(this);
|
||
var len = lengthOfArrayLike(O);
|
||
var relativeIndex = toIntegerOrInfinity(index);
|
||
var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex;
|
||
var numericValue = isBigIntArray(O) ? toBigInt(value) : +value;
|
||
if (actualIndex >= len || actualIndex < 0) throw new $RangeError('Incorrect index');
|
||
var A = new (getTypedArrayConstructor(O))(len);
|
||
var k = 0;
|
||
for (; k < len; k++) A[k] = k === actualIndex ? numericValue : O[k];
|
||
return A;
|
||
} }['with'], !PROPER_ORDER || THROW_ON_NEGATIVE_FRACTIONAL_INDEX);
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 6632
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var globalThis = __webpack_require__(4576);
|
||
var $fromBase64 = __webpack_require__(9143);
|
||
var anUint8Array = __webpack_require__(4154);
|
||
|
||
var Uint8Array = globalThis.Uint8Array;
|
||
|
||
var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.prototype.setFromBase64 || !function () {
|
||
var target = new Uint8Array([255, 255, 255, 255, 255]);
|
||
try {
|
||
target.setFromBase64('', null);
|
||
return;
|
||
} catch (error) { /* empty */ }
|
||
// Webkit not throw an error on odd length string
|
||
try {
|
||
target.setFromBase64('a');
|
||
return;
|
||
} catch (error) { /* empty */ }
|
||
try {
|
||
target.setFromBase64('MjYyZg===');
|
||
} catch (error) {
|
||
return target[0] === 50 && target[1] === 54 && target[2] === 50 && target[3] === 255 && target[4] === 255;
|
||
}
|
||
}();
|
||
|
||
// `Uint8Array.prototype.setFromBase64` method
|
||
// https://github.com/tc39/proposal-arraybuffer-base64
|
||
if (Uint8Array) $({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, {
|
||
setFromBase64: function setFromBase64(string /* , options */) {
|
||
anUint8Array(this);
|
||
|
||
var result = $fromBase64(string, arguments.length > 1 ? arguments[1] : undefined, this, this.length);
|
||
|
||
return { read: result.read, written: result.written };
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4226
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var globalThis = __webpack_require__(4576);
|
||
var aString = __webpack_require__(3463);
|
||
var anUint8Array = __webpack_require__(4154);
|
||
var notDetached = __webpack_require__(5169);
|
||
var $fromHex = __webpack_require__(2303);
|
||
|
||
// Should not throw an error on length-tracking views over ResizableArrayBuffer
|
||
// https://issues.chromium.org/issues/454630441
|
||
function throwsOnLengthTrackingView() {
|
||
try {
|
||
// eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- required for testing
|
||
var rab = new ArrayBuffer(16, { maxByteLength: 1024 });
|
||
// eslint-disable-next-line es/no-uint8array-prototype-setfromhex, es/no-typed-arrays -- required for testing
|
||
new Uint8Array(rab).setFromHex('cafed00d');
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// `Uint8Array.prototype.setFromHex` method
|
||
// https://github.com/tc39/proposal-arraybuffer-base64
|
||
if (globalThis.Uint8Array) $({ target: 'Uint8Array', proto: true, forced: throwsOnLengthTrackingView() }, {
|
||
setFromHex: function setFromHex(string) {
|
||
anUint8Array(this);
|
||
aString(string);
|
||
notDetached(this.buffer);
|
||
var read = $fromHex(string, this).read;
|
||
return { read: read, written: read / 2 };
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 9486
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var globalThis = __webpack_require__(4576);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var anObjectOrUndefined = __webpack_require__(3972);
|
||
var anUint8Array = __webpack_require__(4154);
|
||
var notDetached = __webpack_require__(5169);
|
||
var base64Map = __webpack_require__(2804);
|
||
var getAlphabetOption = __webpack_require__(944);
|
||
|
||
var base64Alphabet = base64Map.i2c;
|
||
var base64UrlAlphabet = base64Map.i2cUrl;
|
||
|
||
var charAt = uncurryThis(''.charAt);
|
||
|
||
var Uint8Array = globalThis.Uint8Array;
|
||
|
||
var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.prototype.toBase64 || !function () {
|
||
try {
|
||
var target = new Uint8Array();
|
||
target.toBase64(null);
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
}();
|
||
|
||
// `Uint8Array.prototype.toBase64` method
|
||
// https://github.com/tc39/proposal-arraybuffer-base64
|
||
if (Uint8Array) $({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, {
|
||
toBase64: function toBase64(/* options */) {
|
||
var array = anUint8Array(this);
|
||
var options = arguments.length ? anObjectOrUndefined(arguments[0]) : undefined;
|
||
var alphabet = getAlphabetOption(options) === 'base64' ? base64Alphabet : base64UrlAlphabet;
|
||
var omitPadding = !!options && !!options.omitPadding;
|
||
notDetached(this.buffer);
|
||
|
||
var result = '';
|
||
var i = 0;
|
||
var length = array.length;
|
||
var triplet;
|
||
|
||
var at = function (shift) {
|
||
return charAt(alphabet, (triplet >> (6 * shift)) & 63);
|
||
};
|
||
|
||
for (; i + 2 < length; i += 3) {
|
||
triplet = (array[i] << 16) + (array[i + 1] << 8) + array[i + 2];
|
||
result += at(3) + at(2) + at(1) + at(0);
|
||
}
|
||
if (i + 2 === length) {
|
||
triplet = (array[i] << 16) + (array[i + 1] << 8);
|
||
result += at(3) + at(2) + at(1) + (omitPadding ? '' : '=');
|
||
} else if (i + 1 === length) {
|
||
triplet = array[i] << 16;
|
||
result += at(3) + at(2) + (omitPadding ? '' : '==');
|
||
}
|
||
|
||
return result;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 456
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var $ = __webpack_require__(6518);
|
||
var globalThis = __webpack_require__(4576);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var anUint8Array = __webpack_require__(4154);
|
||
var notDetached = __webpack_require__(5169);
|
||
|
||
var numberToString = uncurryThis(1.1.toString);
|
||
|
||
var Uint8Array = globalThis.Uint8Array;
|
||
|
||
var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.prototype.toHex || !(function () {
|
||
try {
|
||
var target = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]);
|
||
return target.toHex() === 'ffffffffffffffff';
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
})();
|
||
|
||
// `Uint8Array.prototype.toHex` method
|
||
// https://github.com/tc39/proposal-arraybuffer-base64
|
||
if (Uint8Array) $({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, {
|
||
toHex: function toHex() {
|
||
anUint8Array(this);
|
||
notDetached(this.buffer);
|
||
var result = '';
|
||
for (var i = 0, length = this.length; i < length; i++) {
|
||
var hex = numberToString(this[i], 16);
|
||
result += hex.length === 1 ? '0' + hex : hex;
|
||
}
|
||
return result;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 4603
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var defineBuiltIn = __webpack_require__(6840);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var toString = __webpack_require__(655);
|
||
var validateArgumentsLength = __webpack_require__(2812);
|
||
|
||
var $URLSearchParams = URLSearchParams;
|
||
var URLSearchParamsPrototype = $URLSearchParams.prototype;
|
||
var append = uncurryThis(URLSearchParamsPrototype.append);
|
||
var $delete = uncurryThis(URLSearchParamsPrototype['delete']);
|
||
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
|
||
var push = uncurryThis([].push);
|
||
var params = new $URLSearchParams('a=1&a=2&b=3');
|
||
|
||
params['delete']('a', 1);
|
||
// `undefined` case is a Chromium 117 bug
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
||
params['delete']('b', undefined);
|
||
|
||
if (params + '' !== 'a=2') {
|
||
defineBuiltIn(URLSearchParamsPrototype, 'delete', function (name /* , value */) {
|
||
var length = arguments.length;
|
||
var $value = length < 2 ? undefined : arguments[1];
|
||
if (length && $value === undefined) return $delete(this, name);
|
||
var entries = [];
|
||
forEach(this, function (v, k) { // also validates `this`
|
||
push(entries, { key: k, value: v });
|
||
});
|
||
validateArgumentsLength(length, 1);
|
||
var key = toString(name);
|
||
var value = toString($value);
|
||
var index = 0;
|
||
var dindex = 0;
|
||
var found = false;
|
||
var entriesLength = entries.length;
|
||
var entry;
|
||
while (index < entriesLength) {
|
||
entry = entries[index++];
|
||
if (found || entry.key === key) {
|
||
found = true;
|
||
$delete(this, entry.key);
|
||
} else dindex++;
|
||
}
|
||
while (dindex < entriesLength) {
|
||
entry = entries[dindex++];
|
||
if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
|
||
}
|
||
}, { enumerable: true, unsafe: true });
|
||
}
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 7566
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var defineBuiltIn = __webpack_require__(6840);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var toString = __webpack_require__(655);
|
||
var validateArgumentsLength = __webpack_require__(2812);
|
||
|
||
var $URLSearchParams = URLSearchParams;
|
||
var URLSearchParamsPrototype = $URLSearchParams.prototype;
|
||
var getAll = uncurryThis(URLSearchParamsPrototype.getAll);
|
||
var $has = uncurryThis(URLSearchParamsPrototype.has);
|
||
var params = new $URLSearchParams('a=1');
|
||
|
||
// `undefined` case is a Chromium 117 bug
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
||
if (params.has('a', 2) || !params.has('a', undefined)) {
|
||
defineBuiltIn(URLSearchParamsPrototype, 'has', function has(name /* , value */) {
|
||
var length = arguments.length;
|
||
var $value = length < 2 ? undefined : arguments[1];
|
||
if (length && $value === undefined) return $has(this, name);
|
||
var values = getAll(this, name); // also validates `this`
|
||
validateArgumentsLength(length, 1);
|
||
var value = toString($value);
|
||
var index = 0;
|
||
while (index < values.length) {
|
||
if (values[index++] === value) return true;
|
||
} return false;
|
||
}, { enumerable: true, unsafe: true });
|
||
}
|
||
|
||
|
||
/***/ },
|
||
|
||
/***/ 8721
|
||
(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
||
|
||
|
||
var DESCRIPTORS = __webpack_require__(3724);
|
||
var uncurryThis = __webpack_require__(9504);
|
||
var defineBuiltInAccessor = __webpack_require__(2106);
|
||
|
||
var URLSearchParamsPrototype = URLSearchParams.prototype;
|
||
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
|
||
|
||
// `URLSearchParams.prototype.size` getter
|
||
// https://github.com/whatwg/url/pull/734
|
||
if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) {
|
||
defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
|
||
get: function size() {
|
||
var count = 0;
|
||
forEach(this, function () { count++; });
|
||
return count;
|
||
},
|
||
configurable: true,
|
||
enumerable: true
|
||
});
|
||
}
|
||
|
||
|
||
/***/ }
|
||
|
||
/******/ });
|
||
/************************************************************************/
|
||
/******/ // The module cache
|
||
/******/ var __webpack_module_cache__ = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/ // Check if module is in cache
|
||
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
||
/******/ if (cachedModule !== undefined) {
|
||
/******/ return cachedModule.exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = __webpack_module_cache__[moduleId] = {
|
||
/******/ // no module.id needed
|
||
/******/ // no module.loaded needed
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/************************************************************************/
|
||
/******/ /* webpack/runtime/define property getters */
|
||
/******/ (() => {
|
||
/******/ // define getter functions for harmony exports
|
||
/******/ __webpack_require__.d = (exports, definition) => {
|
||
/******/ for(var key in definition) {
|
||
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
||
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
||
/******/ }
|
||
/******/ }
|
||
/******/ };
|
||
/******/ })();
|
||
/******/
|
||
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
||
/******/ (() => {
|
||
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
|
||
/******/ })();
|
||
/******/
|
||
/************************************************************************/
|
||
var __webpack_exports__ = {};
|
||
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.push.js
|
||
var es_array_push = __webpack_require__(4114);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.json.stringify.js
|
||
var es_json_stringify = __webpack_require__(3110);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array-buffer.detached.js
|
||
var es_array_buffer_detached = __webpack_require__(6573);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array-buffer.transfer.js
|
||
var es_array_buffer_transfer = __webpack_require__(8100);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array-buffer.transfer-to-fixed-length.js
|
||
var es_array_buffer_transfer_to_fixed_length = __webpack_require__(7936);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.constructor.js
|
||
var es_iterator_constructor = __webpack_require__(8111);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.every.js
|
||
var es_iterator_every = __webpack_require__(1148);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.json.parse.js
|
||
var es_json_parse = __webpack_require__(9112);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.typed-array.with.js
|
||
var es_typed_array_with = __webpack_require__(9577);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.uint8-array.set-from-base64.js
|
||
var es_uint8_array_set_from_base64 = __webpack_require__(6632);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.uint8-array.set-from-hex.js
|
||
var es_uint8_array_set_from_hex = __webpack_require__(4226);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.uint8-array.to-base64.js
|
||
var es_uint8_array_to_base64 = __webpack_require__(9486);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.uint8-array.to-hex.js
|
||
var es_uint8_array_to_hex = __webpack_require__(456);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.delete.js
|
||
var web_url_search_params_delete = __webpack_require__(4603);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.has.js
|
||
var web_url_search_params_has = __webpack_require__(7566);
|
||
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.size.js
|
||
var web_url_search_params_size = __webpack_require__(8721);
|
||
;// ./external/quickjs/quickjs-eval.js
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
async function Module(moduleArg = {}) {
|
||
var moduleRtn;
|
||
var e = moduleArg,
|
||
aa = import.meta.url;
|
||
try {
|
||
new URL(".", aa);
|
||
} catch {}
|
||
var m = console.log.bind(console),
|
||
n = console.error.bind(console),
|
||
r = !1,
|
||
t;
|
||
function ba(a) {
|
||
for (var b = 0, c = a.length, d = new Uint8Array(c), g; b < c; ++b) g = a.charCodeAt(b), d[b] = ~g >> 8 & g;
|
||
return d;
|
||
}
|
||
var u,
|
||
w,
|
||
x,
|
||
y,
|
||
z,
|
||
A,
|
||
B = !1;
|
||
function C() {
|
||
var a = D.buffer;
|
||
x = new Int8Array(a);
|
||
new Int16Array(a);
|
||
y = new Uint8Array(a);
|
||
new Uint16Array(a);
|
||
z = new Int32Array(a);
|
||
A = new Uint32Array(a);
|
||
new Float32Array(a);
|
||
new Float64Array(a);
|
||
new BigInt64Array(a);
|
||
new BigUint64Array(a);
|
||
}
|
||
function E(a) {
|
||
e.onAbort?.(a);
|
||
a = "Aborted(" + a + ")";
|
||
n(a);
|
||
r = !0;
|
||
a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
|
||
w?.(a);
|
||
throw a;
|
||
}
|
||
var F;
|
||
async function ca(a) {
|
||
return a;
|
||
}
|
||
async function da(a) {
|
||
var b = F;
|
||
try {
|
||
var c = await ca(b);
|
||
return await WebAssembly.instantiate(c, a);
|
||
} catch (d) {
|
||
n(`failed to asynchronously prepare wasm: ${d}`), E(d);
|
||
}
|
||
}
|
||
async function ea(a) {
|
||
return da(a);
|
||
}
|
||
class G {
|
||
name = "ExitStatus";
|
||
constructor(a) {
|
||
this.message = `Program terminated with exit(${a})`;
|
||
this.status = a;
|
||
}
|
||
}
|
||
var H = a => {
|
||
for (; 0 < a.length;) a.shift()(e);
|
||
},
|
||
I = [],
|
||
J = [],
|
||
fa = () => {
|
||
var a = e.preRun.shift();
|
||
J.push(a);
|
||
},
|
||
K = !0,
|
||
L = new TextDecoder(),
|
||
M = (a, b) => {
|
||
for (var c = b + void 0; a[b] && !(b >= c);) ++b;
|
||
return b;
|
||
},
|
||
N = a => a ? L.decode(y.subarray(a, M(y, a))) : "",
|
||
O = 0,
|
||
ha = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335],
|
||
ia = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
|
||
P = {},
|
||
Q = a => {
|
||
if (!(a instanceof G || "unwind" == a)) throw a;
|
||
},
|
||
R = a => {
|
||
t = a;
|
||
K || 0 < O || (e.onExit?.(a), r = !0);
|
||
throw new G(a);
|
||
},
|
||
ja = a => {
|
||
if (!r) try {
|
||
a();
|
||
} catch (b) {
|
||
Q(b);
|
||
} finally {
|
||
if (!(K || 0 < O)) try {
|
||
t = a = t, R(a);
|
||
} catch (b) {
|
||
Q(b);
|
||
}
|
||
}
|
||
},
|
||
S = (a, b, c) => {
|
||
var d = y;
|
||
if (0 < c) {
|
||
c = b + c - 1;
|
||
for (var g = 0; g < a.length; ++g) {
|
||
var f = a.codePointAt(g);
|
||
if (127 >= f) {
|
||
if (b >= c) break;
|
||
d[b++] = f;
|
||
} else if (2047 >= f) {
|
||
if (b + 1 >= c) break;
|
||
d[b++] = 192 | f >> 6;
|
||
d[b++] = 128 | f & 63;
|
||
} else if (65535 >= f) {
|
||
if (b + 2 >= c) break;
|
||
d[b++] = 224 | f >> 12;
|
||
d[b++] = 128 | f >> 6 & 63;
|
||
d[b++] = 128 | f & 63;
|
||
} else {
|
||
if (b + 3 >= c) break;
|
||
d[b++] = 240 | f >> 18;
|
||
d[b++] = 128 | f >> 12 & 63;
|
||
d[b++] = 128 | f >> 6 & 63;
|
||
d[b++] = 128 | f & 63;
|
||
g++;
|
||
}
|
||
}
|
||
d[b] = 0;
|
||
}
|
||
},
|
||
T = a => {
|
||
for (var b = 0, c = 0; c < a.length; ++c) {
|
||
var d = a.charCodeAt(c);
|
||
127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;
|
||
}
|
||
return b;
|
||
},
|
||
V = a => {
|
||
var b = T(a) + 1,
|
||
c = U(b);
|
||
c && S(a, c, b);
|
||
return c;
|
||
};
|
||
function ka() {}
|
||
for (var la = [null, [], []], oa = (a, b, c, d) => {
|
||
var g = {
|
||
string: h => {
|
||
var k = 0;
|
||
if (null !== h && void 0 !== h && 0 !== h) {
|
||
k = T(h) + 1;
|
||
var p = W(k);
|
||
S(h, p, k);
|
||
k = p;
|
||
}
|
||
return k;
|
||
},
|
||
array: h => {
|
||
var k = W(h.length);
|
||
x.set(h, k);
|
||
return k;
|
||
}
|
||
};
|
||
a = e["_" + a];
|
||
var f = [],
|
||
q = 0;
|
||
if (d) for (var l = 0; l < d.length; l++) {
|
||
var v = g[c[l]];
|
||
v ? (0 === q && (q = ma()), f[l] = v(d[l])) : f[l] = d[l];
|
||
}
|
||
c = a(...f);
|
||
return c = function (h) {
|
||
0 !== q && na(q);
|
||
return "string" === b ? N(h) : "boolean" === b ? !!h : h;
|
||
}(c);
|
||
}, X = new Uint8Array(123), Y = 25; 0 <= Y; --Y) X[48 + Y] = 52 + Y, X[65 + Y] = Y, X[97 + Y] = 26 + Y;
|
||
X[43] = 62;
|
||
X[47] = 63;
|
||
ka = (a, b, c) => {
|
||
a = N(a);
|
||
b = null !== b ? JSON.parse(N(b)) : [];
|
||
try {
|
||
const d = e.externalCall(a, b);
|
||
return d ? V(d) : null;
|
||
} catch (d) {
|
||
return e.HEAPU8[c] = 1, V(d.message);
|
||
}
|
||
};
|
||
e.noExitRuntime && (K = e.noExitRuntime);
|
||
e.print && (m = e.print);
|
||
e.printErr && (n = e.printErr);
|
||
if (e.preInit) for ("function" == typeof e.preInit && (e.preInit = [e.preInit]); 0 < e.preInit.length;) e.preInit.shift()();
|
||
e.ccall = oa;
|
||
e.cwrap = (a, b, c, d) => {
|
||
var g = !c || c.every(f => "number" === f || "boolean" === f);
|
||
return "string" !== b && g && !d ? e["_" + a] : (...f) => oa(a, b, c, f, d);
|
||
};
|
||
e.stringToNewUTF8 = V;
|
||
var U,
|
||
pa,
|
||
na,
|
||
W,
|
||
ma,
|
||
D,
|
||
qa = {
|
||
a: (a, b, c, d) => E(`Assertion failed: ${N(a)}, at: ` + [b ? N(b) : "unknown filename", c, d ? N(d) : "unknown function"]),
|
||
e: () => E(""),
|
||
j: () => {
|
||
K = !1;
|
||
O = 0;
|
||
},
|
||
b: function (a, b) {
|
||
a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);
|
||
a = new Date(1E3 * a);
|
||
z[b >> 2] = a.getSeconds();
|
||
z[b + 4 >> 2] = a.getMinutes();
|
||
z[b + 8 >> 2] = a.getHours();
|
||
z[b + 12 >> 2] = a.getDate();
|
||
z[b + 16 >> 2] = a.getMonth();
|
||
z[b + 20 >> 2] = a.getFullYear() - 1900;
|
||
z[b + 24 >> 2] = a.getDay();
|
||
var c = a.getFullYear();
|
||
z[b + 28 >> 2] = (0 !== c % 4 || 0 === c % 100 && 0 !== c % 400 ? ia : ha)[a.getMonth()] + a.getDate() - 1 | 0;
|
||
z[b + 36 >> 2] = -(60 * a.getTimezoneOffset());
|
||
c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset();
|
||
var d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();
|
||
z[b + 32 >> 2] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;
|
||
},
|
||
k: (a, b) => {
|
||
P[a] && (clearTimeout(P[a].id), delete P[a]);
|
||
if (!b) return 0;
|
||
var c = setTimeout(() => {
|
||
delete P[a];
|
||
ja(() => pa(a, performance.now()));
|
||
}, b);
|
||
P[a] = {
|
||
id: c,
|
||
C: b
|
||
};
|
||
return 0;
|
||
},
|
||
c: (a, b, c, d) => {
|
||
var g = new Date().getFullYear(),
|
||
f = new Date(g, 0, 1).getTimezoneOffset();
|
||
g = new Date(g, 6, 1).getTimezoneOffset();
|
||
A[a >> 2] = 60 * Math.max(f, g);
|
||
z[b >> 2] = Number(f != g);
|
||
b = q => {
|
||
var l = Math.abs(q);
|
||
return `UTC${0 <= q ? "-" : "+"}${String(Math.floor(l / 60)).padStart(2, "0")}${String(l % 60).padStart(2, "0")}`;
|
||
};
|
||
a = b(f);
|
||
b = b(g);
|
||
g < f ? (S(a, c, 17), S(b, d, 17)) : (S(a, d, 17), S(b, c, 17));
|
||
},
|
||
g: ka,
|
||
f: function (a, b) {
|
||
a = N(a);
|
||
let c;
|
||
try {
|
||
c = window.JSON.parse(a);
|
||
} catch (d) {
|
||
c = a;
|
||
}
|
||
0 !== b ? window.alert(a) : window.console.log("DUMP", c);
|
||
},
|
||
d: () => Date.now(),
|
||
l: a => {
|
||
var b = y.length;
|
||
a >>>= 0;
|
||
if (2147483648 < a) return !1;
|
||
for (var c = 1; 4 >= c; c *= 2) {
|
||
var d = b * (1 + .2 / c);
|
||
d = Math.min(d, a + 100663296);
|
||
a: {
|
||
d = (Math.min(2147483648, 65536 * Math.ceil(Math.max(a, d) / 65536)) - D.buffer.byteLength + 65535) / 65536 | 0;
|
||
try {
|
||
D.grow(d);
|
||
C();
|
||
var g = 1;
|
||
break a;
|
||
} catch (f) {}
|
||
g = void 0;
|
||
}
|
||
if (g) return !0;
|
||
}
|
||
return !1;
|
||
},
|
||
m: (a, b, c, d) => {
|
||
for (var g = 0, f = 0; f < c; f++) {
|
||
var q = A[b >> 2],
|
||
l = A[b + 4 >> 2];
|
||
b += 8;
|
||
for (var v = 0; v < l; v++) {
|
||
var h = a,
|
||
k = y[q + v],
|
||
p = la[h];
|
||
0 === k || 10 === k ? (h = 1 === h ? m : n, k = M(p, 0), k = L.decode(p.buffer ? p.subarray(0, k) : new Uint8Array(p.slice(0, k))), h(k), p.length = 0) : p.push(k);
|
||
}
|
||
g += l;
|
||
}
|
||
A[d >> 2] = g;
|
||
return 0;
|
||
},
|
||
o: function (a) {
|
||
a = N(a);
|
||
window.console.log(a);
|
||
},
|
||
h: function (a) {
|
||
a = N(a);
|
||
return Date.parse(a);
|
||
},
|
||
n: function (a, b, c, d) {
|
||
a = N(a);
|
||
b = N(b);
|
||
c = N(c);
|
||
c = `Quickjs -- ${a}: ${b}\n${c}`;
|
||
0 !== d ? window.alert(c) : window.console.error(c);
|
||
},
|
||
i: R
|
||
},
|
||
Z;
|
||
Z = await async function () {
|
||
function a(c) {
|
||
c = Z = c.exports;
|
||
e._evalInSandbox = c.r;
|
||
e._nukeSandbox = c.s;
|
||
e._init = c.t;
|
||
e._commFun = c.u;
|
||
e._dumpMemoryUse = c.v;
|
||
U = c.w;
|
||
e._free = c.x;
|
||
pa = c.y;
|
||
na = c.z;
|
||
W = c.A;
|
||
ma = c.B;
|
||
D = c.p;
|
||
C();
|
||
return Z;
|
||
}
|
||
var b = {
|
||
a: qa
|
||
};
|
||
if (e.instantiateWasm) return new Promise(c => {
|
||
e.instantiateWasm(b, (d, g) => {
|
||
c(a(d, g));
|
||
});
|
||
});
|
||
F ??= ba(' |