| 'use strict'; |
| if (require('./_descriptors')) { |
| var LIBRARY = require('./_library'); |
| var global = require('./_global'); |
| var fails = require('./_fails'); |
| var $export = require('./_export'); |
| var $typed = require('./_typed'); |
| var $buffer = require('./_typed-buffer'); |
| var ctx = require('./_ctx'); |
| var anInstance = require('./_an-instance'); |
| var propertyDesc = require('./_property-desc'); |
| var hide = require('./_hide'); |
| var redefineAll = require('./_redefine-all'); |
| var toInteger = require('./_to-integer'); |
| var toLength = require('./_to-length'); |
| var toIndex = require('./_to-index'); |
| var toAbsoluteIndex = require('./_to-absolute-index'); |
| var toPrimitive = require('./_to-primitive'); |
| var has = require('./_has'); |
| var classof = require('./_classof'); |
| var isObject = require('./_is-object'); |
| var toObject = require('./_to-object'); |
| var isArrayIter = require('./_is-array-iter'); |
| var create = require('./_object-create'); |
| var getPrototypeOf = require('./_object-gpo'); |
| var gOPN = require('./_object-gopn').f; |
| var getIterFn = require('./core.get-iterator-method'); |
| var uid = require('./_uid'); |
| var wks = require('./_wks'); |
| var createArrayMethod = require('./_array-methods'); |
| var createArrayIncludes = require('./_array-includes'); |
| var speciesConstructor = require('./_species-constructor'); |
| var ArrayIterators = require('./es6.array.iterator'); |
| var Iterators = require('./_iterators'); |
| var $iterDetect = require('./_iter-detect'); |
| var setSpecies = require('./_set-species'); |
| var arrayFill = require('./_array-fill'); |
| var arrayCopyWithin = require('./_array-copy-within'); |
| var $DP = require('./_object-dp'); |
| var $GOPD = require('./_object-gopd'); |
| 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 }); |
| |
| Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator; |
| if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator); |
| }; |
| } else module.exports = function () { /* empty */ }; |