[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/js/dist/vendor/ -> wp-polyfill.js (source)

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


Generated : Wed Dec 25 08:20:01 2024 Cross-referenced by PHPXref