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