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