tor-browser

float16.js (42238B)

---

/**
* AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts
**/ /*! @petamoriken/float16 v3.8.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 THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED =
"The comparison function must be either a function or undefined";
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 {
 EPSILON,
 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 {
 abs: MathAbs,
 trunc: MathTrunc
} = Math;
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 NativeUint8Array = Uint8Array;
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 &&
 ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext)
 {
   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 {
   if (ArrayIsArray(value)) {
     return false;
   }
   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 isAnyArrayBuffer(value) {
 return isArrayBuffer(value) || isSharedArrayBuffer(value);
}
function isOrdinaryArray(value) {
 if (!ArrayIsArray(value)) {
   return false;
 }
 return (
   value[SymbolIterator] === NativeArrayPrototypeSymbolIterator &&
   ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext);

}
function isOrdinaryNativeTypedArray(value) {
 if (!isNativeTypedArray(value)) {
   return false;
 }
 return (
   value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator &&
   ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext);

}
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 INVERSE_OF_EPSILON = 1 / EPSILON;
function roundTiesToEven(num) {
 return num + INVERSE_OF_EPSILON - INVERSE_OF_EPSILON;
}
const FLOAT16_MIN_VALUE = 6.103515625e-05;
const FLOAT16_MAX_VALUE = 65504;
const FLOAT16_EPSILON = 0.0009765625;
const FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE = FLOAT16_EPSILON * FLOAT16_MIN_VALUE;
const FLOAT16_EPSILON_DEVIDED_BY_EPSILON = FLOAT16_EPSILON * INVERSE_OF_EPSILON;
function roundToFloat16(num) {
 const number = +num;
 if (!NumberIsFinite(number) || number === 0) {
   return number;
 }
 const sign = number > 0 ? 1 : -1;
 const absolute = MathAbs(number);
 if (absolute < FLOAT16_MIN_VALUE) {
   return sign * roundTiesToEven(absolute / FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE) * FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE;
 }
 const temp = (1 + FLOAT16_EPSILON_DEVIDED_BY_EPSILON) * absolute;
 const result = temp - (temp - absolute);
 if (result > FLOAT16_MAX_VALUE || NumberIsNaN(result)) {
   return sign * Infinity;
 }
 return sign * result;
}
const buffer = new NativeArrayBuffer(4);
const floatView = new NativeFloat32Array(buffer);
const uint32View = new NativeUint32Array(buffer);
const baseTable = new NativeUint16Array(512);
const shiftTable = new NativeUint8Array(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] = roundToFloat16(num);
 const f = uint32View[0];
 const e = f >> 23 & 0x1ff;
 return baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
}
const mantissaTable = new NativeUint32Array(2048);
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);
}
const exponentTable = new NativeUint32Array(64);
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;
const offsetTable = new NativeUint16Array(64);
for (let i = 1; i < 64; ++i) {
 if (i !== 32) {
   offsetTable[i] = 1024;
 }
}
function convertToNumber(float16bits) {
 const i = float16bits >> 10;
 uint32View[0] = mantissaTable[offsetTable[i] + (float16bits & 0x3ff)] + exponentTable[i];
 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) && !isAnyArrayBuffer(input)) {
     let list;
     let length;
     if (isNativeTypedArray(input)) {
       list = input;
       length = TypedArrayPrototypeGetLength(input);
       const buffer = TypedArrayPrototypeGetBuffer(input);
       if (IsDetachedBuffer(buffer)) {
         throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
       }
       if (isNativeBigIntTypedArray(input)) {
         throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);
       }
       const data = new NativeArrayBuffer(
         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]);
 }
 with(index, value) {
   assertFloat16Array(this);
   const float16bitsArray = getFloat16BitsArray(this);
   const length = TypedArrayPrototypeGetLength(float16bitsArray);
   const relativeIndex = ToIntegerOrInfinity(index);
   const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;
   const number = +value;
   if (k < 0 || k >= length) {
     throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);
   }
   const uint16 = new NativeUint16Array(
     TypedArrayPrototypeGetBuffer(float16bitsArray),
     TypedArrayPrototypeGetByteOffset(float16bitsArray),
     TypedArrayPrototypeGetLength(float16bitsArray)
   );
   const cloned = new Float16Array(
     TypedArrayPrototypeGetBuffer(
       TypedArrayPrototypeSlice(uint16)
     )
   );
   const array = getFloat16BitsArray(cloned);
   array[k] = roundToFloat16Bits(number);
   return cloned;
 }
 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;
 }
 toReversed() {
   assertFloat16Array(this);
   const float16bitsArray = getFloat16BitsArray(this);
   const uint16 = new NativeUint16Array(
     TypedArrayPrototypeGetBuffer(float16bitsArray),
     TypedArrayPrototypeGetByteOffset(float16bitsArray),
     TypedArrayPrototypeGetLength(float16bitsArray)
   );
   const cloned = new Float16Array(
     TypedArrayPrototypeGetBuffer(
       TypedArrayPrototypeSlice(uint16)
     )
   );
   const clonedFloat16bitsArray = getFloat16BitsArray(cloned);
   TypedArrayPrototypeReverse(clonedFloat16bitsArray);
   return cloned;
 }
 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;
 }
 toSorted(compareFn) {
   assertFloat16Array(this);
   const float16bitsArray = getFloat16BitsArray(this);
   if (compareFn !== undefined && typeof compareFn !== "function") {
     throw new NativeTypeError(THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED);
   }
   const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;
   const uint16 = new NativeUint16Array(
     TypedArrayPrototypeGetBuffer(float16bitsArray),
     TypedArrayPrototypeGetByteOffset(float16bitsArray),
     TypedArrayPrototypeGetLength(float16bitsArray)
   );
   const cloned = new Float16Array(
     TypedArrayPrototypeGetBuffer(
       TypedArrayPrototypeSlice(uint16)
     )
   );
   const clonedFloat16bitsArray = getFloat16BitsArray(cloned);
   TypedArrayPrototypeSort(clonedFloat16bitsArray, (x, y) => {
     return sortCompare(convertToNumber(x), convertToNumber(y));
   });
   return cloned;
 }
 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 f16round(x) {
 return roundToFloat16(x);
}

export { Float16Array, f16round, getFloat16, f16round as hfround, isFloat16Array, isTypedArray, setFloat16 };