/**

* core-js 2.6.7

* https://github.com/zloirock/core-js

* License: http://rock.mit-license.org

* © 2019 Denis Pushkarev

*/

!function(__e, __g, undefined){

'use strict';

/******/ (function(modules) { // webpackBootstrap

/******/ // The module cache

/******/ var installedModules = {};

/******/

/******/ // The require function

/******/ function __webpack_require__(moduleId) {

/******/

/******/ // Check if module is in cache

/******/ if(installedModules[moduleId]) {

/******/ return installedModules[moduleId].exports;

/******/ }

/******/ // Create a new module (and put it into the cache)

/******/ var module = installedModules[moduleId] = {

/******/ i: moduleId,

/******/ l: false,

/******/ exports: {}

/******/ };

/******/

/******/ // Execute the module function

/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/

/******/ // Flag the module as loaded

/******/ module.l = true;

/******/

/******/ // Return the exports of the module

/******/ return module.exports;

/******/ }

/******/

/******/

/******/ // expose the modules object (__webpack_modules__)

/******/ __webpack_require__.m = modules;

/******/

/******/ // expose the module cache

/******/ __webpack_require__.c = installedModules;

/******/

/******/ // define getter function for harmony exports

/******/ __webpack_require__.d = function(exports, name, getter) {

/******/ if(!__webpack_require__.o(exports, name)) {

/******/ Object.defineProperty(exports, name, {

/******/ configurable: false,

/******/ enumerable: true,

/******/ get: getter

/******/ });

/******/ }

/******/ };

/******/

/******/ // getDefaultExport function for compatibility with non-harmony modules

/******/ __webpack_require__.n = function(module) {

/******/ var getter = module && module.__esModule ?

/******/ function getDefault() { return module['default']; } :

/******/ function getModuleExports() { return module; };

/******/ __webpack_require__.d(getter, 'a', getter);

/******/ return getter;

/******/ };

/******/

/******/ // Object.prototype.hasOwnProperty.call

/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/

/******/ // __webpack_public_path__

/******/ __webpack_require__.p = "";

/******/

/******/ // Load entry module and return exports

/******/ return __webpack_require__(__webpack_require__.s = 126);

/******/ })

/************************************************************************/

/******/ ([

/* 0 */

/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(2);

var core = __webpack_require__(12);

var ctx = __webpack_require__(16);

var hide = __webpack_require__(17);

var has = __webpack_require__(15);

var PROTOTYPE = 'prototype';

var $export = function (type, name, source) {

var IS_FORCED = type & $export.F;

var IS_GLOBAL = type & $export.G;

var IS_STATIC = type & $export.S;

var IS_PROTO = type & $export.P;

var IS_BIND = type & $export.B;

var IS_WRAP = type & $export.W;

var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});

var expProto = exports[PROTOTYPE];

var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];

var key, own, out;

if (IS_GLOBAL) source = name;

for (key in source) {

// contains in native

own = !IS_FORCED && target && target[key] !== undefined;

if (own && has(exports, key)) continue;

// export native or passed

out = own ? target[key] : source[key];

// prevent global pollution for namespaces

exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]

// bind timers to global for call from export context

: IS_BIND && own ? ctx(out, global)

// wrap global constructors for prevent change them in library

: IS_WRAP && target[key] == out ? (function (C) {

var F = function (a, b, c) {

if (this instanceof C) {

switch (arguments.length) {

case 0: return new C();

case 1: return new C(a);

case 2: return new C(a, b);

} return new C(a, b, c);

} return C.apply(this, arguments);

};

F[PROTOTYPE] = C[PROTOTYPE];

return F;

// make static versions for prototype methods

})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;

// export proto methods to core.%CONSTRUCTOR%.methods.%NAME%

if (IS_PROTO) {

(exports.virtual || (exports.virtual = {}))[key] = out;

// export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%

if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);

}

}

};

// type bitmap

$export.F = 1; // forced

$export.G = 2; // global

$export.S = 4; // static

$export.P = 8; // proto

$export.B = 16; // bind

$export.W = 32; // wrap

$export.U = 64; // safe

$export.R = 128; // real proto method for `library`

module.exports = $export;

/***/ }),

/* 1 */

/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(3);

module.exports = function (it) {

if (!isObject(it)) throw TypeError(it + ' is not an object!');

return it;

};

/***/ }),

/* 2 */

/***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028

var global = module.exports = typeof window != 'undefined' && window.Math == Math

? window : typeof self != 'undefined' && self.Math == Math ? self

// eslint-disable-next-line no-new-func

: Function('return this')();

if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef

/***/ }),

