You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
480 lines
18 KiB
480 lines
18 KiB
'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 */ };
|
|
|