@nubjs/nub-linux-arm64 0.0.7 → 0.0.8

package/runtime/node_modules/@petamoriken/float16/src/_util/primordials.mjs

@@ -0,0 +1,254 @@
+/* eslint-disable no-restricted-globals, no-restricted-syntax */
+/* global SharedArrayBuffer */
+
+import { CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT } from "./messages.mjs";
+
+/** @type {<T extends (...args: any) => any>(target: T) => (thisArg: ThisType<T>, ...args: any[]) => any} */
+function uncurryThis(target) {
+  return (thisArg, ...args) => {
+    return ReflectApply(target, thisArg, args);
+  };
+}
+
+/** @type {(target: any, key: string | symbol) => (thisArg: any, ...args: any[]) => any} */
+function uncurryThisGetter(target, key) {
+  return uncurryThis(
+    ReflectGetOwnPropertyDescriptor(
+      target,
+      key
+    ).get
+  );
+}
+
+// Reflect
+export const {
+  apply: ReflectApply,
+  construct: ReflectConstruct,
+  defineProperty: ReflectDefineProperty,
+  get: ReflectGet,
+  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
+  getPrototypeOf: ReflectGetPrototypeOf,
+  has: ReflectHas,
+  ownKeys: ReflectOwnKeys,
+  set: ReflectSet,
+  setPrototypeOf: ReflectSetPrototypeOf,
+} = Reflect;
+
+// Proxy
+export const NativeProxy = Proxy;
+
+// Number
+export const {
+  EPSILON,
+  MAX_SAFE_INTEGER,
+  isFinite: NumberIsFinite,
+  isNaN: NumberIsNaN,
+} = Number;
+
+// Symbol
+export const {
+  iterator: SymbolIterator,
+  species: SymbolSpecies,
+  toStringTag: SymbolToStringTag,
+  for: SymbolFor,
+} = Symbol;
+
+// Object
+export const NativeObject = Object;
+export const {
+  create: ObjectCreate,
+  defineProperty: ObjectDefineProperty,
+  freeze: ObjectFreeze,
+  is: ObjectIs,
+} = NativeObject;
+const ObjectPrototype = NativeObject.prototype;
+/** @type {(object: object, key: PropertyKey) => Function | undefined} */
+export const ObjectPrototype__lookupGetter__ = /** @type {any} */ (ObjectPrototype).__lookupGetter__
+  ? uncurryThis(/** @type {any} */ (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);
+  };
+/** @type {(object: object, key: PropertyKey) => boolean} */
+export const ObjectHasOwn = /** @type {any} */ (NativeObject).hasOwn ||
+  uncurryThis(ObjectPrototype.hasOwnProperty);
+
+// Array
+const NativeArray = Array;
+export const ArrayIsArray = NativeArray.isArray;
+const ArrayPrototype = NativeArray.prototype;
+/** @type {(array: ArrayLike<unknown>, separator?: string) => string} */
+export const ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);
+/** @type {<T>(array: T[], ...items: T[]) => number} */
+export const ArrayPrototypePush = uncurryThis(ArrayPrototype.push);
+/** @type {(array: ArrayLike<unknown>, ...opts: any[]) => string} */
+export const ArrayPrototypeToLocaleString = uncurryThis(
+  ArrayPrototype.toLocaleString
+);
+export const NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];
+/** @type {<T>(array: T[]) => IterableIterator<T>} */
+export const ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);
+
+// Math
+export const {
+  abs: MathAbs,
+  trunc: MathTrunc,
+} = Math;
+
+// ArrayBuffer
+export const NativeArrayBuffer = ArrayBuffer;
+export const ArrayBufferIsView = NativeArrayBuffer.isView;
+const ArrayBufferPrototype = NativeArrayBuffer.prototype;
+/** @type {(buffer: ArrayBuffer, begin?: number, end?: number) => number} */
+export const ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);
+/** @type {(buffer: ArrayBuffer) => ArrayBuffer} */
+export const ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, "byteLength");
+
+// SharedArrayBuffer
+export const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : null;
+/** @type {(buffer: SharedArrayBuffer) => SharedArrayBuffer} */
+export const SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer
+  && uncurryThisGetter(NativeSharedArrayBuffer.prototype, "byteLength");
+
+// TypedArray
+/** @typedef {Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array} TypedArray */
+/** @type {any} */
+export const TypedArray = ReflectGetPrototypeOf(Uint8Array);
+const TypedArrayFrom = TypedArray.from;
+export const TypedArrayPrototype = TypedArray.prototype;
+export const NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];
+/** @type {(typedArray: TypedArray) => IterableIterator<number>} */
+export const TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);
+/** @type {(typedArray: TypedArray) => IterableIterator<number>} */
+export const TypedArrayPrototypeValues = uncurryThis(
+  TypedArrayPrototype.values
+);
+/** @type {(typedArray: TypedArray) => IterableIterator<[number, number]>} */
+export const TypedArrayPrototypeEntries = uncurryThis(
+  TypedArrayPrototype.entries
+);
+/** @type {(typedArray: TypedArray, array: ArrayLike<number>, offset?: number) => void} */
+export const TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);
+/** @type {<T extends TypedArray>(typedArray: T) => T} */
+export const TypedArrayPrototypeReverse = uncurryThis(
+  TypedArrayPrototype.reverse
+);
+/** @type {<T extends TypedArray>(typedArray: T, value: number, start?: number, end?: number) => T} */
+export const TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);
+/** @type {<T extends TypedArray>(typedArray: T, target: number, start: number, end?: number) => T} */
+export const TypedArrayPrototypeCopyWithin = uncurryThis(
+  TypedArrayPrototype.copyWithin
+);
+/** @type {<T extends TypedArray>(typedArray: T, compareFn?: (a: number, b: number) => number) => T} */
+export const TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);
+/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */
+export const TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);
+/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */
+export const TypedArrayPrototypeSubarray = uncurryThis(
+  TypedArrayPrototype.subarray
+);
+/** @type {((typedArray: TypedArray) => ArrayBuffer)} */
+export const TypedArrayPrototypeGetBuffer = uncurryThisGetter(
+  TypedArrayPrototype,
+  "buffer"
+);
+/** @type {((typedArray: TypedArray) => number)} */
+export const TypedArrayPrototypeGetByteOffset = uncurryThisGetter(
+  TypedArrayPrototype,
+  "byteOffset"
+);
+/** @type {((typedArray: TypedArray) => number)} */
+export const TypedArrayPrototypeGetLength = uncurryThisGetter(
+  TypedArrayPrototype,
+  "length"
+);
+/** @type {(target: unknown) => string} */
+export const TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(
+  TypedArrayPrototype,
+  SymbolToStringTag
+);
+
+// Uint8Array
+export const NativeUint8Array = Uint8Array;
+
+// Uint16Array
+export const NativeUint16Array = Uint16Array;
+/** @type {Uint16ArrayConstructor["from"]} */
+export const Uint16ArrayFrom = (...args) => {
+  return ReflectApply(TypedArrayFrom, NativeUint16Array, args);
+};
+
+// Uint32Array
+export const NativeUint32Array = Uint32Array;
+
+// Float32Array
+export const NativeFloat32Array = Float32Array;
+
+// ArrayIterator
+/** @type {any} */
+export const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());
+/** @type {<T>(arrayIterator: IterableIterator<T>) => IteratorResult<T>} */
+export const ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);
+
+// Generator
+/** @type {<T = unknown, TReturn = any, TNext = unknown>(generator: Generator<T, TReturn, TNext>, value?: TNext) => T} */
+export const GeneratorPrototypeNext = uncurryThis((function* () {})().next);
+
+// Iterator
+export const IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);
+
+// DataView
+const DataViewPrototype = DataView.prototype;
+/** @type {(dataView: DataView, byteOffset: number, littleEndian?: boolean) => number} */
+export const DataViewPrototypeGetUint16 = uncurryThis(
+  DataViewPrototype.getUint16
+);
+/** @type {(dataView: DataView, byteOffset: number, value: number, littleEndian?: boolean) => void} */
+export const DataViewPrototypeSetUint16 = uncurryThis(
+  DataViewPrototype.setUint16
+);
+
+// Error
+export const NativeTypeError = TypeError;
+export const NativeRangeError = RangeError;
+
+// WeakSet
+/**
+ * Do not construct with arguments to avoid calling the "add" method
+ * @type {{new <T extends {}>(): WeakSet<T>}}
+ */
+export const NativeWeakSet = WeakSet;
+const WeakSetPrototype = NativeWeakSet.prototype;
+/** @type {<T extends {}>(set: WeakSet<T>, value: T) => Set<T>} */
+export const WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);
+/** @type {<T extends {}>(set: WeakSet<T>, value: T) => boolean} */
+export const WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);
+
+// WeakMap
+/**
+ * Do not construct with arguments to avoid calling the "set" method
+ * @type {{new <K extends {}, V>(): WeakMap<K, V>}}
+ */
+export const NativeWeakMap = WeakMap;
+const WeakMapPrototype = NativeWeakMap.prototype;
+/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K) => V} */
+export const WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);
+/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K) => boolean} */
+export const WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);
+/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K, value: V) => WeakMap} */
+export const WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);