/* 3 */

/***/ (function(module, exports) {

module.exports = function (it) {

return typeof it === 'object' ? it !== null : typeof it === 'function';

};

/***/ }),

/* 4 */

/***/ (function(module, exports) {

module.exports = function (exec) {

try {

return !!exec();

} catch (e) {

return true;

}

};

/***/ }),

/* 5 */

/***/ (function(module, exports, __webpack_require__) {

var store = __webpack_require__(49)('wks');

var uid = __webpack_require__(41);

var Symbol = __webpack_require__(2).Symbol;

var USE_SYMBOL = typeof Symbol == 'function';

var $exports = module.exports = function (name) {

return store[name] || (store[name] =

USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));

};

$exports.store = store;

/***/ }),

/* 6 */

/***/ (function(module, exports, __webpack_require__) {

// 7.1.15 ToLength

var toInteger = __webpack_require__(22);

var min = Math.min;

module.exports = function (it) {

return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991

};

/***/ }),

/* 7 */

/***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty

module.exports = !__webpack_require__(4)(function () {

return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;

});

/***/ }),

/* 8 */

/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__(1);

var IE8_DOM_DEFINE = __webpack_require__(90);

var toPrimitive = __webpack_require__(27);

var dP = Object.defineProperty;

exports.f = __webpack_require__(7) ? Object.defineProperty : function defineProperty(O, P, Attributes) {

anObject(O);

P = toPrimitive(P, true);

anObject(Attributes);

if (IE8_DOM_DEFINE) try {

return dP(O, P, Attributes);

} catch (e) { /* empty */ }

if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');

if ('value' in Attributes) O[P] = Attributes.value;

return O;

};

/***/ }),

/* 9 */

/***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)

var defined = __webpack_require__(24);

module.exports = function (it) {

return Object(defined(it));

};

/***/ }),

/* 10 */

/***/ (function(module, exports) {

module.exports = function (it) {

if (typeof it != 'function') throw TypeError(it + ' is not a function!');

return it;

};

/***/ }),

/* 11 */

/***/ (function(module, exports, __webpack_require__) {

// to indexed object, toObject with fallback for non-array-like ES3 strings

var IObject = __webpack_require__(44);

var defined = __webpack_require__(24);

module.exports = function (it) {

return IObject(defined(it));

};

/***/ }),

/* 12 */

/***/ (function(module, exports) {

var core = module.exports = { version: '2.6.7' };

if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef

/***/ }),

/* 13 */

/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)

var has = __webpack_require__(15);

var toObject = __webpack_require__(9);

var IE_PROTO = __webpack_require__(65)('IE_PROTO');

var ObjectProto = Object.prototype;

module.exports = Object.getPrototypeOf || function (O) {

O = toObject(O);

if (has(O, IE_PROTO)) return O[IE_PROTO];

if (typeof O.constructor == 'function' && O instanceof O.constructor) {

return O.constructor.prototype;

} return O instanceof Object ? ObjectProto : null;

};

/***/ }),

/* 14 */

/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(0);

var fails = __webpack_require__(4);

var defined = __webpack_require__(24);

var quot = /"/g;

// B.2.3.2.1 CreateHTML(string, tag, attribute, value)

var createHTML = function (string, tag, attribute, value) {

var S = String(defined(string));

var p1 = '<' + tag;

if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '&quot;') + '"';

return p1 + '>' + S + '</' + tag + '>';

};

module.exports = function (NAME, exec) {

var O = {};

O[NAME] = exec(createHTML);

$export($export.P + $export.F * fails(function () {

var test = ''[NAME]('"');

return test !== test.toLowerCase() || test.split('"').length > 3;

}), 'String', O);

};

/***/ }),

/* 15 */

/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;

module.exports = function (it, key) {

return hasOwnProperty.call(it, key);

};

/***/ }),

/* 16 */

/***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding

var aFunction = __webpack_require__(10);

module.exports = function (fn, that, length) {

aFunction(fn);

if (that === undefined) return fn;

switch (length) {

case 1: return function (a) {

return fn.call(that, a);

};

case 2: return function (a, b) {

return fn.call(that, a, b);

};

case 3: return function (a, b, c) {

return fn.call(that, a, b, c);

};

}

return function (/* ...args */) {

return fn.apply(that, arguments);

};

};

/***/ }),

/* 17 */

/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(8);

var createDesc = __webpack_require__(28);

