https://www.swissfoundations.ch/wp-includes/js/dist/vendor/wp-polyfill.js?ver=3.15.0

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 `[email protected]`, 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

2446);
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__

2642) {
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/*