mirror of
https://github.com/WordPress/WordPress.git
synced 2024-09-09 22:29:05 +02:00
This patch, somewhat small brings a lot to WordPress. This includes features like: - DataViews. - Customization tools like box shadow, background size and repeat. - UI improvements in the site editor. - Preferences sharing between the post and site editors. - Unified panels and editors between post and site editors. - Improved template mode in the post editor. - Iterations to multiple interactive blocks. - Preparing the blocks and UI for pattern overrides. - and a lot more. Props luisherranz, gziolo, isabel_brison, costdev, jonsurrell, peterwilsoncc, get_dave, antonvlasenko, desrosj. See #60315. Built from https://develop.svn.wordpress.org/trunk@57377 git-svn-id: http://core.svn.wordpress.org/trunk@56883 1a063a9b-81f0-0310-95a4-ce76da25c4cd
4357 lines
126 KiB
JavaScript
4357 lines
126 KiB
JavaScript
/**
|
||
* core-js 3.35.1
|
||
* © 2014-2024 Denis Pushkarev (zloirock.ru)
|
||
* license: https://github.com/zloirock/core-js/blob/v3.35.1/LICENSE
|
||
* source: https://github.com/zloirock/core-js
|
||
*/
|
||
!function (undefined) { 'use strict'; /******/ (function(modules) { // webpackBootstrap
|
||
/******/ // The module cache
|
||
/******/ var installedModules = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ var __webpack_require__ = function (moduleId) {
|
||
/******/
|
||
/******/ // Check if module is in cache
|
||
/******/ if(installedModules[moduleId]) {
|
||
/******/ return installedModules[moduleId].exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = installedModules[moduleId] = {
|
||
/******/ i: moduleId,
|
||
/******/ l: false,
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.l = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/******/
|
||
/******/ // expose the modules object (__webpack_modules__)
|
||
/******/ __webpack_require__.m = modules;
|
||
/******/
|
||
/******/ // expose the module cache
|
||
/******/ __webpack_require__.c = installedModules;
|
||
/******/
|
||
/******/ // define getter function for harmony exports
|
||
/******/ __webpack_require__.d = function(exports, name, getter) {
|
||
/******/ if(!__webpack_require__.o(exports, name)) {
|
||
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
|
||
/******/ }
|
||
/******/ };
|
||
/******/
|
||
/******/ // 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 });
|
||
/******/ };
|
||
/******/
|
||
/******/ // create a fake namespace object
|
||
/******/ // mode & 1: value is a module id, require it
|
||
/******/ // mode & 2: merge all properties of value into the ns
|
||
/******/ // mode & 4: return value when already ns object
|
||
/******/ // mode & 8|1: behave like require
|
||
/******/ __webpack_require__.t = function(value, mode) {
|
||
/******/ if(mode & 1) value = __webpack_require__(value);
|
||
/******/ if(mode & 8) return value;
|
||
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
||
/******/ var ns = Object.create(null);
|
||
/******/ __webpack_require__.r(ns);
|
||
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
|
||
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
|
||
/******/ return ns;
|
||
/******/ };
|
||
/******/
|
||
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
||
/******/ __webpack_require__.n = function(module) {
|
||
/******/ var getter = module && module.__esModule ?
|
||
/******/ function getDefault() { return module['default']; } :
|
||
/******/ function getModuleExports() { return module; };
|
||
/******/ __webpack_require__.d(getter, 'a', getter);
|
||
/******/ return getter;
|
||
/******/ };
|
||
/******/
|
||
/******/ // Object.prototype.hasOwnProperty.call
|
||
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
||
/******/
|
||
/******/ // __webpack_public_path__
|
||
/******/ __webpack_require__.p = "";
|
||
/******/
|
||
/******/
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(__webpack_require__.s = 0);
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ([
|
||
/* 0 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
__webpack_require__(1);
|
||
__webpack_require__(70);
|
||
__webpack_require__(77);
|
||
__webpack_require__(80);
|
||
__webpack_require__(81);
|
||
__webpack_require__(83);
|
||
__webpack_require__(95);
|
||
__webpack_require__(96);
|
||
__webpack_require__(98);
|
||
__webpack_require__(101);
|
||
__webpack_require__(103);
|
||
__webpack_require__(104);
|
||
__webpack_require__(113);
|
||
__webpack_require__(114);
|
||
__webpack_require__(117);
|
||
__webpack_require__(123);
|
||
__webpack_require__(138);
|
||
__webpack_require__(140);
|
||
__webpack_require__(141);
|
||
module.exports = __webpack_require__(142);
|
||
|
||
|
||
/***/ }),
|
||
/* 1 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var toObject = __webpack_require__(38);
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
var setArrayLength = __webpack_require__(67);
|
||
var doesNotExceedSafeInteger = __webpack_require__(69);
|
||
var fails = __webpack_require__(6);
|
||
|
||
var INCORRECT_TO_LENGTH = fails(function () {
|
||
return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
|
||
});
|
||
|
||
// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=12681
|
||
var properErrorOnNonWritableLength = function () {
|
||
try {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
Object.defineProperty([], 'length', { writable: false }).push();
|
||
} catch (error) {
|
||
return error instanceof TypeError;
|
||
}
|
||
};
|
||
|
||
var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
|
||
|
||
// `Array.prototype.push` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.push
|
||
$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
|
||
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
||
push: function push(item) {
|
||
var O = toObject(this);
|
||
var len = lengthOfArrayLike(O);
|
||
var argCount = arguments.length;
|
||
doesNotExceedSafeInteger(len + argCount);
|
||
for (var i = 0; i < argCount; i++) {
|
||
O[len] = arguments[i];
|
||
len++;
|
||
}
|
||
setArrayLength(O, len);
|
||
return len;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 2 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var getOwnPropertyDescriptor = __webpack_require__(4).f;
|
||
var createNonEnumerableProperty = __webpack_require__(42);
|
||
var defineBuiltIn = __webpack_require__(46);
|
||
var defineGlobalProperty = __webpack_require__(36);
|
||
var copyConstructorProperties = __webpack_require__(54);
|
||
var isForced = __webpack_require__(66);
|
||
|
||
/*
|
||
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 = global;
|
||
} else if (STATIC) {
|
||
target = global[TARGET] || defineGlobalProperty(TARGET, {});
|
||
} else {
|
||
target = global[TARGET] && global[TARGET].prototype;
|
||
}
|
||
if (target) for (key in source) {
|
||
sourceProperty = source[key];
|
||
if (options.dontCallGetSet) {
|
||
descriptor = getOwnPropertyDescriptor(target, key);
|
||
targetProperty = descriptor && descriptor.value;
|
||
} else targetProperty = target[key];
|
||
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
|
||
// contained in target
|
||
if (!FORCED && targetProperty !== undefined) {
|
||
if (typeof sourceProperty == typeof targetProperty) continue;
|
||
copyConstructorProperties(sourceProperty, targetProperty);
|
||
}
|
||
// add a flag to not completely full polyfills
|
||
if (options.sham || (targetProperty && targetProperty.sham)) {
|
||
createNonEnumerableProperty(sourceProperty, 'sham', true);
|
||
}
|
||
defineBuiltIn(target, key, sourceProperty, options);
|
||
}
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 3 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var check = function (it) {
|
||
return it && it.Math === Math && it;
|
||
};
|
||
|
||
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
|
||
module.exports =
|
||
// eslint-disable-next-line es/no-global-this -- safe
|
||
check(typeof globalThis == 'object' && globalThis) ||
|
||
check(typeof window == 'object' && window) ||
|
||
// eslint-disable-next-line no-restricted-globals -- safe
|
||
check(typeof self == 'object' && self) ||
|
||
check(typeof global == 'object' && global) ||
|
||
check(typeof this == 'object' && this) ||
|
||
// eslint-disable-next-line no-new-func -- fallback
|
||
(function () { return this; })() || Function('return this')();
|
||
|
||
|
||
/***/ }),
|
||
/* 4 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var call = __webpack_require__(7);
|
||
var propertyIsEnumerableModule = __webpack_require__(9);
|
||
var createPropertyDescriptor = __webpack_require__(10);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var toPropertyKey = __webpack_require__(17);
|
||
var hasOwn = __webpack_require__(37);
|
||
var IE8_DOM_DEFINE = __webpack_require__(40);
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
|
||
// `Object.getOwnPropertyDescriptor` method
|
||
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
||
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
||
O = toIndexedObject(O);
|
||
P = toPropertyKey(P);
|
||
if (IE8_DOM_DEFINE) try {
|
||
return $getOwnPropertyDescriptor(O, P);
|
||
} catch (error) { /* empty */ }
|
||
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 5 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var fails = __webpack_require__(6);
|
||
|
||
// Detect IE8's incomplete defineProperty implementation
|
||
module.exports = !fails(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 6 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = function (exec) {
|
||
try {
|
||
return !!exec();
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 7 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var NATIVE_BIND = __webpack_require__(8);
|
||
|
||
var call = Function.prototype.call;
|
||
|
||
module.exports = NATIVE_BIND ? call.bind(call) : function () {
|
||
return call.apply(call, arguments);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 8 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var fails = __webpack_require__(6);
|
||
|
||
module.exports = !fails(function () {
|
||
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
||
var test = (function () { /* empty */ }).bind();
|
||
// eslint-disable-next-line no-prototype-builtins -- safe
|
||
return typeof test != 'function' || test.hasOwnProperty('prototype');
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 9 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"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;
|
||
|
||
|
||
/***/ }),
|
||
/* 10 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = function (bitmap, value) {
|
||
return {
|
||
enumerable: !(bitmap & 1),
|
||
configurable: !(bitmap & 2),
|
||
writable: !(bitmap & 4),
|
||
value: value
|
||
};
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 11 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// toObject with fallback for non-array-like ES3 strings
|
||
var IndexedObject = __webpack_require__(12);
|
||
var requireObjectCoercible = __webpack_require__(15);
|
||
|
||
module.exports = function (it) {
|
||
return IndexedObject(requireObjectCoercible(it));
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 12 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var fails = __webpack_require__(6);
|
||
var classof = __webpack_require__(14);
|
||
|
||
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;
|
||
|
||
|
||
/***/ }),
|
||
/* 13 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var NATIVE_BIND = __webpack_require__(8);
|
||
|
||
var FunctionPrototype = Function.prototype;
|
||
var call = FunctionPrototype.call;
|
||
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
|
||
|
||
module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
|
||
return function () {
|
||
return call.apply(fn, arguments);
|
||
};
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 14 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
var toString = uncurryThis({}.toString);
|
||
var stringSlice = uncurryThis(''.slice);
|
||
|
||
module.exports = function (it) {
|
||
return stringSlice(toString(it), 8, -1);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 15 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isNullOrUndefined = __webpack_require__(16);
|
||
|
||
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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 16 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 17 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toPrimitive = __webpack_require__(18);
|
||
var isSymbol = __webpack_require__(21);
|
||
|
||
// `ToPropertyKey` abstract operation
|
||
// https://tc39.es/ecma262/#sec-topropertykey
|
||
module.exports = function (argument) {
|
||
var key = toPrimitive(argument, 'string');
|
||
return isSymbol(key) ? key : key + '';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 18 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var call = __webpack_require__(7);
|
||
var isObject = __webpack_require__(19);
|
||
var isSymbol = __webpack_require__(21);
|
||
var getMethod = __webpack_require__(28);
|
||
var ordinaryToPrimitive = __webpack_require__(31);
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 19 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isCallable = __webpack_require__(20);
|
||
|
||
module.exports = function (it) {
|
||
return typeof it == 'object' ? it !== null : isCallable(it);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 20 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
|
||
var documentAll = typeof document == 'object' && document.all;
|
||
|
||
// `IsCallable` abstract operation
|
||
// https://tc39.es/ecma262/#sec-iscallable
|
||
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
|
||
module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
|
||
return typeof argument == 'function' || argument === documentAll;
|
||
} : function (argument) {
|
||
return typeof argument == 'function';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 21 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var isCallable = __webpack_require__(20);
|
||
var isPrototypeOf = __webpack_require__(23);
|
||
var USE_SYMBOL_AS_UID = __webpack_require__(24);
|
||
|
||
var $Object = Object;
|
||
|
||
module.exports = USE_SYMBOL_AS_UID ? function (it) {
|
||
return typeof it == 'symbol';
|
||
} : function (it) {
|
||
var $Symbol = getBuiltIn('Symbol');
|
||
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 22 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var isCallable = __webpack_require__(20);
|
||
|
||
var aFunction = function (argument) {
|
||
return isCallable(argument) ? argument : undefined;
|
||
};
|
||
|
||
module.exports = function (namespace, method) {
|
||
return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 23 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
module.exports = uncurryThis({}.isPrototypeOf);
|
||
|
||
|
||
/***/ }),
|
||
/* 24 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/* eslint-disable es/no-symbol -- required for testing */
|
||
var NATIVE_SYMBOL = __webpack_require__(25);
|
||
|
||
module.exports = NATIVE_SYMBOL
|
||
&& !Symbol.sham
|
||
&& typeof Symbol.iterator == 'symbol';
|
||
|
||
|
||
/***/ }),
|
||
/* 25 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/* eslint-disable es/no-symbol -- required for testing */
|
||
var V8_VERSION = __webpack_require__(26);
|
||
var fails = __webpack_require__(6);
|
||
var global = __webpack_require__(3);
|
||
|
||
var $String = global.String;
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
|
||
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
|
||
var symbol = Symbol('symbol detection');
|
||
// Chrome 38 Symbol has incorrect toString conversion
|
||
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
|
||
// nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
|
||
// of course, fail.
|
||
return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
|
||
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
||
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 26 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var userAgent = __webpack_require__(27);
|
||
|
||
var process = global.process;
|
||
var Deno = global.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;
|
||
|
||
|
||
/***/ }),
|
||
/* 27 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
|
||
|
||
|
||
/***/ }),
|
||
/* 28 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var aCallable = __webpack_require__(29);
|
||
var isNullOrUndefined = __webpack_require__(16);
|
||
|
||
// `GetMethod` abstract operation
|
||
// https://tc39.es/ecma262/#sec-getmethod
|
||
module.exports = function (V, P) {
|
||
var func = V[P];
|
||
return isNullOrUndefined(func) ? undefined : aCallable(func);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 29 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isCallable = __webpack_require__(20);
|
||
var tryToString = __webpack_require__(30);
|
||
|
||
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');
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 30 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $String = String;
|
||
|
||
module.exports = function (argument) {
|
||
try {
|
||
return $String(argument);
|
||
} catch (error) {
|
||
return 'Object';
|
||
}
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 31 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var call = __webpack_require__(7);
|
||
var isCallable = __webpack_require__(20);
|
||
var isObject = __webpack_require__(19);
|
||
|
||
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");
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 32 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var shared = __webpack_require__(33);
|
||
var hasOwn = __webpack_require__(37);
|
||
var uid = __webpack_require__(39);
|
||
var NATIVE_SYMBOL = __webpack_require__(25);
|
||
var USE_SYMBOL_AS_UID = __webpack_require__(24);
|
||
|
||
var Symbol = global.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];
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 33 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var IS_PURE = __webpack_require__(34);
|
||
var store = __webpack_require__(35);
|
||
|
||
(module.exports = function (key, value) {
|
||
return store[key] || (store[key] = value !== undefined ? value : {});
|
||
})('versions', []).push({
|
||
version: '3.35.1',
|
||
mode: IS_PURE ? 'pure' : 'global',
|
||
copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
|
||
license: 'https://github.com/zloirock/core-js/blob/v3.35.1/LICENSE',
|
||
source: 'https://github.com/zloirock/core-js'
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 34 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = false;
|
||
|
||
|
||
/***/ }),
|
||
/* 35 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var defineGlobalProperty = __webpack_require__(36);
|
||
|
||
var SHARED = '__core-js_shared__';
|
||
var store = global[SHARED] || defineGlobalProperty(SHARED, {});
|
||
|
||
module.exports = store;
|
||
|
||
|
||
/***/ }),
|
||
/* 36 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var defineProperty = Object.defineProperty;
|
||
|
||
module.exports = function (key, value) {
|
||
try {
|
||
defineProperty(global, key, { value: value, configurable: true, writable: true });
|
||
} catch (error) {
|
||
global[key] = value;
|
||
} return value;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 37 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var toObject = __webpack_require__(38);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 38 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var requireObjectCoercible = __webpack_require__(15);
|
||
|
||
var $Object = Object;
|
||
|
||
// `ToObject` abstract operation
|
||
// https://tc39.es/ecma262/#sec-toobject
|
||
module.exports = function (argument) {
|
||
return $Object(requireObjectCoercible(argument));
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 39 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
var id = 0;
|
||
var postfix = Math.random();
|
||
var toString = uncurryThis(1.0.toString);
|
||
|
||
module.exports = function (key) {
|
||
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 40 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var fails = __webpack_require__(6);
|
||
var createElement = __webpack_require__(41);
|
||
|
||
// Thanks to IE8 for its funny defineProperty
|
||
module.exports = !DESCRIPTORS && !fails(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty(createElement('div'), 'a', {
|
||
get: function () { return 7; }
|
||
}).a !== 7;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 41 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var isObject = __webpack_require__(19);
|
||
|
||
var document = global.document;
|
||
// typeof document.createElement is 'object' in old IE
|
||
var EXISTS = isObject(document) && isObject(document.createElement);
|
||
|
||
module.exports = function (it) {
|
||
return EXISTS ? document.createElement(it) : {};
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 42 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var definePropertyModule = __webpack_require__(43);
|
||
var createPropertyDescriptor = __webpack_require__(10);
|
||
|
||
module.exports = DESCRIPTORS ? function (object, key, value) {
|
||
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
||
} : function (object, key, value) {
|
||
object[key] = value;
|
||
return object;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 43 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var IE8_DOM_DEFINE = __webpack_require__(40);
|
||
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(44);
|
||
var anObject = __webpack_require__(45);
|
||
var toPropertyKey = __webpack_require__(17);
|
||
|
||
var $TypeError = TypeError;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var $defineProperty = Object.defineProperty;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
var ENUMERABLE = 'enumerable';
|
||
var CONFIGURABLE = 'configurable';
|
||
var WRITABLE = 'writable';
|
||
|
||
// `Object.defineProperty` method
|
||
// https://tc39.es/ecma262/#sec-object.defineproperty
|
||
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
|
||
anObject(O);
|
||
P = toPropertyKey(P);
|
||
anObject(Attributes);
|
||
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
||
var current = $getOwnPropertyDescriptor(O, P);
|
||
if (current && current[WRITABLE]) {
|
||
O[P] = Attributes.value;
|
||
Attributes = {
|
||
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
|
||
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
|
||
writable: false
|
||
};
|
||
}
|
||
} return $defineProperty(O, P, Attributes);
|
||
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
||
anObject(O);
|
||
P = toPropertyKey(P);
|
||
anObject(Attributes);
|
||
if (IE8_DOM_DEFINE) try {
|
||
return $defineProperty(O, P, Attributes);
|
||
} catch (error) { /* empty */ }
|
||
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
|
||
if ('value' in Attributes) O[P] = Attributes.value;
|
||
return O;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 44 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var fails = __webpack_require__(6);
|
||
|
||
// V8 ~ Chrome 36-
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
||
module.exports = DESCRIPTORS && fails(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
|
||
value: 42,
|
||
writable: false
|
||
}).prototype !== 42;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 45 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isObject = __webpack_require__(19);
|
||
|
||
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');
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 46 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isCallable = __webpack_require__(20);
|
||
var definePropertyModule = __webpack_require__(43);
|
||
var makeBuiltIn = __webpack_require__(47);
|
||
var defineGlobalProperty = __webpack_require__(36);
|
||
|
||
module.exports = function (O, key, value, options) {
|
||
if (!options) options = {};
|
||
var simple = options.enumerable;
|
||
var name = options.name !== undefined ? options.name : key;
|
||
if (isCallable(value)) makeBuiltIn(value, name, options);
|
||
if (options.global) {
|
||
if (simple) O[key] = value;
|
||
else defineGlobalProperty(key, value);
|
||
} else {
|
||
try {
|
||
if (!options.unsafe) delete O[key];
|
||
else if (O[key]) simple = true;
|
||
} catch (error) { /* empty */ }
|
||
if (simple) O[key] = value;
|
||
else definePropertyModule.f(O, key, {
|
||
value: value,
|
||
enumerable: false,
|
||
configurable: !options.nonConfigurable,
|
||
writable: !options.nonWritable
|
||
});
|
||
} return O;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 47 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var fails = __webpack_require__(6);
|
||
var isCallable = __webpack_require__(20);
|
||
var hasOwn = __webpack_require__(37);
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(48).CONFIGURABLE;
|
||
var inspectSource = __webpack_require__(49);
|
||
var InternalStateModule = __webpack_require__(50);
|
||
|
||
var enforceInternalState = InternalStateModule.enforce;
|
||
var getInternalState = InternalStateModule.get;
|
||
var $String = String;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var defineProperty = Object.defineProperty;
|
||
var stringSlice = uncurryThis(''.slice);
|
||
var replace = uncurryThis(''.replace);
|
||
var join = uncurryThis([].join);
|
||
|
||
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
|
||
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
|
||
});
|
||
|
||
var TEMPLATE = String(String).split('String');
|
||
|
||
var makeBuiltIn = module.exports = function (value, name, options) {
|
||
if (stringSlice($String(name), 0, 7) === 'Symbol(') {
|
||
name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
|
||
}
|
||
if (options && options.getter) name = 'get ' + name;
|
||
if (options && options.setter) name = 'set ' + name;
|
||
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
|
||
if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
|
||
else value.name = name;
|
||
}
|
||
if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
|
||
defineProperty(value, 'length', { value: options.arity });
|
||
}
|
||
try {
|
||
if (options && hasOwn(options, 'constructor') && options.constructor) {
|
||
if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
|
||
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
|
||
} else if (value.prototype) value.prototype = undefined;
|
||
} catch (error) { /* empty */ }
|
||
var state = enforceInternalState(value);
|
||
if (!hasOwn(state, 'source')) {
|
||
state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
|
||
} return value;
|
||
};
|
||
|
||
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
|
||
// eslint-disable-next-line no-extend-native -- required
|
||
Function.prototype.toString = makeBuiltIn(function toString() {
|
||
return isCallable(this) && getInternalState(this).source || inspectSource(this);
|
||
}, 'toString');
|
||
|
||
|
||
/***/ }),
|
||
/* 48 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var hasOwn = __webpack_require__(37);
|
||
|
||
var FunctionPrototype = Function.prototype;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
|
||
|
||
var EXISTS = hasOwn(FunctionPrototype, 'name');
|
||
// additional protection from minified / mangled / dropped function names
|
||
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
|
||
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
|
||
|
||
module.exports = {
|
||
EXISTS: EXISTS,
|
||
PROPER: PROPER,
|
||
CONFIGURABLE: CONFIGURABLE
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 49 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var isCallable = __webpack_require__(20);
|
||
var store = __webpack_require__(35);
|
||
|
||
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;
|
||
|
||
|
||
/***/ }),
|
||
/* 50 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var NATIVE_WEAK_MAP = __webpack_require__(51);
|
||
var global = __webpack_require__(3);
|
||
var isObject = __webpack_require__(19);
|
||
var createNonEnumerableProperty = __webpack_require__(42);
|
||
var hasOwn = __webpack_require__(37);
|
||
var shared = __webpack_require__(35);
|
||
var sharedKey = __webpack_require__(52);
|
||
var hiddenKeys = __webpack_require__(53);
|
||
|
||
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
||
var TypeError = global.TypeError;
|
||
var WeakMap = global.WeakMap;
|
||
var set, get, has;
|
||
|
||
var enforce = function (it) {
|
||
return has(it) ? get(it) : set(it, {});
|
||
};
|
||
|
||
var getterFor = function (TYPE) {
|
||
return function (it) {
|
||
var state;
|
||
if (!isObject(it) || (state = get(it)).type !== TYPE) {
|
||
throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
|
||
} return state;
|
||
};
|
||
};
|
||
|
||
if (NATIVE_WEAK_MAP || shared.state) {
|
||
var store = shared.state || (shared.state = new WeakMap());
|
||
/* eslint-disable no-self-assign -- prototype methods protection */
|
||
store.get = store.get;
|
||
store.has = store.has;
|
||
store.set = store.set;
|
||
/* eslint-enable no-self-assign -- prototype methods protection */
|
||
set = function (it, metadata) {
|
||
if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
||
metadata.facade = it;
|
||
store.set(it, metadata);
|
||
return metadata;
|
||
};
|
||
get = function (it) {
|
||
return store.get(it) || {};
|
||
};
|
||
has = function (it) {
|
||
return store.has(it);
|
||
};
|
||
} else {
|
||
var STATE = sharedKey('state');
|
||
hiddenKeys[STATE] = true;
|
||
set = function (it, metadata) {
|
||
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
||
metadata.facade = it;
|
||
createNonEnumerableProperty(it, STATE, metadata);
|
||
return metadata;
|
||
};
|
||
get = function (it) {
|
||
return hasOwn(it, STATE) ? it[STATE] : {};
|
||
};
|
||
has = function (it) {
|
||
return hasOwn(it, STATE);
|
||
};
|
||
}
|
||
|
||
module.exports = {
|
||
set: set,
|
||
get: get,
|
||
has: has,
|
||
enforce: enforce,
|
||
getterFor: getterFor
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 51 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var isCallable = __webpack_require__(20);
|
||
|
||
var WeakMap = global.WeakMap;
|
||
|
||
module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
|
||
|
||
|
||
/***/ }),
|
||
/* 52 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var shared = __webpack_require__(33);
|
||
var uid = __webpack_require__(39);
|
||
|
||
var keys = shared('keys');
|
||
|
||
module.exports = function (key) {
|
||
return keys[key] || (keys[key] = uid(key));
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 53 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = {};
|
||
|
||
|
||
/***/ }),
|
||
/* 54 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var hasOwn = __webpack_require__(37);
|
||
var ownKeys = __webpack_require__(55);
|
||
var getOwnPropertyDescriptorModule = __webpack_require__(4);
|
||
var definePropertyModule = __webpack_require__(43);
|
||
|
||
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));
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 55 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var getOwnPropertyNamesModule = __webpack_require__(56);
|
||
var getOwnPropertySymbolsModule = __webpack_require__(65);
|
||
var anObject = __webpack_require__(45);
|
||
|
||
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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 56 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var internalObjectKeys = __webpack_require__(57);
|
||
var enumBugKeys = __webpack_require__(64);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 57 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var hasOwn = __webpack_require__(37);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var indexOf = __webpack_require__(58).indexOf;
|
||
var hiddenKeys = __webpack_require__(53);
|
||
|
||
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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 58 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var toAbsoluteIndex = __webpack_require__(59);
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
|
||
// `Array.prototype.{ indexOf, includes }` methods implementation
|
||
var createMethod = function (IS_INCLUDES) {
|
||
return function ($this, el, fromIndex) {
|
||
var O = toIndexedObject($this);
|
||
var length = lengthOfArrayLike(O);
|
||
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)
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 59 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toIntegerOrInfinity = __webpack_require__(60);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 60 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var trunc = __webpack_require__(61);
|
||
|
||
// `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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 61 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 62 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toLength = __webpack_require__(63);
|
||
|
||
// `LengthOfArrayLike` abstract operation
|
||
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
||
module.exports = function (obj) {
|
||
return toLength(obj.length);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 63 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toIntegerOrInfinity = __webpack_require__(60);
|
||
|
||
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
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 64 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// IE8- don't enum bug keys
|
||
module.exports = [
|
||
'constructor',
|
||
'hasOwnProperty',
|
||
'isPrototypeOf',
|
||
'propertyIsEnumerable',
|
||
'toLocaleString',
|
||
'toString',
|
||
'valueOf'
|
||
];
|
||
|
||
|
||
/***/ }),
|
||
/* 65 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
|
||
exports.f = Object.getOwnPropertySymbols;
|
||
|
||
|
||
/***/ }),
|
||
/* 66 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var fails = __webpack_require__(6);
|
||
var isCallable = __webpack_require__(20);
|
||
|
||
var replacement = /#|\.prototype\./;
|
||
|
||
var isForced = function (feature, detection) {
|
||
var value = data[normalize(feature)];
|
||
return value === POLYFILL ? true
|
||
: value === NATIVE ? false
|
||
: isCallable(detection) ? fails(detection)
|
||
: !!detection;
|
||
};
|
||
|
||
var normalize = isForced.normalize = function (string) {
|
||
return String(string).replace(replacement, '.').toLowerCase();
|
||
};
|
||
|
||
var data = isForced.data = {};
|
||
var NATIVE = isForced.NATIVE = 'N';
|
||
var POLYFILL = isForced.POLYFILL = 'P';
|
||
|
||
module.exports = isForced;
|
||
|
||
|
||
/***/ }),
|
||
/* 67 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var isArray = __webpack_require__(68);
|
||
|
||
var $TypeError = TypeError;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
|
||
// Safari < 13 does not throw an error in this case
|
||
var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
|
||
// makes no sense without proper strict mode support
|
||
if (this !== undefined) return true;
|
||
try {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
Object.defineProperty([], 'length', { writable: false }).length = 1;
|
||
} catch (error) {
|
||
return error instanceof TypeError;
|
||
}
|
||
}();
|
||
|
||
module.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
|
||
if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
|
||
throw new $TypeError('Cannot set read only .length');
|
||
} return O.length = length;
|
||
} : function (O, length) {
|
||
return O.length = length;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 68 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var classof = __webpack_require__(14);
|
||
|
||
// `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';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 69 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 70 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var arrayToReversed = __webpack_require__(71);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var addToUnscopables = __webpack_require__(72);
|
||
|
||
var $Array = Array;
|
||
|
||
// `Array.prototype.toReversed` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.toreversed
|
||
$({ target: 'Array', proto: true }, {
|
||
toReversed: function toReversed() {
|
||
return arrayToReversed(toIndexedObject(this), $Array);
|
||
}
|
||
});
|
||
|
||
addToUnscopables('toReversed');
|
||
|
||
|
||
/***/ }),
|
||
/* 71 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
|
||
// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toReversed
|
||
// https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toReversed
|
||
module.exports = function (O, C) {
|
||
var len = lengthOfArrayLike(O);
|
||
var A = new C(len);
|
||
var k = 0;
|
||
for (; k < len; k++) A[k] = O[len - k - 1];
|
||
return A;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 72 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
var create = __webpack_require__(73);
|
||
var defineProperty = __webpack_require__(43).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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 73 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/* global ActiveXObject -- old IE, WSH */
|
||
var anObject = __webpack_require__(45);
|
||
var definePropertiesModule = __webpack_require__(74);
|
||
var enumBugKeys = __webpack_require__(64);
|
||
var hiddenKeys = __webpack_require__(53);
|
||
var html = __webpack_require__(76);
|
||
var documentCreateElement = __webpack_require__(41);
|
||
var sharedKey = __webpack_require__(52);
|
||
|
||
var GT = '>';
|
||
var LT = '<';
|
||
var PROTOTYPE = 'prototype';
|
||
var SCRIPT = 'script';
|
||
var IE_PROTO = sharedKey('IE_PROTO');
|
||
|
||
var EmptyConstructor = function () { /* empty */ };
|
||
|
||
var scriptTag = function (content) {
|
||
return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
|
||
};
|
||
|
||
// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
|
||
var NullProtoObjectViaActiveX = function (activeXDocument) {
|
||
activeXDocument.write(scriptTag(''));
|
||
activeXDocument.close();
|
||
var temp = activeXDocument.parentWindow.Object;
|
||
activeXDocument = null; // avoid memory leak
|
||
return temp;
|
||
};
|
||
|
||
// Create object with fake `null` prototype: use iframe Object with cleared prototype
|
||
var NullProtoObjectViaIFrame = function () {
|
||
// Thrash, waste and sodomy: IE GC bug
|
||
var iframe = documentCreateElement('iframe');
|
||
var JS = 'java' + SCRIPT + ':';
|
||
var iframeDocument;
|
||
iframe.style.display = 'none';
|
||
html.appendChild(iframe);
|
||
// https://github.com/zloirock/core-js/issues/475
|
||
iframe.src = String(JS);
|
||
iframeDocument = iframe.contentWindow.document;
|
||
iframeDocument.open();
|
||
iframeDocument.write(scriptTag('document.F=Object'));
|
||
iframeDocument.close();
|
||
return iframeDocument.F;
|
||
};
|
||
|
||
// Check for document.domain and active x support
|
||
// No need to use active x approach when document.domain is not set
|
||
// see https://github.com/es-shims/es5-shim/issues/150
|
||
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
|
||
// avoid IE GC bug
|
||
var activeXDocument;
|
||
var NullProtoObject = function () {
|
||
try {
|
||
activeXDocument = new ActiveXObject('htmlfile');
|
||
} catch (error) { /* ignore */ }
|
||
NullProtoObject = typeof document != 'undefined'
|
||
? document.domain && activeXDocument
|
||
? NullProtoObjectViaActiveX(activeXDocument) // old IE
|
||
: NullProtoObjectViaIFrame()
|
||
: NullProtoObjectViaActiveX(activeXDocument); // WSH
|
||
var length = enumBugKeys.length;
|
||
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
|
||
return NullProtoObject();
|
||
};
|
||
|
||
hiddenKeys[IE_PROTO] = true;
|
||
|
||
// `Object.create` method
|
||
// https://tc39.es/ecma262/#sec-object.create
|
||
// eslint-disable-next-line es/no-object-create -- safe
|
||
module.exports = Object.create || function create(O, Properties) {
|
||
var result;
|
||
if (O !== null) {
|
||
EmptyConstructor[PROTOTYPE] = anObject(O);
|
||
result = new EmptyConstructor();
|
||
EmptyConstructor[PROTOTYPE] = null;
|
||
// add "__proto__" for Object.getPrototypeOf polyfill
|
||
result[IE_PROTO] = O;
|
||
} else result = NullProtoObject();
|
||
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 74 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(44);
|
||
var definePropertyModule = __webpack_require__(43);
|
||
var anObject = __webpack_require__(45);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var objectKeys = __webpack_require__(75);
|
||
|
||
// `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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 75 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var internalObjectKeys = __webpack_require__(57);
|
||
var enumBugKeys = __webpack_require__(64);
|
||
|
||
// `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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 76 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var getBuiltIn = __webpack_require__(22);
|
||
|
||
module.exports = getBuiltIn('document', 'documentElement');
|
||
|
||
|
||
/***/ }),
|
||
/* 77 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var aCallable = __webpack_require__(29);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var arrayFromConstructorAndList = __webpack_require__(78);
|
||
var getBuiltInPrototypeMethod = __webpack_require__(79);
|
||
var addToUnscopables = __webpack_require__(72);
|
||
|
||
var $Array = Array;
|
||
var sort = uncurryThis(getBuiltInPrototypeMethod('Array', 'sort'));
|
||
|
||
// `Array.prototype.toSorted` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.tosorted
|
||
$({ target: 'Array', proto: true }, {
|
||
toSorted: function toSorted(compareFn) {
|
||
if (compareFn !== undefined) aCallable(compareFn);
|
||
var O = toIndexedObject(this);
|
||
var A = arrayFromConstructorAndList($Array, O);
|
||
return sort(A, compareFn);
|
||
}
|
||
});
|
||
|
||
addToUnscopables('toSorted');
|
||
|
||
|
||
/***/ }),
|
||
/* 78 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
|
||
module.exports = function (Constructor, list, $length) {
|
||
var index = 0;
|
||
var length = arguments.length > 2 ? $length : lengthOfArrayLike(list);
|
||
var result = new Constructor(length);
|
||
while (length > index) result[index] = list[index++];
|
||
return result;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 79 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
|
||
module.exports = function (CONSTRUCTOR, METHOD) {
|
||
var Constructor = global[CONSTRUCTOR];
|
||
var Prototype = Constructor && Constructor.prototype;
|
||
return Prototype && Prototype[METHOD];
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 80 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var addToUnscopables = __webpack_require__(72);
|
||
var doesNotExceedSafeInteger = __webpack_require__(69);
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
var toAbsoluteIndex = __webpack_require__(59);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
var toIntegerOrInfinity = __webpack_require__(60);
|
||
|
||
var $Array = Array;
|
||
var max = Math.max;
|
||
var min = Math.min;
|
||
|
||
// `Array.prototype.toSpliced` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.tospliced
|
||
$({ target: 'Array', proto: true }, {
|
||
toSpliced: function toSpliced(start, deleteCount /* , ...items */) {
|
||
var O = toIndexedObject(this);
|
||
var len = lengthOfArrayLike(O);
|
||
var actualStart = toAbsoluteIndex(start, len);
|
||
var argumentsLength = arguments.length;
|
||
var k = 0;
|
||
var insertCount, actualDeleteCount, newLen, A;
|
||
if (argumentsLength === 0) {
|
||
insertCount = actualDeleteCount = 0;
|
||
} else if (argumentsLength === 1) {
|
||
insertCount = 0;
|
||
actualDeleteCount = len - actualStart;
|
||
} else {
|
||
insertCount = argumentsLength - 2;
|
||
actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart);
|
||
}
|
||
newLen = doesNotExceedSafeInteger(len + insertCount - actualDeleteCount);
|
||
A = $Array(newLen);
|
||
|
||
for (; k < actualStart; k++) A[k] = O[k];
|
||
for (; k < actualStart + insertCount; k++) A[k] = arguments[k - actualStart + 2];
|
||
for (; k < newLen; k++) A[k] = O[k + actualDeleteCount - insertCount];
|
||
|
||
return A;
|
||
}
|
||
});
|
||
|
||
addToUnscopables('toSpliced');
|
||
|
||
|
||
/***/ }),
|
||
/* 81 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var arrayWith = __webpack_require__(82);
|
||
var toIndexedObject = __webpack_require__(11);
|
||
|
||
var $Array = Array;
|
||
|
||
// `Array.prototype.with` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.with
|
||
$({ target: 'Array', proto: true }, {
|
||
'with': function (index, value) {
|
||
return arrayWith(toIndexedObject(this), $Array, index, value);
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 82 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
var toIntegerOrInfinity = __webpack_require__(60);
|
||
|
||
var $RangeError = RangeError;
|
||
|
||
// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.with
|
||
// https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.with
|
||
module.exports = function (O, C, index, value) {
|
||
var len = lengthOfArrayLike(O);
|
||
var relativeIndex = toIntegerOrInfinity(index);
|
||
var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex;
|
||
if (actualIndex >= len || actualIndex < 0) throw new $RangeError('Incorrect index');
|
||
var A = new C(len);
|
||
var k = 0;
|
||
for (; k < len; k++) A[k] = k === actualIndex ? value : O[k];
|
||
return A;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 83 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var aCallable = __webpack_require__(29);
|
||
var requireObjectCoercible = __webpack_require__(15);
|
||
var iterate = __webpack_require__(84);
|
||
var MapHelpers = __webpack_require__(94);
|
||
var IS_PURE = __webpack_require__(34);
|
||
|
||
var Map = MapHelpers.Map;
|
||
var has = MapHelpers.has;
|
||
var get = MapHelpers.get;
|
||
var set = MapHelpers.set;
|
||
var push = uncurryThis([].push);
|
||
|
||
// `Map.groupBy` method
|
||
// https://github.com/tc39/proposal-array-grouping
|
||
$({ target: 'Map', stat: true, forced: IS_PURE }, {
|
||
groupBy: function groupBy(items, callbackfn) {
|
||
requireObjectCoercible(items);
|
||
aCallable(callbackfn);
|
||
var map = new Map();
|
||
var k = 0;
|
||
iterate(items, function (value) {
|
||
var key = callbackfn(value, k++);
|
||
if (!has(map, key)) set(map, key, [value]);
|
||
else push(get(map, key), value);
|
||
});
|
||
return map;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 84 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var bind = __webpack_require__(85);
|
||
var call = __webpack_require__(7);
|
||
var anObject = __webpack_require__(45);
|
||
var tryToString = __webpack_require__(30);
|
||
var isArrayIteratorMethod = __webpack_require__(87);
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
var isPrototypeOf = __webpack_require__(23);
|
||
var getIterator = __webpack_require__(89);
|
||
var getIteratorMethod = __webpack_require__(90);
|
||
var iteratorClose = __webpack_require__(93);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
var Result = function (stopped, result) {
|
||
this.stopped = stopped;
|
||
this.result = result;
|
||
};
|
||
|
||
var ResultPrototype = Result.prototype;
|
||
|
||
module.exports = function (iterable, unboundFunction, options) {
|
||
var that = options && options.that;
|
||
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
|
||
var IS_RECORD = !!(options && options.IS_RECORD);
|
||
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
|
||
var INTERRUPTED = !!(options && options.INTERRUPTED);
|
||
var fn = bind(unboundFunction, that);
|
||
var iterator, iterFn, index, length, result, next, step;
|
||
|
||
var stop = function (condition) {
|
||
if (iterator) iteratorClose(iterator, 'normal', condition);
|
||
return new Result(true, condition);
|
||
};
|
||
|
||
var callFn = function (value) {
|
||
if (AS_ENTRIES) {
|
||
anObject(value);
|
||
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
|
||
} return INTERRUPTED ? fn(value, stop) : fn(value);
|
||
};
|
||
|
||
if (IS_RECORD) {
|
||
iterator = iterable.iterator;
|
||
} else if (IS_ITERATOR) {
|
||
iterator = iterable;
|
||
} else {
|
||
iterFn = getIteratorMethod(iterable);
|
||
if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
|
||
// optimisation for array iterators
|
||
if (isArrayIteratorMethod(iterFn)) {
|
||
for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
|
||
result = callFn(iterable[index]);
|
||
if (result && isPrototypeOf(ResultPrototype, result)) return result;
|
||
} return new Result(false);
|
||
}
|
||
iterator = getIterator(iterable, iterFn);
|
||
}
|
||
|
||
next = IS_RECORD ? iterable.next : iterator.next;
|
||
while (!(step = call(next, iterator)).done) {
|
||
try {
|
||
result = callFn(step.value);
|
||
} catch (error) {
|
||
iteratorClose(iterator, 'throw', error);
|
||
}
|
||
if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
|
||
} return new Result(false);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 85 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(86);
|
||
var aCallable = __webpack_require__(29);
|
||
var NATIVE_BIND = __webpack_require__(8);
|
||
|
||
var bind = uncurryThis(uncurryThis.bind);
|
||
|
||
// optional / simple context binding
|
||
module.exports = function (fn, that) {
|
||
aCallable(fn);
|
||
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
|
||
return fn.apply(that, arguments);
|
||
};
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 86 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var classofRaw = __webpack_require__(14);
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 87 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
var Iterators = __webpack_require__(88);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 88 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = {};
|
||
|
||
|
||
/***/ }),
|
||
/* 89 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var call = __webpack_require__(7);
|
||
var aCallable = __webpack_require__(29);
|
||
var anObject = __webpack_require__(45);
|
||
var tryToString = __webpack_require__(30);
|
||
var getIteratorMethod = __webpack_require__(90);
|
||
|
||
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');
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 90 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var classof = __webpack_require__(91);
|
||
var getMethod = __webpack_require__(28);
|
||
var isNullOrUndefined = __webpack_require__(16);
|
||
var Iterators = __webpack_require__(88);
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
|
||
var ITERATOR = wellKnownSymbol('iterator');
|
||
|
||
module.exports = function (it) {
|
||
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
|
||
|| getMethod(it, '@@iterator')
|
||
|| Iterators[classof(it)];
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 91 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var TO_STRING_TAG_SUPPORT = __webpack_require__(92);
|
||
var isCallable = __webpack_require__(20);
|
||
var classofRaw = __webpack_require__(14);
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
var $Object = Object;
|
||
|
||
// ES3 wrong here
|
||
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
|
||
|
||
// fallback for IE11 Script Access Denied error
|
||
var tryGet = function (it, key) {
|
||
try {
|
||
return it[key];
|
||
} catch (error) { /* empty */ }
|
||
};
|
||
|
||
// getting tag from ES6+ `Object.prototype.toString`
|
||
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
|
||
var O, tag, result;
|
||
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
||
// @@toStringTag case
|
||
: typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
|
||
// builtinTag case
|
||
: CORRECT_ARGUMENTS ? classofRaw(O)
|
||
// ES3 arguments fallback
|
||
: (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 92 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
var test = {};
|
||
|
||
test[TO_STRING_TAG] = 'z';
|
||
|
||
module.exports = String(test) === '[object z]';
|
||
|
||
|
||
/***/ }),
|
||
/* 93 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var call = __webpack_require__(7);
|
||
var anObject = __webpack_require__(45);
|
||
var getMethod = __webpack_require__(28);
|
||
|
||
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;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 94 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
// eslint-disable-next-line es/no-map -- safe
|
||
var MapPrototype = Map.prototype;
|
||
|
||
module.exports = {
|
||
// eslint-disable-next-line es/no-map -- safe
|
||
Map: Map,
|
||
set: uncurryThis(MapPrototype.set),
|
||
get: uncurryThis(MapPrototype.get),
|
||
has: uncurryThis(MapPrototype.has),
|
||
remove: uncurryThis(MapPrototype['delete']),
|
||
proto: MapPrototype
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 95 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var aCallable = __webpack_require__(29);
|
||
var requireObjectCoercible = __webpack_require__(15);
|
||
var toPropertyKey = __webpack_require__(17);
|
||
var iterate = __webpack_require__(84);
|
||
|
||
var create = getBuiltIn('Object', 'create');
|
||
var push = uncurryThis([].push);
|
||
|
||
// `Object.groupBy` method
|
||
// https://github.com/tc39/proposal-array-grouping
|
||
$({ target: 'Object', stat: true }, {
|
||
groupBy: function groupBy(items, callbackfn) {
|
||
requireObjectCoercible(items);
|
||
aCallable(callbackfn);
|
||
var obj = create(null);
|
||
var k = 0;
|
||
iterate(items, function (value) {
|
||
var key = toPropertyKey(callbackfn(value, k++));
|
||
// in some IE versions, `hasOwnProperty` returns incorrect result on integer keys
|
||
// but since it's a `null` prototype object, we can safely use `in`
|
||
if (key in obj) push(obj[key], value);
|
||
else obj[key] = [value];
|
||
});
|
||
return obj;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 96 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var newPromiseCapabilityModule = __webpack_require__(97);
|
||
|
||
// `Promise.withResolvers` method
|
||
// https://github.com/tc39/proposal-promise-with-resolvers
|
||
$({ target: 'Promise', stat: true }, {
|
||
withResolvers: function withResolvers() {
|
||
var promiseCapability = newPromiseCapabilityModule.f(this);
|
||
return {
|
||
promise: promiseCapability.promise,
|
||
resolve: promiseCapability.resolve,
|
||
reject: promiseCapability.reject
|
||
};
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 97 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var aCallable = __webpack_require__(29);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
var PromiseCapability = function (C) {
|
||
var resolve, reject;
|
||
this.promise = new C(function ($$resolve, $$reject) {
|
||
if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
|
||
resolve = $$resolve;
|
||
reject = $$reject;
|
||
});
|
||
this.resolve = aCallable(resolve);
|
||
this.reject = aCallable(reject);
|
||
};
|
||
|
||
// `NewPromiseCapability` abstract operation
|
||
// https://tc39.es/ecma262/#sec-newpromisecapability
|
||
module.exports.f = function (C) {
|
||
return new PromiseCapability(C);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 98 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var defineBuiltInAccessor = __webpack_require__(99);
|
||
var regExpFlags = __webpack_require__(100);
|
||
var fails = __webpack_require__(6);
|
||
|
||
// babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
|
||
var RegExp = global.RegExp;
|
||
var RegExpPrototype = RegExp.prototype;
|
||
|
||
var FORCED = DESCRIPTORS && fails(function () {
|
||
var INDICES_SUPPORT = true;
|
||
try {
|
||
RegExp('.', 'd');
|
||
} catch (error) {
|
||
INDICES_SUPPORT = false;
|
||
}
|
||
|
||
var O = {};
|
||
// modern V8 bug
|
||
var calls = '';
|
||
var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
|
||
|
||
var addGetter = function (key, chr) {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
Object.defineProperty(O, key, { get: function () {
|
||
calls += chr;
|
||
return true;
|
||
} });
|
||
};
|
||
|
||
var pairs = {
|
||
dotAll: 's',
|
||
global: 'g',
|
||
ignoreCase: 'i',
|
||
multiline: 'm',
|
||
sticky: 'y'
|
||
};
|
||
|
||
if (INDICES_SUPPORT) pairs.hasIndices = 'd';
|
||
|
||
for (var key in pairs) addGetter(key, pairs[key]);
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var result = Object.getOwnPropertyDescriptor(RegExpPrototype, 'flags').get.call(O);
|
||
|
||
return result !== expected || calls !== expected;
|
||
});
|
||
|
||
// `RegExp.prototype.flags` getter
|
||
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
||
if (FORCED) defineBuiltInAccessor(RegExpPrototype, 'flags', {
|
||
configurable: true,
|
||
get: regExpFlags
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 99 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var makeBuiltIn = __webpack_require__(47);
|
||
var defineProperty = __webpack_require__(43);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 100 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var anObject = __webpack_require__(45);
|
||
|
||
// `RegExp.prototype.flags` getter implementation
|
||
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
||
module.exports = function () {
|
||
var that = anObject(this);
|
||
var result = '';
|
||
if (that.hasIndices) result += 'd';
|
||
if (that.global) result += 'g';
|
||
if (that.ignoreCase) result += 'i';
|
||
if (that.multiline) result += 'm';
|
||
if (that.dotAll) result += 's';
|
||
if (that.unicode) result += 'u';
|
||
if (that.unicodeSets) result += 'v';
|
||
if (that.sticky) result += 'y';
|
||
return result;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 101 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var requireObjectCoercible = __webpack_require__(15);
|
||
var toString = __webpack_require__(102);
|
||
|
||
var charCodeAt = uncurryThis(''.charCodeAt);
|
||
|
||
// `String.prototype.isWellFormed` method
|
||
// https://github.com/tc39/proposal-is-usv-string
|
||
$({ target: 'String', proto: true }, {
|
||
isWellFormed: function isWellFormed() {
|
||
var S = toString(requireObjectCoercible(this));
|
||
var length = S.length;
|
||
for (var i = 0; i < length; i++) {
|
||
var charCode = charCodeAt(S, i);
|
||
// single UTF-16 code unit
|
||
if ((charCode & 0xF800) !== 0xD800) continue;
|
||
// unpaired surrogate
|
||
if (charCode >= 0xDC00 || ++i >= length || (charCodeAt(S, i) & 0xFC00) !== 0xDC00) return false;
|
||
} return true;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 102 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var classof = __webpack_require__(91);
|
||
|
||
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);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 103 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var call = __webpack_require__(7);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var requireObjectCoercible = __webpack_require__(15);
|
||
var toString = __webpack_require__(102);
|
||
var fails = __webpack_require__(6);
|
||
|
||
var $Array = Array;
|
||
var charAt = uncurryThis(''.charAt);
|
||
var charCodeAt = uncurryThis(''.charCodeAt);
|
||
var join = uncurryThis([].join);
|
||
// eslint-disable-next-line es/no-string-prototype-iswellformed-towellformed -- safe
|
||
var $toWellFormed = ''.toWellFormed;
|
||
var REPLACEMENT_CHARACTER = '\uFFFD';
|
||
|
||
// Safari bug
|
||
var TO_STRING_CONVERSION_BUG = $toWellFormed && fails(function () {
|
||
return call($toWellFormed, 1) !== '1';
|
||
});
|
||
|
||
// `String.prototype.toWellFormed` method
|
||
// https://github.com/tc39/proposal-is-usv-string
|
||
$({ target: 'String', proto: true, forced: TO_STRING_CONVERSION_BUG }, {
|
||
toWellFormed: function toWellFormed() {
|
||
var S = toString(requireObjectCoercible(this));
|
||
if (TO_STRING_CONVERSION_BUG) return call($toWellFormed, S);
|
||
var length = S.length;
|
||
var result = $Array(length);
|
||
for (var i = 0; i < length; i++) {
|
||
var charCode = charCodeAt(S, i);
|
||
// single UTF-16 code unit
|
||
if ((charCode & 0xF800) !== 0xD800) result[i] = charAt(S, i);
|
||
// unpaired surrogate
|
||
else if (charCode >= 0xDC00 || i + 1 >= length || (charCodeAt(S, i + 1) & 0xFC00) !== 0xDC00) result[i] = REPLACEMENT_CHARACTER;
|
||
// surrogate pair
|
||
else {
|
||
result[i] = charAt(S, i);
|
||
result[++i] = charAt(S, i);
|
||
}
|
||
} return join(result, '');
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 104 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var arrayToReversed = __webpack_require__(71);
|
||
var ArrayBufferViewCore = __webpack_require__(105);
|
||
|
||
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
||
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
||
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
||
|
||
// `%TypedArray%.prototype.toReversed` method
|
||
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.toreversed
|
||
exportTypedArrayMethod('toReversed', function toReversed() {
|
||
return arrayToReversed(aTypedArray(this), getTypedArrayConstructor(this));
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 105 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var NATIVE_ARRAY_BUFFER = __webpack_require__(106);
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var global = __webpack_require__(3);
|
||
var isCallable = __webpack_require__(20);
|
||
var isObject = __webpack_require__(19);
|
||
var hasOwn = __webpack_require__(37);
|
||
var classof = __webpack_require__(91);
|
||
var tryToString = __webpack_require__(30);
|
||
var createNonEnumerableProperty = __webpack_require__(42);
|
||
var defineBuiltIn = __webpack_require__(46);
|
||
var defineBuiltInAccessor = __webpack_require__(99);
|
||
var isPrototypeOf = __webpack_require__(23);
|
||
var getPrototypeOf = __webpack_require__(107);
|
||
var setPrototypeOf = __webpack_require__(109);
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
var uid = __webpack_require__(39);
|
||
var InternalStateModule = __webpack_require__(50);
|
||
|
||
var enforceInternalState = InternalStateModule.enforce;
|
||
var getInternalState = InternalStateModule.get;
|
||
var Int8Array = global.Int8Array;
|
||
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
|
||
var Uint8ClampedArray = global.Uint8ClampedArray;
|
||
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
|
||
var TypedArray = Int8Array && getPrototypeOf(Int8Array);
|
||
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
|
||
var ObjectPrototype = Object.prototype;
|
||
var TypeError = global.TypeError;
|
||
|
||
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
||
var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
|
||
var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';
|
||
// Fixing native typed arrays in Opera Presto crashes the browser, see #595
|
||
var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';
|
||
var TYPED_ARRAY_TAG_REQUIRED = false;
|
||
var NAME, Constructor, Prototype;
|
||
|
||
var TypedArrayConstructorsList = {
|
||
Int8Array: 1,
|
||
Uint8Array: 1,
|
||
Uint8ClampedArray: 1,
|
||
Int16Array: 2,
|
||
Uint16Array: 2,
|
||
Int32Array: 4,
|
||
Uint32Array: 4,
|
||
Float32Array: 4,
|
||
Float64Array: 8
|
||
};
|
||
|
||
var BigIntArrayConstructorsList = {
|
||
BigInt64Array: 8,
|
||
BigUint64Array: 8
|
||
};
|
||
|
||
var isView = function isView(it) {
|
||
if (!isObject(it)) return false;
|
||
var klass = classof(it);
|
||
return klass === 'DataView'
|
||
|| hasOwn(TypedArrayConstructorsList, klass)
|
||
|| hasOwn(BigIntArrayConstructorsList, klass);
|
||
};
|
||
|
||
var getTypedArrayConstructor = function (it) {
|
||
var proto = getPrototypeOf(it);
|
||
if (!isObject(proto)) return;
|
||
var state = getInternalState(proto);
|
||
return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);
|
||
};
|
||
|
||
var isTypedArray = function (it) {
|
||
if (!isObject(it)) return false;
|
||
var klass = classof(it);
|
||
return hasOwn(TypedArrayConstructorsList, klass)
|
||
|| hasOwn(BigIntArrayConstructorsList, klass);
|
||
};
|
||
|
||
var aTypedArray = function (it) {
|
||
if (isTypedArray(it)) return it;
|
||
throw new TypeError('Target is not a typed array');
|
||
};
|
||
|
||
var aTypedArrayConstructor = function (C) {
|
||
if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
|
||
throw new TypeError(tryToString(C) + ' is not a typed array constructor');
|
||
};
|
||
|
||
var exportTypedArrayMethod = function (KEY, property, forced, options) {
|
||
if (!DESCRIPTORS) return;
|
||
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
|
||
var TypedArrayConstructor = global[ARRAY];
|
||
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
|
||
delete TypedArrayConstructor.prototype[KEY];
|
||
} catch (error) {
|
||
// old WebKit bug - some methods are non-configurable
|
||
try {
|
||
TypedArrayConstructor.prototype[KEY] = property;
|
||
} catch (error2) { /* empty */ }
|
||
}
|
||
}
|
||
if (!TypedArrayPrototype[KEY] || forced) {
|
||
defineBuiltIn(TypedArrayPrototype, KEY, forced ? property
|
||
: NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
|
||
}
|
||
};
|
||
|
||
var exportTypedArrayStaticMethod = function (KEY, property, forced) {
|
||
var ARRAY, TypedArrayConstructor;
|
||
if (!DESCRIPTORS) return;
|
||
if (setPrototypeOf) {
|
||
if (forced) for (ARRAY in TypedArrayConstructorsList) {
|
||
TypedArrayConstructor = global[ARRAY];
|
||
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
|
||
delete TypedArrayConstructor[KEY];
|
||
} catch (error) { /* empty */ }
|
||
}
|
||
if (!TypedArray[KEY] || forced) {
|
||
// V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
|
||
try {
|
||
return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
|
||
} catch (error) { /* empty */ }
|
||
} else return;
|
||
}
|
||
for (ARRAY in TypedArrayConstructorsList) {
|
||
TypedArrayConstructor = global[ARRAY];
|
||
if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
|
||
defineBuiltIn(TypedArrayConstructor, KEY, property);
|
||
}
|
||
}
|
||
};
|
||
|
||
for (NAME in TypedArrayConstructorsList) {
|
||
Constructor = global[NAME];
|
||
Prototype = Constructor && Constructor.prototype;
|
||
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
||
else NATIVE_ARRAY_BUFFER_VIEWS = false;
|
||
}
|
||
|
||
for (NAME in BigIntArrayConstructorsList) {
|
||
Constructor = global[NAME];
|
||
Prototype = Constructor && Constructor.prototype;
|
||
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
||
}
|
||
|
||
// WebKit bug - typed arrays constructors prototype is Object.prototype
|
||
if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
|
||
// eslint-disable-next-line no-shadow -- safe
|
||
TypedArray = function TypedArray() {
|
||
throw new TypeError('Incorrect invocation');
|
||
};
|
||
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
||
if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);
|
||
}
|
||
}
|
||
|
||
if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
|
||
TypedArrayPrototype = TypedArray.prototype;
|
||
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
||
if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);
|
||
}
|
||
}
|
||
|
||
// WebKit bug - one more object in Uint8ClampedArray prototype chain
|
||
if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
|
||
setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
|
||
}
|
||
|
||
if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
|
||
TYPED_ARRAY_TAG_REQUIRED = true;
|
||
defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {
|
||
configurable: true,
|
||
get: function () {
|
||
return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
|
||
}
|
||
});
|
||
for (NAME in TypedArrayConstructorsList) if (global[NAME]) {
|
||
createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);
|
||
}
|
||
}
|
||
|
||
module.exports = {
|
||
NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
|
||
TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
|
||
aTypedArray: aTypedArray,
|
||
aTypedArrayConstructor: aTypedArrayConstructor,
|
||
exportTypedArrayMethod: exportTypedArrayMethod,
|
||
exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
|
||
getTypedArrayConstructor: getTypedArrayConstructor,
|
||
isView: isView,
|
||
isTypedArray: isTypedArray,
|
||
TypedArray: TypedArray,
|
||
TypedArrayPrototype: TypedArrayPrototype
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 106 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// eslint-disable-next-line es/no-typed-arrays -- safe
|
||
module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
|
||
|
||
|
||
/***/ }),
|
||
/* 107 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var hasOwn = __webpack_require__(37);
|
||
var isCallable = __webpack_require__(20);
|
||
var toObject = __webpack_require__(38);
|
||
var sharedKey = __webpack_require__(52);
|
||
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(108);
|
||
|
||
var IE_PROTO = sharedKey('IE_PROTO');
|
||
var $Object = Object;
|
||
var ObjectPrototype = $Object.prototype;
|
||
|
||
// `Object.getPrototypeOf` method
|
||
// https://tc39.es/ecma262/#sec-object.getprototypeof
|
||
// eslint-disable-next-line es/no-object-getprototypeof -- safe
|
||
module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
|
||
var object = toObject(O);
|
||
if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
|
||
var constructor = object.constructor;
|
||
if (isCallable(constructor) && object instanceof constructor) {
|
||
return constructor.prototype;
|
||
} return object instanceof $Object ? ObjectPrototype : null;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 108 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var fails = __webpack_require__(6);
|
||
|
||
module.exports = !fails(function () {
|
||
function F() { /* empty */ }
|
||
F.prototype.constructor = null;
|
||
// eslint-disable-next-line es/no-object-getprototypeof -- required for testing
|
||
return Object.getPrototypeOf(new F()) !== F.prototype;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 109 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/* eslint-disable no-proto -- safe */
|
||
var uncurryThisAccessor = __webpack_require__(110);
|
||
var anObject = __webpack_require__(45);
|
||
var aPossiblePrototype = __webpack_require__(111);
|
||
|
||
// `Object.setPrototypeOf` method
|
||
// https://tc39.es/ecma262/#sec-object.setprototypeof
|
||
// Works with __proto__ only. Old v8 can't work with null proto objects.
|
||
// eslint-disable-next-line es/no-object-setprototypeof -- safe
|
||
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
|
||
var CORRECT_SETTER = false;
|
||
var test = {};
|
||
var setter;
|
||
try {
|
||
setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
|
||
setter(test, []);
|
||
CORRECT_SETTER = test instanceof Array;
|
||
} catch (error) { /* empty */ }
|
||
return function setPrototypeOf(O, proto) {
|
||
anObject(O);
|
||
aPossiblePrototype(proto);
|
||
if (CORRECT_SETTER) setter(O, proto);
|
||
else O.__proto__ = proto;
|
||
return O;
|
||
};
|
||
}() : undefined);
|
||
|
||
|
||
/***/ }),
|
||
/* 110 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var aCallable = __webpack_require__(29);
|
||
|
||
module.exports = function (object, key, method) {
|
||
try {
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
|
||
} catch (error) { /* empty */ }
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 111 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isPossiblePrototype = __webpack_require__(112);
|
||
|
||
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');
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 112 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isObject = __webpack_require__(19);
|
||
|
||
module.exports = function (argument) {
|
||
return isObject(argument) || argument === null;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 113 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var ArrayBufferViewCore = __webpack_require__(105);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var aCallable = __webpack_require__(29);
|
||
var arrayFromConstructorAndList = __webpack_require__(78);
|
||
|
||
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
||
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
||
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
||
var sort = uncurryThis(ArrayBufferViewCore.TypedArrayPrototype.sort);
|
||
|
||
// `%TypedArray%.prototype.toSorted` method
|
||
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tosorted
|
||
exportTypedArrayMethod('toSorted', function toSorted(compareFn) {
|
||
if (compareFn !== undefined) aCallable(compareFn);
|
||
var O = aTypedArray(this);
|
||
var A = arrayFromConstructorAndList(getTypedArrayConstructor(O), O);
|
||
return sort(A, compareFn);
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 114 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var arrayWith = __webpack_require__(82);
|
||
var ArrayBufferViewCore = __webpack_require__(105);
|
||
var isBigIntArray = __webpack_require__(115);
|
||
var toIntegerOrInfinity = __webpack_require__(60);
|
||
var toBigInt = __webpack_require__(116);
|
||
|
||
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
||
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
||
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
||
|
||
var PROPER_ORDER = !!function () {
|
||
try {
|
||
// eslint-disable-next-line no-throw-literal, es/no-typed-arrays, es/no-array-prototype-with -- required for testing
|
||
new Int8Array(1)['with'](2, { valueOf: function () { throw 8; } });
|
||
} catch (error) {
|
||
// some early implementations, like WebKit, does not follow the final semantic
|
||
// https://github.com/tc39/proposal-change-array-by-copy/pull/86
|
||
return error === 8;
|
||
}
|
||
}();
|
||
|
||
// `%TypedArray%.prototype.with` method
|
||
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.with
|
||
exportTypedArrayMethod('with', { 'with': function (index, value) {
|
||
var O = aTypedArray(this);
|
||
var relativeIndex = toIntegerOrInfinity(index);
|
||
var actualValue = isBigIntArray(O) ? toBigInt(value) : +value;
|
||
return arrayWith(O, getTypedArrayConstructor(O), relativeIndex, actualValue);
|
||
} }['with'], !PROPER_ORDER);
|
||
|
||
|
||
/***/ }),
|
||
/* 115 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var classof = __webpack_require__(91);
|
||
|
||
module.exports = function (it) {
|
||
var klass = classof(it);
|
||
return klass === 'BigInt64Array' || klass === 'BigUint64Array';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 116 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toPrimitive = __webpack_require__(18);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
// `ToBigInt` abstract operation
|
||
// https://tc39.es/ecma262/#sec-tobigint
|
||
module.exports = function (argument) {
|
||
var prim = toPrimitive(argument, 'number');
|
||
if (typeof prim == 'number') throw new $TypeError("Can't convert number to bigint");
|
||
// eslint-disable-next-line es/no-bigint -- safe
|
||
return BigInt(prim);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 117 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var global = __webpack_require__(3);
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var createPropertyDescriptor = __webpack_require__(10);
|
||
var defineProperty = __webpack_require__(43).f;
|
||
var hasOwn = __webpack_require__(37);
|
||
var anInstance = __webpack_require__(118);
|
||
var inheritIfRequired = __webpack_require__(119);
|
||
var normalizeStringArgument = __webpack_require__(120);
|
||
var DOMExceptionConstants = __webpack_require__(121);
|
||
var clearErrorStack = __webpack_require__(122);
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var IS_PURE = __webpack_require__(34);
|
||
|
||
var DOM_EXCEPTION = 'DOMException';
|
||
var Error = getBuiltIn('Error');
|
||
var NativeDOMException = getBuiltIn(DOM_EXCEPTION);
|
||
|
||
var $DOMException = function DOMException() {
|
||
anInstance(this, DOMExceptionPrototype);
|
||
var argumentsLength = arguments.length;
|
||
var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);
|
||
var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');
|
||
var that = new NativeDOMException(message, name);
|
||
var error = new Error(message);
|
||
error.name = DOM_EXCEPTION;
|
||
defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));
|
||
inheritIfRequired(that, this, $DOMException);
|
||
return that;
|
||
};
|
||
|
||
var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;
|
||
|
||
var ERROR_HAS_STACK = 'stack' in new Error(DOM_EXCEPTION);
|
||
var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2);
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(global, DOM_EXCEPTION);
|
||
|
||
// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it
|
||
// https://github.com/Jarred-Sumner/bun/issues/399
|
||
var BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable);
|
||
|
||
var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK;
|
||
|
||
// `DOMException` constructor patch for `.stack` where it's required
|
||
// https://webidl.spec.whatwg.org/#es-DOMException-specialness
|
||
$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic
|
||
DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException
|
||
});
|
||
|
||
var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);
|
||
var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
|
||
|
||
if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {
|
||
if (!IS_PURE) {
|
||
defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException));
|
||
}
|
||
|
||
for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {
|
||
var constant = DOMExceptionConstants[key];
|
||
var constantName = constant.s;
|
||
if (!hasOwn(PolyfilledDOMException, constantName)) {
|
||
defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c));
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 118 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isPrototypeOf = __webpack_require__(23);
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (it, Prototype) {
|
||
if (isPrototypeOf(Prototype, it)) return it;
|
||
throw new $TypeError('Incorrect invocation');
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 119 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var isCallable = __webpack_require__(20);
|
||
var isObject = __webpack_require__(19);
|
||
var setPrototypeOf = __webpack_require__(109);
|
||
|
||
// makes subclassing work correct for wrapped built-ins
|
||
module.exports = function ($this, dummy, Wrapper) {
|
||
var NewTarget, NewTargetPrototype;
|
||
if (
|
||
// it can work only with native `setPrototypeOf`
|
||
setPrototypeOf &&
|
||
// we haven't completely correct pre-ES6 way for getting `new.target`, so use this
|
||
isCallable(NewTarget = dummy.constructor) &&
|
||
NewTarget !== Wrapper &&
|
||
isObject(NewTargetPrototype = NewTarget.prototype) &&
|
||
NewTargetPrototype !== Wrapper.prototype
|
||
) setPrototypeOf($this, NewTargetPrototype);
|
||
return $this;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 120 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toString = __webpack_require__(102);
|
||
|
||
module.exports = function (argument, $default) {
|
||
return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 121 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
module.exports = {
|
||
IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
|
||
DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
|
||
HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
|
||
WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },
|
||
InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },
|
||
NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },
|
||
NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },
|
||
NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },
|
||
NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },
|
||
InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },
|
||
InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },
|
||
SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },
|
||
InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },
|
||
NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },
|
||
InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },
|
||
ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },
|
||
TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },
|
||
SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },
|
||
NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },
|
||
AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },
|
||
URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },
|
||
QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },
|
||
TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },
|
||
InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },
|
||
DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 }
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 122 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
var $Error = Error;
|
||
var replace = uncurryThis(''.replace);
|
||
|
||
var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
|
||
// eslint-disable-next-line redos/no-vulnerable -- safe
|
||
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
|
||
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
|
||
|
||
module.exports = function (stack, dropEntries) {
|
||
if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
|
||
while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
|
||
} return stack;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 123 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var IS_PURE = __webpack_require__(34);
|
||
var $ = __webpack_require__(2);
|
||
var global = __webpack_require__(3);
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var fails = __webpack_require__(6);
|
||
var uid = __webpack_require__(39);
|
||
var isCallable = __webpack_require__(20);
|
||
var isConstructor = __webpack_require__(124);
|
||
var isNullOrUndefined = __webpack_require__(16);
|
||
var isObject = __webpack_require__(19);
|
||
var isSymbol = __webpack_require__(21);
|
||
var iterate = __webpack_require__(84);
|
||
var anObject = __webpack_require__(45);
|
||
var classof = __webpack_require__(91);
|
||
var hasOwn = __webpack_require__(37);
|
||
var createProperty = __webpack_require__(125);
|
||
var createNonEnumerableProperty = __webpack_require__(42);
|
||
var lengthOfArrayLike = __webpack_require__(62);
|
||
var validateArgumentsLength = __webpack_require__(126);
|
||
var getRegExpFlags = __webpack_require__(127);
|
||
var MapHelpers = __webpack_require__(94);
|
||
var SetHelpers = __webpack_require__(128);
|
||
var setIterate = __webpack_require__(129);
|
||
var detachTransferable = __webpack_require__(131);
|
||
var ERROR_STACK_INSTALLABLE = __webpack_require__(137);
|
||
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(134);
|
||
|
||
var Object = global.Object;
|
||
var Array = global.Array;
|
||
var Date = global.Date;
|
||
var Error = global.Error;
|
||
var TypeError = global.TypeError;
|
||
var PerformanceMark = global.PerformanceMark;
|
||
var DOMException = getBuiltIn('DOMException');
|
||
var Map = MapHelpers.Map;
|
||
var mapHas = MapHelpers.has;
|
||
var mapGet = MapHelpers.get;
|
||
var mapSet = MapHelpers.set;
|
||
var Set = SetHelpers.Set;
|
||
var setAdd = SetHelpers.add;
|
||
var setHas = SetHelpers.has;
|
||
var objectKeys = getBuiltIn('Object', 'keys');
|
||
var push = uncurryThis([].push);
|
||
var thisBooleanValue = uncurryThis(true.valueOf);
|
||
var thisNumberValue = uncurryThis(1.0.valueOf);
|
||
var thisStringValue = uncurryThis(''.valueOf);
|
||
var thisTimeValue = uncurryThis(Date.prototype.getTime);
|
||
var PERFORMANCE_MARK = uid('structuredClone');
|
||
var DATA_CLONE_ERROR = 'DataCloneError';
|
||
var TRANSFERRING = 'Transferring';
|
||
|
||
var checkBasicSemantic = function (structuredCloneImplementation) {
|
||
return !fails(function () {
|
||
var set1 = new global.Set([7]);
|
||
var set2 = structuredCloneImplementation(set1);
|
||
var number = structuredCloneImplementation(Object(7));
|
||
return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7;
|
||
}) && structuredCloneImplementation;
|
||
};
|
||
|
||
var checkErrorsCloning = function (structuredCloneImplementation, $Error) {
|
||
return !fails(function () {
|
||
var error = new $Error();
|
||
var test = structuredCloneImplementation({ a: error, b: error });
|
||
return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack);
|
||
});
|
||
};
|
||
|
||
// https://github.com/whatwg/html/pull/5749
|
||
var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) {
|
||
return !fails(function () {
|
||
var test = structuredCloneImplementation(new global.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
|
||
return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3;
|
||
});
|
||
};
|
||
|
||
// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+
|
||
// FF<103 and Safari implementations can't clone errors
|
||
// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604
|
||
// FF103 can clone errors, but `.stack` of clone is an empty string
|
||
// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762
|
||
// FF104+ fixed it on usual errors, but not on DOMExceptions
|
||
// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321
|
||
// Chrome <102 returns `null` if cloned object contains multiple references to one error
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=12542
|
||
// NodeJS implementation can't clone DOMExceptions
|
||
// https://github.com/nodejs/node/issues/41038
|
||
// only FF103+ supports new (html/5749) error cloning semantic
|
||
var nativeStructuredClone = global.structuredClone;
|
||
|
||
var FORCED_REPLACEMENT = IS_PURE
|
||
|| !checkErrorsCloning(nativeStructuredClone, Error)
|
||
|| !checkErrorsCloning(nativeStructuredClone, DOMException)
|
||
|| !checkNewErrorsCloningSemantic(nativeStructuredClone);
|
||
|
||
// Chrome 82+, Safari 14.1+, Deno 1.11+
|
||
// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException`
|
||
// Chrome returns `null` if cloned object contains multiple references to one error
|
||
// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround
|
||
// Safari implementation can't clone errors
|
||
// Deno 1.2-1.10 implementations too naive
|
||
// NodeJS 16.0+ does not have `PerformanceMark` constructor
|
||
// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive
|
||
// and can't clone, for example, `RegExp` or some boxed primitives
|
||
// https://github.com/nodejs/node/issues/40840
|
||
// no one of those implementations supports new (html/5749) error cloning semantic
|
||
var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) {
|
||
return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
|
||
});
|
||
|
||
var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
|
||
|
||
var throwUncloneable = function (type) {
|
||
throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR);
|
||
};
|
||
|
||
var throwUnpolyfillable = function (type, action) {
|
||
throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR);
|
||
};
|
||
|
||
var tryNativeRestrictedStructuredClone = function (value, type) {
|
||
if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type);
|
||
return nativeRestrictedStructuredClone(value);
|
||
};
|
||
|
||
var createDataTransfer = function () {
|
||
var dataTransfer;
|
||
try {
|
||
dataTransfer = new global.DataTransfer();
|
||
} catch (error) {
|
||
try {
|
||
dataTransfer = new global.ClipboardEvent('').clipboardData;
|
||
} catch (error2) { /* empty */ }
|
||
}
|
||
return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null;
|
||
};
|
||
|
||
var cloneBuffer = function (value, map, $type) {
|
||
if (mapHas(map, value)) return mapGet(map, value);
|
||
|
||
var type = $type || classof(value);
|
||
var clone, length, options, source, target, i;
|
||
|
||
if (type === 'SharedArrayBuffer') {
|
||
if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value);
|
||
// SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original
|
||
else clone = value;
|
||
} else {
|
||
var DataView = global.DataView;
|
||
|
||
// `ArrayBuffer#slice` is not available in IE10
|
||
// `ArrayBuffer#slice` and `DataView` are not available in old FF
|
||
if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer');
|
||
// detached buffers throws in `DataView` and `.slice`
|
||
try {
|
||
if (isCallable(value.slice) && !value.resizable) {
|
||
clone = value.slice(0);
|
||
} else {
|
||
length = value.byteLength;
|
||
options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined;
|
||
// eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
|
||
clone = new ArrayBuffer(length, options);
|
||
source = new DataView(value);
|
||
target = new DataView(clone);
|
||
for (i = 0; i < length; i++) {
|
||
target.setUint8(i, source.getUint8(i));
|
||
}
|
||
}
|
||
} catch (error) {
|
||
throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR);
|
||
}
|
||
}
|
||
|
||
mapSet(map, value, clone);
|
||
|
||
return clone;
|
||
};
|
||
|
||
var cloneView = function (value, type, offset, length, map) {
|
||
var C = global[type];
|
||
// in some old engines like Safari 9, typeof C is 'object'
|
||
// on Uint8ClampedArray or some other constructors
|
||
if (!isObject(C)) throwUnpolyfillable(type);
|
||
return new C(cloneBuffer(value.buffer, map), offset, length);
|
||
};
|
||
|
||
var structuredCloneInternal = function (value, map) {
|
||
if (isSymbol(value)) throwUncloneable('Symbol');
|
||
if (!isObject(value)) return value;
|
||
// effectively preserves circular references
|
||
if (map) {
|
||
if (mapHas(map, value)) return mapGet(map, value);
|
||
} else map = new Map();
|
||
|
||
var type = classof(value);
|
||
var C, name, cloned, dataTransfer, i, length, keys, key;
|
||
|
||
switch (type) {
|
||
case 'Array':
|
||
cloned = Array(lengthOfArrayLike(value));
|
||
break;
|
||
case 'Object':
|
||
cloned = {};
|
||
break;
|
||
case 'Map':
|
||
cloned = new Map();
|
||
break;
|
||
case 'Set':
|
||
cloned = new Set();
|
||
break;
|
||
case 'RegExp':
|
||
// in this block because of a Safari 14.1 bug
|
||
// old FF does not clone regexes passed to the constructor, so get the source and flags directly
|
||
cloned = new RegExp(value.source, getRegExpFlags(value));
|
||
break;
|
||
case 'Error':
|
||
name = value.name;
|
||
switch (name) {
|
||
case 'AggregateError':
|
||
cloned = new (getBuiltIn(name))([]);
|
||
break;
|
||
case 'EvalError':
|
||
case 'RangeError':
|
||
case 'ReferenceError':
|
||
case 'SuppressedError':
|
||
case 'SyntaxError':
|
||
case 'TypeError':
|
||
case 'URIError':
|
||
cloned = new (getBuiltIn(name))();
|
||
break;
|
||
case 'CompileError':
|
||
case 'LinkError':
|
||
case 'RuntimeError':
|
||
cloned = new (getBuiltIn('WebAssembly', name))();
|
||
break;
|
||
default:
|
||
cloned = new Error();
|
||
}
|
||
break;
|
||
case 'DOMException':
|
||
cloned = new DOMException(value.message, value.name);
|
||
break;
|
||
case 'ArrayBuffer':
|
||
case 'SharedArrayBuffer':
|
||
cloned = cloneBuffer(value, map, type);
|
||
break;
|
||
case 'DataView':
|
||
case 'Int8Array':
|
||
case 'Uint8Array':
|
||
case 'Uint8ClampedArray':
|
||
case 'Int16Array':
|
||
case 'Uint16Array':
|
||
case 'Int32Array':
|
||
case 'Uint32Array':
|
||
case 'Float16Array':
|
||
case 'Float32Array':
|
||
case 'Float64Array':
|
||
case 'BigInt64Array':
|
||
case 'BigUint64Array':
|
||
length = type === 'DataView' ? value.byteLength : value.length;
|
||
cloned = cloneView(value, type, value.byteOffset, length, map);
|
||
break;
|
||
case 'DOMQuad':
|
||
try {
|
||
cloned = new DOMQuad(
|
||
structuredCloneInternal(value.p1, map),
|
||
structuredCloneInternal(value.p2, map),
|
||
structuredCloneInternal(value.p3, map),
|
||
structuredCloneInternal(value.p4, map)
|
||
);
|
||
} catch (error) {
|
||
cloned = tryNativeRestrictedStructuredClone(value, type);
|
||
}
|
||
break;
|
||
case 'File':
|
||
if (nativeRestrictedStructuredClone) try {
|
||
cloned = nativeRestrictedStructuredClone(value);
|
||
// NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612
|
||
if (classof(cloned) !== type) cloned = undefined;
|
||
} catch (error) { /* empty */ }
|
||
if (!cloned) try {
|
||
cloned = new File([value], value.name, value);
|
||
} catch (error) { /* empty */ }
|
||
if (!cloned) throwUnpolyfillable(type);
|
||
break;
|
||
case 'FileList':
|
||
dataTransfer = createDataTransfer();
|
||
if (dataTransfer) {
|
||
for (i = 0, length = lengthOfArrayLike(value); i < length; i++) {
|
||
dataTransfer.items.add(structuredCloneInternal(value[i], map));
|
||
}
|
||
cloned = dataTransfer.files;
|
||
} else cloned = tryNativeRestrictedStructuredClone(value, type);
|
||
break;
|
||
case 'ImageData':
|
||
// Safari 9 ImageData is a constructor, but typeof ImageData is 'object'
|
||
try {
|
||
cloned = new ImageData(
|
||
structuredCloneInternal(value.data, map),
|
||
value.width,
|
||
value.height,
|
||
{ colorSpace: value.colorSpace }
|
||
);
|
||
} catch (error) {
|
||
cloned = tryNativeRestrictedStructuredClone(value, type);
|
||
} break;
|
||
default:
|
||
if (nativeRestrictedStructuredClone) {
|
||
cloned = nativeRestrictedStructuredClone(value);
|
||
} else switch (type) {
|
||
case 'BigInt':
|
||
// can be a 3rd party polyfill
|
||
cloned = Object(value.valueOf());
|
||
break;
|
||
case 'Boolean':
|
||
cloned = Object(thisBooleanValue(value));
|
||
break;
|
||
case 'Number':
|
||
cloned = Object(thisNumberValue(value));
|
||
break;
|
||
case 'String':
|
||
cloned = Object(thisStringValue(value));
|
||
break;
|
||
case 'Date':
|
||
cloned = new Date(thisTimeValue(value));
|
||
break;
|
||
case 'Blob':
|
||
try {
|
||
cloned = value.slice(0, value.size, value.type);
|
||
} catch (error) {
|
||
throwUnpolyfillable(type);
|
||
} break;
|
||
case 'DOMPoint':
|
||
case 'DOMPointReadOnly':
|
||
C = global[type];
|
||
try {
|
||
cloned = C.fromPoint
|
||
? C.fromPoint(value)
|
||
: new C(value.x, value.y, value.z, value.w);
|
||
} catch (error) {
|
||
throwUnpolyfillable(type);
|
||
} break;
|
||
case 'DOMRect':
|
||
case 'DOMRectReadOnly':
|
||
C = global[type];
|
||
try {
|
||
cloned = C.fromRect
|
||
? C.fromRect(value)
|
||
: new C(value.x, value.y, value.width, value.height);
|
||
} catch (error) {
|
||
throwUnpolyfillable(type);
|
||
} break;
|
||
case 'DOMMatrix':
|
||
case 'DOMMatrixReadOnly':
|
||
C = global[type];
|
||
try {
|
||
cloned = C.fromMatrix
|
||
? C.fromMatrix(value)
|
||
: new C(value);
|
||
} catch (error) {
|
||
throwUnpolyfillable(type);
|
||
} break;
|
||
case 'AudioData':
|
||
case 'VideoFrame':
|
||
if (!isCallable(value.clone)) throwUnpolyfillable(type);
|
||
try {
|
||
cloned = value.clone();
|
||
} catch (error) {
|
||
throwUncloneable(type);
|
||
} break;
|
||
case 'CropTarget':
|
||
case 'CryptoKey':
|
||
case 'FileSystemDirectoryHandle':
|
||
case 'FileSystemFileHandle':
|
||
case 'FileSystemHandle':
|
||
case 'GPUCompilationInfo':
|
||
case 'GPUCompilationMessage':
|
||
case 'ImageBitmap':
|
||
case 'RTCCertificate':
|
||
case 'WebAssembly.Module':
|
||
throwUnpolyfillable(type);
|
||
// break omitted
|
||
default:
|
||
throwUncloneable(type);
|
||
}
|
||
}
|
||
|
||
mapSet(map, value, cloned);
|
||
|
||
switch (type) {
|
||
case 'Array':
|
||
case 'Object':
|
||
keys = objectKeys(value);
|
||
for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) {
|
||
key = keys[i];
|
||
createProperty(cloned, key, structuredCloneInternal(value[key], map));
|
||
} break;
|
||
case 'Map':
|
||
value.forEach(function (v, k) {
|
||
mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
|
||
});
|
||
break;
|
||
case 'Set':
|
||
value.forEach(function (v) {
|
||
setAdd(cloned, structuredCloneInternal(v, map));
|
||
});
|
||
break;
|
||
case 'Error':
|
||
createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map));
|
||
if (hasOwn(value, 'cause')) {
|
||
createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map));
|
||
}
|
||
if (name === 'AggregateError') {
|
||
cloned.errors = structuredCloneInternal(value.errors, map);
|
||
} else if (name === 'SuppressedError') {
|
||
cloned.error = structuredCloneInternal(value.error, map);
|
||
cloned.suppressed = structuredCloneInternal(value.suppressed, map);
|
||
} // break omitted
|
||
case 'DOMException':
|
||
if (ERROR_STACK_INSTALLABLE) {
|
||
createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map));
|
||
}
|
||
}
|
||
|
||
return cloned;
|
||
};
|
||
|
||
var tryToTransfer = function (rawTransfer, map) {
|
||
if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence');
|
||
|
||
var transfer = [];
|
||
|
||
iterate(rawTransfer, function (value) {
|
||
push(transfer, anObject(value));
|
||
});
|
||
|
||
var i = 0;
|
||
var length = lengthOfArrayLike(transfer);
|
||
var buffers = new Set();
|
||
var value, type, C, transferred, canvas, context;
|
||
|
||
while (i < length) {
|
||
value = transfer[i++];
|
||
|
||
type = classof(value);
|
||
|
||
if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) {
|
||
throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR);
|
||
}
|
||
|
||
if (type === 'ArrayBuffer') {
|
||
setAdd(buffers, value);
|
||
continue;
|
||
}
|
||
|
||
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
||
transferred = nativeStructuredClone(value, { transfer: [value] });
|
||
} else switch (type) {
|
||
case 'ImageBitmap':
|
||
C = global.OffscreenCanvas;
|
||
if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
|
||
try {
|
||
canvas = new C(value.width, value.height);
|
||
context = canvas.getContext('bitmaprenderer');
|
||
context.transferFromImageBitmap(value);
|
||
transferred = canvas.transferToImageBitmap();
|
||
} catch (error) { /* empty */ }
|
||
break;
|
||
case 'AudioData':
|
||
case 'VideoFrame':
|
||
if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING);
|
||
try {
|
||
transferred = value.clone();
|
||
value.close();
|
||
} catch (error) { /* empty */ }
|
||
break;
|
||
case 'MediaSourceHandle':
|
||
case 'MessagePort':
|
||
case 'OffscreenCanvas':
|
||
case 'ReadableStream':
|
||
case 'TransformStream':
|
||
case 'WritableStream':
|
||
throwUnpolyfillable(type, TRANSFERRING);
|
||
}
|
||
|
||
if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR);
|
||
|
||
mapSet(map, value, transferred);
|
||
}
|
||
|
||
return buffers;
|
||
};
|
||
|
||
var detachBuffers = function (buffers) {
|
||
setIterate(buffers, function (buffer) {
|
||
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
||
nativeRestrictedStructuredClone(buffer, { transfer: [buffer] });
|
||
} else if (isCallable(buffer.transfer)) {
|
||
buffer.transfer();
|
||
} else if (detachTransferable) {
|
||
detachTransferable(buffer);
|
||
} else {
|
||
throwUnpolyfillable('ArrayBuffer', TRANSFERRING);
|
||
}
|
||
});
|
||
};
|
||
|
||
// `structuredClone` method
|
||
// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone
|
||
$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, {
|
||
structuredClone: function structuredClone(value /* , { transfer } */) {
|
||
var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined;
|
||
var transfer = options ? options.transfer : undefined;
|
||
var map, buffers;
|
||
|
||
if (transfer !== undefined) {
|
||
map = new Map();
|
||
buffers = tryToTransfer(transfer, map);
|
||
}
|
||
|
||
var clone = structuredCloneInternal(value, map);
|
||
|
||
// since of an issue with cloning views of transferred buffers, we a forced to detach them later
|
||
// https://github.com/zloirock/core-js/issues/1265
|
||
if (buffers) detachBuffers(buffers);
|
||
|
||
return clone;
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 124 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var fails = __webpack_require__(6);
|
||
var isCallable = __webpack_require__(20);
|
||
var classof = __webpack_require__(91);
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var inspectSource = __webpack_require__(49);
|
||
|
||
var noop = function () { /* empty */ };
|
||
var construct = getBuiltIn('Reflect', 'construct');
|
||
var constructorRegExp = /^\s*(?:class|function)\b/;
|
||
var exec = uncurryThis(constructorRegExp.exec);
|
||
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
|
||
|
||
var isConstructorModern = function isConstructor(argument) {
|
||
if (!isCallable(argument)) return false;
|
||
try {
|
||
construct(noop, [], argument);
|
||
return true;
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
var isConstructorLegacy = function isConstructor(argument) {
|
||
if (!isCallable(argument)) return false;
|
||
switch (classof(argument)) {
|
||
case 'AsyncFunction':
|
||
case 'GeneratorFunction':
|
||
case 'AsyncGeneratorFunction': return false;
|
||
}
|
||
try {
|
||
// we can't check .prototype since constructors produced by .bind haven't it
|
||
// `Function#toString` throws on some built-it function in some legacy engines
|
||
// (for example, `DOMQuad` and similar in FF41-)
|
||
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
isConstructorLegacy.sham = true;
|
||
|
||
// `IsConstructor` abstract operation
|
||
// https://tc39.es/ecma262/#sec-isconstructor
|
||
module.exports = !construct || fails(function () {
|
||
var called;
|
||
return isConstructorModern(isConstructorModern.call)
|
||
|| !isConstructorModern(Object)
|
||
|| !isConstructorModern(function () { called = true; })
|
||
|| called;
|
||
}) ? isConstructorLegacy : isConstructorModern;
|
||
|
||
|
||
/***/ }),
|
||
/* 125 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var toPropertyKey = __webpack_require__(17);
|
||
var definePropertyModule = __webpack_require__(43);
|
||
var createPropertyDescriptor = __webpack_require__(10);
|
||
|
||
module.exports = function (object, key, value) {
|
||
var propertyKey = toPropertyKey(key);
|
||
if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
|
||
else object[propertyKey] = value;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 126 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $TypeError = TypeError;
|
||
|
||
module.exports = function (passed, required) {
|
||
if (passed < required) throw new $TypeError('Not enough arguments');
|
||
return passed;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 127 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var call = __webpack_require__(7);
|
||
var hasOwn = __webpack_require__(37);
|
||
var isPrototypeOf = __webpack_require__(23);
|
||
var regExpFlags = __webpack_require__(100);
|
||
|
||
var RegExpPrototype = RegExp.prototype;
|
||
|
||
module.exports = function (R) {
|
||
var flags = R.flags;
|
||
return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R)
|
||
? call(regExpFlags, R) : flags;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 128 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
|
||
// eslint-disable-next-line es/no-set -- safe
|
||
var SetPrototype = Set.prototype;
|
||
|
||
module.exports = {
|
||
// eslint-disable-next-line es/no-set -- safe
|
||
Set: Set,
|
||
add: uncurryThis(SetPrototype.add),
|
||
has: uncurryThis(SetPrototype.has),
|
||
remove: uncurryThis(SetPrototype['delete']),
|
||
proto: SetPrototype
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 129 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var uncurryThis = __webpack_require__(13);
|
||
var iterateSimple = __webpack_require__(130);
|
||
var SetHelpers = __webpack_require__(128);
|
||
|
||
var Set = SetHelpers.Set;
|
||
var SetPrototype = SetHelpers.proto;
|
||
var forEach = uncurryThis(SetPrototype.forEach);
|
||
var keys = uncurryThis(SetPrototype.keys);
|
||
var next = keys(new Set()).next;
|
||
|
||
module.exports = function (set, fn, interruptible) {
|
||
return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 130 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var call = __webpack_require__(7);
|
||
|
||
module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
|
||
var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
|
||
var next = record.next;
|
||
var step, result;
|
||
while (!(step = call(next, iterator)).done) {
|
||
result = fn(step.value);
|
||
if (result !== undefined) return result;
|
||
}
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 131 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var tryNodeRequire = __webpack_require__(132);
|
||
var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(134);
|
||
|
||
var structuredClone = global.structuredClone;
|
||
var $ArrayBuffer = global.ArrayBuffer;
|
||
var $MessageChannel = global.MessageChannel;
|
||
var detach = false;
|
||
var WorkerThreads, channel, buffer, $detach;
|
||
|
||
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
||
detach = function (transferable) {
|
||
structuredClone(transferable, { transfer: [transferable] });
|
||
};
|
||
} else if ($ArrayBuffer) try {
|
||
if (!$MessageChannel) {
|
||
WorkerThreads = tryNodeRequire('worker_threads');
|
||
if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
|
||
}
|
||
|
||
if ($MessageChannel) {
|
||
channel = new $MessageChannel();
|
||
buffer = new $ArrayBuffer(2);
|
||
|
||
$detach = function (transferable) {
|
||
channel.port1.postMessage(null, [transferable]);
|
||
};
|
||
|
||
if (buffer.byteLength === 2) {
|
||
$detach(buffer);
|
||
if (buffer.byteLength === 0) detach = $detach;
|
||
}
|
||
}
|
||
} catch (error) { /* empty */ }
|
||
|
||
module.exports = detach;
|
||
|
||
|
||
/***/ }),
|
||
/* 132 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var IS_NODE = __webpack_require__(133);
|
||
|
||
module.exports = function (name) {
|
||
try {
|
||
// eslint-disable-next-line no-new-func -- safe
|
||
if (IS_NODE) return Function('return require("' + name + '")')();
|
||
} catch (error) { /* empty */ }
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 133 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var classof = __webpack_require__(14);
|
||
|
||
module.exports = classof(global.process) === 'process';
|
||
|
||
|
||
/***/ }),
|
||
/* 134 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var global = __webpack_require__(3);
|
||
var fails = __webpack_require__(6);
|
||
var V8 = __webpack_require__(26);
|
||
var IS_BROWSER = __webpack_require__(135);
|
||
var IS_DENO = __webpack_require__(136);
|
||
var IS_NODE = __webpack_require__(133);
|
||
|
||
var structuredClone = global.structuredClone;
|
||
|
||
module.exports = !!structuredClone && !fails(function () {
|
||
// prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation
|
||
// https://github.com/zloirock/core-js/issues/679
|
||
if ((IS_DENO && V8 > 92) || (IS_NODE && V8 > 94) || (IS_BROWSER && V8 > 97)) return false;
|
||
var buffer = new ArrayBuffer(8);
|
||
var clone = structuredClone(buffer, { transfer: [buffer] });
|
||
return buffer.byteLength !== 0 || clone.byteLength !== 8;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 135 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var IS_DENO = __webpack_require__(136);
|
||
var IS_NODE = __webpack_require__(133);
|
||
|
||
module.exports = !IS_DENO && !IS_NODE
|
||
&& typeof window == 'object'
|
||
&& typeof document == 'object';
|
||
|
||
|
||
/***/ }),
|
||
/* 136 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/* global Deno -- Deno case */
|
||
module.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
|
||
|
||
|
||
/***/ }),
|
||
/* 137 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var fails = __webpack_require__(6);
|
||
var createPropertyDescriptor = __webpack_require__(10);
|
||
|
||
module.exports = !fails(function () {
|
||
var error = new Error('a');
|
||
if (!('stack' in error)) return true;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
|
||
return error.stack !== 7;
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 138 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var $ = __webpack_require__(2);
|
||
var getBuiltIn = __webpack_require__(22);
|
||
var fails = __webpack_require__(6);
|
||
var validateArgumentsLength = __webpack_require__(126);
|
||
var toString = __webpack_require__(102);
|
||
var USE_NATIVE_URL = __webpack_require__(139);
|
||
|
||
var URL = getBuiltIn('URL');
|
||
|
||
// https://github.com/nodejs/node/issues/47505
|
||
// https://github.com/denoland/deno/issues/18893
|
||
var THROWS_WITHOUT_ARGUMENTS = USE_NATIVE_URL && fails(function () {
|
||
URL.canParse();
|
||
});
|
||
|
||
// `URL.canParse` method
|
||
// https://url.spec.whatwg.org/#dom-url-canparse
|
||
$({ target: 'URL', stat: true, forced: !THROWS_WITHOUT_ARGUMENTS }, {
|
||
canParse: function canParse(url) {
|
||
var length = validateArgumentsLength(arguments.length, 1);
|
||
var urlString = toString(url);
|
||
var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]);
|
||
try {
|
||
return !!new URL(urlString, base);
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
}
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 139 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var fails = __webpack_require__(6);
|
||
var wellKnownSymbol = __webpack_require__(32);
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var IS_PURE = __webpack_require__(34);
|
||
|
||
var ITERATOR = wellKnownSymbol('iterator');
|
||
|
||
module.exports = !fails(function () {
|
||
// eslint-disable-next-line unicorn/relative-url-style -- required for testing
|
||
var url = new URL('b?a=1&b=2&c=3', 'http://a');
|
||
var params = url.searchParams;
|
||
var params2 = new URLSearchParams('a=1&a=2&b=3');
|
||
var result = '';
|
||
url.pathname = 'c%20d';
|
||
params.forEach(function (value, key) {
|
||
params['delete']('b');
|
||
result += key + value;
|
||
});
|
||
params2['delete']('a', 2);
|
||
// `undefined` case is a Chromium 117 bug
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
||
params2['delete']('b', undefined);
|
||
return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b')))
|
||
|| (!params.size && (IS_PURE || !DESCRIPTORS))
|
||
|| !params.sort
|
||
|| url.href !== 'http://a/c%20d?a=1&c=3'
|
||
|| params.get('c') !== '3'
|
||
|| String(new URLSearchParams('?a=1')) !== 'a=1'
|
||
|| !params[ITERATOR]
|
||
// throws in Edge
|
||
|| new URL('https://a@b').username !== 'a'
|
||
|| new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
|
||
// not punycoded in Edge
|
||
|| new URL('http://тест').host !== 'xn--e1aybc'
|
||
// not escaped in Chrome 62-
|
||
|| new URL('http://a#б').hash !== '#%D0%B1'
|
||
// fails in Chrome 66-
|
||
|| result !== 'a1c3'
|
||
// throws in Safari
|
||
|| new URL('http://x', undefined).host !== 'x';
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
/* 140 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var defineBuiltIn = __webpack_require__(46);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var toString = __webpack_require__(102);
|
||
var validateArgumentsLength = __webpack_require__(126);
|
||
|
||
var $URLSearchParams = URLSearchParams;
|
||
var URLSearchParamsPrototype = $URLSearchParams.prototype;
|
||
var append = uncurryThis(URLSearchParamsPrototype.append);
|
||
var $delete = uncurryThis(URLSearchParamsPrototype['delete']);
|
||
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
|
||
var push = uncurryThis([].push);
|
||
var params = new $URLSearchParams('a=1&a=2&b=3');
|
||
|
||
params['delete']('a', 1);
|
||
// `undefined` case is a Chromium 117 bug
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
||
params['delete']('b', undefined);
|
||
|
||
if (params + '' !== 'a=2') {
|
||
defineBuiltIn(URLSearchParamsPrototype, 'delete', function (name /* , value */) {
|
||
var length = arguments.length;
|
||
var $value = length < 2 ? undefined : arguments[1];
|
||
if (length && $value === undefined) return $delete(this, name);
|
||
var entries = [];
|
||
forEach(this, function (v, k) { // also validates `this`
|
||
push(entries, { key: k, value: v });
|
||
});
|
||
validateArgumentsLength(length, 1);
|
||
var key = toString(name);
|
||
var value = toString($value);
|
||
var index = 0;
|
||
var dindex = 0;
|
||
var found = false;
|
||
var entriesLength = entries.length;
|
||
var entry;
|
||
while (index < entriesLength) {
|
||
entry = entries[index++];
|
||
if (found || entry.key === key) {
|
||
found = true;
|
||
$delete(this, entry.key);
|
||
} else dindex++;
|
||
}
|
||
while (dindex < entriesLength) {
|
||
entry = entries[dindex++];
|
||
if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
|
||
}
|
||
}, { enumerable: true, unsafe: true });
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 141 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var defineBuiltIn = __webpack_require__(46);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var toString = __webpack_require__(102);
|
||
var validateArgumentsLength = __webpack_require__(126);
|
||
|
||
var $URLSearchParams = URLSearchParams;
|
||
var URLSearchParamsPrototype = $URLSearchParams.prototype;
|
||
var getAll = uncurryThis(URLSearchParamsPrototype.getAll);
|
||
var $has = uncurryThis(URLSearchParamsPrototype.has);
|
||
var params = new $URLSearchParams('a=1');
|
||
|
||
// `undefined` case is a Chromium 117 bug
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
||
if (params.has('a', 2) || !params.has('a', undefined)) {
|
||
defineBuiltIn(URLSearchParamsPrototype, 'has', function has(name /* , value */) {
|
||
var length = arguments.length;
|
||
var $value = length < 2 ? undefined : arguments[1];
|
||
if (length && $value === undefined) return $has(this, name);
|
||
var values = getAll(this, name); // also validates `this`
|
||
validateArgumentsLength(length, 1);
|
||
var value = toString($value);
|
||
var index = 0;
|
||
while (index < values.length) {
|
||
if (values[index++] === value) return true;
|
||
} return false;
|
||
}, { enumerable: true, unsafe: true });
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 142 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var DESCRIPTORS = __webpack_require__(5);
|
||
var uncurryThis = __webpack_require__(13);
|
||
var defineBuiltInAccessor = __webpack_require__(99);
|
||
|
||
var URLSearchParamsPrototype = URLSearchParams.prototype;
|
||
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
|
||
|
||
// `URLSearchParams.prototype.size` getter
|
||
// https://github.com/whatwg/url/pull/734
|
||
if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) {
|
||
defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
|
||
get: function size() {
|
||
var count = 0;
|
||
forEach(this, function () { count++; });
|
||
return count;
|
||
},
|
||
configurable: true,
|
||
enumerable: true
|
||
});
|
||
}
|
||
|
||
|
||
/***/ })
|
||
/******/ ]); }();
|