5282 lines
167 KiB
JavaScript
5282 lines
167 KiB
JavaScript
/*!
|
|
* jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
|
|
* Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
|
|
* Version: v4.7.9
|
|
* Url: https://xdsoft.net/jodit/
|
|
* License(s): MIT
|
|
*/
|
|
|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else {
|
|
var a = factory();
|
|
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
|
|
}
|
|
})(self, function() {
|
|
return /******/ (function() { // webpackBootstrap
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
/***/ 150:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
var defineSymbolToPrimitive = __webpack_require__(28360);
|
|
// `Symbol.toPrimitive` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.toprimitive
|
|
defineWellKnownSymbol('toPrimitive');
|
|
// `Symbol.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
|
|
defineSymbolToPrimitive();
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1055:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1089:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var getOwnPropertyNamesModule = __webpack_require__(63838);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(93715);
|
|
var anObject = __webpack_require__(30941);
|
|
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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1669:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var userAgent = __webpack_require__(1837);
|
|
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;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1837:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var navigator = globalThis.navigator;
|
|
var userAgent = navigator && navigator.userAgent;
|
|
module.exports = userAgent ? String(userAgent) : '';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2958:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var hasOwn = __webpack_require__(26419);
|
|
var ownKeys = __webpack_require__(1089);
|
|
var getOwnPropertyDescriptorModule = __webpack_require__(10393);
|
|
var definePropertyModule = __webpack_require__(9475);
|
|
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));
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2975:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var store = __webpack_require__(49567);
|
|
module.exports = function(key, value) {
|
|
return store[key] || (store[key] = value || {});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3279:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(26919);
|
|
var aCallable = __webpack_require__(90256);
|
|
var anObject = __webpack_require__(30941);
|
|
var tryToString = __webpack_require__(8465);
|
|
var getIteratorMethod = __webpack_require__(72929);
|
|
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');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5944:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var hasOwn = __webpack_require__(26419);
|
|
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() {}).name === 'something';
|
|
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable);
|
|
module.exports = {
|
|
EXISTS: EXISTS,
|
|
PROPER: PROPER,
|
|
CONFIGURABLE: CONFIGURABLE
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6028:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var from = __webpack_require__(53110);
|
|
var checkCorrectnessOfIteration = __webpack_require__(14122);
|
|
var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function(iterable) {
|
|
// eslint-disable-next-line es/no-array-from -- required for testing
|
|
Array.from(iterable);
|
|
});
|
|
// `Array.from` method
|
|
// https://tc39.es/ecma262/#sec-array.from
|
|
$({
|
|
target: 'Array',
|
|
stat: true,
|
|
forced: INCORRECT_ITERATION
|
|
}, {
|
|
from: from
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7557:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
module.exports = globalThis;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7796:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
__webpack_require__(90014);
|
|
var entryUnbind = __webpack_require__(54393);
|
|
module.exports = entryUnbind('Array', 'findIndex');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8465:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
var $String = String;
|
|
module.exports = function(argument) {
|
|
try {
|
|
return $String(argument);
|
|
} catch (error) {
|
|
return 'Object';
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9236:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(26919);
|
|
var isCallable = __webpack_require__(14595);
|
|
var isObject = __webpack_require__(78144);
|
|
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");
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9475:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var IE8_DOM_DEFINE = __webpack_require__(64959);
|
|
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(32624);
|
|
var anObject = __webpack_require__(30941);
|
|
var toPropertyKey = __webpack_require__(72543);
|
|
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) {}
|
|
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
|
|
if ('value' in Attributes) O[P] = Attributes.value;
|
|
return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10393:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var call = __webpack_require__(26919);
|
|
var propertyIsEnumerableModule = __webpack_require__(23043);
|
|
var createPropertyDescriptor = __webpack_require__(63458);
|
|
var toIndexedObject = __webpack_require__(83511);
|
|
var toPropertyKey = __webpack_require__(72543);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var IE8_DOM_DEFINE = __webpack_require__(64959);
|
|
// 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) {}
|
|
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10764:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIntegerOrInfinity = __webpack_require__(79893);
|
|
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
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10845:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineProperty = (__webpack_require__(9475).f);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
module.exports = function(target, TAG, STATIC) {
|
|
if (target && !STATIC) target = target.prototype;
|
|
if (target && !hasOwn(target, TO_STRING_TAG)) {
|
|
defineProperty(target, TO_STRING_TAG, {
|
|
configurable: true,
|
|
value: TAG
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10990:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
// This file can be required in Browserify and Node.js for automatic polyfill
|
|
// To use it: require('es6-promise/auto');
|
|
|
|
module.exports = (__webpack_require__(29100).polyfill)();
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 12057:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var setToStringTag = __webpack_require__(10845);
|
|
// JSON[@@toStringTag] property
|
|
// https://tc39.es/ecma262/#sec-json-@@tostringtag
|
|
setToStringTag(globalThis.JSON, 'JSON', true);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 13181:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classof = __webpack_require__(20233);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 13450:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
module.exports = uncurryThis([].slice);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 14122:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var SAFE_CLOSING = false;
|
|
try {
|
|
var called = 0;
|
|
var iteratorWithReturn = {
|
|
next: function next() {
|
|
return {
|
|
done: !!called++
|
|
};
|
|
},
|
|
'return': function() {
|
|
SAFE_CLOSING = true;
|
|
}
|
|
};
|
|
iteratorWithReturn[ITERATOR] = function() {
|
|
return this;
|
|
};
|
|
// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
|
|
Array.from(iteratorWithReturn, function() {
|
|
throw 2;
|
|
});
|
|
} catch (error) {}
|
|
module.exports = function(exec, SKIP_CLOSING) {
|
|
try {
|
|
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
|
|
} catch (error) {
|
|
return false;
|
|
} // workaround of old WebKit + `eval` bug
|
|
var ITERATION_SUPPORT = false;
|
|
try {
|
|
var object = {};
|
|
object[ITERATOR] = function() {
|
|
return {
|
|
next: function next() {
|
|
return {
|
|
done: ITERATION_SUPPORT = true
|
|
};
|
|
}
|
|
};
|
|
};
|
|
exec(object);
|
|
} catch (error) {}
|
|
return ITERATION_SUPPORT;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 14595:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
|
|
var documentAll = (typeof document === "undefined" ? "undefined" : _type_of(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';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 15447:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var isArray = __webpack_require__(40554);
|
|
var isCallable = __webpack_require__(14595);
|
|
var classof = __webpack_require__(66310);
|
|
var toString = __webpack_require__(13181);
|
|
var push = uncurryThis([].push);
|
|
module.exports = 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;
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 15526:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var definePropertyModule = __webpack_require__(9475);
|
|
var createPropertyDescriptor = __webpack_require__(63458);
|
|
module.exports = function(object, key, value) {
|
|
if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
|
|
else object[key] = value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 16719:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(32624);
|
|
var definePropertyModule = __webpack_require__(9475);
|
|
var anObject = __webpack_require__(30941);
|
|
var toIndexedObject = __webpack_require__(83511);
|
|
var objectKeys = __webpack_require__(77298);
|
|
// `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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 17158:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(96673);
|
|
// 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 get() {
|
|
return 7;
|
|
}
|
|
})[1] !== 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 18316:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
/* eslint-disable es/no-object-getownpropertynames -- safe */ var classof = __webpack_require__(66310);
|
|
var toIndexedObject = __webpack_require__(83511);
|
|
var $getOwnPropertyNames = (__webpack_require__(63838).f);
|
|
var arraySlice = __webpack_require__(13450);
|
|
var windowNames = (typeof window === "undefined" ? "undefined" : _type_of(window)) == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
|
|
var getWindowNames = function getWindowNames(it) {
|
|
try {
|
|
return $getOwnPropertyNames(it);
|
|
} catch (error) {
|
|
return arraySlice(windowNames);
|
|
}
|
|
};
|
|
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
|
|
module.exports.f = function getOwnPropertyNames(it) {
|
|
return windowNames && classof(it) === 'Window' ? getWindowNames(it) : $getOwnPropertyNames(toIndexedObject(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 18818:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 19192:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var IteratorPrototype = (__webpack_require__(96371).IteratorPrototype);
|
|
var create = __webpack_require__(99746);
|
|
var createPropertyDescriptor = __webpack_require__(63458);
|
|
var setToStringTag = __webpack_require__(10845);
|
|
var Iterators = __webpack_require__(84543);
|
|
var returnThis = function returnThis() {
|
|
return this;
|
|
};
|
|
module.exports = function(IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
|
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
IteratorConstructor.prototype = create(IteratorPrototype, {
|
|
next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next)
|
|
});
|
|
setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
|
|
Iterators[TO_STRING_TAG] = returnThis;
|
|
return IteratorConstructor;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20037:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
exports.f = wellKnownSymbol;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20233:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var TO_STRING_TAG_SUPPORT = __webpack_require__(82138);
|
|
var isCallable = __webpack_require__(14595);
|
|
var classofRaw = __webpack_require__(66310);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
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 tryGet(it, key) {
|
|
try {
|
|
return it[key];
|
|
} catch (error) {}
|
|
};
|
|
// 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' : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20998:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var call = __webpack_require__(26919);
|
|
var IS_PURE = __webpack_require__(22445);
|
|
var FunctionName = __webpack_require__(5944);
|
|
var isCallable = __webpack_require__(14595);
|
|
var createIteratorConstructor = __webpack_require__(19192);
|
|
var getPrototypeOf = __webpack_require__(88597);
|
|
var setPrototypeOf = __webpack_require__(28329);
|
|
var setToStringTag = __webpack_require__(10845);
|
|
var createNonEnumerableProperty = __webpack_require__(59541);
|
|
var defineBuiltIn = __webpack_require__(27714);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var Iterators = __webpack_require__(84543);
|
|
var IteratorsCore = __webpack_require__(96371);
|
|
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
|
|
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
|
|
var IteratorPrototype = IteratorsCore.IteratorPrototype;
|
|
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var KEYS = 'keys';
|
|
var VALUES = 'values';
|
|
var ENTRIES = 'entries';
|
|
var returnThis = function returnThis() {
|
|
return this;
|
|
};
|
|
module.exports = function(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
|
|
createIteratorConstructor(IteratorConstructor, NAME, next);
|
|
var getIterationMethod = function getIterationMethod(KIND) {
|
|
if (KIND === DEFAULT && defaultIterator) return defaultIterator;
|
|
if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
|
|
switch(KIND){
|
|
case KEYS:
|
|
return function keys() {
|
|
return new IteratorConstructor(this, KIND);
|
|
};
|
|
case VALUES:
|
|
return function values() {
|
|
return new IteratorConstructor(this, KIND);
|
|
};
|
|
case ENTRIES:
|
|
return function entries() {
|
|
return new IteratorConstructor(this, KIND);
|
|
};
|
|
}
|
|
return function() {
|
|
return new IteratorConstructor(this);
|
|
};
|
|
};
|
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
var INCORRECT_VALUES_NAME = false;
|
|
var IterablePrototype = Iterable.prototype;
|
|
var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype['@@iterator'] || DEFAULT && IterablePrototype[DEFAULT];
|
|
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
|
|
var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
|
|
var CurrentIteratorPrototype, methods, KEY;
|
|
// fix native
|
|
if (anyNativeIterator) {
|
|
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
|
|
if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
|
|
if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
|
if (setPrototypeOf) {
|
|
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
|
|
} else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {
|
|
defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);
|
|
}
|
|
}
|
|
// Set @@toStringTag to native iterators
|
|
setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
|
|
if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
|
|
}
|
|
}
|
|
// fix Array.prototype.{ values, @@iterator }.name in V8 / FF
|
|
if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {
|
|
createNonEnumerableProperty(IterablePrototype, 'name', VALUES);
|
|
} else {
|
|
INCORRECT_VALUES_NAME = true;
|
|
defaultIterator = function values() {
|
|
return call(nativeIterator, this);
|
|
};
|
|
}
|
|
}
|
|
// export additional methods
|
|
if (DEFAULT) {
|
|
methods = {
|
|
values: getIterationMethod(VALUES),
|
|
keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
|
|
entries: getIterationMethod(ENTRIES)
|
|
};
|
|
if (FORCED) for(KEY in methods){
|
|
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
|
|
defineBuiltIn(IterablePrototype, KEY, methods[KEY]);
|
|
}
|
|
}
|
|
else $({
|
|
target: NAME,
|
|
proto: true,
|
|
forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME
|
|
}, methods);
|
|
}
|
|
// define iterator
|
|
if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
|
|
defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, {
|
|
name: DEFAULT
|
|
});
|
|
}
|
|
Iterators[NAME] = defaultIterator;
|
|
return methods;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 22367:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.split` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.split
|
|
defineWellKnownSymbol('split');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 22445:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = false;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 23043:
|
|
/***/ (function(__unused_webpack_module, exports) {
|
|
|
|
"use strict";
|
|
|
|
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;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 23359:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.replace` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.replace
|
|
defineWellKnownSymbol('replace');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 23832:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toLength = __webpack_require__(10764);
|
|
// `LengthOfArrayLike` abstract operation
|
|
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
|
module.exports = function(obj) {
|
|
return toLength(obj.length);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 24503:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isObject = __webpack_require__(78144);
|
|
module.exports = function(argument) {
|
|
return isObject(argument) || argument === null;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 24661:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
// `Symbol.prototype.description` getter
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype.description
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var globalThis = __webpack_require__(75058);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var isCallable = __webpack_require__(14595);
|
|
var isPrototypeOf = __webpack_require__(56167);
|
|
var toString = __webpack_require__(13181);
|
|
var defineBuiltInAccessor = __webpack_require__(66416);
|
|
var copyConstructorProperties = __webpack_require__(2958);
|
|
var NativeSymbol = globalThis.Symbol;
|
|
var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
|
|
if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) || // Safari 12 bug
|
|
NativeSymbol().description !== undefined)) {
|
|
var EmptyStringDescriptionStore = {};
|
|
// wrap Symbol constructor for correct work with undefined description
|
|
var SymbolWrapper = function Symbol() {
|
|
var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]);
|
|
var result = isPrototypeOf(SymbolPrototype, this) ? new NativeSymbol(description) : description === undefined ? NativeSymbol() : NativeSymbol(description);
|
|
if (description === '') EmptyStringDescriptionStore[result] = true;
|
|
return result;
|
|
};
|
|
copyConstructorProperties(SymbolWrapper, NativeSymbol);
|
|
SymbolWrapper.prototype = SymbolPrototype;
|
|
SymbolPrototype.constructor = SymbolWrapper;
|
|
var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)';
|
|
var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf);
|
|
var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString);
|
|
var regexp = /^Symbol\((.*)\)[^)]+$/;
|
|
var replace = uncurryThis(''.replace);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
defineBuiltInAccessor(SymbolPrototype, 'description', {
|
|
configurable: true,
|
|
get: function description() {
|
|
var symbol = thisSymbolValue(this);
|
|
if (hasOwn(EmptyStringDescriptionStore, symbol)) return '';
|
|
var string = symbolDescriptiveString(symbol);
|
|
var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1');
|
|
return desc === '' ? undefined : desc;
|
|
}
|
|
});
|
|
$({
|
|
global: true,
|
|
constructor: true,
|
|
forced: true
|
|
}, {
|
|
Symbol: SymbolWrapper
|
|
});
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 24784:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var apply = __webpack_require__(90003);
|
|
var call = __webpack_require__(26919);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var fails = __webpack_require__(96673);
|
|
var isCallable = __webpack_require__(14595);
|
|
var isSymbol = __webpack_require__(71975);
|
|
var arraySlice = __webpack_require__(13450);
|
|
var getReplacerFunction = __webpack_require__(15447);
|
|
var NATIVE_SYMBOL = __webpack_require__(74693);
|
|
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 numberToString = uncurryThis(1.1.toString);
|
|
var tester = /[\uD800-\uDFFF]/g;
|
|
var low = /^[\uD800-\uDBFF]$/;
|
|
var hi = /^[\uDC00-\uDFFF]$/;
|
|
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]' || $stringify({
|
|
a: symbol
|
|
}) !== '{}' || $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 stringifyWithSymbolsFix = function stringifyWithSymbolsFix(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);
|
|
};
|
|
var fixIllFormed = function fixIllFormed(match, offset, string) {
|
|
var prev = charAt(string, offset - 1);
|
|
var next = charAt(string, offset + 1);
|
|
if (exec(low, match) && !exec(hi, next) || exec(hi, match) && !exec(low, prev)) {
|
|
return '\\u' + numberToString(charCodeAt(match, 0), 16);
|
|
}
|
|
return match;
|
|
};
|
|
if ($stringify) {
|
|
// `JSON.stringify` method
|
|
// https://tc39.es/ecma262/#sec-json.stringify
|
|
$({
|
|
target: 'JSON',
|
|
stat: true,
|
|
arity: 3,
|
|
forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE
|
|
}, {
|
|
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
stringify: function stringify(it, replacer, space) {
|
|
var args = arraySlice(arguments);
|
|
var result = apply(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
|
|
return ILL_FORMED_UNICODE && typeof result == 'string' ? replace(result, tester, fixIllFormed) : result;
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 24877:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// IE8- don't enum bug keys
|
|
module.exports = [
|
|
'constructor',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'toLocaleString',
|
|
'toString',
|
|
'valueOf'
|
|
];
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 26419:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var toObject = __webpack_require__(30995);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 26494:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.isConcatSpreadable` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.isconcatspreadable
|
|
defineWellKnownSymbol('isConcatSpreadable');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 26919:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_BIND = __webpack_require__(37770);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27491:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.search` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.search
|
|
defineWellKnownSymbol('search');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27714:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isCallable = __webpack_require__(14595);
|
|
var definePropertyModule = __webpack_require__(9475);
|
|
var makeBuiltIn = __webpack_require__(55425);
|
|
var defineGlobalProperty = __webpack_require__(36759);
|
|
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) {}
|
|
if (simple) O[key] = value;
|
|
else definePropertyModule.f(O, key, {
|
|
value: value,
|
|
enumerable: false,
|
|
configurable: !options.nonConfigurable,
|
|
writable: !options.nonWritable
|
|
});
|
|
}
|
|
return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 28329:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _instanceof(left, right) {
|
|
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
|
return !!right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
}
|
|
/* eslint-disable no-proto -- safe */ var uncurryThisAccessor = __webpack_require__(60288);
|
|
var isObject = __webpack_require__(78144);
|
|
var requireObjectCoercible = __webpack_require__(93080);
|
|
var aPossiblePrototype = __webpack_require__(34980);
|
|
// `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 = _instanceof(test, Array);
|
|
} catch (error) {}
|
|
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);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 28360:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(26919);
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var defineBuiltIn = __webpack_require__(27714);
|
|
module.exports = function() {
|
|
var Symbol = getBuiltIn('Symbol');
|
|
var SymbolPrototype = Symbol && Symbol.prototype;
|
|
var valueOf = SymbolPrototype && SymbolPrototype.valueOf;
|
|
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
|
|
if (SymbolPrototype && !SymbolPrototype[TO_PRIMITIVE]) {
|
|
// `Symbol.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
|
|
// eslint-disable-next-line no-unused-vars -- required for .length
|
|
defineBuiltIn(SymbolPrototype, TO_PRIMITIVE, function(hint) {
|
|
return call(valueOf, this);
|
|
}, {
|
|
arity: 1
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 29100:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;function _instanceof(left, right) {
|
|
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
|
return !!right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
}
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
/*!
|
|
* @overview es6-promise - a tiny implementation of Promises/A+.
|
|
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
|
|
* @license Licensed under MIT license
|
|
* See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
|
|
* @version v4.2.8+1e68dce6
|
|
*/ (function(global1, factory) {
|
|
( false ? 0 : _type_of(exports)) === 'object' && "object" !== 'undefined' ? module.exports = factory() : true ? !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
|
|
(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
|
|
__WEBPACK_AMD_DEFINE_FACTORY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : 0;
|
|
})(this, function() {
|
|
'use strict';
|
|
function objectOrFunction(x) {
|
|
var type = typeof x === "undefined" ? "undefined" : _type_of(x);
|
|
return x !== null && (type === 'object' || type === 'function');
|
|
}
|
|
function isFunction(x) {
|
|
return typeof x === 'function';
|
|
}
|
|
var _isArray = void 0;
|
|
if (Array.isArray) {
|
|
_isArray = Array.isArray;
|
|
} else {
|
|
_isArray = function _isArray(x) {
|
|
return Object.prototype.toString.call(x) === '[object Array]';
|
|
};
|
|
}
|
|
var isArray = _isArray;
|
|
var len = 0;
|
|
var vertxNext = void 0;
|
|
var customSchedulerFn = void 0;
|
|
var asap = function asap(callback, arg) {
|
|
queue[len] = callback;
|
|
queue[len + 1] = arg;
|
|
len += 2;
|
|
if (len === 2) {
|
|
// If len is 2, that means that we need to schedule an async flush.
|
|
// If additional callbacks are queued before the queue is flushed, they
|
|
// will be processed by this flush that we are scheduling.
|
|
if (customSchedulerFn) {
|
|
customSchedulerFn(flush);
|
|
} else {
|
|
scheduleFlush();
|
|
}
|
|
}
|
|
};
|
|
function setScheduler(scheduleFn) {
|
|
customSchedulerFn = scheduleFn;
|
|
}
|
|
function setAsap(asapFn) {
|
|
asap = asapFn;
|
|
}
|
|
var browserWindow = typeof window !== 'undefined' ? window : undefined;
|
|
var browserGlobal = browserWindow || {};
|
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
|
var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && ({}).toString.call(process) === '[object process]';
|
|
// test for web worker but not in IE10
|
|
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
|
|
// node
|
|
function useNextTick() {
|
|
// node version 0.10.x displays a deprecation warning when nextTick is used recursively
|
|
// see https://github.com/cujojs/when/issues/410 for details
|
|
return function() {
|
|
return process.nextTick(flush);
|
|
};
|
|
}
|
|
// vertx
|
|
function useVertxTimer() {
|
|
if (typeof vertxNext !== 'undefined') {
|
|
return function() {
|
|
vertxNext(flush);
|
|
};
|
|
}
|
|
return useSetTimeout();
|
|
}
|
|
function useMutationObserver() {
|
|
var iterations = 0;
|
|
var observer = new BrowserMutationObserver(flush);
|
|
var node = document.createTextNode('');
|
|
observer.observe(node, {
|
|
characterData: true
|
|
});
|
|
return function() {
|
|
node.data = iterations = ++iterations % 2;
|
|
};
|
|
}
|
|
// web worker
|
|
function useMessageChannel() {
|
|
var channel = new MessageChannel();
|
|
channel.port1.onmessage = flush;
|
|
return function() {
|
|
return channel.port2.postMessage(0);
|
|
};
|
|
}
|
|
function useSetTimeout() {
|
|
// Store setTimeout reference so es6-promise will be unaffected by
|
|
// other code modifying setTimeout (like sinon.useFakeTimers())
|
|
var globalSetTimeout = setTimeout;
|
|
return function() {
|
|
return globalSetTimeout(flush, 1);
|
|
};
|
|
}
|
|
var queue = new Array(1000);
|
|
function flush() {
|
|
for(var i = 0; i < len; i += 2){
|
|
var callback = queue[i];
|
|
var arg = queue[i + 1];
|
|
callback(arg);
|
|
queue[i] = undefined;
|
|
queue[i + 1] = undefined;
|
|
}
|
|
len = 0;
|
|
}
|
|
function attemptVertx() {
|
|
try {
|
|
var vertx = Function('return this')().require('vertx');
|
|
vertxNext = vertx.runOnLoop || vertx.runOnContext;
|
|
return useVertxTimer();
|
|
} catch (e) {
|
|
return useSetTimeout();
|
|
}
|
|
}
|
|
var scheduleFlush = void 0;
|
|
// Decide what async method to use to triggering processing of queued callbacks:
|
|
if (isNode) {
|
|
scheduleFlush = useNextTick();
|
|
} else if (BrowserMutationObserver) {
|
|
scheduleFlush = useMutationObserver();
|
|
} else if (isWorker) {
|
|
scheduleFlush = useMessageChannel();
|
|
} else if (browserWindow === undefined && "function" === 'function') {
|
|
scheduleFlush = attemptVertx();
|
|
} else {
|
|
scheduleFlush = useSetTimeout();
|
|
}
|
|
function then(onFulfillment, onRejection) {
|
|
var parent = this;
|
|
var child = new this.constructor(noop);
|
|
if (child[PROMISE_ID] === undefined) {
|
|
makePromise(child);
|
|
}
|
|
var _state = parent._state;
|
|
if (_state) {
|
|
var callback = arguments[_state - 1];
|
|
asap(function() {
|
|
return invokeCallback(_state, child, callback, parent._result);
|
|
});
|
|
} else {
|
|
subscribe(parent, child, onFulfillment, onRejection);
|
|
}
|
|
return child;
|
|
}
|
|
/**
|
|
`Promise.resolve` returns a promise that will become resolved with the
|
|
passed `value`. It is shorthand for the following:
|
|
|
|
```javascript
|
|
let promise = new Promise(function(resolve, reject){
|
|
resolve(1);
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
let promise = Promise.resolve(1);
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
@method resolve
|
|
@static
|
|
@param {Any} value value that the returned promise will be resolved with
|
|
Useful for tooling.
|
|
@return {Promise} a promise that will become fulfilled with the given
|
|
`value`
|
|
*/ function resolve$1(object) {
|
|
/*jshint validthis:true */ var Constructor = this;
|
|
if (object && (typeof object === "undefined" ? "undefined" : _type_of(object)) === 'object' && object.constructor === Constructor) {
|
|
return object;
|
|
}
|
|
var promise = new Constructor(noop);
|
|
resolve(promise, object);
|
|
return promise;
|
|
}
|
|
var PROMISE_ID = Math.random().toString(36).substring(2);
|
|
function noop() {}
|
|
var PENDING = void 0;
|
|
var FULFILLED = 1;
|
|
var REJECTED = 2;
|
|
function selfFulfillment() {
|
|
return new TypeError("You cannot resolve a promise with itself");
|
|
}
|
|
function cannotReturnOwn() {
|
|
return new TypeError('A promises callback cannot return that same promise.');
|
|
}
|
|
function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
|
|
try {
|
|
then$$1.call(value, fulfillmentHandler, rejectionHandler);
|
|
} catch (e) {
|
|
return e;
|
|
}
|
|
}
|
|
function handleForeignThenable(promise, thenable, then$$1) {
|
|
asap(function(promise) {
|
|
var sealed = false;
|
|
var error = tryThen(then$$1, thenable, function(value) {
|
|
if (sealed) {
|
|
return;
|
|
}
|
|
sealed = true;
|
|
if (thenable !== value) {
|
|
resolve(promise, value);
|
|
} else {
|
|
fulfill(promise, value);
|
|
}
|
|
}, function(reason) {
|
|
if (sealed) {
|
|
return;
|
|
}
|
|
sealed = true;
|
|
reject(promise, reason);
|
|
}, 'Settle: ' + (promise._label || ' unknown promise'));
|
|
if (!sealed && error) {
|
|
sealed = true;
|
|
reject(promise, error);
|
|
}
|
|
}, promise);
|
|
}
|
|
function handleOwnThenable(promise, thenable) {
|
|
if (thenable._state === FULFILLED) {
|
|
fulfill(promise, thenable._result);
|
|
} else if (thenable._state === REJECTED) {
|
|
reject(promise, thenable._result);
|
|
} else {
|
|
subscribe(thenable, undefined, function(value) {
|
|
return resolve(promise, value);
|
|
}, function(reason) {
|
|
return reject(promise, reason);
|
|
});
|
|
}
|
|
}
|
|
function handleMaybeThenable(promise, maybeThenable, then$$1) {
|
|
if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
|
|
handleOwnThenable(promise, maybeThenable);
|
|
} else {
|
|
if (then$$1 === undefined) {
|
|
fulfill(promise, maybeThenable);
|
|
} else if (isFunction(then$$1)) {
|
|
handleForeignThenable(promise, maybeThenable, then$$1);
|
|
} else {
|
|
fulfill(promise, maybeThenable);
|
|
}
|
|
}
|
|
}
|
|
function resolve(promise, value) {
|
|
if (promise === value) {
|
|
reject(promise, selfFulfillment());
|
|
} else if (objectOrFunction(value)) {
|
|
var then$$1 = void 0;
|
|
try {
|
|
then$$1 = value.then;
|
|
} catch (error) {
|
|
reject(promise, error);
|
|
return;
|
|
}
|
|
handleMaybeThenable(promise, value, then$$1);
|
|
} else {
|
|
fulfill(promise, value);
|
|
}
|
|
}
|
|
function publishRejection(promise) {
|
|
if (promise._onerror) {
|
|
promise._onerror(promise._result);
|
|
}
|
|
publish(promise);
|
|
}
|
|
function fulfill(promise, value) {
|
|
if (promise._state !== PENDING) {
|
|
return;
|
|
}
|
|
promise._result = value;
|
|
promise._state = FULFILLED;
|
|
if (promise._subscribers.length !== 0) {
|
|
asap(publish, promise);
|
|
}
|
|
}
|
|
function reject(promise, reason) {
|
|
if (promise._state !== PENDING) {
|
|
return;
|
|
}
|
|
promise._state = REJECTED;
|
|
promise._result = reason;
|
|
asap(publishRejection, promise);
|
|
}
|
|
function subscribe(parent, child, onFulfillment, onRejection) {
|
|
var _subscribers = parent._subscribers;
|
|
var length = _subscribers.length;
|
|
parent._onerror = null;
|
|
_subscribers[length] = child;
|
|
_subscribers[length + FULFILLED] = onFulfillment;
|
|
_subscribers[length + REJECTED] = onRejection;
|
|
if (length === 0 && parent._state) {
|
|
asap(publish, parent);
|
|
}
|
|
}
|
|
function publish(promise) {
|
|
var subscribers = promise._subscribers;
|
|
var settled = promise._state;
|
|
if (subscribers.length === 0) {
|
|
return;
|
|
}
|
|
var child = void 0, callback = void 0, detail = promise._result;
|
|
for(var i = 0; i < subscribers.length; i += 3){
|
|
child = subscribers[i];
|
|
callback = subscribers[i + settled];
|
|
if (child) {
|
|
invokeCallback(settled, child, callback, detail);
|
|
} else {
|
|
callback(detail);
|
|
}
|
|
}
|
|
promise._subscribers.length = 0;
|
|
}
|
|
function invokeCallback(settled, promise, callback, detail) {
|
|
var hasCallback = isFunction(callback), value = void 0, error = void 0, succeeded = true;
|
|
if (hasCallback) {
|
|
try {
|
|
value = callback(detail);
|
|
} catch (e) {
|
|
succeeded = false;
|
|
error = e;
|
|
}
|
|
if (promise === value) {
|
|
reject(promise, cannotReturnOwn());
|
|
return;
|
|
}
|
|
} else {
|
|
value = detail;
|
|
}
|
|
if (promise._state !== PENDING) {
|
|
// noop
|
|
} else if (hasCallback && succeeded) {
|
|
resolve(promise, value);
|
|
} else if (succeeded === false) {
|
|
reject(promise, error);
|
|
} else if (settled === FULFILLED) {
|
|
fulfill(promise, value);
|
|
} else if (settled === REJECTED) {
|
|
reject(promise, value);
|
|
}
|
|
}
|
|
function initializePromise(promise, resolver) {
|
|
try {
|
|
resolver(function resolvePromise(value) {
|
|
resolve(promise, value);
|
|
}, function rejectPromise(reason) {
|
|
reject(promise, reason);
|
|
});
|
|
} catch (e) {
|
|
reject(promise, e);
|
|
}
|
|
}
|
|
var id = 0;
|
|
function nextId() {
|
|
return id++;
|
|
}
|
|
function makePromise(promise) {
|
|
promise[PROMISE_ID] = id++;
|
|
promise._state = undefined;
|
|
promise._result = undefined;
|
|
promise._subscribers = [];
|
|
}
|
|
function validationError() {
|
|
return new Error('Array Methods must be provided an Array');
|
|
}
|
|
var Enumerator = function() {
|
|
function Enumerator(Constructor, input) {
|
|
this._instanceConstructor = Constructor;
|
|
this.promise = new Constructor(noop);
|
|
if (!this.promise[PROMISE_ID]) {
|
|
makePromise(this.promise);
|
|
}
|
|
if (isArray(input)) {
|
|
this.length = input.length;
|
|
this._remaining = input.length;
|
|
this._result = new Array(this.length);
|
|
if (this.length === 0) {
|
|
fulfill(this.promise, this._result);
|
|
} else {
|
|
this.length = this.length || 0;
|
|
this._enumerate(input);
|
|
if (this._remaining === 0) {
|
|
fulfill(this.promise, this._result);
|
|
}
|
|
}
|
|
} else {
|
|
reject(this.promise, validationError());
|
|
}
|
|
}
|
|
Enumerator.prototype._enumerate = function _enumerate(input) {
|
|
for(var i = 0; this._state === PENDING && i < input.length; i++){
|
|
this._eachEntry(input[i], i);
|
|
}
|
|
};
|
|
Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
|
|
var c = this._instanceConstructor;
|
|
var resolve$$1 = c.resolve;
|
|
if (resolve$$1 === resolve$1) {
|
|
var _then = void 0;
|
|
var error = void 0;
|
|
var didError = false;
|
|
try {
|
|
_then = entry.then;
|
|
} catch (e) {
|
|
didError = true;
|
|
error = e;
|
|
}
|
|
if (_then === then && entry._state !== PENDING) {
|
|
this._settledAt(entry._state, i, entry._result);
|
|
} else if (typeof _then !== 'function') {
|
|
this._remaining--;
|
|
this._result[i] = entry;
|
|
} else if (c === Promise$1) {
|
|
var promise = new c(noop);
|
|
if (didError) {
|
|
reject(promise, error);
|
|
} else {
|
|
handleMaybeThenable(promise, entry, _then);
|
|
}
|
|
this._willSettleAt(promise, i);
|
|
} else {
|
|
this._willSettleAt(new c(function(resolve$$1) {
|
|
return resolve$$1(entry);
|
|
}), i);
|
|
}
|
|
} else {
|
|
this._willSettleAt(resolve$$1(entry), i);
|
|
}
|
|
};
|
|
Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
|
|
var promise = this.promise;
|
|
if (promise._state === PENDING) {
|
|
this._remaining--;
|
|
if (state === REJECTED) {
|
|
reject(promise, value);
|
|
} else {
|
|
this._result[i] = value;
|
|
}
|
|
}
|
|
if (this._remaining === 0) {
|
|
fulfill(promise, this._result);
|
|
}
|
|
};
|
|
Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
|
|
var enumerator = this;
|
|
subscribe(promise, undefined, function(value) {
|
|
return enumerator._settledAt(FULFILLED, i, value);
|
|
}, function(reason) {
|
|
return enumerator._settledAt(REJECTED, i, reason);
|
|
});
|
|
};
|
|
return Enumerator;
|
|
}();
|
|
/**
|
|
`Promise.all` accepts an array of promises, and returns a new promise which
|
|
is fulfilled with an array of fulfillment values for the passed promises, or
|
|
rejected with the reason of the first passed promise to be rejected. It casts all
|
|
elements of the passed iterable to promises as it runs this algorithm.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = resolve(1);
|
|
let promise2 = resolve(2);
|
|
let promise3 = resolve(3);
|
|
let promises = [ promise1, promise2, promise3 ];
|
|
|
|
Promise.all(promises).then(function(array){
|
|
// The array here would be [ 1, 2, 3 ];
|
|
});
|
|
```
|
|
|
|
If any of the `promises` given to `all` are rejected, the first promise
|
|
that is rejected will be given as an argument to the returned promises's
|
|
rejection handler. For example:
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = resolve(1);
|
|
let promise2 = reject(new Error("2"));
|
|
let promise3 = reject(new Error("3"));
|
|
let promises = [ promise1, promise2, promise3 ];
|
|
|
|
Promise.all(promises).then(function(array){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(error) {
|
|
// error.message === "2"
|
|
});
|
|
```
|
|
|
|
@method all
|
|
@static
|
|
@param {Array} entries array of promises
|
|
@param {String} label optional string for labeling the promise.
|
|
Useful for tooling.
|
|
@return {Promise} promise that is fulfilled when all `promises` have been
|
|
fulfilled, or rejected if any of them become rejected.
|
|
@static
|
|
*/ function all(entries) {
|
|
return new Enumerator(this, entries).promise;
|
|
}
|
|
/**
|
|
`Promise.race` returns a new promise which is settled in the same way as the
|
|
first passed promise to settle.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
let promise1 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 1');
|
|
}, 200);
|
|
});
|
|
|
|
let promise2 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 2');
|
|
}, 100);
|
|
});
|
|
|
|
Promise.race([promise1, promise2]).then(function(result){
|
|
// result === 'promise 2' because it was resolved before promise1
|
|
// was resolved.
|
|
});
|
|
```
|
|
|
|
`Promise.race` is deterministic in that only the state of the first
|
|
settled promise matters. For example, even if other promises given to the
|
|
`promises` array argument are resolved, but the first settled promise has
|
|
become rejected before the other promises became fulfilled, the returned
|
|
promise will become rejected:
|
|
|
|
```javascript
|
|
let promise1 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve('promise 1');
|
|
}, 200);
|
|
});
|
|
|
|
let promise2 = new Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
reject(new Error('promise 2'));
|
|
}, 100);
|
|
});
|
|
|
|
Promise.race([promise1, promise2]).then(function(result){
|
|
// Code here never runs
|
|
}, function(reason){
|
|
// reason.message === 'promise 2' because promise 2 became rejected before
|
|
// promise 1 became fulfilled
|
|
});
|
|
```
|
|
|
|
An example real-world use case is implementing timeouts:
|
|
|
|
```javascript
|
|
Promise.race([ajax('foo.json'), timeout(5000)])
|
|
```
|
|
|
|
@method race
|
|
@static
|
|
@param {Array} promises array of promises to observe
|
|
Useful for tooling.
|
|
@return {Promise} a promise which settles in the same way as the first passed
|
|
promise to settle.
|
|
*/ function race(entries) {
|
|
/*jshint validthis:true */ var Constructor = this;
|
|
if (!isArray(entries)) {
|
|
return new Constructor(function(_, reject) {
|
|
return reject(new TypeError('You must pass an array to race.'));
|
|
});
|
|
} else {
|
|
return new Constructor(function(resolve, reject) {
|
|
var length = entries.length;
|
|
for(var i = 0; i < length; i++){
|
|
Constructor.resolve(entries[i]).then(resolve, reject);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
`Promise.reject` returns a promise rejected with the passed `reason`.
|
|
It is shorthand for the following:
|
|
|
|
```javascript
|
|
let promise = new Promise(function(resolve, reject){
|
|
reject(new Error('WHOOPS'));
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
let promise = Promise.reject(new Error('WHOOPS'));
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
@method reject
|
|
@static
|
|
@param {Any} reason value that the returned promise will be rejected with.
|
|
Useful for tooling.
|
|
@return {Promise} a promise rejected with the given `reason`.
|
|
*/ function reject$1(reason) {
|
|
/*jshint validthis:true */ var Constructor = this;
|
|
var promise = new Constructor(noop);
|
|
reject(promise, reason);
|
|
return promise;
|
|
}
|
|
function needsResolver() {
|
|
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
|
|
}
|
|
function needsNew() {
|
|
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
|
|
}
|
|
/**
|
|
Promise objects represent the eventual result of an asynchronous operation. The
|
|
primary way of interacting with a promise is through its `then` method, which
|
|
registers callbacks to receive either a promise's eventual value or the reason
|
|
why the promise cannot be fulfilled.
|
|
|
|
Terminology
|
|
-----------
|
|
|
|
- `promise` is an object or function with a `then` method whose behavior conforms to this specification.
|
|
- `thenable` is an object or function that defines a `then` method.
|
|
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
|
|
- `exception` is a value that is thrown using the throw statement.
|
|
- `reason` is a value that indicates why a promise was rejected.
|
|
- `settled` the final resting state of a promise, fulfilled or rejected.
|
|
|
|
A promise can be in one of three states: pending, fulfilled, or rejected.
|
|
|
|
Promises that are fulfilled have a fulfillment value and are in the fulfilled
|
|
state. Promises that are rejected have a rejection reason and are in the
|
|
rejected state. A fulfillment value is never a thenable.
|
|
|
|
Promises can also be said to *resolve* a value. If this value is also a
|
|
promise, then the original promise's settled state will match the value's
|
|
settled state. So a promise that *resolves* a promise that rejects will
|
|
itself reject, and a promise that *resolves* a promise that fulfills will
|
|
itself fulfill.
|
|
|
|
|
|
Basic Usage:
|
|
------------
|
|
|
|
```js
|
|
let promise = new Promise(function(resolve, reject) {
|
|
// on success
|
|
resolve(value);
|
|
|
|
// on failure
|
|
reject(reason);
|
|
});
|
|
|
|
promise.then(function(value) {
|
|
// on fulfillment
|
|
}, function(reason) {
|
|
// on rejection
|
|
});
|
|
```
|
|
|
|
Advanced Usage:
|
|
---------------
|
|
|
|
Promises shine when abstracting away asynchronous interactions such as
|
|
`XMLHttpRequest`s.
|
|
|
|
```js
|
|
function getJSON(url) {
|
|
return new Promise(function(resolve, reject){
|
|
let xhr = new XMLHttpRequest();
|
|
|
|
xhr.open('GET', url);
|
|
xhr.onreadystatechange = handler;
|
|
xhr.responseType = 'json';
|
|
xhr.setRequestHeader('Accept', 'application/json');
|
|
xhr.send();
|
|
|
|
function handler() {
|
|
if (this.readyState === this.DONE) {
|
|
if (this.status === 200) {
|
|
resolve(this.response);
|
|
} else {
|
|
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
|
|
}
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
getJSON('/posts.json').then(function(json) {
|
|
// on fulfillment
|
|
}, function(reason) {
|
|
// on rejection
|
|
});
|
|
```
|
|
|
|
Unlike callbacks, promises are great composable primitives.
|
|
|
|
```js
|
|
Promise.all([
|
|
getJSON('/posts'),
|
|
getJSON('/comments')
|
|
]).then(function(values){
|
|
values[0] // => postsJSON
|
|
values[1] // => commentsJSON
|
|
|
|
return values;
|
|
});
|
|
```
|
|
|
|
@class Promise
|
|
@param {Function} resolver
|
|
Useful for tooling.
|
|
@constructor
|
|
*/ var Promise$1 = function() {
|
|
function Promise(resolver) {
|
|
this[PROMISE_ID] = nextId();
|
|
this._result = this._state = undefined;
|
|
this._subscribers = [];
|
|
if (noop !== resolver) {
|
|
typeof resolver !== 'function' && needsResolver();
|
|
_instanceof(this, Promise) ? initializePromise(this, resolver) : needsNew();
|
|
}
|
|
}
|
|
/**
|
|
The primary way of interacting with a promise is through its `then` method,
|
|
which registers callbacks to receive either a promise's eventual value or the
|
|
reason why the promise cannot be fulfilled.
|
|
```js
|
|
findUser().then(function(user){
|
|
// user is available
|
|
}, function(reason){
|
|
// user is unavailable, and you are given the reason why
|
|
});
|
|
```
|
|
Chaining
|
|
--------
|
|
The return value of `then` is itself a promise. This second, 'downstream'
|
|
promise is resolved with the return value of the first promise's fulfillment
|
|
or rejection handler, or rejected if the handler throws an exception.
|
|
```js
|
|
findUser().then(function (user) {
|
|
return user.name;
|
|
}, function (reason) {
|
|
return 'default name';
|
|
}).then(function (userName) {
|
|
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
|
|
// will be `'default name'`
|
|
});
|
|
findUser().then(function (user) {
|
|
throw new Error('Found user, but still unhappy');
|
|
}, function (reason) {
|
|
throw new Error('`findUser` rejected and we're unhappy');
|
|
}).then(function (value) {
|
|
// never reached
|
|
}, function (reason) {
|
|
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
|
|
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
|
|
});
|
|
```
|
|
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
|
|
```js
|
|
findUser().then(function (user) {
|
|
throw new PedagogicalException('Upstream error');
|
|
}).then(function (value) {
|
|
// never reached
|
|
}).then(function (value) {
|
|
// never reached
|
|
}, function (reason) {
|
|
// The `PedgagocialException` is propagated all the way down to here
|
|
});
|
|
```
|
|
Assimilation
|
|
------------
|
|
Sometimes the value you want to propagate to a downstream promise can only be
|
|
retrieved asynchronously. This can be achieved by returning a promise in the
|
|
fulfillment or rejection handler. The downstream promise will then be pending
|
|
until the returned promise is settled. This is called *assimilation*.
|
|
```js
|
|
findUser().then(function (user) {
|
|
return findCommentsByAuthor(user);
|
|
}).then(function (comments) {
|
|
// The user's comments are now available
|
|
});
|
|
```
|
|
If the assimliated promise rejects, then the downstream promise will also reject.
|
|
```js
|
|
findUser().then(function (user) {
|
|
return findCommentsByAuthor(user);
|
|
}).then(function (comments) {
|
|
// If `findCommentsByAuthor` fulfills, we'll have the value here
|
|
}, function (reason) {
|
|
// If `findCommentsByAuthor` rejects, we'll have the reason here
|
|
});
|
|
```
|
|
Simple Example
|
|
--------------
|
|
Synchronous Example
|
|
```javascript
|
|
let result;
|
|
try {
|
|
result = findResult();
|
|
// success
|
|
} catch(reason) {
|
|
// failure
|
|
}
|
|
```
|
|
Errback Example
|
|
```js
|
|
findResult(function(result, err){
|
|
if (err) {
|
|
// failure
|
|
} else {
|
|
// success
|
|
}
|
|
});
|
|
```
|
|
Promise Example;
|
|
```javascript
|
|
findResult().then(function(result){
|
|
// success
|
|
}, function(reason){
|
|
// failure
|
|
});
|
|
```
|
|
Advanced Example
|
|
--------------
|
|
Synchronous Example
|
|
```javascript
|
|
let author, books;
|
|
try {
|
|
author = findAuthor();
|
|
books = findBooksByAuthor(author);
|
|
// success
|
|
} catch(reason) {
|
|
// failure
|
|
}
|
|
```
|
|
Errback Example
|
|
```js
|
|
function foundBooks(books) {
|
|
}
|
|
function failure(reason) {
|
|
}
|
|
findAuthor(function(author, err){
|
|
if (err) {
|
|
failure(err);
|
|
// failure
|
|
} else {
|
|
try {
|
|
findBoooksByAuthor(author, function(books, err) {
|
|
if (err) {
|
|
failure(err);
|
|
} else {
|
|
try {
|
|
foundBooks(books);
|
|
} catch(reason) {
|
|
failure(reason);
|
|
}
|
|
}
|
|
});
|
|
} catch(error) {
|
|
failure(err);
|
|
}
|
|
// success
|
|
}
|
|
});
|
|
```
|
|
Promise Example;
|
|
```javascript
|
|
findAuthor().
|
|
then(findBooksByAuthor).
|
|
then(function(books){
|
|
// found books
|
|
}).catch(function(reason){
|
|
// something went wrong
|
|
});
|
|
```
|
|
@method then
|
|
@param {Function} onFulfilled
|
|
@param {Function} onRejected
|
|
Useful for tooling.
|
|
@return {Promise}
|
|
*/ /**
|
|
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
|
|
as the catch block of a try/catch statement.
|
|
```js
|
|
function findAuthor(){
|
|
throw new Error('couldn't find that author');
|
|
}
|
|
// synchronous
|
|
try {
|
|
findAuthor();
|
|
} catch(reason) {
|
|
// something went wrong
|
|
}
|
|
// async with promises
|
|
findAuthor().catch(function(reason){
|
|
// something went wrong
|
|
});
|
|
```
|
|
@method catch
|
|
@param {Function} onRejection
|
|
Useful for tooling.
|
|
@return {Promise}
|
|
*/ Promise.prototype.catch = function _catch(onRejection) {
|
|
return this.then(null, onRejection);
|
|
};
|
|
/**
|
|
`finally` will be invoked regardless of the promise's fate just as native
|
|
try/catch/finally behaves
|
|
|
|
Synchronous example:
|
|
|
|
```js
|
|
findAuthor() {
|
|
if (Math.random() > 0.5) {
|
|
throw new Error();
|
|
}
|
|
return new Author();
|
|
}
|
|
|
|
try {
|
|
return findAuthor(); // succeed or fail
|
|
} catch(error) {
|
|
return findOtherAuther();
|
|
} finally {
|
|
// always runs
|
|
// doesn't affect the return value
|
|
}
|
|
```
|
|
|
|
Asynchronous example:
|
|
|
|
```js
|
|
findAuthor().catch(function(reason){
|
|
return findOtherAuther();
|
|
}).finally(function(){
|
|
// author was either found, or not
|
|
});
|
|
```
|
|
|
|
@method finally
|
|
@param {Function} callback
|
|
@return {Promise}
|
|
*/ Promise.prototype.finally = function _finally(callback) {
|
|
var promise = this;
|
|
var constructor = promise.constructor;
|
|
if (isFunction(callback)) {
|
|
return promise.then(function(value) {
|
|
return constructor.resolve(callback()).then(function() {
|
|
return value;
|
|
});
|
|
}, function(reason) {
|
|
return constructor.resolve(callback()).then(function() {
|
|
throw reason;
|
|
});
|
|
});
|
|
}
|
|
return promise.then(callback, callback);
|
|
};
|
|
return Promise;
|
|
}();
|
|
Promise$1.prototype.then = then;
|
|
Promise$1.all = all;
|
|
Promise$1.race = race;
|
|
Promise$1.resolve = resolve$1;
|
|
Promise$1.reject = reject$1;
|
|
Promise$1._setScheduler = setScheduler;
|
|
Promise$1._setAsap = setAsap;
|
|
Promise$1._asap = asap;
|
|
/*global self*/ function polyfill() {
|
|
var local = void 0;
|
|
if (typeof __webpack_require__.g !== 'undefined') {
|
|
local = __webpack_require__.g;
|
|
} else if (typeof self !== 'undefined') {
|
|
local = self;
|
|
} else {
|
|
try {
|
|
local = Function('return this')();
|
|
} catch (e) {
|
|
throw new Error('polyfill failed because global object is unavailable in this environment');
|
|
}
|
|
}
|
|
var P = local.Promise;
|
|
if (P) {
|
|
var promiseToString = null;
|
|
try {
|
|
promiseToString = Object.prototype.toString.call(P.resolve());
|
|
} catch (e) {
|
|
// silently ignored
|
|
}
|
|
if (promiseToString === '[object Promise]' && !P.cast) {
|
|
return;
|
|
}
|
|
}
|
|
local.Promise = Promise$1;
|
|
}
|
|
// Strange compat..
|
|
Promise$1.polyfill = polyfill;
|
|
Promise$1.Promise = Promise$1;
|
|
return Promise$1;
|
|
}); //# sourceMappingURL=es6-promise.map
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 29437:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var setToStringTag = __webpack_require__(10845);
|
|
// Math[@@toStringTag] property
|
|
// https://tc39.es/ecma262/#sec-math-@@tostringtag
|
|
setToStringTag(Math, 'Math', true);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 29833:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var isCallable = __webpack_require__(14595);
|
|
var aFunction = function aFunction(argument) {
|
|
return isCallable(argument) ? argument : undefined;
|
|
};
|
|
module.exports = function(namespace, method) {
|
|
return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 30941:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isObject = __webpack_require__(78144);
|
|
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');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 30995:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var requireObjectCoercible = __webpack_require__(93080);
|
|
var $Object = Object;
|
|
// `ToObject` abstract operation
|
|
// https://tc39.es/ecma262/#sec-toobject
|
|
module.exports = function(argument) {
|
|
return $Object(requireObjectCoercible(argument));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 31050:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_SYMBOL = __webpack_require__(74693);
|
|
/* eslint-disable es/no-symbol -- safe */ module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 31353:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var toIntegerOrInfinity = __webpack_require__(79893);
|
|
var toString = __webpack_require__(13181);
|
|
var requireObjectCoercible = __webpack_require__(93080);
|
|
var charAt = uncurryThis(''.charAt);
|
|
var charCodeAt = uncurryThis(''.charCodeAt);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
var createMethod = function createMethod(CONVERT_TO_STRING) {
|
|
return function($this, pos) {
|
|
var S = toString(requireObjectCoercible($this));
|
|
var position = toIntegerOrInfinity(pos);
|
|
var size = S.length;
|
|
var first, second;
|
|
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
|
|
first = charCodeAt(S, position);
|
|
return first < 0xD800 || first > 0xDBFF || position + 1 === size || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF ? CONVERT_TO_STRING ? charAt(S, position) : first : CONVERT_TO_STRING ? stringSlice(S, position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
|
|
};
|
|
};
|
|
module.exports = {
|
|
// `String.prototype.codePointAt` method
|
|
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
|
|
codeAt: createMethod(false),
|
|
// `String.prototype.at` method
|
|
// https://github.com/mathiasbynens/String.prototype.at
|
|
charAt: createMethod(true)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 32624:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var fails = __webpack_require__(96673);
|
|
// 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() {}, 'prototype', {
|
|
value: 42,
|
|
writable: false
|
|
}).prototype !== 42;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 34155:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_WEAK_MAP = __webpack_require__(97948);
|
|
var globalThis = __webpack_require__(75058);
|
|
var isObject = __webpack_require__(78144);
|
|
var createNonEnumerableProperty = __webpack_require__(59541);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var shared = __webpack_require__(49567);
|
|
var sharedKey = __webpack_require__(99353);
|
|
var hiddenKeys = __webpack_require__(38043);
|
|
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
|
var TypeError = globalThis.TypeError;
|
|
var WeakMap = globalThis.WeakMap;
|
|
var set, get, has;
|
|
var enforce = function enforce(it) {
|
|
return has(it) ? get(it) : set(it, {});
|
|
};
|
|
var getterFor = function getterFor(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 set(it, metadata) {
|
|
if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
store.set(it, metadata);
|
|
return metadata;
|
|
};
|
|
get = function get(it) {
|
|
return store.get(it) || {};
|
|
};
|
|
has = function has(it) {
|
|
return store.has(it);
|
|
};
|
|
} else {
|
|
var STATE = sharedKey('state');
|
|
hiddenKeys[STATE] = true;
|
|
set = function set(it, metadata) {
|
|
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
createNonEnumerableProperty(it, STATE, metadata);
|
|
return metadata;
|
|
};
|
|
get = function get(it) {
|
|
return hasOwn(it, STATE) ? it[STATE] : {};
|
|
};
|
|
has = function has(it) {
|
|
return hasOwn(it, STATE);
|
|
};
|
|
}
|
|
module.exports = {
|
|
set: set,
|
|
get: get,
|
|
has: has,
|
|
enforce: enforce,
|
|
getterFor: getterFor
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 34315:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(26919);
|
|
var isObject = __webpack_require__(78144);
|
|
var isSymbol = __webpack_require__(71975);
|
|
var getMethod = __webpack_require__(57996);
|
|
var ordinaryToPrimitive = __webpack_require__(9236);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 34980:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isPossiblePrototype = __webpack_require__(24503);
|
|
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');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 36446:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var toIndexedObject = __webpack_require__(83511);
|
|
var indexOf = (__webpack_require__(59299).indexOf);
|
|
var hiddenKeys = __webpack_require__(38043);
|
|
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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 36759:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
// 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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 37770:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(96673);
|
|
module.exports = !fails(function() {
|
|
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
|
var test = (function() {}).bind();
|
|
// eslint-disable-next-line no-prototype-builtins -- safe
|
|
return typeof test != 'function' || test.hasOwnProperty('prototype');
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 38043:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = {};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 40554:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classof = __webpack_require__(66310);
|
|
// `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';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 40891:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var NATIVE_SYMBOL = __webpack_require__(74693);
|
|
var fails = __webpack_require__(96673);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(93715);
|
|
var toObject = __webpack_require__(30995);
|
|
// V8 ~ Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
|
|
var FORCED = !NATIVE_SYMBOL || fails(function() {
|
|
getOwnPropertySymbolsModule.f(1);
|
|
});
|
|
// `Object.getOwnPropertySymbols` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertysymbols
|
|
$({
|
|
target: 'Object',
|
|
stat: true,
|
|
forced: FORCED
|
|
}, {
|
|
getOwnPropertySymbols: function getOwnPropertySymbols(it) {
|
|
var $getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return $getOwnPropertySymbols ? $getOwnPropertySymbols(toObject(it)) : [];
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 41890:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(96673);
|
|
var isCallable = __webpack_require__(14595);
|
|
var replacement = /#|\.prototype\./;
|
|
var isForced = function isForced(feature, detection) {
|
|
var value = data[normalize(feature)];
|
|
return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
|
|
};
|
|
var normalize = isForced.normalize = function normalize(string) {
|
|
return String(string).replace(replacement, '.').toLowerCase();
|
|
};
|
|
var data = isForced.data = {};
|
|
var NATIVE = isForced.NATIVE = 'N';
|
|
var POLYFILL = isForced.POLYFILL = 'P';
|
|
module.exports = isForced;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 41943:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// 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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 42695:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
var setToStringTag = __webpack_require__(10845);
|
|
// `Symbol.toStringTag` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.tostringtag
|
|
defineWellKnownSymbol('toStringTag');
|
|
// `Symbol.prototype[@@toStringTag]` property
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
|
|
setToStringTag(getBuiltIn('Symbol'), 'Symbol');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 43098:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
__webpack_require__(71093);
|
|
__webpack_require__(6028);
|
|
var path = __webpack_require__(7557);
|
|
module.exports = path.Array.from;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 43334:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
/* eslint-disable es/no-symbol -- required for testing */ var NATIVE_SYMBOL = __webpack_require__(74693);
|
|
module.exports = NATIVE_SYMBOL && !Symbol.sham && _type_of(Symbol.iterator) == 'symbol';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 43707:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
var defineProperty = (__webpack_require__(9475).f);
|
|
var getOwnPropertyDescriptor = (__webpack_require__(10393).f);
|
|
var Symbol = globalThis.Symbol;
|
|
// `Symbol.asyncDispose` well-known symbol
|
|
// https://github.com/tc39/proposal-async-explicit-resource-management
|
|
defineWellKnownSymbol('asyncDispose');
|
|
if (Symbol) {
|
|
var descriptor = getOwnPropertyDescriptor(Symbol, 'asyncDispose');
|
|
// workaround of NodeJS 20.4 bug
|
|
// https://github.com/nodejs/node/issues/48699
|
|
// and incorrect descriptor from some transpilers and userland helpers
|
|
if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
|
|
defineProperty(Symbol, 'asyncDispose', {
|
|
value: descriptor.value,
|
|
enumerable: false,
|
|
configurable: false,
|
|
writable: false
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 45797:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.iterator` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.iterator
|
|
defineWellKnownSymbol('iterator');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 46119:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var fails = __webpack_require__(96673);
|
|
var isCallable = __webpack_require__(14595);
|
|
var classof = __webpack_require__(20233);
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var inspectSource = __webpack_require__(69228);
|
|
var noop = function noop() {};
|
|
var construct = getBuiltIn('Reflect', 'construct');
|
|
var constructorRegExp = /^\s*(?:class|function)\b/;
|
|
var exec = uncurryThis(constructorRegExp.exec);
|
|
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
|
|
var isConstructorModern = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
try {
|
|
construct(noop, [], argument);
|
|
return true;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
};
|
|
var isConstructorLegacy = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
switch(classof(argument)){
|
|
case 'AsyncFunction':
|
|
case 'GeneratorFunction':
|
|
case 'AsyncGeneratorFunction':
|
|
return false;
|
|
}
|
|
try {
|
|
// we can't check .prototype since constructors produced by .bind haven't it
|
|
// `Function#toString` throws on some built-it function in some legacy engines
|
|
// (for example, `DOMQuad` and similar in FF41-)
|
|
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
isConstructorLegacy.sham = true;
|
|
// `IsConstructor` abstract operation
|
|
// https://tc39.es/ecma262/#sec-isconstructor
|
|
module.exports = !construct || fails(function() {
|
|
var called;
|
|
return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
|
|
called = true;
|
|
}) || called;
|
|
}) ? isConstructorLegacy : isConstructorModern;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 46738:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_BIND = __webpack_require__(37770);
|
|
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);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 49567:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var IS_PURE = __webpack_require__(22445);
|
|
var globalThis = __webpack_require__(75058);
|
|
var defineGlobalProperty = __webpack_require__(36759);
|
|
var SHARED = '__core-js_shared__';
|
|
var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
|
|
(store.versions || (store.versions = [])).push({
|
|
version: '3.46.0',
|
|
mode: IS_PURE ? 'pure' : 'global',
|
|
copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru), 2025 CoreJS Company (core-js.io)',
|
|
license: 'https://github.com/zloirock/core-js/blob/v3.46.0/LICENSE',
|
|
source: 'https://github.com/zloirock/core-js'
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 50112:
|
|
/***/ (function() {
|
|
|
|
/*
|
|
* classList.js: Cross-browser full element.classList implementation.
|
|
* 1.1.20170427
|
|
*
|
|
* By Eli Grey, http://eligrey.com
|
|
* License: Dedicated to the public domain.
|
|
* See https://github.com/eligrey/classList.js/blob/master/LICENSE.md
|
|
*/ /*global self, document, DOMException */ /*! @source http://purl.eligrey.com/github/classList.js/blob/master/classList.js */ if ("document" in window.self) {
|
|
// Full polyfill for browsers with no classList support
|
|
// Including IE < Edge missing SVGElement.classList
|
|
if (!("classList" in document.createElement("_")) || document.createElementNS && !("classList" in document.createElementNS("http://www.w3.org/2000/svg", "g"))) {
|
|
(function(view) {
|
|
"use strict";
|
|
if (!('Element' in view)) return;
|
|
var classListProp = "classList", protoProp = "prototype", elemCtrProto = view.Element[protoProp], objCtr = Object, strTrim = String[protoProp].trim || function() {
|
|
return this.replace(/^\s+|\s+$/g, "");
|
|
}, arrIndexOf = Array[protoProp].indexOf || function(item) {
|
|
var i = 0, len = this.length;
|
|
for(; i < len; i++){
|
|
if (i in this && this[i] === item) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}, DOMEx = function DOMEx(type, message) {
|
|
this.name = type;
|
|
this.code = DOMException[type];
|
|
this.message = message;
|
|
}, checkTokenAndGetIndex = function checkTokenAndGetIndex(classList, token) {
|
|
if (token === "") {
|
|
throw new DOMEx("SYNTAX_ERR", "An invalid or illegal string was specified");
|
|
}
|
|
if (/\s/.test(token)) {
|
|
throw new DOMEx("INVALID_CHARACTER_ERR", "String contains an invalid character");
|
|
}
|
|
return arrIndexOf.call(classList, token);
|
|
}, ClassList = function ClassList(elem) {
|
|
var trimmedClasses = strTrim.call(elem.getAttribute("class") || ""), classes = trimmedClasses ? trimmedClasses.split(/\s+/) : [], i = 0, len = classes.length;
|
|
for(; i < len; i++){
|
|
this.push(classes[i]);
|
|
}
|
|
this._updateClassName = function() {
|
|
elem.setAttribute("class", this.toString());
|
|
};
|
|
}, classListProto = ClassList[protoProp] = [], classListGetter = function classListGetter() {
|
|
return new ClassList(this);
|
|
};
|
|
// Most DOMException implementations don't allow calling DOMException's toString()
|
|
// on non-DOMExceptions. Error's toString() is sufficient here.
|
|
DOMEx[protoProp] = Error[protoProp];
|
|
classListProto.item = function(i) {
|
|
return this[i] || null;
|
|
};
|
|
classListProto.contains = function(token) {
|
|
token += "";
|
|
return checkTokenAndGetIndex(this, token) !== -1;
|
|
};
|
|
classListProto.add = function() {
|
|
var tokens = arguments, i = 0, l = tokens.length, token, updated = false;
|
|
do {
|
|
token = tokens[i] + "";
|
|
if (checkTokenAndGetIndex(this, token) === -1) {
|
|
this.push(token);
|
|
updated = true;
|
|
}
|
|
}while (++i < l);
|
|
if (updated) {
|
|
this._updateClassName();
|
|
}
|
|
};
|
|
classListProto.remove = function() {
|
|
var tokens = arguments, i = 0, l = tokens.length, token, updated = false, index;
|
|
do {
|
|
token = tokens[i] + "";
|
|
index = checkTokenAndGetIndex(this, token);
|
|
while(index !== -1){
|
|
this.splice(index, 1);
|
|
updated = true;
|
|
index = checkTokenAndGetIndex(this, token);
|
|
}
|
|
}while (++i < l);
|
|
if (updated) {
|
|
this._updateClassName();
|
|
}
|
|
};
|
|
classListProto.toggle = function(token, force) {
|
|
token += "";
|
|
var result = this.contains(token), method = result ? force !== true && "remove" : force !== false && "add";
|
|
if (method) {
|
|
this[method](token);
|
|
}
|
|
if (force === true || force === false) {
|
|
return force;
|
|
} else {
|
|
return !result;
|
|
}
|
|
};
|
|
classListProto.toString = function() {
|
|
return this.join(" ");
|
|
};
|
|
if (objCtr.defineProperty) {
|
|
var classListPropDesc = {
|
|
get: classListGetter,
|
|
enumerable: true,
|
|
configurable: true
|
|
};
|
|
try {
|
|
objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);
|
|
} catch (ex) {
|
|
// adding undefined to fight this issue https://github.com/eligrey/classList.js/issues/36
|
|
// modernie IE8-MSW7 machine has IE8 8.0.6001.18702 and is affected
|
|
if (ex.number === undefined || ex.number === -0x7FF5EC54) {
|
|
classListPropDesc.enumerable = false;
|
|
objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);
|
|
}
|
|
}
|
|
} else if (objCtr[protoProp].__defineGetter__) {
|
|
elemCtrProto.__defineGetter__(classListProp, classListGetter);
|
|
}
|
|
})(window.self);
|
|
}
|
|
// There is full or partial native classList support, so just check if we need
|
|
// to normalize the add/remove and toggle APIs.
|
|
(function() {
|
|
"use strict";
|
|
var testElement = document.createElement("_");
|
|
testElement.classList.add("c1", "c2");
|
|
// Polyfill for IE 10/11 and Firefox <26, where classList.add and
|
|
// classList.remove exist but support only one argument at a time.
|
|
if (!testElement.classList.contains("c2")) {
|
|
var createMethod = function createMethod(method) {
|
|
var original = DOMTokenList.prototype[method];
|
|
DOMTokenList.prototype[method] = function(token) {
|
|
var i, len = arguments.length;
|
|
for(i = 0; i < len; i++){
|
|
token = arguments[i];
|
|
original.call(this, token);
|
|
}
|
|
};
|
|
};
|
|
createMethod('add');
|
|
createMethod('remove');
|
|
}
|
|
testElement.classList.toggle("c3", false);
|
|
// Polyfill for IE 10 and Firefox <24, where classList.toggle does not
|
|
// support the second argument.
|
|
if (testElement.classList.contains("c3")) {
|
|
var _toggle = DOMTokenList.prototype.toggle;
|
|
DOMTokenList.prototype.toggle = function(token, force) {
|
|
if (1 in arguments && !this.contains(token) === !force) {
|
|
return force;
|
|
} else {
|
|
return _toggle.call(this, token);
|
|
}
|
|
};
|
|
}
|
|
testElement = null;
|
|
})();
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 50300:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
var globalThis = __webpack_require__(75058);
|
|
var getOwnPropertyDescriptor = (__webpack_require__(10393).f);
|
|
var createNonEnumerableProperty = __webpack_require__(59541);
|
|
var defineBuiltIn = __webpack_require__(27714);
|
|
var defineGlobalProperty = __webpack_require__(36759);
|
|
var copyConstructorProperties = __webpack_require__(2958);
|
|
var isForced = __webpack_require__(41890);
|
|
/*
|
|
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 === "undefined" ? "undefined" : _type_of(sourceProperty)) == (typeof targetProperty === "undefined" ? "undefined" : _type_of(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);
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 50617:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var shared = __webpack_require__(2975);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var uid = __webpack_require__(18818);
|
|
var NATIVE_SYMBOL = __webpack_require__(74693);
|
|
var USE_SYMBOL_AS_UID = __webpack_require__(43334);
|
|
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];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 51107:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
module.exports = getBuiltIn('document', 'documentElement');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 51265:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// TODO: Remove this module from `core-js@4` since it's split to modules listed below
|
|
__webpack_require__(63627);
|
|
__webpack_require__(89676);
|
|
__webpack_require__(78638);
|
|
__webpack_require__(24784);
|
|
__webpack_require__(40891);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 52413:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var anObject = __webpack_require__(30941);
|
|
var iteratorClose = __webpack_require__(73737);
|
|
// call something on iterator step with safe closing on error
|
|
module.exports = function(iterator, fn, value, ENTRIES) {
|
|
try {
|
|
return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
|
|
} catch (error) {
|
|
iteratorClose(iterator, 'throw', error);
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 52699:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var Iterators = __webpack_require__(84543);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 52867:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.hasInstance` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.hasinstance
|
|
defineWellKnownSymbol('hasInstance');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 53110:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var bind = __webpack_require__(71594);
|
|
var call = __webpack_require__(26919);
|
|
var toObject = __webpack_require__(30995);
|
|
var callWithSafeIterationClosing = __webpack_require__(52413);
|
|
var isArrayIteratorMethod = __webpack_require__(52699);
|
|
var isConstructor = __webpack_require__(46119);
|
|
var lengthOfArrayLike = __webpack_require__(23832);
|
|
var createProperty = __webpack_require__(15526);
|
|
var getIterator = __webpack_require__(3279);
|
|
var getIteratorMethod = __webpack_require__(72929);
|
|
var $Array = Array;
|
|
// `Array.from` method implementation
|
|
// https://tc39.es/ecma262/#sec-array.from
|
|
module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */ ) {
|
|
var O = toObject(arrayLike);
|
|
var IS_CONSTRUCTOR = isConstructor(this);
|
|
var argumentsLength = arguments.length;
|
|
var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
|
|
var mapping = mapfn !== undefined;
|
|
if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
|
|
var iteratorMethod = getIteratorMethod(O);
|
|
var index = 0;
|
|
var length, result, step, iterator, next, value;
|
|
// if the target is not iterable or it's an array with the default iterator - use a simple case
|
|
if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {
|
|
result = IS_CONSTRUCTOR ? new this() : [];
|
|
iterator = getIterator(O, iteratorMethod);
|
|
next = iterator.next;
|
|
for(; !(step = call(next, iterator)).done; index++){
|
|
value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [
|
|
step.value,
|
|
index
|
|
], true) : step.value;
|
|
createProperty(result, index, value);
|
|
}
|
|
} else {
|
|
length = lengthOfArrayLike(O);
|
|
result = IS_CONSTRUCTOR ? new this(length) : $Array(length);
|
|
for(; length > index; index++){
|
|
value = mapping ? mapfn(O[index], index) : O[index];
|
|
createProperty(result, index, value);
|
|
}
|
|
}
|
|
result.length = index;
|
|
return result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 54393:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
module.exports = function(CONSTRUCTOR, METHOD) {
|
|
return uncurryThis(globalThis[CONSTRUCTOR].prototype[METHOD]);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 55425:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var fails = __webpack_require__(96673);
|
|
var isCallable = __webpack_require__(14595);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(5944).CONFIGURABLE);
|
|
var inspectSource = __webpack_require__(69228);
|
|
var InternalStateModule = __webpack_require__(34155);
|
|
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() {}, 'length', {
|
|
value: 8
|
|
}).length !== 8;
|
|
});
|
|
var TEMPLATE = String(String).split('String');
|
|
var makeBuiltIn = module.exports = function makeBuiltIn(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) {}
|
|
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');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 56167:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
module.exports = uncurryThis({}.isPrototypeOf);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 56184:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIntegerOrInfinity = __webpack_require__(79893);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 56379:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(96673);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var V8_VERSION = __webpack_require__(1669);
|
|
var SPECIES = wellKnownSymbol('species');
|
|
module.exports = function(METHOD_NAME) {
|
|
// We can't use this feature detection in V8 since it causes
|
|
// deoptimization and serious performance degradation
|
|
// https://github.com/zloirock/core-js/issues/677
|
|
return V8_VERSION >= 51 || !fails(function() {
|
|
var array = [];
|
|
var constructor = array.constructor = {};
|
|
constructor[SPECIES] = function() {
|
|
return {
|
|
foo: 1
|
|
};
|
|
};
|
|
return array[METHOD_NAME](Boolean).foo !== 1;
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 56582:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var globalThis = __webpack_require__(75058);
|
|
var setToStringTag = __webpack_require__(10845);
|
|
$({
|
|
global: true
|
|
}, {
|
|
Reflect: {}
|
|
});
|
|
// Reflect[@@toStringTag] property
|
|
// https://tc39.es/ecma262/#sec-reflect-@@tostringtag
|
|
setToStringTag(globalThis.Reflect, 'Reflect', true);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 56895:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var arraySpeciesConstructor = __webpack_require__(72783);
|
|
// `ArraySpeciesCreate` abstract operation
|
|
// https://tc39.es/ecma262/#sec-arrayspeciescreate
|
|
module.exports = function(originalArray, length) {
|
|
return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 57108:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.matchAll` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.matchall
|
|
defineWellKnownSymbol('matchAll');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 57683:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
__webpack_require__(75024);
|
|
__webpack_require__(78837);
|
|
__webpack_require__(51265);
|
|
__webpack_require__(43707);
|
|
__webpack_require__(97778);
|
|
__webpack_require__(24661);
|
|
__webpack_require__(92770);
|
|
__webpack_require__(52867);
|
|
__webpack_require__(26494);
|
|
__webpack_require__(45797);
|
|
__webpack_require__(67130);
|
|
__webpack_require__(57108);
|
|
__webpack_require__(23359);
|
|
__webpack_require__(27491);
|
|
__webpack_require__(89689);
|
|
__webpack_require__(22367);
|
|
__webpack_require__(150);
|
|
__webpack_require__(42695);
|
|
__webpack_require__(94248);
|
|
__webpack_require__(12057);
|
|
__webpack_require__(29437);
|
|
__webpack_require__(56582);
|
|
var path = __webpack_require__(7557);
|
|
module.exports = path.Symbol;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 57996:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var aCallable = __webpack_require__(90256);
|
|
var isNullOrUndefined = __webpack_require__(41943);
|
|
// `GetMethod` abstract operation
|
|
// https://tc39.es/ecma262/#sec-getmethod
|
|
module.exports = function(V, P) {
|
|
var func = V[P];
|
|
return isNullOrUndefined(func) ? undefined : aCallable(func);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 59299:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIndexedObject = __webpack_require__(83511);
|
|
var toAbsoluteIndex = __webpack_require__(56184);
|
|
var lengthOfArrayLike = __webpack_require__(23832);
|
|
// `Array.prototype.{ indexOf, includes }` methods implementation
|
|
var createMethod = function createMethod(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)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 59541:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var definePropertyModule = __webpack_require__(9475);
|
|
var createPropertyDescriptor = __webpack_require__(63458);
|
|
module.exports = DESCRIPTORS ? function(object, key, value) {
|
|
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
|
} : function(object, key, value) {
|
|
object[key] = value;
|
|
return object;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 59979:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 60288:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var aCallable = __webpack_require__(90256);
|
|
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) {}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 62017:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var path = __webpack_require__(7557);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var wrappedWellKnownSymbolModule = __webpack_require__(20037);
|
|
var defineProperty = (__webpack_require__(9475).f);
|
|
module.exports = function(NAME) {
|
|
var Symbol = path.Symbol || (path.Symbol = {});
|
|
if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
|
|
value: wrappedWellKnownSymbolModule.f(NAME)
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 63458:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = function(bitmap, value) {
|
|
return {
|
|
enumerable: !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable: !(bitmap & 4),
|
|
value: value
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 63627:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _instanceof(left, right) {
|
|
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
|
return !!right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
}
|
|
var $ = __webpack_require__(50300);
|
|
var globalThis = __webpack_require__(75058);
|
|
var call = __webpack_require__(26919);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var IS_PURE = __webpack_require__(22445);
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var NATIVE_SYMBOL = __webpack_require__(74693);
|
|
var fails = __webpack_require__(96673);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var isPrototypeOf = __webpack_require__(56167);
|
|
var anObject = __webpack_require__(30941);
|
|
var toIndexedObject = __webpack_require__(83511);
|
|
var toPropertyKey = __webpack_require__(72543);
|
|
var $toString = __webpack_require__(13181);
|
|
var createPropertyDescriptor = __webpack_require__(63458);
|
|
var nativeObjectCreate = __webpack_require__(99746);
|
|
var objectKeys = __webpack_require__(77298);
|
|
var getOwnPropertyNamesModule = __webpack_require__(63838);
|
|
var getOwnPropertyNamesExternal = __webpack_require__(18316);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(93715);
|
|
var getOwnPropertyDescriptorModule = __webpack_require__(10393);
|
|
var definePropertyModule = __webpack_require__(9475);
|
|
var definePropertiesModule = __webpack_require__(16719);
|
|
var propertyIsEnumerableModule = __webpack_require__(23043);
|
|
var defineBuiltIn = __webpack_require__(27714);
|
|
var defineBuiltInAccessor = __webpack_require__(66416);
|
|
var shared = __webpack_require__(2975);
|
|
var sharedKey = __webpack_require__(99353);
|
|
var hiddenKeys = __webpack_require__(38043);
|
|
var uid = __webpack_require__(18818);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var wrappedWellKnownSymbolModule = __webpack_require__(20037);
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
var defineSymbolToPrimitive = __webpack_require__(28360);
|
|
var setToStringTag = __webpack_require__(10845);
|
|
var InternalStateModule = __webpack_require__(34155);
|
|
var $forEach = (__webpack_require__(78027).forEach);
|
|
var HIDDEN = sharedKey('hidden');
|
|
var SYMBOL = 'Symbol';
|
|
var PROTOTYPE = 'prototype';
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(SYMBOL);
|
|
var ObjectPrototype = Object[PROTOTYPE];
|
|
var $Symbol = globalThis.Symbol;
|
|
var SymbolPrototype = $Symbol && $Symbol[PROTOTYPE];
|
|
var RangeError = globalThis.RangeError;
|
|
var TypeError = globalThis.TypeError;
|
|
var QObject = globalThis.QObject;
|
|
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
var nativeDefineProperty = definePropertyModule.f;
|
|
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
|
|
var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
|
|
var push = uncurryThis([].push);
|
|
var AllSymbols = shared('symbols');
|
|
var ObjectPrototypeSymbols = shared('op-symbols');
|
|
var WellKnownSymbolsStore = shared('wks');
|
|
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
|
|
var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
|
|
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
|
|
var fallbackDefineProperty = function fallbackDefineProperty(O, P, Attributes) {
|
|
var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
|
|
if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];
|
|
nativeDefineProperty(O, P, Attributes);
|
|
if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
|
|
nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
|
|
}
|
|
};
|
|
var setSymbolDescriptor = DESCRIPTORS && fails(function() {
|
|
return nativeObjectCreate(nativeDefineProperty({}, 'a', {
|
|
get: function get() {
|
|
return nativeDefineProperty(this, 'a', {
|
|
value: 7
|
|
}).a;
|
|
}
|
|
})).a !== 7;
|
|
}) ? fallbackDefineProperty : nativeDefineProperty;
|
|
var wrap = function wrap(tag, description) {
|
|
var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype);
|
|
setInternalState(symbol, {
|
|
type: SYMBOL,
|
|
tag: tag,
|
|
description: description
|
|
});
|
|
if (!DESCRIPTORS) symbol.description = description;
|
|
return symbol;
|
|
};
|
|
var $defineProperty = function defineProperty(O, P, Attributes) {
|
|
if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
|
|
anObject(O);
|
|
var key = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (hasOwn(AllSymbols, key)) {
|
|
if (!Attributes.enumerable) {
|
|
if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, nativeObjectCreate(null)));
|
|
O[HIDDEN][key] = true;
|
|
} else {
|
|
if (hasOwn(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;
|
|
Attributes = nativeObjectCreate(Attributes, {
|
|
enumerable: createPropertyDescriptor(0, false)
|
|
});
|
|
}
|
|
return setSymbolDescriptor(O, key, Attributes);
|
|
}
|
|
return nativeDefineProperty(O, key, Attributes);
|
|
};
|
|
var $defineProperties = function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var properties = toIndexedObject(Properties);
|
|
var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
|
|
$forEach(keys, function(key) {
|
|
if (!DESCRIPTORS || call($propertyIsEnumerable, properties, key)) $defineProperty(O, key, properties[key]);
|
|
});
|
|
return O;
|
|
};
|
|
var $create = function create(O, Properties) {
|
|
return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
|
|
};
|
|
var $propertyIsEnumerable = function propertyIsEnumerable(V) {
|
|
var P = toPropertyKey(V);
|
|
var enumerable = call(nativePropertyIsEnumerable, this, P);
|
|
if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P)) return false;
|
|
return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
|
|
};
|
|
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
|
|
var it = toIndexedObject(O);
|
|
var key = toPropertyKey(P);
|
|
if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key)) return;
|
|
var descriptor = nativeGetOwnPropertyDescriptor(it, key);
|
|
if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(it, HIDDEN) && it[HIDDEN][key])) {
|
|
descriptor.enumerable = true;
|
|
}
|
|
return descriptor;
|
|
};
|
|
var $getOwnPropertyNames = function getOwnPropertyNames(O) {
|
|
var names = nativeGetOwnPropertyNames(toIndexedObject(O));
|
|
var result = [];
|
|
$forEach(names, function(key) {
|
|
if (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key)) push(result, key);
|
|
});
|
|
return result;
|
|
};
|
|
var $getOwnPropertySymbols = function $getOwnPropertySymbols(O) {
|
|
var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
|
|
var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
|
|
var result = [];
|
|
$forEach(names, function(key) {
|
|
if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) {
|
|
push(result, AllSymbols[key]);
|
|
}
|
|
});
|
|
return result;
|
|
};
|
|
// `Symbol` constructor
|
|
// https://tc39.es/ecma262/#sec-symbol-constructor
|
|
if (!NATIVE_SYMBOL) {
|
|
$Symbol = function Symbol1() {
|
|
if (isPrototypeOf(SymbolPrototype, this)) throw new TypeError('Symbol is not a constructor');
|
|
var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]);
|
|
var tag = uid(description);
|
|
var setter = function setter1(value) {
|
|
var $this = this === undefined ? globalThis : this;
|
|
if ($this === ObjectPrototype) call(setter, ObjectPrototypeSymbols, value);
|
|
if (hasOwn($this, HIDDEN) && hasOwn($this[HIDDEN], tag)) $this[HIDDEN][tag] = false;
|
|
var descriptor = createPropertyDescriptor(1, value);
|
|
try {
|
|
setSymbolDescriptor($this, tag, descriptor);
|
|
} catch (error) {
|
|
if (!_instanceof(error, RangeError)) throw error;
|
|
fallbackDefineProperty($this, tag, descriptor);
|
|
}
|
|
};
|
|
if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, {
|
|
configurable: true,
|
|
set: setter
|
|
});
|
|
return wrap(tag, description);
|
|
};
|
|
SymbolPrototype = $Symbol[PROTOTYPE];
|
|
defineBuiltIn(SymbolPrototype, 'toString', function toString() {
|
|
return getInternalState(this).tag;
|
|
});
|
|
defineBuiltIn($Symbol, 'withoutSetter', function(description) {
|
|
return wrap(uid(description), description);
|
|
});
|
|
propertyIsEnumerableModule.f = $propertyIsEnumerable;
|
|
definePropertyModule.f = $defineProperty;
|
|
definePropertiesModule.f = $defineProperties;
|
|
getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
|
|
getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
|
|
getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;
|
|
wrappedWellKnownSymbolModule.f = function(name) {
|
|
return wrap(wellKnownSymbol(name), name);
|
|
};
|
|
if (DESCRIPTORS) {
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype.description
|
|
defineBuiltInAccessor(SymbolPrototype, 'description', {
|
|
configurable: true,
|
|
get: function description() {
|
|
return getInternalState(this).description;
|
|
}
|
|
});
|
|
if (!IS_PURE) {
|
|
defineBuiltIn(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, {
|
|
unsafe: true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
$({
|
|
global: true,
|
|
constructor: true,
|
|
wrap: true,
|
|
forced: !NATIVE_SYMBOL,
|
|
sham: !NATIVE_SYMBOL
|
|
}, {
|
|
Symbol: $Symbol
|
|
});
|
|
$forEach(objectKeys(WellKnownSymbolsStore), function(name) {
|
|
defineWellKnownSymbol(name);
|
|
});
|
|
$({
|
|
target: SYMBOL,
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL
|
|
}, {
|
|
useSetter: function useSetter() {
|
|
USE_SETTER = true;
|
|
},
|
|
useSimple: function useSimple() {
|
|
USE_SETTER = false;
|
|
}
|
|
});
|
|
$({
|
|
target: 'Object',
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL,
|
|
sham: !DESCRIPTORS
|
|
}, {
|
|
// `Object.create` method
|
|
// https://tc39.es/ecma262/#sec-object.create
|
|
create: $create,
|
|
// `Object.defineProperty` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperty
|
|
defineProperty: $defineProperty,
|
|
// `Object.defineProperties` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperties
|
|
defineProperties: $defineProperties,
|
|
// `Object.getOwnPropertyDescriptor` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
|
|
getOwnPropertyDescriptor: $getOwnPropertyDescriptor
|
|
});
|
|
$({
|
|
target: 'Object',
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL
|
|
}, {
|
|
// `Object.getOwnPropertyNames` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertynames
|
|
getOwnPropertyNames: $getOwnPropertyNames
|
|
});
|
|
// `Symbol.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
|
|
defineSymbolToPrimitive();
|
|
// `Symbol.prototype[@@toStringTag]` property
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
|
|
setToStringTag($Symbol, SYMBOL);
|
|
hiddenKeys[HIDDEN] = true;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 63838:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var internalObjectKeys = __webpack_require__(36446);
|
|
var enumBugKeys = __webpack_require__(24877);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 64369:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var isObject = __webpack_require__(78144);
|
|
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) : {};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 64959:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(17158);
|
|
var fails = __webpack_require__(96673);
|
|
var createElement = __webpack_require__(64369);
|
|
// 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 get() {
|
|
return 7;
|
|
}
|
|
}).a !== 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 66310:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var toString = uncurryThis({}.toString);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
module.exports = function(it) {
|
|
return stringSlice(toString(it), 8, -1);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 66416:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var makeBuiltIn = __webpack_require__(55425);
|
|
var defineProperty = __webpack_require__(9475);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 67130:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.match` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.match
|
|
defineWellKnownSymbol('match');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 69228:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var isCallable = __webpack_require__(14595);
|
|
var store = __webpack_require__(49567);
|
|
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;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 70439:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// `CreateIterResultObject` abstract operation
|
|
// https://tc39.es/ecma262/#sec-createiterresultobject
|
|
module.exports = function(value, done) {
|
|
return {
|
|
value: value,
|
|
done: done
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 71093:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var charAt = (__webpack_require__(31353).charAt);
|
|
var toString = __webpack_require__(13181);
|
|
var InternalStateModule = __webpack_require__(34155);
|
|
var defineIterator = __webpack_require__(20998);
|
|
var createIterResultObject = __webpack_require__(70439);
|
|
var STRING_ITERATOR = 'String Iterator';
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
|
|
// `String.prototype[@@iterator]` method
|
|
// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
|
|
defineIterator(String, 'String', function(iterated) {
|
|
setInternalState(this, {
|
|
type: STRING_ITERATOR,
|
|
string: toString(iterated),
|
|
index: 0
|
|
});
|
|
// `%StringIteratorPrototype%.next` method
|
|
// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
|
|
}, function next() {
|
|
var state = getInternalState(this);
|
|
var string = state.string;
|
|
var index = state.index;
|
|
var point;
|
|
if (index >= string.length) return createIterResultObject(undefined, true);
|
|
point = charAt(string, index);
|
|
state.index += point.length;
|
|
return createIterResultObject(point, false);
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 71594:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(93474);
|
|
var aCallable = __webpack_require__(90256);
|
|
var NATIVE_BIND = __webpack_require__(37770);
|
|
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() {
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 71975:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var isCallable = __webpack_require__(14595);
|
|
var isPrototypeOf = __webpack_require__(56167);
|
|
var USE_SYMBOL_AS_UID = __webpack_require__(43334);
|
|
var $Object = Object;
|
|
module.exports = USE_SYMBOL_AS_UID ? function(it) {
|
|
return (typeof it === "undefined" ? "undefined" : _type_of(it)) == 'symbol';
|
|
} : function(it) {
|
|
var $Symbol = getBuiltIn('Symbol');
|
|
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 72543:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toPrimitive = __webpack_require__(34315);
|
|
var isSymbol = __webpack_require__(71975);
|
|
// `ToPropertyKey` abstract operation
|
|
// https://tc39.es/ecma262/#sec-topropertykey
|
|
module.exports = function(argument) {
|
|
var key = toPrimitive(argument, 'string');
|
|
return isSymbol(key) ? key : key + '';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 72783:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isArray = __webpack_require__(40554);
|
|
var isConstructor = __webpack_require__(46119);
|
|
var isObject = __webpack_require__(78144);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var SPECIES = wellKnownSymbol('species');
|
|
var $Array = Array;
|
|
// a part of `ArraySpeciesCreate` abstract operation
|
|
// https://tc39.es/ecma262/#sec-arrayspeciescreate
|
|
module.exports = function(originalArray) {
|
|
var C;
|
|
if (isArray(originalArray)) {
|
|
C = originalArray.constructor;
|
|
// cross-realm fallback
|
|
if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
|
|
else if (isObject(C)) {
|
|
C = C[SPECIES];
|
|
if (C === null) C = undefined;
|
|
}
|
|
}
|
|
return C === undefined ? $Array : C;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 72929:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classof = __webpack_require__(20233);
|
|
var getMethod = __webpack_require__(57996);
|
|
var isNullOrUndefined = __webpack_require__(41943);
|
|
var Iterators = __webpack_require__(84543);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
module.exports = function(it) {
|
|
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR) || getMethod(it, '@@iterator') || Iterators[classof(it)];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 73737:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(26919);
|
|
var anObject = __webpack_require__(30941);
|
|
var getMethod = __webpack_require__(57996);
|
|
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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 74693:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _instanceof(left, right) {
|
|
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
|
return !!right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
}
|
|
/* eslint-disable es/no-symbol -- required for testing */ var V8_VERSION = __webpack_require__(1669);
|
|
var fails = __webpack_require__(96673);
|
|
var globalThis = __webpack_require__(75058);
|
|
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) || !_instanceof(Object(symbol), Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
|
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 75024:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var fails = __webpack_require__(96673);
|
|
var isArray = __webpack_require__(40554);
|
|
var isObject = __webpack_require__(78144);
|
|
var toObject = __webpack_require__(30995);
|
|
var lengthOfArrayLike = __webpack_require__(23832);
|
|
var doesNotExceedSafeInteger = __webpack_require__(59979);
|
|
var createProperty = __webpack_require__(15526);
|
|
var arraySpeciesCreate = __webpack_require__(56895);
|
|
var arrayMethodHasSpeciesSupport = __webpack_require__(56379);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var V8_VERSION = __webpack_require__(1669);
|
|
var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
|
|
// We can't use this feature detection in V8 since it causes
|
|
// deoptimization and serious performance degradation
|
|
// https://github.com/zloirock/core-js/issues/679
|
|
var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function() {
|
|
var array = [];
|
|
array[IS_CONCAT_SPREADABLE] = false;
|
|
return array.concat()[0] !== array;
|
|
});
|
|
var isConcatSpreadable = function isConcatSpreadable(O) {
|
|
if (!isObject(O)) return false;
|
|
var spreadable = O[IS_CONCAT_SPREADABLE];
|
|
return spreadable !== undefined ? !!spreadable : isArray(O);
|
|
};
|
|
var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');
|
|
// `Array.prototype.concat` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.concat
|
|
// with adding support of @@isConcatSpreadable and @@species
|
|
$({
|
|
target: 'Array',
|
|
proto: true,
|
|
arity: 1,
|
|
forced: FORCED
|
|
}, {
|
|
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
concat: function concat(arg) {
|
|
var O = toObject(this);
|
|
var A = arraySpeciesCreate(O, 0);
|
|
var n = 0;
|
|
var i, k, length, len, E;
|
|
for(i = -1, length = arguments.length; i < length; i++){
|
|
E = i === -1 ? O : arguments[i];
|
|
if (isConcatSpreadable(E)) {
|
|
len = lengthOfArrayLike(E);
|
|
doesNotExceedSafeInteger(n + len);
|
|
for(k = 0; k < len; k++, n++)if (k in E) createProperty(A, n, E[k]);
|
|
} else {
|
|
doesNotExceedSafeInteger(n + 1);
|
|
createProperty(A, n++, E);
|
|
}
|
|
}
|
|
A.length = n;
|
|
return A;
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 75058:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
var check = function check(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 === "undefined" ? "undefined" : _type_of(globalThis)) == 'object' && globalThis) || check((typeof window === "undefined" ? "undefined" : _type_of(window)) == 'object' && window) || // eslint-disable-next-line no-restricted-globals -- safe
|
|
check((typeof self === "undefined" ? "undefined" : _type_of(self)) == 'object' && self) || check((typeof __webpack_require__.g === "undefined" ? "undefined" : _type_of(__webpack_require__.g)) == 'object' && __webpack_require__.g) || check(_type_of(this) == 'object' && this) || // eslint-disable-next-line no-new-func -- fallback
|
|
function() {
|
|
return this;
|
|
}() || Function('return this')();
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 77298:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var internalObjectKeys = __webpack_require__(36446);
|
|
var enumBugKeys = __webpack_require__(24877);
|
|
// `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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 78027:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var bind = __webpack_require__(71594);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var IndexedObject = __webpack_require__(82545);
|
|
var toObject = __webpack_require__(30995);
|
|
var lengthOfArrayLike = __webpack_require__(23832);
|
|
var arraySpeciesCreate = __webpack_require__(56895);
|
|
var push = uncurryThis([].push);
|
|
// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
|
|
var createMethod = function createMethod(TYPE) {
|
|
var IS_MAP = TYPE === 1;
|
|
var IS_FILTER = TYPE === 2;
|
|
var IS_SOME = TYPE === 3;
|
|
var IS_EVERY = TYPE === 4;
|
|
var IS_FIND_INDEX = TYPE === 6;
|
|
var IS_FILTER_REJECT = TYPE === 7;
|
|
var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
|
|
return function($this, callbackfn, that, specificCreate) {
|
|
var O = toObject($this);
|
|
var self = IndexedObject(O);
|
|
var length = lengthOfArrayLike(self);
|
|
var boundFunction = bind(callbackfn, that);
|
|
var index = 0;
|
|
var create = specificCreate || arraySpeciesCreate;
|
|
var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
|
|
var value, result;
|
|
for(; length > index; index++)if (NO_HOLES || index in self) {
|
|
value = self[index];
|
|
result = boundFunction(value, index, O);
|
|
if (TYPE) {
|
|
if (IS_MAP) target[index] = result; // map
|
|
else if (result) switch(TYPE){
|
|
case 3:
|
|
return true; // some
|
|
case 5:
|
|
return value; // find
|
|
case 6:
|
|
return index; // findIndex
|
|
case 2:
|
|
push(target, value); // filter
|
|
}
|
|
else switch(TYPE){
|
|
case 4:
|
|
return false; // every
|
|
case 7:
|
|
push(target, value); // filterReject
|
|
}
|
|
}
|
|
}
|
|
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
|
|
};
|
|
};
|
|
module.exports = {
|
|
// `Array.prototype.forEach` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.foreach
|
|
forEach: createMethod(0),
|
|
// `Array.prototype.map` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.map
|
|
map: createMethod(1),
|
|
// `Array.prototype.filter` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.filter
|
|
filter: createMethod(2),
|
|
// `Array.prototype.some` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.some
|
|
some: createMethod(3),
|
|
// `Array.prototype.every` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.every
|
|
every: createMethod(4),
|
|
// `Array.prototype.find` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.find
|
|
find: createMethod(5),
|
|
// `Array.prototype.findIndex` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.findIndex
|
|
findIndex: createMethod(6),
|
|
// `Array.prototype.filterReject` method
|
|
// https://github.com/tc39/proposal-array-filtering
|
|
filterReject: createMethod(7)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 78144:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
var isCallable = __webpack_require__(14595);
|
|
module.exports = function(it) {
|
|
return (typeof it === "undefined" ? "undefined" : _type_of(it)) == 'object' ? it !== null : isCallable(it);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 78638:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var isSymbol = __webpack_require__(71975);
|
|
var tryToString = __webpack_require__(8465);
|
|
var shared = __webpack_require__(2975);
|
|
var NATIVE_SYMBOL_REGISTRY = __webpack_require__(31050);
|
|
var SymbolToStringRegistry = shared('symbol-to-string-registry');
|
|
// `Symbol.keyFor` method
|
|
// https://tc39.es/ecma262/#sec-symbol.keyfor
|
|
$({
|
|
target: 'Symbol',
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL_REGISTRY
|
|
}, {
|
|
keyFor: function keyFor(sym) {
|
|
if (!isSymbol(sym)) throw new TypeError(tryToString(sym) + ' is not a symbol');
|
|
if (hasOwn(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 78837:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var TO_STRING_TAG_SUPPORT = __webpack_require__(82138);
|
|
var defineBuiltIn = __webpack_require__(27714);
|
|
var toString = __webpack_require__(99981);
|
|
// `Object.prototype.toString` method
|
|
// https://tc39.es/ecma262/#sec-object.prototype.tostring
|
|
if (!TO_STRING_TAG_SUPPORT) {
|
|
defineBuiltIn(Object.prototype, 'toString', toString, {
|
|
unsafe: true
|
|
});
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 79893:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var trunc = __webpack_require__(1055);
|
|
// `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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 82138:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var test = {};
|
|
test[TO_STRING_TAG] = 'z';
|
|
module.exports = String(test) === '[object z]';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 82545:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(46738);
|
|
var fails = __webpack_require__(96673);
|
|
var classof = __webpack_require__(66310);
|
|
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;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 82911:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var create = __webpack_require__(99746);
|
|
var defineProperty = (__webpack_require__(9475).f);
|
|
var UNSCOPABLES = wellKnownSymbol('unscopables');
|
|
var ArrayPrototype = Array.prototype;
|
|
// Array.prototype[@@unscopables]
|
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
if (ArrayPrototype[UNSCOPABLES] === undefined) {
|
|
defineProperty(ArrayPrototype, UNSCOPABLES, {
|
|
configurable: true,
|
|
value: create(null)
|
|
});
|
|
}
|
|
// add a key to Array.prototype[@@unscopables]
|
|
module.exports = function(key) {
|
|
ArrayPrototype[UNSCOPABLES][key] = true;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 83511:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// toObject with fallback for non-array-like ES3 strings
|
|
var IndexedObject = __webpack_require__(82545);
|
|
var requireObjectCoercible = __webpack_require__(93080);
|
|
module.exports = function(it) {
|
|
return IndexedObject(requireObjectCoercible(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 84543:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = {};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 85353:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(96673);
|
|
module.exports = !fails(function() {
|
|
function F() {}
|
|
F.prototype.constructor = null;
|
|
// eslint-disable-next-line es/no-object-getprototypeof -- required for testing
|
|
return Object.getPrototypeOf(new F()) !== F.prototype;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 88597:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _instanceof(left, right) {
|
|
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
|
|
return !!right[Symbol.hasInstance](left);
|
|
} else {
|
|
return left instanceof right;
|
|
}
|
|
}
|
|
var hasOwn = __webpack_require__(26419);
|
|
var isCallable = __webpack_require__(14595);
|
|
var toObject = __webpack_require__(30995);
|
|
var sharedKey = __webpack_require__(99353);
|
|
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(85353);
|
|
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) && _instanceof(object, constructor)) {
|
|
return constructor.prototype;
|
|
}
|
|
return _instanceof(object, $Object) ? ObjectPrototype : null;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 89676:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var getBuiltIn = __webpack_require__(29833);
|
|
var hasOwn = __webpack_require__(26419);
|
|
var toString = __webpack_require__(13181);
|
|
var shared = __webpack_require__(2975);
|
|
var NATIVE_SYMBOL_REGISTRY = __webpack_require__(31050);
|
|
var StringToSymbolRegistry = shared('string-to-symbol-registry');
|
|
var SymbolToStringRegistry = shared('symbol-to-string-registry');
|
|
// `Symbol.for` method
|
|
// https://tc39.es/ecma262/#sec-symbol.for
|
|
$({
|
|
target: 'Symbol',
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL_REGISTRY
|
|
}, {
|
|
'for': function(key) {
|
|
var string = toString(key);
|
|
if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
|
|
var symbol = getBuiltIn('Symbol')(string);
|
|
StringToSymbolRegistry[string] = symbol;
|
|
SymbolToStringRegistry[symbol] = string;
|
|
return symbol;
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 89689:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.species` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.species
|
|
defineWellKnownSymbol('species');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 90003:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
function _type_of(obj) {
|
|
"@swc/helpers - typeof";
|
|
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
|
}
|
|
var NATIVE_BIND = __webpack_require__(37770);
|
|
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 === "undefined" ? "undefined" : _type_of(Reflect)) == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
|
|
return call.apply(apply, arguments);
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 90014:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(50300);
|
|
var $findIndex = (__webpack_require__(78027).findIndex);
|
|
var addToUnscopables = __webpack_require__(82911);
|
|
var FIND_INDEX = 'findIndex';
|
|
var SKIPS_HOLES = true;
|
|
// Shouldn't skip holes
|
|
// eslint-disable-next-line es/no-array-prototype-findindex -- testing
|
|
if (FIND_INDEX in []) Array(1)[FIND_INDEX](function() {
|
|
SKIPS_HOLES = false;
|
|
});
|
|
// `Array.prototype.findIndex` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.findindex
|
|
$({
|
|
target: 'Array',
|
|
proto: true,
|
|
forced: SKIPS_HOLES
|
|
}, {
|
|
findIndex: function findIndex(callbackfn /* , that = undefined */ ) {
|
|
return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
|
}
|
|
});
|
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
addToUnscopables(FIND_INDEX);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 90256:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isCallable = __webpack_require__(14595);
|
|
var tryToString = __webpack_require__(8465);
|
|
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');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 92770:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
var defineProperty = (__webpack_require__(9475).f);
|
|
var getOwnPropertyDescriptor = (__webpack_require__(10393).f);
|
|
var Symbol = globalThis.Symbol;
|
|
// `Symbol.dispose` well-known symbol
|
|
// https://github.com/tc39/proposal-explicit-resource-management
|
|
defineWellKnownSymbol('dispose');
|
|
if (Symbol) {
|
|
var descriptor = getOwnPropertyDescriptor(Symbol, 'dispose');
|
|
// workaround of NodeJS 20.4 bug
|
|
// https://github.com/nodejs/node/issues/48699
|
|
// and incorrect descriptor from some transpilers and userland helpers
|
|
if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
|
|
defineProperty(Symbol, 'dispose', {
|
|
value: descriptor.value,
|
|
enumerable: false,
|
|
configurable: false,
|
|
writable: false
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 93080:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isNullOrUndefined = __webpack_require__(41943);
|
|
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;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 93474:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classofRaw = __webpack_require__(66310);
|
|
var uncurryThis = __webpack_require__(46738);
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 93715:
|
|
/***/ (function(__unused_webpack_module, exports) {
|
|
|
|
"use strict";
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
|
|
exports.f = Object.getOwnPropertySymbols;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 94248:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.unscopables` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.unscopables
|
|
defineWellKnownSymbol('unscopables');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 96371:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(96673);
|
|
var isCallable = __webpack_require__(14595);
|
|
var isObject = __webpack_require__(78144);
|
|
var create = __webpack_require__(99746);
|
|
var getPrototypeOf = __webpack_require__(88597);
|
|
var defineBuiltIn = __webpack_require__(27714);
|
|
var wellKnownSymbol = __webpack_require__(50617);
|
|
var IS_PURE = __webpack_require__(22445);
|
|
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
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 96673:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = function(exec) {
|
|
try {
|
|
return !!exec();
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 97778:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(62017);
|
|
// `Symbol.asyncIterator` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.asynciterator
|
|
defineWellKnownSymbol('asyncIterator');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 97948:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var globalThis = __webpack_require__(75058);
|
|
var isCallable = __webpack_require__(14595);
|
|
var WeakMap = globalThis.WeakMap;
|
|
module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 99353:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var shared = __webpack_require__(2975);
|
|
var uid = __webpack_require__(18818);
|
|
var keys = shared('keys');
|
|
module.exports = function(key) {
|
|
return keys[key] || (keys[key] = uid(key));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 99746:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* global ActiveXObject -- old IE, WSH */ var anObject = __webpack_require__(30941);
|
|
var definePropertiesModule = __webpack_require__(16719);
|
|
var enumBugKeys = __webpack_require__(24877);
|
|
var hiddenKeys = __webpack_require__(38043);
|
|
var html = __webpack_require__(51107);
|
|
var documentCreateElement = __webpack_require__(64369);
|
|
var sharedKey = __webpack_require__(99353);
|
|
var GT = '>';
|
|
var LT = '<';
|
|
var PROTOTYPE = 'prototype';
|
|
var SCRIPT = 'script';
|
|
var IE_PROTO = sharedKey('IE_PROTO');
|
|
var EmptyConstructor = function EmptyConstructor() {};
|
|
var scriptTag = function scriptTag(content) {
|
|
return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
|
|
};
|
|
// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
|
|
var NullProtoObjectViaActiveX = function NullProtoObjectViaActiveX(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 NullProtoObjectViaIFrame() {
|
|
// 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 NullProtoObject1() {
|
|
try {
|
|
activeXDocument = new ActiveXObject('htmlfile');
|
|
} catch (error) {}
|
|
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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 99981:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var TO_STRING_TAG_SUPPORT = __webpack_require__(82138);
|
|
var classof = __webpack_require__(20233);
|
|
// `Object.prototype.toString` method implementation
|
|
// https://tc39.es/ecma262/#sec-object.prototype.tostring
|
|
module.exports = TO_STRING_TAG_SUPPORT ? ({}).toString : function toString() {
|
|
return '[object ' + classof(this) + ']';
|
|
};
|
|
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
/************************************************************************/
|
|
/******/ // 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/compat get default export */
|
|
/******/ !function() {
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function() { return module['default']; } :
|
|
/******/ function() { return module; };
|
|
/******/ __webpack_require__.d(getter, { a: getter });
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/define property getters */
|
|
/******/ !function() {
|
|
/******/ // define getter functions for harmony exports
|
|
/******/ __webpack_require__.d = function(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/global */
|
|
/******/ !function() {
|
|
/******/ __webpack_require__.g = (function() {
|
|
/******/ if (typeof globalThis === 'object') return globalThis;
|
|
/******/ try {
|
|
/******/ return this || new Function('return this')();
|
|
/******/ } catch (e) {
|
|
/******/ if (typeof window === 'object') return window;
|
|
/******/ }
|
|
/******/ })();
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
|
/******/ !function() {
|
|
/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/make namespace object */
|
|
/******/ !function() {
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = function(exports) {
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
/******/ }
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
/******/ }();
|
|
/******/
|
|
/************************************************************************/
|
|
var __webpack_exports__ = {};
|
|
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
|
|
!function() {
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony import */ var classlist_polyfill__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(50112);
|
|
/* harmony import */ var classlist_polyfill__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(classlist_polyfill__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var es6_promise_auto__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10990);
|
|
/* harmony import */ var es6_promise_auto__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(es6_promise_auto__WEBPACK_IMPORTED_MODULE_1__);
|
|
/* harmony import */ var core_js_es_symbol__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(57683);
|
|
/* harmony import */ var core_js_es_symbol__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_es_symbol__WEBPACK_IMPORTED_MODULE_2__);
|
|
/* harmony import */ var core_js_es_array_find_index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7796);
|
|
/* harmony import */ var core_js_es_array_find_index__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_es_array_find_index__WEBPACK_IMPORTED_MODULE_3__);
|
|
/* harmony import */ var core_js_es_array_from__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(43098);
|
|
/* harmony import */ var core_js_es_array_from__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(core_js_es_array_from__WEBPACK_IMPORTED_MODULE_4__);
|
|
/*!
|
|
* Jodit Editor (https://xdsoft.net/jodit/)
|
|
* Released under MIT see LICENSE.txt in the project root for license information.
|
|
* Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
|
|
*/
|
|
|
|
|
|
|
|
|
|
// for ie11
|
|
if (!Array.prototype.includes) {
|
|
Array.prototype.includes = function(value) {
|
|
return this.indexOf(value) > -1;
|
|
};
|
|
}
|
|
// for ie11
|
|
if (typeof Object.assign !== 'function') {
|
|
// Must be writable: true, enumerable: false, configurable: true
|
|
Object.defineProperty(Object, 'assign', {
|
|
value: function assign(target, varArgs) {
|
|
// .length of function is 2
|
|
if (target == null) {
|
|
throw new TypeError('Cannot convert undefined or null to object');
|
|
}
|
|
var to = Object(target);
|
|
for(var index = 1; index < arguments.length; index++){
|
|
// eslint-disable-next-line prefer-rest-params
|
|
var nextSource = arguments[index];
|
|
if (nextSource != null) {
|
|
for(var nextKey in nextSource){
|
|
// Avoid bugs when hasOwnProperty is shadowed
|
|
if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
|
|
to[nextKey] = nextSource[nextKey];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return to;
|
|
},
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
if (!Array.prototype.find) {
|
|
Array.prototype.find = function(value) {
|
|
return this.indexOf(value) > -1 ? value : undefined;
|
|
};
|
|
}
|
|
if (!String.prototype.endsWith) {
|
|
String.prototype.endsWith = function(value) {
|
|
return this[this.length - 1] === value;
|
|
};
|
|
}
|
|
|
|
}();
|
|
/******/ return __webpack_exports__;
|
|
/******/ })()
|
|
;
|
|
}); |