module.exports = __webpack_require__(7) ? function (object, key, value) {

return dP.f(object, key, createDesc(1, value));

} : function (object, key, value) {

object[key] = value;

return object;

};

/***/ }),

/* 18 */

/***/ (function(module, exports, __webpack_require__) {

var pIE = __webpack_require__(45);

var createDesc = __webpack_require__(28);

var toIObject = __webpack_require__(11);

var toPrimitive = __webpack_require__(27);

var has = __webpack_require__(15);

var IE8_DOM_DEFINE = __webpack_require__(90);

var gOPD = Object.getOwnPropertyDescriptor;

exports.f = __webpack_require__(7) ? gOPD : function getOwnPropertyDescriptor(O, P) {

O = toIObject(O);

P = toPrimitive(P, true);

if (IE8_DOM_DEFINE) try {

return gOPD(O, P);

} catch (e) { /* empty */ }

if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);

};

/***/ }),

/* 19 */

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var fails = __webpack_require__(4);

module.exports = function (method, arg) {

return !!method && fails(function () {

// eslint-disable-next-line no-useless-call

arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);

});

};

/***/ }),

/* 20 */

/***/ (function(module, exports, __webpack_require__) {

// 0 -> Array#forEach

// 1 -> Array#map

// 2 -> Array#filter

// 3 -> Array#some

// 4 -> Array#every

// 5 -> Array#find

// 6 -> Array#findIndex

var ctx = __webpack_require__(16);

var IObject = __webpack_require__(44);

var toObject = __webpack_require__(9);

var toLength = __webpack_require__(6);

var asc = __webpack_require__(80);

module.exports = function (TYPE, $create) {

var IS_MAP = TYPE == 1;

var IS_FILTER = TYPE == 2;

var IS_SOME = TYPE == 3;

var IS_EVERY = TYPE == 4;

var IS_FIND_INDEX = TYPE == 6;

var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;

var create = $create || asc;

return function ($this, callbackfn, that) {

var O = toObject($this);

var self = IObject(O);

var f = ctx(callbackfn, that, 3);

var length = toLength(self.length);

var index = 0;

var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;

var val, res;

for (;length > index; index++) if (NO_HOLES || index in self) {

val = self[index];

res = f(val, index, O);

if (TYPE) {

if (IS_MAP) result[index] = res; // map

else if (res) switch (TYPE) {

case 3: return true; // some

case 5: return val; // find

case 6: return index; // findIndex

case 2: result.push(val); // filter

} else if (IS_EVERY) return false; // every

}

}

return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;

};

};

/***/ }),

/* 21 */

/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = function (it) {

return toString.call(it).slice(8, -1);

};

/***/ }),

/* 22 */

/***/ (function(module, exports) {

// 7.1.4 ToInteger

var ceil = Math.ceil;

var floor = Math.floor;

module.exports = function (it) {

return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);

};

/***/ }),

/* 23 */

/***/ (function(module, exports, __webpack_require__) {

// most Object methods by ES6 should accept primitives

var $export = __webpack_require__(0);

var core = __webpack_require__(12);

var fails = __webpack_require__(4);

module.exports = function (KEY, exec) {

var fn = (core.Object || {})[KEY] || Object[KEY];

var exp = {};

exp[KEY] = exec(fn);

$export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);

};

/***/ }),

/* 24 */

/***/ (function(module, exports) {

// 7.2.1 RequireObjectCoercible(argument)

module.exports = function (it) {

if (it == undefined) throw TypeError("Can't call method on " + it);

return it;

};

/***/ }),

/* 25 */

