'use strict';
|
var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-basic-detection');
|
var DESCRIPTORS = require('../internals/descriptors');
|
var globalThis = require('../internals/global-this');
|
var isCallable = require('../internals/is-callable');
|
var isObject = require('../internals/is-object');
|
var hasOwn = require('../internals/has-own-property');
|
var classof = require('../internals/classof');
|
var tryToString = require('../internals/try-to-string');
|
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
|
var defineBuiltIn = require('../internals/define-built-in');
|
var defineBuiltInAccessor = require('../internals/define-built-in-accessor');
|
var isPrototypeOf = require('../internals/object-is-prototype-of');
|
var getPrototypeOf = require('../internals/object-get-prototype-of');
|
var setPrototypeOf = require('../internals/object-set-prototype-of');
|
var wellKnownSymbol = require('../internals/well-known-symbol');
|
var uid = require('../internals/uid');
|
var InternalStateModule = require('../internals/internal-state');
|
|
var enforceInternalState = InternalStateModule.enforce;
|
var getInternalState = InternalStateModule.get;
|
var Int8Array = globalThis.Int8Array;
|
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
|
var Uint8ClampedArray = globalThis.Uint8ClampedArray;
|
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
|
var TypedArray = Int8Array && getPrototypeOf(Int8Array);
|
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
|
var ObjectPrototype = Object.prototype;
|
var TypeError = globalThis.TypeError;
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
|
var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';
|
// Fixing native typed arrays in Opera Presto crashes the browser, see #595
|
var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera';
|
var TYPED_ARRAY_TAG_REQUIRED = false;
|
var NAME, Constructor, Prototype;
|
|
var TypedArrayConstructorsList = {
|
Int8Array: 1,
|
Uint8Array: 1,
|
Uint8ClampedArray: 1,
|
Int16Array: 2,
|
Uint16Array: 2,
|
Int32Array: 4,
|
Uint32Array: 4,
|
Float32Array: 4,
|
Float64Array: 8
|
};
|
|
var BigIntArrayConstructorsList = {
|
BigInt64Array: 8,
|
BigUint64Array: 8
|
};
|
|
var isView = function isView(it) {
|
if (!isObject(it)) return false;
|
var klass = classof(it);
|
return klass === 'DataView'
|
|| hasOwn(TypedArrayConstructorsList, klass)
|
|| hasOwn(BigIntArrayConstructorsList, klass);
|
};
|
|
var getTypedArrayConstructor = function (it) {
|
var proto = getPrototypeOf(it);
|
if (!isObject(proto)) return;
|
var state = getInternalState(proto);
|
return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);
|
};
|
|
var isTypedArray = function (it) {
|
if (!isObject(it)) return false;
|
var klass = classof(it);
|
return hasOwn(TypedArrayConstructorsList, klass)
|
|| hasOwn(BigIntArrayConstructorsList, klass);
|
};
|
|
var aTypedArray = function (it) {
|
if (isTypedArray(it)) return it;
|
throw new TypeError('Target is not a typed array');
|
};
|
|
var aTypedArrayConstructor = function (C) {
|
if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
|
throw new TypeError(tryToString(C) + ' is not a typed array constructor');
|
};
|
|
var exportTypedArrayMethod = function (KEY, property, forced, options) {
|
if (!DESCRIPTORS) return;
|
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
|
var TypedArrayConstructor = globalThis[ARRAY];
|
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
|
delete TypedArrayConstructor.prototype[KEY];
|
} catch (error) {
|
// old WebKit bug - some methods are non-configurable
|
try {
|
TypedArrayConstructor.prototype[KEY] = property;
|
} catch (error2) { /* empty */ }
|
}
|
}
|
if (!TypedArrayPrototype[KEY] || forced) {
|
defineBuiltIn(TypedArrayPrototype, KEY, forced ? property
|
: NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
|
}
|
};
|
|
var exportTypedArrayStaticMethod = function (KEY, property, forced) {
|
var ARRAY, TypedArrayConstructor;
|
if (!DESCRIPTORS) return;
|
if (setPrototypeOf) {
|
if (forced) for (ARRAY in TypedArrayConstructorsList) {
|
TypedArrayConstructor = globalThis[ARRAY];
|
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
|
delete TypedArrayConstructor[KEY];
|
} catch (error) { /* empty */ }
|
}
|
if (!TypedArray[KEY] || forced) {
|
// V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
|
try {
|
return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
|
} catch (error) { /* empty */ }
|
} else return;
|
}
|
for (ARRAY in TypedArrayConstructorsList) {
|
TypedArrayConstructor = globalThis[ARRAY];
|
if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
|
defineBuiltIn(TypedArrayConstructor, KEY, property);
|
}
|
}
|
};
|
|
for (NAME in TypedArrayConstructorsList) {
|
Constructor = globalThis[NAME];
|
Prototype = Constructor && Constructor.prototype;
|
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
else NATIVE_ARRAY_BUFFER_VIEWS = false;
|
}
|
|
for (NAME in BigIntArrayConstructorsList) {
|
Constructor = globalThis[NAME];
|
Prototype = Constructor && Constructor.prototype;
|
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
}
|
|
// WebKit bug - typed arrays constructors prototype is Object.prototype
|
if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
|
// eslint-disable-next-line no-shadow -- safe
|
TypedArray = function TypedArray() {
|
throw new TypeError('Incorrect invocation');
|
};
|
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray);
|
}
|
}
|
|
if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
|
TypedArrayPrototype = TypedArray.prototype;
|
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype);
|
}
|
}
|
|
// WebKit bug - one more object in Uint8ClampedArray prototype chain
|
if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
|
setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
|
}
|
|
if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
|
TYPED_ARRAY_TAG_REQUIRED = true;
|
defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {
|
configurable: true,
|
get: function () {
|
return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
|
}
|
});
|
for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) {
|
createNonEnumerableProperty(globalThis[NAME], TYPED_ARRAY_TAG, NAME);
|
}
|
}
|
|
module.exports = {
|
NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
|
TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
|
aTypedArray: aTypedArray,
|
aTypedArrayConstructor: aTypedArrayConstructor,
|
exportTypedArrayMethod: exportTypedArrayMethod,
|
exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
|
getTypedArrayConstructor: getTypedArrayConstructor,
|
isView: isView,
|
isTypedArray: isTypedArray,
|
TypedArray: TypedArray,
|
TypedArrayPrototype: TypedArrayPrototype
|
};
|
