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