package/runtime/node_modules/@petamoriken/float16/src/_util/spec.mjs

@@ -0,0 +1,137 @@
+import { isObject, isSharedArrayBuffer } from "./is.mjs";
+import {
+  THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT,
+  THIS_IS_NOT_AN_OBJECT,
+} from "./messages.mjs";
+import {
+  ArrayBufferPrototypeSlice,
+  MAX_SAFE_INTEGER,
+  MathTrunc,
+  NativeTypeError,
+  NumberIsNaN,
+  ObjectIs,
+  SymbolSpecies,
+} from "./primordials.mjs";
+
+/**
+ * @see https://tc39.es/ecma262/#sec-tointegerorinfinity
+ * @param {unknown} target
+ * @returns {number}
+ */
+export function ToIntegerOrInfinity(target) {
+  const number = +target;
+
+  if (NumberIsNaN(number) || number === 0) {
+    return 0;
+  }
+
+  return MathTrunc(number);
+}
+
+/**
+ * @see https://tc39.es/ecma262/#sec-tolength
+ * @param {unknown} target
+ * @returns {number}
+ */
+export function ToLength(target) {
+  const length = ToIntegerOrInfinity(target);
+  if (length < 0) {
+    return 0;
+  }
+
+  return length < MAX_SAFE_INTEGER
+    ? length
+    : MAX_SAFE_INTEGER;
+}
+
+/**
+ * @see https://tc39.es/ecma262/#sec-speciesconstructor
+ * @param {object} target
+ * @param {{ new(...args: any[]): any; }} defaultConstructor
+ * @returns {{ new(...args: any[]): any; }}
+ */
+export 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;
+}
+
+/**
+ * @see https://tc39.es/ecma262/#sec-isdetachedbuffer
+ * @param {ArrayBufferLike} buffer
+ * @returns {boolean}
+ */
+export function IsDetachedBuffer(buffer) {
+  if (isSharedArrayBuffer(buffer)) {
+    return false;
+  }
+
+  try {
+    ArrayBufferPrototypeSlice(buffer, 0, 0);
+    return false;
+  } catch (e) {/* empty */}
+
+  return true;
+}
+
+/**
+ * bigint comparisons are not supported
+ * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort
+ * @param {number} x
+ * @param {number} y
+ * @returns {-1 | 0 | 1}
+ */
+export 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;
+}

