PageRenderTime 134ms CodeModel.GetById 24ms app.highlight 87ms RepoModel.GetById 1ms app.codeStats 1ms

/node_modules/babel-polyfill/node_modules/core-js/client/shim.js

https://bitbucket.org/worklabschd/bingle_customer2
JavaScript | 8197 lines | 8091 code | 46 blank | 60 comment | 56 complexity | a24d2901c96d7b162caee61c6a3b3622 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/**
   2 * core-js 2.5.5
   3 * https://github.com/zloirock/core-js
   4 * License: http://rock.mit-license.org
   5 * © 2018 Denis Pushkarev
   6 */
   7!function(__e, __g, undefined){
   8'use strict';
   9/******/ (function(modules) { // webpackBootstrap
  10/******/ 	// The module cache
  11/******/ 	var installedModules = {};
  12/******/
  13/******/ 	// The require function
  14/******/ 	function __webpack_require__(moduleId) {
  15/******/
  16/******/ 		// Check if module is in cache
  17/******/ 		if(installedModules[moduleId]) {
  18/******/ 			return installedModules[moduleId].exports;
  19/******/ 		}
  20/******/ 		// Create a new module (and put it into the cache)
  21/******/ 		var module = installedModules[moduleId] = {
  22/******/ 			i: moduleId,
  23/******/ 			l: false,
  24/******/ 			exports: {}
  25/******/ 		};
  26/******/
  27/******/ 		// Execute the module function
  28/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  29/******/
  30/******/ 		// Flag the module as loaded
  31/******/ 		module.l = true;
  32/******/
  33/******/ 		// Return the exports of the module
  34/******/ 		return module.exports;
  35/******/ 	}
  36/******/
  37/******/
  38/******/ 	// expose the modules object (__webpack_modules__)
  39/******/ 	__webpack_require__.m = modules;
  40/******/
  41/******/ 	// expose the module cache
  42/******/ 	__webpack_require__.c = installedModules;
  43/******/
  44/******/ 	// define getter function for harmony exports
  45/******/ 	__webpack_require__.d = function(exports, name, getter) {
  46/******/ 		if(!__webpack_require__.o(exports, name)) {
  47/******/ 			Object.defineProperty(exports, name, {
  48/******/ 				configurable: false,
  49/******/ 				enumerable: true,
  50/******/ 				get: getter
  51/******/ 			});
  52/******/ 		}
  53/******/ 	};
  54/******/
  55/******/ 	// getDefaultExport function for compatibility with non-harmony modules
  56/******/ 	__webpack_require__.n = function(module) {
  57/******/ 		var getter = module && module.__esModule ?
  58/******/ 			function getDefault() { return module['default']; } :
  59/******/ 			function getModuleExports() { return module; };
  60/******/ 		__webpack_require__.d(getter, 'a', getter);
  61/******/ 		return getter;
  62/******/ 	};
  63/******/
  64/******/ 	// Object.prototype.hasOwnProperty.call
  65/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  66/******/
  67/******/ 	// __webpack_public_path__
  68/******/ 	__webpack_require__.p = "";
  69/******/
  70/******/ 	// Load entry module and return exports
  71/******/ 	return __webpack_require__(__webpack_require__.s = 124);
  72/******/ })
  73/************************************************************************/
  74/******/ ([
  75/* 0 */
  76/***/ (function(module, exports, __webpack_require__) {
  77
  78var global = __webpack_require__(2);
  79var core = __webpack_require__(28);
  80var hide = __webpack_require__(11);
  81var redefine = __webpack_require__(12);
  82var ctx = __webpack_require__(18);
  83var PROTOTYPE = 'prototype';
  84
  85var $export = function (type, name, source) {
  86  var IS_FORCED = type & $export.F;
  87  var IS_GLOBAL = type & $export.G;
  88  var IS_STATIC = type & $export.S;
  89  var IS_PROTO = type & $export.P;
  90  var IS_BIND = type & $export.B;
  91  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
  92  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
  93  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
  94  var key, own, out, exp;
  95  if (IS_GLOBAL) source = name;
  96  for (key in source) {
  97    // contains in native
  98    own = !IS_FORCED && target && target[key] !== undefined;
  99    // export native or passed
 100    out = (own ? target : source)[key];
 101    // bind timers to global for call from export context
 102    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
 103    // extend global
 104    if (target) redefine(target, key, out, type & $export.U);
 105    // export
 106    if (exports[key] != out) hide(exports, key, exp);
 107    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
 108  }
 109};
 110global.core = core;
 111// type bitmap
 112$export.F = 1;   // forced
 113$export.G = 2;   // global
 114$export.S = 4;   // static
 115$export.P = 8;   // proto
 116$export.B = 16;  // bind
 117$export.W = 32;  // wrap
 118$export.U = 64;  // safe
 119$export.R = 128; // real proto method for `library`
 120module.exports = $export;
 121
 122
 123/***/ }),
 124/* 1 */
 125/***/ (function(module, exports, __webpack_require__) {
 126
 127var isObject = __webpack_require__(4);
 128module.exports = function (it) {
 129  if (!isObject(it)) throw TypeError(it + ' is not an object!');
 130  return it;
 131};
 132
 133
 134/***/ }),
 135/* 2 */
 136/***/ (function(module, exports) {
 137
 138// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
 139var global = module.exports = typeof window != 'undefined' && window.Math == Math
 140  ? window : typeof self != 'undefined' && self.Math == Math ? self
 141  // eslint-disable-next-line no-new-func
 142  : Function('return this')();
 143if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
 144
 145
 146/***/ }),
 147/* 3 */
 148/***/ (function(module, exports) {
 149
 150module.exports = function (exec) {
 151  try {
 152    return !!exec();
 153  } catch (e) {
 154    return true;
 155  }
 156};
 157
 158
 159/***/ }),
 160/* 4 */
 161/***/ (function(module, exports) {
 162
 163module.exports = function (it) {
 164  return typeof it === 'object' ? it !== null : typeof it === 'function';
 165};
 166
 167
 168/***/ }),
 169/* 5 */
 170/***/ (function(module, exports, __webpack_require__) {
 171
 172var store = __webpack_require__(49)('wks');
 173var uid = __webpack_require__(32);
 174var Symbol = __webpack_require__(2).Symbol;
 175var USE_SYMBOL = typeof Symbol == 'function';
 176
 177var $exports = module.exports = function (name) {
 178  return store[name] || (store[name] =
 179    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
 180};
 181
 182$exports.store = store;
 183
 184
 185/***/ }),
 186/* 6 */
 187/***/ (function(module, exports, __webpack_require__) {
 188
 189// Thank's IE8 for his funny defineProperty
 190module.exports = !__webpack_require__(3)(function () {
 191  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
 192});
 193
 194
 195/***/ }),
 196/* 7 */
 197/***/ (function(module, exports, __webpack_require__) {
 198
 199var anObject = __webpack_require__(1);
 200var IE8_DOM_DEFINE = __webpack_require__(90);
 201var toPrimitive = __webpack_require__(21);
 202var dP = Object.defineProperty;
 203
 204exports.f = __webpack_require__(6) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
 205  anObject(O);
 206  P = toPrimitive(P, true);
 207  anObject(Attributes);
 208  if (IE8_DOM_DEFINE) try {
 209    return dP(O, P, Attributes);
 210  } catch (e) { /* empty */ }
 211  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
 212  if ('value' in Attributes) O[P] = Attributes.value;
 213  return O;
 214};
 215
 216
 217/***/ }),
 218/* 8 */
 219/***/ (function(module, exports, __webpack_require__) {
 220
 221// 7.1.15 ToLength
 222var toInteger = __webpack_require__(23);
 223var min = Math.min;
 224module.exports = function (it) {
 225  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
 226};
 227
 228
 229/***/ }),
 230/* 9 */
 231/***/ (function(module, exports, __webpack_require__) {
 232
 233// 7.1.13 ToObject(argument)
 234var defined = __webpack_require__(22);
 235module.exports = function (it) {
 236  return Object(defined(it));
 237};
 238
 239
 240/***/ }),
 241/* 10 */
 242/***/ (function(module, exports) {
 243
 244module.exports = function (it) {
 245  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
 246  return it;
 247};
 248
 249
 250/***/ }),
 251/* 11 */
 252/***/ (function(module, exports, __webpack_require__) {
 253
 254var dP = __webpack_require__(7);
 255var createDesc = __webpack_require__(31);
 256module.exports = __webpack_require__(6) ? function (object, key, value) {
 257  return dP.f(object, key, createDesc(1, value));
 258} : function (object, key, value) {
 259  object[key] = value;
 260  return object;
 261};
 262
 263
 264/***/ }),
 265/* 12 */
 266/***/ (function(module, exports, __webpack_require__) {
 267
 268var global = __webpack_require__(2);
 269var hide = __webpack_require__(11);
 270var has = __webpack_require__(14);
 271var SRC = __webpack_require__(32)('src');
 272var TO_STRING = 'toString';
 273var $toString = Function[TO_STRING];
 274var TPL = ('' + $toString).split(TO_STRING);
 275
 276__webpack_require__(28).inspectSource = function (it) {
 277  return $toString.call(it);
 278};
 279
 280(module.exports = function (O, key, val, safe) {
 281  var isFunction = typeof val == 'function';
 282  if (isFunction) has(val, 'name') || hide(val, 'name', key);
 283  if (O[key] === val) return;
 284  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
 285  if (O === global) {
 286    O[key] = val;
 287  } else if (!safe) {
 288    delete O[key];
 289    hide(O, key, val);
 290  } else if (O[key]) {
 291    O[key] = val;
 292  } else {
 293    hide(O, key, val);
 294  }
 295// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
 296})(Function.prototype, TO_STRING, function toString() {
 297  return typeof this == 'function' && this[SRC] || $toString.call(this);
 298});
 299
 300
 301/***/ }),
 302/* 13 */
 303/***/ (function(module, exports, __webpack_require__) {
 304
 305var $export = __webpack_require__(0);
 306var fails = __webpack_require__(3);
 307var defined = __webpack_require__(22);
 308var quot = /"/g;
 309// B.2.3.2.1 CreateHTML(string, tag, attribute, value)
 310var createHTML = function (string, tag, attribute, value) {
 311  var S = String(defined(string));
 312  var p1 = '<' + tag;
 313  if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '&quot;') + '"';
 314  return p1 + '>' + S + '</' + tag + '>';
 315};
 316module.exports = function (NAME, exec) {
 317  var O = {};
 318  O[NAME] = exec(createHTML);
 319  $export($export.P + $export.F * fails(function () {
 320    var test = ''[NAME]('"');
 321    return test !== test.toLowerCase() || test.split('"').length > 3;
 322  }), 'String', O);
 323};
 324
 325
 326/***/ }),
 327/* 14 */
 328/***/ (function(module, exports) {
 329
 330var hasOwnProperty = {}.hasOwnProperty;
 331module.exports = function (it, key) {
 332  return hasOwnProperty.call(it, key);
 333};
 334
 335
 336/***/ }),
 337/* 15 */
 338/***/ (function(module, exports, __webpack_require__) {
 339
 340// to indexed object, toObject with fallback for non-array-like ES3 strings
 341var IObject = __webpack_require__(46);
 342var defined = __webpack_require__(22);
 343module.exports = function (it) {
 344  return IObject(defined(it));
 345};
 346
 347
 348/***/ }),
 349/* 16 */
 350/***/ (function(module, exports, __webpack_require__) {
 351
 352var pIE = __webpack_require__(47);
 353var createDesc = __webpack_require__(31);
 354var toIObject = __webpack_require__(15);
 355var toPrimitive = __webpack_require__(21);
 356var has = __webpack_require__(14);
 357var IE8_DOM_DEFINE = __webpack_require__(90);
 358var gOPD = Object.getOwnPropertyDescriptor;
 359
 360exports.f = __webpack_require__(6) ? gOPD : function getOwnPropertyDescriptor(O, P) {
 361  O = toIObject(O);
 362  P = toPrimitive(P, true);
 363  if (IE8_DOM_DEFINE) try {
 364    return gOPD(O, P);
 365  } catch (e) { /* empty */ }
 366  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
 367};
 368
 369
 370/***/ }),
 371/* 17 */
 372/***/ (function(module, exports, __webpack_require__) {
 373
 374// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
 375var has = __webpack_require__(14);
 376var toObject = __webpack_require__(9);
 377var IE_PROTO = __webpack_require__(65)('IE_PROTO');
 378var ObjectProto = Object.prototype;
 379
 380module.exports = Object.getPrototypeOf || function (O) {
 381  O = toObject(O);
 382  if (has(O, IE_PROTO)) return O[IE_PROTO];
 383  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
 384    return O.constructor.prototype;
 385  } return O instanceof Object ? ObjectProto : null;
 386};
 387
 388
 389/***/ }),
 390/* 18 */
 391/***/ (function(module, exports, __webpack_require__) {
 392
 393// optional / simple context binding
 394var aFunction = __webpack_require__(10);
 395module.exports = function (fn, that, length) {
 396  aFunction(fn);
 397  if (that === undefined) return fn;
 398  switch (length) {
 399    case 1: return function (a) {
 400      return fn.call(that, a);
 401    };
 402    case 2: return function (a, b) {
 403      return fn.call(that, a, b);
 404    };
 405    case 3: return function (a, b, c) {
 406      return fn.call(that, a, b, c);
 407    };
 408  }
 409  return function (/* ...args */) {
 410    return fn.apply(that, arguments);
 411  };
 412};
 413
 414
 415/***/ }),
 416/* 19 */
 417/***/ (function(module, exports) {
 418
 419var toString = {}.toString;
 420
 421module.exports = function (it) {
 422  return toString.call(it).slice(8, -1);
 423};
 424
 425
 426/***/ }),
 427/* 20 */
 428/***/ (function(module, exports, __webpack_require__) {
 429
 430"use strict";
 431
 432var fails = __webpack_require__(3);
 433
 434module.exports = function (method, arg) {
 435  return !!method && fails(function () {
 436    // eslint-disable-next-line no-useless-call
 437    arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);
 438  });
 439};
 440
 441
 442/***/ }),
 443/* 21 */
 444/***/ (function(module, exports, __webpack_require__) {
 445
 446// 7.1.1 ToPrimitive(input [, PreferredType])
 447var isObject = __webpack_require__(4);
 448// instead of the ES6 spec version, we didn't implement @@toPrimitive case
 449// and the second argument - flag - preferred type is a string
 450module.exports = function (it, S) {
 451  if (!isObject(it)) return it;
 452  var fn, val;
 453  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
 454  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
 455  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
 456  throw TypeError("Can't convert object to primitive value");
 457};
 458
 459
 460/***/ }),
 461/* 22 */
 462/***/ (function(module, exports) {
 463
 464// 7.2.1 RequireObjectCoercible(argument)
 465module.exports = function (it) {
 466  if (it == undefined) throw TypeError("Can't call method on  " + it);
 467  return it;
 468};
 469
 470
 471/***/ }),
 472/* 23 */
 473/***/ (function(module, exports) {
 474
 475// 7.1.4 ToInteger
 476var ceil = Math.ceil;
 477var floor = Math.floor;
 478module.exports = function (it) {
 479  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
 480};
 481
 482
 483/***/ }),
 484/* 24 */
 485/***/ (function(module, exports, __webpack_require__) {
 486
 487// most Object methods by ES6 should accept primitives
 488var $export = __webpack_require__(0);
 489var core = __webpack_require__(28);
 490var fails = __webpack_require__(3);
 491module.exports = function (KEY, exec) {
 492  var fn = (core.Object || {})[KEY] || Object[KEY];
 493  var exp = {};
 494  exp[KEY] = exec(fn);
 495  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
 496};
 497
 498
 499/***/ }),
 500/* 25 */
 501/***/ (function(module, exports, __webpack_require__) {
 502
 503// 0 -> Array#forEach
 504// 1 -> Array#map
 505// 2 -> Array#filter
 506// 3 -> Array#some
 507// 4 -> Array#every
 508// 5 -> Array#find
 509// 6 -> Array#findIndex
 510var ctx = __webpack_require__(18);
 511var IObject = __webpack_require__(46);
 512var toObject = __webpack_require__(9);
 513var toLength = __webpack_require__(8);
 514var asc = __webpack_require__(82);
 515module.exports = function (TYPE, $create) {
 516  var IS_MAP = TYPE == 1;
 517  var IS_FILTER = TYPE == 2;
 518  var IS_SOME = TYPE == 3;
 519  var IS_EVERY = TYPE == 4;
 520  var IS_FIND_INDEX = TYPE == 6;
 521  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
 522  var create = $create || asc;
 523  return function ($this, callbackfn, that) {
 524    var O = toObject($this);
 525    var self = IObject(O);
 526    var f = ctx(callbackfn, that, 3);
 527    var length = toLength(self.length);
 528    var index = 0;
 529    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
 530    var val, res;
 531    for (;length > index; index++) if (NO_HOLES || index in self) {
 532      val = self[index];
 533      res = f(val, index, O);
 534      if (TYPE) {
 535        if (IS_MAP) result[index] = res;   // map
 536        else if (res) switch (TYPE) {
 537          case 3: return true;             // some
 538          case 5: return val;              // find
 539          case 6: return index;            // findIndex
 540          case 2: result.push(val);        // filter
 541        } else if (IS_EVERY) return false; // every
 542      }
 543    }
 544    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
 545  };
 546};
 547
 548
 549/***/ }),
 550/* 26 */
 551/***/ (function(module, exports, __webpack_require__) {
 552
 553"use strict";
 554
 555if (__webpack_require__(6)) {
 556  var LIBRARY = __webpack_require__(33);
 557  var global = __webpack_require__(2);
 558  var fails = __webpack_require__(3);
 559  var $export = __webpack_require__(0);
 560  var $typed = __webpack_require__(59);
 561  var $buffer = __webpack_require__(88);
 562  var ctx = __webpack_require__(18);
 563  var anInstance = __webpack_require__(39);
 564  var propertyDesc = __webpack_require__(31);
 565  var hide = __webpack_require__(11);
 566  var redefineAll = __webpack_require__(41);
 567  var toInteger = __webpack_require__(23);
 568  var toLength = __webpack_require__(8);
 569  var toIndex = __webpack_require__(117);
 570  var toAbsoluteIndex = __webpack_require__(35);
 571  var toPrimitive = __webpack_require__(21);
 572  var has = __webpack_require__(14);
 573  var classof = __webpack_require__(48);
 574  var isObject = __webpack_require__(4);
 575  var toObject = __webpack_require__(9);
 576  var isArrayIter = __webpack_require__(79);
 577  var create = __webpack_require__(36);
 578  var getPrototypeOf = __webpack_require__(17);
 579  var gOPN = __webpack_require__(37).f;
 580  var getIterFn = __webpack_require__(81);
 581  var uid = __webpack_require__(32);
 582  var wks = __webpack_require__(5);
 583  var createArrayMethod = __webpack_require__(25);
 584  var createArrayIncludes = __webpack_require__(50);
 585  var speciesConstructor = __webpack_require__(57);
 586  var ArrayIterators = __webpack_require__(84);
 587  var Iterators = __webpack_require__(44);
 588  var $iterDetect = __webpack_require__(54);
 589  var setSpecies = __webpack_require__(38);
 590  var arrayFill = __webpack_require__(83);
 591  var arrayCopyWithin = __webpack_require__(106);
 592  var $DP = __webpack_require__(7);
 593  var $GOPD = __webpack_require__(16);
 594  var dP = $DP.f;
 595  var gOPD = $GOPD.f;
 596  var RangeError = global.RangeError;
 597  var TypeError = global.TypeError;
 598  var Uint8Array = global.Uint8Array;
 599  var ARRAY_BUFFER = 'ArrayBuffer';
 600  var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER;
 601  var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
 602  var PROTOTYPE = 'prototype';
 603  var ArrayProto = Array[PROTOTYPE];
 604  var $ArrayBuffer = $buffer.ArrayBuffer;
 605  var $DataView = $buffer.DataView;
 606  var arrayForEach = createArrayMethod(0);
 607  var arrayFilter = createArrayMethod(2);
 608  var arraySome = createArrayMethod(3);
 609  var arrayEvery = createArrayMethod(4);
 610  var arrayFind = createArrayMethod(5);
 611  var arrayFindIndex = createArrayMethod(6);
 612  var arrayIncludes = createArrayIncludes(true);
 613  var arrayIndexOf = createArrayIncludes(false);
 614  var arrayValues = ArrayIterators.values;
 615  var arrayKeys = ArrayIterators.keys;
 616  var arrayEntries = ArrayIterators.entries;
 617  var arrayLastIndexOf = ArrayProto.lastIndexOf;
 618  var arrayReduce = ArrayProto.reduce;
 619  var arrayReduceRight = ArrayProto.reduceRight;
 620  var arrayJoin = ArrayProto.join;
 621  var arraySort = ArrayProto.sort;
 622  var arraySlice = ArrayProto.slice;
 623  var arrayToString = ArrayProto.toString;
 624  var arrayToLocaleString = ArrayProto.toLocaleString;
 625  var ITERATOR = wks('iterator');
 626  var TAG = wks('toStringTag');
 627  var TYPED_CONSTRUCTOR = uid('typed_constructor');
 628  var DEF_CONSTRUCTOR = uid('def_constructor');
 629  var ALL_CONSTRUCTORS = $typed.CONSTR;
 630  var TYPED_ARRAY = $typed.TYPED;
 631  var VIEW = $typed.VIEW;
 632  var WRONG_LENGTH = 'Wrong length!';
 633
 634  var $map = createArrayMethod(1, function (O, length) {
 635    return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
 636  });
 637
 638  var LITTLE_ENDIAN = fails(function () {
 639    // eslint-disable-next-line no-undef
 640    return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
 641  });
 642
 643  var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () {
 644    new Uint8Array(1).set({});
 645  });
 646
 647  var toOffset = function (it, BYTES) {
 648    var offset = toInteger(it);
 649    if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!');
 650    return offset;
 651  };
 652
 653  var validate = function (it) {
 654    if (isObject(it) && TYPED_ARRAY in it) return it;
 655    throw TypeError(it + ' is not a typed array!');
 656  };
 657
 658  var allocate = function (C, length) {
 659    if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {
 660      throw TypeError('It is not a typed array constructor!');
 661    } return new C(length);
 662  };
 663
 664  var speciesFromList = function (O, list) {
 665    return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
 666  };
 667
 668  var fromList = function (C, list) {
 669    var index = 0;
 670    var length = list.length;
 671    var result = allocate(C, length);
 672    while (length > index) result[index] = list[index++];
 673    return result;
 674  };
 675
 676  var addGetter = function (it, key, internal) {
 677    dP(it, key, { get: function () { return this._d[internal]; } });
 678  };
 679
 680  var $from = function from(source /* , mapfn, thisArg */) {
 681    var O = toObject(source);
 682    var aLen = arguments.length;
 683    var mapfn = aLen > 1 ? arguments[1] : undefined;
 684    var mapping = mapfn !== undefined;
 685    var iterFn = getIterFn(O);
 686    var i, length, values, result, step, iterator;
 687    if (iterFn != undefined && !isArrayIter(iterFn)) {
 688      for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) {
 689        values.push(step.value);
 690      } O = values;
 691    }
 692    if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);
 693    for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) {
 694      result[i] = mapping ? mapfn(O[i], i) : O[i];
 695    }
 696    return result;
 697  };
 698
 699  var $of = function of(/* ...items */) {
 700    var index = 0;
 701    var length = arguments.length;
 702    var result = allocate(this, length);
 703    while (length > index) result[index] = arguments[index++];
 704    return result;
 705  };
 706
 707  // iOS Safari 6.x fails here
 708  var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); });
 709
 710  var $toLocaleString = function toLocaleString() {
 711    return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);
 712  };
 713
 714  var proto = {
 715    copyWithin: function copyWithin(target, start /* , end */) {
 716      return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
 717    },
 718    every: function every(callbackfn /* , thisArg */) {
 719      return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
 720    },
 721    fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars
 722      return arrayFill.apply(validate(this), arguments);
 723    },
 724    filter: function filter(callbackfn /* , thisArg */) {
 725      return speciesFromList(this, arrayFilter(validate(this), callbackfn,
 726        arguments.length > 1 ? arguments[1] : undefined));
 727    },
 728    find: function find(predicate /* , thisArg */) {
 729      return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
 730    },
 731    findIndex: function findIndex(predicate /* , thisArg */) {
 732      return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
 733    },
 734    forEach: function forEach(callbackfn /* , thisArg */) {
 735      arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
 736    },
 737    indexOf: function indexOf(searchElement /* , fromIndex */) {
 738      return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
 739    },
 740    includes: function includes(searchElement /* , fromIndex */) {
 741      return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
 742    },
 743    join: function join(separator) { // eslint-disable-line no-unused-vars
 744      return arrayJoin.apply(validate(this), arguments);
 745    },
 746    lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars
 747      return arrayLastIndexOf.apply(validate(this), arguments);
 748    },
 749    map: function map(mapfn /* , thisArg */) {
 750      return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);
 751    },
 752    reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars
 753      return arrayReduce.apply(validate(this), arguments);
 754    },
 755    reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars
 756      return arrayReduceRight.apply(validate(this), arguments);
 757    },
 758    reverse: function reverse() {
 759      var that = this;
 760      var length = validate(that).length;
 761      var middle = Math.floor(length / 2);
 762      var index = 0;
 763      var value;
 764      while (index < middle) {
 765        value = that[index];
 766        that[index++] = that[--length];
 767        that[length] = value;
 768      } return that;
 769    },
 770    some: function some(callbackfn /* , thisArg */) {
 771      return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
 772    },
 773    sort: function sort(comparefn) {
 774      return arraySort.call(validate(this), comparefn);
 775    },
 776    subarray: function subarray(begin, end) {
 777      var O = validate(this);
 778      var length = O.length;
 779      var $begin = toAbsoluteIndex(begin, length);
 780      return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
 781        O.buffer,
 782        O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
 783        toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)
 784      );
 785    }
 786  };
 787
 788  var $slice = function slice(start, end) {
 789    return speciesFromList(this, arraySlice.call(validate(this), start, end));
 790  };
 791
 792  var $set = function set(arrayLike /* , offset */) {
 793    validate(this);
 794    var offset = toOffset(arguments[1], 1);
 795    var length = this.length;
 796    var src = toObject(arrayLike);
 797    var len = toLength(src.length);
 798    var index = 0;
 799    if (len + offset > length) throw RangeError(WRONG_LENGTH);
 800    while (index < len) this[offset + index] = src[index++];
 801  };
 802
 803  var $iterators = {
 804    entries: function entries() {
 805      return arrayEntries.call(validate(this));
 806    },
 807    keys: function keys() {
 808      return arrayKeys.call(validate(this));
 809    },
 810    values: function values() {
 811      return arrayValues.call(validate(this));
 812    }
 813  };
 814
 815  var isTAIndex = function (target, key) {
 816    return isObject(target)
 817      && target[TYPED_ARRAY]
 818      && typeof key != 'symbol'
 819      && key in target
 820      && String(+key) == String(key);
 821  };
 822  var $getDesc = function getOwnPropertyDescriptor(target, key) {
 823    return isTAIndex(target, key = toPrimitive(key, true))
 824      ? propertyDesc(2, target[key])
 825      : gOPD(target, key);
 826  };
 827  var $setDesc = function defineProperty(target, key, desc) {
 828    if (isTAIndex(target, key = toPrimitive(key, true))
 829      && isObject(desc)
 830      && has(desc, 'value')
 831      && !has(desc, 'get')
 832      && !has(desc, 'set')
 833      // TODO: add validation descriptor w/o calling accessors
 834      && !desc.configurable
 835      && (!has(desc, 'writable') || desc.writable)
 836      && (!has(desc, 'enumerable') || desc.enumerable)
 837    ) {
 838      target[key] = desc.value;
 839      return target;
 840    } return dP(target, key, desc);
 841  };
 842
 843  if (!ALL_CONSTRUCTORS) {
 844    $GOPD.f = $getDesc;
 845    $DP.f = $setDesc;
 846  }
 847
 848  $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {
 849    getOwnPropertyDescriptor: $getDesc,
 850    defineProperty: $setDesc
 851  });
 852
 853  if (fails(function () { arrayToString.call({}); })) {
 854    arrayToString = arrayToLocaleString = function toString() {
 855      return arrayJoin.call(this);
 856    };
 857  }
 858
 859  var $TypedArrayPrototype$ = redefineAll({}, proto);
 860  redefineAll($TypedArrayPrototype$, $iterators);
 861  hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
 862  redefineAll($TypedArrayPrototype$, {
 863    slice: $slice,
 864    set: $set,
 865    constructor: function () { /* noop */ },
 866    toString: arrayToString,
 867    toLocaleString: $toLocaleString
 868  });
 869  addGetter($TypedArrayPrototype$, 'buffer', 'b');
 870  addGetter($TypedArrayPrototype$, 'byteOffset', 'o');
 871  addGetter($TypedArrayPrototype$, 'byteLength', 'l');
 872  addGetter($TypedArrayPrototype$, 'length', 'e');
 873  dP($TypedArrayPrototype$, TAG, {
 874    get: function () { return this[TYPED_ARRAY]; }
 875  });
 876
 877  // eslint-disable-next-line max-statements
 878  module.exports = function (KEY, BYTES, wrapper, CLAMPED) {
 879    CLAMPED = !!CLAMPED;
 880    var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array';
 881    var GETTER = 'get' + KEY;
 882    var SETTER = 'set' + KEY;
 883    var TypedArray = global[NAME];
 884    var Base = TypedArray || {};
 885    var TAC = TypedArray && getPrototypeOf(TypedArray);
 886    var FORCED = !TypedArray || !$typed.ABV;
 887    var O = {};
 888    var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];
 889    var getter = function (that, index) {
 890      var data = that._d;
 891      return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
 892    };
 893    var setter = function (that, index, value) {
 894      var data = that._d;
 895      if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;
 896      data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
 897    };
 898    var addElement = function (that, index) {
 899      dP(that, index, {
 900        get: function () {
 901          return getter(this, index);
 902        },
 903        set: function (value) {
 904          return setter(this, index, value);
 905        },
 906        enumerable: true
 907      });
 908    };
 909    if (FORCED) {
 910      TypedArray = wrapper(function (that, data, $offset, $length) {
 911        anInstance(that, TypedArray, NAME, '_d');
 912        var index = 0;
 913        var offset = 0;
 914        var buffer, byteLength, length, klass;
 915        if (!isObject(data)) {
 916          length = toIndex(data);
 917          byteLength = length * BYTES;
 918          buffer = new $ArrayBuffer(byteLength);
 919        } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {
 920          buffer = data;
 921          offset = toOffset($offset, BYTES);
 922          var $len = data.byteLength;
 923          if ($length === undefined) {
 924            if ($len % BYTES) throw RangeError(WRONG_LENGTH);
 925            byteLength = $len - offset;
 926            if (byteLength < 0) throw RangeError(WRONG_LENGTH);
 927          } else {
 928            byteLength = toLength($length) * BYTES;
 929            if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);
 930          }
 931          length = byteLength / BYTES;
 932        } else if (TYPED_ARRAY in data) {
 933          return fromList(TypedArray, data);
 934        } else {
 935          return $from.call(TypedArray, data);
 936        }
 937        hide(that, '_d', {
 938          b: buffer,
 939          o: offset,
 940          l: byteLength,
 941          e: length,
 942          v: new $DataView(buffer)
 943        });
 944        while (index < length) addElement(that, index++);
 945      });
 946      TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);
 947      hide(TypedArrayPrototype, 'constructor', TypedArray);
 948    } else if (!fails(function () {
 949      TypedArray(1);
 950    }) || !fails(function () {
 951      new TypedArray(-1); // eslint-disable-line no-new
 952    }) || !$iterDetect(function (iter) {
 953      new TypedArray(); // eslint-disable-line no-new
 954      new TypedArray(null); // eslint-disable-line no-new
 955      new TypedArray(1.5); // eslint-disable-line no-new
 956      new TypedArray(iter); // eslint-disable-line no-new
 957    }, true)) {
 958      TypedArray = wrapper(function (that, data, $offset, $length) {
 959        anInstance(that, TypedArray, NAME);
 960        var klass;
 961        // `ws` module bug, temporarily remove validation length for Uint8Array
 962        // https://github.com/websockets/ws/pull/645
 963        if (!isObject(data)) return new Base(toIndex(data));
 964        if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {
 965          return $length !== undefined
 966            ? new Base(data, toOffset($offset, BYTES), $length)
 967            : $offset !== undefined
 968              ? new Base(data, toOffset($offset, BYTES))
 969              : new Base(data);
 970        }
 971        if (TYPED_ARRAY in data) return fromList(TypedArray, data);
 972        return $from.call(TypedArray, data);
 973      });
 974      arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) {
 975        if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);
 976      });
 977      TypedArray[PROTOTYPE] = TypedArrayPrototype;
 978      if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;
 979    }
 980    var $nativeIterator = TypedArrayPrototype[ITERATOR];
 981    var CORRECT_ITER_NAME = !!$nativeIterator
 982      && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined);
 983    var $iterator = $iterators.values;
 984    hide(TypedArray, TYPED_CONSTRUCTOR, true);
 985    hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
 986    hide(TypedArrayPrototype, VIEW, true);
 987    hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);
 988
 989    if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) {
 990      dP(TypedArrayPrototype, TAG, {
 991        get: function () { return NAME; }
 992      });
 993    }
 994
 995    O[NAME] = TypedArray;
 996
 997    $export($export.G + $export.W + $export.F * (TypedArray != Base), O);
 998
 999    $export($export.S, NAME, {
1000      BYTES_PER_ELEMENT: BYTES
1001    });
1002
1003    $export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, {
1004      from: $from,
1005      of: $of
1006    });
1007
1008    if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);
1009
1010    $export($export.P, NAME, proto);
1011
1012    setSpecies(NAME);
1013
1014    $export($export.P + $export.F * FORCED_SET, NAME, { set: $set });
1015
1016    $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);
1017
1018    if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString;
1019
1020    $export($export.P + $export.F * fails(function () {
1021      new TypedArray(1).slice();
1022    }), NAME, { slice: $slice });
1023
1024    $export($export.P + $export.F * (fails(function () {
1025      return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString();
1026    }) || !fails(function () {
1027      TypedArrayPrototype.toLocaleString.call([1, 2]);
1028    })), NAME, { toLocaleString: $toLocaleString });
1029
1030    Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
1031    if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator);
1032  };
1033} else module.exports = function () { /* empty */ };
1034
1035
1036/***/ }),
1037/* 27 */
1038/***/ (function(module, exports, __webpack_require__) {
1039
1040var Map = __webpack_require__(111);
1041var $export = __webpack_require__(0);
1042var shared = __webpack_require__(49)('metadata');
1043var store = shared.store || (shared.store = new (__webpack_require__(114))());
1044
1045var getOrCreateMetadataMap = function (target, targetKey, create) {
1046  var targetMetadata = store.get(target);
1047  if (!targetMetadata) {
1048    if (!create) return undefined;
1049    store.set(target, targetMetadata = new Map());
1050  }
1051  var keyMetadata = targetMetadata.get(targetKey);
1052  if (!keyMetadata) {
1053    if (!create) return undefined;
1054    targetMetadata.set(targetKey, keyMetadata = new Map());
1055  } return keyMetadata;
1056};
1057var ordinaryHasOwnMetadata = function (MetadataKey, O, P) {
1058  var metadataMap = getOrCreateMetadataMap(O, P, false);
1059  return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
1060};
1061var ordinaryGetOwnMetadata = function (MetadataKey, O, P) {
1062  var metadataMap = getOrCreateMetadataMap(O, P, false);
1063  return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
1064};
1065var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) {
1066  getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
1067};
1068var ordinaryOwnMetadataKeys = function (target, targetKey) {
1069  var metadataMap = getOrCreateMetadataMap(target, targetKey, false);
1070  var keys = [];
1071  if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); });
1072  return keys;
1073};
1074var toMetaKey = function (it) {
1075  return it === undefined || typeof it == 'symbol' ? it : String(it);
1076};
1077var exp = function (O) {
1078  $export($export.S, 'Reflect', O);
1079};
1080
1081module.exports = {
1082  store: store,
1083  map: getOrCreateMetadataMap,
1084  has: ordinaryHasOwnMetadata,
1085  get: ordinaryGetOwnMetadata,
1086  set: ordinaryDefineOwnMetadata,
1087  keys: ordinaryOwnMetadataKeys,
1088  key: toMetaKey,
1089  exp: exp
1090};
1091
1092
1093/***/ }),
1094/* 28 */
1095/***/ (function(module, exports) {
1096
1097var core = module.exports = { version: '2.5.5' };
1098if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
1099
1100
1101/***/ }),
1102/* 29 */
1103/***/ (function(module, exports, __webpack_require__) {
1104
1105var META = __webpack_require__(32)('meta');
1106var isObject = __webpack_require__(4);
1107var has = __webpack_require__(14);
1108var setDesc = __webpack_require__(7).f;
1109var id = 0;
1110var isExtensible = Object.isExtensible || function () {
1111  return true;
1112};
1113var FREEZE = !__webpack_require__(3)(function () {
1114  return isExtensible(Object.preventExtensions({}));
1115});
1116var setMeta = function (it) {
1117  setDesc(it, META, { value: {
1118    i: 'O' + ++id, // object ID
1119    w: {}          // weak collections IDs
1120  } });
1121};
1122var fastKey = function (it, create) {
1123  // return primitive with prefix
1124  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
1125  if (!has(it, META)) {
1126    // can't set metadata to uncaught frozen object
1127    if (!isExtensible(it)) return 'F';
1128    // not necessary to add metadata
1129    if (!create) return 'E';
1130    // add missing metadata
1131    setMeta(it);
1132  // return object ID
1133  } return it[META].i;
1134};
1135var getWeak = function (it, create) {
1136  if (!has(it, META)) {
1137    // can't set metadata to uncaught frozen object
1138    if (!isExtensible(it)) return true;
1139    // not necessary to add metadata
1140    if (!create) return false;
1141    // add missing metadata
1142    setMeta(it);
1143  // return hash weak collections IDs
1144  } return it[META].w;
1145};
1146// add metadata on freeze-family methods calling
1147var onFreeze = function (it) {
1148  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
1149  return it;
1150};
1151var meta = module.exports = {
1152  KEY: META,
1153  NEED: false,
1154  fastKey: fastKey,
1155  getWeak: getWeak,
1156  onFreeze: onFreeze
1157};
1158
1159
1160/***/ }),
1161/* 30 */
1162/***/ (function(module, exports, __webpack_require__) {
1163
1164// 22.1.3.31 Array.prototype[@@unscopables]
1165var UNSCOPABLES = __webpack_require__(5)('unscopables');
1166var ArrayProto = Array.prototype;
1167if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(11)(ArrayProto, UNSCOPABLES, {});
1168module.exports = function (key) {
1169  ArrayProto[UNSCOPABLES][key] = true;
1170};
1171
1172
1173/***/ }),
1174/* 31 */
1175/***/ (function(module, exports) {
1176
1177module.exports = function (bitmap, value) {
1178  return {
1179    enumerable: !(bitmap & 1),
1180    configurable: !(bitmap & 2),
1181    writable: !(bitmap & 4),
1182    value: value
1183  };
1184};
1185
1186
1187/***/ }),
1188/* 32 */
1189/***/ (function(module, exports) {
1190
1191var id = 0;
1192var px = Math.random();
1193module.exports = function (key) {
1194  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
1195};
1196
1197
1198/***/ }),
1199/* 33 */
1200/***/ (function(module, exports) {
1201
1202module.exports = false;
1203
1204
1205/***/ }),
1206/* 34 */
1207/***/ (function(module, exports, __webpack_require__) {
1208
1209// 19.1.2.14 / 15.2.3.14 Object.keys(O)
1210var $keys = __webpack_require__(92);
1211var enumBugKeys = __webpack_require__(66);
1212
1213module.exports = Object.keys || function keys(O) {
1214  return $keys(O, enumBugKeys);
1215};
1216
1217
1218/***/ }),
1219/* 35 */
1220/***/ (function(module, exports, __webpack_require__) {
1221
1222var toInteger = __webpack_require__(23);
1223var max = Math.max;
1224var min = Math.min;
1225module.exports = function (index, length) {
1226  index = toInteger(index);
1227  return index < 0 ? max(index + length, 0) : min(index, length);
1228};
1229
1230
1231/***/ }),
1232/* 36 */
1233/***/ (function(module, exports, __webpack_require__) {
1234
1235// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
1236var anObject = __webpack_require__(1);
1237var dPs = __webpack_require__(93);
1238var enumBugKeys = __webpack_require__(66);
1239var IE_PROTO = __webpack_require__(65)('IE_PROTO');
1240var Empty = function () { /* empty */ };
1241var PROTOTYPE = 'prototype';
1242
1243// Create object with fake `null` prototype: use iframe Object with cleared prototype
1244var createDict = function () {
1245  // Thrash, waste and sodomy: IE GC bug
1246  var iframe = __webpack_require__(63)('iframe');
1247  var i = enumBugKeys.length;
1248  var lt = '<';
1249  var gt = '>';
1250  var iframeDocument;
1251  iframe.style.display = 'none';
1252  __webpack_require__(67).appendChild(iframe);
1253  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
1254  // createDict = iframe.contentWindow.Object;
1255  // html.removeChild(iframe);
1256  iframeDocument = iframe.contentWindow.document;
1257  iframeDocument.open();
1258  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
1259  iframeDocument.close();
1260  createDict = iframeDocument.F;
1261  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
1262  return createDict();
1263};
1264
1265module.exports = Object.create || function create(O, Properties) {
1266  var result;
1267  if (O !== null) {
1268    Empty[PROTOTYPE] = anObject(O);
1269    result = new Empty();
1270    Empty[PROTOTYPE] = null;
1271    // add "__proto__" for Object.getPrototypeOf polyfill
1272    result[IE_PROTO] = O;
1273  } else result = createDict();
1274  return Properties === undefined ? result : dPs(result, Properties);
1275};
1276
1277
1278/***/ }),
1279/* 37 */
1280/***/ (function(module, exports, __webpack_require__) {
1281
1282// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
1283var $keys = __webpack_require__(92);
1284var hiddenKeys = __webpack_require__(66).concat('length', 'prototype');
1285
1286exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1287  return $keys(O, hiddenKeys);
1288};
1289
1290
1291/***/ }),
1292/* 38 */
1293/***/ (function(module, exports, __webpack_require__) {
1294
1295"use strict";
1296
1297var global = __webpack_require__(2);
1298var dP = __webpack_require__(7);
1299var DESCRIPTORS = __webpack_require__(6);
1300var SPECIES = __webpack_require__(5)('species');
1301
1302module.exports = function (KEY) {
1303  var C = global[KEY];
1304  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
1305    configurable: true,
1306    get: function () { return this; }
1307  });
1308};
1309
1310
1311/***/ }),
1312/* 39 */
1313/***/ (function(module, exports) {
1314
1315module.exports = function (it, Constructor, name, forbiddenField) {
1316  if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
1317    throw TypeError(name + ': incorrect invocation!');
1318  } return it;
1319};
1320
1321
1322/***/ }),
1323/* 40 */
1324/***/ (function(module, exports, __webpack_require__) {
1325
1326var ctx = __webpack_require__(18);
1327var call = __webpack_require__(104);
1328var isArrayIter = __webpack_require__(79);
1329var anObject = __webpack_require__(1);
1330var toLength = __webpack_require__(8);
1331var getIterFn = __webpack_require__(81);
1332var BREAK = {};
1333var RETURN = {};
1334var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
1335  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
1336  var f = ctx(fn, that, entries ? 2 : 1);
1337  var index = 0;
1338  var length, step, iterator, result;
1339  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
1340  // fast case for arrays with default iterator
1341  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
1342    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
1343    if (result === BREAK || result === RETURN) return result;
1344  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
1345    result = call(iterator, f, step.value, entries);
1346    if (result === BREAK || result === RETURN) return result;
1347  }
1348};
1349exports.BREAK = BREAK;
1350exports.RETURN = RETURN;
1351
1352
1353/***/ }),
1354/* 41 */
1355/***/ (function(module, exports, __webpack_require__) {
1356
1357var redefine = __webpack_require__(12);
1358module.exports = function (target, src, safe) {
1359  for (var key in src) redefine(target, key, src[key], safe);
1360  return target;
1361};
1362
1363
1364/***/ }),
1365/* 42 */
1366/***/ (function(module, exports, __webpack_require__) {
1367
1368var def = __webpack_require__(7).f;
1369var has = __webpack_require__(14);
1370var TAG = __webpack_require__(5)('toStringTag');
1371
1372module.exports = function (it, tag, stat) {
1373  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
1374};
1375
1376
1377/***/ }),
1378/* 43 */
1379/***/ (function(module, exports, __webpack_require__) {
1380
1381var $export = __webpack_require__(0);
1382var defined = __webpack_require__(22);
1383var fails = __webpack_require__(3);
1384var spaces = __webpack_require__(70);
1385var space = '[' + spaces + ']';
1386var non = '\u200b\u0085';
1387var ltrim = RegExp('^' + space + space + '*');
1388var rtrim = RegExp(space + space + '*$');
1389
1390var exporter = function (KEY, exec, ALIAS) {
1391  var exp = {};
1392  var FORCE = fails(function () {
1393    return !!spaces[KEY]() || non[KEY]() != non;
1394  });
1395  var fn = exp[KEY] = FORCE ? exec(trim) : spaces[KEY];
1396  if (ALIAS) exp[ALIAS] = fn;
1397  $export($export.P + $export.F * FORCE, 'String', exp);
1398};
1399
1400// 1 -> String#trimLeft
1401// 2 -> String#trimRight
1402// 3 -> String#trim
1403var trim = exporter.trim = function (string, TYPE) {
1404  string = String(defined(string));
1405  if (TYPE & 1) string = string.replace(ltrim, '');
1406  if (TYPE & 2) string = string.replace(rtrim, '');
1407  return string;
1408};
1409
1410module.exports = exporter;
1411
1412
1413/***/ }),
1414/* 44 */
1415/***/ (function(module, exports) {
1416
1417module.exports = {};
1418
1419
1420/***/ }),
1421/* 45 */
1422/***/ (function(module, exports, __webpack_require__) {
1423
1424var isObject = __webpack_require__(4);
1425module.exports = function (it, TYPE) {
1426  if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
1427  return it;
1428};
1429
1430
1431/***/ }),
1432/* 46 */
1433/***/ (function(module, exports, __webpack_require__) {
1434
1435// fallback for non-array-like ES3 and non-enumerable old V8 strings
1436var cof = __webpack_require__(19);
1437// eslint-disable-next-line no-prototype-builtins
1438module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
1439  return cof(it) == 'String' ? it.split('') : Object(it);
1440};
1441
1442
1443/***/ }),
1444/* 47 */
1445/***/ (function(module, exports) {
1446
1447exports.f = {}.propertyIsEnumerable;
1448
1449
1450/***/ }),
1451/* 48 */
1452/***/ (function(module, exports, __webpack_require__) {
1453
1454// getting tag from 19.1.3.6 Object.prototype.toString()
1455var cof = __webpack_require__(19);
1456var TAG = __webpack_require__(5)('toStringTag');
1457// ES3 wrong here
1458var ARG = cof(function () { return arguments; }()) == 'Arguments';
1459
1460// fallback for IE11 Script Access Denied error
1461var tryGet = function (it, key) {
1462  try {
1463    return it[key];
1464  } catch (e) { /* empty */ }
1465};
1466
1467module.exports = function (it) {
1468  var O, T, B;
1469  return it === undefined ? 'Undefined' : it === null ? 'Null'
1470    // @@toStringTag case
1471    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
1472    // builtinTag case
1473    : ARG ? cof(O)
1474    // ES3 arguments fallback
1475    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
1476};
1477
1478
1479/***/ }),
1480/* 49 */
1481/***/ (function(module, exports, __webpack_require__) {
1482
1483var global = __webpack_require__(2);
1484var SHARED = '__core-js_shared__';
1485var store = global[SHARED] || (global[SHARED] = {});
1486module.exports = function (key) {
1487  return store[key] || (store[key] = {});
1488};
1489
1490
1491/***/ }),
1492/* 50 */
1493/***/ (function(module, exports, __webpack_require__) {
1494
1495// false -> Array#indexOf
1496// true  -> Array#includes
1497var toIObject = __webpack_require__(15);
1498var toLength = __webpack_require__(8);
1499var toAbsoluteIndex = __webpack_require__(35);
1500module.exports = function (IS_INCLUDES) {
1501  return function ($this, el, fromIndex) {
1502    var O = toIObject($this);
1503    var length = toLength(O.length);
1504    var index = toAbsoluteIndex(fromIndex, length);
1505    var value;
1506    // Array#includes uses SameValueZero equality algorithm
1507    // eslint-disable-next-line no-self-compare
1508    if (IS_INCLUDES && el != el) while (length > index) {
1509      value = O[index++];
1510      // eslint-disable-next-line no-self-compare
1511      if (value != value) return true;
1512    // Array#indexOf ignores holes, Array#includes - not
1513    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
1514      if (O[index] === el) return IS_INCLUDES || index || 0;
1515    } return !IS_INCLUDES && -1;
1516  };
1517};
1518
1519
1520/***/ }),
1521/* 51 */
1522/***/ (function(module, exports) {
1523
1524exports.f = Object.getOwnPropertySymbols;
1525
1526
1527/***/ }),
1528/* 52 */
1529/***/ (function(module, exports, __webpack_require__) {
1530
1531// 7.2.2 IsArray(argument)
1532var cof = __webpack_require__(19);
1533module.exports = Array.isArray || function isArray(arg) {
1534  return cof(arg) == 'Array';
1535};
1536
1537
1538/***/ }),
1539/* 53 */
1540/***/ (function(module, exports, __webpack_require__) {
1541
1542// 7.2.8 IsRegExp(argument)
1543var isObject = __webpack_require__(4);
1544var cof = __webpack_require__(19);
1545var MATCH = __webpack_require__(5)('match');
1546module.exports = function (it) {
1547  var isRegExp;
1548  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
1549};
1550
1551
1552/***/ }),
1553/* 54 */
1554/***/ (function(module, exports, __webpack_require__) {
1555
1556var ITERATOR = __webpack_require__(5)('iterator');
1557var SAFE_CLOSING = false;
1558
1559try {
1560  var riter = [7][ITERATOR]();
1561  riter['return'] = function () { SAFE_CLOSING = true; };
1562  // eslint-disable-next-line no-throw-literal
1563  Array.from(riter, function () { throw 2; });
1564} catch (e) { /* empty */ }
1565
1566module.exports = function (exec, skipClosing) {
1567  if (!skipClosing && !SAFE_CLOSING) return false;
1568  var safe = false;
1569  try {
1570    var arr = [7];
1571    var iter = arr[ITERATOR]();
1572    iter.next = function () { return { done: safe = true }; };
1573    arr[ITERATOR] = function () { return iter; };
1574    exec(arr);
1575  } catch (e) { /* empty */ }
1576  return safe;
1577};
1578
1579
1580/***/ }),
1581/* 55 */
1582/***/ (function(module, exports, __webpack_require__) {
1583
1584"use strict";
1585
1586// 21.2.5.3 get RegExp.prototype.flags
1587var anObject = __webpack_require__(1);
1588module.exports = function () {
1589  var that = anObject(this);
1590  var result = '';
1591  if (that.global) result += 'g';
1592  if (that.ignoreCase) result += 'i';
1593  if (that.multiline) result += 'm';
1594  if (that.unicode) result += 'u';
1595  if (that.sticky) result += 'y';
1596  return result;
1597};
1598
1599
1600/***/ }),
1601/* 56 */
1602/***/ (function(module, exports, __webpack_require__) {
1603
1604"use strict";
1605
1606var hide = __webpack_require__(11);
1607var redefine = __webpack_require__(12);
1608var fails = __webpack_require__(3);
1609var defined = __webpack_require__(22);
1610var wks = __webpack_require__(5);
1611
1612module.exports = function (KEY, length, exec) {
1613  var SYMBOL = wks(KEY);
1614  var fns = exec(defined, SYMBOL, ''[KEY]);
1615  var strfn = fns[0];
1616  var rxfn = fns[1];
1617  if (fails(function () {
1618    var O = {};
1619    O[SYMBOL] = function () { return 7; };
1620    return ''[KEY](O) != 7;
1621  })) {
1622    redefine(String.prototype, KEY, strfn);

Large files files are truncated, but you can click here to view the full file