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


Generated : Tue Mar 19 08:20:01 2024 Cross-referenced by PHPXref