[Summary view] [Print] [Text view]

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