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