PageRenderTime 150ms CodeModel.GetById 24ms app.highlight 103ms RepoModel.GetById 1ms app.codeStats 1ms

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

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

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