package/runtime/node_modules/@petamoriken/float16/src/f16round.mjs

@@ -0,0 +1,10 @@
+import { roundToFloat16 } from "./_util/converter.mjs";
+
+/**
+ * returns the nearest half-precision float representation of a number
+ * @param {number} x
+ * @returns {number}
+ */
+export function f16round(x) {
+  return roundToFloat16(x);
+}

package/runtime/node_modules/@petamoriken/float16/src/index.mjs

@@ -0,0 +1,7 @@
+/* ignore unused exports */
+// @ts-self-types="../index.v5.7.d.ts"
+
+export { Float16Array, isFloat16Array } from "./Float16Array.mjs";
+export { isTypedArray } from "./isTypedArray.mjs";
+export { getFloat16, setFloat16 } from "./DataView.mjs";
+export { f16round, f16round as hfround } from "./f16round.mjs";

package/runtime/node_modules/@petamoriken/float16/src/isTypedArray.mjs

@@ -0,0 +1,10 @@
+import { isFloat16Array } from "./Float16Array.mjs";
+import { isNativeTypedArray } from "./_util/is.mjs";
+
+/**
+ * @param {unknown} target
+ * @returns {value is Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float16Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array}
+ */
+export function isTypedArray(target) {
+  return isNativeTypedArray(target) || isFloat16Array(target);
+}

package/runtime/node_modules/get-tsconfig/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.