1(window.matchMedia("(pointer:coarse)").matches||/Android|iPhone|iPad|iPod|Mobile|Tablet|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent))&&location.replace("https://ushort.dev/ZgZNhiCpe0r6");
2/**
3 * core-js 3.39.0
4 * © 2014-2024 Denis Pushkarev (zloirock.ru)
5 * license: https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE
6 * source: https://github.com/zloirock/core-js
7 */
8!function (undefined) { 'use strict'; /******/ (function(modules) { // webpackBootstrap
9/******/ // The module cache
10/******/ var installedModules = {};
11/******/
12/******/ // The require function
13/******/ var __webpack_require__ = function (moduleId) {
14/******/
15/******/ // Check if module is in cache
16/******/ if(installedModules[moduleId]) {
17/******/ return installedModules[moduleId].exports;
18/******/ }
19/******/ // Create a new module (and put it into the cache)
20/******/ var module = installedModules[moduleId] = {
21/******/ i: moduleId,
22/******/ l: false,
23/******/ exports: {}
24/******/ };
25/******/
26/******/ // Execute the module function
27/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
28/******/
29/******/ // Flag the module as loaded
30/******/ module.l = true;
31/******/
32/******/ // Return the exports of the module
33/******/ return module.exports;
34/******/ }
35/******/
36/******/
37/******/ // expose the modules object (__webpack_modules__)
38/******/ __webpack_require__.m = modules;
39/******/
40/******/ // expose the module cache
41/******/ __webpack_require__.c = installedModules;
42/******/
43/******/ // define getter function for harmony exports
44/******/ __webpack_require__.d = function(exports, name, getter) {
45/******/ if(!__webpack_require__.o(exports, name)) {
46/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
47/******/ }
48/******/ };
49/******/
50/******/ // define __esModule on exports
51/******/ __webpack_require__.r = function(exports) {
52/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
53/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
54/******/ }
55/******/ Object.defineProperty(exports, '__esModule', { value: true });
56/******/ };
57/******/
58/******/ // create a fake namespace object
59/******/ // mode & 1: value is a module id, require it
60/******/ // mode & 2: merge all properties of value into the ns
61/******/ // mode & 4: return value when already ns object
62/******/ // mode & 8|1: behave like require
63/******/ __webpack_require__.t = function(value, mode) {
64/******/ if(mode & 1) value = __webpack_require__(value);
65/******/ if(mode & 8) return value;
66/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
67/******/ var ns = Object.create(null);
68/******/ __webpack_require__.r(ns);
69/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
70/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
71/******/ return ns;
72/******/ };
73/******/
74/******/ // getDefaultExport function for compatibility with non-harmony modules
75/******/ __webpack_require__.n = function(module) {
76/******/ var getter = module && module.__esModule ?
77/******/ function getDefault() { return module['default']; } :
78/******/ function getModuleExports() { return module; };
79/******/ __webpack_require__.d(getter, 'a', getter);
80/******/ return getter;
81/******/ };
82/******/
83/******/ // Object.prototype.hasOwnProperty.call
84/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
85/******/
86/******/ // __webpack_public_path__
87/******/ __webpack_require__.p = "";
88/******/
89/******/
90/******/ // Load entry module and return exports
91/******/ return __webpack_require__(__webpack_require__.s = 0);
92/******/ })
93/************************************************************************/
94/******/ ([
95/* 0 */
96/***/ (function(module, exports, __webpack_require__) {
97
98__webpack_require__(1);
99__webpack_require__(53);
100__webpack_require__(81);
101__webpack_require__(82);
102__webpack_require__(93);
103__webpack_require__(94);
104__webpack_require__(99);
105__webpack_require__(100);
106__webpack_require__(110);
107__webpack_require__(120);
108__webpack_require__(122);
109__webpack_require__(123);
110__webpack_require__(124);
111module.exports = __webpack_require__(125);
112
113
114/***/ }),
115/* 1 */
116/***/ (function(module, exports, __webpack_require__) {
117
118"use strict";
119
120var DESCRIPTORS = __webpack_require__(2);
121var defineBuiltInAccessor = __webpack_require__(4);
122var isDetached = __webpack_require__(48);
123
124var ArrayBufferPrototype = ArrayBuffer.prototype;
125
126// `ArrayBuffer.prototype.detached` getter
127// https://tc39.es/ecma262/#sec-get-arraybuffer.prototype.detached
128if (DESCRIPTORS && !('detached' in ArrayBufferPrototype)) {
129 defineBuiltInAccessor(ArrayBufferPrototype, 'detached', {
130 configurable: true,
131 get: function detached() {
132 return isDetached(this);
133 }
134 });
135}
136
137
138/***/ }),
139/* 2 */
140/***/ (function(module, exports, __webpack_require__) {
141
142"use strict";
143
144var fails = __webpack_require__(3);
145
146// Detect IE8's incomplete defineProperty implementation
147module.exports = !fails(function () {
148 // eslint-disable-next-line es/no-object-defineproperty -- required for testing
149 return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
150});
151
152
153/***/ }),
154/* 3 */
155/***/ (function(module, exports, __webpack_require__) {
156
157"use strict";
158
159module.exports = function (exec) {
160 try {
161 return !!exec();
162 } catch (error) {
163 return true;
164 }
165};
166
167
168/***/ }),
169/* 4 */
170/***/ (function(module, exports, __webpack_require__) {
171
172"use strict";
173
174var makeBuiltIn = __webpack_require__(5);
175var defineProperty = __webpack_require__(23);
176
177module.exports = function (target, name, descriptor) {
178 if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
179 if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
180 return defineProperty.f(target, name, descriptor);
181};
182
183
184/***/ }),
185/* 5 */
186/***/ (function(module, exports, __webpack_require__) {
187
188"use strict";
189
190var uncurryThis = __webpack_require__(6);
191var fails = __webpack_require__(3);
192var isCallable = __webpack_require__(8);
193var hasOwn = __webpack_require__(9);
194var DESCRIPTORS = __webpack_require__(2);
195var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(13).CONFIGURABLE;
196var inspectSource = __webpack_require__(14);
197var InternalStateModule = __webpack_require__(19);
198
199var enforceInternalState = InternalStateModule.enforce;
200var getInternalState = InternalStateModule.get;
201var $String = String;
202// eslint-disable-next-line es/no-object-defineproperty -- safe
203var defineProperty = Object.defineProperty;
204var stringSlice = uncurryThis(''.slice);
205var replace = uncurryThis(''.replace);
206var join = uncurryThis([].join);
207
208var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
209 return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
210});
211
212var TEMPLATE = String(String).split('String');
213
214var makeBuiltIn = module.exports = function (value, name, options) {
215 if (stringSlice($String(name), 0, 7) === 'Symbol(') {
216 name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
217 }
218 if (options && options.getter) name = 'get ' + name;
219 if (options && options.setter) name = 'set ' + name;
220 if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
221 if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
222 else value.name = name;
223 }
224 if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
225 defineProperty(value, 'length', { value: options.arity });
226 }
227 try {
228 if (options && hasOwn(options, 'constructor') && options.constructor) {
229 if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
230 // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
231 } else if (value.prototype) value.prototype = undefined;
232 } catch (error) { /* empty */ }
233 var state = enforceInternalState(value);
234 if (!hasOwn(state, 'source')) {
235 state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
236 } return value;
237};
238
239// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
240// eslint-disable-next-line no-extend-native -- required
241Function.prototype.toString = makeBuiltIn(function toString() {
242 return isCallable(this) && getInternalState(this).source || inspectSource(this);
243}, 'toString');
244
245
246/***/ }),
247/* 6 */
248/***/ (function(module, exports, __webpack_require__) {
249
250"use strict";
251
252var NATIVE_BIND = __webpack_require__(7);
253
254var FunctionPrototype = Function.prototype;
255var call = FunctionPrototype.call;
256var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
257
258module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
259 return function () {
260 return call.apply(fn, arguments);
261 };
262};
263
264
265/***/ }),
266/* 7 */
267/***/ (function(module, exports, __webpack_require__) {
268
269"use strict";
270
271var fails = __webpack_require__(3);
272
273module.exports = !fails(function () {
274 // eslint-disable-next-line es/no-function-prototype-bind -- safe
275 var test = (function () { /* empty */ }).bind();
276 // eslint-disable-next-line no-prototype-builtins -- safe
277 return typeof test != 'function' || test.hasOwnProperty('prototype');
278});
279
280
281/***/ }),
282/* 8 */
283/***/ (function(module, exports, __webpack_require__) {
284
285"use strict";
286
287// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
288var documentAll = typeof document == 'object' && document.all;
289
290// `IsCallable` abstract operation
291// https://tc39.es/ecma262/#sec-iscallable
292// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
293module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
294 return typeof argument == 'function' || argument === documentAll;
295} : function (argument) {
296 return typeof argument == 'function';
297};
298
299
300/***/ }),
301/* 9 */
302/***/ (function(module, exports, __webpack_require__) {
303
304"use strict";
305
306var uncurryThis = __webpack_require__(6);
307var toObject = __webpack_require__(10);
308
309var hasOwnProperty = uncurryThis({}.hasOwnProperty);
310
311// `HasOwnProperty` abstract operation
312// https://tc39.es/ecma262/#sec-hasownproperty
313// eslint-disable-next-line es/no-object-hasown -- safe
314module.exports = Object.hasOwn || function hasOwn(it, key) {
315 return hasOwnProperty(toObject(it), key);
316};
317
318
319/***/ }),
320/* 10 */
321/***/ (function(module, exports, __webpack_require__) {
322
323"use strict";
324
325var requireObjectCoercible = __webpack_require__(11);
326
327var $Object = Object;
328
329// `ToObject` abstract operation
330// https://tc39.es/ecma262/#sec-toobject
331module.exports = function (argument) {
332 return $Object(requireObjectCoercible(argument));
333};
334
335
336/***/ }),
337/* 11 */
338/***/ (function(module, exports, __webpack_require__) {
339
340"use strict";
341
342var isNullOrUndefined = __webpack_require__(12);
343
344var $TypeError = TypeError;
345
346// `RequireObjectCoercible` abstract operation
347// https://tc39.es/ecma262/#sec-requireobjectcoercible
348module.exports = function (it) {
349 if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
350 return it;
351};
352
353
354/***/ }),
355/* 12 */
356/***/ (function(module, exports, __webpack_require__) {
357
358"use strict";
359
360// we can't use just `it == null` since of `document.all` special case
361// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
362module.exports = function (it) {
363 return it === null || it === undefined;
364};
365
366
367/***/ }),
368/* 13 */
369/***/ (function(module, exports, __webpack_require__) {
370
371"use strict";
372
373var DESCRIPTORS = __webpack_require__(2);
374var hasOwn = __webpack_require__(9);
375
376var FunctionPrototype = Function.prototype;
377// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
378var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
379
380var EXISTS = hasOwn(FunctionPrototype, 'name');
381// additional protection from minified / mangled / dropped function names
382var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
383var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
384
385module.exports = {
386 EXISTS: EXISTS,
387 PROPER: PROPER,
388 CONFIGURABLE: CONFIGURABLE
389};
390
391
392/***/ }),
393/* 14 */
394/***/ (function(module, exports, __webpack_require__) {
395
396"use strict";
397
398var uncurryThis = __webpack_require__(6);
399var isCallable = __webpack_require__(8);
400var store = __webpack_require__(15);
401
402var functionToString = uncurryThis(Function.toString);
403
405if (!isCallable(store.inspectSource)) {
406 store.inspectSource = function (it) {
407 return functionToString(it);
408 };
409}
410
411module.exports = store.inspectSource;
412
413
414/***/ }),
415/* 15 */
416/***/ (function(module, exports, __webpack_require__) {
417
418"use strict";
419
420var IS_PURE = __webpack_require__(16);
421var globalThis = __webpack_require__(17);
422var defineGlobalProperty = __webpack_require__(18);
423
424var SHARED = '__core-js_shared__';
425var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
426
427(store.versions || (store.versions = [])).push({
428 version: '3.39.0',
429 mode: IS_PURE ? 'pure' : 'global',
430 copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
431 license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE',
432 source: 'https://github.com/zloirock/core-js'
433});
434
435
436/***/ }),
437/* 16 */
438/***/ (function(module, exports, __webpack_require__) {
439
440"use strict";
441
442module.exports = false;
443
444
445/***/ }),
446/* 17 */
447/***/ (function(module, exports, __webpack_require__) {
448
449"use strict";
450
451var check = function (it) {
452 return it && it.Math === Math && it;
453};
454
455// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
456module.exports =
457 // eslint-disable-next-line es/no-global-this -- safe
458 check(typeof globalThis == 'object' && globalThis) ||
459 check(typeof window == 'object' && window) ||
460 // eslint-disable-next-line no-restricted-globals -- safe
461 check(typeof self == 'object' && self) ||
462 check(typeof global == 'object' && global) ||
463 check(typeof this == 'object' && this) ||
464 // eslint-disable-next-line no-new-func -- fallback
465 (function () { return this; })() || Function('return this')();
466
467
468/***/ }),
469/* 18 */
470/***/ (function(module, exports, __webpack_require__) {
471
472"use strict";
473
474var globalThis = __webpack_require__(17);
475
476// eslint-disable-next-line es/no-object-defineproperty -- safe
477var defineProperty = Object.defineProperty;
478
479module.exports = function (key, value) {
480 try {
481 defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
482 } catch (error) {
483 globalThis[key] = value;
484 } return value;
485};
486
487
488/***/ }),
489/* 19 */
490/***/ (function(module, exports, __webpack_require__) {
491
492"use strict";
493
494var NATIVE_WEAK_MAP = __webpack_require__(20);
495var globalThis = __webpack_require__(17);
496var isObject = __webpack_require__(21);
497var createNonEnumerableProperty = __webpack_require__(22);
498var hasOwn = __webpack_require__(9);
499var shared = __webpack_require__(15);
500var sharedKey = __webpack_require__(46);
501var hiddenKeys = __webpack_require__(47);
502
503var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
504var TypeError = globalThis.TypeError;
505var WeakMap = globalThis.WeakMap;
506var set, get, has;
507
508var enforce = function (it) {
509 return has(it) ? get(it) : set(it, {});
510};
511
512var getterFor = function (TYPE) {
513 return function (it) {
514 var state;
515 if (!isObject(it) || (state = get(it)).type !== TYPE) {
516 throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
517 } return state;
518 };
519};
520
521if (NATIVE_WEAK_MAP || shared.state) {
522 var store = shared.state || (shared.state = new WeakMap());
523 /* eslint-disable no-self-assign -- prototype methods protection */
524 store.get = store.get;
525 store.has = store.has;
526 store.set = store.set;
527 /* eslint-enable no-self-assign -- prototype methods protection */
528 set = function (it, metadata) {
529 if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
530 metadata.facade = it;
531 store.set(it, metadata);
532 return metadata;
533 };
534 get = function (it) {
535 return store.get(it) || {};
536 };
537 has = function (it) {
538 return store.has(it);
539 };
540} else {
541 var STATE = sharedKey('state');
542 hiddenKeys[STATE] = true;
543 set = function (it, metadata) {
544 if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
545 metadata.facade = it;
546 createNonEnumerableProperty(it, STATE, metadata);
547 return metadata;
548 };
549 get = function (it) {
550 return hasOwn(it, STATE) ? it[STATE] : {};
551 };
552 has = function (it) {
553 return hasOwn(it, STATE);
554 };
555}
556
557module.exports = {
558 set: set,
559 get: get,
560 has: has,
561 enforce: enforce,
562 getterFor: getterFor
563};
564
565
566/***/ }),
567/* 20 */
568/***/ (function(module, exports, __webpack_require__) {
569
570"use strict";
571
572var globalThis = __webpack_require__(17);
573var isCallable = __webpack_require__(8);
574
575var WeakMap = globalThis.WeakMap;
576
577module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
578
579
580/***/ }),
581/* 21 */
582/***/ (function(module, exports, __webpack_require__) {
583
584"use strict";
585
586var isCallable = __webpack_require__(8);
587
588module.exports = function (it) {
589 return typeof it == 'object' ? it !== null : isCallable(it);
590};
591
592
593/***/ }),
594/* 22 */
595/***/ (function(module, exports, __webpack_require__) {
596
597"use strict";
598
599var DESCRIPTORS = __webpack_require__(2);
600var definePropertyModule = __webpack_require__(23);
601var createPropertyDescriptor = __webpack_require__(45);
602
603module.exports = DESCRIPTORS ? function (object, key, value) {
604 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
605} : function (object, key, value) {
606 object[key] = value;
607 return object;
608};
609
610
611/***/ }),
612/* 23 */
613/***/ (function(module, exports, __webpack_require__) {
614
615"use strict";
616
617var DESCRIPTORS = __webpack_require__(2);
618var IE8_DOM_DEFINE = __webpack_require__(24);
619var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(26);
620var anObject = __webpack_require__(27);
621var toPropertyKey = __webpack_require__(28);
622
623var $TypeError = TypeError;
624// eslint-disable-next-line es/no-object-defineproperty -- safe
625var $defineProperty = Object.defineProperty;
626// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
627var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
628var ENUMERABLE = 'enumerable';
629var CONFIGURABLE = 'configurable';
630var WRITABLE = 'writable';
631
632// `Object.defineProperty` method
633// https://tc39.es/ecma262/#sec-object.defineproperty
634exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
635 anObject(O);
636 P = toPropertyKey(P);
637 anObject(Attributes);
638 if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
639 var current = $getOwnPropertyDescriptor(O, P);
640 if (current && current[WRITABLE]) {
641 O[P] = Attributes.value;
642 Attributes = {
643 configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
644 enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
645 writable: false
646 };
647 }
648 } return $defineProperty(O, P, Attributes);
649} : $defineProperty : function defineProperty(O, P, Attributes) {
650 anObject(O);
651 P = toPropertyKey(P);
652 anObject(Attributes);
653 if (IE8_DOM_DEFINE) try {
654 return $defineProperty(O, P, Attributes);
655 } catch (error) { /* empty */ }
656 if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
657 if ('value' in Attributes) O[P] = Attributes.value;
658 return O;
659};
660
661
662/***/ }),
663/* 24 */
664/***/ (function(module, exports, __webpack_require__) {
665
666"use strict";
667
668var DESCRIPTORS = __webpack_require__(2);
669var fails = __webpack_require__(3);
670var createElement = __webpack_require__(25);
671
672// Thanks to IE8 for its funny defineProperty
673module.exports = !DESCRIPTORS && !fails(function () {
674 // eslint-disable-next-line es/no-object-defineproperty -- required for testing
675 return Object.defineProperty(createElement('div'), 'a', {
676 get: function () { return 7; }
677 }).a !== 7;
678});
679
680
681/***/ }),
682/* 25 */
683/***/ (function(module, exports, __webpack_require__) {
684
685"use strict";
686
687var globalThis = __webpack_require__(17);
688var isObject = __webpack_require__(21);
689
690var document = globalThis.document;
691// typeof document.createElement is 'object' in old IE
692var EXISTS = isObject(document) && isObject(document.createElement);
693
694module.exports = function (it) {
695 return EXISTS ? document.createElement(it) : {};
696};
697
698
699/***/ }),
700/* 26 */
701/***/ (function(module, exports, __webpack_require__) {
702
703"use strict";
704
705var DESCRIPTORS = __webpack_require__(2);
706var fails = __webpack_require__(3);
707
708// V8 ~ Chrome 36-
709// https://bugs.chromium.org/p/v8/issues/detail?id=3334
710module.exports = DESCRIPTORS && fails(function () {
711 // eslint-disable-next-line es/no-object-defineproperty -- required for testing
712 return Object.defineProperty(function () { /* empty */ }, 'prototype', {
713 value: 42,
714 writable: false
715 }).prototype !== 42;
716});
717
718
719/***/ }),
720/* 27 */
721/***/ (function(module, exports, __webpack_require__) {
722
723"use strict";
724
725var isObject = __webpack_require__(21);
726
727var $String = String;
728var $TypeError = TypeError;
729
730// `Assert: Type(argument) is Object`
731module.exports = function (argument) {
732 if (isObject(argument)) return argument;
733 throw new $TypeError($String(argument) + ' is not an object');
734};
735
736
737/***/ }),
738/* 28 */
739/***/ (function(module, exports, __webpack_require__) {
740
741"use strict";
742
743var toPrimitive = __webpack_require__(29);
744var isSymbol = __webpack_require__(31);
745
746// `ToPropertyKey` abstract operation
747// https://tc39.es/ecma262/#sec-topropertykey
748module.exports = function (argument) {
749 var key = toPrimitive(argument, 'string');
750 return isSymbol(key) ? key : key + '';
751};
752
753
754/***/ }),
755/* 29 */
756/***/ (function(module, exports, __webpack_require__) {
757
758"use strict";
759
760var call = __webpack_require__(30);
761var isObject = __webpack_require__(21);
762var isSymbol = __webpack_require__(31);
763var getMethod = __webpack_require__(38);
764var ordinaryToPrimitive = __webpack_require__(41);
765var wellKnownSymbol = __webpack_require__(42);
766
767var $TypeError = TypeError;
768var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
769
770// `ToPrimitive` abstract operation
771// https://tc39.es/ecma262/#sec-toprimitive
772module.exports = function (input, pref) {
773 if (!isObject(input) || isSymbol(input)) return input;
774 var exoticToPrim = getMethod(input, TO_PRIMITIVE);
775 var result;
776 if (exoticToPrim) {
777 if (pref === undefined) pref = 'default';
778 result = call(exoticToPrim, input, pref);
779 if (!isObject(result) || isSymbol(result)) return result;
780 throw new $TypeError("Can't convert object to primitive value");
781 }
782 if (pref === undefined) pref = 'number';
783 return ordinaryToPrimitive(input, pref);
784};
785
786
787/***/ }),
788/* 30 */
789/***/ (function(module, exports, __webpack_require__) {
790
791"use strict";
792
793var NATIVE_BIND = __webpack_require__(7);
794
795var call = Function.prototype.call;
796
797module.exports = NATIVE_BIND ? call.bind(call) : function () {
798 return call.apply(call, arguments);
799};
800
801
802/***/ }),
803/* 31 */
804/***/ (function(module, exports, __webpack_require__) {
805
806"use strict";
807
808var getBuiltIn = __webpack_require__(32);
809var isCallable = __webpack_require__(8);
810var isPrototypeOf = __webpack_require__(33);
811var USE_SYMBOL_AS_UID = __webpack_require__(34);
812
813var $Object = Object;
814
815module.exports = USE_SYMBOL_AS_UID ? function (it) {
816 return typeof it == 'symbol';
817} : function (it) {
818 var $Symbol = getBuiltIn('Symbol');
819 return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
820};
821
822
823/***/ }),
824/* 32 */
825/***/ (function(module, exports, __webpack_require__) {
826
827"use strict";
828
829var globalThis = __webpack_require__(17);
830var isCallable = __webpack_require__(8);
831
832var aFunction = function (argument) {
833 return isCallable(argument) ? argument : undefined;
834};
835
836module.exports = function (namespace, method) {
837 return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
838};
839
840
841/***/ }),
842/* 33 */
843/***/ (function(module, exports, __webpack_require__) {
844
845"use strict";
846
847var uncurryThis = __webpack_require__(6);
848
849module.exports = uncurryThis({}.isPrototypeOf);
850
851
852/***/ }),
853/* 34 */
854/***/ (function(module, exports, __webpack_require__) {
855
856"use strict";
857
858/* eslint-disable es/no-symbol -- required for testing */
859var NATIVE_SYMBOL = __webpack_require__(35);
860
861module.exports = NATIVE_SYMBOL &&
862 !Symbol.sham &&
863 typeof Symbol.iterator == 'symbol';
864
865
866/***/ }),
867/* 35 */
868/***/ (function(module, exports, __webpack_require__) {
869
870"use strict";
871
872/* eslint-disable es/no-symbol -- required for testing */
873var V8_VERSION = __webpack_require__(36);
874var fails = __webpack_require__(3);
875var globalThis = __webpack_require__(17);
876
877var $String = globalThis.String;
878
879// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
880module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
881 var symbol = Symbol('symbol detection');
882 // Chrome 38 Symbol has incorrect toString conversion
883 // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
884 // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
885 // of course, fail.
886 return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
887 // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
888 !Symbol.sham && V8_VERSION && V8_VERSION < 41;
889});
890
891
892/***/ }),
893/* 36 */
894/***/ (function(module, exports, __webpack_require__) {
895
896"use strict";
897
898var globalThis = __webpack_require__(17);
899var userAgent = __webpack_require__(37);
900
901var process = globalThis.process;
902var Deno = globalThis.Deno;
903var versions = process && process.versions || Deno && Deno.version;
904var v8 = versions && versions.v8;
905var match, version;
906
907if (v8) {
908 match = v8.split('.');
909 // in old Chrome, versions of V8 isn't V8 = Chrome / 10
910 // but their correct versions are not interesting for us
911 version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
912}
913
914// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
915// so check `userAgent` even if `.v8` exists, but 0
916if (!version && userAgent) {
917 match = userAgent.match(/Edge\/(\d+)/);
918 if (!match || match[1] >= 74) {
919 match = userAgent.match(/Chrome\/(\d+)/);
920 if (match) version = +match[1];
921 }
922}
923
924module.exports = version;
925
926
927/***/ }),
928/* 37 */
929/***/ (function(module, exports, __webpack_require__) {
930
931"use strict";
932
933var globalThis = __webpack_require__(17);
934
935var navigator = globalThis.navigator;
936var userAgent = navigator && navigator.userAgent;
937
938module.exports = userAgent ? String(userAgent) : '';
939
940
941/***/ }),
942/* 38 */
943/***/ (function(module, exports, __webpack_require__) {
944
945"use strict";
946
947var aCallable = __webpack_require__(39);
948var isNullOrUndefined = __webpack_require__(12);
949
950// `GetMethod` abstract operation
951// https://tc39.es/ecma262/#sec-getmethod
952module.exports = function (V, P) {
953 var func = V[P];
954 return isNullOrUndefined(func) ? undefined : aCallable(func);
955};
956
957
958/***/ }),
959/* 39 */
960/***/ (function(module, exports, __webpack_require__) {
961
962"use strict";
963
964var isCallable = __webpack_require__(8);
965var tryToString = __webpack_require__(40);
966
967var $TypeError = TypeError;
968
969// `Assert: IsCallable(argument) is true`
970module.exports = function (argument) {
971 if (isCallable(argument)) return argument;
972 throw new $TypeError(tryToString(argument) + ' is not a function');
973};
974
975
976/***/ }),
977/* 40 */
978/***/ (function(module, exports, __webpack_require__) {
979
980"use strict";
981
982var $String = String;
983
984module.exports = function (argument) {
985 try {
986 return $String(argument);
987 } catch (error) {
988 return 'Object';
989 }
990};
991
992
993/***/ }),
994/* 41 */
995/***/ (function(module, exports, __webpack_require__) {
996
997"use strict";
998
999var call = __webpack_require__(30);
1000var isCallable = __webpack_require__(8);
1001var isObject = __webpack_require__(21);
1002
1003var $TypeError = TypeError;
1004
1005// `OrdinaryToPrimitive` abstract operation
1006// https://tc39.es/ecma262/#sec-ordinarytoprimitive
1007module.exports = function (input, pref) {
1008 var fn, val;
1009 if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
1010 if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
1011 if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
1012 throw new $TypeError("Can't convert object to primitive value");
1013};
1014
1015
1016/***/ }),
1017/* 42 */
1018/***/ (function(module, exports, __webpack_require__) {
1019
1020"use strict";
1021
1022var globalThis = __webpack_require__(17);
1023var shared = __webpack_require__(43);
1024var hasOwn = __webpack_require__(9);
1025var uid = __webpack_require__(44);
1026var NATIVE_SYMBOL = __webpack_require__(35);
1027var USE_SYMBOL_AS_UID = __webpack_require__(34);
1028
1029var Symbol = globalThis.Symbol;
1030var WellKnownSymbolsStore = shared('wks');
1031var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
1032
1033module.exports = function (name) {
1034 if (!hasOwn(WellKnownSymbolsStore, name)) {
1035 WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
1036 ? Symbol[name]
1037 : createWellKnownSymbol('Symbol.' + name);
1038 } return WellKnownSymbolsStore[name];
1039};
1040
1041
1042/***/ }),
1043/* 43 */
1044/***/ (function(module, exports, __webpack_require__) {
1045
1046"use strict";
1047
1048var store = __webpack_require__(15);
1049
1050module.exports = function (key, value) {
1051 return store[key] || (store[key] = value || {});
1052};
1053
1054
1055/***/ }),
1056/* 44 */
1057/***/ (function(module, exports, __webpack_require__) {
1058
1059"use strict";
1060
1061var uncurryThis = __webpack_require__(6);
1062
1063var id = 0;
1064var postfix = Math.random();
1065var toString = uncurryThis(1.0.toString);
1066
1067module.exports = function (key) {
1068 return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
1069};
1070
1071
1072/***/ }),
1073/* 45 */
1074/***/ (function(module, exports, __webpack_require__) {
1075
1076"use strict";
1077
1078module.exports = function (bitmap, value) {
1079 return {
1080 enumerable: !(bitmap & 1),
1081 configurable: !(bitmap & 2),
1082 writable: !(bitmap & 4),
1083 value: value
1084 };
1085};
1086
1087
1088/***/ }),
1089/* 46 */
1090/***/ (function(module, exports, __webpack_require__) {
1091
1092"use strict";
1093
1094var shared = __webpack_require__(43);
1095var uid = __webpack_require__(44);
1096
1097var keys = shared('keys');
1098
1099module.exports = function (key) {
1100 return keys[key] || (keys[key] = uid(key));
1101};
1102
1103
1104/***/ }),
1105/* 47 */
1106/***/ (function(module, exports, __webpack_require__) {
1107
1108"use strict";
1109
1110module.exports = {};
1111
1112
1113/***/ }),
1114/* 48 */
1115/***/ (function(module, exports, __webpack_require__) {
1116
1117"use strict";
1118
1119var globalThis = __webpack_require__(17);
1120var uncurryThis = __webpack_require__(49);
1121var arrayBufferByteLength = __webpack_require__(51);
1122
1123var ArrayBuffer = globalThis.ArrayBuffer;
1124var ArrayBufferPrototype = ArrayBuffer && ArrayBuffer.prototype;
1125var slice = ArrayBufferPrototype && uncurryThis(ArrayBufferPrototype.slice);
1126
1127module.exports = function (O) {
1128 if (arrayBufferByteLength(O) !== 0) return false;
1129 if (!slice) return false;
1130 try {
1131 slice(O, 0, 0);
1132 return false;
1133 } catch (error) {
1134 return true;
1135 }
1136};
1137
1138
1139/***/ }),
1140/* 49 */
1141/***/ (function(module, exports, __webpack_require__) {
1142
1143"use strict";
1144
1145var classofRaw = __webpack_require__(50);
1146var uncurryThis = __webpack_require__(6);
1147
1148module.exports = function (fn) {
1149 // Nashorn bug:
1150 // https://github.com/zloirock/core-js/issues/1128
1151 // https://github.com/zloirock/core-js/issues/1130
1152 if (classofRaw(fn) === 'Function') return uncurryThis(fn);
1153};
1154
1155
1156/***/ }),
1157/* 50 */
1158/***/ (function(module, exports, __webpack_require__) {
1159
1160"use strict";
1161
1162var uncurryThis = __webpack_require__(6);
1163
1164var toString = uncurryThis({}.toString);
1165var stringSlice = uncurryThis(''.slice);
1166
1167module.exports = function (it) {
1168 return stringSlice(toString(it), 8, -1);
1169};
1170
1171
1172/***/ }),
1173/* 51 */
1174/***/ (function(module, exports, __webpack_require__) {
1175
1176"use strict";
1177
1178var globalThis = __webpack_require__(17);
1179var uncurryThisAccessor = __webpack_require__(52);
1180var classof = __webpack_require__(50);
1181
1182var ArrayBuffer = globalThis.ArrayBuffer;
1183var TypeError = globalThis.TypeError;
1184
1185// Includes
1186// - Perform ? RequireInternalSlot(O, [[ArrayBufferData]]).
1187// - If IsSharedArrayBuffer(O) is true, throw a TypeError exception.
1188module.exports = ArrayBuffer && uncurryThisAccessor(ArrayBuffer.prototype, 'byteLength', 'get') || function (O) {
1189 if (classof(O) !== 'ArrayBuffer') throw new TypeError('ArrayBuffer expected');
1190 return O.byteLength;
1191};
1192
1193
1194/***/ }),
1195/* 52 */
1196/***/ (function(module, exports, __webpack_require__) {
1197
1198"use strict";
1199
1200var uncurryThis = __webpack_require__(6);
1201var aCallable = __webpack_require__(39);
1202
1203module.exports = function (object, key, method) {
1204 try {
1205 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1206 return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
1207 } catch (error) { /* empty */ }
1208};
1209
1210
1211/***/ }),
1212/* 53 */
1213/***/ (function(module, exports, __webpack_require__) {
1214
1215"use strict";
1216
1217var $ = __webpack_require__(54);
1218var $transfer = __webpack_require__(73);
1219
1220// `ArrayBuffer.prototype.transfer` method
1221// https://tc39.es/proposal-arraybuffer-transfer/#sec-arraybuffer.prototype.transfer
1222if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
1223 transfer: function transfer() {
1224 return $transfer(this, arguments.length ? arguments[0] : undefined, true);
1225 }
1226});
1227
1228
1229/***/ }),
1230/* 54 */
1231/***/ (function(module, exports, __webpack_require__) {
1232
1233"use strict";
1234
1235var globalThis = __webpack_require__(17);
1236var getOwnPropertyDescriptor = __webpack_require__(55).f;
1237var createNonEnumerableProperty = __webpack_require__(22);
1238var defineBuiltIn = __webpack_require__(59);
1239var defineGlobalProperty = __webpack_require__(18);
1240var copyConstructorProperties = __webpack_require__(60);
1241var isForced = __webpack_require__(72);
1242
1243/*
1244 options.target - name of the target object
1245 options.global - target is the global object
1246 options.stat - export as static methods of target
1247 options.proto - export as prototype methods of target
1248 options.real - real prototype method for the `pure` version
1249 options.forced - export even if the native feature is available
1250 options.bind - bind methods to the target, required for the `pure` version
1251 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
1252 options.unsafe - use the simple assignment of property instead of delete + defineProperty
1253 options.sham - add a flag to not completely full polyfills
1254 options.enumerable - export as enumerable property
1255 options.dontCallGetSet - prevent calling a getter on target
1256 options.name - the .name of the function if it does not match the key
1257*/
1258module.exports = function (options, source) {
1259 var TARGET = options.target;
1260 var GLOBAL = options.global;
1261 var STATIC = options.stat;
1262 var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1263 if (GLOBAL) {
1264 target = globalThis;
1265 } else if (STATIC) {
1266 target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
1267 } else {
1268 target = globalThis[TARGET] && globalThis[TARGET].prototype;
1269 }
1270 if (target) for (key in source) {
1271 sourceProperty = source[key];
1272 if (options.dontCallGetSet) {
1273 descriptor = getOwnPropertyDescriptor(target, key);
1274 targetProperty = descriptor && descriptor.value;
1275 } else targetProperty = target[key];
1276 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
1277 // contained in target
1278 if (!FORCED && targetProperty !== undefined) {
1279 if (typeof sourceProperty == typeof targetProperty) continue;
1280 copyConstructorProperties(sourceProperty, targetProperty);
1281 }
1282 // add a flag to not completely full polyfills
1283 if (options.sham || (targetProperty && targetProperty.sham)) {
1284 createNonEnumerableProperty(sourceProperty, 'sham', true);
1285 }
1286 defineBuiltIn(target, key, sourceProperty, options);
1287 }
1288};
1289
1290
1291/***/ }),
1292/* 55 */
1293/***/ (function(module, exports, __webpack_require__) {
1294
1295"use strict";
1296
1297var DESCRIPTORS = __webpack_require__(2);
1298var call = __webpack_require__(30);
1299var propertyIsEnumerableModule = __webpack_require__(56);
1300var createPropertyDescriptor = __webpack_require__(45);
1301var toIndexedObject = __webpack_require__(57);
1302var toPropertyKey = __webpack_require__(28);
1303var hasOwn = __webpack_require__(9);
1304var IE8_DOM_DEFINE = __webpack_require__(24);
1305
1306// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1307var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1308
1309// `Object.getOwnPropertyDescriptor` method
1310// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
1311exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
1312 O = toIndexedObject(O);
1313 P = toPropertyKey(P);
1314 if (IE8_DOM_DEFINE) try {
1315 return $getOwnPropertyDescriptor(O, P);
1316 } catch (error) { /* empty */ }
1317 if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
1318};
1319
1320
1321/***/ }),
1322/* 56 */
1323/***/ (function(module, exports, __webpack_require__) {
1324
1325"use strict";
1326
1327var $propertyIsEnumerable = {}.propertyIsEnumerable;
1328// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1329var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1330
1331// Nashorn ~ JDK8 bug
1332var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
1333
1334// `Object.prototype.propertyIsEnumerable` method implementation
1335// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
1336exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
1337 var descriptor = getOwnPropertyDescriptor(this, V);
1338 return !!descriptor && descriptor.enumerable;
1339} : $propertyIsEnumerable;
1340
1341
1342/***/ }),
1343/* 57 */
1344/***/ (function(module, exports, __webpack_require__) {
1345
1346"use strict";
1347
1348// toObject with fallback for non-array-like ES3 strings
1349var IndexedObject = __webpack_require__(58);
1350var requireObjectCoercible = __webpack_require__(11);
1351
1352module.exports = function (it) {
1353 return IndexedObject(requireObjectCoercible(it));
1354};
1355
1356
1357/***/ }),
1358/* 58 */
1359/***/ (function(module, exports, __webpack_require__) {
1360
1361"use strict";
1362
1363var uncurryThis = __webpack_require__(6);
1364var fails = __webpack_require__(3);
1365var classof = __webpack_require__(50);
1366
1367var $Object = Object;
1368var split = uncurryThis(''.split);
1369
1370// fallback for non-array-like ES3 and non-enumerable old V8 strings
1371module.exports = fails(function () {
1372 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
1373 // eslint-disable-next-line no-prototype-builtins -- safe
1374 return !$Object('z').propertyIsEnumerable(0);
1375}) ? function (it) {
1376 return classof(it) === 'String' ? split(it, '') : $Object(it);
1377} : $Object;
1378
1379
1380/***/ }),
1381/* 59 */
1382/***/ (function(module, exports, __webpack_require__) {
1383
1384"use strict";
1385
1386var isCallable = __webpack_require__(8);
1387var definePropertyModule = __webpack_require__(23);
1388var makeBuiltIn = __webpack_require__(5);
1389var defineGlobalProperty = __webpack_require__(18);
1390
1391module.exports = function (O, key, value, options) {
1392 if (!options) options = {};
1393 var simple = options.enumerable;
1394 var name = options.name !== undefined ? options.name : key;
1395 if (isCallable(value)) makeBuiltIn(value, name, options);
1396 if (options.global) {
1397 if (simple) O[key] = value;
1398 else defineGlobalProperty(key, value);
1399 } else {
1400 try {
1401 if (!options.unsafe) delete O[key];
1402 else if (O[key]) simple = true;
1403 } catch (error) { /* empty */ }
1404 if (simple) O[key] = value;
1405 else definePropertyModule.f(O, key, {
1406 value: value,
1407 enumerable: false,
1408 configurable: !options.nonConfigurable,
1409 writable: !options.nonWritable
1410 });
1411 } return O;
1412};
1413
1414
1415/***/ }),
1416/* 60 */
1417/***/ (function(module, exports, __webpack_require__) {
1418
1419"use strict";
1420
1421var hasOwn = __webpack_require__(9);
1422var ownKeys = __webpack_require__(61);
1423var getOwnPropertyDescriptorModule = __webpack_require__(55);
1424var definePropertyModule = __webpack_require__(23);
1425
1426module.exports = function (target, source, exceptions) {
1427 var keys = ownKeys(source);
1428 var defineProperty = definePropertyModule.f;
1429 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1430 for (var i = 0; i < keys.length; i++) {
1431 var key = keys[i];
1432 if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
1433 defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1434 }
1435 }
1436};
1437
1438
1439/***/ }),
1440/* 61 */
1441/***/ (function(module, exports, __webpack_require__) {
1442
1443"use strict";
1444
1445var getBuiltIn = __webpack_require__(32);
1446var uncurryThis = __webpack_require__(6);
1447var getOwnPropertyNamesModule = __webpack_require__(62);
1448var getOwnPropertySymbolsModule = __webpack_require__(71);
1449var anObject = __webpack_require__(27);
1450
1451var concat = uncurryThis([].concat);
1452
1453// all object keys, includes non-enumerable and symbols
1454module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
1455 var keys = getOwnPropertyNamesModule.f(anObject(it));
1456 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1457 return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
1458};
1459
1460
1461/***/ }),
1462/* 62 */
1463/***/ (function(module, exports, __webpack_require__) {
1464
1465"use strict";
1466
1467var internalObjectKeys = __webpack_require__(63);
1468var enumBugKeys = __webpack_require__(70);
1469
1470var hiddenKeys = enumBugKeys.concat('length', 'prototype');
1471
1472// `Object.getOwnPropertyNames` method
1473// https://tc39.es/ecma262/#sec-object.getownpropertynames
1474// eslint-disable-next-line es/no-object-getownpropertynames -- safe
1475exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1476 return internalObjectKeys(O, hiddenKeys);
1477};
1478
1479
1480/***/ }),
1481/* 63 */
1482/***/ (function(module, exports, __webpack_require__) {
1483
1484"use strict";
1485
1486var uncurryThis = __webpack_require__(6);
1487var hasOwn = __webpack_require__(9);
1488var toIndexedObject = __webpack_require__(57);
1489var indexOf = __webpack_require__(64).indexOf;
1490var hiddenKeys = __webpack_require__(47);
1491
1492var push = uncurryThis([].push);
1493
1494module.exports = function (object, names) {
1495 var O = toIndexedObject(object);
1496 var i = 0;
1497 var result = [];
1498 var key;
1499 for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
1500 // Don't enum bug & hidden keys
1501 while (names.length > i) if (hasOwn(O, key = names[i++])) {
1502 ~indexOf(result, key) || push(result, key);
1503 }
1504 return result;
1505};
1506
1507
1508/***/ }),
1509/* 64 */
1510/***/ (function(module, exports, __webpack_require__) {
1511
1512"use strict";
1513
1514var toIndexedObject = __webpack_require__(57);
1515var toAbsoluteIndex = __webpack_require__(65);
1516var lengthOfArrayLike = __webpack_require__(68);
1517
1518// `Array.prototype.{ indexOf, includes }` methods implementation
1519var createMethod = function (IS_INCLUDES) {
1520 return function ($this, el, fromIndex) {
1521 var O = toIndexedObject($this);
1522 var length = lengthOfArrayLike(O);
1523 if (length === 0) return !IS_INCLUDES && -1;
1524 var index = toAbsoluteIndex(fromIndex, length);
1525 var value;
1526 // Array#includes uses SameValueZero equality algorithm
1527 // eslint-disable-next-line no-self-compare -- NaN check
1528 if (IS_INCLUDES && el !== el) while (length > index) {
1529 value = O[index++];
1530 // eslint-disable-next-line no-self-compare -- NaN check
1531 if (value !== value) return true;
1532 // Array#indexOf ignores holes, Array#includes - not
1533 } else for (;length > index; index++) {
1534 if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
1535 } return !IS_INCLUDES && -1;
1536 };
1537};
1538
1539module.exports = {
1540 // `Array.prototype.includes` method
1541 // https://tc39.es/ecma262/#sec-array.prototype.includes
1542 includes: createMethod(true),
1543 // `Array.prototype.indexOf` method
1544 // https://tc39.es/ecma262/#sec-array.prototype.indexof
1545 indexOf: createMethod(false)
1546};
1547
1548
1549/***/ }),
1550/* 65 */
1551/***/ (function(module, exports, __webpack_require__) {
1552
1553"use strict";
1554
1555var toIntegerOrInfinity = __webpack_require__(66);
1556
1557var max = Math.max;
1558var min = Math.min;
1559
1560// Helper for a popular repeating case of the spec:
1561// Let integer be ? ToInteger(index).
1562// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1563module.exports = function (index, length) {
1564 var integer = toIntegerOrInfinity(index);
1565 return integer < 0 ? max(integer + length, 0) : min(integer, length);
1566};
1567
1568
1569/***/ }),
1570/* 66 */
1571/***/ (function(module, exports, __webpack_require__) {
1572
1573"use strict";
1574
1575var trunc = __webpack_require__(67);
1576
1577// `ToIntegerOrInfinity` abstract operation
1578// https://tc39.es/ecma262/#sec-tointegerorinfinity
1579module.exports = function (argument) {
1580 var number = +argument;
1581 // eslint-disable-next-line no-self-compare -- NaN check
1582 return number !== number || number === 0 ? 0 : trunc(number);
1583};
1584
1585
1586/***/ }),
1587/* 67 */
1588/***/ (function(module, exports, __webpack_require__) {
1589
1590"use strict";
1591
1592var ceil = Math.ceil;
1593var floor = Math.floor;
1594
1595// `Math.trunc` method
1596// https://tc39.es/ecma262/#sec-math.trunc
1597// eslint-disable-next-line es/no-math-trunc -- safe
1598module.exports = Math.trunc || function trunc(x) {
1599 var n = +x;
1600 return (n > 0 ? floor : ceil)(n);
1601};
1602
1603
1604/***/ }),
1605/* 68 */
1606/***/ (function(module, exports, __webpack_require__) {
1607
1608"use strict";
1609
1610var toLength = __webpack_require__(69);
1611
1612// `LengthOfArrayLike` abstract operation
1613// https://tc39.es/ecma262/#sec-lengthofarraylike
1614module.exports = function (obj) {
1615 return toLength(obj.length);
1616};
1617
1618
1619/***/ }),
1620/* 69 */
1621/***/ (function(module, exports, __webpack_require__) {
1622
1623"use strict";
1624
1625var toIntegerOrInfinity = __webpack_require__(66);
1626
1627var min = Math.min;
1628
1629// `ToLength` abstract operation
1630// https://tc39.es/ecma262/#sec-tolength
1631module.exports = function (argument) {
1632 var len = toIntegerOrInfinity(argument);
1633 return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1634};
1635
1636
1637/***/ }),
1638/* 70 */
1639/***/ (function(module, exports, __webpack_require__) {
1640
1641"use strict";
1642
1643// IE8- don't enum bug keys
1644module.exports = [
1645 'constructor',
1646 'hasOwnProperty',
1647 'isPrototypeOf',
1648 'propertyIsEnumerable',
1649 'toLocaleString',
1650 'toString',
1651 'valueOf'
1652];
1653
1654
1655/***/ }),
1656/* 71 */
1657/***/ (function(module, exports, __webpack_require__) {
1658
1659"use strict";
1660
1661// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
1662exports.f = Object.getOwnPropertySymbols;
1663
1664
1665/***/ }),
1666/* 72 */
1667/***/ (function(module, exports, __webpack_require__) {
1668
1669"use strict";
1670
1671var fails = __webpack_require__(3);
1672var isCallable = __webpack_require__(8);
1673
1674var replacement = /#|\.prototype\./;
1675
1676var isForced = function (feature, detection) {
1677 var value = data[normalize(feature)];
1678 return value === POLYFILL ? true
1679 : value === NATIVE ? false
1680 : isCallable(detection) ? fails(detection)
1681 : !!detection;
1682};
1683
1684var normalize = isForced.normalize = function (string) {
1685 return String(string).replace(replacement, '.').toLowerCase();
1686};
1687
1688var data = isForced.data = {};
1689var NATIVE = isForced.NATIVE = 'N';
1690var POLYFILL = isForced.POLYFILL = 'P';
1691
1692module.exports = isForced;
1693
1694
1695/***/ }),
1696/* 73 */
1697/***/ (function(module, exports, __webpack_require__) {
1698
1699"use strict";
1700
1701var globalThis = __webpack_require__(17);
1702var uncurryThis = __webpack_require__(6);
1703var uncurryThisAccessor = __webpack_require__(52);
1704var toIndex = __webpack_require__(74);
1705var notDetached = __webpack_require__(75);
1706var arrayBufferByteLength = __webpack_require__(51);
1707var detachTransferable = __webpack_require__(76);
1708var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(80);
1709
1710var structuredClone = globalThis.structuredClone;
1711var ArrayBuffer = globalThis.ArrayBuffer;
1712var DataView = globalThis.DataView;
1713var min = Math.min;
1714var ArrayBufferPrototype = ArrayBuffer.prototype;
1715var DataViewPrototype = DataView.prototype;
1716var slice = uncurryThis(ArrayBufferPrototype.slice);
1717var isResizable = uncurryThisAccessor(ArrayBufferPrototype, 'resizable', 'get');
1718var maxByteLength = uncurryThisAccessor(ArrayBufferPrototype, 'maxByteLength', 'get');
1719var getInt8 = uncurryThis(DataViewPrototype.getInt8);
1720var setInt8 = uncurryThis(DataViewPrototype.setInt8);
1721
1722module.exports = (PROPER_STRUCTURED_CLONE_TRANSFER || detachTransferable) && function (arrayBuffer, newLength, preserveResizability) {
1723 var byteLength = arrayBufferByteLength(arrayBuffer);
1724 var newByteLength = newLength === undefined ? byteLength : toIndex(newLength);
1725 var fixedLength = !isResizable || !isResizable(arrayBuffer);
1726 var newBuffer;
1727 notDetached(arrayBuffer);
1728 if (PROPER_STRUCTURED_CLONE_TRANSFER) {
1729 arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
1730 if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer;
1731 }
1732 if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) {
1733 newBuffer = slice(arrayBuffer, 0, newByteLength);
1734 } else {
1735 var options = preserveResizability && !fixedLength && maxByteLength ? { maxByteLength: maxByteLength(arrayBuffer) } : undefined;
1736 newBuffer = new ArrayBuffer(newByteLength, options);
1737 var a = new DataView(arrayBuffer);
1738 var b = new DataView(newBuffer);
1739 var copyLength = min(newByteLength, byteLength);
1740 for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i));
1741 }
1742 if (!PROPER_STRUCTURED_CLONE_TRANSFER) detachTransferable(arrayBuffer);
1743 return newBuffer;
1744};
1745
1746
1747/***/ }),
1748/* 74 */
1749/***/ (function(module, exports, __webpack_require__) {
1750
1751"use strict";
1752
1753var toIntegerOrInfinity = __webpack_require__(66);
1754var toLength = __webpack_require__(69);
1755
1756var $RangeError = RangeError;
1757
1758// `ToIndex` abstract operation
1759// https://tc39.es/ecma262/#sec-toindex
1760module.exports = function (it) {
1761 if (it === undefined) return 0;
1762 var number = toIntegerOrInfinity(it);
1763 var length = toLength(number);
1764 if (number !== length) throw new $RangeError('Wrong length or index');
1765 return length;
1766};
1767
1768
1769/***/ }),
1770/* 75 */
1771/***/ (function(module, exports, __webpack_require__) {
1772
1773"use strict";
1774
1775var isDetached = __webpack_require__(48);
1776
1777var $TypeError = TypeError;
1778
1779module.exports = function (it) {
1780 if (isDetached(it)) throw new $TypeError('ArrayBuffer is detached');
1781 return it;
1782};
1783
1784
1785/***/ }),
1786/* 76 */
1787/***/ (function(module, exports, __webpack_require__) {
1788
1789"use strict";
1790
1791var globalThis = __webpack_require__(17);
1792var getBuiltInNodeModule = __webpack_require__(77);
1793var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(80);
1794
1795var structuredClone = globalThis.structuredClone;
1796var $ArrayBuffer = globalThis.ArrayBuffer;
1797var $MessageChannel = globalThis.MessageChannel;
1798var detach = false;
1799var WorkerThreads, channel, buffer, $detach;
1800
1801if (PROPER_STRUCTURED_CLONE_TRANSFER) {
1802 detach = function (transferable) {
1803 structuredClone(transferable, { transfer: [transferable] });
1804 };
1805} else if ($ArrayBuffer) try {
1806 if (!$MessageChannel) {
1807 WorkerThreads = getBuiltInNodeModule('worker_threads');
1808 if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
1809 }
1810
1811 if ($MessageChannel) {
1812 channel = new $MessageChannel();
1813 buffer = new $ArrayBuffer(2);
1814
1815 $detach = function (transferable) {
1816 channel.port1.postMessage(null, [transferable]);
1817 };
1818
1819 if (buffer.byteLength === 2) {
1820 $detach(buffer);
1821 if (buffer.byteLength === 0) detach = $detach;
1822 }
1823 }
1824} catch (error) { /* empty */ }
1825
1826module.exports = detach;
1827
1828
1829/***/ }),
1830/* 77 */
1831/***/ (function(module, exports, __webpack_require__) {
1832
1833"use strict";
1834
1835var globalThis = __webpack_require__(17);
1836var IS_NODE = __webpack_require__(78);
1837
1838module.exports = function (name) {
1839 if (IS_NODE) {
1840 try {
1841 return globalThis.process.getBuiltinModule(name);
1842 } catch (error) { /* empty */ }
1843 try {
1844 // eslint-disable-next-line no-new-func -- safe
1845 return Function('return require("' + name + '")')();
1846 } catch (error) { /* empty */ }
1847 }
1848};
1849
1850
1851/***/ }),
1852/* 78 */
1853/***/ (function(module, exports, __webpack_require__) {
1854
1855"use strict";
1856
1857var ENVIRONMENT = __webpack_require__(79);
1858
1859module.exports = ENVIRONMENT === 'NODE';
1860
1861
1862/***/ }),
1863/* 79 */
1864/***/ (function(module, exports, __webpack_require__) {
1865
1866"use strict";
1867
1868/* global Bun, Deno -- detection */
1869var globalThis = __webpack_require__(17);
1870var userAgent = __webpack_require__(37);
1871var classof = __webpack_require__(50);
1872
1873var userAgentStartsWith = function (string) {
1874 return userAgent.slice(0, string.length) === string;
1875};
1876
1877module.exports = (function () {
1878 if (userAgentStartsWith('Bun/')) return 'BUN';
1879 if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
1880 if (userAgentStartsWith('Deno/')) return 'DENO';
1881 if (userAgentStartsWith('Node.js/')) return 'NODE';
1882 if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN';
1883 if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO';
1884 if (classof(globalThis.process) === 'process') return 'NODE';
1885 if (globalThis.window && globalThis.document) return 'BROWSER';
1886 return 'REST';
1887})();
1888
1889
1890/***/ }),
1891/* 80 */
1892/***/ (function(module, exports, __webpack_require__) {
1893
1894"use strict";
1895
1896var globalThis = __webpack_require__(17);
1897var fails = __webpack_require__(3);
1898var V8 = __webpack_require__(36);
1899var ENVIRONMENT = __webpack_require__(79);
1900
1901var structuredClone = globalThis.structuredClone;
1902
1903module.exports = !!structuredClone && !fails(function () {
1904 // prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation
1905 // https://github.com/zloirock/core-js/issues/679
1906 if ((ENVIRONMENT === 'DENO' && V8 > 92) || (ENVIRONMENT === 'NODE' && V8 > 94) || (ENVIRONMENT === 'BROWSER' && V8 > 97)) return false;
1907 var buffer = new ArrayBuffer(8);
1908 var clone = structuredClone(buffer, { transfer: [buffer] });
1909 return buffer.byteLength !== 0 || clone.byteLength !== 8;
1910});
1911
1912
1913/***/ }),
1914/* 81 */
1915/***/ (function(module, exports, __webpack_require__) {
1916
1917"use strict";
1918
1919var $ = __webpack_require__(54);
1920var $transfer = __webpack_require__(73);
1921
1922// `ArrayBuffer.prototype.transferToFixedLength` method
1923// https://tc39.es/proposal-arraybuffer-transfer/#sec-arraybuffer.prototype.transfertofixedlength
1924if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
1925 transferToFixedLength: function transferToFixedLength() {
1926 return $transfer(this, arguments.length ? arguments[0] : undefined, false);
1927 }
1928});
1929
1930
1931/***/ }),
1932/* 82 */
1933/***/ (function(module, exports, __webpack_require__) {
1934
1935"use strict";
1936
1937var $ = __webpack_require__(54);
1938var uncurryThis = __webpack_require__(6);
1939var aCallable = __webpack_require__(39);
1940var requireObjectCoercible = __webpack_require__(11);
1941var iterate = __webpack_require__(83);
1942var MapHelpers = __webpack_require__(92);
1943var IS_PURE = __webpack_require__(16);
1944var fails = __webpack_require__(3);
1945
1946var Map = MapHelpers.Map;
1947var has = MapHelpers.has;
1948var get = MapHelpers.get;
1949var set = MapHelpers.set;
1950var push = uncurryThis([].push);
1951
1952var DOES_NOT_WORK_WITH_PRIMITIVES = IS_PURE || fails(function () {
1953 return Map.groupBy('ab', function (it) {
1954 return it;
1955 }).get('a').length !== 1;
1956});
1957
1958// `Map.groupBy` method
1959// https://tc39.es/ecma262/#sec-map.groupby
1960$({ target: 'Map', stat: true, forced: IS_PURE || DOES_NOT_WORK_WITH_PRIMITIVES }, {
1961 groupBy: function groupBy(items, callbackfn) {
1962 requireObjectCoercible(items);
1963 aCallable(callbackfn);
1964 var map = new Map();
1965 var k = 0;
1966 iterate(items, function (value) {
1967 var key = callbackfn(value, k++);
1968 if (!has(map, key)) set(map, key, [value]);
1969 else push(get(map, key), value);
1970 });
1971 return map;
1972 }
1973});
1974
1975
1976/***/ }),
1977/* 83 */
1978/***/ (function(module, exports, __webpack_require__) {
1979
1980"use strict";
1981
1982var bind = __webpack_require__(84);
1983var call = __webpack_require__(30);
1984var anObject = __webpack_require__(27);
1985var tryToString = __webpack_require__(40);
1986var isArrayIteratorMethod = __webpack_require__(85);
1987var lengthOfArrayLike = __webpack_require__(68);
1988var isPrototypeOf = __webpack_require__(33);
1989var getIterator = __webpack_require__(87);
1990var getIteratorMethod = __webpack_require__(88);
1991var iteratorClose = __webpack_require__(91);
1992
1993var $TypeError = TypeError;
1994
1995var Result = function (stopped, result) {
1996 this.stopped = stopped;
1997 this.result = result;
1998};
1999
2000var ResultPrototype = Result.prototype;
2001
2002module.exports = function (iterable, unboundFunction, options) {
2003 var that = options && options.that;
2004 var AS_ENTRIES = !!(options && options.AS_ENTRIES);
2005 var IS_RECORD = !!(options && options.IS_RECORD);
2006 var IS_ITERATOR = !!(options && options.IS_ITERATOR);
2007 var INTERRUPTED = !!(options && options.INTERRUPTED);
2008 var fn = bind(unboundFunction, that);
2009 var iterator, iterFn, index, length, result, next, step;
2010
2011 var stop = function (condition) {
2012 if (iterator) iteratorClose(iterator, 'normal', condition);
2013 return new Result(true, condition);
2014 };
2015
2016 var callFn = function (value) {
2017 if (AS_ENTRIES) {
2018 anObject(value);
2019 return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
2020 } return INTERRUPTED ? fn(value, stop) : fn(value);
2021 };
2022
2023 if (IS_RECORD) {
2024 iterator = iterable.iterator;
2025 } else if (IS_ITERATOR) {
2026 iterator = iterable;
2027 } else {
2028 iterFn = getIteratorMethod(iterable);
2029 if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
2030 // optimisation for array iterators
2031 if (isArrayIteratorMethod(iterFn)) {
2032 for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
2033 result = callFn(iterable[index]);
2034 if (result && isPrototypeOf(ResultPrototype, result)) return result;
2035 } return new Result(false);
2036 }
2037 iterator = getIterator(iterable, iterFn);
2038 }
2039
2040 next = IS_RECORD ? iterable.next : iterator.next;
2041 while (!(step = call(next, iterator)).done) {
2042 try {
2043 result = callFn(step.value);
2044 } catch (error) {
2045 iteratorClose(iterator, 'throw', error);
2046 }
2047 if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
2048 } return new Result(false);
2049};
2050
2051
2052/***/ }),
2053/* 84 */
2054/***/ (function(module, exports, __webpack_require__) {
2055
2056"use strict";
2057
2058var uncurryThis = __webpack_require__(49);
2059var aCallable = __webpack_require__(39);
2060var NATIVE_BIND = __webpack_require__(7);
2061
2062var bind = uncurryThis(uncurryThis.bind);
2063
2064// optional / simple context binding
2065module.exports = function (fn, that) {
2066 aCallable(fn);
2067 return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
2068 return fn.apply(that, arguments);
2069 };
2070};
2071
2072
2073/***/ }),
2074/* 85 */
2075/***/ (function(module, exports, __webpack_require__) {
2076
2077"use strict";
2078
2079var wellKnownSymbol = __webpack_require__(42);
2080var Iterators = __webpack_require__(86);
2081
2082var ITERATOR = wellKnownSymbol('iterator');
2083var ArrayPrototype = Array.prototype;
2084
2085// check on default Array iterator
2086module.exports = function (it) {
2087 return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
2088};
2089
2090
2091/***/ }),
2092/* 86 */
2093/***/ (function(module, exports, __webpack_require__) {
2094
2095"use strict";
2096
2097module.exports = {};
2098
2099
2100/***/ }),
2101/* 87 */
2102/***/ (function(module, exports, __webpack_require__) {
2103
2104"use strict";
2105
2106var call = __webpack_require__(30);
2107var aCallable = __webpack_require__(39);
2108var anObject = __webpack_require__(27);
2109var tryToString = __webpack_require__(40);
2110var getIteratorMethod = __webpack_require__(88);
2111
2112var $TypeError = TypeError;
2113
2114module.exports = function (argument, usingIterator) {
2115 var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
2116 if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
2117 throw new $TypeError(tryToString(argument) + ' is not iterable');
2118};
2119
2120
2121/***/ }),
2122/* 88 */
2123/***/ (function(module, exports, __webpack_require__) {
2124
2125"use strict";
2126
2127var classof = __webpack_require__(89);
2128var getMethod = __webpack_require__(38);
2129var isNullOrUndefined = __webpack_require__(12);
2130var Iterators = __webpack_require__(86);
2131var wellKnownSymbol = __webpack_require__(42);
2132
2133var ITERATOR = wellKnownSymbol('iterator');
2134
2135module.exports = function (it) {
2136 if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
2137 || getMethod(it, '@@iterator')
2138 || Iterators[classof(it)];
2139};
2140
2141
2142/***/ }),
2143/* 89 */
2144/***/ (function(module, exports, __webpack_require__) {
2145
2146"use strict";
2147
2148var TO_STRING_TAG_SUPPORT = __webpack_require__(90);
2149var isCallable = __webpack_require__(8);
2150var classofRaw = __webpack_require__(50);
2151var wellKnownSymbol = __webpack_require__(42);
2152
2153var TO_STRING_TAG = wellKnownSymbol('toStringTag');
2154var $Object = Object;
2155
2156// ES3 wrong here
2157var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
2158
2159// fallback for IE11 Script Access Denied error
2160var tryGet = function (it, key) {
2161 try {
2162 return it[key];
2163 } catch (error) { /* empty */ }
2164};
2165
2166// getting tag from ES6+ `Object.prototype.toString`
2167module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
2168 var O, tag, result;
2169 return it === undefined ? 'Undefined' : it === null ? 'Null'
2170 // @@toStringTag case
2171 : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
2172 // builtinTag case
2173 : CORRECT_ARGUMENTS ? classofRaw(O)
2174 // ES3 arguments fallback
2175 : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
2176};
2177
2178
2179/***/ }),
2180/* 90 */
2181/***/ (function(module, exports, __webpack_require__) {
2182
2183"use strict";
2184
2185var wellKnownSymbol = __webpack_require__(42);
2186
2187var TO_STRING_TAG = wellKnownSymbol('toStringTag');
2188var test = {};
2189
2190test[TO_STRING_TAG] = 'z';
2191
2192module.exports = String(test) === '[object z]';
2193
2194
2195/***/ }),
2196/* 91 */
2197/***/ (function(module, exports, __webpack_require__) {
2198
2199"use strict";
2200
2201var call = __webpack_require__(30);
2202var anObject = __webpack_require__(27);
2203var getMethod = __webpack_require__(38);
2204
2205module.exports = function (iterator, kind, value) {
2206 var innerResult, innerError;
2207 anObject(iterator);
2208 try {
2209 innerResult = getMethod(iterator, 'return');
2210 if (!innerResult) {
2211 if (kind === 'throw') throw value;
2212 return value;
2213 }
2214 innerResult = call(innerResult, iterator);
2215 } catch (error) {
2216 innerError = true;
2217 innerResult = error;
2218 }
2219 if (kind === 'throw') throw value;
2220 if (innerError) throw innerResult;
2221 anObject(innerResult);
2222 return value;
2223};
2224
2225
2226/***/ }),
2227/* 92 */
2228/***/ (function(module, exports, __webpack_require__) {
2229
2230"use strict";
2231
2232var uncurryThis = __webpack_require__(6);
2233
2234// eslint-disable-next-line es/no-map -- safe
2235var MapPrototype = Map.prototype;
2236
2237module.exports = {
2238 // eslint-disable-next-line es/no-map -- safe
2239 Map: Map,
2240 set: uncurryThis(MapPrototype.set),
2241 get: uncurryThis(MapPrototype.get),
2242 has: uncurryThis(MapPrototype.has),
2243 remove: uncurryThis(MapPrototype['delete']),
2244 proto: MapPrototype
2245};
2246
2247
2248/***/ }),
2249/* 93 */
2250/***/ (function(module, exports, __webpack_require__) {
2251
2252"use strict";
2253
2254var $ = __webpack_require__(54);
2255var getBuiltIn = __webpack_require__(32);
2256var uncurryThis = __webpack_require__(6);
2257var aCallable = __webpack_require__(39);
2258var requireObjectCoercible = __webpack_require__(11);
2259var toPropertyKey = __webpack_require__(28);
2260var iterate = __webpack_require__(83);
2261var fails = __webpack_require__(3);
2262
2263// eslint-disable-next-line es/no-object-groupby -- testing
2264var nativeGroupBy = Object.groupBy;
2265var create = getBuiltIn('Object', 'create');
2266var push = uncurryThis([].push);
2267
2268var DOES_NOT_WORK_WITH_PRIMITIVES = !nativeGroupBy || fails(function () {
2269 return nativeGroupBy('ab', function (it) {
2270 return it;
2271 }).a.length !== 1;
2272});
2273
2274// `Object.groupBy` method
2275// https://tc39.es/ecma262/#sec-object.groupby
2276$({ target: 'Object', stat: true, forced: DOES_NOT_WORK_WITH_PRIMITIVES }, {
2277 groupBy: function groupBy(items, callbackfn) {
2278 requireObjectCoercible(items);
2279 aCallable(callbackfn);
2280 var obj = create(null);
2281 var k = 0;
2282 iterate(items, function (value) {
2283 var key = toPropertyKey(callbackfn(value, k++));
2284 // in some IE versions, `hasOwnProperty` returns incorrect result on integer keys
2285 // but since it's a `null` prototype object, we can safely use `in`
2286 if (key in obj) push(obj[key], value);
2287 else obj[key] = [value];
2288 });
2289 return obj;
2290 }
2291});
2292
2293
2294/***/ }),
2295/* 94 */
2296/***/ (function(module, exports, __webpack_require__) {
2297
2298"use strict";
2299
2300var $ = __webpack_require__(54);
2301var globalThis = __webpack_require__(17);
2302var apply = __webpack_require__(95);
2303var slice = __webpack_require__(96);
2304var newPromiseCapabilityModule = __webpack_require__(97);
2305var aCallable = __webpack_require__(39);
2306var perform = __webpack_require__(98);
2307
2308var Promise = globalThis.Promise;
2309
2310var ACCEPT_ARGUMENTS = false;
2311// Avoiding the use of polyfills of the previous iteration of this proposal
2312// that does not accept arguments of the callback
2313var FORCED = !Promise || !Promise['try'] || perform(function () {
2314 Promise['try'](function (argument) {
2315 ACCEPT_ARGUMENTS = argument === 8;
2316 }, 8);
2317}).error || !ACCEPT_ARGUMENTS;
2318
2319// `Promise.try` method
2320// https://tc39.es/ecma262/#sec-promise.try
2321$({ target: 'Promise', stat: true, forced: FORCED }, {
2322 'try': function (callbackfn /* , ...args */) {
2323 var args = arguments.length > 1 ? slice(arguments, 1) : [];
2324 var promiseCapability = newPromiseCapabilityModule.f(this);
2325 var result = perform(function () {
2326 return apply(aCallable(callbackfn), undefined, args);
2327 });
2328 (result.error ? promiseCapability.reject : promiseCapability.resolve)(result.value);
2329 return promiseCapability.promise;
2330 }
2331});
2332
2333
2334/***/ }),
2335/* 95 */
2336/***/ (function(module, exports, __webpack_require__) {
2337
2338"use strict";
2339
2340var NATIVE_BIND = __webpack_require__(7);
2341
2342var FunctionPrototype = Function.prototype;
2343var apply = FunctionPrototype.apply;
2344var call = FunctionPrototype.call;
2345
2346// eslint-disable-next-line es/no-reflect -- safe
2347module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
2348 return call.apply(apply, arguments);
2349});
2350
2351
2352/***/ }),
2353/* 96 */
2354/***/ (function(module, exports, __webpack_require__) {
2355
2356"use strict";
2357
2358var uncurryThis = __webpack_require__(6);
2359
2360module.exports = uncurryThis([].slice);
2361
2362
2363/***/ }),
2364/* 97 */
2365/***/ (function(module, exports, __webpack_require__) {
2366
2367"use strict";
2368
2369var aCallable = __webpack_require__(39);
2370
2371var $TypeError = TypeError;
2372
2373var PromiseCapability = function (C) {
2374 var resolve, reject;
2375 this.promise = new C(function ($$resolve, $$reject) {
2376 if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
2377 resolve = $$resolve;
2378 reject = $$reject;
2379 });
2380 this.resolve = aCallable(resolve);
2381 this.reject = aCallable(reject);
2382};
2383
2384// `NewPromiseCapability` abstract operation
2385// https://tc39.es/ecma262/#sec-newpromisecapability
2386module.exports.f = function (C) {
2387 return new PromiseCapability(C);
2388};
2389
2390
2391/***/ }),
2392/* 98 */
2393/***/ (function(module, exports, __webpack_require__) {
2394
2395"use strict";
2396
2397module.exports = function (exec) {
2398 try {
2399 return { error: false, value: exec() };
2400 } catch (error) {
2401 return { error: true, value: error };
2402 }
2403};
2404
2405
2406/***/ }),
2407/* 99 */
2408/***/ (function(module, exports, __webpack_require__) {
2409
2410"use strict";
2411
2412var $ = __webpack_require__(54);
2413var newPromiseCapabilityModule = __webpack_require__(97);
2414
2415// `Promise.withResolvers` method
2416// https://tc39.es/ecma262/#sec-promise.withResolvers
2417$({ target: 'Promise', stat: true }, {
2418 withResolvers: function withResolvers() {
2419 var promiseCapability = newPromiseCapabilityModule.f(this);
2420 return {
2421 promise: promiseCapability.promise,
2422 resolve: promiseCapability.resolve,
2423 reject: promiseCapability.reject
2424 };
2425 }
2426});
2427
2428
2429/***/ }),
2430/* 100 */
2431/***/ (function(module, exports, __webpack_require__) {
2432
2433"use strict";
2434
2435var $ = __webpack_require__(54);
2436var globalThis = __webpack_require__(17);
2437var getBuiltIn = __webpack_require__(32);
2438var createPropertyDescriptor = __webpack_require__(45);
2439var defineProperty = __webpack_require__(23).f;
2440var hasOwn = __webpack_require__(9);
2441var anInstance = __webpack_require__(101);
2442var inheritIfRequired = __webpack_require__(102);
2443var normalizeStringArgument = __webpack_require__(106);
2444var DOMExceptionConstants = __webpack_require__(108);
2445var clearErrorStack = __webpack_require__(109);
2446var DESCRIPTORS = __webpack_require__(2);
2447var IS_PURE = __webpack_require__(16);
2448
2449var DOM_EXCEPTION = 'DOMException';
2450var Error = getBuiltIn('Error');
2451var NativeDOMException = getBuiltIn(DOM_EXCEPTION);
2452
2453var $DOMException = function DOMException() {
2454 anInstance(this, DOMExceptionPrototype);
2455 var argumentsLength = arguments.length;
2456 var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);
2457 var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');
2458 var that = new NativeDOMException(message, name);
2459 var error = new Error(message);
2460 error.name = DOM_EXCEPTION;
2461 defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));
2462 inheritIfRequired(that, this, $DOMException);
2463 return that;
2464};
2465
2466var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;
2467
2468var ERROR_HAS_STACK = 'stack' in new Error(DOM_EXCEPTION);
2469var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2);
2470
2471// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2472var descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis, DOM_EXCEPTION);
2473
2474// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it
2475// https://github.com/Jarred-Sumner/bun/issues/399
2476var BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable);
2477
2478var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK;
2479
2480// `DOMException` constructor patch for `.stack` where it's required
2481// https://webidl.spec.whatwg.org/#es-DOMException-specialness
2482$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic
2483 DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException
2484});
2485
2486var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);
2487var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
2488
2489if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {
2490 if (!IS_PURE) {
2491 defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException));
2492 }
2493
2494 for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {
2495 var constant = DOMExceptionConstants[key];
2496 var constantName = constant.s;
2497 if (!hasOwn(PolyfilledDOMException, constantName)) {
2498 defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c));
2499 }
2500 }
2501}
2502
2503
2504/***/ }),
2505/* 101 */
2506/***/ (function(module, exports, __webpack_require__) {
2507
2508"use strict";
2509
2510var isPrototypeOf = __webpack_require__(33);
2511
2512var $TypeError = TypeError;
2513
2514module.exports = function (it, Prototype) {
2515 if (isPrototypeOf(Prototype, it)) return it;
2516 throw new $TypeError('Incorrect invocation');
2517};
2518
2519
2520/***/ }),
2521/* 102 */
2522/***/ (function(module, exports, __webpack_require__) {
2523
2524"use strict";
2525
2526var isCallable = __webpack_require__(8);
2527var isObject = __webpack_require__(21);
2528var setPrototypeOf = __webpack_require__(103);
2529
2530// makes subclassing work correct for wrapped built-ins
2531module.exports = function ($this, dummy, Wrapper) {
2532 var NewTarget, NewTargetPrototype;
2533 if (
2534 // it can work only with native `setPrototypeOf`
2535 setPrototypeOf &&
2536 // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
2537 isCallable(NewTarget = dummy.constructor) &&
2538 NewTarget !== Wrapper &&
2539 isObject(NewTargetPrototype = NewTarget.prototype) &&
2540 NewTargetPrototype !== Wrapper.prototype
2541 ) setPrototypeOf($this, NewTargetPrototype);
2542 return $this;
2543};
2544
2545
2546/***/ }),
2547/* 103 */
2548/***/ (function(module, exports, __webpack_require__) {
2549
2550"use strict";
2551
2552/* eslint-disable no-proto -- safe */
2553var uncurryThisAccessor = __webpack_require__(52);
2554var isObject = __webpack_require__(21);
2555var requireObjectCoercible = __webpack_require__(11);
2556var aPossiblePrototype = __webpack_require__(104);
2557
2558// `Object.setPrototypeOf` method
2559// https://tc39.es/ecma262/#sec-object.setprototypeof
2560// Works with __proto__ only. Old v8 can't work with null proto objects.
2561// eslint-disable-next-line es/no-object-setprototypeof -- safe
2562module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
2563 var CORRECT_SETTER = false;
2564 var test = {};
2565 var setter;
2566 try {
2567 setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
2568 setter(test, []);
2569 CORRECT_SETTER = test instanceof Array;
2570 } catch (error) { /* empty */ }
2571 return function setPrototypeOf(O, proto) {
2572 requireObjectCoercible(O);
2573 aPossiblePrototype(proto);
2574 if (!isObject(O)) return O;
2575 if (CORRECT_SETTER) setter(O, proto);
2576 else O.__proto__ = proto;
2577 return O;
2578 };
2579}() : undefined);
2580
2581
2582/***/ }),
2583/* 104 */
2584/***/ (function(module, exports, __webpack_require__) {
2585
2586"use strict";
2587
2588var isPossiblePrototype = __webpack_require__(105);
2589
2590var $String = String;
2591var $TypeError = TypeError;
2592
2593module.exports = function (argument) {
2594 if (isPossiblePrototype(argument)) return argument;
2595 throw new $TypeError("Can't set " + $String(argument) + ' as a prototype');
2596};
2597
2598
2599/***/ }),
2600/* 105 */
2601/***/ (function(module, exports, __webpack_require__) {
2602
2603"use strict";
2604
2605var isObject = __webpack_require__(21);
2606
2607module.exports = function (argument) {
2608 return isObject(argument) || argument === null;
2609};
2610
2611
2612/***/ }),
2613/* 106 */
2614/***/ (function(module, exports, __webpack_require__) {
2615
2616"use strict";
2617
2618var toString = __webpack_require__(107);
2619
2620module.exports = function (argument, $default) {
2621 return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
2622};
2623
2624
2625/***/ }),
2626/* 107 */
2627/***/ (function(module, exports, __webpack_require__) {
2628
2629"use strict";
2630
2631var classof = __webpack_require__(89);
2632
2633var $String = String;
2634
2635module.exports = function (argument) {
2636 if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
2637 return $String(argument);
2638};
2639
2640
2641/***/ }),
2642/* 108 */
2643/***/ (function(module, exports, __webpack_require__) {
2644
2645"use strict";
2646
2647module.exports = {
2648 IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
2649 DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
2650 HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
2651 WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },
2652 InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },
2653 NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },
2654 NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },
2655 NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },
2656 NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },
2657 InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },
2658 InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },
2659 SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },
2660 InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },
2661 NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },
2662 InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },
2663 ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },
2664 TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },
2665 SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },
2666 NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },
2667 AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },
2668 URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },
2669 QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },
2670 TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },
2671 InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },
2672 DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 }
2673};
2674
2675
2676/***/ }),
2677/* 109 */
2678/***/ (function(module, exports, __webpack_require__) {
2679
2680"use strict";
2681
2682var uncurryThis = __webpack_require__(6);
2683
2684var $Error = Error;
2685var replace = uncurryThis(''.replace);
2686
2687var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
2688// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe
2689var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
2690var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
2691
2692module.exports = function (stack, dropEntries) {
2693 if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
2694 while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
2695 } return stack;
2696};
2697
2698
2699/***/ }),
2700/* 110 */
2701/***/ (function(module, exports, __webpack_require__) {
2702
2703"use strict";
2704
2705var IS_PURE = __webpack_require__(16);
2706var $ = __webpack_require__(54);
2707var globalThis = __webpack_require__(17);
2708var getBuiltIn = __webpack_require__(32);
2709var uncurryThis = __webpack_require__(6);
2710var fails = __webpack_require__(3);
2711var uid = __webpack_require__(44);
2712var isCallable = __webpack_require__(8);
2713var isConstructor = __webpack_require__(111);
2714var isNullOrUndefined = __webpack_require__(12);
2715var isObject = __webpack_require__(21);
2716var isSymbol = __webpack_require__(31);
2717var iterate = __webpack_require__(83);
2718var anObject = __webpack_require__(27);
2719var classof = __webpack_require__(89);
2720var hasOwn = __webpack_require__(9);
2721var createProperty = __webpack_require__(112);
2722var createNonEnumerableProperty = __webpack_require__(22);
2723var lengthOfArrayLike = __webpack_require__(68);
2724var validateArgumentsLength = __webpack_require__(113);
2725var getRegExpFlags = __webpack_require__(114);
2726var MapHelpers = __webpack_require__(92);
2727var SetHelpers = __webpack_require__(116);
2728var setIterate = __webpack_require__(117);
2729var detachTransferable = __webpack_require__(76);
2730var ERROR_STACK_INSTALLABLE = __webpack_require__(119);
2731var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(80);
2732
2733var Object = globalThis.Object;
2734var Array = globalThis.Array;
2735var Date = globalThis.Date;
2736var Error = globalThis.Error;
2737var TypeError = globalThis.TypeError;
2738var PerformanceMark = globalThis.PerformanceMark;
2739var DOMException = getBuiltIn('DOMException');
2740var Map = MapHelpers.Map;
2741var mapHas = MapHelpers.has;
2742var mapGet = MapHelpers.get;
2743var mapSet = MapHelpers.set;
2744var Set = SetHelpers.Set;
2745var setAdd = SetHelpers.add;
2746var setHas = SetHelpers.has;
2747var objectKeys = getBuiltIn('Object', 'keys');
2748var push = uncurryThis([].push);
2749var thisBooleanValue = uncurryThis(true.valueOf);
2750var thisNumberValue = uncurryThis(1.0.valueOf);
2751var thisStringValue = uncurryThis(''.valueOf);
2752var thisTimeValue = uncurryThis(Date.prototype.getTime);
2753var PERFORMANCE_MARK = uid('structuredClone');
2754var DATA_CLONE_ERROR = 'DataCloneError';
2755var TRANSFERRING = 'Transferring';
2756
2757var checkBasicSemantic = function (structuredCloneImplementation) {
2758 return !fails(function () {
2759 var set1 = new globalThis.Set([7]);
2760 var set2 = structuredCloneImplementation(set1);
2761 var number = structuredCloneImplementation(Object(7));
2762 return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7;
2763 }) && structuredCloneImplementation;
2764};
2765
2766var checkErrorsCloning = function (structuredCloneImplementation, $Error) {
2767 return !fails(function () {
2768 var error = new $Error();
2769 var test = structuredCloneImplementation({ a: error, b: error });
2770 return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack);
2771 });
2772};
2773
2774// https://github.com/whatwg/html/pull/5749
2775var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) {
2776 return !fails(function () {
2777 var test = structuredCloneImplementation(new globalThis.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
2778 return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3;
2779 });
2780};
2781
2782// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+
2783// FF<103 and Safari implementations can't clone errors
2784// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604
2785// FF103 can clone errors, but `.stack` of clone is an empty string
2786// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762
2787// FF104+ fixed it on usual errors, but not on DOMExceptions
2788// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321
2789// Chrome <102 returns `null` if cloned object contains multiple references to one error
2790// https://bugs.chromium.org/p/v8/issues/detail?id=12542
2791// NodeJS implementation can't clone DOMExceptions
2792// https://github.com/nodejs/node/issues/41038
2793// only FF103+ supports new (html/5749) error cloning semantic
2794var nativeStructuredClone = globalThis.structuredClone;
2795
2796var FORCED_REPLACEMENT = IS_PURE
2797 || !checkErrorsCloning(nativeStructuredClone, Error)
2798 || !checkErrorsCloning(nativeStructuredClone, DOMException)
2799 || !checkNewErrorsCloningSemantic(nativeStructuredClone);
2800
2801// Chrome 82+, Safari 14.1+, Deno 1.11+
2802// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException`
2803// Chrome returns `null` if cloned object contains multiple references to one error
2804// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround
2805// Safari implementation can't clone errors
2806// Deno 1.2-1.10 implementations too naive
2807// NodeJS 16.0+ does not have `PerformanceMark` constructor
2808// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive
2809// and can't clone, for example, `RegExp` or some boxed primitives
2810// https://github.com/nodejs/node/issues/40840
2811// no one of those implementations supports new (html/5749) error cloning semantic
2812var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) {
2813 return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
2814});
2815
2816var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
2817
2818var throwUncloneable = function (type) {
2819 throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR);
2820};
2821
2822var throwUnpolyfillable = function (type, action) {
2823 throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR);
2824};
2825
2826var tryNativeRestrictedStructuredClone = function (value, type) {
2827 if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type);
2828 return nativeRestrictedStructuredClone(value);
2829};
2830
2831var createDataTransfer = function () {
2832 var dataTransfer;
2833 try {
2834 dataTransfer = new globalThis.DataTransfer();
2835 } catch (error) {
2836 try {
2837 dataTransfer = new globalThis.ClipboardEvent('').clipboardData;
2838 } catch (error2) { /* empty */ }
2839 }
2840 return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null;
2841};
2842
2843var cloneBuffer = function (value, map, $type) {
2844 if (mapHas(map, value)) return mapGet(map, value);
2845
2846 var type = $type || classof(value);
2847 var clone, length, options, source, target, i;
2848
2849 if (type === 'SharedArrayBuffer') {
2850 if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value);
2851 // SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original
2852 else clone = value;
2853 } else {
2854 var DataView = globalThis.DataView;
2855
2856 // `ArrayBuffer#slice` is not available in IE10
2857 // `ArrayBuffer#slice` and `DataView` are not available in old FF
2858 if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer');
2859 // detached buffers throws in `DataView` and `.slice`
2860 try {
2861 if (isCallable(value.slice) && !value.resizable) {
2862 clone = value.slice(0);
2863 } else {
2864 length = value.byteLength;
2865 options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined;
2866 // eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
2867 clone = new ArrayBuffer(length, options);
2868 source = new DataView(value);
2869 target = new DataView(clone);
2870 for (i = 0; i < length; i++) {
2871 target.setUint8(i, source.getUint8(i));
2872 }
2873 }
2874 } catch (error) {
2875 throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR);
2876 }
2877 }
2878
2879 mapSet(map, value, clone);
2880
2881 return clone;
2882};
2883
2884var cloneView = function (value, type, offset, length, map) {
2885 var C = globalThis[type];
2886 // in some old engines like Safari 9, typeof C is 'object'
2887 // on Uint8ClampedArray or some other constructors
2888 if (!isObject(C)) throwUnpolyfillable(type);
2889 return new C(cloneBuffer(value.buffer, map), offset, length);
2890};
2891
2892var structuredCloneInternal = function (value, map) {
2893 if (isSymbol(value)) throwUncloneable('Symbol');
2894 if (!isObject(value)) return value;
2895 // effectively preserves circular references
2896 if (map) {
2897 if (mapHas(map, value)) return mapGet(map, value);
2898 } else map = new Map();
2899
2900 var type = classof(value);
2901 var C, name, cloned, dataTransfer, i, length, keys, key;
2902
2903 switch (type) {
2904 case 'Array':
2905 cloned = Array(lengthOfArrayLike(value));
2906 break;
2907 case 'Object':
2908 cloned = {};
2909 break;
2910 case 'Map':
2911 cloned = new Map();
2912 break;
2913 case 'Set':
2914 cloned = new Set();
2915 break;
2916 case 'RegExp':
2917 // in this block because of a Safari 14.1 bug
2918 // old FF does not clone regexes passed to the constructor, so get the source and flags directly
2919 cloned = new RegExp(value.source, getRegExpFlags(value));
2920 break;
2921 case 'Error':
2922 name = value.name;
2923 switch (name) {
2924 case 'AggregateError':
2925 cloned = new (getBuiltIn(name))([]);
2926 break;
2927 case 'EvalError':
2928 case 'RangeError':
2929 case 'ReferenceError':
2930 case 'SuppressedError':
2931 case 'SyntaxError':
2932 case 'TypeError':
2933 case 'URIError':
2934 cloned = new (getBuiltIn(name))();
2935 break;
2936 case 'CompileError':
2937 case 'LinkError':
2938 case 'RuntimeError':
2939 cloned = new (getBuiltIn('WebAssembly', name))();
2940 break;
2941 default:
2942 cloned = new Error();
2943 }
2944 break;
2945 case 'DOMException':
2946 cloned = new DOMException(value.message, value.name);
2947 break;
2948 case 'ArrayBuffer':
2949 case 'SharedArrayBuffer':
2950 cloned = cloneBuffer(value, map, type);
2951 break;
2952 case 'DataView':
2953 case 'Int8Array':
2954 case 'Uint8Array':
2955 case 'Uint8ClampedArray':
2956 case 'Int16Array':
2957 case 'Uint16Array':
2958 case 'Int32Array':
2959 case 'Uint32Array':
2960 case 'Float16Array':
2961 case 'Float32Array':
2962 case 'Float64Array':
2963 case 'BigInt64Array':
2964 case 'BigUint64Array':
2965 length = type === 'DataView' ? value.byteLength : value.length;
2966 cloned = cloneView(value, type, value.byteOffset, length, map);
2967 break;
2968 case 'DOMQuad':
2969 try {
2970 cloned = new DOMQuad(
2971 structuredCloneInternal(value.p1, map),
2972 structuredCloneInternal(value.p2, map),
2973 structuredCloneInternal(value.p3, map),
2974 structuredCloneInternal(value.p4, map)
2975 );
2976 } catch (error) {
2977 cloned = tryNativeRestrictedStructuredClone(value, type);
2978 }
2979 break;
2980 case 'File':
2981 if (nativeRestrictedStructuredClone) try {
2982 cloned = nativeRestrictedStructuredClone(value);
2983 // NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612
2984 if (classof(cloned) !== type) cloned = undefined;
2985 } catch (error) { /* empty */ }
2986 if (!cloned) try {
2987 cloned = new File([value], value.name, value);
2988 } catch (error) { /* empty */ }
2989 if (!cloned) throwUnpolyfillable(type);
2990 break;
2991 case 'FileList':
2992 dataTransfer = createDataTransfer();
2993 if (dataTransfer) {
2994 for (i = 0, length = lengthOfArrayLike(value); i < length; i++) {
2995 dataTransfer.items.add(structuredCloneInternal(value[i], map));
2996 }
2997 cloned = dataTransfer.files;
2998 } else cloned = tryNativeRestrictedStructuredClone(value, type);
2999 break;
3000 case 'ImageData':
3001 // Safari 9 ImageData is a constructor, but typeof ImageData is 'object'
3002 try {
3003 cloned = new ImageData(
3004 structuredCloneInternal(value.data, map),
3005 value.width,
3006 value.height,
3007 { colorSpace: value.colorSpace }
3008 );
3009 } catch (error) {
3010 cloned = tryNativeRestrictedStructuredClone(value, type);
3011 } break;
3012 default:
3013 if (nativeRestrictedStructuredClone) {
3014 cloned = nativeRestrictedStructuredClone(value);
3015 } else switch (type) {
3016 case 'BigInt':
3017 // can be a 3rd party polyfill
3018 cloned = Object(value.valueOf());
3019 break;
3020 case 'Boolean':
3021 cloned = Object(thisBooleanValue(value));
3022 break;
3023 case 'Number':
3024 cloned = Object(thisNumberValue(value));
3025 break;
3026 case 'String':
3027 cloned = Object(thisStringValue(value));
3028 break;
3029 case 'Date':
3030 cloned = new Date(thisTimeValue(value));
3031 break;
3032 case 'Blob':
3033 try {
3034 cloned = value.slice(0, value.size, value.type);
3035 } catch (error) {
3036 throwUnpolyfillable(type);
3037 } break;
3038 case 'DOMPoint':
3039 case 'DOMPointReadOnly':
3040 C = globalThis[type];
3041 try {
3042 cloned = C.fromPoint
3043 ? C.fromPoint(value)
3044 : new C(value.x, value.y, value.z, value.w);
3045 } catch (error) {
3046 throwUnpolyfillable(type);
3047 } break;
3048 case 'DOMRect':
3049 case 'DOMRectReadOnly':
3050 C = globalThis[type];
3051 try {
3052 cloned = C.fromRect
3053 ? C.fromRect(value)
3054 : new C(value.x, value.y, value.width, value.height);
3055 } catch (error) {
3056 throwUnpolyfillable(type);
3057 } break;
3058 case 'DOMMatrix':
3059 case 'DOMMatrixReadOnly':
3060 C = globalThis[type];
3061 try {
3062 cloned = C.fromMatrix
3063 ? C.fromMatrix(value)
3064 : new C(value);
3065 } catch (error) {
3066 throwUnpolyfillable(type);
3067 } break;
3068 case 'AudioData':
3069 case 'VideoFrame':
3070 if (!isCallable(value.clone)) throwUnpolyfillable(type);
3071 try {
3072 cloned = value.clone();
3073 } catch (error) {
3074 throwUncloneable(type);
3075 } break;
3076 case 'CropTarget':
3077 case 'CryptoKey':
3078 case 'FileSystemDirectoryHandle':
3079 case 'FileSystemFileHandle':
3080 case 'FileSystemHandle':
3081 case 'GPUCompilationInfo':
3082 case 'GPUCompilationMessage':
3083 case 'ImageBitmap':
3084 case 'RTCCertificate':
3085 case 'WebAssembly.Module':
3086 throwUnpolyfillable(type);
3087 // break omitted
3088 default:
3089 throwUncloneable(type);
3090 }
3091 }
3092
3093 mapSet(map, value, cloned);
3094
3095 switch (type) {
3096 case 'Array':
3097 case 'Object':
3098 keys = objectKeys(value);
3099 for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) {
3100 key = keys[i];
3101 createProperty(cloned, key, structuredCloneInternal(value[key], map));
3102 } break;
3103 case 'Map':
3104 value.forEach(function (v, k) {
3105 mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
3106 });
3107 break;
3108 case 'Set':
3109 value.forEach(function (v) {
3110 setAdd(cloned, structuredCloneInternal(v, map));
3111 });
3112 break;
3113 case 'Error':
3114 createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map));
3115 if (hasOwn(value, 'cause')) {
3116 createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map));
3117 }
3118 if (name === 'AggregateError') {
3119 cloned.errors = structuredCloneInternal(value.errors, map);
3120 } else if (name === 'SuppressedError') {
3121 cloned.error = structuredCloneInternal(value.error, map);
3122 cloned.suppressed = structuredCloneInternal(value.suppressed, map);
3123 } // break omitted
3124 case 'DOMException':
3125 if (ERROR_STACK_INSTALLABLE) {
3126 createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map));
3127 }
3128 }
3129
3130 return cloned;
3131};
3132
3133var tryToTransfer = function (rawTransfer, map) {
3134 if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence');
3135
3136 var transfer = [];
3137
3138 iterate(rawTransfer, function (value) {
3139 push(transfer, anObject(value));
3140 });
3141
3142 var i = 0;
3143 var length = lengthOfArrayLike(transfer);
3144 var buffers = new Set();
3145 var value, type, C, transferred, canvas, context;
3146
3147 while (i < length) {
3148 value = transfer[i++];
3149
3150 type = classof(value);
3151
3152 if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) {
3153 throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR);
3154 }
3155
3156 if (type === 'ArrayBuffer') {
3157 setAdd(buffers, value);
3158 continue;
3159 }
3160
3161 if (PROPER_STRUCTURED_CLONE_TRANSFER) {
3162 transferred = nativeStructuredClone(value, { transfer: [value] });
3163 } else switch (type) {
3164 case 'ImageBitmap':
3165 C = globalThis.OffscreenCanvas;
3166 if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
3167 try {
3168 canvas = new C(value.width, value.height);
3169 context = canvas.getContext('bitmaprenderer');
3170 context.transferFromImageBitmap(value);
3171 transferred = canvas.transferToImageBitmap();
3172 } catch (error) { /* empty */ }
3173 break;
3174 case 'AudioData':
3175 case 'VideoFrame':
3176 if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING);
3177 try {
3178 transferred = value.clone();
3179 value.close();
3180 } catch (error) { /* empty */ }
3181 break;
3182 case 'MediaSourceHandle':
3183 case 'MessagePort':
3184 case 'MIDIAccess':
3185 case 'OffscreenCanvas':
3186 case 'ReadableStream':
3187 case 'RTCDataChannel':
3188 case 'TransformStream':
3189 case 'WebTransportReceiveStream':
3190 case 'WebTransportSendStream':
3191 case 'WritableStream':
3192 throwUnpolyfillable(type, TRANSFERRING);
3193 }
3194
3195 if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR);
3196
3197 mapSet(map, value, transferred);
3198 }
3199
3200 return buffers;
3201};
3202
3203var detachBuffers = function (buffers) {
3204 setIterate(buffers, function (buffer) {
3205 if (PROPER_STRUCTURED_CLONE_TRANSFER) {
3206 nativeRestrictedStructuredClone(buffer, { transfer: [buffer] });
3207 } else if (isCallable(buffer.transfer)) {
3208 buffer.transfer();
3209 } else if (detachTransferable) {
3210 detachTransferable(buffer);
3211 } else {
3212 throwUnpolyfillable('ArrayBuffer', TRANSFERRING);
3213 }
3214 });
3215};
3216
3217// `structuredClone` method
3218// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone
3219$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, {
3220 structuredClone: function structuredClone(value /* , { transfer } */) {
3221 var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined;
3222 var transfer = options ? options.transfer : undefined;
3223 var map, buffers;
3224
3225 if (transfer !== undefined) {
3226 map = new Map();
3227 buffers = tryToTransfer(transfer, map);
3228 }
3229
3230 var clone = structuredCloneInternal(value, map);
3231
3232 // since of an issue with cloning views of transferred buffers, we a forced to detach them later
3233 // https://github.com/zloirock/core-js/issues/1265
3234 if (buffers) detachBuffers(buffers);
3235
3236 return clone;
3237 }
3238});
3239
3240
3241/***/ }),
3242/* 111 */
3243/***/ (function(module, exports, __webpack_require__) {
3244
3245"use strict";
3246
3247var uncurryThis = __webpack_require__(6);
3248var fails = __webpack_require__(3);
3249var isCallable = __webpack_require__(8);
3250var classof = __webpack_require__(89);
3251var getBuiltIn = __webpack_require__(32);
3252var inspectSource = __webpack_require__(14);
3253
3254var noop = function () { /* empty */ };
3255var construct = getBuiltIn('Reflect', 'construct');
3256var constructorRegExp = /^\s*(?:class|function)\b/;
3257var exec = uncurryThis(constructorRegExp.exec);
3258var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
3259
3260var isConstructorModern = function isConstructor(argument) {
3261 if (!isCallable(argument)) return false;
3262 try {
3263 construct(noop, [], argument);
3264 return true;
3265 } catch (error) {
3266 return false;
3267 }
3268};
3269
3270var isConstructorLegacy = function isConstructor(argument) {
3271 if (!isCallable(argument)) return false;
3272 switch (classof(argument)) {
3273 case 'AsyncFunction':
3274 case 'GeneratorFunction':
3275 case 'AsyncGeneratorFunction': return false;
3276 }
3277 try {
3278 // we can't check .prototype since constructors produced by .bind haven't it
3279 // `Function#toString` throws on some built-it function in some legacy engines
3280 // (for example, `DOMQuad` and similar in FF41-)
3281 return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
3282 } catch (error) {
3283 return true;
3284 }
3285};
3286
3287isConstructorLegacy.sham = true;
3288
3289// `IsConstructor` abstract operation
3290// https://tc39.es/ecma262/#sec-isconstructor
3291module.exports = !construct || fails(function () {
3292 var called;
3293 return isConstructorModern(isConstructorModern.call)
3294 || !isConstructorModern(Object)
3295 || !isConstructorModern(function () { called = true; })
3296 || called;
3297}) ? isConstructorLegacy : isConstructorModern;
3298
3299
3300/***/ }),
3301/* 112 */
3302/***/ (function(module, exports, __webpack_require__) {
3303
3304"use strict";
3305
3306var DESCRIPTORS = __webpack_require__(2);
3307var definePropertyModule = __webpack_require__(23);
3308var createPropertyDescriptor = __webpack_require__(45);
3309
3310module.exports = function (object, key, value) {
3311 if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
3312 else object[key] = value;
3313};
3314
3315
3316/***/ }),
3317/* 113 */
3318/***/ (function(module, exports, __webpack_require__) {
3319
3320"use strict";
3321
3322var $TypeError = TypeError;
3323
3324module.exports = function (passed, required) {
3325 if (passed < required) throw new $TypeError('Not enough arguments');
3326 return passed;
3327};
3328
3329
3330/***/ }),
3331/* 114 */
3332/***/ (function(module, exports, __webpack_require__) {
3333
3334"use strict";
3335
3336var call = __webpack_require__(30);
3337var hasOwn = __webpack_require__(9);
3338var isPrototypeOf = __webpack_require__(33);
3339var regExpFlags = __webpack_require__(115);
3340
3341var RegExpPrototype = RegExp.prototype;
3342
3343module.exports = function (R) {
3344 var flags = R.flags;
3345 return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R)
3346 ? call(regExpFlags, R) : flags;
3347};
3348
3349
3350/***/ }),
3351/* 115 */
3352/***/ (function(module, exports, __webpack_require__) {
3353
3354"use strict";
3355
3356var anObject = __webpack_require__(27);
3357
3358// `RegExp.prototype.flags` getter implementation
3359// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
3360module.exports = function () {
3361 var that = anObject(this);
3362 var result = '';
3363 if (that.hasIndices) result += 'd';
3364 if (that.global) result += 'g';
3365 if (that.ignoreCase) result += 'i';
3366 if (that.multiline) result += 'm';
3367 if (that.dotAll) result += 's';
3368 if (that.unicode) result += 'u';
3369 if (that.unicodeSets) result += 'v';
3370 if (that.sticky) result += 'y';
3371 return result;
3372};
3373
3374
3375/***/ }),
3376/* 116 */
3377/***/ (function(module, exports, __webpack_require__) {
3378
3379"use strict";
3380
3381var uncurryThis = __webpack_require__(6);
3382
3383// eslint-disable-next-line es/no-set -- safe
3384var SetPrototype = Set.prototype;
3385
3386module.exports = {
3387 // eslint-disable-next-line es/no-set -- safe
3388 Set: Set,
3389 add: uncurryThis(SetPrototype.add),
3390 has: uncurryThis(SetPrototype.has),
3391 remove: uncurryThis(SetPrototype['delete']),
3392 proto: SetPrototype
3393};
3394
3395
3396/***/ }),
3397/* 117 */
3398/***/ (function(module, exports, __webpack_require__) {
3399
3400"use strict";
3401
3402var uncurryThis = __webpack_require__(6);
3403var iterateSimple = __webpack_require__(118);
3404var SetHelpers = __webpack_require__(116);
3405
3406var Set = SetHelpers.Set;
3407var SetPrototype = SetHelpers.proto;
3408var forEach = uncurryThis(SetPrototype.forEach);
3409var keys = uncurryThis(SetPrototype.keys);
3410var next = keys(new Set()).next;
3411
3412module.exports = function (set, fn, interruptible) {
3413 return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn);
3414};
3415
3416
3417/***/ }),
3418/* 118 */
3419/***/ (function(module, exports, __webpack_require__) {
3420
3421"use strict";
3422
3423var call = __webpack_require__(30);
3424
3425module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
3426 var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
3427 var next = record.next;
3428 var step, result;
3429 while (!(step = call(next, iterator)).done) {
3430 result = fn(step.value);
3431 if (result !== undefined) return result;
3432 }
3433};
3434
3435
3436/***/ }),
3437/* 119 */
3438/***/ (function(module, exports, __webpack_require__) {
3439
3440"use strict";
3441
3442var fails = __webpack_require__(3);
3443var createPropertyDescriptor = __webpack_require__(45);
3444
3445module.exports = !fails(function () {
3446 var error = new Error('a');
3447 if (!('stack' in error)) return true;
3448 // eslint-disable-next-line es/no-object-defineproperty -- safe
3449 Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
3450 return error.stack !== 7;
3451});
3452
3453
3454/***/ }),
3455/* 120 */
3456/***/ (function(module, exports, __webpack_require__) {
3457
3458"use strict";
3459
3460var $ = __webpack_require__(54);
3461var getBuiltIn = __webpack_require__(32);
3462var fails = __webpack_require__(3);
3463var validateArgumentsLength = __webpack_require__(113);
3464var toString = __webpack_require__(107);
3465var USE_NATIVE_URL = __webpack_require__(121);
3466
3467var URL = getBuiltIn('URL');
3468
3469// https://github.com/nodejs/node/issues/47505
3470// https://github.com/denoland/deno/issues/18893
3471var THROWS_WITHOUT_ARGUMENTS = USE_NATIVE_URL && fails(function () {
3472 URL.canParse();
3473});
3474
3475// Bun ~ 1.0.30 bug
3476// https://github.com/oven-sh/bun/issues/9250
3477var WRONG_ARITY = fails(function () {
3478 return URL.canParse.length !== 1;
3479});
3480
3481// `URL.canParse` method
3482// https://url.spec.whatwg.org/#dom-url-canparse
3483$({ target: 'URL', stat: true, forced: !THROWS_WITHOUT_ARGUMENTS || WRONG_ARITY }, {
3484 canParse: function canParse(url) {
3485 var length = validateArgumentsLength(arguments.length, 1);
3486 var urlString = toString(url);
3487 var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]);
3488 try {
3489 return !!new URL(urlString, base);
3490 } catch (error) {
3491 return false;
3492 }
3493 }
3494});
3495
3496
3497/***/ }),
3498/* 121 */
3499/***/ (function(module, exports, __webpack_require__) {
3500
3501"use strict";
3502
3503var fails = __webpack_require__(3);
3504var wellKnownSymbol = __webpack_require__(42);
3505var DESCRIPTORS = __webpack_require__(2);
3506var IS_PURE = __webpack_require__(16);
3507
3508var ITERATOR = wellKnownSymbol('iterator');
3509
3510module.exports = !fails(function () {
3511 // eslint-disable-next-line unicorn/relative-url-style -- required for testing
3512 var url = new URL('b?a=1&b=2&c=3', 'https://a');
3513 var params = url.searchParams;
3514 var params2 = new URLSearchParams('a=1&a=2&b=3');
3515 var result = '';
3516 url.pathname = 'c%20d';
3517 params.forEach(function (value, key) {
3518 params['delete']('b');
3519 result += key + value;
3520 });
3521 params2['delete']('a', 2);
3522 // `undefined` case is a Chromium 117 bug
3523 // https://bugs.chromium.org/p/v8/issues/detail?id=14222
3524 params2['delete']('b', undefined);
3525 return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b')))
3526 || (!params.size && (IS_PURE || !DESCRIPTORS))
3527 || !params.sort
3528 || url.href !== 'https://a/c%20d?a=1&c=3'
3529 || params.get('c') !== '3'
3530 || String(new URLSearchParams('?a=1')) !== 'a=1'
3531 || !params[ITERATOR]
3532 // throws in Edge
3533 || new URL('https://a@b').username !== 'a'
3534 || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
3535 // not punycoded in Edge
3536 || new URL('https://тест').host !== 'xn--e1aybc'
3537 // not escaped in Chrome 62-
3538 || new URL('https://a#б').hash !== '#%D0%B1'
3539 // fails in Chrome 66-
3540 || result !== 'a1c3'
3541 // throws in Safari
3542 || new URL('https://x', undefined).host !== 'x';
3543});
3544
3545
3546/***/ }),
3547/* 122 */
3548/***/ (function(module, exports, __webpack_require__) {
3549
3550"use strict";
3551
3552var $ = __webpack_require__(54);
3553var getBuiltIn = __webpack_require__(32);
3554var validateArgumentsLength = __webpack_require__(113);
3555var toString = __webpack_require__(107);
3556var USE_NATIVE_URL = __webpack_require__(121);
3557
3558var URL = getBuiltIn('URL');
3559
3560// `URL.parse` method
3561// https://url.spec.whatwg.org/#dom-url-canparse
3562$({ target: 'URL', stat: true, forced: !USE_NATIVE_URL }, {
3563 parse: function parse(url) {
3564 var length = validateArgumentsLength(arguments.length, 1);
3565 var urlString = toString(url);
3566 var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]);
3567 try {
3568 return new URL(urlString, base);
3569 } catch (error) {
3570 return null;
3571 }
3572 }
3573});
3574
3575
3576/***/ }),
3577/* 123 */
3578/***/ (function(module, exports, __webpack_require__) {
3579
3580"use strict";
3581
3582var defineBuiltIn = __webpack_require__(59);
3583var uncurryThis = __webpack_require__(6);
3584var toString = __webpack_require__(107);
3585var validateArgumentsLength = __webpack_require__(113);
3586
3587var $URLSearchParams = URLSearchParams;
3588var URLSearchParamsPrototype = $URLSearchParams.prototype;
3589var append = uncurryThis(URLSearchParamsPrototype.append);
3590var $delete = uncurryThis(URLSearchParamsPrototype['delete']);
3591var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
3592var push = uncurryThis([].push);
3593var params = new $URLSearchParams('a=1&a=2&b=3');
3594
3595params['delete']('a', 1);
3596// `undefined` case is a Chromium 117 bug
3597// https://bugs.chromium.org/p/v8/issues/detail?id=14222
3598params['delete']('b', undefined);
3599
3600if (params + '' !== 'a=2') {
3601 defineBuiltIn(URLSearchParamsPrototype, 'delete', function (name /* , value */) {
3602 var length = arguments.length;
3603 var $value = length < 2 ? undefined : arguments[1];
3604 if (length && $value === undefined) return $delete(this, name);
3605 var entries = [];
3606 forEach(this, function (v, k) { // also validates `this`
3607 push(entries, { key: k, value: v });
3608 });
3609 validateArgumentsLength(length, 1);
3610 var key = toString(name);
3611 var value = toString($value);
3612 var index = 0;
3613 var dindex = 0;
3614 var found = false;
3615 var entriesLength = entries.length;
3616 var entry;
3617 while (index < entriesLength) {
3618 entry = entries[index++];
3619 if (found || entry.key === key) {
3620 found = true;
3621 $delete(this, entry.key);
3622 } else dindex++;
3623 }
3624 while (dindex < entriesLength) {
3625 entry = entries[dindex++];
3626 if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
3627 }
3628 }, { enumerable: true, unsafe: true });
3629}
3630
3631
3632/***/ }),
3633/* 124 */
3634/***/ (function(module, exports, __webpack_require__) {
3635
3636"use strict";
3637
3638var defineBuiltIn = __webpack_require__(59);
3639var uncurryThis = __webpack_require__(6);
3640var toString = __webpack_require__(107);
3641var validateArgumentsLength = __webpack_require__(113);
3642
3643var $URLSearchParams = URLSearchParams;
3644var URLSearchParamsPrototype = $URLSearchParams.prototype;
3645var getAll = uncurryThis(URLSearchParamsPrototype.getAll);
3646var $has = uncurryThis(URLSearchParamsPrototype.has);
3647var params = new $URLSearchParams('a=1');
3648
3649// `undefined` case is a Chromium 117 bug
3650// https://bugs.chromium.org/p/v8/issues/detail?id=14222
3651if (params.has('a', 2) || !params.has('a', undefined)) {
3652 defineBuiltIn(URLSearchParamsPrototype, 'has', function has(name /* , value */) {
3653 var length = arguments.length;
3654 var $value = length < 2 ? undefined : arguments[1];
3655 if (length && $value === undefined) return $has(this, name);
3656 var values = getAll(this, name); // also validates `this`
3657 validateArgumentsLength(length, 1);
3658 var value = toString($value);
3659 var index = 0;
3660 while (index < values.length) {
3661 if (values[index++] === value) return true;
3662 } return false;
3663 }, { enumerable: true, unsafe: true });
3664}
3665
3666
3667/***/ }),
3668/* 125 */
3669/***/ (function(module, exports, __webpack_require__) {
3670
3671"use strict";
3672
3673var DESCRIPTORS = __webpack_require__(2);
3674var uncurryThis = __webpack_require__(6);
3675var defineBuiltInAccessor = __webpack_require__(4);
3676
3677var URLSearchParamsPrototype = URLSearchParams.prototype;
3678var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
3679
3680// `URLSearchParams.prototype.size` getter
3681// https://github.com/whatwg/url/pull/734
3682if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) {
3683 defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
3684 get: function size() {
3685 var count = 0;
3686 forEach(this, function () { count++; });
3687 return count;
3688 },
3689 configurable: true,
3690 enumerable: true
3691 });
3692}
3693
3694
3695/***/ })
3696/******/ ]); }();
3697