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