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