/***/ (function(module, exports, __webpack_require__) {

"use strict";

if (__webpack_require__(7)) {

var LIBRARY = __webpack_require__(30);

var global = __webpack_require__(2);

var fails = __webpack_require__(4);

var $export = __webpack_require__(0);

var $typed = __webpack_require__(58);

var $buffer = __webpack_require__(88);

var ctx = __webpack_require__(16);

var anInstance = __webpack_require__(38);

var propertyDesc = __webpack_require__(28);

var hide = __webpack_require__(17);

var redefineAll = __webpack_require__(39);

var toInteger = __webpack_require__(22);

var toLength = __webpack_require__(6);

var toIndex = __webpack_require__(115);

var toAbsoluteIndex = __webpack_require__(35);

var toPrimitive = __webpack_require__(27);

var has = __webpack_require__(15);

var classof = __webpack_require__(37);

var isObject = __webpack_require__(3);

var toObject = __webpack_require__(9);

var isArrayIter = __webpack_require__(77);

var create = __webpack_require__(32);

var getPrototypeOf = __webpack_require__(13);

var gOPN = __webpack_require__(46).f;

var getIterFn = __webpack_require__(48);

var uid = __webpack_require__(41);

var wks = __webpack_require__(5);

var createArrayMethod = __webpack_require__(20);

var createArrayIncludes = __webpack_require__(50);

var speciesConstructor = __webpack_require__(55);

var ArrayIterators = __webpack_require__(82);

var Iterators = __webpack_require__(36);

var $iterDetect = __webpack_require__(79);

var setSpecies = __webpack_require__(43);

var arrayFill = __webpack_require__(81);

var arrayCopyWithin = __webpack_require__(106);

var $DP = __webpack_require__(8);

var $GOPD = __webpack_require__(18);

var dP = $DP.f;

var gOPD = $GOPD.f;

var RangeError = global.RangeError;

var TypeError = global.TypeError;

var Uint8Array = global.Uint8Array;

var ARRAY_BUFFER = 'ArrayBuffer';

var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER;

var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';

var PROTOTYPE = 'prototype';

var ArrayProto = Array[PROTOTYPE];

var $ArrayBuffer = $buffer.ArrayBuffer;

var $DataView = $buffer.DataView;

var arrayForEach = createArrayMethod(0);

var arrayFilter = createArrayMethod(2);

var arraySome = createArrayMethod(3);

var arrayEvery = createArrayMethod(4);

var arrayFind = createArrayMethod(5);

var arrayFindIndex = createArrayMethod(6);

var arrayIncludes = createArrayIncludes(true);

var arrayIndexOf = createArrayIncludes(false);

var arrayValues = ArrayIterators.values;

var arrayKeys = ArrayIterators.keys;

var arrayEntries = ArrayIterators.entries;

var arrayLastIndexOf = ArrayProto.lastIndexOf;

var arrayReduce = ArrayProto.reduce;

var arrayReduceRight = ArrayProto.reduceRight;

var arrayJoin = ArrayProto.join;

var arraySort = ArrayProto.sort;

var arraySlice = ArrayProto.slice;

var arrayToString = ArrayProto.toString;

var arrayToLocaleString = ArrayProto.toLocaleString;

var ITERATOR = wks('iterator');

var TAG = wks('toStringTag');

var TYPED_CONSTRUCTOR = uid('typed_constructor');

var DEF_CONSTRUCTOR = uid('def_constructor');

var ALL_CONSTRUCTORS = $typed.CONSTR;

var TYPED_ARRAY = $typed.TYPED;

var VIEW = $typed.VIEW;

var WRONG_LENGTH = 'Wrong length!';

var $map = createArrayMethod(1, function (O, length) {

return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);

});

var LITTLE_ENDIAN = fails(function () {

// eslint-disable-next-line no-undef

return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;

});

var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () {

new Uint8Array(1).set({});

});

var toOffset = function (it, BYTES) {

var offset = toInteger(it);

if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!');

return offset;

};

var validate = function (it) {

if (isObject(it) && TYPED_ARRAY in it) return it;

throw TypeError(it + ' is not a typed array!');

};

var allocate = function (C, length) {

if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {

throw TypeError('It is not a typed array constructor!');

} return new C(length);

};

var speciesFromList = function (O, list) {

return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);

};

var fromList = function (C, list) {

var index = 0;

var length = list.length;

var result = allocate(C, length);

while (length > index) result[index] = list[index++];

return result;

};

var addGetter = function (it, key, internal) {

dP(it, key, { get: function () { return this._d[internal]; } });

};

var $from = function from(source /* , mapfn, thisArg */) {

var O = toObject(source);

var aLen = arguments.length;

var mapfn = aLen > 1 ? arguments[1] : undefined;

var mapping = mapfn !== undefined;

var iterFn = getIterFn(O);

var i, length, values, result, step, iterator;

if (iterFn != undefined && !isArrayIter(iterFn)) {

for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) {

values.push(step.value);

} O = values;

}

if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);

for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) {

result[i] = mapping ? mapfn(O[i], i) : O[i];

}

return result;

};

var $of = function of(/* ...items */) {

var index = 0;

var length = arguments.length;

var result = allocate(this, length);

while (length > index) result[index] = arguments[index++];

return result;

};

// iOS Safari 6.x fails here

var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); });

var $toLocaleString = function toLocaleString() {

return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);

};

var proto = {

copyWithin: function copyWithin(target, start /* , end */) {

return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);

},

