[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

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

   1  /**
   2   * core-js 3.19.1
   3   * https://github.com/zloirock/core-js
   4   * License: http://rock.mit-license.org
   5   * © 2022 Denis Pushkarev (zloirock.ru)
   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__(67);
  99  __webpack_require__(68);
 100  __webpack_require__(72);
 101  __webpack_require__(79);
 102  module.exports = __webpack_require__(85);
 103  
 104  
 105  /***/ }),
 106  /* 1 */
 107  /***/ (function(module, exports, __webpack_require__) {
 108  
 109  "use strict";
 110  
 111  var $ = __webpack_require__(2);
 112  var toObject = __webpack_require__(36);
 113  var lengthOfArrayLike = __webpack_require__(57);
 114  var toIntegerOrInfinity = __webpack_require__(56);
 115  var addToUnscopables = __webpack_require__(62);
 116  
 117  // `Array.prototype.at` method
 118  // https://github.com/tc39/proposal-relative-indexing-method
 119  $({ target: 'Array', proto: true }, {
 120    at: function at(index) {
 121      var O = toObject(this);
 122      var len = lengthOfArrayLike(O);
 123      var relativeIndex = toIntegerOrInfinity(index);
 124      var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
 125      return (k < 0 || k >= len) ? undefined : O[k];
 126    }
 127  });
 128  
 129  addToUnscopables('at');
 130  
 131  
 132  /***/ }),
 133  /* 2 */
 134  /***/ (function(module, exports, __webpack_require__) {
 135  
 136  var global = __webpack_require__(3);
 137  var getOwnPropertyDescriptor = __webpack_require__(4).f;
 138  var createNonEnumerableProperty = __webpack_require__(40);
 139  var redefine = __webpack_require__(43);
 140  var setGlobal = __webpack_require__(34);
 141  var copyConstructorProperties = __webpack_require__(50);
 142  var isForced = __webpack_require__(61);
 143  
 144  /*
 145    options.target      - name of the target object
 146    options.global      - target is the global object
 147    options.stat        - export as static methods of target
 148    options.proto       - export as prototype methods of target
 149    options.real        - real prototype method for the `pure` version
 150    options.forced      - export even if the native feature is available
 151    options.bind        - bind methods to the target, required for the `pure` version
 152    options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
 153    options.unsafe      - use the simple assignment of property instead of delete + defineProperty
 154    options.sham        - add a flag to not completely full polyfills
 155    options.enumerable  - export as enumerable property
 156    options.noTargetGet - prevent calling a getter on target
 157    options.name        - the .name of the function if it does not match the key
 158  */
 159  module.exports = function (options, source) {
 160    var TARGET = options.target;
 161    var GLOBAL = options.global;
 162    var STATIC = options.stat;
 163    var FORCED, target, key, targetProperty, sourceProperty, descriptor;
 164    if (GLOBAL) {
 165      target = global;
 166    } else if (STATIC) {
 167      target = global[TARGET] || setGlobal(TARGET, {});
 168    } else {
 169      target = (global[TARGET] || {}).prototype;
 170    }
 171    if (target) for (key in source) {
 172      sourceProperty = source[key];
 173      if (options.noTargetGet) {
 174        descriptor = getOwnPropertyDescriptor(target, key);
 175        targetProperty = descriptor && descriptor.value;
 176      } else targetProperty = target[key];
 177      FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
 178      // contained in target
 179      if (!FORCED && targetProperty !== undefined) {
 180        if (typeof sourceProperty == typeof targetProperty) continue;
 181        copyConstructorProperties(sourceProperty, targetProperty);
 182      }
 183      // add a flag to not completely full polyfills
 184      if (options.sham || (targetProperty && targetProperty.sham)) {
 185        createNonEnumerableProperty(sourceProperty, 'sham', true);
 186      }
 187      // extend global
 188      redefine(target, key, sourceProperty, options);
 189    }
 190  };
 191  
 192  
 193  /***/ }),
 194  /* 3 */
 195  /***/ (function(module, exports) {
 196  
 197  var check = function (it) {
 198    return it && it.Math == Math && it;
 199  };
 200  
 201  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
 202  module.exports =
 203    // eslint-disable-next-line es/no-global-this -- safe
 204    check(typeof globalThis == 'object' && globalThis) ||
 205    check(typeof window == 'object' && window) ||
 206    // eslint-disable-next-line no-restricted-globals -- safe
 207    check(typeof self == 'object' && self) ||
 208    check(typeof global == 'object' && global) ||
 209    // eslint-disable-next-line no-new-func -- fallback
 210    (function () { return this; })() || Function('return this')();
 211  
 212  
 213  /***/ }),
 214  /* 4 */
 215  /***/ (function(module, exports, __webpack_require__) {
 216  
 217  var DESCRIPTORS = __webpack_require__(5);
 218  var call = __webpack_require__(7);
 219  var propertyIsEnumerableModule = __webpack_require__(8);
 220  var createPropertyDescriptor = __webpack_require__(9);
 221  var toIndexedObject = __webpack_require__(10);
 222  var toPropertyKey = __webpack_require__(15);
 223  var hasOwn = __webpack_require__(35);
 224  var IE8_DOM_DEFINE = __webpack_require__(38);
 225  
 226  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
 227  var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 228  
 229  // `Object.getOwnPropertyDescriptor` method
 230  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
 231  exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
 232    O = toIndexedObject(O);
 233    P = toPropertyKey(P);
 234    if (IE8_DOM_DEFINE) try {
 235      return $getOwnPropertyDescriptor(O, P);
 236    } catch (error) { /* empty */ }
 237    if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
 238  };
 239  
 240  
 241  /***/ }),
 242  /* 5 */
 243  /***/ (function(module, exports, __webpack_require__) {
 244  
 245  var fails = __webpack_require__(6);
 246  
 247  // Detect IE8's incomplete defineProperty implementation
 248  module.exports = !fails(function () {
 249    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
 250    return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
 251  });
 252  
 253  
 254  /***/ }),
 255  /* 6 */
 256  /***/ (function(module, exports) {
 257  
 258  module.exports = function (exec) {
 259    try {
 260      return !!exec();
 261    } catch (error) {
 262      return true;
 263    }
 264  };
 265  
 266  
 267  /***/ }),
 268  /* 7 */
 269  /***/ (function(module, exports) {
 270  
 271  var call = Function.prototype.call;
 272  
 273  module.exports = call.bind ? call.bind(call) : function () {
 274    return call.apply(call, arguments);
 275  };
 276  
 277  
 278  /***/ }),
 279  /* 8 */
 280  /***/ (function(module, exports, __webpack_require__) {
 281  
 282  "use strict";
 283  
 284  var $propertyIsEnumerable = {}.propertyIsEnumerable;
 285  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
 286  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 287  
 288  // Nashorn ~ JDK8 bug
 289  var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
 290  
 291  // `Object.prototype.propertyIsEnumerable` method implementation
 292  // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
 293  exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
 294    var descriptor = getOwnPropertyDescriptor(this, V);
 295    return !!descriptor && descriptor.enumerable;
 296  } : $propertyIsEnumerable;
 297  
 298  
 299  /***/ }),
 300  /* 9 */
 301  /***/ (function(module, exports) {
 302  
 303  module.exports = function (bitmap, value) {
 304    return {
 305      enumerable: !(bitmap & 1),
 306      configurable: !(bitmap & 2),
 307      writable: !(bitmap & 4),
 308      value: value
 309    };
 310  };
 311  
 312  
 313  /***/ }),
 314  /* 10 */
 315  /***/ (function(module, exports, __webpack_require__) {
 316  
 317  // toObject with fallback for non-array-like ES3 strings
 318  var IndexedObject = __webpack_require__(11);
 319  var requireObjectCoercible = __webpack_require__(14);
 320  
 321  module.exports = function (it) {
 322    return IndexedObject(requireObjectCoercible(it));
 323  };
 324  
 325  
 326  /***/ }),
 327  /* 11 */
 328  /***/ (function(module, exports, __webpack_require__) {
 329  
 330  var global = __webpack_require__(3);
 331  var uncurryThis = __webpack_require__(12);
 332  var fails = __webpack_require__(6);
 333  var classof = __webpack_require__(13);
 334  
 335  var Object = global.Object;
 336  var split = uncurryThis(''.split);
 337  
 338  // fallback for non-array-like ES3 and non-enumerable old V8 strings
 339  module.exports = fails(function () {
 340    // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
 341    // eslint-disable-next-line no-prototype-builtins -- safe
 342    return !Object('z').propertyIsEnumerable(0);
 343  }) ? function (it) {
 344    return classof(it) == 'String' ? split(it, '') : Object(it);
 345  } : Object;
 346  
 347  
 348  /***/ }),
 349  /* 12 */
 350  /***/ (function(module, exports) {
 351  
 352  var FunctionPrototype = Function.prototype;
 353  var bind = FunctionPrototype.bind;
 354  var call = FunctionPrototype.call;
 355  var callBind = bind && bind.bind(call);
 356  
 357  module.exports = bind ? function (fn) {
 358    return fn && callBind(call, fn);
 359  } : function (fn) {
 360    return fn && function () {
 361      return call.apply(fn, arguments);
 362    };
 363  };
 364  
 365  
 366  /***/ }),
 367  /* 13 */
 368  /***/ (function(module, exports, __webpack_require__) {
 369  
 370  var uncurryThis = __webpack_require__(12);
 371  
 372  var toString = uncurryThis({}.toString);
 373  var stringSlice = uncurryThis(''.slice);
 374  
 375  module.exports = function (it) {
 376    return stringSlice(toString(it), 8, -1);
 377  };
 378  
 379  
 380  /***/ }),
 381  /* 14 */
 382  /***/ (function(module, exports, __webpack_require__) {
 383  
 384  var global = __webpack_require__(3);
 385  
 386  var TypeError = global.TypeError;
 387  
 388  // `RequireObjectCoercible` abstract operation
 389  // https://tc39.es/ecma262/#sec-requireobjectcoercible
 390  module.exports = function (it) {
 391    if (it == undefined) throw TypeError("Can't call method on " + it);
 392    return it;
 393  };
 394  
 395  
 396  /***/ }),
 397  /* 15 */
 398  /***/ (function(module, exports, __webpack_require__) {
 399  
 400  var toPrimitive = __webpack_require__(16);
 401  var isSymbol = __webpack_require__(19);
 402  
 403  // `ToPropertyKey` abstract operation
 404  // https://tc39.es/ecma262/#sec-topropertykey
 405  module.exports = function (argument) {
 406    var key = toPrimitive(argument, 'string');
 407    return isSymbol(key) ? key : key + '';
 408  };
 409  
 410  
 411  /***/ }),
 412  /* 16 */
 413  /***/ (function(module, exports, __webpack_require__) {
 414  
 415  var global = __webpack_require__(3);
 416  var call = __webpack_require__(7);
 417  var isObject = __webpack_require__(17);
 418  var isSymbol = __webpack_require__(19);
 419  var getMethod = __webpack_require__(26);
 420  var ordinaryToPrimitive = __webpack_require__(29);
 421  var wellKnownSymbol = __webpack_require__(30);
 422  
 423  var TypeError = global.TypeError;
 424  var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
 425  
 426  // `ToPrimitive` abstract operation
 427  // https://tc39.es/ecma262/#sec-toprimitive
 428  module.exports = function (input, pref) {
 429    if (!isObject(input) || isSymbol(input)) return input;
 430    var exoticToPrim = getMethod(input, TO_PRIMITIVE);
 431    var result;
 432    if (exoticToPrim) {
 433      if (pref === undefined) pref = 'default';
 434      result = call(exoticToPrim, input, pref);
 435      if (!isObject(result) || isSymbol(result)) return result;
 436      throw TypeError("Can't convert object to primitive value");
 437    }
 438    if (pref === undefined) pref = 'number';
 439    return ordinaryToPrimitive(input, pref);
 440  };
 441  
 442  
 443  /***/ }),
 444  /* 17 */
 445  /***/ (function(module, exports, __webpack_require__) {
 446  
 447  var isCallable = __webpack_require__(18);
 448  
 449  module.exports = function (it) {
 450    return typeof it == 'object' ? it !== null : isCallable(it);
 451  };
 452  
 453  
 454  /***/ }),
 455  /* 18 */
 456  /***/ (function(module, exports) {
 457  
 458  // `IsCallable` abstract operation
 459  // https://tc39.es/ecma262/#sec-iscallable
 460  module.exports = function (argument) {
 461    return typeof argument == 'function';
 462  };
 463  
 464  
 465  /***/ }),
 466  /* 19 */
 467  /***/ (function(module, exports, __webpack_require__) {
 468  
 469  var global = __webpack_require__(3);
 470  var getBuiltIn = __webpack_require__(20);
 471  var isCallable = __webpack_require__(18);
 472  var isPrototypeOf = __webpack_require__(21);
 473  var USE_SYMBOL_AS_UID = __webpack_require__(22);
 474  
 475  var Object = global.Object;
 476  
 477  module.exports = USE_SYMBOL_AS_UID ? function (it) {
 478    return typeof it == 'symbol';
 479  } : function (it) {
 480    var $Symbol = getBuiltIn('Symbol');
 481    return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));
 482  };
 483  
 484  
 485  /***/ }),
 486  /* 20 */
 487  /***/ (function(module, exports, __webpack_require__) {
 488  
 489  var global = __webpack_require__(3);
 490  var isCallable = __webpack_require__(18);
 491  
 492  var aFunction = function (argument) {
 493    return isCallable(argument) ? argument : undefined;
 494  };
 495  
 496  module.exports = function (namespace, method) {
 497    return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
 498  };
 499  
 500  
 501  /***/ }),
 502  /* 21 */
 503  /***/ (function(module, exports, __webpack_require__) {
 504  
 505  var uncurryThis = __webpack_require__(12);
 506  
 507  module.exports = uncurryThis({}.isPrototypeOf);
 508  
 509  
 510  /***/ }),
 511  /* 22 */
 512  /***/ (function(module, exports, __webpack_require__) {
 513  
 514  /* eslint-disable es/no-symbol -- required for testing */
 515  var NATIVE_SYMBOL = __webpack_require__(23);
 516  
 517  module.exports = NATIVE_SYMBOL
 518    && !Symbol.sham
 519    && typeof Symbol.iterator == 'symbol';
 520  
 521  
 522  /***/ }),
 523  /* 23 */
 524  /***/ (function(module, exports, __webpack_require__) {
 525  
 526  /* eslint-disable es/no-symbol -- required for testing */
 527  var V8_VERSION = __webpack_require__(24);
 528  var fails = __webpack_require__(6);
 529  
 530  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
 531  module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
 532    var symbol = Symbol();
 533    // Chrome 38 Symbol has incorrect toString conversion
 534    // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
 535    return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
 536      // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
 537      !Symbol.sham && V8_VERSION && V8_VERSION < 41;
 538  });
 539  
 540  
 541  /***/ }),
 542  /* 24 */
 543  /***/ (function(module, exports, __webpack_require__) {
 544  
 545  var global = __webpack_require__(3);
 546  var userAgent = __webpack_require__(25);
 547  
 548  var process = global.process;
 549  var Deno = global.Deno;
 550  var versions = process && process.versions || Deno && Deno.version;
 551  var v8 = versions && versions.v8;
 552  var match, version;
 553  
 554  if (v8) {
 555    match = v8.split('.');
 556    // in old Chrome, versions of V8 isn't V8 = Chrome / 10
 557    // but their correct versions are not interesting for us
 558    version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
 559  }
 560  
 561  // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
 562  // so check `userAgent` even if `.v8` exists, but 0
 563  if (!version && userAgent) {
 564    match = userAgent.match(/Edge\/(\d+)/);
 565    if (!match || match[1] >= 74) {
 566      match = userAgent.match(/Chrome\/(\d+)/);
 567      if (match) version = +match[1];
 568    }
 569  }
 570  
 571  module.exports = version;
 572  
 573  
 574  /***/ }),
 575  /* 25 */
 576  /***/ (function(module, exports, __webpack_require__) {
 577  
 578  var getBuiltIn = __webpack_require__(20);
 579  
 580  module.exports = getBuiltIn('navigator', 'userAgent') || '';
 581  
 582  
 583  /***/ }),
 584  /* 26 */
 585  /***/ (function(module, exports, __webpack_require__) {
 586  
 587  var aCallable = __webpack_require__(27);
 588  
 589  // `GetMethod` abstract operation
 590  // https://tc39.es/ecma262/#sec-getmethod
 591  module.exports = function (V, P) {
 592    var func = V[P];
 593    return func == null ? undefined : aCallable(func);
 594  };
 595  
 596  
 597  /***/ }),
 598  /* 27 */
 599  /***/ (function(module, exports, __webpack_require__) {
 600  
 601  var global = __webpack_require__(3);
 602  var isCallable = __webpack_require__(18);
 603  var tryToString = __webpack_require__(28);
 604  
 605  var TypeError = global.TypeError;
 606  
 607  // `Assert: IsCallable(argument) is true`
 608  module.exports = function (argument) {
 609    if (isCallable(argument)) return argument;
 610    throw TypeError(tryToString(argument) + ' is not a function');
 611  };
 612  
 613  
 614  /***/ }),
 615  /* 28 */
 616  /***/ (function(module, exports, __webpack_require__) {
 617  
 618  var global = __webpack_require__(3);
 619  
 620  var String = global.String;
 621  
 622  module.exports = function (argument) {
 623    try {
 624      return String(argument);
 625    } catch (error) {
 626      return 'Object';
 627    }
 628  };
 629  
 630  
 631  /***/ }),
 632  /* 29 */
 633  /***/ (function(module, exports, __webpack_require__) {
 634  
 635  var global = __webpack_require__(3);
 636  var call = __webpack_require__(7);
 637  var isCallable = __webpack_require__(18);
 638  var isObject = __webpack_require__(17);
 639  
 640  var TypeError = global.TypeError;
 641  
 642  // `OrdinaryToPrimitive` abstract operation
 643  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
 644  module.exports = function (input, pref) {
 645    var fn, val;
 646    if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
 647    if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
 648    if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
 649    throw TypeError("Can't convert object to primitive value");
 650  };
 651  
 652  
 653  /***/ }),
 654  /* 30 */
 655  /***/ (function(module, exports, __webpack_require__) {
 656  
 657  var global = __webpack_require__(3);
 658  var shared = __webpack_require__(31);
 659  var hasOwn = __webpack_require__(35);
 660  var uid = __webpack_require__(37);
 661  var NATIVE_SYMBOL = __webpack_require__(23);
 662  var USE_SYMBOL_AS_UID = __webpack_require__(22);
 663  
 664  var WellKnownSymbolsStore = shared('wks');
 665  var Symbol = global.Symbol;
 666  var symbolFor = Symbol && Symbol['for'];
 667  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
 668  
 669  module.exports = function (name) {
 670    if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
 671      var description = 'Symbol.' + name;
 672      if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {
 673        WellKnownSymbolsStore[name] = Symbol[name];
 674      } else if (USE_SYMBOL_AS_UID && symbolFor) {
 675        WellKnownSymbolsStore[name] = symbolFor(description);
 676      } else {
 677        WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
 678      }
 679    } return WellKnownSymbolsStore[name];
 680  };
 681  
 682  
 683  /***/ }),
 684  /* 31 */
 685  /***/ (function(module, exports, __webpack_require__) {
 686  
 687  var IS_PURE = __webpack_require__(32);
 688  var store = __webpack_require__(33);
 689  
 690  (module.exports = function (key, value) {
 691    return store[key] || (store[key] = value !== undefined ? value : {});
 692  })('versions', []).push({
 693    version: '3.19.1',
 694    mode: IS_PURE ? 'pure' : 'global',
 695    copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
 696  });
 697  
 698  
 699  /***/ }),
 700  /* 32 */
 701  /***/ (function(module, exports) {
 702  
 703  module.exports = false;
 704  
 705  
 706  /***/ }),
 707  /* 33 */
 708  /***/ (function(module, exports, __webpack_require__) {
 709  
 710  var global = __webpack_require__(3);
 711  var setGlobal = __webpack_require__(34);
 712  
 713  var SHARED = '__core-js_shared__';
 714  var store = global[SHARED] || setGlobal(SHARED, {});
 715  
 716  module.exports = store;
 717  
 718  
 719  /***/ }),
 720  /* 34 */
 721  /***/ (function(module, exports, __webpack_require__) {
 722  
 723  var global = __webpack_require__(3);
 724  
 725  // eslint-disable-next-line es/no-object-defineproperty -- safe
 726  var defineProperty = Object.defineProperty;
 727  
 728  module.exports = function (key, value) {
 729    try {
 730      defineProperty(global, key, { value: value, configurable: true, writable: true });
 731    } catch (error) {
 732      global[key] = value;
 733    } return value;
 734  };
 735  
 736  
 737  /***/ }),
 738  /* 35 */
 739  /***/ (function(module, exports, __webpack_require__) {
 740  
 741  var uncurryThis = __webpack_require__(12);
 742  var toObject = __webpack_require__(36);
 743  
 744  var hasOwnProperty = uncurryThis({}.hasOwnProperty);
 745  
 746  // `HasOwnProperty` abstract operation
 747  // https://tc39.es/ecma262/#sec-hasownproperty
 748  module.exports = Object.hasOwn || function hasOwn(it, key) {
 749    return hasOwnProperty(toObject(it), key);
 750  };
 751  
 752  
 753  /***/ }),
 754  /* 36 */
 755  /***/ (function(module, exports, __webpack_require__) {
 756  
 757  var global = __webpack_require__(3);
 758  var requireObjectCoercible = __webpack_require__(14);
 759  
 760  var Object = global.Object;
 761  
 762  // `ToObject` abstract operation
 763  // https://tc39.es/ecma262/#sec-toobject
 764  module.exports = function (argument) {
 765    return Object(requireObjectCoercible(argument));
 766  };
 767  
 768  
 769  /***/ }),
 770  /* 37 */
 771  /***/ (function(module, exports, __webpack_require__) {
 772  
 773  var uncurryThis = __webpack_require__(12);
 774  
 775  var id = 0;
 776  var postfix = Math.random();
 777  var toString = uncurryThis(1.0.toString);
 778  
 779  module.exports = function (key) {
 780    return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
 781  };
 782  
 783  
 784  /***/ }),
 785  /* 38 */
 786  /***/ (function(module, exports, __webpack_require__) {
 787  
 788  var DESCRIPTORS = __webpack_require__(5);
 789  var fails = __webpack_require__(6);
 790  var createElement = __webpack_require__(39);
 791  
 792  // Thank's IE8 for his funny defineProperty
 793  module.exports = !DESCRIPTORS && !fails(function () {
 794    // eslint-disable-next-line es/no-object-defineproperty -- requied for testing
 795    return Object.defineProperty(createElement('div'), 'a', {
 796      get: function () { return 7; }
 797    }).a != 7;
 798  });
 799  
 800  
 801  /***/ }),
 802  /* 39 */
 803  /***/ (function(module, exports, __webpack_require__) {
 804  
 805  var global = __webpack_require__(3);
 806  var isObject = __webpack_require__(17);
 807  
 808  var document = global.document;
 809  // typeof document.createElement is 'object' in old IE
 810  var EXISTS = isObject(document) && isObject(document.createElement);
 811  
 812  module.exports = function (it) {
 813    return EXISTS ? document.createElement(it) : {};
 814  };
 815  
 816  
 817  /***/ }),
 818  /* 40 */
 819  /***/ (function(module, exports, __webpack_require__) {
 820  
 821  var DESCRIPTORS = __webpack_require__(5);
 822  var definePropertyModule = __webpack_require__(41);
 823  var createPropertyDescriptor = __webpack_require__(9);
 824  
 825  module.exports = DESCRIPTORS ? function (object, key, value) {
 826    return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
 827  } : function (object, key, value) {
 828    object[key] = value;
 829    return object;
 830  };
 831  
 832  
 833  /***/ }),
 834  /* 41 */
 835  /***/ (function(module, exports, __webpack_require__) {
 836  
 837  var global = __webpack_require__(3);
 838  var DESCRIPTORS = __webpack_require__(5);
 839  var IE8_DOM_DEFINE = __webpack_require__(38);
 840  var anObject = __webpack_require__(42);
 841  var toPropertyKey = __webpack_require__(15);
 842  
 843  var TypeError = global.TypeError;
 844  // eslint-disable-next-line es/no-object-defineproperty -- safe
 845  var $defineProperty = Object.defineProperty;
 846  
 847  // `Object.defineProperty` method
 848  // https://tc39.es/ecma262/#sec-object.defineproperty
 849  exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {
 850    anObject(O);
 851    P = toPropertyKey(P);
 852    anObject(Attributes);
 853    if (IE8_DOM_DEFINE) try {
 854      return $defineProperty(O, P, Attributes);
 855    } catch (error) { /* empty */ }
 856    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
 857    if ('value' in Attributes) O[P] = Attributes.value;
 858    return O;
 859  };
 860  
 861  
 862  /***/ }),
 863  /* 42 */
 864  /***/ (function(module, exports, __webpack_require__) {
 865  
 866  var global = __webpack_require__(3);
 867  var isObject = __webpack_require__(17);
 868  
 869  var String = global.String;
 870  var TypeError = global.TypeError;
 871  
 872  // `Assert: Type(argument) is Object`
 873  module.exports = function (argument) {
 874    if (isObject(argument)) return argument;
 875    throw TypeError(String(argument) + ' is not an object');
 876  };
 877  
 878  
 879  /***/ }),
 880  /* 43 */
 881  /***/ (function(module, exports, __webpack_require__) {
 882  
 883  var global = __webpack_require__(3);
 884  var isCallable = __webpack_require__(18);
 885  var hasOwn = __webpack_require__(35);
 886  var createNonEnumerableProperty = __webpack_require__(40);
 887  var setGlobal = __webpack_require__(34);
 888  var inspectSource = __webpack_require__(44);
 889  var InternalStateModule = __webpack_require__(45);
 890  var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(49).CONFIGURABLE;
 891  
 892  var getInternalState = InternalStateModule.get;
 893  var enforceInternalState = InternalStateModule.enforce;
 894  var TEMPLATE = String(String).split('String');
 895  
 896  (module.exports = function (O, key, value, options) {
 897    var unsafe = options ? !!options.unsafe : false;
 898    var simple = options ? !!options.enumerable : false;
 899    var noTargetGet = options ? !!options.noTargetGet : false;
 900    var name = options && options.name !== undefined ? options.name : key;
 901    var state;
 902    if (isCallable(value)) {
 903      if (String(name).slice(0, 7) === 'Symbol(') {
 904        name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
 905      }
 906      if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
 907        createNonEnumerableProperty(value, 'name', name);
 908      }
 909      state = enforceInternalState(value);
 910      if (!state.source) {
 911        state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
 912      }
 913    }
 914    if (O === global) {
 915      if (simple) O[key] = value;
 916      else setGlobal(key, value);
 917      return;
 918    } else if (!unsafe) {
 919      delete O[key];
 920    } else if (!noTargetGet && O[key]) {
 921      simple = true;
 922    }
 923    if (simple) O[key] = value;
 924    else createNonEnumerableProperty(O, key, value);
 925  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
 926  })(Function.prototype, 'toString', function toString() {
 927    return isCallable(this) && getInternalState(this).source || inspectSource(this);
 928  });
 929  
 930  
 931  /***/ }),
 932  /* 44 */
 933  /***/ (function(module, exports, __webpack_require__) {
 934  
 935  var uncurryThis = __webpack_require__(12);
 936  var isCallable = __webpack_require__(18);
 937  var store = __webpack_require__(33);
 938  
 939  var functionToString = uncurryThis(Function.toString);
 940  
 941  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
 942  if (!isCallable(store.inspectSource)) {
 943    store.inspectSource = function (it) {
 944      return functionToString(it);
 945    };
 946  }
 947  
 948  module.exports = store.inspectSource;
 949  
 950  
 951  /***/ }),
 952  /* 45 */
 953  /***/ (function(module, exports, __webpack_require__) {
 954  
 955  var NATIVE_WEAK_MAP = __webpack_require__(46);
 956  var global = __webpack_require__(3);
 957  var uncurryThis = __webpack_require__(12);
 958  var isObject = __webpack_require__(17);
 959  var createNonEnumerableProperty = __webpack_require__(40);
 960  var hasOwn = __webpack_require__(35);
 961  var shared = __webpack_require__(33);
 962  var sharedKey = __webpack_require__(47);
 963  var hiddenKeys = __webpack_require__(48);
 964  
 965  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
 966  var TypeError = global.TypeError;
 967  var WeakMap = global.WeakMap;
 968  var set, get, has;
 969  
 970  var enforce = function (it) {
 971    return has(it) ? get(it) : set(it, {});
 972  };
 973  
 974  var getterFor = function (TYPE) {
 975    return function (it) {
 976      var state;
 977      if (!isObject(it) || (state = get(it)).type !== TYPE) {
 978        throw TypeError('Incompatible receiver, ' + TYPE + ' required');
 979      } return state;
 980    };
 981  };
 982  
 983  if (NATIVE_WEAK_MAP || shared.state) {
 984    var store = shared.state || (shared.state = new WeakMap());
 985    var wmget = uncurryThis(store.get);
 986    var wmhas = uncurryThis(store.has);
 987    var wmset = uncurryThis(store.set);
 988    set = function (it, metadata) {
 989      if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
 990      metadata.facade = it;
 991      wmset(store, it, metadata);
 992      return metadata;
 993    };
 994    get = function (it) {
 995      return wmget(store, it) || {};
 996    };
 997    has = function (it) {
 998      return wmhas(store, it);
 999    };
1000  } else {
1001    var STATE = sharedKey('state');
1002    hiddenKeys[STATE] = true;
1003    set = function (it, metadata) {
1004      if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1005      metadata.facade = it;
1006      createNonEnumerableProperty(it, STATE, metadata);
1007      return metadata;
1008    };
1009    get = function (it) {
1010      return hasOwn(it, STATE) ? it[STATE] : {};
1011    };
1012    has = function (it) {
1013      return hasOwn(it, STATE);
1014    };
1015  }
1016  
1017  module.exports = {
1018    set: set,
1019    get: get,
1020    has: has,
1021    enforce: enforce,
1022    getterFor: getterFor
1023  };
1024  
1025  
1026  /***/ }),
1027  /* 46 */
1028  /***/ (function(module, exports, __webpack_require__) {
1029  
1030  var global = __webpack_require__(3);
1031  var isCallable = __webpack_require__(18);
1032  var inspectSource = __webpack_require__(44);
1033  
1034  var WeakMap = global.WeakMap;
1035  
1036  module.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));
1037  
1038  
1039  /***/ }),
1040  /* 47 */
1041  /***/ (function(module, exports, __webpack_require__) {
1042  
1043  var shared = __webpack_require__(31);
1044  var uid = __webpack_require__(37);
1045  
1046  var keys = shared('keys');
1047  
1048  module.exports = function (key) {
1049    return keys[key] || (keys[key] = uid(key));
1050  };
1051  
1052  
1053  /***/ }),
1054  /* 48 */
1055  /***/ (function(module, exports) {
1056  
1057  module.exports = {};
1058  
1059  
1060  /***/ }),
1061  /* 49 */
1062  /***/ (function(module, exports, __webpack_require__) {
1063  
1064  var DESCRIPTORS = __webpack_require__(5);
1065  var hasOwn = __webpack_require__(35);
1066  
1067  var FunctionPrototype = Function.prototype;
1068  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1069  var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
1070  
1071  var EXISTS = hasOwn(FunctionPrototype, 'name');
1072  // additional protection from minified / mangled / dropped function names
1073  var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
1074  var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
1075  
1076  module.exports = {
1077    EXISTS: EXISTS,
1078    PROPER: PROPER,
1079    CONFIGURABLE: CONFIGURABLE
1080  };
1081  
1082  
1083  /***/ }),
1084  /* 50 */
1085  /***/ (function(module, exports, __webpack_require__) {
1086  
1087  var hasOwn = __webpack_require__(35);
1088  var ownKeys = __webpack_require__(51);
1089  var getOwnPropertyDescriptorModule = __webpack_require__(4);
1090  var definePropertyModule = __webpack_require__(41);
1091  
1092  module.exports = function (target, source) {
1093    var keys = ownKeys(source);
1094    var defineProperty = definePropertyModule.f;
1095    var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1096    for (var i = 0; i < keys.length; i++) {
1097      var key = keys[i];
1098      if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1099    }
1100  };
1101  
1102  
1103  /***/ }),
1104  /* 51 */
1105  /***/ (function(module, exports, __webpack_require__) {
1106  
1107  var getBuiltIn = __webpack_require__(20);
1108  var uncurryThis = __webpack_require__(12);
1109  var getOwnPropertyNamesModule = __webpack_require__(52);
1110  var getOwnPropertySymbolsModule = __webpack_require__(60);
1111  var anObject = __webpack_require__(42);
1112  
1113  var concat = uncurryThis([].concat);
1114  
1115  // all object keys, includes non-enumerable and symbols
1116  module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
1117    var keys = getOwnPropertyNamesModule.f(anObject(it));
1118    var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1119    return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
1120  };
1121  
1122  
1123  /***/ }),
1124  /* 52 */
1125  /***/ (function(module, exports, __webpack_require__) {
1126  
1127  var internalObjectKeys = __webpack_require__(53);
1128  var enumBugKeys = __webpack_require__(59);
1129  
1130  var hiddenKeys = enumBugKeys.concat('length', 'prototype');
1131  
1132  // `Object.getOwnPropertyNames` method
1133  // https://tc39.es/ecma262/#sec-object.getownpropertynames
1134  // eslint-disable-next-line es/no-object-getownpropertynames -- safe
1135  exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1136    return internalObjectKeys(O, hiddenKeys);
1137  };
1138  
1139  
1140  /***/ }),
1141  /* 53 */
1142  /***/ (function(module, exports, __webpack_require__) {
1143  
1144  var uncurryThis = __webpack_require__(12);
1145  var hasOwn = __webpack_require__(35);
1146  var toIndexedObject = __webpack_require__(10);
1147  var indexOf = __webpack_require__(54).indexOf;
1148  var hiddenKeys = __webpack_require__(48);
1149  
1150  var push = uncurryThis([].push);
1151  
1152  module.exports = function (object, names) {
1153    var O = toIndexedObject(object);
1154    var i = 0;
1155    var result = [];
1156    var key;
1157    for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
1158    // Don't enum bug & hidden keys
1159    while (names.length > i) if (hasOwn(O, key = names[i++])) {
1160      ~indexOf(result, key) || push(result, key);
1161    }
1162    return result;
1163  };
1164  
1165  
1166  /***/ }),
1167  /* 54 */
1168  /***/ (function(module, exports, __webpack_require__) {
1169  
1170  var toIndexedObject = __webpack_require__(10);
1171  var toAbsoluteIndex = __webpack_require__(55);
1172  var lengthOfArrayLike = __webpack_require__(57);
1173  
1174  // `Array.prototype.{ indexOf, includes }` methods implementation
1175  var createMethod = function (IS_INCLUDES) {
1176    return function ($this, el, fromIndex) {
1177      var O = toIndexedObject($this);
1178      var length = lengthOfArrayLike(O);
1179      var index = toAbsoluteIndex(fromIndex, length);
1180      var value;
1181      // Array#includes uses SameValueZero equality algorithm
1182      // eslint-disable-next-line no-self-compare -- NaN check
1183      if (IS_INCLUDES && el != el) while (length > index) {
1184        value = O[index++];
1185        // eslint-disable-next-line no-self-compare -- NaN check
1186        if (value != value) return true;
1187      // Array#indexOf ignores holes, Array#includes - not
1188      } else for (;length > index; index++) {
1189        if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
1190      } return !IS_INCLUDES && -1;
1191    };
1192  };
1193  
1194  module.exports = {
1195    // `Array.prototype.includes` method
1196    // https://tc39.es/ecma262/#sec-array.prototype.includes
1197    includes: createMethod(true),
1198    // `Array.prototype.indexOf` method
1199    // https://tc39.es/ecma262/#sec-array.prototype.indexof
1200    indexOf: createMethod(false)
1201  };
1202  
1203  
1204  /***/ }),
1205  /* 55 */
1206  /***/ (function(module, exports, __webpack_require__) {
1207  
1208  var toIntegerOrInfinity = __webpack_require__(56);
1209  
1210  var max = Math.max;
1211  var min = Math.min;
1212  
1213  // Helper for a popular repeating case of the spec:
1214  // Let integer be ? ToInteger(index).
1215  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1216  module.exports = function (index, length) {
1217    var integer = toIntegerOrInfinity(index);
1218    return integer < 0 ? max(integer + length, 0) : min(integer, length);
1219  };
1220  
1221  
1222  /***/ }),
1223  /* 56 */
1224  /***/ (function(module, exports) {
1225  
1226  var ceil = Math.ceil;
1227  var floor = Math.floor;
1228  
1229  // `ToIntegerOrInfinity` abstract operation
1230  // https://tc39.es/ecma262/#sec-tointegerorinfinity
1231  module.exports = function (argument) {
1232    var number = +argument;
1233    // eslint-disable-next-line no-self-compare -- safe
1234    return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);
1235  };
1236  
1237  
1238  /***/ }),
1239  /* 57 */
1240  /***/ (function(module, exports, __webpack_require__) {
1241  
1242  var toLength = __webpack_require__(58);
1243  
1244  // `LengthOfArrayLike` abstract operation
1245  // https://tc39.es/ecma262/#sec-lengthofarraylike
1246  module.exports = function (obj) {
1247    return toLength(obj.length);
1248  };
1249  
1250  
1251  /***/ }),
1252  /* 58 */
1253  /***/ (function(module, exports, __webpack_require__) {
1254  
1255  var toIntegerOrInfinity = __webpack_require__(56);
1256  
1257  var min = Math.min;
1258  
1259  // `ToLength` abstract operation
1260  // https://tc39.es/ecma262/#sec-tolength
1261  module.exports = function (argument) {
1262    return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1263  };
1264  
1265  
1266  /***/ }),
1267  /* 59 */
1268  /***/ (function(module, exports) {
1269  
1270  // IE8- don't enum bug keys
1271  module.exports = [
1272    'constructor',
1273    'hasOwnProperty',
1274    'isPrototypeOf',
1275    'propertyIsEnumerable',
1276    'toLocaleString',
1277    'toString',
1278    'valueOf'
1279  ];
1280  
1281  
1282  /***/ }),
1283  /* 60 */
1284  /***/ (function(module, exports) {
1285  
1286  // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
1287  exports.f = Object.getOwnPropertySymbols;
1288  
1289  
1290  /***/ }),
1291  /* 61 */
1292  /***/ (function(module, exports, __webpack_require__) {
1293  
1294  var fails = __webpack_require__(6);
1295  var isCallable = __webpack_require__(18);
1296  
1297  var replacement = /#|\.prototype\./;
1298  
1299  var isForced = function (feature, detection) {
1300    var value = data[normalize(feature)];
1301    return value == POLYFILL ? true
1302      : value == NATIVE ? false
1303      : isCallable(detection) ? fails(detection)
1304      : !!detection;
1305  };
1306  
1307  var normalize = isForced.normalize = function (string) {
1308    return String(string).replace(replacement, '.').toLowerCase();
1309  };
1310  
1311  var data = isForced.data = {};
1312  var NATIVE = isForced.NATIVE = 'N';
1313  var POLYFILL = isForced.POLYFILL = 'P';
1314  
1315  module.exports = isForced;
1316  
1317  
1318  /***/ }),
1319  /* 62 */
1320  /***/ (function(module, exports, __webpack_require__) {
1321  
1322  var wellKnownSymbol = __webpack_require__(30);
1323  var create = __webpack_require__(63);
1324  var definePropertyModule = __webpack_require__(41);
1325  
1326  var UNSCOPABLES = wellKnownSymbol('unscopables');
1327  var ArrayPrototype = Array.prototype;
1328  
1329  // Array.prototype[@@unscopables]
1330  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1331  if (ArrayPrototype[UNSCOPABLES] == undefined) {
1332    definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
1333      configurable: true,
1334      value: create(null)
1335    });
1336  }
1337  
1338  // add a key to Array.prototype[@@unscopables]
1339  module.exports = function (key) {
1340    ArrayPrototype[UNSCOPABLES][key] = true;
1341  };
1342  
1343  
1344  /***/ }),
1345  /* 63 */
1346  /***/ (function(module, exports, __webpack_require__) {
1347  
1348  /* global ActiveXObject -- old IE, WSH */
1349  var anObject = __webpack_require__(42);
1350  var defineProperties = __webpack_require__(64);
1351  var enumBugKeys = __webpack_require__(59);
1352  var hiddenKeys = __webpack_require__(48);
1353  var html = __webpack_require__(66);
1354  var documentCreateElement = __webpack_require__(39);
1355  var sharedKey = __webpack_require__(47);
1356  
1357  var GT = '>';
1358  var LT = '<';
1359  var PROTOTYPE = 'prototype';
1360  var SCRIPT = 'script';
1361  var IE_PROTO = sharedKey('IE_PROTO');
1362  
1363  var EmptyConstructor = function () { /* empty */ };
1364  
1365  var scriptTag = function (content) {
1366    return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
1367  };
1368  
1369  // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
1370  var NullProtoObjectViaActiveX = function (activeXDocument) {
1371    activeXDocument.write(scriptTag(''));
1372    activeXDocument.close();
1373    var temp = activeXDocument.parentWindow.Object;
1374    activeXDocument = null; // avoid memory leak
1375    return temp;
1376  };
1377  
1378  // Create object with fake `null` prototype: use iframe Object with cleared prototype
1379  var NullProtoObjectViaIFrame = function () {
1380    // Thrash, waste and sodomy: IE GC bug
1381    var iframe = documentCreateElement('iframe');
1382    var JS = 'java' + SCRIPT + ':';
1383    var iframeDocument;
1384    iframe.style.display = 'none';
1385    html.appendChild(iframe);
1386    // https://github.com/zloirock/core-js/issues/475
1387    iframe.src = String(JS);
1388    iframeDocument = iframe.contentWindow.document;
1389    iframeDocument.open();
1390    iframeDocument.write(scriptTag('document.F=Object'));
1391    iframeDocument.close();
1392    return iframeDocument.F;
1393  };
1394  
1395  // Check for document.domain and active x support
1396  // No need to use active x approach when document.domain is not set
1397  // see https://github.com/es-shims/es5-shim/issues/150
1398  // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
1399  // avoid IE GC bug
1400  var activeXDocument;
1401  var NullProtoObject = function () {
1402    try {
1403      activeXDocument = new ActiveXObject('htmlfile');
1404    } catch (error) { /* ignore */ }
1405    NullProtoObject = typeof document != 'undefined'
1406      ? document.domain && activeXDocument
1407        ? NullProtoObjectViaActiveX(activeXDocument) // old IE
1408        : NullProtoObjectViaIFrame()
1409      : NullProtoObjectViaActiveX(activeXDocument); // WSH
1410    var length = enumBugKeys.length;
1411    while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
1412    return NullProtoObject();
1413  };
1414  
1415  hiddenKeys[IE_PROTO] = true;
1416  
1417  // `Object.create` method
1418  // https://tc39.es/ecma262/#sec-object.create
1419  module.exports = Object.create || function create(O, Properties) {
1420    var result;
1421    if (O !== null) {
1422      EmptyConstructor[PROTOTYPE] = anObject(O);
1423      result = new EmptyConstructor();
1424      EmptyConstructor[PROTOTYPE] = null;
1425      // add "__proto__" for Object.getPrototypeOf polyfill
1426      result[IE_PROTO] = O;
1427    } else result = NullProtoObject();
1428    return Properties === undefined ? result : defineProperties(result, Properties);
1429  };
1430  
1431  
1432  /***/ }),
1433  /* 64 */
1434  /***/ (function(module, exports, __webpack_require__) {
1435  
1436  var DESCRIPTORS = __webpack_require__(5);
1437  var definePropertyModule = __webpack_require__(41);
1438  var anObject = __webpack_require__(42);
1439  var toIndexedObject = __webpack_require__(10);
1440  var objectKeys = __webpack_require__(65);
1441  
1442  // `Object.defineProperties` method
1443  // https://tc39.es/ecma262/#sec-object.defineproperties
1444  // eslint-disable-next-line es/no-object-defineproperties -- safe
1445  module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
1446    anObject(O);
1447    var props = toIndexedObject(Properties);
1448    var keys = objectKeys(Properties);
1449    var length = keys.length;
1450    var index = 0;
1451    var key;
1452    while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
1453    return O;
1454  };
1455  
1456  
1457  /***/ }),
1458  /* 65 */
1459  /***/ (function(module, exports, __webpack_require__) {
1460  
1461  var internalObjectKeys = __webpack_require__(53);
1462  var enumBugKeys = __webpack_require__(59);
1463  
1464  // `Object.keys` method
1465  // https://tc39.es/ecma262/#sec-object.keys
1466  // eslint-disable-next-line es/no-object-keys -- safe
1467  module.exports = Object.keys || function keys(O) {
1468    return internalObjectKeys(O, enumBugKeys);
1469  };
1470  
1471  
1472  /***/ }),
1473  /* 66 */
1474  /***/ (function(module, exports, __webpack_require__) {
1475  
1476  var getBuiltIn = __webpack_require__(20);
1477  
1478  module.exports = getBuiltIn('document', 'documentElement');
1479  
1480  
1481  /***/ }),
1482  /* 67 */
1483  /***/ (function(module, exports, __webpack_require__) {
1484  
1485  var $ = __webpack_require__(2);
1486  var hasOwn = __webpack_require__(35);
1487  
1488  // `Object.hasOwn` method
1489  // https://github.com/tc39/proposal-accessible-object-hasownproperty
1490  $({ target: 'Object', stat: true }, {
1491    hasOwn: hasOwn
1492  });
1493  
1494  
1495  /***/ }),
1496  /* 68 */
1497  /***/ (function(module, exports, __webpack_require__) {
1498  
1499  "use strict";
1500  
1501  var $ = __webpack_require__(2);
1502  var uncurryThis = __webpack_require__(12);
1503  var requireObjectCoercible = __webpack_require__(14);
1504  var toIntegerOrInfinity = __webpack_require__(56);
1505  var toString = __webpack_require__(69);
1506  var fails = __webpack_require__(6);
1507  
1508  var charAt = uncurryThis(''.charAt);
1509  
1510  var FORCED = fails(function () {
1511    return '𠮷'.at(0) !== '\uD842';
1512  });
1513  
1514  // `String.prototype.at` method
1515  // https://github.com/tc39/proposal-relative-indexing-method
1516  $({ target: 'String', proto: true, forced: FORCED }, {
1517    at: function at(index) {
1518      var S = toString(requireObjectCoercible(this));
1519      var len = S.length;
1520      var relativeIndex = toIntegerOrInfinity(index);
1521      var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
1522      return (k < 0 || k >= len) ? undefined : charAt(S, k);
1523    }
1524  });
1525  
1526  
1527  /***/ }),
1528  /* 69 */
1529  /***/ (function(module, exports, __webpack_require__) {
1530  
1531  var global = __webpack_require__(3);
1532  var classof = __webpack_require__(70);
1533  
1534  var String = global.String;
1535  
1536  module.exports = function (argument) {
1537    if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
1538    return String(argument);
1539  };
1540  
1541  
1542  /***/ }),
1543  /* 70 */
1544  /***/ (function(module, exports, __webpack_require__) {
1545  
1546  var global = __webpack_require__(3);
1547  var TO_STRING_TAG_SUPPORT = __webpack_require__(71);
1548  var isCallable = __webpack_require__(18);
1549  var classofRaw = __webpack_require__(13);
1550  var wellKnownSymbol = __webpack_require__(30);
1551  
1552  var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1553  var Object = global.Object;
1554  
1555  // ES3 wrong here
1556  var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
1557  
1558  // fallback for IE11 Script Access Denied error
1559  var tryGet = function (it, key) {
1560    try {
1561      return it[key];
1562    } catch (error) { /* empty */ }
1563  };
1564  
1565  // getting tag from ES6+ `Object.prototype.toString`
1566  module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1567    var O, tag, result;
1568    return it === undefined ? 'Undefined' : it === null ? 'Null'
1569      // @@toStringTag case
1570      : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
1571      // builtinTag case
1572      : CORRECT_ARGUMENTS ? classofRaw(O)
1573      // ES3 arguments fallback
1574      : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
1575  };
1576  
1577  
1578  /***/ }),
1579  /* 71 */
1580  /***/ (function(module, exports, __webpack_require__) {
1581  
1582  var wellKnownSymbol = __webpack_require__(30);
1583  
1584  var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1585  var test = {};
1586  
1587  test[TO_STRING_TAG] = 'z';
1588  
1589  module.exports = String(test) === '[object z]';
1590  
1591  
1592  /***/ }),
1593  /* 72 */
1594  /***/ (function(module, exports, __webpack_require__) {
1595  
1596  "use strict";
1597  
1598  var ArrayBufferViewCore = __webpack_require__(73);
1599  var lengthOfArrayLike = __webpack_require__(57);
1600  var toIntegerOrInfinity = __webpack_require__(56);
1601  
1602  var aTypedArray = ArrayBufferViewCore.aTypedArray;
1603  var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
1604  
1605  // `%TypedArray%.prototype.at` method
1606  // https://github.com/tc39/proposal-relative-indexing-method
1607  exportTypedArrayMethod('at', function at(index) {
1608    var O = aTypedArray(this);
1609    var len = lengthOfArrayLike(O);
1610    var relativeIndex = toIntegerOrInfinity(index);
1611    var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
1612    return (k < 0 || k >= len) ? undefined : O[k];
1613  });
1614  
1615  
1616  /***/ }),
1617  /* 73 */
1618  /***/ (function(module, exports, __webpack_require__) {
1619  
1620  "use strict";
1621  
1622  var NATIVE_ARRAY_BUFFER = __webpack_require__(74);
1623  var DESCRIPTORS = __webpack_require__(5);
1624  var global = __webpack_require__(3);
1625  var isCallable = __webpack_require__(18);
1626  var isObject = __webpack_require__(17);
1627  var hasOwn = __webpack_require__(35);
1628  var classof = __webpack_require__(70);
1629  var tryToString = __webpack_require__(28);
1630  var createNonEnumerableProperty = __webpack_require__(40);
1631  var redefine = __webpack_require__(43);
1632  var defineProperty = __webpack_require__(41).f;
1633  var isPrototypeOf = __webpack_require__(21);
1634  var getPrototypeOf = __webpack_require__(75);
1635  var setPrototypeOf = __webpack_require__(77);
1636  var wellKnownSymbol = __webpack_require__(30);
1637  var uid = __webpack_require__(37);
1638  
1639  var Int8Array = global.Int8Array;
1640  var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
1641  var Uint8ClampedArray = global.Uint8ClampedArray;
1642  var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
1643  var TypedArray = Int8Array && getPrototypeOf(Int8Array);
1644  var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
1645  var ObjectPrototype = Object.prototype;
1646  var TypeError = global.TypeError;
1647  
1648  var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1649  var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
1650  var TYPED_ARRAY_CONSTRUCTOR = uid('TYPED_ARRAY_CONSTRUCTOR');
1651  // Fixing native typed arrays in Opera Presto crashes the browser, see #595
1652  var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';
1653  var TYPED_ARRAY_TAG_REQIRED = false;
1654  var NAME, Constructor, Prototype;
1655  
1656  var TypedArrayConstructorsList = {
1657    Int8Array: 1,
1658    Uint8Array: 1,
1659    Uint8ClampedArray: 1,
1660    Int16Array: 2,
1661    Uint16Array: 2,
1662    Int32Array: 4,
1663    Uint32Array: 4,
1664    Float32Array: 4,
1665    Float64Array: 8
1666  };
1667  
1668  var BigIntArrayConstructorsList = {
1669    BigInt64Array: 8,
1670    BigUint64Array: 8
1671  };
1672  
1673  var isView = function isView(it) {
1674    if (!isObject(it)) return false;
1675    var klass = classof(it);
1676    return klass === 'DataView'
1677      || hasOwn(TypedArrayConstructorsList, klass)
1678      || hasOwn(BigIntArrayConstructorsList, klass);
1679  };
1680  
1681  var isTypedArray = function (it) {
1682    if (!isObject(it)) return false;
1683    var klass = classof(it);
1684    return hasOwn(TypedArrayConstructorsList, klass)
1685      || hasOwn(BigIntArrayConstructorsList, klass);
1686  };
1687  
1688  var aTypedArray = function (it) {
1689    if (isTypedArray(it)) return it;
1690    throw TypeError('Target is not a typed array');
1691  };
1692  
1693  var aTypedArrayConstructor = function (C) {
1694    if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
1695    throw TypeError(tryToString(C) + ' is not a typed array constructor');
1696  };
1697  
1698  var exportTypedArrayMethod = function (KEY, property, forced) {
1699    if (!DESCRIPTORS) return;
1700    if (forced) for (var ARRAY in TypedArrayConstructorsList) {
1701      var TypedArrayConstructor = global[ARRAY];
1702      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
1703        delete TypedArrayConstructor.prototype[KEY];
1704      } catch (error) { /* empty */ }
1705    }
1706    if (!TypedArrayPrototype[KEY] || forced) {
1707      redefine(TypedArrayPrototype, KEY, forced ? property
1708        : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property);
1709    }
1710  };
1711  
1712  var exportTypedArrayStaticMethod = function (KEY, property, forced) {
1713    var ARRAY, TypedArrayConstructor;
1714    if (!DESCRIPTORS) return;
1715    if (setPrototypeOf) {
1716      if (forced) for (ARRAY in TypedArrayConstructorsList) {
1717        TypedArrayConstructor = global[ARRAY];
1718        if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
1719          delete TypedArrayConstructor[KEY];
1720        } catch (error) { /* empty */ }
1721      }
1722      if (!TypedArray[KEY] || forced) {
1723        // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
1724        try {
1725          return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
1726        } catch (error) { /* empty */ }
1727      } else return;
1728    }
1729    for (ARRAY in TypedArrayConstructorsList) {
1730      TypedArrayConstructor = global[ARRAY];
1731      if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
1732        redefine(TypedArrayConstructor, KEY, property);
1733      }
1734    }
1735  };
1736  
1737  for (NAME in TypedArrayConstructorsList) {
1738    Constructor = global[NAME];
1739    Prototype = Constructor && Constructor.prototype;
1740    if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);
1741    else NATIVE_ARRAY_BUFFER_VIEWS = false;
1742  }
1743  
1744  for (NAME in BigIntArrayConstructorsList) {
1745    Constructor = global[NAME];
1746    Prototype = Constructor && Constructor.prototype;
1747    if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);
1748  }
1749  
1750  // WebKit bug - typed arrays constructors prototype is Object.prototype
1751  if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
1752    // eslint-disable-next-line no-shadow -- safe
1753    TypedArray = function TypedArray() {
1754      throw TypeError('Incorrect invocation');
1755    };
1756    if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
1757      if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);
1758    }
1759  }
1760  
1761  if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
1762    TypedArrayPrototype = TypedArray.prototype;
1763    if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
1764      if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);
1765    }
1766  }
1767  
1768  // WebKit bug - one more object in Uint8ClampedArray prototype chain
1769  if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
1770    setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
1771  }
1772  
1773  if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
1774    TYPED_ARRAY_TAG_REQIRED = true;
1775    defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () {
1776      return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
1777    } });
1778    for (NAME in TypedArrayConstructorsList) if (global[NAME]) {
1779      createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);
1780    }
1781  }
1782  
1783  module.exports = {
1784    NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
1785    TYPED_ARRAY_CONSTRUCTOR: TYPED_ARRAY_CONSTRUCTOR,
1786    TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG,
1787    aTypedArray: aTypedArray,
1788    aTypedArrayConstructor: aTypedArrayConstructor,
1789    exportTypedArrayMethod: exportTypedArrayMethod,
1790    exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
1791    isView: isView,
1792    isTypedArray: isTypedArray,
1793    TypedArray: TypedArray,
1794    TypedArrayPrototype: TypedArrayPrototype
1795  };
1796  
1797  
1798  /***/ }),
1799  /* 74 */
1800  /***/ (function(module, exports) {
1801  
1802  // eslint-disable-next-line es/no-typed-arrays -- safe
1803  module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
1804  
1805  
1806  /***/ }),
1807  /* 75 */
1808  /***/ (function(module, exports, __webpack_require__) {
1809  
1810  var global = __webpack_require__(3);
1811  var hasOwn = __webpack_require__(35);
1812  var isCallable = __webpack_require__(18);
1813  var toObject = __webpack_require__(36);
1814  var sharedKey = __webpack_require__(47);
1815  var CORRECT_PROTOTYPE_GETTER = __webpack_require__(76);
1816  
1817  var IE_PROTO = sharedKey('IE_PROTO');
1818  var Object = global.Object;
1819  var ObjectPrototype = Object.prototype;
1820  
1821  // `Object.getPrototypeOf` method
1822  // https://tc39.es/ecma262/#sec-object.getprototypeof
1823  module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
1824    var object = toObject(O);
1825    if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
1826    var constructor = object.constructor;
1827    if (isCallable(constructor) && object instanceof constructor) {
1828      return constructor.prototype;
1829    } return object instanceof Object ? ObjectPrototype : null;
1830  };
1831  
1832  
1833  /***/ }),
1834  /* 76 */
1835  /***/ (function(module, exports, __webpack_require__) {
1836  
1837  var fails = __webpack_require__(6);
1838  
1839  module.exports = !fails(function () {
1840    function F() { /* empty */ }
1841    F.prototype.constructor = null;
1842    // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
1843    return Object.getPrototypeOf(new F()) !== F.prototype;
1844  });
1845  
1846  
1847  /***/ }),
1848  /* 77 */
1849  /***/ (function(module, exports, __webpack_require__) {
1850  
1851  /* eslint-disable no-proto -- safe */
1852  var uncurryThis = __webpack_require__(12);
1853  var anObject = __webpack_require__(42);
1854  var aPossiblePrototype = __webpack_require__(78);
1855  
1856  // `Object.setPrototypeOf` method
1857  // https://tc39.es/ecma262/#sec-object.setprototypeof
1858  // Works with __proto__ only. Old v8 can't work with null proto objects.
1859  // eslint-disable-next-line es/no-object-setprototypeof -- safe
1860  module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
1861    var CORRECT_SETTER = false;
1862    var test = {};
1863    var setter;
1864    try {
1865      // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1866      setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
1867      setter(test, []);
1868      CORRECT_SETTER = test instanceof Array;
1869    } catch (error) { /* empty */ }
1870    return function setPrototypeOf(O, proto) {
1871      anObject(O);
1872      aPossiblePrototype(proto);
1873      if (CORRECT_SETTER) setter(O, proto);
1874      else O.__proto__ = proto;
1875      return O;
1876    };
1877  }() : undefined);
1878  
1879  
1880  /***/ }),
1881  /* 78 */
1882  /***/ (function(module, exports, __webpack_require__) {
1883  
1884  var global = __webpack_require__(3);
1885  var isCallable = __webpack_require__(18);
1886  
1887  var String = global.String;
1888  var TypeError = global.TypeError;
1889  
1890  module.exports = function (argument) {
1891    if (typeof argument == 'object' || isCallable(argument)) return argument;
1892    throw TypeError("Can't set " + String(argument) + ' as a prototype');
1893  };
1894  
1895  
1896  /***/ }),
1897  /* 79 */
1898  /***/ (function(module, exports, __webpack_require__) {
1899  
1900  "use strict";
1901  
1902  var global = __webpack_require__(3);
1903  var uncurryThis = __webpack_require__(12);
1904  var fails = __webpack_require__(6);
1905  var aCallable = __webpack_require__(27);
1906  var internalSort = __webpack_require__(80);
1907  var ArrayBufferViewCore = __webpack_require__(73);
1908  var FF = __webpack_require__(82);
1909  var IE_OR_EDGE = __webpack_require__(83);
1910  var V8 = __webpack_require__(24);
1911  var WEBKIT = __webpack_require__(84);
1912  
1913  var Array = global.Array;
1914  var aTypedArray = ArrayBufferViewCore.aTypedArray;
1915  var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
1916  var Uint16Array = global.Uint16Array;
1917  var un$Sort = Uint16Array && uncurryThis(Uint16Array.prototype.sort);
1918  
1919  // WebKit
1920  var ACCEPT_INCORRECT_ARGUMENTS = !!un$Sort && !(fails(function () {
1921    un$Sort(new Uint16Array(2), null);
1922  }) && fails(function () {
1923    un$Sort(new Uint16Array(2), {});
1924  }));
1925  
1926  var STABLE_SORT = !!un$Sort && !fails(function () {
1927    // feature detection can be too slow, so check engines versions
1928    if (V8) return V8 < 74;
1929    if (FF) return FF < 67;
1930    if (IE_OR_EDGE) return true;
1931    if (WEBKIT) return WEBKIT < 602;
1932  
1933    var array = new Uint16Array(516);
1934    var expected = Array(516);
1935    var index, mod;
1936  
1937    for (index = 0; index < 516; index++) {
1938      mod = index % 4;
1939      array[index] = 515 - index;
1940      expected[index] = index - 2 * mod + 3;
1941    }
1942  
1943    un$Sort(array, function (a, b) {
1944      return (a / 4 | 0) - (b / 4 | 0);
1945    });
1946  
1947    for (index = 0; index < 516; index++) {
1948      if (array[index] !== expected[index]) return true;
1949    }
1950  });
1951  
1952  var getSortCompare = function (comparefn) {
1953    return function (x, y) {
1954      if (comparefn !== undefined) return +comparefn(x, y) || 0;
1955      // eslint-disable-next-line no-self-compare -- NaN check
1956      if (y !== y) return -1;
1957      // eslint-disable-next-line no-self-compare -- NaN check
1958      if (x !== x) return 1;
1959      if (x === 0 && y === 0) return 1 / x > 0 && 1 / y < 0 ? 1 : -1;
1960      return x > y;
1961    };
1962  };
1963  
1964  // `%TypedArray%.prototype.sort` method
1965  // https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort
1966  exportTypedArrayMethod('sort', function sort(comparefn) {
1967    if (comparefn !== undefined) aCallable(comparefn);
1968    if (STABLE_SORT) return un$Sort(this, comparefn);
1969  
1970    return internalSort(aTypedArray(this), getSortCompare(comparefn));
1971  }, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS);
1972  
1973  
1974  /***/ }),
1975  /* 80 */
1976  /***/ (function(module, exports, __webpack_require__) {
1977  
1978  var arraySlice = __webpack_require__(81);
1979  
1980  var floor = Math.floor;
1981  
1982  var mergeSort = function (array, comparefn) {
1983    var length = array.length;
1984    var middle = floor(length / 2);
1985    return length < 8 ? insertionSort(array, comparefn) : merge(
1986      array,
1987      mergeSort(arraySlice(array, 0, middle), comparefn),
1988      mergeSort(arraySlice(array, middle), comparefn),
1989      comparefn
1990    );
1991  };
1992  
1993  var insertionSort = function (array, comparefn) {
1994    var length = array.length;
1995    var i = 1;
1996    var element, j;
1997  
1998    while (i < length) {
1999      j = i;
2000      element = array[i];
2001      while (j && comparefn(array[j - 1], element) > 0) {
2002        array[j] = array[--j];
2003      }
2004      if (j !== i++) array[j] = element;
2005    } return array;
2006  };
2007  
2008  var merge = function (array, left, right, comparefn) {
2009    var llength = left.length;
2010    var rlength = right.length;
2011    var lindex = 0;
2012    var rindex = 0;
2013  
2014    while (lindex < llength || rindex < rlength) {
2015      array[lindex + rindex] = (lindex < llength && rindex < rlength)
2016        ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]
2017        : lindex < llength ? left[lindex++] : right[rindex++];
2018    } return array;
2019  };
2020  
2021  module.exports = mergeSort;
2022  
2023  
2024  /***/ }),
2025  /* 81 */
2026  /***/ (function(module, exports, __webpack_require__) {
2027  
2028  var uncurryThis = __webpack_require__(12);
2029  
2030  module.exports = uncurryThis([].slice);
2031  
2032  
2033  /***/ }),
2034  /* 82 */
2035  /***/ (function(module, exports, __webpack_require__) {
2036  
2037  var userAgent = __webpack_require__(25);
2038  
2039  var firefox = userAgent.match(/firefox\/(\d+)/i);
2040  
2041  module.exports = !!firefox && +firefox[1];
2042  
2043  
2044  /***/ }),
2045  /* 83 */
2046  /***/ (function(module, exports, __webpack_require__) {
2047  
2048  var UA = __webpack_require__(25);
2049  
2050  module.exports = /MSIE|Trident/.test(UA);
2051  
2052  
2053  /***/ }),
2054  /* 84 */
2055  /***/ (function(module, exports, __webpack_require__) {
2056  
2057  var userAgent = __webpack_require__(25);
2058  
2059  var webkit = userAgent.match(/AppleWebKit\/(\d+)\./);
2060  
2061  module.exports = !!webkit && +webkit[1];
2062  
2063  
2064  /***/ }),
2065  /* 85 */
2066  /***/ (function(module, exports, __webpack_require__) {
2067  
2068  var $ = __webpack_require__(2);
2069  var global = __webpack_require__(3);
2070  var task = __webpack_require__(86);
2071  
2072  var FORCED = !global.setImmediate || !global.clearImmediate;
2073  
2074  // http://w3c.github.io/setImmediate/
2075  $({ global: true, bind: true, enumerable: true, forced: FORCED }, {
2076    // `setImmediate` method
2077    // http://w3c.github.io/setImmediate/#si-setImmediate
2078    setImmediate: task.set,
2079    // `clearImmediate` method
2080    // http://w3c.github.io/setImmediate/#si-clearImmediate
2081    clearImmediate: task.clear
2082  });
2083  
2084  
2085  /***/ }),
2086  /* 86 */
2087  /***/ (function(module, exports, __webpack_require__) {
2088  
2089  var global = __webpack_require__(3);
2090  var apply = __webpack_require__(87);
2091  var bind = __webpack_require__(88);
2092  var isCallable = __webpack_require__(18);
2093  var hasOwn = __webpack_require__(35);
2094  var fails = __webpack_require__(6);
2095  var html = __webpack_require__(66);
2096  var arraySlice = __webpack_require__(81);
2097  var createElement = __webpack_require__(39);
2098  var IS_IOS = __webpack_require__(89);
2099  var IS_NODE = __webpack_require__(90);
2100  
2101  var set = global.setImmediate;
2102  var clear = global.clearImmediate;
2103  var process = global.process;
2104  var Dispatch = global.Dispatch;
2105  var Function = global.Function;
2106  var MessageChannel = global.MessageChannel;
2107  var String = global.String;
2108  var counter = 0;
2109  var queue = {};
2110  var ONREADYSTATECHANGE = 'onreadystatechange';
2111  var location, defer, channel, port;
2112  
2113  try {
2114    // Deno throws a ReferenceError on `location` access without `--location` flag
2115    location = global.location;
2116  } catch (error) { /* empty */ }
2117  
2118  var run = function (id) {
2119    if (hasOwn(queue, id)) {
2120      var fn = queue[id];
2121      delete queue[id];
2122      fn();
2123    }
2124  };
2125  
2126  var runner = function (id) {
2127    return function () {
2128      run(id);
2129    };
2130  };
2131  
2132  var listener = function (event) {
2133    run(event.data);
2134  };
2135  
2136  var post = function (id) {
2137    // old engines have not location.origin
2138    global.postMessage(String(id), location.protocol + '//' + location.host);
2139  };
2140  
2141  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
2142  if (!set || !clear) {
2143    set = function setImmediate(fn) {
2144      var args = arraySlice(arguments, 1);
2145      queue[++counter] = function () {
2146        apply(isCallable(fn) ? fn : Function(fn), undefined, args);
2147      };
2148      defer(counter);
2149      return counter;
2150    };
2151    clear = function clearImmediate(id) {
2152      delete queue[id];
2153    };
2154    // Node.js 0.8-
2155    if (IS_NODE) {
2156      defer = function (id) {
2157        process.nextTick(runner(id));
2158      };
2159    // Sphere (JS game engine) Dispatch API
2160    } else if (Dispatch && Dispatch.now) {
2161      defer = function (id) {
2162        Dispatch.now(runner(id));
2163      };
2164    // Browsers with MessageChannel, includes WebWorkers
2165    // except iOS - https://github.com/zloirock/core-js/issues/624
2166    } else if (MessageChannel && !IS_IOS) {
2167      channel = new MessageChannel();
2168      port = channel.port2;
2169      channel.port1.onmessage = listener;
2170      defer = bind(port.postMessage, port);
2171    // Browsers with postMessage, skip WebWorkers
2172    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
2173    } else if (
2174      global.addEventListener &&
2175      isCallable(global.postMessage) &&
2176      !global.importScripts &&
2177      location && location.protocol !== 'file:' &&
2178      !fails(post)
2179    ) {
2180      defer = post;
2181      global.addEventListener('message', listener, false);
2182    // IE8-
2183    } else if (ONREADYSTATECHANGE in createElement('script')) {
2184      defer = function (id) {
2185        html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
2186          html.removeChild(this);
2187          run(id);
2188        };
2189      };
2190    // Rest old browsers
2191    } else {
2192      defer = function (id) {
2193        setTimeout(runner(id), 0);
2194      };
2195    }
2196  }
2197  
2198  module.exports = {
2199    set: set,
2200    clear: clear
2201  };
2202  
2203  
2204  /***/ }),
2205  /* 87 */
2206  /***/ (function(module, exports) {
2207  
2208  var FunctionPrototype = Function.prototype;
2209  var apply = FunctionPrototype.apply;
2210  var bind = FunctionPrototype.bind;
2211  var call = FunctionPrototype.call;
2212  
2213  // eslint-disable-next-line es/no-reflect -- safe
2214  module.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {
2215    return call.apply(apply, arguments);
2216  });
2217  
2218  
2219  /***/ }),
2220  /* 88 */
2221  /***/ (function(module, exports, __webpack_require__) {
2222  
2223  var uncurryThis = __webpack_require__(12);
2224  var aCallable = __webpack_require__(27);
2225  
2226  var bind = uncurryThis(uncurryThis.bind);
2227  
2228  // optional / simple context binding
2229  module.exports = function (fn, that) {
2230    aCallable(fn);
2231    return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) {
2232      return fn.apply(that, arguments);
2233    };
2234  };
2235  
2236  
2237  /***/ }),
2238  /* 89 */
2239  /***/ (function(module, exports, __webpack_require__) {
2240  
2241  var userAgent = __webpack_require__(25);
2242  
2243  module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
2244  
2245  
2246  /***/ }),
2247  /* 90 */
2248  /***/ (function(module, exports, __webpack_require__) {
2249  
2250  var classof = __webpack_require__(13);
2251  var global = __webpack_require__(3);
2252  
2253  module.exports = classof(global.process) == 'process';
2254  
2255  
2256  /***/ })
2257  /******/ ]); }();


Generated: Fri May 20 01:00:02 2022 Cross-referenced by PHPXref 0.7.1