vendor: 22,939 bytes, lines 1-780
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__(71); 99__webpack_require__(72); 100__webpack_require__(85); 101__webpack_require__(109); 102module.exports = __webpack_require__(111); 103 104 105/***/ }), 106/* 1 */ 107/***/ (function(module, exports, __webpack_require__) { 108 109"use strict"; 110 111var $ = __webpack_require__(2); 112var globalThis = __webpack_require__(3); 113var apply = __webpack_require__(67); 114var slice = __webpack_require__(68); 115var newPromiseCapabilityModule = __webpack_require__(69); 116var aCallable = __webpack_require__(29); 117var perform = __webpack_require__(70); 118 119var Promise = globalThis.Promise; 120 121var ACCEPT_ARGUMENTS = false; 122// Avoiding the use of polyfills of the previous iteration of this proposal 123// that does not accept arguments of the callback 124var FORCED = !Promise || !Promise['try'] || perform(function () { 125 Promise['try'](function (argument) { 126 ACCEPT_ARGUMENTS = argument === 8; 127 }, 8); 128}).error || !ACCEPT_ARGUMENTS; 129 130// `Promise.try` method 131// https://tc39.es/ecma262/#sec-promise.try 132$({ target: 'Promise', stat: true, forced: FORCED }, { 133 'try': function (callbackfn /* , ...args */) { 134 var args = arguments.length > 1 ? slice(arguments, 1) : []; 135 var promiseCapability = newPromiseCapabilityModule.f(this); 136 var result = perform(function () { 137 return apply(aCallable(callbackfn), undefined, args); 138 }); 139 (result.error ? promiseCapability.reject : promiseCapability.resolve)(result.value); 140 return promiseCapability.promise; 141 } 142}); 143 144 145/***/ }), 146/* 2 */ 147/***/ (function(module, exports, __webpack_require__) { 148 149"use strict"; 150 151var globalThis = __webpack_require__(3); 152var getOwnPropertyDescriptor = __webpack_require__(4).f; 153var createNonEnumerableProperty = __webpack_require__(42); 154var defineBuiltIn = __webpack_require__(46); 155var defineGlobalProperty = __webpack_require__(36); 156var copyConstructorProperties = __webpack_require__(54); 157var isForced = __webpack_require__(66); 158 159/* 160 options.target - name of the target object 161 options.global - target is the global object 162 options.stat - export as static methods of target 163 options.proto - export as prototype methods of target 164 options.real - real prototype method for the `pure` version 165 options.forced - export even if the native feature is available 166 options.bind - bind methods to the target, required for the `pure` version 167 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version 168 options.unsafe - use the simple assignment of property instead of delete + defineProperty 169 options.sham - add a flag to not completely full polyfills 170 options.enumerable - export as enumerable property 171 options.dontCallGetSet - prevent calling a getter on target 172 options.name - the .name of the function if it does not match the key 173*/ 174module.exports = function (options, source) { 175 var TARGET = options.target; 176 var GLOBAL = options.global; 177 var STATIC = options.stat; 178 var FORCED, target, key, targetProperty, sourceProperty, descriptor; 179 if (GLOBAL) { 180 target = globalThis; 181 } else if (STATIC) { 182 target = globalThis[TARGET] || defineGlobalProperty(TARGET, {}); 183 } else { 184 target = globalThis[TARGET] && globalThis[TARGET].prototype; 185 } 186 if (target) for (key in source) { 187 sourceProperty = source[key]; 188 if (options.dontCallGetSet) { 189 descriptor = getOwnPropertyDescriptor(target, key); 190 targetProperty = descriptor && descriptor.value; 191 } else targetProperty = target[key]; 192 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); 193 // contained in target 194 if (!FORCED && targetProperty !== undefined) { 195 if (typeof sourceProperty == typeof targetProperty) continue; 196 copyConstructorProperties(sourceProperty, targetProperty); 197 } 198 // add a flag to not completely full polyfills 199 if (options.sham || (targetProperty && targetProperty.sham)) { 200 createNonEnumerableProperty(sourceProperty, 'sham', true); 201 } 202 defineBuiltIn(target, key, sourceProperty, options); 203 } 204}; 205 206 207/***/ }), 208/* 3 */ 209/***/ (function(module, exports, __webpack_require__) { 210 211"use strict"; 212 213var check = function (it) { 214 return it && it.Math === Math && it; 215}; 216 217// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 218module.exports = 219 // eslint-disable-next-line es/no-global-this -- safe 220 check(typeof globalThis == 'object' && globalThis) || 221 check(typeof window == 'object' && window) || 222 // eslint-disable-next-line no-restricted-globals -- safe 223 check(typeof self == 'object' && self) || 224 check(typeof global == 'object' && global) || 225 check(typeof this == 'object' && this) || 226 // eslint-disable-next-line no-new-func -- fallback 227 (function () { return this; })() || Function('return this')(); 228 229 230/***/ }), 231/* 4 */ 232/***/ (function(module, exports, __webpack_require__) { 233 234"use strict"; 235 236var DESCRIPTORS = __webpack_require__(5); 237var call = __webpack_require__(7); 238var propertyIsEnumerableModule = __webpack_require__(9); 239var createPropertyDescriptor = __webpack_require__(10); 240var toIndexedObject = __webpack_require__(11); 241var toPropertyKey = __webpack_require__(17); 242var hasOwn = __webpack_require__(37); 243var IE8_DOM_DEFINE = __webpack_require__(40); 244 245// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 246var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 247 248// `Object.getOwnPropertyDescriptor` method 249// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor 250exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { 251 O = toIndexedObject(O); 252 P = toPropertyKey(P); 253 if (IE8_DOM_DEFINE) try { 254 return $getOwnPropertyDescriptor(O, P); 255 } catch (error) { /* empty */ } 256 if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); 257}; 258 259 260/***/ }), 261/* 5 */ 262/***/ (function(module, exports, __webpack_require__) { 263 264"use strict"; 265 266var fails = __webpack_require__(6); 267 268// Detect IE8's incomplete defineProperty implementation 269module.exports = !fails(function () { 270 // eslint-disable-next-line es/no-object-defineproperty -- required for testing 271 return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; 272}); 273 274 275/***/ }), 276/* 6 */ 277/***/ (function(module, exports, __webpack_require__) { 278 279"use strict"; 280 281module.exports = function (exec) { 282 try { 283 return !!exec(); 284 } catch (error) { 285 return true; 286 } 287}; 288 289 290/***/ }), 291/* 7 */ 292/***/ (function(module, exports, __webpack_require__) { 293 294"use strict"; 295 296var NATIVE_BIND = __webpack_require__(8); 297 298var call = Function.prototype.call; 299 300module.exports = NATIVE_BIND ? call.bind(call) : function () { 301 return call.apply(call, arguments); 302}; 303 304 305/***/ }), 306/* 8 */ 307/***/ (function(module, exports, __webpack_require__) { 308 309"use strict"; 310 311var fails = __webpack_require__(6); 312 313module.exports = !fails(function () { 314 // eslint-disable-next-line es/no-function-prototype-bind -- safe 315 var test = (function () { /* empty */ }).bind(); 316 // eslint-disable-next-line no-prototype-builtins -- safe 317 return typeof test != 'function' || test.hasOwnProperty('prototype'); 318}); 319 320 321/***/ }), 322/* 9 */ 323/***/ (function(module, exports, __webpack_require__) { 324 325"use strict"; 326 327var $propertyIsEnumerable = {}.propertyIsEnumerable; 328// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 329var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 330 331// Nashorn ~ JDK8 bug 332var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); 333 334// `Object.prototype.propertyIsEnumerable` method implementation 335// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable 336exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { 337 var descriptor = getOwnPropertyDescriptor(this, V); 338 return !!descriptor && descriptor.enumerable; 339} : $propertyIsEnumerable; 340 341 342/***/ }), 343/* 10 */ 344/***/ (function(module, exports, __webpack_require__) { 345 346"use strict"; 347 348module.exports = function (bitmap, value) { 349 return { 350 enumerable: !(bitmap & 1), 351 configurable: !(bitmap & 2), 352 writable: !(bitmap & 4), 353 value: value 354 }; 355}; 356 357 358/***/ }), 359/* 11 */ 360/***/ (function(module, exports, __webpack_require__) { 361 362"use strict"; 363 364// toObject with fallback for non-array-like ES3 strings 365var IndexedObject = __webpack_require__(12); 366var requireObjectCoercible = __webpack_require__(15); 367 368module.exports = function (it) { 369 return IndexedObject(requireObjectCoercible(it)); 370}; 371 372 373/***/ }), 374/* 12 */ 375/***/ (function(module, exports, __webpack_require__) { 376 377"use strict"; 378 379var uncurryThis = __webpack_require__(13); 380var fails = __webpack_require__(6); 381var classof = __webpack_require__(14); 382 383var $Object = Object; 384var split = uncurryThis(''.split); 385 386// fallback for non-array-like ES3 and non-enumerable old V8 strings 387module.exports = fails(function () { 388 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 389 // eslint-disable-next-line no-prototype-builtins -- safe 390 return !$Object('z').propertyIsEnumerable(0); 391}) ? function (it) { 392 return classof(it) === 'String' ? split(it, '') : $Object(it); 393} : $Object; 394 395 396/***/ }), 397/* 13 */ 398/***/ (function(module, exports, __webpack_require__) { 399 400"use strict"; 401 402var NATIVE_BIND = __webpack_require__(8); 403 404var FunctionPrototype = Function.prototype; 405var call = FunctionPrototype.call; 406var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call); 407 408module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) { 409 return function () { 410 return call.apply(fn, arguments); 411 }; 412}; 413 414 415/***/ }), 416/* 14 */ 417/***/ (function(module, exports, __webpack_require__) { 418 419"use strict"; 420 421var uncurryThis = __webpack_require__(13); 422 423var toString = uncurryThis({}.toString); 424var stringSlice = uncurryThis(''.slice); 425 426module.exports = function (it) { 427 return stringSlice(toString(it), 8, -1); 428}; 429 430 431/***/ }), 432/* 15 */ 433/***/ (function(module, exports, __webpack_require__) { 434 435"use strict"; 436 437var isNullOrUndefined = __webpack_require__(16); 438 439var $TypeError = TypeError; 440 441// `RequireObjectCoercible` abstract operation 442// https://tc39.es/ecma262/#sec-requireobjectcoercible 443module.exports = function (it) { 444 if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it); 445 return it; 446}; 447 448 449/***/ }), 450/* 16 */ 451/***/ (function(module, exports, __webpack_require__) { 452 453"use strict"; 454 455// we can't use just `it == null` since of `document.all` special case 456// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec 457module.exports = function (it) { 458 return it === null || it === undefined; 459}; 460 461 462/***/ }), 463/* 17 */ 464/***/ (function(module, exports, __webpack_require__) { 465 466"use strict"; 467 468var toPrimitive = __webpack_require__(18); 469var isSymbol = __webpack_require__(21); 470 471// `ToPropertyKey` abstract operation 472// https://tc39.es/ecma262/#sec-topropertykey 473module.exports = function (argument) { 474 var key = toPrimitive(argument, 'string'); 475 return isSymbol(key) ? key : key + ''; 476}; 477 478 479/***/ }), 480/* 18 */ 481/***/ (function(module, exports, __webpack_require__) { 482 483"use strict"; 484 485var call = __webpack_require__(7); 486var isObject = __webpack_require__(19); 487var isSymbol = __webpack_require__(21); 488var getMethod = __webpack_require__(28); 489var ordinaryToPrimitive = __webpack_require__(31); 490var wellKnownSymbol = __webpack_require__(32); 491 492var $TypeError = TypeError; 493var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); 494 495// `ToPrimitive` abstract operation 496// https://tc39.es/ecma262/#sec-toprimitive 497module.exports = function (input, pref) { 498 if (!isObject(input) || isSymbol(input)) return input; 499 var exoticToPrim = getMethod(input, TO_PRIMITIVE); 500 var result; 501 if (exoticToPrim) { 502 if (pref === undefined) pref = 'default'; 503 result = call(exoticToPrim, input, pref); 504 if (!isObject(result) || isSymbol(result)) return result; 505 throw new $TypeError("Can't convert object to primitive value"); 506 } 507 if (pref === undefined) pref = 'number'; 508 return ordinaryToPrimitive(input, pref); 509}; 510 511 512/***/ }), 513/* 19 */ 514/***/ (function(module, exports, __webpack_require__) { 515 516"use strict"; 517 518var isCallable = __webpack_require__(20); 519 520module.exports = function (it) { 521 return typeof it == 'object' ? it !== null : isCallable(it); 522}; 523 524 525/***/ }), 526/* 20 */ 527/***/ (function(module, exports, __webpack_require__) { 528 529"use strict"; 530 531// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot 532var documentAll = typeof document == 'object' && document.all; 533 534// `IsCallable` abstract operation 535// https://tc39.es/ecma262/#sec-iscallable 536// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing 537module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) { 538 return typeof argument == 'function' || argument === documentAll; 539} : function (argument) { 540 return typeof argument == 'function'; 541}; 542 543 544/***/ }), 545/* 21 */ 546/***/ (function(module, exports, __webpack_require__) { 547 548"use strict"; 549 550var getBuiltIn = __webpack_require__(22); 551var isCallable = __webpack_require__(20); 552var isPrototypeOf = __webpack_require__(23); 553var USE_SYMBOL_AS_UID = __webpack_require__(24); 554 555var $Object = Object; 556 557module.exports = USE_SYMBOL_AS_UID ? function (it) { 558 return typeof it == 'symbol'; 559} : function (it) { 560 var $Symbol = getBuiltIn('Symbol'); 561 return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it)); 562}; 563 564 565/***/ }), 566/* 22 */ 567/***/ (function(module, exports, __webpack_require__) { 568 569"use strict"; 570 571var globalThis = __webpack_require__(3); 572var isCallable = __webpack_require__(20); 573 574var aFunction = function (argument) { 575 return isCallable(argument) ? argument : undefined; 576}; 577 578module.exports = function (namespace, method) { 579 return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method]; 580}; 581 582 583/***/ }), 584/* 23 */ 585/***/ (function(module, exports, __webpack_require__) { 586 587"use strict"; 588 589var uncurryThis = __webpack_require__(13); 590 591module.exports = uncurryThis({}.isPrototypeOf); 592 593 594/***/ }), 595/* 24 */ 596/***/ (function(module, exports, __webpack_require__) { 597 598"use strict"; 599 600/* eslint-disable es/no-symbol -- required for testing */ 601var NATIVE_SYMBOL = __webpack_require__(25); 602 603module.exports = NATIVE_SYMBOL && 604 !Symbol.sham && 605 typeof Symbol.iterator == 'symbol'; 606 607 608/***/ }), 609/* 25 */ 610/***/ (function(module, exports, __webpack_require__) { 611 612"use strict"; 613 614/* eslint-disable es/no-symbol -- required for testing */ 615var V8_VERSION = __webpack_require__(26); 616var fails = __webpack_require__(6); 617var globalThis = __webpack_require__(3); 618 619var $String = globalThis.String; 620 621// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing 622module.exports = !!Object.getOwnPropertySymbols && !fails(function () { 623 var symbol = Symbol('symbol detection'); 624 // Chrome 38 Symbol has incorrect toString conversion 625 // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances 626 // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, 627 // of course, fail. 628 return !$String(symbol) || !(Object(symbol) instanceof Symbol) || 629 // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances 630 !Symbol.sham && V8_VERSION && V8_VERSION < 41; 631}); 632 633 634/***/ }), 635/* 26 */ 636/***/ (function(module, exports, __webpack_require__) { 637 638"use strict"; 639 640var globalThis = __webpack_require__(3); 641var userAgent = __webpack_require__(27); 642 643var process = globalThis.process; 644var Deno = globalThis.Deno; 645var versions = process && process.versions || Deno && Deno.version; 646var v8 = versions && versions.v8; 647var match, version; 648 649if (v8) { 650 match = v8.split('.'); 651 // in old Chrome, versions of V8 isn't V8 = Chrome / 10 652 // but their correct versions are not interesting for us 653 version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); 654} 655 656// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` 657// so check `userAgent` even if `.v8` exists, but 0 658if (!version && userAgent) { 659 match = userAgent.match(/Edge\/(\d+)/); 660 if (!match || match[1] >= 74) { 661 match = userAgent.match(/Chrome\/(\d+)/); 662 if (match) version = +match[1]; 663 } 664} 665 666module.exports = version; 667 668 669/***/ }), 670/* 27 */ 671/***/ (function(module, exports, __webpack_require__) { 672 673"use strict"; 674 675var globalThis = __webpack_require__(3); 676 677var navigator = globalThis.navigator; 678var userAgent = navigator && navigator.userAgent; 679 680module.exports = userAgent ? String(userAgent) : ''; 681 682 683/***/ }), 684/* 28 */ 685/***/ (function(module, exports, __webpack_require__) { 686 687"use strict"; 688 689var aCallable = __webpack_require__(29); 690var isNullOrUndefined = __webpack_require__(16); 691 692// `GetMethod` abstract operation 693// https://tc39.es/ecma262/#sec-getmethod 694module.exports = function (V, P) { 695 var func = V[P]; 696 return isNullOrUndefined(func) ? undefined : aCallable(func); 697}; 698 699 700/***/ }), 701/* 29 */ 702/***/ (function(module, exports, __webpack_require__) { 703 704"use strict"; 705 706var isCallable = __webpack_require__(20); 707var tryToString = __webpack_require__(30); 708 709var $TypeError = TypeError; 710 711// `Assert: IsCallable(argument) is true` 712module.exports = function (argument) { 713 if (isCallable(argument)) return argument; 714 throw new $TypeError(tryToString(argument) + ' is not a function'); 715}; 716 717 718/***/ }), 719/* 30 */ 720/***/ (function(module, exports, __webpack_require__) { 721 722"use strict"; 723 724var $String = String; 725 726module.exports = function (argument) { 727 try { 728 return $String(argument); 729 } catch (error) { 730 return 'Object'; 731 } 732}; 733 734 735/***/ }), 736/* 31 */ 737/***/ (function(module, exports, __webpack_require__) { 738 739"use strict"; 740 741var call = __webpack_require__(7); 742var isCallable = __webpack_require__(20); 743var isObject = __webpack_require__(19); 744 745var $TypeError = TypeError; 746 747// `OrdinaryToPrimitive` abstract operation 748// https://tc39.es/ecma262/#sec-ordinarytoprimitive 749module.exports = function (input, pref) { 750 var fn, val; 751 if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; 752 if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val; 753 if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; 754 throw new $TypeError("Can't convert object to primitive value"); 755}; 756 757 758/***/ }), 759/* 32 */ 760/***/ (function(module, exports, __webpack_require__) { 761 762"use strict"; 763 764var globalThis = __webpack_require__(3); 765var shared = __webpack_require__(33); 766var hasOwn = __webpack_require__(37); 767var uid = __webpack_require__(39); 768var NATIVE_SYMBOL = __webpack_require__(25); 769var USE_SYMBOL_AS_UID = __webpack_require__(24); 770 771var Symbol = globalThis.Symbol; 772var WellKnownSymbolsStore = shared('wks'); 773var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid; 774 775module.exports = function (name) { 776 if (!hasOwn(WellKnownSymbolsStore, name)) { 777 WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) 778 ? Symbol[name] 779 : createWellKnownSymbol('Symbol.' + name); 780 }
vendor: 4,643 bytes, lines 780-972
780 return WellKnownSymbolsStore[name]; 781}; 782 783 784/***/ }), 785/* 33 */ 786/***/ (function(module, exports, __webpack_require__) { 787 788"use strict"; 789 790var store = __webpack_require__(34); 791 792module.exports = function (key, value) { 793 return store[key] || (store[key] = value || {}); 794}; 795 796 797/***/ }), 798/* 34 */ 799/***/ (function(module, exports, __webpack_require__) { 800 801"use strict"; 802 803var IS_PURE = __webpack_require__(35); 804var globalThis = __webpack_require__(3); 805var defineGlobalProperty = __webpack_require__(36); 806 807var SHARED = '__core-js_shared__'; 808var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {}); 809 810(store.versions || (store.versions = [])).push({ 811 version: '3.39.0', 812 mode: IS_PURE ? 'pure' : 'global', 813 copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)', 814 license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE', 815 source: 'https://github.com/zloirock/core-js' 816}); 817 818 819/***/ }), 820/* 35 */ 821/***/ (function(module, exports, __webpack_require__) { 822 823"use strict"; 824 825module.exports = false; 826 827 828/***/ }), 829/* 36 */ 830/***/ (function(module, exports, __webpack_require__) { 831 832"use strict"; 833 834var globalThis = __webpack_require__(3); 835 836// eslint-disable-next-line es/no-object-defineproperty -- safe 837var defineProperty = Object.defineProperty; 838 839module.exports = function (key, value) { 840 try { 841 defineProperty(globalThis, key, { value: value, configurable: true, writable: true }); 842 } catch (error) { 843 globalThis[key] = value; 844 } return value; 845}; 846 847 848/***/ }), 849/* 37 */ 850/***/ (function(module, exports, __webpack_require__) { 851 852"use strict"; 853 854var uncurryThis = __webpack_require__(13); 855var toObject = __webpack_require__(38); 856 857var hasOwnProperty = uncurryThis({}.hasOwnProperty); 858 859// `HasOwnProperty` abstract operation 860// https://tc39.es/ecma262/#sec-hasownproperty 861// eslint-disable-next-line es/no-object-hasown -- safe 862module.exports = Object.hasOwn || function hasOwn(it, key) { 863 return hasOwnProperty(toObject(it), key); 864}; 865 866 867/***/ }), 868/* 38 */ 869/***/ (function(module, exports, __webpack_require__) { 870 871"use strict"; 872 873var requireObjectCoercible = __webpack_require__(15); 874 875var $Object = Object; 876 877// `ToObject` abstract operation 878// https://tc39.es/ecma262/#sec-toobject 879module.exports = function (argument) { 880 return $Object(requireObjectCoercible(argument)); 881}; 882 883 884/***/ }), 885/* 39 */ 886/***/ (function(module, exports, __webpack_require__) { 887 888"use strict"; 889 890var uncurryThis = __webpack_require__(13); 891 892var id = 0; 893var postfix = Math.random(); 894var toString = uncurryThis(1.0.toString); 895 896module.exports = function (key) { 897 return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36); 898}; 899 900 901/***/ }), 902/* 40 */ 903/***/ (function(module, exports, __webpack_require__) { 904 905"use strict"; 906 907var DESCRIPTORS = __webpack_require__(5); 908var fails = __webpack_require__(6); 909var createElement = __webpack_require__(41); 910 911// Thanks to IE8 for its funny defineProperty 912module.exports = !DESCRIPTORS && !fails(function () { 913 // eslint-disable-next-line es/no-object-defineproperty -- required for testing 914 return Object.defineProperty(createElement('div'), 'a', { 915 get: function () { return 7; } 916 }).a !== 7; 917}); 918 919 920/***/ }), 921/* 41 */ 922/***/ (function(module, exports, __webpack_require__) { 923 924"use strict"; 925 926var globalThis = __webpack_require__(3); 927var isObject = __webpack_require__(19); 928 929var document = globalThis.document; 930// typeof document.createElement is 'object' in old IE 931var EXISTS = isObject(document) && isObject(document.createElement); 932 933module.exports = function (it) { 934 return EXISTS ? document.createElement(it) : {}; 935}; 936 937 938/***/ }), 939/* 42 */ 940/***/ (function(module, exports, __webpack_require__) { 941 942"use strict"; 943 944var DESCRIPTORS = __webpack_require__(5); 945var definePropertyModule = __webpack_require__(43); 946var createPropertyDescriptor = __webpack_require__(10); 947 948module.exports = DESCRIPTORS ? function (object, key, value) { 949 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); 950} : function (object, key, value) { 951 object[key] = value; 952 return object; 953}; 954 955 956/***/ }), 957/* 43 */ 958/***/ (function(module, exports, __webpack_require__) { 959 960"use strict"; 961 962var DESCRIPTORS = __webpack_require__(5); 963var IE8_DOM_DEFINE = __webpack_require__(40); 964var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(44); 965var anObject = __webpack_require__(45); 966var toPropertyKey = __webpack_require__(17); 967 968var $TypeError = TypeError; 969// eslint-disable-next-line es/no-object-defineproperty -- safe 970var $defineProperty = Object.defineProperty; 971// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 972var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
vendor: 19,857 bytes, lines 973-1699
973var ENUMERABLE = 'enumerable'; 974var CONFIGURABLE = 'configurable'; 975var WRITABLE = 'writable'; 976 977// `Object.defineProperty` method 978// https://tc39.es/ecma262/#sec-object.defineproperty 979exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) { 980 anObject(O); 981 P = toPropertyKey(P); 982 anObject(Attributes); 983 if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { 984 var current = $getOwnPropertyDescriptor(O, P); 985 if (current && current[WRITABLE]) { 986 O[P] = Attributes.value; 987 Attributes = { 988 configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], 989 enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], 990 writable: false 991 }; 992 } 993 } return $defineProperty(O, P, Attributes); 994} : $defineProperty : function defineProperty(O, P, Attributes) { 995 anObject(O); 996 P = toPropertyKey(P); 997 anObject(Attributes); 998 if (IE8_DOM_DEFINE) try { 999 return $defineProperty(O, P, Attributes); 1000 } catch (error) { /* empty */ } 1001 if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported'); 1002 if ('value' in Attributes) O[P] = Attributes.value; 1003 return O; 1004}; 1005 1006 1007/***/ }), 1008/* 44 */ 1009/***/ (function(module, exports, __webpack_require__) { 1010 1011"use strict"; 1012 1013var DESCRIPTORS = __webpack_require__(5); 1014var fails = __webpack_require__(6); 1015 1016// V8 ~ Chrome 36- 1017// https://bugs.chromium.org/p/v8/issues/detail?id=3334 1018module.exports = DESCRIPTORS && fails(function () { 1019 // eslint-disable-next-line es/no-object-defineproperty -- required for testing 1020 return Object.defineProperty(function () { /* empty */ }, 'prototype', { 1021 value: 42, 1022 writable: false 1023 }).prototype !== 42; 1024}); 1025 1026 1027/***/ }), 1028/* 45 */ 1029/***/ (function(module, exports, __webpack_require__) { 1030 1031"use strict"; 1032 1033var isObject = __webpack_require__(19); 1034 1035var $String = String; 1036var $TypeError = TypeError; 1037 1038// `Assert: Type(argument) is Object` 1039module.exports = function (argument) { 1040 if (isObject(argument)) return argument; 1041 throw new $TypeError($String(argument) + ' is not an object'); 1042}; 1043 1044 1045/***/ }), 1046/* 46 */ 1047/***/ (function(module, exports, __webpack_require__) { 1048 1049"use strict"; 1050 1051var isCallable = __webpack_require__(20); 1052var definePropertyModule = __webpack_require__(43); 1053var makeBuiltIn = __webpack_require__(47); 1054var defineGlobalProperty = __webpack_require__(36); 1055 1056module.exports = function (O, key, value, options) { 1057 if (!options) options = {}; 1058 var simple = options.enumerable; 1059 var name = options.name !== undefined ? options.name : key; 1060 if (isCallable(value)) makeBuiltIn(value, name, options); 1061 if (options.global) { 1062 if (simple) O[key] = value; 1063 else defineGlobalProperty(key, value); 1064 } else { 1065 try { 1066 if (!options.unsafe) delete O[key]; 1067 else if (O[key]) simple = true; 1068 } catch (error) { /* empty */ } 1069 if (simple) O[key] = value; 1070 else definePropertyModule.f(O, key, { 1071 value: value, 1072 enumerable: false, 1073 configurable: !options.nonConfigurable, 1074 writable: !options.nonWritable 1075 }); 1076 } return O; 1077}; 1078 1079 1080/***/ }), 1081/* 47 */ 1082/***/ (function(module, exports, __webpack_require__) { 1083 1084"use strict"; 1085 1086var uncurryThis = __webpack_require__(13); 1087var fails = __webpack_require__(6); 1088var isCallable = __webpack_require__(20); 1089var hasOwn = __webpack_require__(37); 1090var DESCRIPTORS = __webpack_require__(5); 1091var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(48).CONFIGURABLE; 1092var inspectSource = __webpack_require__(49); 1093var InternalStateModule = __webpack_require__(50); 1094 1095var enforceInternalState = InternalStateModule.enforce; 1096var getInternalState = InternalStateModule.get; 1097var $String = String; 1098// eslint-disable-next-line es/no-object-defineproperty -- safe 1099var defineProperty = Object.defineProperty; 1100var stringSlice = uncurryThis(''.slice); 1101var replace = uncurryThis(''.replace); 1102var join = uncurryThis([].join); 1103 1104var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () { 1105 return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; 1106}); 1107 1108var TEMPLATE = String(String).split('String'); 1109 1110var makeBuiltIn = module.exports = function (value, name, options) { 1111 if (stringSlice($String(name), 0, 7) === 'Symbol(') { 1112 name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']'; 1113 } 1114 if (options && options.getter) name = 'get ' + name; 1115 if (options && options.setter) name = 'set ' + name; 1116 if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) { 1117 if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true }); 1118 else value.name = name; 1119 } 1120 if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) { 1121 defineProperty(value, 'length', { value: options.arity }); 1122 } 1123 try { 1124 if (options && hasOwn(options, 'constructor') && options.constructor) { 1125 if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false }); 1126 // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable 1127 } else if (value.prototype) value.prototype = undefined; 1128 } catch (error) { /* empty */ } 1129 var state = enforceInternalState(value); 1130 if (!hasOwn(state, 'source')) { 1131 state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); 1132 } return value; 1133}; 1134 1135// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative 1136// eslint-disable-next-line no-extend-native -- required 1137Function.prototype.toString = makeBuiltIn(function toString() { 1138 return isCallable(this) && getInternalState(this).source || inspectSource(this); 1139}, 'toString'); 1140 1141 1142/***/ }), 1143/* 48 */ 1144/***/ (function(module, exports, __webpack_require__) { 1145 1146"use strict"; 1147 1148var DESCRIPTORS = __webpack_require__(5); 1149var hasOwn = __webpack_require__(37); 1150 1151var FunctionPrototype = Function.prototype; 1152// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 1153var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor; 1154 1155var EXISTS = hasOwn(FunctionPrototype, 'name'); 1156// additional protection from minified / mangled / dropped function names 1157var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; 1158var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable)); 1159 1160module.exports = { 1161 EXISTS: EXISTS, 1162 PROPER: PROPER, 1163 CONFIGURABLE: CONFIGURABLE 1164}; 1165 1166 1167/***/ }), 1168/* 49 */ 1169/***/ (function(module, exports, __webpack_require__) { 1170 1171"use strict"; 1172 1173var uncurryThis = __webpack_require__(13); 1174var isCallable = __webpack_require__(20); 1175var store = __webpack_require__(34); 1176 1177var functionToString = uncurryThis(Function.toString); 1178 1179// this helper broken in `[email protected]`, so we can't use `shared` helper 1180if (!isCallable(store.inspectSource)) { 1181 store.inspectSource = function (it) { 1182 return functionToString(it); 1183 }; 1184} 1185 1186module.exports = store.inspectSource; 1187 1188 1189/***/ }), 1190/* 50 */ 1191/***/ (function(module, exports, __webpack_require__) { 1192 1193"use strict"; 1194 1195var NATIVE_WEAK_MAP = __webpack_require__(51); 1196var globalThis = __webpack_require__(3); 1197var isObject = __webpack_require__(19); 1198var createNonEnumerableProperty = __webpack_require__(42); 1199var hasOwn = __webpack_require__(37); 1200var shared = __webpack_require__(34); 1201var sharedKey = __webpack_require__(52); 1202var hiddenKeys = __webpack_require__(53); 1203 1204var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; 1205var TypeError = globalThis.TypeError; 1206var WeakMap = globalThis.WeakMap; 1207var set, get, has; 1208 1209var enforce = function (it) { 1210 return has(it) ? get(it) : set(it, {}); 1211}; 1212 1213var getterFor = function (TYPE) { 1214 return function (it) { 1215 var state; 1216 if (!isObject(it) || (state = get(it)).type !== TYPE) { 1217 throw new TypeError('Incompatible receiver, ' + TYPE + ' required'); 1218 } return state; 1219 }; 1220}; 1221 1222if (NATIVE_WEAK_MAP || shared.state) { 1223 var store = shared.state || (shared.state = new WeakMap()); 1224 /* eslint-disable no-self-assign -- prototype methods protection */ 1225 store.get = store.get; 1226 store.has = store.has; 1227 store.set = store.set; 1228 /* eslint-enable no-self-assign -- prototype methods protection */ 1229 set = function (it, metadata) { 1230 if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); 1231 metadata.facade = it; 1232 store.set(it, metadata); 1233 return metadata; 1234 }; 1235 get = function (it) { 1236 return store.get(it) || {}; 1237 }; 1238 has = function (it) { 1239 return store.has(it); 1240 }; 1241} else { 1242 var STATE = sharedKey('state'); 1243 hiddenKeys[STATE] = true; 1244 set = function (it, metadata) { 1245 if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); 1246 metadata.facade = it; 1247 createNonEnumerableProperty(it, STATE, metadata); 1248 return metadata; 1249 }; 1250 get = function (it) { 1251 return hasOwn(it, STATE) ? it[STATE] : {}; 1252 }; 1253 has = function (it) { 1254 return hasOwn(it, STATE); 1255 }; 1256} 1257 1258module.exports = { 1259 set: set, 1260 get: get, 1261 has: has, 1262 enforce: enforce, 1263 getterFor: getterFor 1264}; 1265 1266 1267/***/ }), 1268/* 51 */ 1269/***/ (function(module, exports, __webpack_require__) { 1270 1271"use strict"; 1272 1273var globalThis = __webpack_require__(3); 1274var isCallable = __webpack_require__(20); 1275 1276var WeakMap = globalThis.WeakMap; 1277 1278module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap)); 1279 1280 1281/***/ }), 1282/* 52 */ 1283/***/ (function(module, exports, __webpack_require__) { 1284 1285"use strict"; 1286 1287var shared = __webpack_require__(33); 1288var uid = __webpack_require__(39); 1289 1290var keys = shared('keys'); 1291 1292module.exports = function (key) { 1293 return keys[key] || (keys[key] = uid(key)); 1294}; 1295 1296 1297/***/ }), 1298/* 53 */ 1299/***/ (function(module, exports, __webpack_require__) { 1300 1301"use strict"; 1302 1303module.exports = {}; 1304 1305 1306/***/ }), 1307/* 54 */ 1308/***/ (function(module, exports, __webpack_require__) { 1309 1310"use strict"; 1311 1312var hasOwn = __webpack_require__(37); 1313var ownKeys = __webpack_require__(55); 1314var getOwnPropertyDescriptorModule = __webpack_require__(4); 1315var definePropertyModule = __webpack_require__(43); 1316 1317module.exports = function (target, source, exceptions) { 1318 var keys = ownKeys(source); 1319 var defineProperty = definePropertyModule.f; 1320 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; 1321 for (var i = 0; i < keys.length; i++) { 1322 var key = keys[i]; 1323 if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) { 1324 defineProperty(target, key, getOwnPropertyDescriptor(source, key)); 1325 } 1326 } 1327}; 1328 1329 1330/***/ }), 1331/* 55 */ 1332/***/ (function(module, exports, __webpack_require__) { 1333 1334"use strict"; 1335 1336var getBuiltIn = __webpack_require__(22); 1337var uncurryThis = __webpack_require__(13); 1338var getOwnPropertyNamesModule = __webpack_require__(56); 1339var getOwnPropertySymbolsModule = __webpack_require__(65); 1340var anObject = __webpack_require__(45); 1341 1342var concat = uncurryThis([].concat); 1343 1344// all object keys, includes non-enumerable and symbols 1345module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { 1346 var keys = getOwnPropertyNamesModule.f(anObject(it)); 1347 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; 1348 return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys; 1349}; 1350 1351 1352/***/ }), 1353/* 56 */ 1354/***/ (function(module, exports, __webpack_require__) { 1355 1356"use strict"; 1357 1358var internalObjectKeys = __webpack_require__(57); 1359var enumBugKeys = __webpack_require__(64); 1360 1361var hiddenKeys = enumBugKeys.concat('length', 'prototype'); 1362 1363// `Object.getOwnPropertyNames` method 1364// https://tc39.es/ecma262/#sec-object.getownpropertynames 1365// eslint-disable-next-line es/no-object-getownpropertynames -- safe 1366exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { 1367 return internalObjectKeys(O, hiddenKeys); 1368}; 1369 1370 1371/***/ }), 1372/* 57 */ 1373/***/ (function(module, exports, __webpack_require__) { 1374 1375"use strict"; 1376 1377var uncurryThis = __webpack_require__(13); 1378var hasOwn = __webpack_require__(37); 1379var toIndexedObject = __webpack_require__(11); 1380var indexOf = __webpack_require__(58).indexOf; 1381var hiddenKeys = __webpack_require__(53); 1382 1383var push = uncurryThis([].push); 1384 1385module.exports = function (object, names) { 1386 var O = toIndexedObject(object); 1387 var i = 0; 1388 var result = []; 1389 var key; 1390 for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key); 1391 // Don't enum bug & hidden keys 1392 while (names.length > i) if (hasOwn(O, key = names[i++])) { 1393 ~indexOf(result, key) || push(result, key); 1394 } 1395 return result; 1396}; 1397 1398 1399/***/ }), 1400/* 58 */ 1401/***/ (function(module, exports, __webpack_require__) { 1402 1403"use strict"; 1404 1405var toIndexedObject = __webpack_require__(11); 1406var toAbsoluteIndex = __webpack_require__(59); 1407var lengthOfArrayLike = __webpack_require__(62); 1408 1409// `Array.prototype.{ indexOf, includes }` methods implementation 1410var createMethod = function (IS_INCLUDES) { 1411 return function ($this, el, fromIndex) { 1412 var O = toIndexedObject($this); 1413 var length = lengthOfArrayLike(O); 1414 if (length === 0) return !IS_INCLUDES && -1; 1415 var index = toAbsoluteIndex(fromIndex, length); 1416 var value; 1417 // Array#includes uses SameValueZero equality algorithm 1418 // eslint-disable-next-line no-self-compare -- NaN check 1419 if (IS_INCLUDES && el !== el) while (length > index) { 1420 value = O[index++]; 1421 // eslint-disable-next-line no-self-compare -- NaN check 1422 if (value !== value) return true; 1423 // Array#indexOf ignores holes, Array#includes - not 1424 } else for (;length > index; index++) { 1425 if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; 1426 } return !IS_INCLUDES && -1; 1427 }; 1428}; 1429 1430module.exports = { 1431 // `Array.prototype.includes` method 1432 // https://tc39.es/ecma262/#sec-array.prototype.includes 1433 includes: createMethod(true), 1434 // `Array.prototype.indexOf` method 1435 // https://tc39.es/ecma262/#sec-array.prototype.indexof 1436 indexOf: createMethod(false) 1437}; 1438 1439 1440/***/ }), 1441/* 59 */ 1442/***/ (function(module, exports, __webpack_require__) { 1443 1444"use strict"; 1445 1446var toIntegerOrInfinity = __webpack_require__(60); 1447 1448var max = Math.max; 1449var min = Math.min; 1450 1451// Helper for a popular repeating case of the spec: 1452// Let integer be ? ToInteger(index). 1453// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). 1454module.exports = function (index, length) { 1455 var integer = toIntegerOrInfinity(index); 1456 return integer < 0 ? max(integer + length, 0) : min(integer, length); 1457}; 1458 1459 1460/***/ }), 1461/* 60 */ 1462/***/ (function(module, exports, __webpack_require__) { 1463 1464"use strict"; 1465 1466var trunc = __webpack_require__(61); 1467 1468// `ToIntegerOrInfinity` abstract operation 1469// https://tc39.es/ecma262/#sec-tointegerorinfinity 1470module.exports = function (argument) { 1471 var number = +argument; 1472 // eslint-disable-next-line no-self-compare -- NaN check 1473 return number !== number || number === 0 ? 0 : trunc(number); 1474}; 1475 1476 1477/***/ }), 1478/* 61 */ 1479/***/ (function(module, exports, __webpack_require__) { 1480 1481"use strict"; 1482 1483var ceil = Math.ceil; 1484var floor = Math.floor; 1485 1486// `Math.trunc` method 1487// https://tc39.es/ecma262/#sec-math.trunc 1488// eslint-disable-next-line es/no-math-trunc -- safe 1489module.exports = Math.trunc || function trunc(x) { 1490 var n = +x; 1491 return (n > 0 ? floor : ceil)(n); 1492}; 1493 1494 1495/***/ }), 1496/* 62 */ 1497/***/ (function(module, exports, __webpack_require__) { 1498 1499"use strict"; 1500 1501var toLength = __webpack_require__(63); 1502 1503// `LengthOfArrayLike` abstract operation 1504// https://tc39.es/ecma262/#sec-lengthofarraylike 1505module.exports = function (obj) { 1506 return toLength(obj.length); 1507}; 1508 1509 1510/***/ }), 1511/* 63 */ 1512/***/ (function(module, exports, __webpack_require__) { 1513 1514"use strict"; 1515 1516var toIntegerOrInfinity = __webpack_require__(60); 1517 1518var min = Math.min; 1519 1520// `ToLength` abstract operation 1521// https://tc39.es/ecma262/#sec-tolength 1522module.exports = function (argument) { 1523 var len = toIntegerOrInfinity(argument); 1524 return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 1525}; 1526 1527 1528/***/ }), 1529/* 64 */ 1530/***/ (function(module, exports, __webpack_require__) { 1531 1532"use strict"; 1533 1534// IE8- don't enum bug keys 1535module.exports = [ 1536 'constructor', 1537 'hasOwnProperty', 1538 'isPrototypeOf', 1539 'propertyIsEnumerable', 1540 'toLocaleString', 1541 'toString', 1542 'valueOf' 1543]; 1544 1545 1546/***/ }), 1547/* 65 */ 1548/***/ (function(module, exports, __webpack_require__) { 1549 1550"use strict"; 1551 1552// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe 1553exports.f = Object.getOwnPropertySymbols; 1554 1555 1556/***/ }), 1557/* 66 */ 1558/***/ (function(module, exports, __webpack_require__) { 1559 1560"use strict"; 1561 1562var fails = __webpack_require__(6); 1563var isCallable = __webpack_require__(20); 1564 1565var replacement = /#|\.prototype\./; 1566 1567var isForced = function (feature, detection) { 1568 var value = data[normalize(feature)]; 1569 return value === POLYFILL ? true 1570 : value === NATIVE ? false 1571 : isCallable(detection) ? fails(detection) 1572 : !!detection; 1573}; 1574 1575var normalize = isForced.normalize = function (string) { 1576 return String(string).replace(replacement, '.').toLowerCase(); 1577}; 1578 1579var data = isForced.data = {}; 1580var NATIVE = isForced.NATIVE = 'N'; 1581var POLYFILL = isForced.POLYFILL = 'P'; 1582 1583module.exports = isForced; 1584 1585 1586/***/ }), 1587/* 67 */ 1588/***/ (function(module, exports, __webpack_require__) { 1589 1590"use strict"; 1591 1592var NATIVE_BIND = __webpack_require__(8); 1593 1594var FunctionPrototype = Function.prototype; 1595var apply = FunctionPrototype.apply; 1596var call = FunctionPrototype.call; 1597 1598// eslint-disable-next-line es/no-reflect -- safe 1599module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () { 1600 return call.apply(apply, arguments); 1601}); 1602 1603 1604/***/ }), 1605/* 68 */ 1606/***/ (function(module, exports, __webpack_require__) { 1607 1608"use strict"; 1609 1610var uncurryThis = __webpack_require__(13); 1611 1612module.exports = uncurryThis([].slice); 1613 1614 1615/***/ }), 1616/* 69 */ 1617/***/ (function(module, exports, __webpack_require__) { 1618 1619"use strict"; 1620 1621var aCallable = __webpack_require__(29); 1622 1623var $TypeError = TypeError; 1624 1625var PromiseCapability = function (C) { 1626 var resolve, reject; 1627 this.promise = new C(function ($$resolve, $$reject) { 1628 if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor'); 1629 resolve = $$resolve; 1630 reject = $$reject; 1631 }); 1632 this.resolve = aCallable(resolve); 1633 this.reject = aCallable(reject); 1634}; 1635 1636// `NewPromiseCapability` abstract operation 1637// https://tc39.es/ecma262/#sec-newpromisecapability 1638module.exports.f = function (C) { 1639 return new PromiseCapability(C); 1640}; 1641 1642 1643/***/ }), 1644/* 70 */ 1645/***/ (function(module, exports, __webpack_require__) { 1646 1647"use strict"; 1648 1649module.exports = function (exec) { 1650 try { 1651 return { error: false, value: exec() }; 1652 } catch (error) { 1653 return { error: true, value: error }; 1654 } 1655}; 1656 1657 1658/***/ }), 1659/* 71 */ 1660/***/ (function(module, exports, __webpack_require__) { 1661 1662"use strict"; 1663 1664var $ = __webpack_require__(2); 1665var newPromiseCapabilityModule = __webpack_require__(69); 1666 1667// `Promise.withResolvers` method 1668// https://tc39.es/ecma262/#sec-promise.withResolvers 1669$({ target: 'Promise', stat: true }, { 1670 withResolvers: function withResolvers() { 1671 var promiseCapability = newPromiseCapabilityModule.f(this); 1672 return { 1673 promise: promiseCapability.promise, 1674 resolve: promiseCapability.resolve, 1675 reject: promiseCapability.reject 1676 }; 1677 } 1678}); 1679 1680 1681/***/ }), 1682/* 72 */ 1683/***/ (function(module, exports, __webpack_require__) { 1684 1685"use strict"; 1686 1687var $ = __webpack_require__(2); 1688var globalThis = __webpack_require__(3); 1689var getBuiltIn = __webpack_require__(22); 1690var createPropertyDescriptor = __webpack_require__(10); 1691var defineProperty = __webpack_require__(43).f; 1692var hasOwn = __webpack_require__(37); 1693var anInstance = __webpack_require__(73); 1694var inheritIfRequired = __webpack_require__(74); 1695var normalizeStringArgument = __webpack_require__(79); 1696var DOMExceptionConstants = __webpack_require__(83); 1697var clearErrorStack = __webpack_require__(84); 1698var DESCRIPTORS = __webpack_require__(5); 1699var IS_PURE = __webpack_require__(3
vendor: 2,451 bytes, lines 1699-1756
16995); 1700 1701var DOM_EXCEPTION = 'DOMException'; 1702var Error = getBuiltIn('Error'); 1703var NativeDOMException = getBuiltIn(DOM_EXCEPTION); 1704 1705var $DOMException = function DOMException() { 1706 anInstance(this, DOMExceptionPrototype); 1707 var argumentsLength = arguments.length; 1708 var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]); 1709 var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error'); 1710 var that = new NativeDOMException(message, name); 1711 var error = new Error(message); 1712 error.name = DOM_EXCEPTION; 1713 defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1))); 1714 inheritIfRequired(that, this, $DOMException); 1715 return that; 1716}; 1717 1718var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype; 1719 1720var ERROR_HAS_STACK = 'stack' in new Error(DOM_EXCEPTION); 1721var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2); 1722 1723// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 1724var descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis, DOM_EXCEPTION); 1725 1726// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it 1727// https://github.com/Jarred-Sumner/bun/issues/399 1728var BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable); 1729 1730var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK; 1731 1732// `DOMException` constructor patch for `.stack` where it's required 1733// https://webidl.spec.whatwg.org/#es-DOMException-specialness 1734$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic 1735 DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException 1736}); 1737 1738var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION); 1739var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype; 1740 1741if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) { 1742 if (!IS_PURE) { 1743 defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException)); 1744 } 1745 1746 for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) { 1747 var constant = DOMExceptionConstants[key]; 1748 var constantName = constant.s; 1749 if (!hasOwn(PolyfilledDOMException, constantName)) { 1750 defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c)); 1751 } 1752 } 1753} 1754 1755 1756/***/ }),
vendor: 9,492 bytes, lines 1757-2072
1757/* 73 */ 1758/***/ (function(module, exports, __webpack_require__) { 1759 1760"use strict"; 1761 1762var isPrototypeOf = __webpack_require__(23); 1763 1764var $TypeError = TypeError; 1765 1766module.exports = function (it, Prototype) { 1767 if (isPrototypeOf(Prototype, it)) return it; 1768 throw new $TypeError('Incorrect invocation'); 1769}; 1770 1771 1772/***/ }), 1773/* 74 */ 1774/***/ (function(module, exports, __webpack_require__) { 1775 1776"use strict"; 1777 1778var isCallable = __webpack_require__(20); 1779var isObject = __webpack_require__(19); 1780var setPrototypeOf = __webpack_require__(75); 1781 1782// makes subclassing work correct for wrapped built-ins 1783module.exports = function ($this, dummy, Wrapper) { 1784 var NewTarget, NewTargetPrototype; 1785 if ( 1786 // it can work only with native `setPrototypeOf` 1787 setPrototypeOf && 1788 // we haven't completely correct pre-ES6 way for getting `new.target`, so use this 1789 isCallable(NewTarget = dummy.constructor) && 1790 NewTarget !== Wrapper && 1791 isObject(NewTargetPrototype = NewTarget.prototype) && 1792 NewTargetPrototype !== Wrapper.prototype 1793 ) setPrototypeOf($this, NewTargetPrototype); 1794 return $this; 1795}; 1796 1797 1798/***/ }), 1799/* 75 */ 1800/***/ (function(module, exports, __webpack_require__) { 1801 1802"use strict"; 1803 1804/* eslint-disable no-proto -- safe */ 1805var uncurryThisAccessor = __webpack_require__(76); 1806var isObject = __webpack_require__(19); 1807var requireObjectCoercible = __webpack_require__(15); 1808var aPossiblePrototype = __webpack_require__(77); 1809 1810// `Object.setPrototypeOf` method 1811// https://tc39.es/ecma262/#sec-object.setprototypeof 1812// Works with __proto__ only. Old v8 can't work with null proto objects. 1813// eslint-disable-next-line es/no-object-setprototypeof -- safe 1814module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { 1815 var CORRECT_SETTER = false; 1816 var test = {}; 1817 var setter; 1818 try { 1819 setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); 1820 setter(test, []); 1821 CORRECT_SETTER = test instanceof Array; 1822 } catch (error) { /* empty */ } 1823 return function setPrototypeOf(O, proto) { 1824 requireObjectCoercible(O); 1825 aPossiblePrototype(proto); 1826 if (!isObject(O)) return O; 1827 if (CORRECT_SETTER) setter(O, proto); 1828 else O.__proto__ = proto; 1829 return O; 1830 }; 1831}() : undefined); 1832 1833 1834/***/ }), 1835/* 76 */ 1836/***/ (function(module, exports, __webpack_require__) { 1837 1838"use strict"; 1839 1840var uncurryThis = __webpack_require__(13); 1841var aCallable = __webpack_require__(29); 1842 1843module.exports = function (object, key, method) { 1844 try { 1845 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe 1846 return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method])); 1847 } catch (error) { /* empty */ } 1848}; 1849 1850 1851/***/ }), 1852/* 77 */ 1853/***/ (function(module, exports, __webpack_require__) { 1854 1855"use strict"; 1856 1857var isPossiblePrototype = __webpack_require__(78); 1858 1859var $String = String; 1860var $TypeError = TypeError; 1861 1862module.exports = function (argument) { 1863 if (isPossiblePrototype(argument)) return argument; 1864 throw new $TypeError("Can't set " + $String(argument) + ' as a prototype'); 1865}; 1866 1867 1868/***/ }), 1869/* 78 */ 1870/***/ (function(module, exports, __webpack_require__) { 1871 1872"use strict"; 1873 1874var isObject = __webpack_require__(19); 1875 1876module.exports = function (argument) { 1877 return isObject(argument) || argument === null; 1878}; 1879 1880 1881/***/ }), 1882/* 79 */ 1883/***/ (function(module, exports, __webpack_require__) { 1884 1885"use strict"; 1886 1887var toString = __webpack_require__(80); 1888 1889module.exports = function (argument, $default) { 1890 return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument); 1891}; 1892 1893 1894/***/ }), 1895/* 80 */ 1896/***/ (function(module, exports, __webpack_require__) { 1897 1898"use strict"; 1899 1900var classof = __webpack_require__(81); 1901 1902var $String = String; 1903 1904module.exports = function (argument) { 1905 if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); 1906 return $String(argument); 1907}; 1908 1909 1910/***/ }), 1911/* 81 */ 1912/***/ (function(module, exports, __webpack_require__) { 1913 1914"use strict"; 1915 1916var TO_STRING_TAG_SUPPORT = __webpack_require__(82); 1917var isCallable = __webpack_require__(20); 1918var classofRaw = __webpack_require__(14); 1919var wellKnownSymbol = __webpack_require__(32); 1920 1921var TO_STRING_TAG = wellKnownSymbol('toStringTag'); 1922var $Object = Object; 1923 1924// ES3 wrong here 1925var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments'; 1926 1927// fallback for IE11 Script Access Denied error 1928var tryGet = function (it, key) { 1929 try { 1930 return it[key]; 1931 } catch (error) { /* empty */ } 1932}; 1933 1934// getting tag from ES6+ `Object.prototype.toString` 1935module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { 1936 var O, tag, result; 1937 return it === undefined ? 'Undefined' : it === null ? 'Null' 1938 // @@toStringTag case 1939 : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag 1940 // builtinTag case 1941 : CORRECT_ARGUMENTS ? classofRaw(O) 1942 // ES3 arguments fallback 1943 : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result; 1944}; 1945 1946 1947/***/ }), 1948/* 82 */ 1949/***/ (function(module, exports, __webpack_require__) { 1950 1951"use strict"; 1952 1953var wellKnownSymbol = __webpack_require__(32); 1954 1955var TO_STRING_TAG = wellKnownSymbol('toStringTag'); 1956var test = {}; 1957 1958test[TO_STRING_TAG] = 'z'; 1959 1960module.exports = String(test) === '[object z]'; 1961 1962 1963/***/ }), 1964/* 83 */ 1965/***/ (function(module, exports, __webpack_require__) { 1966 1967"use strict"; 1968 1969module.exports = { 1970 IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 }, 1971 DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 }, 1972 HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 }, 1973 WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 }, 1974 InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 }, 1975 NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 }, 1976 NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 }, 1977 NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 }, 1978 NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 }, 1979 InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 }, 1980 InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 }, 1981 SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 }, 1982 InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 }, 1983 NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 }, 1984 InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 }, 1985 ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 }, 1986 TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 }, 1987 SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 }, 1988 NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 }, 1989 AbortError: { s: 'ABORT_ERR', c: 20, m: 1 }, 1990 URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 }, 1991 QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 }, 1992 TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 }, 1993 InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 }, 1994 DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 } 1995}; 1996 1997 1998/***/ }), 1999/* 84 */ 2000/***/ (function(module, exports, __webpack_require__) { 2001 2002"use strict"; 2003 2004var uncurryThis = __webpack_require__(13); 2005 2006var $Error = Error; 2007var replace = uncurryThis(''.replace); 2008 2009var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd'); 2010// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe 2011var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/; 2012var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST); 2013 2014module.exports = function (stack, dropEntries) { 2015 if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) { 2016 while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, ''); 2017 } return stack; 2018}; 2019 2020 2021/***/ }), 2022/* 85 */ 2023/***/ (function(module, exports, __webpack_require__) { 2024 2025"use strict"; 2026 2027var IS_PURE = __webpack_require__(35); 2028var $ = __webpack_require__(2); 2029var globalThis = __webpack_require__(3); 2030var getBuiltIn = __webpack_require__(22); 2031var uncurryThis = __webpack_require__(13); 2032var fails = __webpack_require__(6); 2033var uid = __webpack_require__(39); 2034var isCallable = __webpack_require__(20); 2035var isConstructor = __webpack_require__(86); 2036var isNullOrUndefined = __webpack_require__(16); 2037var isObject = __webpack_require__(19); 2038var isSymbol = __webpack_require__(21); 2039var iterate = __webpack_require__(87); 2040var anObject = __webpack_require__(45); 2041var classof = __webpack_require__(81); 2042var hasOwn = __webpack_require__(37); 2043var createProperty = __webpack_require__(95); 2044var createNonEnumerableProperty = __webpack_require__(42); 2045var lengthOfArrayLike = __webpack_require__(62); 2046var validateArgumentsLength = __webpack_require__(96); 2047var getRegExpFlags = __webpack_require__(97); 2048var MapHelpers = __webpack_require__(99); 2049var SetHelpers = __webpack_require__(100); 2050var setIterate = __webpack_require__(101); 2051var detachTransferable = __webpack_require__(103); 2052var ERROR_STACK_INSTALLABLE = __webpack_require__(108); 2053var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(107); 2054 2055var Object = globalThis.Object; 2056var Array = globalThis.Array; 2057var Date = globalThis.Date; 2058var Error = globalThis.Error; 2059var TypeError = globalThis.TypeError; 2060var PerformanceMark = globalThis.PerformanceMark; 2061var DOMException = getBuiltIn('DOMException'); 2062var Map = MapHelpers.Map; 2063var mapHas = MapHelpers.has; 2064var mapGet = MapHelpers.get; 2065var mapSet = MapHelpers.set; 2066var Set = SetHelpers.Set; 2067var setAdd = SetHelpers.add; 2068var setHas = SetHelpers.has; 2069var objectKeys = getBuiltIn('Object', 'keys'); 2070var push = uncurryThis([].push); 2071var thisBooleanValue = uncurryThis(true.valueOf); 2072var thisNumberValue = uncurryThis(1.0
vendor: 14,102 bytes, lines 2072-2470
2072.valueOf); 2073var thisStringValue = uncurryThis(''.valueOf); 2074var thisTimeValue = uncurryThis(Date.prototype.getTime); 2075var PERFORMANCE_MARK = uid('structuredClone'); 2076var DATA_CLONE_ERROR = 'DataCloneError'; 2077var TRANSFERRING = 'Transferring'; 2078 2079var checkBasicSemantic = function (structuredCloneImplementation) { 2080 return !fails(function () { 2081 var set1 = new globalThis.Set([7]); 2082 var set2 = structuredCloneImplementation(set1); 2083 var number = structuredCloneImplementation(Object(7)); 2084 return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7; 2085 }) && structuredCloneImplementation; 2086}; 2087 2088var checkErrorsCloning = function (structuredCloneImplementation, $Error) { 2089 return !fails(function () { 2090 var error = new $Error(); 2091 var test = structuredCloneImplementation({ a: error, b: error }); 2092 return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack); 2093 }); 2094}; 2095 2096// https://github.com/whatwg/html/pull/5749 2097var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) { 2098 return !fails(function () { 2099 var test = structuredCloneImplementation(new globalThis.AggregateError([1], PERFORMANCE_MARK, { cause: 3 })); 2100 return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3; 2101 }); 2102}; 2103 2104// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+ 2105// FF<103 and Safari implementations can't clone errors 2106// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604 2107// FF103 can clone errors, but `.stack` of clone is an empty string 2108// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762 2109// FF104+ fixed it on usual errors, but not on DOMExceptions 2110// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321 2111// Chrome <102 returns `null` if cloned object contains multiple references to one error 2112// https://bugs.chromium.org/p/v8/issues/detail?id=12542 2113// NodeJS implementation can't clone DOMExceptions 2114// https://github.com/nodejs/node/issues/41038 2115// only FF103+ supports new (html/5749) error cloning semantic 2116var nativeStructuredClone = globalThis.structuredClone; 2117 2118var FORCED_REPLACEMENT = IS_PURE 2119 || !checkErrorsCloning(nativeStructuredClone, Error) 2120 || !checkErrorsCloning(nativeStructuredClone, DOMException) 2121 || !checkNewErrorsCloningSemantic(nativeStructuredClone); 2122 2123// Chrome 82+, Safari 14.1+, Deno 1.11+ 2124// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException` 2125// Chrome returns `null` if cloned object contains multiple references to one error 2126// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround 2127// Safari implementation can't clone errors 2128// Deno 1.2-1.10 implementations too naive 2129// NodeJS 16.0+ does not have `PerformanceMark` constructor 2130// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive 2131// and can't clone, for example, `RegExp` or some boxed primitives 2132// https://github.com/nodejs/node/issues/40840 2133// no one of those implementations supports new (html/5749) error cloning semantic 2134var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) { 2135 return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail; 2136}); 2137 2138var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark; 2139 2140var throwUncloneable = function (type) { 2141 throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR); 2142}; 2143 2144var throwUnpolyfillable = function (type, action) { 2145 throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR); 2146}; 2147 2148var tryNativeRestrictedStructuredClone = function (value, type) { 2149 if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type); 2150 return nativeRestrictedStructuredClone(value); 2151}; 2152 2153var createDataTransfer = function () { 2154 var dataTransfer; 2155 try { 2156 dataTransfer = new globalThis.DataTransfer(); 2157 } catch (error) { 2158 try { 2159 dataTransfer = new globalThis.ClipboardEvent('').clipboardData; 2160 } catch (error2) { /* empty */ } 2161 } 2162 return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null; 2163}; 2164 2165var cloneBuffer = function (value, map, $type) { 2166 if (mapHas(map, value)) return mapGet(map, value); 2167 2168 var type = $type || classof(value); 2169 var clone, length, options, source, target, i; 2170 2171 if (type === 'SharedArrayBuffer') { 2172 if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value); 2173 // SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original 2174 else clone = value; 2175 } else { 2176 var DataView = globalThis.DataView; 2177 2178 // `ArrayBuffer#slice` is not available in IE10 2179 // `ArrayBuffer#slice` and `DataView` are not available in old FF 2180 if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer'); 2181 // detached buffers throws in `DataView` and `.slice` 2182 try { 2183 if (isCallable(value.slice) && !value.resizable) { 2184 clone = value.slice(0); 2185 } else { 2186 length = value.byteLength; 2187 options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined; 2188 // eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe 2189 clone = new ArrayBuffer(length, options); 2190 source = new DataView(value); 2191 target = new DataView(clone); 2192 for (i = 0; i < length; i++) { 2193 target.setUint8(i, source.getUint8(i)); 2194 } 2195 } 2196 } catch (error) { 2197 throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR); 2198 } 2199 } 2200 2201 mapSet(map, value, clone); 2202 2203 return clone; 2204}; 2205 2206var cloneView = function (value, type, offset, length, map) { 2207 var C = globalThis[type]; 2208 // in some old engines like Safari 9, typeof C is 'object' 2209 // on Uint8ClampedArray or some other constructors 2210 if (!isObject(C)) throwUnpolyfillable(type); 2211 return new C(cloneBuffer(value.buffer, map), offset, length); 2212}; 2213 2214var structuredCloneInternal = function (value, map) { 2215 if (isSymbol(value)) throwUncloneable('Symbol'); 2216 if (!isObject(value)) return value; 2217 // effectively preserves circular references 2218 if (map) { 2219 if (mapHas(map, value)) return mapGet(map, value); 2220 } else map = new Map(); 2221 2222 var type = classof(value); 2223 var C, name, cloned, dataTransfer, i, length, keys, key; 2224 2225 switch (type) { 2226 case 'Array': 2227 cloned = Array(lengthOfArrayLike(value)); 2228 break; 2229 case 'Object': 2230 cloned = {}; 2231 break; 2232 case 'Map': 2233 cloned = new Map(); 2234 break; 2235 case 'Set': 2236 cloned = new Set(); 2237 break; 2238 case 'RegExp': 2239 // in this block because of a Safari 14.1 bug 2240 // old FF does not clone regexes passed to the constructor, so get the source and flags directly 2241 cloned = new RegExp(value.source, getRegExpFlags(value)); 2242 break; 2243 case 'Error': 2244 name = value.name; 2245 switch (name) { 2246 case 'AggregateError': 2247 cloned = new (getBuiltIn(name))([]); 2248 break; 2249 case 'EvalError': 2250 case 'RangeError': 2251 case 'ReferenceError': 2252 case 'SuppressedError': 2253 case 'SyntaxError': 2254 case 'TypeError': 2255 case 'URIError': 2256 cloned = new (getBuiltIn(name))(); 2257 break; 2258 case 'CompileError': 2259 case 'LinkError': 2260 case 'RuntimeError': 2261 cloned = new (getBuiltIn('WebAssembly', name))(); 2262 break; 2263 default: 2264 cloned = new Error(); 2265 } 2266 break; 2267 case 'DOMException': 2268 cloned = new DOMException(value.message, value.name); 2269 break; 2270 case 'ArrayBuffer': 2271 case 'SharedArrayBuffer': 2272 cloned = cloneBuffer(value, map, type); 2273 break; 2274 case 'DataView': 2275 case 'Int8Array': 2276 case 'Uint8Array': 2277 case 'Uint8ClampedArray': 2278 case 'Int16Array': 2279 case 'Uint16Array': 2280 case 'Int32Array': 2281 case 'Uint32Array': 2282 case 'Float16Array': 2283 case 'Float32Array': 2284 case 'Float64Array': 2285 case 'BigInt64Array': 2286 case 'BigUint64Array': 2287 length = type === 'DataView' ? value.byteLength : value.length; 2288 cloned = cloneView(value, type, value.byteOffset, length, map); 2289 break; 2290 case 'DOMQuad': 2291 try { 2292 cloned = new DOMQuad( 2293 structuredCloneInternal(value.p1, map), 2294 structuredCloneInternal(value.p2, map), 2295 structuredCloneInternal(value.p3, map), 2296 structuredCloneInternal(value.p4, map) 2297 ); 2298 } catch (error) { 2299 cloned = tryNativeRestrictedStructuredClone(value, type); 2300 } 2301 break; 2302 case 'File': 2303 if (nativeRestrictedStructuredClone) try { 2304 cloned = nativeRestrictedStructuredClone(value); 2305 // NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612 2306 if (classof(cloned) !== type) cloned = undefined; 2307 } catch (error) { /* empty */ } 2308 if (!cloned) try { 2309 cloned = new File([value], value.name, value); 2310 } catch (error) { /* empty */ } 2311 if (!cloned) throwUnpolyfillable(type); 2312 break; 2313 case 'FileList': 2314 dataTransfer = createDataTransfer(); 2315 if (dataTransfer) { 2316 for (i = 0, length = lengthOfArrayLike(value); i < length; i++) { 2317 dataTransfer.items.add(structuredCloneInternal(value[i], map)); 2318 } 2319 cloned = dataTransfer.files; 2320 } else cloned = tryNativeRestrictedStructuredClone(value, type); 2321 break; 2322 case 'ImageData': 2323 // Safari 9 ImageData is a constructor, but typeof ImageData is 'object' 2324 try { 2325 cloned = new ImageData( 2326 structuredCloneInternal(value.data, map), 2327 value.width, 2328 value.height, 2329 { colorSpace: value.colorSpace } 2330 ); 2331 } catch (error) { 2332 cloned = tryNativeRestrictedStructuredClone(value, type); 2333 } break; 2334 default: 2335 if (nativeRestrictedStructuredClone) { 2336 cloned = nativeRestrictedStructuredClone(value); 2337 } else switch (type) { 2338 case 'BigInt': 2339 // can be a 3rd party polyfill 2340 cloned = Object(value.valueOf()); 2341 break; 2342 case 'Boolean': 2343 cloned = Object(thisBooleanValue(value)); 2344 break; 2345 case 'Number': 2346 cloned = Object(thisNumberValue(value)); 2347 break; 2348 case 'String': 2349 cloned = Object(thisStringValue(value)); 2350 break; 2351 case 'Date': 2352 cloned = new Date(thisTimeValue(value)); 2353 break; 2354 case 'Blob': 2355 try { 2356 cloned = value.slice(0, value.size, value.type); 2357 } catch (error) { 2358 throwUnpolyfillable(type); 2359 } break; 2360 case 'DOMPoint': 2361 case 'DOMPointReadOnly': 2362 C = globalThis[type]; 2363 try { 2364 cloned = C.fromPoint 2365 ? C.fromPoint(value) 2366 : new C(value.x, value.y, value.z, value.w); 2367 } catch (error) { 2368 throwUnpolyfillable(type); 2369 } break; 2370 case 'DOMRect': 2371 case 'DOMRectReadOnly': 2372 C = globalThis[type]; 2373 try { 2374 cloned = C.fromRect 2375 ? C.fromRect(value) 2376 : new C(value.x, value.y, value.width, value.height); 2377 } catch (error) { 2378 throwUnpolyfillable(type); 2379 } break; 2380 case 'DOMMatrix': 2381 case 'DOMMatrixReadOnly': 2382 C = globalThis[type]; 2383 try { 2384 cloned = C.fromMatrix 2385 ? C.fromMatrix(value) 2386 : new C(value); 2387 } catch (error) { 2388 throwUnpolyfillable(type); 2389 } break; 2390 case 'AudioData': 2391 case 'VideoFrame': 2392 if (!isCallable(value.clone)) throwUnpolyfillable(type); 2393 try { 2394 cloned = value.clone(); 2395 } catch (error) { 2396 throwUncloneable(type); 2397 } break; 2398 case 'CropTarget': 2399 case 'CryptoKey': 2400 case 'FileSystemDirectoryHandle': 2401 case 'FileSystemFileHandle': 2402 case 'FileSystemHandle': 2403 case 'GPUCompilationInfo': 2404 case 'GPUCompilationMessage': 2405 case 'ImageBitmap': 2406 case 'RTCCertificate': 2407 case 'WebAssembly.Module': 2408 throwUnpolyfillable(type); 2409 // break omitted 2410 default: 2411 throwUncloneable(type); 2412 } 2413 } 2414 2415 mapSet(map, value, cloned); 2416 2417 switch (type) { 2418 case 'Array': 2419 case 'Object': 2420 keys = objectKeys(value); 2421 for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) { 2422 key = keys[i]; 2423 createProperty(cloned, key, structuredCloneInternal(value[key], map)); 2424 } break; 2425 case 'Map': 2426 value.forEach(function (v, k) { 2427 mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map)); 2428 }); 2429 break; 2430 case 'Set': 2431 value.forEach(function (v) { 2432 setAdd(cloned, structuredCloneInternal(v, map)); 2433 }); 2434 break; 2435 case 'Error': 2436 createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map)); 2437 if (hasOwn(value, 'cause')) { 2438 createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map)); 2439 } 2440 if (name === 'AggregateError') { 2441 cloned.errors = structuredCloneInternal(value.errors, map); 2442 } else if (name === 'SuppressedError') { 2443 cloned.error = structuredCloneInternal(value.error, map); 2444 cloned.suppressed = structuredCloneInternal(value.suppressed, map); 2445 } // break omitted 2446 case 'DOMException': 2447 if (ERROR_STACK_INSTALLABLE) { 2448 createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map)); 2449 } 2450 } 2451 2452 return cloned; 2453}; 2454 2455var tryToTransfer = function (rawTransfer, map) { 2456 if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence'); 2457 2458 var transfer = []; 2459 2460 iterate(rawTransfer, function (value) { 2461 push(transfer, anObject(value)); 2462 }); 2463 2464 var i = 0; 2465 var length = lengthOfArrayLike(transfer); 2466 var buffers = new Set(); 2467 var value, type, C, transferred, canvas, context; 2468 2469 while (i < length) { 2470 value = transfer[i++];
vendor: 22,076 bytes, lines 2471-3263
2471 2472 type = classof(value); 2473 2474 if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) { 2475 throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR); 2476 } 2477 2478 if (type === 'ArrayBuffer') { 2479 setAdd(buffers, value); 2480 continue; 2481 } 2482 2483 if (PROPER_STRUCTURED_CLONE_TRANSFER) { 2484 transferred = nativeStructuredClone(value, { transfer: [value] }); 2485 } else switch (type) { 2486 case 'ImageBitmap': 2487 C = globalThis.OffscreenCanvas; 2488 if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING); 2489 try { 2490 canvas = new C(value.width, value.height); 2491 context = canvas.getContext('bitmaprenderer'); 2492 context.transferFromImageBitmap(value); 2493 transferred = canvas.transferToImageBitmap(); 2494 } catch (error) { /* empty */ } 2495 break; 2496 case 'AudioData': 2497 case 'VideoFrame': 2498 if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING); 2499 try { 2500 transferred = value.clone(); 2501 value.close(); 2502 } catch (error) { /* empty */ } 2503 break; 2504 case 'MediaSourceHandle': 2505 case 'MessagePort': 2506 case 'MIDIAccess': 2507 case 'OffscreenCanvas': 2508 case 'ReadableStream': 2509 case 'RTCDataChannel': 2510 case 'TransformStream': 2511 case 'WebTransportReceiveStream': 2512 case 'WebTransportSendStream': 2513 case 'WritableStream': 2514 throwUnpolyfillable(type, TRANSFERRING); 2515 } 2516 2517 if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR); 2518 2519 mapSet(map, value, transferred); 2520 } 2521 2522 return buffers; 2523}; 2524 2525var detachBuffers = function (buffers) { 2526 setIterate(buffers, function (buffer) { 2527 if (PROPER_STRUCTURED_CLONE_TRANSFER) { 2528 nativeRestrictedStructuredClone(buffer, { transfer: [buffer] }); 2529 } else if (isCallable(buffer.transfer)) { 2530 buffer.transfer(); 2531 } else if (detachTransferable) { 2532 detachTransferable(buffer); 2533 } else { 2534 throwUnpolyfillable('ArrayBuffer', TRANSFERRING); 2535 } 2536 }); 2537}; 2538 2539// `structuredClone` method 2540// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone 2541$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, { 2542 structuredClone: function structuredClone(value /* , { transfer } */) { 2543 var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined; 2544 var transfer = options ? options.transfer : undefined; 2545 var map, buffers; 2546 2547 if (transfer !== undefined) { 2548 map = new Map(); 2549 buffers = tryToTransfer(transfer, map); 2550 } 2551 2552 var clone = structuredCloneInternal(value, map); 2553 2554 // since of an issue with cloning views of transferred buffers, we a forced to detach them later 2555 // https://github.com/zloirock/core-js/issues/1265 2556 if (buffers) detachBuffers(buffers); 2557 2558 return clone; 2559 } 2560}); 2561 2562 2563/***/ }), 2564/* 86 */ 2565/***/ (function(module, exports, __webpack_require__) { 2566 2567"use strict"; 2568 2569var uncurryThis = __webpack_require__(13); 2570var fails = __webpack_require__(6); 2571var isCallable = __webpack_require__(20); 2572var classof = __webpack_require__(81); 2573var getBuiltIn = __webpack_require__(22); 2574var inspectSource = __webpack_require__(49); 2575 2576var noop = function () { /* empty */ }; 2577var construct = getBuiltIn('Reflect', 'construct'); 2578var constructorRegExp = /^\s*(?:class|function)\b/; 2579var exec = uncurryThis(constructorRegExp.exec); 2580var INCORRECT_TO_STRING = !constructorRegExp.test(noop); 2581 2582var isConstructorModern = function isConstructor(argument) { 2583 if (!isCallable(argument)) return false; 2584 try { 2585 construct(noop, [], argument); 2586 return true; 2587 } catch (error) { 2588 return false; 2589 } 2590}; 2591 2592var isConstructorLegacy = function isConstructor(argument) { 2593 if (!isCallable(argument)) return false; 2594 switch (classof(argument)) { 2595 case 'AsyncFunction': 2596 case 'GeneratorFunction': 2597 case 'AsyncGeneratorFunction': return false; 2598 } 2599 try { 2600 // we can't check .prototype since constructors produced by .bind haven't it 2601 // `Function#toString` throws on some built-it function in some legacy engines 2602 // (for example, `DOMQuad` and similar in FF41-) 2603 return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument)); 2604 } catch (error) { 2605 return true; 2606 } 2607}; 2608 2609isConstructorLegacy.sham = true; 2610 2611// `IsConstructor` abstract operation 2612// https://tc39.es/ecma262/#sec-isconstructor 2613module.exports = !construct || fails(function () { 2614 var called; 2615 return isConstructorModern(isConstructorModern.call) 2616 || !isConstructorModern(Object) 2617 || !isConstructorModern(function () { called = true; }) 2618 || called; 2619}) ? isConstructorLegacy : isConstructorModern; 2620 2621 2622/***/ }), 2623/* 87 */ 2624/***/ (function(module, exports, __webpack_require__) { 2625 2626"use strict"; 2627 2628var bind = __webpack_require__(88); 2629var call = __webpack_require__(7); 2630var anObject = __webpack_require__(45); 2631var tryToString = __webpack_require__(30); 2632var isArrayIteratorMethod = __webpack_require__(90); 2633var lengthOfArrayLike = __webpack_require__(62); 2634var isPrototypeOf = __webpack_require__(23); 2635var getIterator = __webpack_require__(92); 2636var getIteratorMethod = __webpack_require__(93); 2637var iteratorClose = __webpack_require__(94); 2638 2639var $TypeError = TypeError; 2640 2641var Result = function (stopped, result) { 2642 this.stopped = stopped; 2643 this.result = result; 2644}; 2645 2646var ResultPrototype = Result.prototype; 2647 2648module.exports = function (iterable, unboundFunction, options) { 2649 var that = options && options.that; 2650 var AS_ENTRIES = !!(options && options.AS_ENTRIES); 2651 var IS_RECORD = !!(options && options.IS_RECORD); 2652 var IS_ITERATOR = !!(options && options.IS_ITERATOR); 2653 var INTERRUPTED = !!(options && options.INTERRUPTED); 2654 var fn = bind(unboundFunction, that); 2655 var iterator, iterFn, index, length, result, next, step; 2656 2657 var stop = function (condition) { 2658 if (iterator) iteratorClose(iterator, 'normal', condition); 2659 return new Result(true, condition); 2660 }; 2661 2662 var callFn = function (value) { 2663 if (AS_ENTRIES) { 2664 anObject(value); 2665 return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); 2666 } return INTERRUPTED ? fn(value, stop) : fn(value); 2667 }; 2668 2669 if (IS_RECORD) { 2670 iterator = iterable.iterator; 2671 } else if (IS_ITERATOR) { 2672 iterator = iterable; 2673 } else { 2674 iterFn = getIteratorMethod(iterable); 2675 if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); 2676 // optimisation for array iterators 2677 if (isArrayIteratorMethod(iterFn)) { 2678 for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) { 2679 result = callFn(iterable[index]); 2680 if (result && isPrototypeOf(ResultPrototype, result)) return result; 2681 } return new Result(false); 2682 } 2683 iterator = getIterator(iterable, iterFn); 2684 } 2685 2686 next = IS_RECORD ? iterable.next : iterator.next; 2687 while (!(step = call(next, iterator)).done) { 2688 try { 2689 result = callFn(step.value); 2690 } catch (error) { 2691 iteratorClose(iterator, 'throw', error); 2692 } 2693 if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; 2694 } return new Result(false); 2695}; 2696 2697 2698/***/ }), 2699/* 88 */ 2700/***/ (function(module, exports, __webpack_require__) { 2701 2702"use strict"; 2703 2704var uncurryThis = __webpack_require__(89); 2705var aCallable = __webpack_require__(29); 2706var NATIVE_BIND = __webpack_require__(8); 2707 2708var bind = uncurryThis(uncurryThis.bind); 2709 2710// optional / simple context binding 2711module.exports = function (fn, that) { 2712 aCallable(fn); 2713 return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) { 2714 return fn.apply(that, arguments); 2715 }; 2716}; 2717 2718 2719/***/ }), 2720/* 89 */ 2721/***/ (function(module, exports, __webpack_require__) { 2722 2723"use strict"; 2724 2725var classofRaw = __webpack_require__(14); 2726var uncurryThis = __webpack_require__(13); 2727 2728module.exports = function (fn) { 2729 // Nashorn bug: 2730 // https://github.com/zloirock/core-js/issues/1128 2731 // https://github.com/zloirock/core-js/issues/1130 2732 if (classofRaw(fn) === 'Function') return uncurryThis(fn); 2733}; 2734 2735 2736/***/ }), 2737/* 90 */ 2738/***/ (function(module, exports, __webpack_require__) { 2739 2740"use strict"; 2741 2742var wellKnownSymbol = __webpack_require__(32); 2743var Iterators = __webpack_require__(91); 2744 2745var ITERATOR = wellKnownSymbol('iterator'); 2746var ArrayPrototype = Array.prototype; 2747 2748// check on default Array iterator 2749module.exports = function (it) { 2750 return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); 2751}; 2752 2753 2754/***/ }), 2755/* 91 */ 2756/***/ (function(module, exports, __webpack_require__) { 2757 2758"use strict"; 2759 2760module.exports = {}; 2761 2762 2763/***/ }), 2764/* 92 */ 2765/***/ (function(module, exports, __webpack_require__) { 2766 2767"use strict"; 2768 2769var call = __webpack_require__(7); 2770var aCallable = __webpack_require__(29); 2771var anObject = __webpack_require__(45); 2772var tryToString = __webpack_require__(30); 2773var getIteratorMethod = __webpack_require__(93); 2774 2775var $TypeError = TypeError; 2776 2777module.exports = function (argument, usingIterator) { 2778 var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator; 2779 if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument)); 2780 throw new $TypeError(tryToString(argument) + ' is not iterable'); 2781}; 2782 2783 2784/***/ }), 2785/* 93 */ 2786/***/ (function(module, exports, __webpack_require__) { 2787 2788"use strict"; 2789 2790var classof = __webpack_require__(81); 2791var getMethod = __webpack_require__(28); 2792var isNullOrUndefined = __webpack_require__(16); 2793var Iterators = __webpack_require__(91); 2794var wellKnownSymbol = __webpack_require__(32); 2795 2796var ITERATOR = wellKnownSymbol('iterator'); 2797 2798module.exports = function (it) { 2799 if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR) 2800 || getMethod(it, '@@iterator') 2801 || Iterators[classof(it)]; 2802}; 2803 2804 2805/***/ }), 2806/* 94 */ 2807/***/ (function(module, exports, __webpack_require__) { 2808 2809"use strict"; 2810 2811var call = __webpack_require__(7); 2812var anObject = __webpack_require__(45); 2813var getMethod = __webpack_require__(28); 2814 2815module.exports = function (iterator, kind, value) { 2816 var innerResult, innerError; 2817 anObject(iterator); 2818 try { 2819 innerResult = getMethod(iterator, 'return'); 2820 if (!innerResult) { 2821 if (kind === 'throw') throw value; 2822 return value; 2823 } 2824 innerResult = call(innerResult, iterator); 2825 } catch (error) { 2826 innerError = true; 2827 innerResult = error; 2828 } 2829 if (kind === 'throw') throw value; 2830 if (innerError) throw innerResult; 2831 anObject(innerResult); 2832 return value; 2833}; 2834 2835 2836/***/ }), 2837/* 95 */ 2838/***/ (function(module, exports, __webpack_require__) { 2839 2840"use strict"; 2841 2842var DESCRIPTORS = __webpack_require__(5); 2843var definePropertyModule = __webpack_require__(43); 2844var createPropertyDescriptor = __webpack_require__(10); 2845 2846module.exports = function (object, key, value) { 2847 if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value)); 2848 else object[key] = value; 2849}; 2850 2851 2852/***/ }), 2853/* 96 */ 2854/***/ (function(module, exports, __webpack_require__) { 2855 2856"use strict"; 2857 2858var $TypeError = TypeError; 2859 2860module.exports = function (passed, required) { 2861 if (passed < required) throw new $TypeError('Not enough arguments'); 2862 return passed; 2863}; 2864 2865 2866/***/ }), 2867/* 97 */ 2868/***/ (function(module, exports, __webpack_require__) { 2869 2870"use strict"; 2871 2872var call = __webpack_require__(7); 2873var hasOwn = __webpack_require__(37); 2874var isPrototypeOf = __webpack_require__(23); 2875var regExpFlags = __webpack_require__(98); 2876 2877var RegExpPrototype = RegExp.prototype; 2878 2879module.exports = function (R) { 2880 var flags = R.flags; 2881 return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R) 2882 ? call(regExpFlags, R) : flags; 2883}; 2884 2885 2886/***/ }), 2887/* 98 */ 2888/***/ (function(module, exports, __webpack_require__) { 2889 2890"use strict"; 2891 2892var anObject = __webpack_require__(45); 2893 2894// `RegExp.prototype.flags` getter implementation 2895// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags 2896module.exports = function () { 2897 var that = anObject(this); 2898 var result = ''; 2899 if (that.hasIndices) result += 'd'; 2900 if (that.global) result += 'g'; 2901 if (that.ignoreCase) result += 'i'; 2902 if (that.multiline) result += 'm'; 2903 if (that.dotAll) result += 's'; 2904 if (that.unicode) result += 'u'; 2905 if (that.unicodeSets) result += 'v'; 2906 if (that.sticky) result += 'y'; 2907 return result; 2908}; 2909 2910 2911/***/ }), 2912/* 99 */ 2913/***/ (function(module, exports, __webpack_require__) { 2914 2915"use strict"; 2916 2917var uncurryThis = __webpack_require__(13); 2918 2919// eslint-disable-next-line es/no-map -- safe 2920var MapPrototype = Map.prototype; 2921 2922module.exports = { 2923 // eslint-disable-next-line es/no-map -- safe 2924 Map: Map, 2925 set: uncurryThis(MapPrototype.set), 2926 get: uncurryThis(MapPrototype.get), 2927 has: uncurryThis(MapPrototype.has), 2928 remove: uncurryThis(MapPrototype['delete']), 2929 proto: MapPrototype 2930}; 2931 2932 2933/***/ }), 2934/* 100 */ 2935/***/ (function(module, exports, __webpack_require__) { 2936 2937"use strict"; 2938 2939var uncurryThis = __webpack_require__(13); 2940 2941// eslint-disable-next-line es/no-set -- safe 2942var SetPrototype = Set.prototype; 2943 2944module.exports = { 2945 // eslint-disable-next-line es/no-set -- safe 2946 Set: Set, 2947 add: uncurryThis(SetPrototype.add), 2948 has: uncurryThis(SetPrototype.has), 2949 remove: uncurryThis(SetPrototype['delete']), 2950 proto: SetPrototype 2951}; 2952 2953 2954/***/ }), 2955/* 101 */ 2956/***/ (function(module, exports, __webpack_require__) { 2957 2958"use strict"; 2959 2960var uncurryThis = __webpack_require__(13); 2961var iterateSimple = __webpack_require__(102); 2962var SetHelpers = __webpack_require__(100); 2963 2964var Set = SetHelpers.Set; 2965var SetPrototype = SetHelpers.proto; 2966var forEach = uncurryThis(SetPrototype.forEach); 2967var keys = uncurryThis(SetPrototype.keys); 2968var next = keys(new Set()).next; 2969 2970module.exports = function (set, fn, interruptible) { 2971 return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn); 2972}; 2973 2974 2975/***/ }), 2976/* 102 */ 2977/***/ (function(module, exports, __webpack_require__) { 2978 2979"use strict"; 2980 2981var call = __webpack_require__(7); 2982 2983module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) { 2984 var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator; 2985 var next = record.next; 2986 var step, result; 2987 while (!(step = call(next, iterator)).done) { 2988 result = fn(step.value); 2989 if (result !== undefined) return result; 2990 } 2991}; 2992 2993 2994/***/ }), 2995/* 103 */ 2996/***/ (function(module, exports, __webpack_require__) { 2997 2998"use strict"; 2999 3000var globalThis = __webpack_require__(3); 3001var getBuiltInNodeModule = __webpack_require__(104); 3002var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(107); 3003 3004var structuredClone = globalThis.structuredClone; 3005var $ArrayBuffer = globalThis.ArrayBuffer; 3006var $MessageChannel = globalThis.MessageChannel; 3007var detach = false; 3008var WorkerThreads, channel, buffer, $detach; 3009 3010if (PROPER_STRUCTURED_CLONE_TRANSFER) { 3011 detach = function (transferable) { 3012 structuredClone(transferable, { transfer: [transferable] }); 3013 }; 3014} else if ($ArrayBuffer) try { 3015 if (!$MessageChannel) { 3016 WorkerThreads = getBuiltInNodeModule('worker_threads'); 3017 if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel; 3018 } 3019 3020 if ($MessageChannel) { 3021 channel = new $MessageChannel(); 3022 buffer = new $ArrayBuffer(2); 3023 3024 $detach = function (transferable) { 3025 channel.port1.postMessage(null, [transferable]); 3026 }; 3027 3028 if (buffer.byteLength === 2) { 3029 $detach(buffer); 3030 if (buffer.byteLength === 0) detach = $detach; 3031 } 3032 } 3033} catch (error) { /* empty */ } 3034 3035module.exports = detach; 3036 3037 3038/***/ }), 3039/* 104 */ 3040/***/ (function(module, exports, __webpack_require__) { 3041 3042"use strict"; 3043 3044var globalThis = __webpack_require__(3); 3045var IS_NODE = __webpack_require__(105); 3046 3047module.exports = function (name) { 3048 if (IS_NODE) { 3049 try { 3050 return globalThis.process.getBuiltinModule(name); 3051 } catch (error) { /* empty */ } 3052 try { 3053 // eslint-disable-next-line no-new-func -- safe 3054 return Function('return require("' + name + '")')(); 3055 } catch (error) { /* empty */ } 3056 } 3057}; 3058 3059 3060/***/ }), 3061/* 105 */ 3062/***/ (function(module, exports, __webpack_require__) { 3063 3064"use strict"; 3065 3066var ENVIRONMENT = __webpack_require__(106); 3067 3068module.exports = ENVIRONMENT === 'NODE'; 3069 3070 3071/***/ }), 3072/* 106 */ 3073/***/ (function(module, exports, __webpack_require__) { 3074 3075"use strict"; 3076 3077/* global Bun, Deno -- detection */ 3078var globalThis = __webpack_require__(3); 3079var userAgent = __webpack_require__(27); 3080var classof = __webpack_require__(14); 3081 3082var userAgentStartsWith = function (string) { 3083 return userAgent.slice(0, string.length) === string; 3084}; 3085 3086module.exports = (function () { 3087 if (userAgentStartsWith('Bun/')) return 'BUN'; 3088 if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE'; 3089 if (userAgentStartsWith('Deno/')) return 'DENO'; 3090 if (userAgentStartsWith('Node.js/')) return 'NODE'; 3091 if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN'; 3092 if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO'; 3093 if (classof(globalThis.process) === 'process') return 'NODE'; 3094 if (globalThis.window && globalThis.document) return 'BROWSER'; 3095 return 'REST'; 3096})(); 3097 3098 3099/***/ }), 3100/* 107 */ 3101/***/ (function(module, exports, __webpack_require__) { 3102 3103"use strict"; 3104 3105var globalThis = __webpack_require__(3); 3106var fails = __webpack_require__(6); 3107var V8 = __webpack_require__(26); 3108var ENVIRONMENT = __webpack_require__(106); 3109 3110var structuredClone = globalThis.structuredClone; 3111 3112module.exports = !!structuredClone && !fails(function () { 3113 // prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation 3114 // https://github.com/zloirock/core-js/issues/679 3115 if ((ENVIRONMENT === 'DENO' && V8 > 92) || (ENVIRONMENT === 'NODE' && V8 > 94) || (ENVIRONMENT === 'BROWSER' && V8 > 97)) return false; 3116 var buffer = new ArrayBuffer(8); 3117 var clone = structuredClone(buffer, { transfer: [buffer] }); 3118 return buffer.byteLength !== 0 || clone.byteLength !== 8; 3119}); 3120 3121 3122/***/ }), 3123/* 108 */ 3124/***/ (function(module, exports, __webpack_require__) { 3125 3126"use strict"; 3127 3128var fails = __webpack_require__(6); 3129var createPropertyDescriptor = __webpack_require__(10); 3130 3131module.exports = !fails(function () { 3132 var error = new Error('a'); 3133 if (!('stack' in error)) return true; 3134 // eslint-disable-next-line es/no-object-defineproperty -- safe 3135 Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7)); 3136 return error.stack !== 7; 3137}); 3138 3139 3140/***/ }), 3141/* 109 */ 3142/***/ (function(module, exports, __webpack_require__) { 3143 3144"use strict"; 3145 3146var $ = __webpack_require__(2); 3147var getBuiltIn = __webpack_require__(22); 3148var fails = __webpack_require__(6); 3149var validateArgumentsLength = __webpack_require__(96); 3150var toString = __webpack_require__(80); 3151var USE_NATIVE_URL = __webpack_require__(110); 3152 3153var URL = getBuiltIn('URL'); 3154 3155// https://github.com/nodejs/node/issues/47505 3156// https://github.com/denoland/deno/issues/18893 3157var THROWS_WITHOUT_ARGUMENTS = USE_NATIVE_URL && fails(function () { 3158 URL.canParse(); 3159}); 3160 3161// Bun ~ 1.0.30 bug 3162// https://github.com/oven-sh/bun/issues/9250 3163var WRONG_ARITY = fails(function () { 3164 return URL.canParse.length !== 1; 3165}); 3166 3167// `URL.canParse` method 3168// https://url.spec.whatwg.org/#dom-url-canparse 3169$({ target: 'URL', stat: true, forced: !THROWS_WITHOUT_ARGUMENTS || WRONG_ARITY }, { 3170 canParse: function canParse(url) { 3171 var length = validateArgumentsLength(arguments.length, 1); 3172 var urlString = toString(url); 3173 var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]); 3174 try { 3175 return !!new URL(urlString, base); 3176 } catch (error) { 3177 return false; 3178 } 3179 } 3180}); 3181 3182 3183/***/ }), 3184/* 110 */ 3185/***/ (function(module, exports, __webpack_require__) { 3186 3187"use strict"; 3188 3189var fails = __webpack_require__(6); 3190var wellKnownSymbol = __webpack_require__(32); 3191var DESCRIPTORS = __webpack_require__(5); 3192var IS_PURE = __webpack_require__(35); 3193 3194var ITERATOR = wellKnownSymbol('iterator'); 3195 3196module.exports = !fails(function () { 3197 // eslint-disable-next-line unicorn/relative-url-style -- required for testing 3198 var url = new URL('b?a=1&b=2&c=3', 'https://a'); 3199 var params = url.searchParams; 3200 var params2 = new URLSearchParams('a=1&a=2&b=3'); 3201 var result = ''; 3202 url.pathname = 'c%20d'; 3203 params.forEach(function (value, key) { 3204 params['delete']('b'); 3205 result += key + value; 3206 }); 3207 params2['delete']('a', 2); 3208 // `undefined` case is a Chromium 117 bug 3209 // https://bugs.chromium.org/p/v8/issues/detail?id=14222 3210 params2['delete']('b', undefined); 3211 return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b'))) 3212 || (!params.size && (IS_PURE || !DESCRIPTORS)) 3213 || !params.sort 3214 || url.href !== 'https://a/c%20d?a=1&c=3' 3215 || params.get('c') !== '3' 3216 || String(new URLSearchParams('?a=1')) !== 'a=1' 3217 || !params[ITERATOR] 3218 // throws in Edge 3219 || new URL('https://a@b').username !== 'a' 3220 || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' 3221 // not punycoded in Edge 3222 || new URL('https://ÑеÑÑ').host !== 'xn--e1aybc' 3223 // not escaped in Chrome 62- 3224 || new URL('https://a#б').hash !== '#%D0%B1' 3225 // fails in Chrome 66- 3226 || result !== 'a1c3' 3227 // throws in Safari 3228 || new URL('https://x', undefined).host !== 'x'; 3229}); 3230 3231 3232/***/ }), 3233/* 111 */ 3234/***/ (function(module, exports, __webpack_require__) { 3235 3236"use strict"; 3237 3238var $ = __webpack_require__(2); 3239var getBuiltIn = __webpack_require__(22); 3240var validateArgumentsLength = __webpack_require__(96); 3241var toString = __webpack_require__(80); 3242var USE_NATIVE_URL = __webpack_require__(110); 3243 3244var URL = getBuiltIn('URL'); 3245 3246// `URL.parse` method 3247// https://url.spec.whatwg.org/#dom-url-canparse 3248$({ target: 'URL', stat: true, forced: !USE_NATIVE_URL }, { 3249 parse: function parse(url) { 3250 var length = validateArgumentsLength(arguments.length, 1); 3251 var urlString = toString(url); 3252 var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]); 3253 try { 3254 return new URL(urlString, base); 3255 } catch (error) { 3256 return null; 3257 } 3258 } 3259}); 3260 3261 3262/***/ }) 3263/******/ ]); }();
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.