every: function every(callbackfn /* , thisArg */) {

return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);

},

fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars

return arrayFill.apply(validate(this), arguments);

},

filter: function filter(callbackfn /* , thisArg */) {

return speciesFromList(this, arrayFilter(validate(this), callbackfn,

arguments.length > 1 ? arguments[1] : undefined));

},

find: function find(predicate /* , thisArg */) {

return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);

},

findIndex: function findIndex(predicate /* , thisArg */) {

return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);

},

forEach: function forEach(callbackfn /* , thisArg */) {

arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);

},

indexOf: function indexOf(searchElement /* , fromIndex */) {

return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);

},

includes: function includes(searchElement /* , fromIndex */) {

return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);

},

join: function join(separator) { // eslint-disable-line no-unused-vars

return arrayJoin.apply(validate(this), arguments);

},

lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars

return arrayLastIndexOf.apply(validate(this), arguments);

},

map: function map(mapfn /* , thisArg */) {

return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);

},

reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars

return arrayReduce.apply(validate(this), arguments);

},

reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars

return arrayReduceRight.apply(validate(this), arguments);

},

reverse: function reverse() {

var that = this;

var length = validate(that).length;

var middle = Math.floor(length / 2);

var index = 0;

var value;

while (index < middle) {

value = that[index];

that[index++] = that[--length];

that[length] = value;

} return that;

},

some: function some(callbackfn /* , thisArg */) {

return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);

},

sort: function sort(comparefn) {

return arraySort.call(validate(this), comparefn);

},

subarray: function subarray(begin, end) {

var O = validate(this);

var length = O.length;

var $begin = toAbsoluteIndex(begin, length);

return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(

O.buffer,

O.byteOffset + $begin * O.BYTES_PER_ELEMENT,

toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)

);

}

};

var $slice = function slice(start, end) {

return speciesFromList(this, arraySlice.call(validate(this), start, end));

};

var $set = function set(arrayLike /* , offset */) {

validate(this);

var offset = toOffset(arguments[1], 1);

var length = this.length;

var src = toObject(arrayLike);

var len = toLength(src.length);

var index = 0;

if (len + offset > length) throw RangeError(WRONG_LENGTH);

while (index < len) this[offset + index] = src[index++];

};

var $iterators = {

entries: function entries() {

return arrayEntries.call(validate(this));

},

keys: function keys() {

return arrayKeys.call(validate(this));

},

values: function values() {

return arrayValues.call(validate(this));

}

};

var isTAIndex = function (target, key) {

return isObject(target)

&& target[TYPED_ARRAY]

&& typeof key != 'symbol'

&& key in target

&& String(+key) == String(key);

};

var $getDesc = function getOwnPropertyDescriptor(target, key) {

return isTAIndex(target, key = toPrimitive(key, true))

? propertyDesc(2, target[key])

: gOPD(target, key);

};

var $setDesc = function defineProperty(target, key, desc) {

if (isTAIndex(target, key = toPrimitive(key, true))

&& isObject(desc)

&& has(desc, 'value')

&& !has(desc, 'get')

&& !has(desc, 'set')

// TODO: add validation descriptor w/o calling accessors

&& !desc.configurable

&& (!has(desc, 'writable') || desc.writable)

&& (!has(desc, 'enumerable') || desc.enumerable)

) {

target[key] = desc.value;

return target;

} return dP(target, key, desc);

};

if (!ALL_CONSTRUCTORS) {

$GOPD.f = $getDesc;

$DP.f = $setDesc;

}

$export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {

getOwnPropertyDescriptor: $getDesc,

defineProperty: $setDesc

});

if (fails(function () { arrayToString.call({}); })) {

arrayToString = arrayToLocaleString = function toString() {

return arrayJoin.call(this);

};

}

var $TypedArrayPrototype$ = redefineAll({}, proto);

redefineAll($TypedArrayPrototype$, $iterators);

hide($TypedArrayPrototype$, ITERATOR, $iterators.values);

redefineAll($TypedArrayPrototype$, {

slice: $slice,

set: $set,

constructor: function () { /* noop */ },

toString: arrayToString,

toLocaleString: $toLocaleString

});

addGetter($TypedArrayPrototype$, 'buffer', 'b');

addGetter($TypedArrayPrototype$, 'byteOffset', 'o');

addGetter($TypedArrayPrototype$, 'byteLength', 'l');

addGetter($TypedArrayPrototype$, 'length', 'e');

