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