481 lines
18 KiB
JavaScript
481 lines
18 KiB
JavaScript
|
'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 */ };
|