diff options
Diffstat (limited to 'testing/web-platform/mozilla/tests/webgpu/external')
4 files changed, 1235 insertions, 0 deletions
diff --git a/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.d.js b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.d.js new file mode 100644 index 0000000000..d78ce8de82 --- /dev/null +++ b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.d.js @@ -0,0 +1,4 @@ +/** +* AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts +**/export {}; +//# sourceMappingURL=float16.d.js.map
\ No newline at end of file diff --git a/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.d.js.map b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.d.js.map new file mode 100644 index 0000000000..ad7929e6a4 --- /dev/null +++ b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.d.js.map @@ -0,0 +1 @@ +{"version":3,"file":"float16.d.js","names":[],"sources":["../../../../src/external/petamoriken/float16/float16.d.ts"],"sourcesContent":["/**\n * A typed array of 16-bit float values. The contents are initialized to 0. If the requested number\n * of bytes could not be allocated an exception is raised.\n */\nexport interface Float16Array {\n /**\n * The size in bytes of each element in the array.\n */\n readonly BYTES_PER_ELEMENT: number;\n\n /**\n * The ArrayBuffer instance referenced by the array.\n */\n readonly buffer: ArrayBufferLike;\n\n /**\n * The length in bytes of the array.\n */\n readonly byteLength: number;\n\n /**\n * The offset in bytes of the array.\n */\n readonly byteOffset: number;\n\n [Symbol.iterator](): IterableIterator<number>;\n\n /**\n * Returns an array of key, value pairs for every entry in the array\n */\n entries(): IterableIterator<[number, number]>;\n\n /**\n * Returns an list of keys in the array\n */\n keys(): IterableIterator<number>;\n\n /**\n * Returns an list of values in the array\n */\n values(): IterableIterator<number>;\n\n /**\n * Returns the item located at the specified index.\n * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.\n */\n at(index: number): number | undefined;\n\n /**\n * Returns the this object after copying a section of the array identified by start and end\n * to the same array starting at position target\n * @param target If target is negative, it is treated as length+target where length is the\n * length of the array.\n * @param start If start is negative, it is treated as length+start. If end is negative, it\n * is treated as length+end.\n * @param end If not specified, length of the this object is used as its default value.\n */\n copyWithin(target: number, start: number, end?: number): this;\n\n /**\n * Determines whether all the members of an array satisfy the specified test.\n * @param callbackfn A function that accepts up to three arguments. The every method calls\n * the callbackfn function for each element in the array until the callbackfn returns a value\n * which is coercible to the Boolean value false, or until the end of the array.\n * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n * If thisArg is omitted, undefined is used as the this value.\n */\n every(\n callbackfn: (value: number, index: number, array: Float16Array) => unknown,\n thisArg?: any,\n ): boolean;\n\n /**\n * Returns the this object after filling the section identified by start and end with value\n * @param value value to fill array section with\n * @param start index to start filling the array at. If start is negative, it is treated as\n * length+start where length is the length of the array.\n * @param end index to stop filling the array at. If end is negative, it is treated as\n * length+end.\n */\n fill(value: number, start?: number, end?: number): this;\n\n /**\n * Returns the elements of an array that meet the condition specified in a callback function.\n * @param predicate A function that accepts up to three arguments. The filter method calls\n * the predicate function one time for each element in the array.\n * @param thisArg An object to which the this keyword can refer in the predicate function.\n * If thisArg is omitted, undefined is used as the this value.\n */\n filter(\n predicate: (value: number, index: number, array: Float16Array) => any,\n thisArg?: any,\n ): Float16Array;\n\n /**\n * Returns the value of the first element in the array where predicate is true, and undefined\n * otherwise.\n * @param predicate find calls predicate once for each element of the array, in ascending\n * order, until it finds one where predicate returns true. If such an element is found, find\n * immediately returns that element value. Otherwise, find returns undefined.\n * @param thisArg If provided, it will be used as the this value for each invocation of\n * predicate. If it is not provided, undefined is used instead.\n */\n find(\n predicate: (value: number, index: number, obj: Float16Array) => boolean,\n thisArg?: any,\n ): number | undefined;\n\n /**\n * Returns the index of the first element in the array where predicate is true, and -1\n * otherwise.\n * @param predicate find calls predicate once for each element of the array, in ascending\n * order, until it finds one where predicate returns true. If such an element is found,\n * findIndex immediately returns that element index. Otherwise, findIndex returns -1.\n * @param thisArg If provided, it will be used as the this value for each invocation of\n * predicate. If it is not provided, undefined is used instead.\n */\n findIndex(\n predicate: (value: number, index: number, obj: Float16Array) => boolean,\n thisArg?: any,\n ): number;\n\n /**\n * Returns the value of the last element in the array where predicate is true, and undefined\n * otherwise.\n * @param predicate find calls predicate once for each element of the array, in descending\n * order, until it finds one where predicate returns true. If such an element is found, findLast\n * immediately returns that element value. Otherwise, findLast returns undefined.\n * @param thisArg If provided, it will be used as the this value for each invocation of\n * predicate. If it is not provided, undefined is used instead.\n */\n findLast(\n predicate: (value: number, index: number, obj: Float16Array) => boolean,\n thisArg?: any,\n ): number | undefined;\n\n /**\n * Returns the index of the last element in the array where predicate is true, and -1\n * otherwise.\n * @param predicate find calls predicate once for each element of the array, in descending\n * order, until it finds one where predicate returns true. If such an element is found,\n * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.\n * @param thisArg If provided, it will be used as the this value for each invocation of\n * predicate. If it is not provided, undefined is used instead.\n */\n findLastIndex(\n predicate: (value: number, index: number, obj: Float16Array) => boolean,\n thisArg?: any,\n ): number;\n\n /**\n * Performs the specified action for each element in an array.\n * @param callbackfn A function that accepts up to three arguments. forEach calls the\n * callbackfn function one time for each element in the array.\n * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n * If thisArg is omitted, undefined is used as the this value.\n */\n forEach(\n callbackfn: (value: number, index: number, array: Float16Array) => void,\n thisArg?: any,\n ): void;\n\n /**\n * Determines whether an array includes a certain element, returning true or false as appropriate.\n * @param searchElement The element to search for.\n * @param fromIndex The position in this array at which to begin searching for searchElement.\n */\n includes(searchElement: number, fromIndex?: number): boolean;\n\n /**\n * Returns the index of the first occurrence of a value in an array.\n * @param searchElement The value to locate in the array.\n * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\n * search starts at index 0.\n */\n indexOf(searchElement: number, fromIndex?: number): number;\n\n /**\n * Adds all the elements of an array separated by the specified separator string.\n * @param separator A string used to separate one element of an array from the next in the\n * resulting String. If omitted, the array elements are separated with a comma.\n */\n join(separator?: string): string;\n\n /**\n * Returns the index of the last occurrence of a value in an array.\n * @param searchElement The value to locate in the array.\n * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\n * search starts at index 0.\n */\n lastIndexOf(searchElement: number, fromIndex?: number): number;\n\n /**\n * The length of the array.\n */\n readonly length: number;\n\n /**\n * Calls a defined callback function on each element of an array, and returns an array that\n * contains the results.\n * @param callbackfn A function that accepts up to three arguments. The map method calls the\n * callbackfn function one time for each element in the array.\n * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n * If thisArg is omitted, undefined is used as the this value.\n */\n map(\n callbackfn: (value: number, index: number, array: Float16Array) => number,\n thisArg?: any,\n ): Float16Array;\n\n /**\n * Calls the specified callback function for all the elements in an array. The return value of\n * the callback function is the accumulated result, and is provided as an argument in the next\n * call to the callback function.\n * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\n * callbackfn function one time for each element in the array.\n * @param initialValue If initialValue is specified, it is used as the initial value to start\n * the accumulation. The first call to the callbackfn function provides this value as an argument\n * instead of an array value.\n */\n reduce(\n callbackfn: (\n previousValue: number,\n currentValue: number,\n currentIndex: number,\n array: Float16Array,\n ) => number,\n ): number;\n reduce(\n callbackfn: (\n previousValue: number,\n currentValue: number,\n currentIndex: number,\n array: Float16Array,\n ) => number,\n initialValue: number,\n ): number;\n reduce<U>(\n callbackfn: (\n previousValue: U,\n currentValue: number,\n currentIndex: number,\n array: Float16Array,\n ) => U,\n initialValue: U,\n ): U;\n\n /**\n * Calls the specified callback function for all the elements in an array, in descending order.\n * The return value of the callback function is the accumulated result, and is provided as an\n * argument in the next call to the callback function.\n * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\n * the callbackfn function one time for each element in the array.\n * @param initialValue If initialValue is specified, it is used as the initial value to start\n * the accumulation. The first call to the callbackfn function provides this value as an\n * argument instead of an array value.\n */\n reduceRight(\n callbackfn: (\n previousValue: number,\n currentValue: number,\n currentIndex: number,\n array: Float16Array,\n ) => number,\n ): number;\n reduceRight(\n callbackfn: (\n previousValue: number,\n currentValue: number,\n currentIndex: number,\n array: Float16Array,\n ) => number,\n initialValue: number,\n ): number;\n reduceRight<U>(\n callbackfn: (\n previousValue: U,\n currentValue: number,\n currentIndex: number,\n array: Float16Array,\n ) => U,\n initialValue: U,\n ): U;\n\n /**\n * Reverses the elements in an Array.\n */\n reverse(): this;\n\n /**\n * Sets a value or an array of values.\n * @param array A typed or untyped array of values to set.\n * @param offset The index in the current array at which the values are to be written.\n */\n set(array: ArrayLike<number>, offset?: number): void;\n\n /**\n * Returns a section of an array.\n * @param start The beginning of the specified portion of the array.\n * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.\n */\n slice(start?: number, end?: number): Float16Array;\n\n /**\n * Determines whether the specified callback function returns true for any element of an array.\n * @param callbackfn A function that accepts up to three arguments. The some method calls\n * the callbackfn function for each element in the array until the callbackfn returns a value\n * which is coercible to the Boolean value true, or until the end of the array.\n * @param thisArg An object to which the this keyword can refer in the callbackfn function.\n * If thisArg is omitted, undefined is used as the this value.\n */\n some(\n callbackfn: (value: number, index: number, array: Float16Array) => unknown,\n thisArg?: any,\n ): boolean;\n\n /**\n * Sorts an array.\n * @param compareFn Function used to determine the order of the elements. It is expected to return\n * a negative value if first argument is less than second argument, zero if they're equal and a positive\n * value otherwise. If omitted, the elements are sorted in ascending.\n */\n sort(compareFn?: (a: number, b: number) => number): this;\n\n /**\n * Gets a new Float16Array view of the ArrayBuffer store for this array, referencing the elements\n * at begin, inclusive, up to end, exclusive.\n * @param begin The index of the beginning of the array.\n * @param end The index of the end of the array.\n */\n subarray(begin?: number, end?: number): Float16Array;\n\n /**\n * Converts a number to a string by using the current locale.\n */\n toLocaleString(): string;\n\n /**\n * Returns a string representation of an array.\n */\n toString(): string;\n\n /**\n * Returns the primitive value of the specified object.\n */\n valueOf(): Float16Array;\n\n readonly [Symbol.toStringTag]: \"Float16Array\";\n\n [index: number]: number;\n}\n\nexport interface Float16ArrayConstructor {\n readonly prototype: Float16Array;\n new (): Float16Array;\n new (length: number): Float16Array;\n new (elements: Iterable<number>): Float16Array;\n new (array: ArrayLike<number> | ArrayBufferLike): Float16Array;\n new (\n buffer: ArrayBufferLike,\n byteOffset: number,\n length?: number,\n ): Float16Array;\n\n /**\n * The size in bytes of each element in the array.\n */\n readonly BYTES_PER_ELEMENT: number;\n\n /**\n * Returns a new array from a set of elements.\n * @param items A set of elements to include in the new array object.\n */\n of(...items: number[]): Float16Array;\n\n /**\n * Creates an array from an array-like or iterable object.\n * @param elements An iterable object to convert to an array.\n */\n from(elements: Iterable<number>): Float16Array;\n\n /**\n * Creates an array from an array-like or iterable object.\n * @param elements An iterable object to convert to an array.\n * @param mapfn A mapping function to call on every element of the array.\n * @param thisArg Value of 'this' used to invoke the mapfn.\n */\n from<T>(\n elements: Iterable<T>,\n mapfn: (v: T, k: number) => number,\n thisArg?: any,\n ): Float16Array;\n\n /**\n * Creates an array from an array-like or iterable object.\n * @param arrayLike An array-like object to convert to an array.\n */\n from(arrayLike: ArrayLike<number>): Float16Array;\n\n /**\n * Creates an array from an array-like or iterable object.\n * @param arrayLike An array-like object to convert to an array.\n * @param mapfn A mapping function to call on every element of the array.\n * @param thisArg Value of 'this' used to invoke the mapfn.\n */\n from<T>(\n arrayLike: ArrayLike<T>,\n mapfn: (v: T, k: number) => number,\n thisArg?: any,\n ): Float16Array;\n}\nexport declare const Float16Array: Float16ArrayConstructor;\n\n/**\n * Returns `true` if the value is a Float16Array instance.\n * @since v3.4.0\n */\nexport declare function isFloat16Array(value: unknown): value is Float16Array;\n\n/**\n * Returns `true` if the value is a type of TypedArray instance that contains Float16Array.\n * @since v3.6.0\n */\nexport declare function isTypedArray(\n value: unknown,\n): value is\n | Uint8Array\n | Uint8ClampedArray\n | Uint16Array\n | Uint32Array\n | Int8Array\n | Int16Array\n | Int32Array\n | Float16Array\n | Float32Array\n | Float64Array\n | BigUint64Array\n | BigInt64Array;\n\n/**\n * Gets the Float16 value at the specified byte offset from the start of the view. There is\n * no alignment constraint; multi-byte values may be fetched from any offset.\n * @param byteOffset The place in the buffer at which the value should be retrieved.\n * @param littleEndian If false or undefined, a big-endian value should be read,\n * otherwise a little-endian value should be read.\n */\nexport declare function getFloat16(\n dataView: DataView,\n byteOffset: number,\n littleEndian?: boolean,\n): number;\n\n/**\n * Stores an Float16 value at the specified byte offset from the start of the view.\n * @param byteOffset The place in the buffer at which the value should be set.\n * @param value The value to set.\n * @param littleEndian If false or undefined, a big-endian value should be written,\n * otherwise a little-endian value should be written.\n */\nexport declare function setFloat16(\n dataView: DataView,\n byteOffset: number,\n value: number,\n littleEndian?: boolean,\n): void;\n\n/**\n * Returns the nearest half-precision float representation of a number.\n * @param x A numeric expression.\n */\nexport declare function hfround(x: number): number;\n"],"mappings":";AAAA;AAAA,G"}
\ No newline at end of file diff --git a/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.js b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.js new file mode 100644 index 0000000000..13314a1d4c --- /dev/null +++ b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.js @@ -0,0 +1,1229 @@ +/** +* AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts +**/ /*! @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 }; +//# sourceMappingURL=float16.js.map
\ No newline at end of file diff --git a/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.js.map b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.js.map new file mode 100644 index 0000000000..5996472809 --- /dev/null +++ b/testing/web-platform/mozilla/tests/webgpu/external/petamoriken/float16/float16.js.map @@ -0,0 +1 @@ +{"version":3,"file":"float16.js","names":["THIS_IS_NOT_AN_OBJECT","THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT","THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY","THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT","SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT","DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH","ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER","CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT","CANNOT_MIX_BIGINT_AND_OTHER_TYPES","ITERATOR_PROPERTY_IS_NOT_CALLABLE","REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE","OFFSET_IS_OUT_OF_BOUNDS","uncurryThis","target","thisArg","args","ReflectApply","uncurryThisGetter","key","ReflectGetOwnPropertyDescriptor","get","apply","construct","ReflectConstruct","defineProperty","ReflectDefineProperty","ReflectGet","getOwnPropertyDescriptor","getPrototypeOf","ReflectGetPrototypeOf","has","ReflectHas","ownKeys","ReflectOwnKeys","set","ReflectSet","setPrototypeOf","ReflectSetPrototypeOf","Reflect","NativeProxy","Proxy","MAX_SAFE_INTEGER","isFinite","NumberIsFinite","isNaN","NumberIsNaN","Number","iterator","SymbolIterator","species","SymbolSpecies","toStringTag","SymbolToStringTag","for","SymbolFor","Symbol","NativeObject","Object","create","ObjectCreate","ObjectDefineProperty","freeze","ObjectFreeze","is","ObjectIs","ObjectPrototype","prototype","ObjectPrototype__lookupGetter__","__lookupGetter__","object","NativeTypeError","descriptor","undefined","ObjectHasOwn","hasOwn","hasOwnProperty","NativeArray","Array","ArrayIsArray","isArray","ArrayPrototype","ArrayPrototypeJoin","join","ArrayPrototypePush","push","ArrayPrototypeToLocaleString","toLocaleString","NativeArrayPrototypeSymbolIterator","ArrayPrototypeSymbolIterator","MathTrunc","Math","trunc","NativeArrayBuffer","ArrayBuffer","ArrayBufferIsView","isView","ArrayBufferPrototype","ArrayBufferPrototypeSlice","slice","ArrayBufferPrototypeGetByteLength","NativeSharedArrayBuffer","SharedArrayBuffer","SharedArrayBufferPrototypeGetByteLength","TypedArray","Uint8Array","TypedArrayFrom","from","TypedArrayPrototype","NativeTypedArrayPrototypeSymbolIterator","TypedArrayPrototypeKeys","keys","TypedArrayPrototypeValues","values","TypedArrayPrototypeEntries","entries","TypedArrayPrototypeSet","TypedArrayPrototypeReverse","reverse","TypedArrayPrototypeFill","fill","TypedArrayPrototypeCopyWithin","copyWithin","TypedArrayPrototypeSort","sort","TypedArrayPrototypeSlice","TypedArrayPrototypeSubarray","subarray","TypedArrayPrototypeGetBuffer","TypedArrayPrototypeGetByteOffset","TypedArrayPrototypeGetLength","TypedArrayPrototypeGetSymbolToStringTag","NativeUint16Array","Uint16Array","Uint16ArrayFrom","NativeUint32Array","Uint32Array","NativeFloat32Array","Float32Array","ArrayIteratorPrototype","ArrayIteratorPrototypeNext","next","GeneratorPrototypeNext","IteratorPrototype","DataViewPrototype","DataView","DataViewPrototypeGetUint16","getUint16","DataViewPrototypeSetUint16","setUint16","TypeError","NativeRangeError","RangeError","NativeWeakSet","WeakSet","WeakSetPrototype","WeakSetPrototypeAdd","add","WeakSetPrototypeHas","NativeWeakMap","WeakMap","WeakMapPrototype","WeakMapPrototypeGet","WeakMapPrototypeHas","WeakMapPrototypeSet","arrayIterators","SafeIteratorPrototype","value","arrayIterator","safeIfNeeded","array","safe","generators","DummyArrayIteratorPrototype","generator","writable","configurable","wrap","dummy","isObject","isObjectLike","isNativeTypedArray","isNativeBigIntTypedArray","typedArrayName","isArrayBuffer","e","isSharedArrayBuffer","isOrdinaryArray","isOrdinaryNativeTypedArray","isCanonicalIntegerIndexString","number","brand","hasFloat16ArrayBrand","constructor","buffer","floatView","uint32View","baseTable","shiftTable","i","roundToFloat16Bits","num","f","mantissaTable","exponentTable","offsetTable","m","convertToNumber","float16bits","ToIntegerOrInfinity","ToLength","length","SpeciesConstructor","defaultConstructor","IsDetachedBuffer","defaultCompare","x","y","isXNaN","isYNaN","isXPlusZero","isYPlusZero","BYTES_PER_ELEMENT","float16bitsArrays","isFloat16Array","assertFloat16Array","assertSpeciesTypedArray","count","isTargetFloat16Array","isTargetTypedArray","float16bitsArray","getFloat16BitsArray","float16","cloned","Float16Array","byteOffset","copyToArray","TypedArrayPrototypeGetters","handler","receiver","input","_byteOffset","_length","new","list","BufferConstructor","data","arguments","proxy","src","opts","Constructor","uint16","mapFunc","val","of","items","at","index","relativeIndex","k","map","callback","filter","kept","reduce","accumulator","start","reduceRight","forEach","find","findIndex","findLast","findLastIndex","every","some","targetOffset","targetLength","srcLength","Infinity","compareFn","sortCompare","end","relativeStart","relativeEnd","final","n","begin","uint16Subarray","indexOf","element","lastIndexOf","includes","separator","Float16ArrayPrototype","isTypedArray","getFloat16","dataView","setFloat16","hfround","x16"],"sources":["../../../../src/external/petamoriken/float16/float16.js"],"sourcesContent":["/*! @petamoriken/float16 v3.6.6 | MIT License - https://github.com/petamoriken/float16 */\n\nconst THIS_IS_NOT_AN_OBJECT = \"This is not an object\";\nconst THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = \"This is not a Float16Array object\";\nconst THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY =\n \"This constructor is not a subclass of Float16Array\";\nconst THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT =\n \"The constructor property value is not an object\";\nconst SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT =\n \"Species constructor didn't return TypedArray object\";\nconst DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH =\n \"Derived constructor created TypedArray object which was too small length\";\nconst ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER =\n \"Attempting to access detached ArrayBuffer\";\nconst CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT =\n \"Cannot convert undefined or null to object\";\nconst CANNOT_MIX_BIGINT_AND_OTHER_TYPES =\n \"Cannot mix BigInt and other types, use explicit conversions\";\nconst ITERATOR_PROPERTY_IS_NOT_CALLABLE = \"@@iterator property is not callable\";\nconst REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE =\n \"Reduce of empty array with no initial value\";\nconst OFFSET_IS_OUT_OF_BOUNDS = \"Offset is out of bounds\";\n\nfunction uncurryThis(target) {\n return (thisArg, ...args) => {\n return ReflectApply(target, thisArg, args);\n };\n}\nfunction uncurryThisGetter(target, key) {\n return uncurryThis(\n ReflectGetOwnPropertyDescriptor(\n target,\n key\n ).get\n );\n}\nconst {\n apply: ReflectApply,\n construct: ReflectConstruct,\n defineProperty: ReflectDefineProperty,\n get: ReflectGet,\n getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,\n getPrototypeOf: ReflectGetPrototypeOf,\n has: ReflectHas,\n ownKeys: ReflectOwnKeys,\n set: ReflectSet,\n setPrototypeOf: ReflectSetPrototypeOf,\n} = Reflect;\nconst NativeProxy = Proxy;\nconst {\n MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,\n isFinite: NumberIsFinite,\n isNaN: NumberIsNaN,\n} = Number;\nconst {\n iterator: SymbolIterator,\n species: SymbolSpecies,\n toStringTag: SymbolToStringTag,\n for: SymbolFor,\n} = Symbol;\nconst NativeObject = Object;\nconst {\n create: ObjectCreate,\n defineProperty: ObjectDefineProperty,\n freeze: ObjectFreeze,\n is: ObjectIs,\n} = NativeObject;\nconst ObjectPrototype = NativeObject.prototype;\nconst ObjectPrototype__lookupGetter__ = (ObjectPrototype).__lookupGetter__\n ? uncurryThis( (ObjectPrototype).__lookupGetter__)\n : (object, key) => {\n if (object == null) {\n throw NativeTypeError(\n CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n );\n }\n let target = NativeObject(object);\n do {\n const descriptor = ReflectGetOwnPropertyDescriptor(target, key);\n if (descriptor !== undefined) {\n if (ObjectHasOwn(descriptor, \"get\")) {\n return descriptor.get;\n }\n return;\n }\n } while ((target = ReflectGetPrototypeOf(target)) !== null);\n };\nconst ObjectHasOwn = (NativeObject).hasOwn ||\n uncurryThis(ObjectPrototype.hasOwnProperty);\nconst NativeArray = Array;\nconst ArrayIsArray = NativeArray.isArray;\nconst ArrayPrototype = NativeArray.prototype;\nconst ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);\nconst ArrayPrototypePush = uncurryThis(ArrayPrototype.push);\nconst ArrayPrototypeToLocaleString = uncurryThis(\n ArrayPrototype.toLocaleString\n);\nconst NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];\nconst ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);\nconst MathTrunc = Math.trunc;\nconst NativeArrayBuffer = ArrayBuffer;\nconst ArrayBufferIsView = NativeArrayBuffer.isView;\nconst ArrayBufferPrototype = NativeArrayBuffer.prototype;\nconst ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);\nconst ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, \"byteLength\");\nconst NativeSharedArrayBuffer = typeof SharedArrayBuffer !== \"undefined\" ? SharedArrayBuffer : null;\nconst SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer\n && uncurryThisGetter(NativeSharedArrayBuffer.prototype, \"byteLength\");\nconst TypedArray = ReflectGetPrototypeOf(Uint8Array);\nconst TypedArrayFrom = TypedArray.from;\nconst TypedArrayPrototype = TypedArray.prototype;\nconst NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];\nconst TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);\nconst TypedArrayPrototypeValues = uncurryThis(\n TypedArrayPrototype.values\n);\nconst TypedArrayPrototypeEntries = uncurryThis(\n TypedArrayPrototype.entries\n);\nconst TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);\nconst TypedArrayPrototypeReverse = uncurryThis(\n TypedArrayPrototype.reverse\n);\nconst TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);\nconst TypedArrayPrototypeCopyWithin = uncurryThis(\n TypedArrayPrototype.copyWithin\n);\nconst TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);\nconst TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);\nconst TypedArrayPrototypeSubarray = uncurryThis(\n TypedArrayPrototype.subarray\n);\nconst TypedArrayPrototypeGetBuffer = uncurryThisGetter(\n TypedArrayPrototype,\n \"buffer\"\n);\nconst TypedArrayPrototypeGetByteOffset = uncurryThisGetter(\n TypedArrayPrototype,\n \"byteOffset\"\n);\nconst TypedArrayPrototypeGetLength = uncurryThisGetter(\n TypedArrayPrototype,\n \"length\"\n);\nconst TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(\n TypedArrayPrototype,\n SymbolToStringTag\n);\nconst NativeUint16Array = Uint16Array;\nconst Uint16ArrayFrom = (...args) => {\n return ReflectApply(TypedArrayFrom, NativeUint16Array, args);\n};\nconst NativeUint32Array = Uint32Array;\nconst NativeFloat32Array = Float32Array;\nconst ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());\nconst ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);\nconst GeneratorPrototypeNext = uncurryThis((function* () {})().next);\nconst IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);\nconst DataViewPrototype = DataView.prototype;\nconst DataViewPrototypeGetUint16 = uncurryThis(\n DataViewPrototype.getUint16\n);\nconst DataViewPrototypeSetUint16 = uncurryThis(\n DataViewPrototype.setUint16\n);\nconst NativeTypeError = TypeError;\nconst NativeRangeError = RangeError;\nconst NativeWeakSet = WeakSet;\nconst WeakSetPrototype = NativeWeakSet.prototype;\nconst WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);\nconst WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);\nconst NativeWeakMap = WeakMap;\nconst WeakMapPrototype = NativeWeakMap.prototype;\nconst WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);\nconst WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);\nconst WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);\n\nconst arrayIterators = new NativeWeakMap();\nconst SafeIteratorPrototype = ObjectCreate(null, {\n next: {\n value: function next() {\n const arrayIterator = WeakMapPrototypeGet(arrayIterators, this);\n return ArrayIteratorPrototypeNext(arrayIterator);\n },\n },\n [SymbolIterator]: {\n value: function values() {\n return this;\n },\n },\n});\nfunction safeIfNeeded(array) {\n if (array[SymbolIterator] === NativeArrayPrototypeSymbolIterator) {\n return array;\n }\n const safe = ObjectCreate(SafeIteratorPrototype);\n WeakMapPrototypeSet(arrayIterators, safe, ArrayPrototypeSymbolIterator(array));\n return safe;\n}\nconst generators = new NativeWeakMap();\nconst DummyArrayIteratorPrototype = ObjectCreate(IteratorPrototype, {\n next: {\n value: function next() {\n const generator = WeakMapPrototypeGet(generators, this);\n return GeneratorPrototypeNext(generator);\n },\n writable: true,\n configurable: true,\n },\n});\nfor (const key of ReflectOwnKeys(ArrayIteratorPrototype)) {\n if (key === \"next\") {\n continue;\n }\n ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key));\n}\nfunction wrap(generator) {\n const dummy = ObjectCreate(DummyArrayIteratorPrototype);\n WeakMapPrototypeSet(generators, dummy, generator);\n return dummy;\n}\n\nfunction isObject(value) {\n return (value !== null && typeof value === \"object\") ||\n typeof value === \"function\";\n}\nfunction isObjectLike(value) {\n return value !== null && typeof value === \"object\";\n}\nfunction isNativeTypedArray(value) {\n return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined;\n}\nfunction isNativeBigIntTypedArray(value) {\n const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value);\n return typedArrayName === \"BigInt64Array\" ||\n typedArrayName === \"BigUint64Array\";\n}\nfunction isArrayBuffer(value) {\n try {\n ArrayBufferPrototypeGetByteLength( (value));\n return true;\n } catch (e) {\n return false;\n }\n}\nfunction isSharedArrayBuffer(value) {\n if (NativeSharedArrayBuffer === null) {\n return false;\n }\n try {\n SharedArrayBufferPrototypeGetByteLength( (value));\n return true;\n } catch (e) {\n return false;\n }\n}\nfunction isOrdinaryArray(value) {\n if (!ArrayIsArray(value)) {\n return false;\n }\n if (value[SymbolIterator] === NativeArrayPrototypeSymbolIterator) {\n return true;\n }\n const iterator = value[SymbolIterator]();\n return iterator[SymbolToStringTag] === \"Array Iterator\";\n}\nfunction isOrdinaryNativeTypedArray(value) {\n if (!isNativeTypedArray(value)) {\n return false;\n }\n if (value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator) {\n return true;\n }\n const iterator = value[SymbolIterator]();\n return iterator[SymbolToStringTag] === \"Array Iterator\";\n}\nfunction isCanonicalIntegerIndexString(value) {\n if (typeof value !== \"string\") {\n return false;\n }\n const number = +value;\n if (value !== number + \"\") {\n return false;\n }\n if (!NumberIsFinite(number)) {\n return false;\n }\n return number === MathTrunc(number);\n}\n\nconst brand = SymbolFor(\"__Float16Array__\");\nfunction hasFloat16ArrayBrand(target) {\n if (!isObjectLike(target)) {\n return false;\n }\n const prototype = ReflectGetPrototypeOf(target);\n if (!isObjectLike(prototype)) {\n return false;\n }\n const constructor = prototype.constructor;\n if (constructor === undefined) {\n return false;\n }\n if (!isObject(constructor)) {\n throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);\n }\n return ReflectHas(constructor, brand);\n}\n\nconst buffer = new NativeArrayBuffer(4);\nconst floatView = new NativeFloat32Array(buffer);\nconst uint32View = new NativeUint32Array(buffer);\nconst baseTable = new NativeUint32Array(512);\nconst shiftTable = new NativeUint32Array(512);\nfor (let i = 0; i < 256; ++i) {\n const e = i - 127;\n if (e < -27) {\n baseTable[i] = 0x0000;\n baseTable[i | 0x100] = 0x8000;\n shiftTable[i] = 24;\n shiftTable[i | 0x100] = 24;\n } else if (e < -14) {\n baseTable[i] = 0x0400 >> (-e - 14);\n baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;\n shiftTable[i] = -e - 1;\n shiftTable[i | 0x100] = -e - 1;\n } else if (e <= 15) {\n baseTable[i] = (e + 15) << 10;\n baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;\n shiftTable[i] = 13;\n shiftTable[i | 0x100] = 13;\n } else if (e < 128) {\n baseTable[i] = 0x7c00;\n baseTable[i | 0x100] = 0xfc00;\n shiftTable[i] = 24;\n shiftTable[i | 0x100] = 24;\n } else {\n baseTable[i] = 0x7c00;\n baseTable[i | 0x100] = 0xfc00;\n shiftTable[i] = 13;\n shiftTable[i | 0x100] = 13;\n }\n}\nfunction roundToFloat16Bits(num) {\n floatView[0] = (num);\n const f = uint32View[0];\n const e = (f >> 23) & 0x1ff;\n return baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);\n}\nconst mantissaTable = new NativeUint32Array(2048);\nconst exponentTable = new NativeUint32Array(64);\nconst offsetTable = new NativeUint32Array(64);\nfor (let i = 1; i < 1024; ++i) {\n let m = i << 13;\n let e = 0;\n while((m & 0x00800000) === 0) {\n m <<= 1;\n e -= 0x00800000;\n }\n m &= ~0x00800000;\n e += 0x38800000;\n mantissaTable[i] = m | e;\n}\nfor (let i = 1024; i < 2048; ++i) {\n mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);\n}\nfor (let i = 1; i < 31; ++i) {\n exponentTable[i] = i << 23;\n}\nexponentTable[31] = 0x47800000;\nexponentTable[32] = 0x80000000;\nfor (let i = 33; i < 63; ++i) {\n exponentTable[i] = 0x80000000 + ((i - 32) << 23);\n}\nexponentTable[63] = 0xc7800000;\nfor (let i = 1; i < 64; ++i) {\n if (i !== 32) {\n offsetTable[i] = 1024;\n }\n}\nfunction convertToNumber(float16bits) {\n const m = float16bits >> 10;\n uint32View[0] = mantissaTable[offsetTable[m] + (float16bits & 0x3ff)] + exponentTable[m];\n return floatView[0];\n}\n\nfunction ToIntegerOrInfinity(target) {\n const number = +target;\n if (NumberIsNaN(number) || number === 0) {\n return 0;\n }\n return MathTrunc(number);\n}\nfunction ToLength(target) {\n const length = ToIntegerOrInfinity(target);\n if (length < 0) {\n return 0;\n }\n return length < MAX_SAFE_INTEGER\n ? length\n : MAX_SAFE_INTEGER;\n}\nfunction SpeciesConstructor(target, defaultConstructor) {\n if (!isObject(target)) {\n throw NativeTypeError(THIS_IS_NOT_AN_OBJECT);\n }\n const constructor = target.constructor;\n if (constructor === undefined) {\n return defaultConstructor;\n }\n if (!isObject(constructor)) {\n throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);\n }\n const species = constructor[SymbolSpecies];\n if (species == null) {\n return defaultConstructor;\n }\n return species;\n}\nfunction IsDetachedBuffer(buffer) {\n if (isSharedArrayBuffer(buffer)) {\n return false;\n }\n try {\n ArrayBufferPrototypeSlice(buffer, 0, 0);\n return false;\n } catch (e) {}\n return true;\n}\nfunction defaultCompare(x, y) {\n const isXNaN = NumberIsNaN(x);\n const isYNaN = NumberIsNaN(y);\n if (isXNaN && isYNaN) {\n return 0;\n }\n if (isXNaN) {\n return 1;\n }\n if (isYNaN) {\n return -1;\n }\n if (x < y) {\n return -1;\n }\n if (x > y) {\n return 1;\n }\n if (x === 0 && y === 0) {\n const isXPlusZero = ObjectIs(x, 0);\n const isYPlusZero = ObjectIs(y, 0);\n if (!isXPlusZero && isYPlusZero) {\n return -1;\n }\n if (isXPlusZero && !isYPlusZero) {\n return 1;\n }\n }\n return 0;\n}\n\nconst BYTES_PER_ELEMENT = 2;\nconst float16bitsArrays = new NativeWeakMap();\nfunction isFloat16Array(target) {\n return WeakMapPrototypeHas(float16bitsArrays, target) ||\n (!ArrayBufferIsView(target) && hasFloat16ArrayBrand(target));\n}\nfunction assertFloat16Array(target) {\n if (!isFloat16Array(target)) {\n throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT);\n }\n}\nfunction assertSpeciesTypedArray(target, count) {\n const isTargetFloat16Array = isFloat16Array(target);\n const isTargetTypedArray = isNativeTypedArray(target);\n if (!isTargetFloat16Array && !isTargetTypedArray) {\n throw NativeTypeError(SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT);\n }\n if (typeof count === \"number\") {\n let length;\n if (isTargetFloat16Array) {\n const float16bitsArray = getFloat16BitsArray(target);\n length = TypedArrayPrototypeGetLength(float16bitsArray);\n } else {\n length = TypedArrayPrototypeGetLength(target);\n }\n if (length < count) {\n throw NativeTypeError(\n DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH\n );\n }\n }\n if (isNativeBigIntTypedArray(target)) {\n throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);\n }\n}\nfunction getFloat16BitsArray(float16) {\n const float16bitsArray = WeakMapPrototypeGet(float16bitsArrays, float16);\n if (float16bitsArray !== undefined) {\n const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);\n if (IsDetachedBuffer(buffer)) {\n throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n }\n return float16bitsArray;\n }\n const buffer = (float16).buffer;\n if (IsDetachedBuffer(buffer)) {\n throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n }\n const cloned = ReflectConstruct(Float16Array, [\n buffer,\n (float16).byteOffset,\n (float16).length,\n ], float16.constructor);\n return WeakMapPrototypeGet(float16bitsArrays, cloned);\n}\nfunction copyToArray(float16bitsArray) {\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const array = [];\n for (let i = 0; i < length; ++i) {\n array[i] = convertToNumber(float16bitsArray[i]);\n }\n return array;\n}\nconst TypedArrayPrototypeGetters = new NativeWeakSet();\nfor (const key of ReflectOwnKeys(TypedArrayPrototype)) {\n if (key === SymbolToStringTag) {\n continue;\n }\n const descriptor = ReflectGetOwnPropertyDescriptor(TypedArrayPrototype, key);\n if (ObjectHasOwn(descriptor, \"get\") && typeof descriptor.get === \"function\") {\n WeakSetPrototypeAdd(TypedArrayPrototypeGetters, descriptor.get);\n }\n}\nconst handler = ObjectFreeze( ({\n get(target, key, receiver) {\n if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n return convertToNumber(ReflectGet(target, key));\n }\n if (WeakSetPrototypeHas(TypedArrayPrototypeGetters, ObjectPrototype__lookupGetter__(target, key))) {\n return ReflectGet(target, key);\n }\n return ReflectGet(target, key, receiver);\n },\n set(target, key, value, receiver) {\n if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n return ReflectSet(target, key, roundToFloat16Bits(value));\n }\n return ReflectSet(target, key, value, receiver);\n },\n getOwnPropertyDescriptor(target, key) {\n if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n const descriptor = ReflectGetOwnPropertyDescriptor(target, key);\n descriptor.value = convertToNumber(descriptor.value);\n return descriptor;\n }\n return ReflectGetOwnPropertyDescriptor(target, key);\n },\n defineProperty(target, key, descriptor) {\n if (\n isCanonicalIntegerIndexString(key) &&\n ObjectHasOwn(target, key) &&\n ObjectHasOwn(descriptor, \"value\")\n ) {\n descriptor.value = roundToFloat16Bits(descriptor.value);\n return ReflectDefineProperty(target, key, descriptor);\n }\n return ReflectDefineProperty(target, key, descriptor);\n },\n}));\nclass Float16Array {\n constructor(input, _byteOffset, _length) {\n let float16bitsArray;\n if (isFloat16Array(input)) {\n float16bitsArray = ReflectConstruct(NativeUint16Array, [getFloat16BitsArray(input)], new.target);\n } else if (isObject(input) && !isArrayBuffer(input)) {\n let list;\n let length;\n if (isNativeTypedArray(input)) {\n list = input;\n length = TypedArrayPrototypeGetLength(input);\n const buffer = TypedArrayPrototypeGetBuffer(input);\n const BufferConstructor = !isSharedArrayBuffer(buffer)\n ? (SpeciesConstructor(\n buffer,\n NativeArrayBuffer\n ))\n : NativeArrayBuffer;\n if (IsDetachedBuffer(buffer)) {\n throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n }\n if (isNativeBigIntTypedArray(input)) {\n throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);\n }\n const data = new BufferConstructor(\n length * BYTES_PER_ELEMENT\n );\n float16bitsArray = ReflectConstruct(NativeUint16Array, [data], new.target);\n } else {\n const iterator = input[SymbolIterator];\n if (iterator != null && typeof iterator !== \"function\") {\n throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);\n }\n if (iterator != null) {\n if (isOrdinaryArray(input)) {\n list = input;\n length = input.length;\n } else {\n list = [... (input)];\n length = list.length;\n }\n } else {\n list = (input);\n length = ToLength(list.length);\n }\n float16bitsArray = ReflectConstruct(NativeUint16Array, [length], new.target);\n }\n for (let i = 0; i < length; ++i) {\n float16bitsArray[i] = roundToFloat16Bits(list[i]);\n }\n } else {\n float16bitsArray = ReflectConstruct(NativeUint16Array, arguments, new.target);\n }\n const proxy = (new NativeProxy(float16bitsArray, handler));\n WeakMapPrototypeSet(float16bitsArrays, proxy, float16bitsArray);\n return proxy;\n }\n static from(src, ...opts) {\n const Constructor = this;\n if (!ReflectHas(Constructor, brand)) {\n throw NativeTypeError(\n THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY\n );\n }\n if (Constructor === Float16Array) {\n if (isFloat16Array(src) && opts.length === 0) {\n const float16bitsArray = getFloat16BitsArray(src);\n const uint16 = new NativeUint16Array(\n TypedArrayPrototypeGetBuffer(float16bitsArray),\n TypedArrayPrototypeGetByteOffset(float16bitsArray),\n TypedArrayPrototypeGetLength(float16bitsArray)\n );\n return new Float16Array(\n TypedArrayPrototypeGetBuffer(TypedArrayPrototypeSlice(uint16))\n );\n }\n if (opts.length === 0) {\n return new Float16Array(\n TypedArrayPrototypeGetBuffer(\n Uint16ArrayFrom(src, roundToFloat16Bits)\n )\n );\n }\n const mapFunc = opts[0];\n const thisArg = opts[1];\n return new Float16Array(\n TypedArrayPrototypeGetBuffer(\n Uint16ArrayFrom(src, function (val, ...args) {\n return roundToFloat16Bits(\n ReflectApply(mapFunc, this, [val, ...safeIfNeeded(args)])\n );\n }, thisArg)\n )\n );\n }\n let list;\n let length;\n const iterator = src[SymbolIterator];\n if (iterator != null && typeof iterator !== \"function\") {\n throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);\n }\n if (iterator != null) {\n if (isOrdinaryArray(src)) {\n list = src;\n length = src.length;\n } else if (isOrdinaryNativeTypedArray(src)) {\n list = src;\n length = TypedArrayPrototypeGetLength(src);\n } else {\n list = [...src];\n length = list.length;\n }\n } else {\n if (src == null) {\n throw NativeTypeError(\n CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n );\n }\n list = NativeObject(src);\n length = ToLength(list.length);\n }\n const array = new Constructor(length);\n if (opts.length === 0) {\n for (let i = 0; i < length; ++i) {\n array[i] = (list[i]);\n }\n } else {\n const mapFunc = opts[0];\n const thisArg = opts[1];\n for (let i = 0; i < length; ++i) {\n array[i] = ReflectApply(mapFunc, thisArg, [list[i], i]);\n }\n }\n return array;\n }\n static of(...items) {\n const Constructor = this;\n if (!ReflectHas(Constructor, brand)) {\n throw NativeTypeError(\n THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY\n );\n }\n const length = items.length;\n if (Constructor === Float16Array) {\n const proxy = new Float16Array(length);\n const float16bitsArray = getFloat16BitsArray(proxy);\n for (let i = 0; i < length; ++i) {\n float16bitsArray[i] = roundToFloat16Bits(items[i]);\n }\n return proxy;\n }\n const array = new Constructor(length);\n for (let i = 0; i < length; ++i) {\n array[i] = items[i];\n }\n return array;\n }\n keys() {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n return TypedArrayPrototypeKeys(float16bitsArray);\n }\n values() {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n return wrap((function* () {\n for (const val of TypedArrayPrototypeValues(float16bitsArray)) {\n yield convertToNumber(val);\n }\n })());\n }\n entries() {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n return wrap((function* () {\n for (const [i, val] of TypedArrayPrototypeEntries(float16bitsArray)) {\n yield ([i, convertToNumber(val)]);\n }\n })());\n }\n at(index) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const relativeIndex = ToIntegerOrInfinity(index);\n const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;\n if (k < 0 || k >= length) {\n return;\n }\n return convertToNumber(float16bitsArray[k]);\n }\n map(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n if (Constructor === Float16Array) {\n const proxy = new Float16Array(length);\n const array = getFloat16BitsArray(proxy);\n for (let i = 0; i < length; ++i) {\n const val = convertToNumber(float16bitsArray[i]);\n array[i] = roundToFloat16Bits(\n ReflectApply(callback, thisArg, [val, i, this])\n );\n }\n return proxy;\n }\n const array = new Constructor(length);\n assertSpeciesTypedArray(array, length);\n for (let i = 0; i < length; ++i) {\n const val = convertToNumber(float16bitsArray[i]);\n array[i] = ReflectApply(callback, thisArg, [val, i, this]);\n }\n return (array);\n }\n filter(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n const kept = [];\n for (let i = 0; i < length; ++i) {\n const val = convertToNumber(float16bitsArray[i]);\n if (ReflectApply(callback, thisArg, [val, i, this])) {\n ArrayPrototypePush(kept, val);\n }\n }\n const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n const array = new Constructor(kept);\n assertSpeciesTypedArray(array);\n return (array);\n }\n reduce(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n if (length === 0 && opts.length === 0) {\n throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);\n }\n let accumulator, start;\n if (opts.length === 0) {\n accumulator = convertToNumber(float16bitsArray[0]);\n start = 1;\n } else {\n accumulator = opts[0];\n start = 0;\n }\n for (let i = start; i < length; ++i) {\n accumulator = callback(\n accumulator,\n convertToNumber(float16bitsArray[i]),\n i,\n this\n );\n }\n return accumulator;\n }\n reduceRight(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n if (length === 0 && opts.length === 0) {\n throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);\n }\n let accumulator, start;\n if (opts.length === 0) {\n accumulator = convertToNumber(float16bitsArray[length - 1]);\n start = length - 2;\n } else {\n accumulator = opts[0];\n start = length - 1;\n }\n for (let i = start; i >= 0; --i) {\n accumulator = callback(\n accumulator,\n convertToNumber(float16bitsArray[i]),\n i,\n this\n );\n }\n return accumulator;\n }\n forEach(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = 0; i < length; ++i) {\n ReflectApply(callback, thisArg, [\n convertToNumber(float16bitsArray[i]),\n i,\n this,\n ]);\n }\n }\n find(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = 0; i < length; ++i) {\n const value = convertToNumber(float16bitsArray[i]);\n if (ReflectApply(callback, thisArg, [value, i, this])) {\n return value;\n }\n }\n }\n findIndex(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = 0; i < length; ++i) {\n const value = convertToNumber(float16bitsArray[i]);\n if (ReflectApply(callback, thisArg, [value, i, this])) {\n return i;\n }\n }\n return -1;\n }\n findLast(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = length - 1; i >= 0; --i) {\n const value = convertToNumber(float16bitsArray[i]);\n if (ReflectApply(callback, thisArg, [value, i, this])) {\n return value;\n }\n }\n }\n findLastIndex(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = length - 1; i >= 0; --i) {\n const value = convertToNumber(float16bitsArray[i]);\n if (ReflectApply(callback, thisArg, [value, i, this])) {\n return i;\n }\n }\n return -1;\n }\n every(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = 0; i < length; ++i) {\n if (\n !ReflectApply(callback, thisArg, [\n convertToNumber(float16bitsArray[i]),\n i,\n this,\n ])\n ) {\n return false;\n }\n }\n return true;\n }\n some(callback, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const thisArg = opts[0];\n for (let i = 0; i < length; ++i) {\n if (\n ReflectApply(callback, thisArg, [\n convertToNumber(float16bitsArray[i]),\n i,\n this,\n ])\n ) {\n return true;\n }\n }\n return false;\n }\n set(input, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const targetOffset = ToIntegerOrInfinity(opts[0]);\n if (targetOffset < 0) {\n throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n }\n if (input == null) {\n throw NativeTypeError(\n CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n );\n }\n if (isNativeBigIntTypedArray(input)) {\n throw NativeTypeError(\n CANNOT_MIX_BIGINT_AND_OTHER_TYPES\n );\n }\n if (isFloat16Array(input)) {\n return TypedArrayPrototypeSet(\n getFloat16BitsArray(this),\n getFloat16BitsArray(input),\n targetOffset\n );\n }\n if (isNativeTypedArray(input)) {\n const buffer = TypedArrayPrototypeGetBuffer(input);\n if (IsDetachedBuffer(buffer)) {\n throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n }\n }\n const targetLength = TypedArrayPrototypeGetLength(float16bitsArray);\n const src = NativeObject(input);\n const srcLength = ToLength(src.length);\n if (targetOffset === Infinity || srcLength + targetOffset > targetLength) {\n throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n }\n for (let i = 0; i < srcLength; ++i) {\n float16bitsArray[i + targetOffset] = roundToFloat16Bits(src[i]);\n }\n }\n reverse() {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n TypedArrayPrototypeReverse(float16bitsArray);\n return this;\n }\n fill(value, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n TypedArrayPrototypeFill(\n float16bitsArray,\n roundToFloat16Bits(value),\n ...safeIfNeeded(opts)\n );\n return this;\n }\n copyWithin(target, start, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n TypedArrayPrototypeCopyWithin(float16bitsArray, target, start, ...safeIfNeeded(opts));\n return this;\n }\n sort(compareFn) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;\n TypedArrayPrototypeSort(float16bitsArray, (x, y) => {\n return sortCompare(convertToNumber(x), convertToNumber(y));\n });\n return this;\n }\n slice(start, end) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n if (Constructor === Float16Array) {\n const uint16 = new NativeUint16Array(\n TypedArrayPrototypeGetBuffer(float16bitsArray),\n TypedArrayPrototypeGetByteOffset(float16bitsArray),\n TypedArrayPrototypeGetLength(float16bitsArray)\n );\n return new Float16Array(\n TypedArrayPrototypeGetBuffer(\n TypedArrayPrototypeSlice(uint16, start, end)\n )\n );\n }\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n const relativeStart = ToIntegerOrInfinity(start);\n const relativeEnd = end === undefined ? length : ToIntegerOrInfinity(end);\n let k;\n if (relativeStart === -Infinity) {\n k = 0;\n } else if (relativeStart < 0) {\n k = length + relativeStart > 0 ? length + relativeStart : 0;\n } else {\n k = length < relativeStart ? length : relativeStart;\n }\n let final;\n if (relativeEnd === -Infinity) {\n final = 0;\n } else if (relativeEnd < 0) {\n final = length + relativeEnd > 0 ? length + relativeEnd : 0;\n } else {\n final = length < relativeEnd ? length : relativeEnd;\n }\n const count = final - k > 0 ? final - k : 0;\n const array = new Constructor(count);\n assertSpeciesTypedArray(array, count);\n if (count === 0) {\n return array;\n }\n const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);\n if (IsDetachedBuffer(buffer)) {\n throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n }\n let n = 0;\n while (k < final) {\n array[n] = convertToNumber(float16bitsArray[k]);\n ++k;\n ++n;\n }\n return (array);\n }\n subarray(begin, end) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n const uint16 = new NativeUint16Array(\n TypedArrayPrototypeGetBuffer(float16bitsArray),\n TypedArrayPrototypeGetByteOffset(float16bitsArray),\n TypedArrayPrototypeGetLength(float16bitsArray)\n );\n const uint16Subarray = TypedArrayPrototypeSubarray(uint16, begin, end);\n const array = new Constructor(\n TypedArrayPrototypeGetBuffer(uint16Subarray),\n TypedArrayPrototypeGetByteOffset(uint16Subarray),\n TypedArrayPrototypeGetLength(uint16Subarray)\n );\n assertSpeciesTypedArray(array);\n return (array);\n }\n indexOf(element, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n let from = ToIntegerOrInfinity(opts[0]);\n if (from === Infinity) {\n return -1;\n }\n if (from < 0) {\n from += length;\n if (from < 0) {\n from = 0;\n }\n }\n for (let i = from; i < length; ++i) {\n if (\n ObjectHasOwn(float16bitsArray, i) &&\n convertToNumber(float16bitsArray[i]) === element\n ) {\n return i;\n }\n }\n return -1;\n }\n lastIndexOf(element, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n let from = opts.length >= 1 ? ToIntegerOrInfinity(opts[0]) : length - 1;\n if (from === -Infinity) {\n return -1;\n }\n if (from >= 0) {\n from = from < length - 1 ? from : length - 1;\n } else {\n from += length;\n }\n for (let i = from; i >= 0; --i) {\n if (\n ObjectHasOwn(float16bitsArray, i) &&\n convertToNumber(float16bitsArray[i]) === element\n ) {\n return i;\n }\n }\n return -1;\n }\n includes(element, ...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const length = TypedArrayPrototypeGetLength(float16bitsArray);\n let from = ToIntegerOrInfinity(opts[0]);\n if (from === Infinity) {\n return false;\n }\n if (from < 0) {\n from += length;\n if (from < 0) {\n from = 0;\n }\n }\n const isNaN = NumberIsNaN(element);\n for (let i = from; i < length; ++i) {\n const value = convertToNumber(float16bitsArray[i]);\n if (isNaN && NumberIsNaN(value)) {\n return true;\n }\n if (value === element) {\n return true;\n }\n }\n return false;\n }\n join(separator) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const array = copyToArray(float16bitsArray);\n return ArrayPrototypeJoin(array, separator);\n }\n toLocaleString(...opts) {\n assertFloat16Array(this);\n const float16bitsArray = getFloat16BitsArray(this);\n const array = copyToArray(float16bitsArray);\n return ArrayPrototypeToLocaleString(array, ...safeIfNeeded(opts));\n }\n get [SymbolToStringTag]() {\n if (isFloat16Array(this)) {\n return (\"Float16Array\");\n }\n }\n}\nObjectDefineProperty(Float16Array, \"BYTES_PER_ELEMENT\", {\n value: BYTES_PER_ELEMENT,\n});\nObjectDefineProperty(Float16Array, brand, {});\nReflectSetPrototypeOf(Float16Array, TypedArray);\nconst Float16ArrayPrototype = Float16Array.prototype;\nObjectDefineProperty(Float16ArrayPrototype, \"BYTES_PER_ELEMENT\", {\n value: BYTES_PER_ELEMENT,\n});\nObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, {\n value: Float16ArrayPrototype.values,\n writable: true,\n configurable: true,\n});\nReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype);\n\nfunction isTypedArray(target) {\n return isNativeTypedArray(target) || isFloat16Array(target);\n}\n\nfunction getFloat16(dataView, byteOffset, ...opts) {\n return convertToNumber(\n DataViewPrototypeGetUint16(dataView, byteOffset, ...safeIfNeeded(opts))\n );\n}\nfunction setFloat16(dataView, byteOffset, value, ...opts) {\n return DataViewPrototypeSetUint16(\n dataView,\n byteOffset,\n roundToFloat16Bits(value),\n ...safeIfNeeded(opts)\n );\n}\n\nfunction hfround(x) {\n const number = +x;\n if (!NumberIsFinite(number) || number === 0) {\n return number;\n }\n const x16 = roundToFloat16Bits(number);\n return convertToNumber(x16);\n}\n\nexport { Float16Array, getFloat16, hfround, isFloat16Array, isTypedArray, setFloat16 };\n"],"mappings":"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"}
\ No newline at end of file |