{"version":3,"sources":["jsdelivr-header.js","/npm/@petamoriken/float16@3.6.5/browser/float16.js"],"names":[],"mappings":"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","file":"/npm/@petamoriken/float16@3.6.5/browser/float16.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.13.1.\n * Original file: /npm/@petamoriken/float16@3.6.5/browser/float16.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*! @petamoriken/float16 v3.6.5 | MIT License - https://github.com/petamoriken/float16 */\n\nconst float16 = (function (exports) {\n  'use strict';\n\n  const THIS_IS_NOT_AN_OBJECT = \"This is not an object\";\n  const THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = \"This is not a Float16Array object\";\n  const THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY =\n    \"This constructor is not a subclass of Float16Array\";\n  const THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT =\n    \"The constructor property value is not an object\";\n  const SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT =\n    \"Species constructor didn't return TypedArray object\";\n  const DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH =\n    \"Derived constructor created TypedArray object which was too small length\";\n  const ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER =\n    \"Attempting to access detached ArrayBuffer\";\n  const CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT =\n    \"Cannot convert undefined or null to object\";\n  const CANNOT_CONVERT_A_BIGINT_VALUE_TO_A_NUMBER =\n    \"Cannot convert a BigInt value to a number\";\n  const CANNOT_MIX_BIGINT_AND_OTHER_TYPES =\n    \"Cannot mix BigInt and other types, use explicit conversions\";\n  const ITERATOR_PROPERTY_IS_NOT_CALLABLE = \"@@iterator property is not callable\";\n  const REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE =\n    \"Reduce of empty array with no initial value\";\n  const OFFSET_IS_OUT_OF_BOUNDS = \"Offset is out of bounds\";\n\n  function uncurryThis(target) {\n    return (thisArg, ...args) => {\n      return ReflectApply(target, thisArg, args);\n    };\n  }\n  function uncurryThisGetter(target, key) {\n    return uncurryThis(\n      ReflectGetOwnPropertyDescriptor(\n        target,\n        key\n      ).get\n    );\n  }\n  const {\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;\n  const NativeProxy = Proxy;\n  const NativeNumber = Number;\n  const {\n    isFinite: NumberIsFinite,\n    isNaN: NumberIsNaN,\n  } = NativeNumber;\n  const {\n    iterator: SymbolIterator,\n    species: SymbolSpecies,\n    toStringTag: SymbolToStringTag,\n    for: SymbolFor,\n  } = Symbol;\n  const NativeObject = Object;\n  const {\n    create: ObjectCreate,\n    defineProperty: ObjectDefineProperty,\n    freeze: ObjectFreeze,\n    is: ObjectIs,\n  } = NativeObject;\n  const ObjectPrototype = NativeObject.prototype;\n  const 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    };\n  const ObjectHasOwn =  (NativeObject).hasOwn ||\n    uncurryThis(ObjectPrototype.hasOwnProperty);\n  const NativeArray = Array;\n  const ArrayIsArray = NativeArray.isArray;\n  const ArrayPrototype = NativeArray.prototype;\n  const ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);\n  const ArrayPrototypePush = uncurryThis(ArrayPrototype.push);\n  const ArrayPrototypeToLocaleString = uncurryThis(\n    ArrayPrototype.toLocaleString\n  );\n  const NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];\n  const ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);\n  const MathTrunc = Math.trunc;\n  const NativeArrayBuffer = ArrayBuffer;\n  const ArrayBufferIsView = NativeArrayBuffer.isView;\n  const ArrayBufferPrototype = NativeArrayBuffer.prototype;\n  const ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);\n  const ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, \"byteLength\");\n  const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== \"undefined\" ? SharedArrayBuffer : null;\n  const SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer\n    && uncurryThisGetter(NativeSharedArrayBuffer.prototype, \"byteLength\");\n  const TypedArray = ReflectGetPrototypeOf(Uint8Array);\n  const TypedArrayFrom = TypedArray.from;\n  const TypedArrayPrototype = TypedArray.prototype;\n  const NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];\n  const TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);\n  const TypedArrayPrototypeValues = uncurryThis(\n    TypedArrayPrototype.values\n  );\n  const TypedArrayPrototypeEntries = uncurryThis(\n    TypedArrayPrototype.entries\n  );\n  const TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);\n  const TypedArrayPrototypeReverse = uncurryThis(\n    TypedArrayPrototype.reverse\n  );\n  const TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);\n  const TypedArrayPrototypeCopyWithin = uncurryThis(\n    TypedArrayPrototype.copyWithin\n  );\n  const TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);\n  const TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);\n  const TypedArrayPrototypeSubarray = uncurryThis(\n    TypedArrayPrototype.subarray\n  );\n  const TypedArrayPrototypeGetBuffer = uncurryThisGetter(\n    TypedArrayPrototype,\n    \"buffer\"\n  );\n  const TypedArrayPrototypeGetByteOffset = uncurryThisGetter(\n    TypedArrayPrototype,\n    \"byteOffset\"\n  );\n  const TypedArrayPrototypeGetLength = uncurryThisGetter(\n    TypedArrayPrototype,\n    \"length\"\n  );\n  const TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(\n    TypedArrayPrototype,\n    SymbolToStringTag\n  );\n  const NativeUint16Array = Uint16Array;\n  const Uint16ArrayFrom = (...args) => {\n    return ReflectApply(TypedArrayFrom, NativeUint16Array, args);\n  };\n  const NativeUint32Array = Uint32Array;\n  const NativeFloat32Array = Float32Array;\n  const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());\n  const ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);\n  const GeneratorPrototypeNext = uncurryThis((function* () {})().next);\n  const IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);\n  const DataViewPrototype = DataView.prototype;\n  const DataViewPrototypeGetUint16 = uncurryThis(\n    DataViewPrototype.getUint16\n  );\n  const DataViewPrototypeSetUint16 = uncurryThis(\n    DataViewPrototype.setUint16\n  );\n  const NativeTypeError = TypeError;\n  const NativeRangeError = RangeError;\n  const NativeWeakSet = WeakSet;\n  const WeakSetPrototype = NativeWeakSet.prototype;\n  const WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);\n  const WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);\n  const NativeWeakMap = WeakMap;\n  const WeakMapPrototype = NativeWeakMap.prototype;\n  const WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);\n  const WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);\n  const WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);\n\n  const arrayIterators = new NativeWeakMap();\n  const 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  });\n  function 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  }\n  const generators = new NativeWeakMap();\n  const 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  });\n  for (const key of ReflectOwnKeys(ArrayIteratorPrototype)) {\n    if (key === \"next\") {\n      continue;\n    }\n    ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key));\n  }\n  function wrap(generator) {\n    const dummy = ObjectCreate(DummyArrayIteratorPrototype);\n    WeakMapPrototypeSet(generators, dummy, generator);\n    return dummy;\n  }\n\n  function isObject(value) {\n    return (value !== null && typeof value === \"object\") ||\n      typeof value === \"function\";\n  }\n  function isObjectLike(value) {\n    return value !== null && typeof value === \"object\";\n  }\n  function isNativeTypedArray(value) {\n    return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined;\n  }\n  function isNativeBigIntTypedArray(value) {\n    const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value);\n    return typedArrayName === \"BigInt64Array\" ||\n      typedArrayName === \"BigUint64Array\";\n  }\n  function isArrayBuffer(value) {\n    try {\n      ArrayBufferPrototypeGetByteLength( (value));\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n  function 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  }\n  function 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  }\n  function 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  }\n  function isCanonicalIntegerIndexString(value) {\n    if (typeof value !== \"string\") {\n      return false;\n    }\n    const number = NativeNumber(value);\n    if (value !== number + \"\") {\n      return false;\n    }\n    if (!NumberIsFinite(number)) {\n      return false;\n    }\n    return number === MathTrunc(number);\n  }\n\n  const brand = SymbolFor(\"__Float16Array__\");\n  function 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\n  const buffer = new NativeArrayBuffer(4);\n  const floatView = new NativeFloat32Array(buffer);\n  const uint32View = new NativeUint32Array(buffer);\n  const baseTable = new NativeUint32Array(512);\n  const shiftTable = new NativeUint32Array(512);\n  for (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  }\n  function 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  }\n  const mantissaTable = new NativeUint32Array(2048);\n  const exponentTable = new NativeUint32Array(64);\n  const offsetTable = new NativeUint32Array(64);\n  for (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  }\n  for (let i = 1024; i < 2048; ++i) {\n    mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);\n  }\n  for (let i = 1; i < 31; ++i) {\n    exponentTable[i] = i << 23;\n  }\n  exponentTable[31] = 0x47800000;\n  exponentTable[32] = 0x80000000;\n  for (let i = 33; i < 63; ++i) {\n    exponentTable[i] = 0x80000000 + ((i - 32) << 23);\n  }\n  exponentTable[63] = 0xc7800000;\n  for (let i = 1; i < 64; ++i) {\n    if (i !== 32) {\n      offsetTable[i] = 1024;\n    }\n  }\n  function convertToNumber(float16bits) {\n    const m = float16bits >> 10;\n    uint32View[0] = mantissaTable[offsetTable[m] + (float16bits & 0x3ff)] + exponentTable[m];\n    return floatView[0];\n  }\n\n  const MAX_SAFE_INTEGER = NativeNumber.MAX_SAFE_INTEGER;\n  function ToIntegerOrInfinity(target) {\n    if (typeof target === \"bigint\") {\n      throw NativeTypeError(CANNOT_CONVERT_A_BIGINT_VALUE_TO_A_NUMBER);\n    }\n    const number = NativeNumber(target);\n    if (NumberIsNaN(number) || number === 0) {\n      return 0;\n    }\n    return MathTrunc(number);\n  }\n  function 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  }\n  function 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  }\n  function 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  }\n  function 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\n  const BYTES_PER_ELEMENT = 2;\n  const float16bitsArrays = new NativeWeakMap();\n  function isFloat16Array(target) {\n    return WeakMapPrototypeHas(float16bitsArrays, target) ||\n      (!ArrayBufferIsView(target) && hasFloat16ArrayBrand(target));\n  }\n  function assertFloat16Array(target) {\n    if (!isFloat16Array(target)) {\n      throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT);\n    }\n  }\n  function 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  }\n  function 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  }\n  function 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  }\n  const TypedArrayPrototypeGetters = new NativeWeakSet();\n  for (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  }\n  const 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  }));\n  class 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  }\n  ObjectDefineProperty(Float16Array, \"BYTES_PER_ELEMENT\", {\n    value: BYTES_PER_ELEMENT,\n  });\n  ObjectDefineProperty(Float16Array, brand, {});\n  ReflectSetPrototypeOf(Float16Array, TypedArray);\n  const Float16ArrayPrototype = Float16Array.prototype;\n  ObjectDefineProperty(Float16ArrayPrototype, \"BYTES_PER_ELEMENT\", {\n    value: BYTES_PER_ELEMENT,\n  });\n  ObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, {\n    value: Float16ArrayPrototype.values,\n    writable: true,\n    configurable: true,\n  });\n  ReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype);\n\n  function isTypedArray(target) {\n    return isNativeTypedArray(target) || isFloat16Array(target);\n  }\n\n  function getFloat16(dataView, byteOffset, ...opts) {\n    return convertToNumber(\n      DataViewPrototypeGetUint16(dataView, byteOffset, ...safeIfNeeded(opts))\n    );\n  }\n  function setFloat16(dataView, byteOffset, value, ...opts) {\n    return DataViewPrototypeSetUint16(\n      dataView,\n      byteOffset,\n      roundToFloat16Bits(value),\n      ...safeIfNeeded(opts)\n    );\n  }\n\n  function hfround(num) {\n    if (typeof num === \"bigint\") {\n      throw NativeTypeError(CANNOT_CONVERT_A_BIGINT_VALUE_TO_A_NUMBER);\n    }\n    num = NativeNumber(num);\n    if (!NumberIsFinite(num) || num === 0) {\n      return num;\n    }\n    const x16 = roundToFloat16Bits(num);\n    return convertToNumber(x16);\n  }\n\n  exports.Float16Array = Float16Array;\n  exports.getFloat16 = getFloat16;\n  exports.hfround = hfround;\n  exports.isFloat16Array = isFloat16Array;\n  exports.isTypedArray = isTypedArray;\n  exports.setFloat16 = setFloat16;\n\n  Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });\n\n  return exports;\n\n})({});\n"]}