@nubjs/nub-linux-x64 0.0.7 → 0.0.9

package/runtime/node_modules/@petamoriken/float16/browser/float16.js

@@ -0,0 +1,1340 @@
+/*! @petamoriken/float16 v3.9.3 | MIT License - https://github.com/petamoriken/float16 */
+
+var float16 = (function (exports) {
+  'use strict';
+
+  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 < -24) {
+      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 &= -8388609;
+    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);
+  }
+
+  exports.Float16Array = Float16Array;
+  exports.f16round = f16round;
+  exports.getFloat16 = getFloat16;
+  exports.hfround = f16round;
+  exports.isFloat16Array = isFloat16Array;
+  exports.isTypedArray = isTypedArray;
+  exports.setFloat16 = setFloat16;
+
+  Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+  return exports;
+
+})({});