dP($TypedArrayPrototype$, TAG, {

get: function () { return this[TYPED_ARRAY]; }

});

// eslint-disable-next-line max-statements

module.exports = function (KEY, BYTES, wrapper, CLAMPED) {

CLAMPED = !!CLAMPED;

var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array';

var GETTER = 'get' + KEY;

var SETTER = 'set' + KEY;

var TypedArray = global[NAME];

var Base = TypedArray || {};

var TAC = TypedArray && getPrototypeOf(TypedArray);

var FORCED = !TypedArray || !$typed.ABV;

var O = {};

var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];

var getter = function (that, index) {

var data = that._d;

return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);

};

var setter = function (that, index, value) {

var data = that._d;

if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;

data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);

};

var addElement = function (that, index) {

dP(that, index, {

get: function () {

return getter(this, index);

},

set: function (value) {

return setter(this, index, value);

},

enumerable: true

});

};

if (FORCED) {

TypedArray = wrapper(function (that, data, $offset, $length) {

anInstance(that, TypedArray, NAME, '_d');

var index = 0;

var offset = 0;

var buffer, byteLength, length, klass;

if (!isObject(data)) {

length = toIndex(data);

byteLength = length * BYTES;

buffer = new $ArrayBuffer(byteLength);

} else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {

buffer = data;

offset = toOffset($offset, BYTES);

var $len = data.byteLength;

if ($length === undefined) {

if ($len % BYTES) throw RangeError(WRONG_LENGTH);

byteLength = $len - offset;

if (byteLength < 0) throw RangeError(WRONG_LENGTH);

} else {

byteLength = toLength($length) * BYTES;

if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);

}

length = byteLength / BYTES;

} else if (TYPED_ARRAY in data) {

return fromList(TypedArray, data);

} else {

return $from.call(TypedArray, data);

}

hide(that, '_d', {

b: buffer,

o: offset,

l: byteLength,

e: length,

v: new $DataView(buffer)

});

while (index < length) addElement(that, index++);

});

TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);

hide(TypedArrayPrototype, 'constructor', TypedArray);

} else if (!fails(function () {

TypedArray(1);

}) || !fails(function () {

new TypedArray(-1); // eslint-disable-line no-new

}) || !$iterDetect(function (iter) {

new TypedArray(); // eslint-disable-line no-new

new TypedArray(null); // eslint-disable-line no-new

new TypedArray(1.5); // eslint-disable-line no-new

new TypedArray(iter); // eslint-disable-line no-new

}, true)) {

TypedArray = wrapper(function (that, data, $offset, $length) {

anInstance(that, TypedArray, NAME);

var klass;

// `ws` module bug, temporarily remove validation length for Uint8Array

// https://github.com/websockets/ws/pull/645

if (!isObject(data)) return new Base(toIndex(data));

if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {

return $length !== undefined

? new Base(data, toOffset($offset, BYTES), $length)

: $offset !== undefined

? new Base(data, toOffset($offset, BYTES))

: new Base(data);

}

if (TYPED_ARRAY in data) return fromList(TypedArray, data);

return $from.call(TypedArray, data);

});

arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) {

if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);

});

TypedArray[PROTOTYPE] = TypedArrayPrototype;

if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;

}

var $nativeIterator = TypedArrayPrototype[ITERATOR];

var CORRECT_ITER_NAME = !!$nativeIterator

&& ($nativeIterator.name == 'values' || $nativeIterator.name == undefined);

var $iterator = $iterators.values;

hide(TypedArray, TYPED_CONSTRUCTOR, true);

hide(TypedArrayPrototype, TYPED_ARRAY, NAME);

hide(TypedArrayPrototype, VIEW, true);

hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);

if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) {

dP(TypedArrayPrototype, TAG, {

get: function () { return NAME; }

});

}

O[NAME] = TypedArray;

$export($export.G + $export.W + $export.F * (TypedArray != Base), O);

$export($export.S, NAME, {

BYTES_PER_ELEMENT: BYTES

});

$export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, {

from: $from,

of: $of

});

if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);

$export($export.P, NAME, proto);

setSpecies(NAME);

$export($export.P + $export.F * FORCED_SET, NAME, { set: $set });

$export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);

if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString;

$export($export.P + $export.F * fails(function () {

new TypedArray(1).slice();

}), NAME, { slice: $slice });

$export($export.P + $export.F * (fails(function () {

return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString();

}) || !fails(function () {

TypedArrayPrototype.toLocaleString.call([1, 2]);

})), NAME, { toLocaleString: $toLocaleString });