From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../src/external/petamoriken/float16/float16.js | 1228 ++++++++++++++++++++ 1 file changed, 1228 insertions(+) create mode 100644 dom/webgpu/tests/cts/checkout/src/external/petamoriken/float16/float16.js (limited to 'dom/webgpu/tests/cts/checkout/src/external/petamoriken/float16/float16.js') diff --git a/dom/webgpu/tests/cts/checkout/src/external/petamoriken/float16/float16.js b/dom/webgpu/tests/cts/checkout/src/external/petamoriken/float16/float16.js new file mode 100644 index 0000000000..54843a4842 --- /dev/null +++ b/dom/webgpu/tests/cts/checkout/src/external/petamoriken/float16/float16.js @@ -0,0 +1,1228 @@ +/*! @petamoriken/float16 v3.6.6 | MIT License - https://github.com/petamoriken/float16 */ + +const THIS_IS_NOT_AN_OBJECT = "This is not an object"; +const THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = "This is not a Float16Array object"; +const THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY = + "This constructor is not a subclass of Float16Array"; +const THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT = + "The constructor property value is not an object"; +const SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT = + "Species constructor didn't return TypedArray object"; +const DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH = + "Derived constructor created TypedArray object which was too small length"; +const ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER = + "Attempting to access detached ArrayBuffer"; +const CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT = + "Cannot convert undefined or null to object"; +const CANNOT_MIX_BIGINT_AND_OTHER_TYPES = + "Cannot mix BigInt and other types, use explicit conversions"; +const ITERATOR_PROPERTY_IS_NOT_CALLABLE = "@@iterator property is not callable"; +const REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE = + "Reduce of empty array with no initial value"; +const OFFSET_IS_OUT_OF_BOUNDS = "Offset is out of bounds"; + +function uncurryThis(target) { + return (thisArg, ...args) => { + return ReflectApply(target, thisArg, args); + }; +} +function uncurryThisGetter(target, key) { + return uncurryThis( + ReflectGetOwnPropertyDescriptor( + target, + key + ).get + ); +} +const { + apply: ReflectApply, + construct: ReflectConstruct, + defineProperty: ReflectDefineProperty, + get: ReflectGet, + getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor, + getPrototypeOf: ReflectGetPrototypeOf, + has: ReflectHas, + ownKeys: ReflectOwnKeys, + set: ReflectSet, + setPrototypeOf: ReflectSetPrototypeOf, +} = Reflect; +const NativeProxy = Proxy; +const { + MAX_SAFE_INTEGER: MAX_SAFE_INTEGER, + isFinite: NumberIsFinite, + isNaN: NumberIsNaN, +} = Number; +const { + iterator: SymbolIterator, + species: SymbolSpecies, + toStringTag: SymbolToStringTag, + for: SymbolFor, +} = Symbol; +const NativeObject = Object; +const { + create: ObjectCreate, + defineProperty: ObjectDefineProperty, + freeze: ObjectFreeze, + is: ObjectIs, +} = NativeObject; +const ObjectPrototype = NativeObject.prototype; +const ObjectPrototype__lookupGetter__ = (ObjectPrototype).__lookupGetter__ + ? uncurryThis( (ObjectPrototype).__lookupGetter__) + : (object, key) => { + if (object == null) { + throw NativeTypeError( + CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT + ); + } + let target = NativeObject(object); + do { + const descriptor = ReflectGetOwnPropertyDescriptor(target, key); + if (descriptor !== undefined) { + if (ObjectHasOwn(descriptor, "get")) { + return descriptor.get; + } + return; + } + } while ((target = ReflectGetPrototypeOf(target)) !== null); + }; +const ObjectHasOwn = (NativeObject).hasOwn || + uncurryThis(ObjectPrototype.hasOwnProperty); +const NativeArray = Array; +const ArrayIsArray = NativeArray.isArray; +const ArrayPrototype = NativeArray.prototype; +const ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join); +const ArrayPrototypePush = uncurryThis(ArrayPrototype.push); +const ArrayPrototypeToLocaleString = uncurryThis( + ArrayPrototype.toLocaleString +); +const NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator]; +const ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator); +const MathTrunc = Math.trunc; +const NativeArrayBuffer = ArrayBuffer; +const ArrayBufferIsView = NativeArrayBuffer.isView; +const ArrayBufferPrototype = NativeArrayBuffer.prototype; +const ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice); +const ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, "byteLength"); +const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : null; +const SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer + && uncurryThisGetter(NativeSharedArrayBuffer.prototype, "byteLength"); +const TypedArray = ReflectGetPrototypeOf(Uint8Array); +const TypedArrayFrom = TypedArray.from; +const TypedArrayPrototype = TypedArray.prototype; +const NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator]; +const TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys); +const TypedArrayPrototypeValues = uncurryThis( + TypedArrayPrototype.values +); +const TypedArrayPrototypeEntries = uncurryThis( + TypedArrayPrototype.entries +); +const TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set); +const TypedArrayPrototypeReverse = uncurryThis( + TypedArrayPrototype.reverse +); +const TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill); +const TypedArrayPrototypeCopyWithin = uncurryThis( + TypedArrayPrototype.copyWithin +); +const TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort); +const TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice); +const TypedArrayPrototypeSubarray = uncurryThis( + TypedArrayPrototype.subarray +); +const TypedArrayPrototypeGetBuffer = uncurryThisGetter( + TypedArrayPrototype, + "buffer" +); +const TypedArrayPrototypeGetByteOffset = uncurryThisGetter( + TypedArrayPrototype, + "byteOffset" +); +const TypedArrayPrototypeGetLength = uncurryThisGetter( + TypedArrayPrototype, + "length" +); +const TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter( + TypedArrayPrototype, + SymbolToStringTag +); +const NativeUint16Array = Uint16Array; +const Uint16ArrayFrom = (...args) => { + return ReflectApply(TypedArrayFrom, NativeUint16Array, args); +}; +const NativeUint32Array = Uint32Array; +const NativeFloat32Array = Float32Array; +const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]()); +const ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next); +const GeneratorPrototypeNext = uncurryThis((function* () {})().next); +const IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype); +const DataViewPrototype = DataView.prototype; +const DataViewPrototypeGetUint16 = uncurryThis( + DataViewPrototype.getUint16 +); +const DataViewPrototypeSetUint16 = uncurryThis( + DataViewPrototype.setUint16 +); +const NativeTypeError = TypeError; +const NativeRangeError = RangeError; +const NativeWeakSet = WeakSet; +const WeakSetPrototype = NativeWeakSet.prototype; +const WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add); +const WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has); +const NativeWeakMap = WeakMap; +const WeakMapPrototype = NativeWeakMap.prototype; +const WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get); +const WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has); +const WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set); + +const arrayIterators = new NativeWeakMap(); +const SafeIteratorPrototype = ObjectCreate(null, { + next: { + value: function next() { + const arrayIterator = WeakMapPrototypeGet(arrayIterators, this); + return ArrayIteratorPrototypeNext(arrayIterator); + }, + }, + [SymbolIterator]: { + value: function values() { + return this; + }, + }, +}); +function safeIfNeeded(array) { + if (array[SymbolIterator] === NativeArrayPrototypeSymbolIterator) { + return array; + } + const safe = ObjectCreate(SafeIteratorPrototype); + WeakMapPrototypeSet(arrayIterators, safe, ArrayPrototypeSymbolIterator(array)); + return safe; +} +const generators = new NativeWeakMap(); +const DummyArrayIteratorPrototype = ObjectCreate(IteratorPrototype, { + next: { + value: function next() { + const generator = WeakMapPrototypeGet(generators, this); + return GeneratorPrototypeNext(generator); + }, + writable: true, + configurable: true, + }, +}); +for (const key of ReflectOwnKeys(ArrayIteratorPrototype)) { + if (key === "next") { + continue; + } + ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key)); +} +function wrap(generator) { + const dummy = ObjectCreate(DummyArrayIteratorPrototype); + WeakMapPrototypeSet(generators, dummy, generator); + return dummy; +} + +function isObject(value) { + return (value !== null && typeof value === "object") || + typeof value === "function"; +} +function isObjectLike(value) { + return value !== null && typeof value === "object"; +} +function isNativeTypedArray(value) { + return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined; +} +function isNativeBigIntTypedArray(value) { + const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value); + return typedArrayName === "BigInt64Array" || + typedArrayName === "BigUint64Array"; +} +function isArrayBuffer(value) { + try { + ArrayBufferPrototypeGetByteLength( (value)); + return true; + } catch (e) { + return false; + } +} +function isSharedArrayBuffer(value) { + if (NativeSharedArrayBuffer === null) { + return false; + } + try { + SharedArrayBufferPrototypeGetByteLength( (value)); + return true; + } catch (e) { + return false; + } +} +function isOrdinaryArray(value) { + if (!ArrayIsArray(value)) { + return false; + } + if (value[SymbolIterator] === NativeArrayPrototypeSymbolIterator) { + return true; + } + const iterator = value[SymbolIterator](); + return iterator[SymbolToStringTag] === "Array Iterator"; +} +function isOrdinaryNativeTypedArray(value) { + if (!isNativeTypedArray(value)) { + return false; + } + if (value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator) { + return true; + } + const iterator = value[SymbolIterator](); + return iterator[SymbolToStringTag] === "Array Iterator"; +} +function isCanonicalIntegerIndexString(value) { + if (typeof value !== "string") { + return false; + } + const number = +value; + if (value !== number + "") { + return false; + } + if (!NumberIsFinite(number)) { + return false; + } + return number === MathTrunc(number); +} + +const brand = SymbolFor("__Float16Array__"); +function hasFloat16ArrayBrand(target) { + if (!isObjectLike(target)) { + return false; + } + const prototype = ReflectGetPrototypeOf(target); + if (!isObjectLike(prototype)) { + return false; + } + const constructor = prototype.constructor; + if (constructor === undefined) { + return false; + } + if (!isObject(constructor)) { + throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT); + } + return ReflectHas(constructor, brand); +} + +const buffer = new NativeArrayBuffer(4); +const floatView = new NativeFloat32Array(buffer); +const uint32View = new NativeUint32Array(buffer); +const baseTable = new NativeUint32Array(512); +const shiftTable = new NativeUint32Array(512); +for (let i = 0; i < 256; ++i) { + const e = i - 127; + if (e < -27) { + baseTable[i] = 0x0000; + baseTable[i | 0x100] = 0x8000; + shiftTable[i] = 24; + shiftTable[i | 0x100] = 24; + } else if (e < -14) { + baseTable[i] = 0x0400 >> (-e - 14); + baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000; + shiftTable[i] = -e - 1; + shiftTable[i | 0x100] = -e - 1; + } else if (e <= 15) { + baseTable[i] = (e + 15) << 10; + baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000; + shiftTable[i] = 13; + shiftTable[i | 0x100] = 13; + } else if (e < 128) { + baseTable[i] = 0x7c00; + baseTable[i | 0x100] = 0xfc00; + shiftTable[i] = 24; + shiftTable[i | 0x100] = 24; + } else { + baseTable[i] = 0x7c00; + baseTable[i | 0x100] = 0xfc00; + shiftTable[i] = 13; + shiftTable[i | 0x100] = 13; + } +} +function roundToFloat16Bits(num) { + floatView[0] = (num); + const f = uint32View[0]; + const e = (f >> 23) & 0x1ff; + return baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]); +} +const mantissaTable = new NativeUint32Array(2048); +const exponentTable = new NativeUint32Array(64); +const offsetTable = new NativeUint32Array(64); +for (let i = 1; i < 1024; ++i) { + let m = i << 13; + let e = 0; + while((m & 0x00800000) === 0) { + m <<= 1; + e -= 0x00800000; + } + m &= ~0x00800000; + e += 0x38800000; + mantissaTable[i] = m | e; +} +for (let i = 1024; i < 2048; ++i) { + mantissaTable[i] = 0x38000000 + ((i - 1024) << 13); +} +for (let i = 1; i < 31; ++i) { + exponentTable[i] = i << 23; +} +exponentTable[31] = 0x47800000; +exponentTable[32] = 0x80000000; +for (let i = 33; i < 63; ++i) { + exponentTable[i] = 0x80000000 + ((i - 32) << 23); +} +exponentTable[63] = 0xc7800000; +for (let i = 1; i < 64; ++i) { + if (i !== 32) { + offsetTable[i] = 1024; + } +} +function convertToNumber(float16bits) { + const m = float16bits >> 10; + uint32View[0] = mantissaTable[offsetTable[m] + (float16bits & 0x3ff)] + exponentTable[m]; + return floatView[0]; +} + +function ToIntegerOrInfinity(target) { + const number = +target; + if (NumberIsNaN(number) || number === 0) { + return 0; + } + return MathTrunc(number); +} +function ToLength(target) { + const length = ToIntegerOrInfinity(target); + if (length < 0) { + return 0; + } + return length < MAX_SAFE_INTEGER + ? length + : MAX_SAFE_INTEGER; +} +function SpeciesConstructor(target, defaultConstructor) { + if (!isObject(target)) { + throw NativeTypeError(THIS_IS_NOT_AN_OBJECT); + } + const constructor = target.constructor; + if (constructor === undefined) { + return defaultConstructor; + } + if (!isObject(constructor)) { + throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT); + } + const species = constructor[SymbolSpecies]; + if (species == null) { + return defaultConstructor; + } + return species; +} +function IsDetachedBuffer(buffer) { + if (isSharedArrayBuffer(buffer)) { + return false; + } + try { + ArrayBufferPrototypeSlice(buffer, 0, 0); + return false; + } catch (e) {} + return true; +} +function defaultCompare(x, y) { + const isXNaN = NumberIsNaN(x); + const isYNaN = NumberIsNaN(y); + if (isXNaN && isYNaN) { + return 0; + } + if (isXNaN) { + return 1; + } + if (isYNaN) { + return -1; + } + if (x < y) { + return -1; + } + if (x > y) { + return 1; + } + if (x === 0 && y === 0) { + const isXPlusZero = ObjectIs(x, 0); + const isYPlusZero = ObjectIs(y, 0); + if (!isXPlusZero && isYPlusZero) { + return -1; + } + if (isXPlusZero && !isYPlusZero) { + return 1; + } + } + return 0; +} + +const BYTES_PER_ELEMENT = 2; +const float16bitsArrays = new NativeWeakMap(); +function isFloat16Array(target) { + return WeakMapPrototypeHas(float16bitsArrays, target) || + (!ArrayBufferIsView(target) && hasFloat16ArrayBrand(target)); +} +function assertFloat16Array(target) { + if (!isFloat16Array(target)) { + throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT); + } +} +function assertSpeciesTypedArray(target, count) { + const isTargetFloat16Array = isFloat16Array(target); + const isTargetTypedArray = isNativeTypedArray(target); + if (!isTargetFloat16Array && !isTargetTypedArray) { + throw NativeTypeError(SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT); + } + if (typeof count === "number") { + let length; + if (isTargetFloat16Array) { + const float16bitsArray = getFloat16BitsArray(target); + length = TypedArrayPrototypeGetLength(float16bitsArray); + } else { + length = TypedArrayPrototypeGetLength(target); + } + if (length < count) { + throw NativeTypeError( + DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH + ); + } + } + if (isNativeBigIntTypedArray(target)) { + throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES); + } +} +function getFloat16BitsArray(float16) { + const float16bitsArray = WeakMapPrototypeGet(float16bitsArrays, float16); + if (float16bitsArray !== undefined) { + const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray); + if (IsDetachedBuffer(buffer)) { + throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); + } + return float16bitsArray; + } + const buffer = (float16).buffer; + if (IsDetachedBuffer(buffer)) { + throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); + } + const cloned = ReflectConstruct(Float16Array, [ + buffer, + (float16).byteOffset, + (float16).length, + ], float16.constructor); + return WeakMapPrototypeGet(float16bitsArrays, cloned); +} +function copyToArray(float16bitsArray) { + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const array = []; + for (let i = 0; i < length; ++i) { + array[i] = convertToNumber(float16bitsArray[i]); + } + return array; +} +const TypedArrayPrototypeGetters = new NativeWeakSet(); +for (const key of ReflectOwnKeys(TypedArrayPrototype)) { + if (key === SymbolToStringTag) { + continue; + } + const descriptor = ReflectGetOwnPropertyDescriptor(TypedArrayPrototype, key); + if (ObjectHasOwn(descriptor, "get") && typeof descriptor.get === "function") { + WeakSetPrototypeAdd(TypedArrayPrototypeGetters, descriptor.get); + } +} +const handler = ObjectFreeze( ({ + get(target, key, receiver) { + if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) { + return convertToNumber(ReflectGet(target, key)); + } + if (WeakSetPrototypeHas(TypedArrayPrototypeGetters, ObjectPrototype__lookupGetter__(target, key))) { + return ReflectGet(target, key); + } + return ReflectGet(target, key, receiver); + }, + set(target, key, value, receiver) { + if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) { + return ReflectSet(target, key, roundToFloat16Bits(value)); + } + return ReflectSet(target, key, value, receiver); + }, + getOwnPropertyDescriptor(target, key) { + if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) { + const descriptor = ReflectGetOwnPropertyDescriptor(target, key); + descriptor.value = convertToNumber(descriptor.value); + return descriptor; + } + return ReflectGetOwnPropertyDescriptor(target, key); + }, + defineProperty(target, key, descriptor) { + if ( + isCanonicalIntegerIndexString(key) && + ObjectHasOwn(target, key) && + ObjectHasOwn(descriptor, "value") + ) { + descriptor.value = roundToFloat16Bits(descriptor.value); + return ReflectDefineProperty(target, key, descriptor); + } + return ReflectDefineProperty(target, key, descriptor); + }, +})); +class Float16Array { + constructor(input, _byteOffset, _length) { + let float16bitsArray; + if (isFloat16Array(input)) { + float16bitsArray = ReflectConstruct(NativeUint16Array, [getFloat16BitsArray(input)], new.target); + } else if (isObject(input) && !isArrayBuffer(input)) { + let list; + let length; + if (isNativeTypedArray(input)) { + list = input; + length = TypedArrayPrototypeGetLength(input); + const buffer = TypedArrayPrototypeGetBuffer(input); + const BufferConstructor = !isSharedArrayBuffer(buffer) + ? (SpeciesConstructor( + buffer, + NativeArrayBuffer + )) + : NativeArrayBuffer; + if (IsDetachedBuffer(buffer)) { + throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); + } + if (isNativeBigIntTypedArray(input)) { + throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES); + } + const data = new BufferConstructor( + length * BYTES_PER_ELEMENT + ); + float16bitsArray = ReflectConstruct(NativeUint16Array, [data], new.target); + } else { + const iterator = input[SymbolIterator]; + if (iterator != null && typeof iterator !== "function") { + throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE); + } + if (iterator != null) { + if (isOrdinaryArray(input)) { + list = input; + length = input.length; + } else { + list = [... (input)]; + length = list.length; + } + } else { + list = (input); + length = ToLength(list.length); + } + float16bitsArray = ReflectConstruct(NativeUint16Array, [length], new.target); + } + for (let i = 0; i < length; ++i) { + float16bitsArray[i] = roundToFloat16Bits(list[i]); + } + } else { + float16bitsArray = ReflectConstruct(NativeUint16Array, arguments, new.target); + } + const proxy = (new NativeProxy(float16bitsArray, handler)); + WeakMapPrototypeSet(float16bitsArrays, proxy, float16bitsArray); + return proxy; + } + static from(src, ...opts) { + const Constructor = this; + if (!ReflectHas(Constructor, brand)) { + throw NativeTypeError( + THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY + ); + } + if (Constructor === Float16Array) { + if (isFloat16Array(src) && opts.length === 0) { + const float16bitsArray = getFloat16BitsArray(src); + const uint16 = new NativeUint16Array( + TypedArrayPrototypeGetBuffer(float16bitsArray), + TypedArrayPrototypeGetByteOffset(float16bitsArray), + TypedArrayPrototypeGetLength(float16bitsArray) + ); + return new Float16Array( + TypedArrayPrototypeGetBuffer(TypedArrayPrototypeSlice(uint16)) + ); + } + if (opts.length === 0) { + return new Float16Array( + TypedArrayPrototypeGetBuffer( + Uint16ArrayFrom(src, roundToFloat16Bits) + ) + ); + } + const mapFunc = opts[0]; + const thisArg = opts[1]; + return new Float16Array( + TypedArrayPrototypeGetBuffer( + Uint16ArrayFrom(src, function (val, ...args) { + return roundToFloat16Bits( + ReflectApply(mapFunc, this, [val, ...safeIfNeeded(args)]) + ); + }, thisArg) + ) + ); + } + let list; + let length; + const iterator = src[SymbolIterator]; + if (iterator != null && typeof iterator !== "function") { + throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE); + } + if (iterator != null) { + if (isOrdinaryArray(src)) { + list = src; + length = src.length; + } else if (isOrdinaryNativeTypedArray(src)) { + list = src; + length = TypedArrayPrototypeGetLength(src); + } else { + list = [...src]; + length = list.length; + } + } else { + if (src == null) { + throw NativeTypeError( + CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT + ); + } + list = NativeObject(src); + length = ToLength(list.length); + } + const array = new Constructor(length); + if (opts.length === 0) { + for (let i = 0; i < length; ++i) { + array[i] = (list[i]); + } + } else { + const mapFunc = opts[0]; + const thisArg = opts[1]; + for (let i = 0; i < length; ++i) { + array[i] = ReflectApply(mapFunc, thisArg, [list[i], i]); + } + } + return array; + } + static of(...items) { + const Constructor = this; + if (!ReflectHas(Constructor, brand)) { + throw NativeTypeError( + THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY + ); + } + const length = items.length; + if (Constructor === Float16Array) { + const proxy = new Float16Array(length); + const float16bitsArray = getFloat16BitsArray(proxy); + for (let i = 0; i < length; ++i) { + float16bitsArray[i] = roundToFloat16Bits(items[i]); + } + return proxy; + } + const array = new Constructor(length); + for (let i = 0; i < length; ++i) { + array[i] = items[i]; + } + return array; + } + keys() { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + return TypedArrayPrototypeKeys(float16bitsArray); + } + values() { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + return wrap((function* () { + for (const val of TypedArrayPrototypeValues(float16bitsArray)) { + yield convertToNumber(val); + } + })()); + } + entries() { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + return wrap((function* () { + for (const [i, val] of TypedArrayPrototypeEntries(float16bitsArray)) { + yield ([i, convertToNumber(val)]); + } + })()); + } + at(index) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const relativeIndex = ToIntegerOrInfinity(index); + const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex; + if (k < 0 || k >= length) { + return; + } + return convertToNumber(float16bitsArray[k]); + } + map(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + const Constructor = SpeciesConstructor(float16bitsArray, Float16Array); + if (Constructor === Float16Array) { + const proxy = new Float16Array(length); + const array = getFloat16BitsArray(proxy); + for (let i = 0; i < length; ++i) { + const val = convertToNumber(float16bitsArray[i]); + array[i] = roundToFloat16Bits( + ReflectApply(callback, thisArg, [val, i, this]) + ); + } + return proxy; + } + const array = new Constructor(length); + assertSpeciesTypedArray(array, length); + for (let i = 0; i < length; ++i) { + const val = convertToNumber(float16bitsArray[i]); + array[i] = ReflectApply(callback, thisArg, [val, i, this]); + } + return (array); + } + filter(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + const kept = []; + for (let i = 0; i < length; ++i) { + const val = convertToNumber(float16bitsArray[i]); + if (ReflectApply(callback, thisArg, [val, i, this])) { + ArrayPrototypePush(kept, val); + } + } + const Constructor = SpeciesConstructor(float16bitsArray, Float16Array); + const array = new Constructor(kept); + assertSpeciesTypedArray(array); + return (array); + } + reduce(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + if (length === 0 && opts.length === 0) { + throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE); + } + let accumulator, start; + if (opts.length === 0) { + accumulator = convertToNumber(float16bitsArray[0]); + start = 1; + } else { + accumulator = opts[0]; + start = 0; + } + for (let i = start; i < length; ++i) { + accumulator = callback( + accumulator, + convertToNumber(float16bitsArray[i]), + i, + this + ); + } + return accumulator; + } + reduceRight(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + if (length === 0 && opts.length === 0) { + throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE); + } + let accumulator, start; + if (opts.length === 0) { + accumulator = convertToNumber(float16bitsArray[length - 1]); + start = length - 2; + } else { + accumulator = opts[0]; + start = length - 1; + } + for (let i = start; i >= 0; --i) { + accumulator = callback( + accumulator, + convertToNumber(float16bitsArray[i]), + i, + this + ); + } + return accumulator; + } + forEach(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = 0; i < length; ++i) { + ReflectApply(callback, thisArg, [ + convertToNumber(float16bitsArray[i]), + i, + this, + ]); + } + } + find(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = 0; i < length; ++i) { + const value = convertToNumber(float16bitsArray[i]); + if (ReflectApply(callback, thisArg, [value, i, this])) { + return value; + } + } + } + findIndex(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = 0; i < length; ++i) { + const value = convertToNumber(float16bitsArray[i]); + if (ReflectApply(callback, thisArg, [value, i, this])) { + return i; + } + } + return -1; + } + findLast(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = length - 1; i >= 0; --i) { + const value = convertToNumber(float16bitsArray[i]); + if (ReflectApply(callback, thisArg, [value, i, this])) { + return value; + } + } + } + findLastIndex(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = length - 1; i >= 0; --i) { + const value = convertToNumber(float16bitsArray[i]); + if (ReflectApply(callback, thisArg, [value, i, this])) { + return i; + } + } + return -1; + } + every(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = 0; i < length; ++i) { + if ( + !ReflectApply(callback, thisArg, [ + convertToNumber(float16bitsArray[i]), + i, + this, + ]) + ) { + return false; + } + } + return true; + } + some(callback, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const thisArg = opts[0]; + for (let i = 0; i < length; ++i) { + if ( + ReflectApply(callback, thisArg, [ + convertToNumber(float16bitsArray[i]), + i, + this, + ]) + ) { + return true; + } + } + return false; + } + set(input, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const targetOffset = ToIntegerOrInfinity(opts[0]); + if (targetOffset < 0) { + throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS); + } + if (input == null) { + throw NativeTypeError( + CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT + ); + } + if (isNativeBigIntTypedArray(input)) { + throw NativeTypeError( + CANNOT_MIX_BIGINT_AND_OTHER_TYPES + ); + } + if (isFloat16Array(input)) { + return TypedArrayPrototypeSet( + getFloat16BitsArray(this), + getFloat16BitsArray(input), + targetOffset + ); + } + if (isNativeTypedArray(input)) { + const buffer = TypedArrayPrototypeGetBuffer(input); + if (IsDetachedBuffer(buffer)) { + throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); + } + } + const targetLength = TypedArrayPrototypeGetLength(float16bitsArray); + const src = NativeObject(input); + const srcLength = ToLength(src.length); + if (targetOffset === Infinity || srcLength + targetOffset > targetLength) { + throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS); + } + for (let i = 0; i < srcLength; ++i) { + float16bitsArray[i + targetOffset] = roundToFloat16Bits(src[i]); + } + } + reverse() { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + TypedArrayPrototypeReverse(float16bitsArray); + return this; + } + fill(value, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + TypedArrayPrototypeFill( + float16bitsArray, + roundToFloat16Bits(value), + ...safeIfNeeded(opts) + ); + return this; + } + copyWithin(target, start, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + TypedArrayPrototypeCopyWithin(float16bitsArray, target, start, ...safeIfNeeded(opts)); + return this; + } + sort(compareFn) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const sortCompare = compareFn !== undefined ? compareFn : defaultCompare; + TypedArrayPrototypeSort(float16bitsArray, (x, y) => { + return sortCompare(convertToNumber(x), convertToNumber(y)); + }); + return this; + } + slice(start, end) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const Constructor = SpeciesConstructor(float16bitsArray, Float16Array); + if (Constructor === Float16Array) { + const uint16 = new NativeUint16Array( + TypedArrayPrototypeGetBuffer(float16bitsArray), + TypedArrayPrototypeGetByteOffset(float16bitsArray), + TypedArrayPrototypeGetLength(float16bitsArray) + ); + return new Float16Array( + TypedArrayPrototypeGetBuffer( + TypedArrayPrototypeSlice(uint16, start, end) + ) + ); + } + const length = TypedArrayPrototypeGetLength(float16bitsArray); + const relativeStart = ToIntegerOrInfinity(start); + const relativeEnd = end === undefined ? length : ToIntegerOrInfinity(end); + let k; + if (relativeStart === -Infinity) { + k = 0; + } else if (relativeStart < 0) { + k = length + relativeStart > 0 ? length + relativeStart : 0; + } else { + k = length < relativeStart ? length : relativeStart; + } + let final; + if (relativeEnd === -Infinity) { + final = 0; + } else if (relativeEnd < 0) { + final = length + relativeEnd > 0 ? length + relativeEnd : 0; + } else { + final = length < relativeEnd ? length : relativeEnd; + } + const count = final - k > 0 ? final - k : 0; + const array = new Constructor(count); + assertSpeciesTypedArray(array, count); + if (count === 0) { + return array; + } + const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray); + if (IsDetachedBuffer(buffer)) { + throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); + } + let n = 0; + while (k < final) { + array[n] = convertToNumber(float16bitsArray[k]); + ++k; + ++n; + } + return (array); + } + subarray(begin, end) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const Constructor = SpeciesConstructor(float16bitsArray, Float16Array); + const uint16 = new NativeUint16Array( + TypedArrayPrototypeGetBuffer(float16bitsArray), + TypedArrayPrototypeGetByteOffset(float16bitsArray), + TypedArrayPrototypeGetLength(float16bitsArray) + ); + const uint16Subarray = TypedArrayPrototypeSubarray(uint16, begin, end); + const array = new Constructor( + TypedArrayPrototypeGetBuffer(uint16Subarray), + TypedArrayPrototypeGetByteOffset(uint16Subarray), + TypedArrayPrototypeGetLength(uint16Subarray) + ); + assertSpeciesTypedArray(array); + return (array); + } + indexOf(element, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + let from = ToIntegerOrInfinity(opts[0]); + if (from === Infinity) { + return -1; + } + if (from < 0) { + from += length; + if (from < 0) { + from = 0; + } + } + for (let i = from; i < length; ++i) { + if ( + ObjectHasOwn(float16bitsArray, i) && + convertToNumber(float16bitsArray[i]) === element + ) { + return i; + } + } + return -1; + } + lastIndexOf(element, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + let from = opts.length >= 1 ? ToIntegerOrInfinity(opts[0]) : length - 1; + if (from === -Infinity) { + return -1; + } + if (from >= 0) { + from = from < length - 1 ? from : length - 1; + } else { + from += length; + } + for (let i = from; i >= 0; --i) { + if ( + ObjectHasOwn(float16bitsArray, i) && + convertToNumber(float16bitsArray[i]) === element + ) { + return i; + } + } + return -1; + } + includes(element, ...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const length = TypedArrayPrototypeGetLength(float16bitsArray); + let from = ToIntegerOrInfinity(opts[0]); + if (from === Infinity) { + return false; + } + if (from < 0) { + from += length; + if (from < 0) { + from = 0; + } + } + const isNaN = NumberIsNaN(element); + for (let i = from; i < length; ++i) { + const value = convertToNumber(float16bitsArray[i]); + if (isNaN && NumberIsNaN(value)) { + return true; + } + if (value === element) { + return true; + } + } + return false; + } + join(separator) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const array = copyToArray(float16bitsArray); + return ArrayPrototypeJoin(array, separator); + } + toLocaleString(...opts) { + assertFloat16Array(this); + const float16bitsArray = getFloat16BitsArray(this); + const array = copyToArray(float16bitsArray); + return ArrayPrototypeToLocaleString(array, ...safeIfNeeded(opts)); + } + get [SymbolToStringTag]() { + if (isFloat16Array(this)) { + return ("Float16Array"); + } + } +} +ObjectDefineProperty(Float16Array, "BYTES_PER_ELEMENT", { + value: BYTES_PER_ELEMENT, +}); +ObjectDefineProperty(Float16Array, brand, {}); +ReflectSetPrototypeOf(Float16Array, TypedArray); +const Float16ArrayPrototype = Float16Array.prototype; +ObjectDefineProperty(Float16ArrayPrototype, "BYTES_PER_ELEMENT", { + value: BYTES_PER_ELEMENT, +}); +ObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, { + value: Float16ArrayPrototype.values, + writable: true, + configurable: true, +}); +ReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype); + +function isTypedArray(target) { + return isNativeTypedArray(target) || isFloat16Array(target); +} + +function getFloat16(dataView, byteOffset, ...opts) { + return convertToNumber( + DataViewPrototypeGetUint16(dataView, byteOffset, ...safeIfNeeded(opts)) + ); +} +function setFloat16(dataView, byteOffset, value, ...opts) { + return DataViewPrototypeSetUint16( + dataView, + byteOffset, + roundToFloat16Bits(value), + ...safeIfNeeded(opts) + ); +} + +function hfround(x) { + const number = +x; + if (!NumberIsFinite(number) || number === 0) { + return number; + } + const x16 = roundToFloat16Bits(number); + return convertToNumber(x16); +} + +export { Float16Array, getFloat16, hfround, isFloat16Array, isTypedArray, setFloat16 }; -- cgit v1.2.3