numkong 7.0.0 → 7.4.2

package/wasm/numkong.js

@@ -0,0 +1,1124 @@
+// javascript/dist/esm/types.js
+var conversionFunctions;
+var DType;
+(function(DType2) {
+  DType2[DType2["F64"] = 0] = "F64";
+  DType2[DType2["F32"] = 1] = "F32";
+  DType2[DType2["F16"] = 2] = "F16";
+  DType2[DType2["BF16"] = 3] = "BF16";
+  DType2[DType2["E4M3"] = 4] = "E4M3";
+  DType2[DType2["E5M2"] = 5] = "E5M2";
+  DType2[DType2["E2M3"] = 6] = "E2M3";
+  DType2[DType2["E3M2"] = 7] = "E3M2";
+  DType2[DType2["I8"] = 8] = "I8";
+  DType2[DType2["U8"] = 9] = "U8";
+  DType2[DType2["U1"] = 10] = "U1";
+  DType2[DType2["I32"] = 11] = "I32";
+  DType2[DType2["U32"] = 12] = "U32";
+})(DType || (DType = {}));
+var DTYPE_STRINGS = [
+  "f64",
+  "f32",
+  "f16",
+  "bf16",
+  "e4m3",
+  "e5m2",
+  "e2m3",
+  "e3m2",
+  "i8",
+  "u8",
+  "u1",
+  "i32",
+  "u32"
+];
+function dtypeToString(d) {
+  return DTYPE_STRINGS[d];
+}
+function inferDtype(arr) {
+  if (arr instanceof Float64Array)
+    return DType.F64;
+  if (arr instanceof Float32Array)
+    return DType.F32;
+  if (arr instanceof Int32Array)
+    return DType.I32;
+  if (arr instanceof Int8Array)
+    return DType.I8;
+  if (arr instanceof Uint8Array)
+    return DType.U8;
+  if (arr instanceof Uint16Array)
+    return DType.F16;
+  if (arr instanceof Uint32Array)
+    return DType.U32;
+  throw new Error(`Cannot infer dtype from ${arr.constructor.name}`);
+}
+var TensorBase = class {
+  constructor(buffer, byteOffset, dtype) {
+    this.buffer = buffer;
+    this.byteOffset = byteOffset;
+    this.dtype = dtype;
+  }
+  /** @brief Bytes per element for this tensor's dtype (compiles to jump table). */
+  get bytesPerElement() {
+    switch (this.dtype) {
+      case DType.F64:
+        return 8;
+      case DType.F32:
+      case DType.I32:
+      case DType.U32:
+        return 4;
+      case DType.F16:
+      case DType.BF16:
+        return 2;
+      default:
+        return 1;
+    }
+  }
+  /** @brief Total byte length of the tensor data. */
+  get byteLength() {
+    return this.length * this.bytesPerElement;
+  }
+};
+var VectorBase = class extends TensorBase {
+  constructor(buffer, byteOffset, length, dtype) {
+    super(buffer, byteOffset, dtype);
+    this.length = length;
+  }
+  get rank() {
+    return 1;
+  }
+};
+var VectorView = class _VectorView extends VectorBase {
+  constructor(buffer, byteOffset, length, dtype) {
+    super(buffer, byteOffset, length, dtype);
+  }
+  toString() {
+    return `VectorView(${this.length}, ${dtypeToString(this.dtype)})`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+  /** @brief Create a VectorView from any TypedArray, inferring or accepting dtype. */
+  static from(arr, dtype) {
+    const d = dtype ?? inferDtype(arr);
+    return new _VectorView(arr.buffer, arr.byteOffset, arr.length, d);
+  }
+};
+var Vector = class _Vector extends VectorBase {
+  constructor(lengthOrBuffer, dtypeOrLength, dtype) {
+    if (typeof lengthOrBuffer === "number") {
+      const length = lengthOrBuffer;
+      const dt = dtypeOrLength;
+      let bpe;
+      switch (dt) {
+        case DType.F64:
+          bpe = 8;
+          break;
+        case DType.F32:
+        case DType.I32:
+        case DType.U32:
+          bpe = 4;
+          break;
+        case DType.F16:
+        case DType.BF16:
+          bpe = 2;
+          break;
+        default:
+          bpe = 1;
+          break;
+      }
+      super(new ArrayBuffer(length * bpe), 0, length, dt);
+    } else {
+      super(lengthOrBuffer, 0, dtypeOrLength, dtype);
+    }
+  }
+  toString() {
+    return `Vector(${this.length}, ${dtypeToString(this.dtype)})`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+  /** @brief Create an owning Vector by copying data from a TypedArray. */
+  static fromTypedArray(arr, dtype) {
+    const d = dtype ?? inferDtype(arr);
+    return new _Vector(arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength), arr.length, d);
+  }
+  /** @brief Create an owning Vector by copying data from any TensorBase. */
+  static fromView(view) {
+    return new _Vector(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength), view.length, view.dtype);
+  }
+  /** @brief Return a TypedArray view over this Vector's owned buffer (zero-copy). */
+  toTypedArray() {
+    switch (this.dtype) {
+      case DType.F64:
+        return new Float64Array(this.buffer, 0, this.length);
+      case DType.F32:
+        return new Float32Array(this.buffer, 0, this.length);
+      case DType.I32:
+        return new Int32Array(this.buffer, 0, this.length);
+      case DType.U32:
+        return new Uint32Array(this.buffer, 0, this.length);
+      case DType.F16:
+      case DType.BF16:
+        return new Uint16Array(this.buffer, 0, this.length);
+      case DType.I8:
+        return new Int8Array(this.buffer, 0, this.length);
+      default:
+        return new Uint8Array(this.buffer, 0, this.length);
+    }
+  }
+};
+var MatrixBase = class extends TensorBase {
+  constructor(buffer, byteOffset, dtype, rows, cols, rowStride, colStride) {
+    super(buffer, byteOffset, dtype);
+    this.rows = rows;
+    this.cols = cols;
+    this.rowStride = rowStride;
+    this.colStride = colStride;
+  }
+  get length() {
+    return this.rows * this.cols;
+  }
+  get rank() {
+    return 2;
+  }
+};
+var Matrix = class _Matrix extends MatrixBase {
+  constructor(rowsOrBuffer, colsOrByteOffset, dtype, rows, cols, rowStride, colStride) {
+    if (typeof rowsOrBuffer === "number") {
+      const r = rowsOrBuffer;
+      const c = colsOrByteOffset;
+      let bpe;
+      switch (dtype) {
+        case DType.F64:
+          bpe = 8;
+          break;
+        case DType.F32:
+        case DType.I32:
+        case DType.U32:
+          bpe = 4;
+          break;
+        case DType.F16:
+        case DType.BF16:
+          bpe = 2;
+          break;
+        default:
+          bpe = 1;
+          break;
+      }
+      super(new ArrayBuffer(r * c * bpe), 0, dtype, r, c, c * bpe, bpe);
+    } else {
+      const r = rows;
+      const c = cols;
+      let bpe;
+      switch (dtype) {
+        case DType.F64:
+          bpe = 8;
+          break;
+        case DType.F32:
+        case DType.I32:
+        case DType.U32:
+          bpe = 4;
+          break;
+        case DType.F16:
+        case DType.BF16:
+          bpe = 2;
+          break;
+        default:
+          bpe = 1;
+          break;
+      }
+      super(rowsOrBuffer, colsOrByteOffset, dtype, r, c, rowStride ?? c * bpe, colStride ?? bpe);
+    }
+  }
+  toString() {
+    return `Matrix(${this.rows}\xD7${this.cols}, ${dtypeToString(this.dtype)})`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+  static fromTypedArray(array, rows, cols, dtype) {
+    const d = dtype ?? inferDtype(array);
+    const buf = array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
+    return new _Matrix(buf, 0, d, rows, cols);
+  }
+  toTypedArray() {
+    switch (this.dtype) {
+      case DType.F64:
+        return new Float64Array(this.buffer, this.byteOffset, this.rows * this.cols);
+      case DType.F32:
+        return new Float32Array(this.buffer, this.byteOffset, this.rows * this.cols);
+      case DType.I32:
+        return new Int32Array(this.buffer, this.byteOffset, this.rows * this.cols);
+      case DType.U32:
+        return new Uint32Array(this.buffer, this.byteOffset, this.rows * this.cols);
+      case DType.F16:
+      case DType.BF16:
+        return new Uint16Array(this.buffer, this.byteOffset, this.rows * this.cols);
+      case DType.I8:
+        return new Int8Array(this.buffer, this.byteOffset, this.rows * this.cols);
+      default:
+        return new Uint8Array(this.buffer, this.byteOffset, this.rows * this.cols);
+    }
+  }
+  row(index) {
+    return new VectorView(this.buffer, this.byteOffset + index * this.rowStride, this.cols, this.dtype);
+  }
+};
+var PackedMatrix = class {
+  constructor(buffer, width, depth, dtype, byteLength) {
+    this._disposed = false;
+    this.buffer = buffer;
+    this.width = width;
+    this.depth = depth;
+    this.dtype = dtype;
+    this.byteLength = byteLength;
+  }
+  dispose() {
+    this._disposed = true;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  toString() {
+    return `PackedMatrix(${this.width}\xD7${this.depth}, ${dtypeToString(this.dtype)}, ${this.byteLength} bytes)`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+function outputDtype(family, input) {
+  switch (input) {
+    case DType.F64:
+      return DType.F64;
+    case DType.F32:
+      return DType.F64;
+    case DType.F16:
+    case DType.BF16:
+    case DType.E4M3:
+    case DType.E5M2:
+    case DType.E2M3:
+    case DType.E3M2:
+      return DType.F32;
+    case DType.I8:
+      return family === "dots" ? DType.I32 : DType.F32;
+    case DType.U8:
+      return family === "dots" ? DType.U32 : DType.F32;
+    default:
+      return DType.F32;
+  }
+}
+var Float16Array = class extends Uint16Array {
+  constructor(length, byteOffset, arrayLength) {
+    if (typeof length === "number") {
+      super(length);
+    } else if (ArrayBuffer.isView(length) || length instanceof ArrayBuffer) {
+      super(length, byteOffset, arrayLength);
+    } else {
+      const src = length;
+      const arr = new Uint16Array(src.length);
+      if (conversionFunctions) {
+        for (let i = 0; i < src.length; i++) {
+          arr[i] = conversionFunctions.castF32ToF16(src[i]);
+        }
+      }
+      super(arr);
+    }
+  }
+  /**
+   * @brief Converts the entire f16 array to f32 (Float32Array).
+   * @returns Float32Array with decoded values
+   */
+  toFloat32Array() {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    const result = new Float32Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      result[i] = conversionFunctions.castF16ToF32(this[i]);
+    }
+    return result;
+  }
+  /**
+   * @brief Gets the f32 value at the specified index.
+   * @param index Array index
+   * @returns Decoded f32 value
+   */
+  getFloat32(index) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    return conversionFunctions.castF16ToF32(this[index]);
+  }
+  /**
+   * @brief Sets the value at the specified index from an f32 value.
+   * @param index Array index
+   * @param value f32 value to encode and store
+   */
+  setFloat32(index, value) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    this[index] = conversionFunctions.castF32ToF16(value);
+  }
+  toString() {
+    if (!conversionFunctions)
+      return `Float16Array(${this.length})`;
+    const limit = Math.min(this.length, 20);
+    const parts = [];
+    for (let i = 0; i < limit; i++) {
+      const f = conversionFunctions.castF16ToF32(this[i]);
+      parts.push(`${f} [0x${this[i].toString(16).padStart(4, "0")}]`);
+    }
+    const suffix = this.length > 20 ? ", ..." : "";
+    return `Float16Array(${this.length}) [${parts.join(", ")}${suffix}]`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+var BFloat16Array = class extends Uint16Array {
+  constructor(length, byteOffset, arrayLength) {
+    if (typeof length === "number") {
+      super(length);
+    } else if (ArrayBuffer.isView(length) || length instanceof ArrayBuffer) {
+      super(length, byteOffset, arrayLength);
+    } else {
+      const src = length;
+      const arr = new Uint16Array(src.length);
+      if (conversionFunctions) {
+        for (let i = 0; i < src.length; i++) {
+          arr[i] = conversionFunctions.castF32ToBF16(src[i]);
+        }
+      }
+      super(arr);
+    }
+  }
+  toFloat32Array() {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    const result = new Float32Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      result[i] = conversionFunctions.castBF16ToF32(this[i]);
+    }
+    return result;
+  }
+  getFloat32(index) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    return conversionFunctions.castBF16ToF32(this[index]);
+  }
+  setFloat32(index, value) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    this[index] = conversionFunctions.castF32ToBF16(value);
+  }
+  toString() {
+    if (!conversionFunctions)
+      return `BFloat16Array(${this.length})`;
+    const limit = Math.min(this.length, 20);
+    const parts = [];
+    for (let i = 0; i < limit; i++) {
+      const f = conversionFunctions.castBF16ToF32(this[i]);
+      parts.push(`${f} [0x${this[i].toString(16).padStart(4, "0")}]`);
+    }
+    const suffix = this.length > 20 ? ", ..." : "";
+    return `BFloat16Array(${this.length}) [${parts.join(", ")}${suffix}]`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+var E4M3Array = class extends Uint8Array {
+  constructor(length, byteOffset, arrayLength) {
+    if (typeof length === "number") {
+      super(length);
+    } else if (ArrayBuffer.isView(length) || length instanceof ArrayBuffer) {
+      super(length, byteOffset, arrayLength);
+    } else {
+      const src = length;
+      const arr = new Uint8Array(src.length);
+      if (conversionFunctions) {
+        for (let i = 0; i < src.length; i++) {
+          arr[i] = conversionFunctions.castF32ToE4M3(src[i]);
+        }
+      }
+      super(arr);
+    }
+  }
+  toFloat32Array() {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    const result = new Float32Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      result[i] = conversionFunctions.castE4M3ToF32(this[i]);
+    }
+    return result;
+  }
+  getFloat32(index) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    return conversionFunctions.castE4M3ToF32(this[index]);
+  }
+  setFloat32(index, value) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    this[index] = conversionFunctions.castF32ToE4M3(value);
+  }
+  toString() {
+    if (!conversionFunctions)
+      return `E4M3Array(${this.length})`;
+    const limit = Math.min(this.length, 20);
+    const parts = [];
+    for (let i = 0; i < limit; i++) {
+      const f = conversionFunctions.castE4M3ToF32(this[i]);
+      parts.push(`${f} [0x${this[i].toString(16).padStart(2, "0")}]`);
+    }
+    const suffix = this.length > 20 ? ", ..." : "";
+    return `E4M3Array(${this.length}) [${parts.join(", ")}${suffix}]`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+var E5M2Array = class extends Uint8Array {
+  constructor(length, byteOffset, arrayLength) {
+    if (typeof length === "number") {
+      super(length);
+    } else if (ArrayBuffer.isView(length) || length instanceof ArrayBuffer) {
+      super(length, byteOffset, arrayLength);
+    } else {
+      const src = length;
+      const arr = new Uint8Array(src.length);
+      if (conversionFunctions) {
+        for (let i = 0; i < src.length; i++) {
+          arr[i] = conversionFunctions.castF32ToE5M2(src[i]);
+        }
+      }
+      super(arr);
+    }
+  }
+  toFloat32Array() {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    const result = new Float32Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      result[i] = conversionFunctions.castE5M2ToF32(this[i]);
+    }
+    return result;
+  }
+  getFloat32(index) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    return conversionFunctions.castE5M2ToF32(this[index]);
+  }
+  setFloat32(index, value) {
+    if (!conversionFunctions) {
+      throw new Error("Conversion functions not initialized");
+    }
+    this[index] = conversionFunctions.castF32ToE5M2(value);
+  }
+  toString() {
+    if (!conversionFunctions)
+      return `E5M2Array(${this.length})`;
+    const limit = Math.min(this.length, 20);
+    const parts = [];
+    for (let i = 0; i < limit; i++) {
+      const f = conversionFunctions.castE5M2ToF32(this[i]);
+      parts.push(`${f} [0x${this[i].toString(16).padStart(2, "0")}]`);
+    }
+    const suffix = this.length > 20 ? ", ..." : "";
+    return `E5M2Array(${this.length}) [${parts.join(", ")}${suffix}]`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+var BinaryArray = class _BinaryArray extends Uint8Array {
+  constructor(bitLength) {
+    const byteLength = Math.ceil(bitLength / 8);
+    super(byteLength);
+    this._bitLength = bitLength;
+  }
+  /**
+   * @brief Gets the bit value at the specified index.
+   * @param index Bit index (0 to bitLength-1)
+   * @returns 0 or 1
+   */
+  getBit(index) {
+    if (index < 0 || index >= this._bitLength) {
+      throw new RangeError("Index out of bounds");
+    }
+    const byteIndex = index >>> 3;
+    const bitIndex = index & 7;
+    return this[byteIndex] >>> bitIndex & 1;
+  }
+  /**
+   * @brief Sets the bit value at the specified index.
+   * @param index Bit index (0 to bitLength-1)
+   * @param value 0 or 1
+   */
+  setBit(index, value) {
+    if (index < 0 || index >= this._bitLength) {
+      throw new RangeError("Index out of bounds");
+    }
+    const byteIndex = index >>> 3;
+    const bitIndex = index & 7;
+    if (value) {
+      this[byteIndex] |= 1 << bitIndex;
+    } else {
+      this[byteIndex] &= ~(1 << bitIndex);
+    }
+  }
+  /**
+   * @brief Returns the logical bit length of the array.
+   */
+  get bitLength() {
+    return this._bitLength;
+  }
+  /**
+   * @brief Creates a BinaryArray from a Float32Array (positive values = 1, else 0).
+   * @param vector Source floating-point vector
+   * @returns Binary array with quantized values
+   */
+  static fromFloat32Array(vector) {
+    const binary = new _BinaryArray(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+      if (vector[i] > 0) {
+        binary.setBit(i, 1);
+      }
+    }
+    return binary;
+  }
+  /**
+   * @brief Creates a BinaryArray from a Float64Array (positive values = 1, else 0).
+   * @param vector Source floating-point vector
+   * @returns Binary array with quantized values
+   */
+  static fromFloat64Array(vector) {
+    const binary = new _BinaryArray(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+      if (vector[i] > 0) {
+        binary.setBit(i, 1);
+      }
+    }
+    return binary;
+  }
+  toString() {
+    const limit = Math.min(this.length, 20);
+    const parts = [];
+    for (let i = 0; i < limit; i++) {
+      parts.push(`0b${this[i].toString(2).padStart(8, "0")}`);
+    }
+    const suffix = this.length > 20 ? ", ..." : "";
+    return `BinaryArray(${this._bitLength}) [${parts.join(", ")}${suffix}]`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+function isFloat16Array(obj) {
+  return obj instanceof Float16Array;
+}
+function isBFloat16Array(obj) {
+  return obj instanceof BFloat16Array;
+}
+function isE4M3Array(obj) {
+  return obj instanceof E4M3Array;
+}
+function isE5M2Array(obj) {
+  return obj instanceof E5M2Array;
+}
+function isBinaryArray(obj) {
+  return obj instanceof BinaryArray;
+}
+
+// javascript/dist/esm/numkong-wasm.js
+var Module = null;
+var isMemory64 = false;
+var resultPtr = 0;
+var HEAP32;
+var HEAPU8;
+var HEAPU32;
+var HEAPF32;
+var HEAPF64;
+function toWasmPtr(n) {
+  return isMemory64 ? BigInt(n) : n;
+}
+function initWasm(wasmModule) {
+  Module = wasmModule;
+  const buffer = wasmModule.wasmMemory.buffer;
+  HEAP32 = new Int32Array(buffer);
+  HEAPU8 = new Uint8Array(buffer);
+  HEAPU32 = new Uint32Array(buffer);
+  HEAPF32 = new Float32Array(buffer);
+  HEAPF64 = new Float64Array(buffer);
+  try {
+    const probe = wasmModule._malloc(8);
+    wasmModule._nk_dot_f32(BigInt(probe), BigInt(probe), 0, BigInt(probe));
+    isMemory64 = true;
+    wasmModule._free(probe);
+  } catch {
+    isMemory64 = false;
+  }
+  resultPtr = wasmModule._malloc(8);
+}
+function detectType(arr) {
+  if (arr instanceof Float64Array) {
+    return { dtype: DType.F64, bytesPerElement: 8, heapView: "HEAPF64", resultType: "f64" };
+  } else if (arr instanceof Float32Array) {
+    return { dtype: DType.F32, bytesPerElement: 4, heapView: "HEAPF32", resultType: "f64" };
+  } else if (arr instanceof Int8Array) {
+    return { dtype: DType.I8, bytesPerElement: 1, heapView: "HEAPU8", resultType: "i32" };
+  } else if (arr instanceof Uint8Array) {
+    return { dtype: DType.U8, bytesPerElement: 1, heapView: "HEAPU8", resultType: "u32" };
+  }
+  const constructorName = arr.constructor.name;
+  if (constructorName === "Float16Array") {
+    return { dtype: DType.F16, bytesPerElement: 2, heapView: "HEAPU8", resultType: "f32" };
+  } else if (constructorName === "BFloat16Array") {
+    return { dtype: DType.BF16, bytesPerElement: 2, heapView: "HEAPU8", resultType: "f32" };
+  } else if (constructorName === "E4M3Array") {
+    throw new Error("E4M3 not yet supported in WASM backend");
+  } else if (constructorName === "E5M2Array") {
+    throw new Error("E5M2 not yet supported in WASM backend");
+  } else if (constructorName === "BinaryArray") {
+    return { dtype: DType.U1, bytesPerElement: 1, heapView: "HEAPU8", resultType: "u32" };
+  }
+  throw new Error(`Unsupported array type: ${constructorName}`);
+}
+function typeInfoFromDtype(dtype) {
+  switch (dtype) {
+    case DType.F64:
+      return { dtype, bytesPerElement: 8, heapView: "HEAPF64", resultType: "f64" };
+    case DType.F32:
+      return { dtype, bytesPerElement: 4, heapView: "HEAPF32", resultType: "f64" };
+    case DType.F16:
+      return { dtype, bytesPerElement: 2, heapView: "HEAPU8", resultType: "f32" };
+    case DType.BF16:
+      return { dtype, bytesPerElement: 2, heapView: "HEAPU8", resultType: "f32" };
+    case DType.I8:
+      return { dtype, bytesPerElement: 1, heapView: "HEAPU8", resultType: "i32" };
+    case DType.U8:
+      return { dtype, bytesPerElement: 1, heapView: "HEAPU8", resultType: "u32" };
+    case DType.U1:
+      return { dtype, bytesPerElement: 1, heapView: "HEAPU8", resultType: "u32" };
+    default:
+      throw new Error(`Unsupported dtype: ${dtype}`);
+  }
+}
+function resolveInput(a) {
+  if (a instanceof TensorBase) {
+    return {
+      buffer: a.buffer,
+      byteOffset: a.byteOffset,
+      length: a.length,
+      byteLength: a.byteLength,
+      typeInfo: typeInfoFromDtype(a.dtype)
+    };
+  }
+  const typeInfo = detectType(a);
+  return {
+    buffer: a.buffer,
+    byteOffset: a.byteOffset,
+    length: a.length,
+    byteLength: a.length * typeInfo.bytesPerElement,
+    typeInfo
+  };
+}
+function allocAndCopyResolved(buffer, byteOffset, byteLength) {
+  if (!Module)
+    throw new Error("WASM module not initialized");
+  const ptr = Module._malloc(byteLength);
+  const src = new Uint8Array(buffer, byteOffset, byteLength);
+  HEAPU8.set(src, ptr);
+  return ptr;
+}
+function readResult(ptr, resultType) {
+  if (!Module)
+    throw new Error("WASM module not initialized");
+  switch (resultType) {
+    case "f64":
+      return HEAPF64[ptr / 8];
+    case "f32":
+      return HEAPF32[ptr / 4];
+    case "i32":
+      return HEAP32[ptr / 4];
+    case "u32":
+      return HEAPU32[ptr / 4];
+  }
+}
+function distance(metric, a, b) {
+  if (!Module) {
+    throw new Error("WASM module not initialized. Call initWasm() first.");
+  }
+  const resolvedA = resolveInput(a);
+  const resolvedB = resolveInput(b);
+  if (resolvedA.length !== resolvedB.length) {
+    throw new Error(`Array length mismatch: ${resolvedA.length} !== ${resolvedB.length}`);
+  }
+  const n = resolvedA.length;
+  const isOnHeapA = resolvedA.buffer === Module.wasmMemory.buffer;
+  const isOnHeapB = resolvedB.buffer === Module.wasmMemory.buffer;
+  const aOff = isOnHeapA ? resolvedA.byteOffset : allocAndCopyResolved(resolvedA.buffer, resolvedA.byteOffset, resolvedA.byteLength);
+  const bOff = isOnHeapB ? resolvedB.byteOffset : allocAndCopyResolved(resolvedB.buffer, resolvedB.byteOffset, resolvedB.byteLength);
+  try {
+    const fnName = `_nk_${metric}_${dtypeToString(resolvedA.typeInfo.dtype)}`;
+    const fn = Module[fnName];
+    if (!fn || typeof fn !== "function") {
+      throw new Error(`Function ${fnName} not available in WASM module`);
+    }
+    fn(toWasmPtr(aOff), toWasmPtr(bOff), n, toWasmPtr(resultPtr));
+    return readResult(resultPtr, resolvedA.typeInfo.resultType);
+  } finally {
+    if (!isOnHeapA)
+      Module._free(aOff);
+    if (!isOnHeapB)
+      Module._free(bOff);
+  }
+}
+function sqeuclidean(a, b) {
+  return distance("sqeuclidean", a, b);
+}
+function euclidean(a, b) {
+  return distance("euclidean", a, b);
+}
+function angular(a, b) {
+  return distance("angular", a, b);
+}
+function dot(a, b) {
+  return distance("dot", a, b);
+}
+var inner = dot;
+function hamming(a, b) {
+  if (!Module) {
+    throw new Error("WASM module not initialized");
+  }
+  const bufferA = a.buffer, offsetA = a.byteOffset, lengthA = a.length;
+  const bufferB = b.buffer, offsetB = b.byteOffset, lengthB = b.length;
+  const byteLengthA = a instanceof TensorBase ? a.byteLength : lengthA;
+  const byteLengthB = b instanceof TensorBase ? b.byteLength : lengthB;
+  if (lengthA !== lengthB) {
+    throw new Error(`Array length mismatch: ${lengthA} !== ${lengthB}`);
+  }
+  const isOnHeapA = bufferA === Module.wasmMemory.buffer;
+  const isOnHeapB = bufferB === Module.wasmMemory.buffer;
+  const aOff = isOnHeapA ? offsetA : allocAndCopyResolved(bufferA, offsetA, byteLengthA);
+  const bOff = isOnHeapB ? offsetB : allocAndCopyResolved(bufferB, offsetB, byteLengthB);
+  try {
+    const fn = Module._nk_hamming_u1;
+    if (!fn || typeof fn !== "function") {
+      throw new Error("Function _nk_hamming_u1 not available in WASM module");
+    }
+    fn(toWasmPtr(aOff), toWasmPtr(bOff), lengthA, toWasmPtr(resultPtr));
+    return readResult(resultPtr, "u32");
+  } finally {
+    if (!isOnHeapA)
+      Module._free(aOff);
+    if (!isOnHeapB)
+      Module._free(bOff);
+  }
+}
+function jaccard(a, b) {
+  if (!Module) {
+    throw new Error("WASM module not initialized");
+  }
+  const bufferA = a.buffer, offsetA = a.byteOffset, lengthA = a.length;
+  const bufferB = b.buffer, offsetB = b.byteOffset, lengthB = b.length;
+  const byteLengthA = a instanceof TensorBase ? a.byteLength : lengthA;
+  const byteLengthB = b instanceof TensorBase ? b.byteLength : lengthB;
+  if (lengthA !== lengthB) {
+    throw new Error(`Array length mismatch: ${lengthA} !== ${lengthB}`);
+  }
+  const isOnHeapA = bufferA === Module.wasmMemory.buffer;
+  const isOnHeapB = bufferB === Module.wasmMemory.buffer;
+  const aOff = isOnHeapA ? offsetA : allocAndCopyResolved(bufferA, offsetA, byteLengthA);
+  const bOff = isOnHeapB ? offsetB : allocAndCopyResolved(bufferB, offsetB, byteLengthB);
+  try {
+    const fn = Module._nk_jaccard_u1;
+    if (!fn || typeof fn !== "function") {
+      throw new Error("Function _nk_jaccard_u1 not available in WASM module");
+    }
+    fn(toWasmPtr(aOff), toWasmPtr(bOff), lengthA, toWasmPtr(resultPtr));
+    return readResult(resultPtr, "f32");
+  } finally {
+    if (!isOnHeapA)
+      Module._free(aOff);
+    if (!isOnHeapB)
+      Module._free(bOff);
+  }
+}
+function kullbackleibler(a, b) {
+  if (!Module) {
+    throw new Error("WASM module not initialized");
+  }
+  const resolvedA = resolveInput(a);
+  const resolvedB = resolveInput(b);
+  if (resolvedA.length !== resolvedB.length) {
+    throw new Error(`Array length mismatch: ${resolvedA.length} !== ${resolvedB.length}`);
+  }
+  const n = resolvedA.length;
+  const isOnHeapA = resolvedA.buffer === Module.wasmMemory.buffer;
+  const isOnHeapB = resolvedB.buffer === Module.wasmMemory.buffer;
+  const aOff = isOnHeapA ? resolvedA.byteOffset : allocAndCopyResolved(resolvedA.buffer, resolvedA.byteOffset, resolvedA.byteLength);
+  const bOff = isOnHeapB ? resolvedB.byteOffset : allocAndCopyResolved(resolvedB.buffer, resolvedB.byteOffset, resolvedB.byteLength);
+  try {
+    const fnName = `_nk_kld_${dtypeToString(resolvedA.typeInfo.dtype)}`;
+    const fn = Module[fnName];
+    if (!fn || typeof fn !== "function") {
+      throw new Error(`Function ${fnName} not available in WASM module`);
+    }
+    fn(toWasmPtr(aOff), toWasmPtr(bOff), n, toWasmPtr(resultPtr));
+    return readResult(resultPtr, resolvedA.typeInfo.resultType);
+  } finally {
+    if (!isOnHeapA)
+      Module._free(aOff);
+    if (!isOnHeapB)
+      Module._free(bOff);
+  }
+}
+function jensenshannon(a, b) {
+  if (!Module) {
+    throw new Error("WASM module not initialized");
+  }
+  const resolvedA = resolveInput(a);
+  const resolvedB = resolveInput(b);
+  if (resolvedA.length !== resolvedB.length) {
+    throw new Error(`Array length mismatch: ${resolvedA.length} !== ${resolvedB.length}`);
+  }
+  const n = resolvedA.length;
+  const isOnHeapA = resolvedA.buffer === Module.wasmMemory.buffer;
+  const isOnHeapB = resolvedB.buffer === Module.wasmMemory.buffer;
+  const aOff = isOnHeapA ? resolvedA.byteOffset : allocAndCopyResolved(resolvedA.buffer, resolvedA.byteOffset, resolvedA.byteLength);
+  const bOff = isOnHeapB ? resolvedB.byteOffset : allocAndCopyResolved(resolvedB.buffer, resolvedB.byteOffset, resolvedB.byteLength);
+  try {
+    const fnName = `_nk_jsd_${dtypeToString(resolvedA.typeInfo.dtype)}`;
+    const fn = Module[fnName];
+    if (!fn || typeof fn !== "function") {
+      throw new Error(`Function ${fnName} not available in WASM module`);
+    }
+    fn(toWasmPtr(aOff), toWasmPtr(bOff), n, toWasmPtr(resultPtr));
+    return readResult(resultPtr, resolvedA.typeInfo.resultType);
+  } finally {
+    if (!isOnHeapA)
+      Module._free(aOff);
+    if (!isOnHeapB)
+      Module._free(bOff);
+  }
+}
+function getCapabilities() {
+  if (!Module) {
+    throw new Error("WASM module not initialized");
+  }
+  const caps = Module._nk_capabilities();
+  return typeof caps === "bigint" ? caps : BigInt(caps);
+}
+function hasCapability(cap) {
+  return (getCapabilities() & cap) !== 0n;
+}
+var packedRegistry = null;
+var WasmPackedMatrix = class extends PackedMatrix {
+  constructor(heapPointer, byteLength, width, depth, dtype) {
+    const buffer = new ArrayBuffer(byteLength);
+    new Uint8Array(buffer).set(HEAPU8.subarray(heapPointer, heapPointer + byteLength));
+    super(buffer, width, depth, dtype, byteLength);
+    this._wasmDisposed = false;
+    this._heapPointer = heapPointer;
+    if (!packedRegistry && typeof FinalizationRegistry !== "undefined") {
+      packedRegistry = new FinalizationRegistry((ptr) => {
+        if (Module)
+          Module._free(ptr);
+      });
+    }
+    if (packedRegistry) {
+      packedRegistry.register(this, heapPointer);
+    }
+  }
+  get heapPointer() {
+    return this._heapPointer;
+  }
+  dispose() {
+    if (!this._wasmDisposed && Module) {
+      Module._free(this._heapPointer);
+      this._wasmDisposed = true;
+    }
+    super.dispose();
+  }
+};
+function allocAndCopyMatrix(matrix) {
+  const byteLength = matrix.rows * matrix.rowStride;
+  return allocAndCopyResolved(matrix.buffer, matrix.byteOffset, byteLength);
+}
+function dotsPackedSize(width, depth, dtype) {
+  if (!Module)
+    throw new Error("WASM module not initialized");
+  const fnName = `_nk_dots_packed_size_${dtypeToString(dtype)}`;
+  const fn = Module[fnName];
+  if (!fn || typeof fn !== "function") {
+    throw new Error(`Function ${fnName} not available in WASM module`);
+  }
+  return fn(width, depth);
+}
+function dotsPack(matrix) {
+  if (!Module)
+    throw new Error("WASM module not initialized");
+  const dtypeStr = dtypeToString(matrix.dtype);
+  const sizeFnName = `_nk_dots_packed_size_${dtypeStr}`;
+  const packFnName = `_nk_dots_pack_${dtypeStr}`;
+  const sizeFn = Module[sizeFnName];
+  const packFn = Module[packFnName];
+  if (!sizeFn || !packFn) {
+    throw new Error(`Pack functions not available for dtype ${dtypeStr}`);
+  }
+  const packedByteCount = sizeFn(matrix.rows, matrix.cols);
+  const packedPtr = Module._malloc(packedByteCount);
+  const matrixPtr = allocAndCopyMatrix(matrix);
+  try {
+    packFn(toWasmPtr(matrixPtr), matrix.rows, matrix.cols, matrix.rowStride, toWasmPtr(packedPtr));
+  } finally {
+    Module._free(matrixPtr);
+  }
+  return new WasmPackedMatrix(packedPtr, packedByteCount, matrix.rows, matrix.cols, matrix.dtype);
+}
+function wasmPackedOperation(metricPrefix, family, a, packed, out) {
+  if (!Module)
+    throw new Error("WASM module not initialized");
+  if (a.cols !== packed.depth) {
+    throw new Error(`Matrix cols (${a.cols}) must match packed depth (${packed.depth})`);
+  }
+  const outDtype = outputDtype(family, a.dtype);
+  if (!out) {
+    out = new Matrix(a.rows, packed.width, outDtype);
+  }
+  const dtypeStr = dtypeToString(a.dtype);
+  const fnName = `_nk_${metricPrefix}_${dtypeStr}`;
+  const fn = Module[fnName];
+  if (!fn || typeof fn !== "function") {
+    throw new Error(`Function ${fnName} not available in WASM module`);
+  }
+  const outBpe = out.bytesPerElement;
+  const resultByteLength = out.rows * out.cols * outBpe;
+  const aPtr = allocAndCopyMatrix(a);
+  const resultPtr2 = Module._malloc(resultByteLength);
+  let packedPtr;
+  let packedAllocated = false;
+  if (packed instanceof WasmPackedMatrix) {
+    packedPtr = allocAndCopyResolved(packed.buffer, 0, packed.byteLength);
+    packedAllocated = true;
+  } else {
+    packedPtr = allocAndCopyResolved(packed.buffer, 0, packed.byteLength);
+    packedAllocated = true;
+  }
+  try {
+    fn(toWasmPtr(aPtr), toWasmPtr(packedPtr), toWasmPtr(resultPtr2), a.rows, packed.width, a.cols, a.rowStride, out.rowStride);
+    const outArray = new Uint8Array(out.buffer, out.byteOffset, resultByteLength);
+    outArray.set(HEAPU8.subarray(resultPtr2, resultPtr2 + resultByteLength));
+  } finally {
+    Module._free(aPtr);
+    Module._free(resultPtr2);
+    if (packedAllocated)
+      Module._free(packedPtr);
+  }
+  return out;
+}
+function wasmSymmetricOperation(metricPrefix, family, vectors, out, rowStart = 0, rowCount) {
+  if (!Module)
+    throw new Error("WASM module not initialized");
+  const count = rowCount ?? vectors.rows - rowStart;
+  const outDtype = outputDtype(family, vectors.dtype);
+  if (!out) {
+    out = new Matrix(vectors.rows, vectors.rows, outDtype);
+  }
+  const dtypeStr = dtypeToString(vectors.dtype);
+  const fnName = `_nk_${metricPrefix}_${dtypeStr}`;
+  const fn = Module[fnName];
+  if (!fn || typeof fn !== "function") {
+    throw new Error(`Function ${fnName} not available in WASM module`);
+  }
+  const resultByteLength = out.rows * out.cols * out.bytesPerElement;
+  const vectorsPtr = allocAndCopyMatrix(vectors);
+  const resultPtr2 = Module._malloc(resultByteLength);
+  try {
+    fn(toWasmPtr(vectorsPtr), vectors.rows, vectors.cols, vectors.rowStride, toWasmPtr(resultPtr2), out.rowStride, rowStart, count);
+    const outArray = new Uint8Array(out.buffer, out.byteOffset, resultByteLength);
+    outArray.set(HEAPU8.subarray(resultPtr2, resultPtr2 + resultByteLength));
+  } finally {
+    Module._free(vectorsPtr);
+    Module._free(resultPtr2);
+  }
+  return out;
+}
+function dotsPacked(a, packed, out) {
+  return wasmPackedOperation("dots_packed", "dots", a, packed, out);
+}
+function angularsPacked(a, packed, out) {
+  return wasmPackedOperation("angulars_packed", "angulars", a, packed, out);
+}
+function euclideansPacked(a, packed, out) {
+  return wasmPackedOperation("euclideans_packed", "euclideans", a, packed, out);
+}
+function dotsSymmetric(vectors, out, options) {
+  return wasmSymmetricOperation("dots_symmetric", "dots", vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+function angularsSymmetric(vectors, out, options) {
+  return wasmSymmetricOperation("angulars_symmetric", "angulars", vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+function euclideansSymmetric(vectors, out, options) {
+  return wasmSymmetricOperation("euclideans_symmetric", "euclideans", vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+
+// javascript/dist/esm/numkong-browser.js
+var glueUrl = new URL("./numkong-emscripten.js", import.meta.url);
+var { default: NumKongModule } = await import(glueUrl.href);
+var wasmInstance = await NumKongModule({
+  locateFile: (path) => new URL(path, glueUrl).href
+});
+initWasm(wasmInstance);
+export {
+  BFloat16Array,
+  BinaryArray,
+  DType,
+  E4M3Array,
+  E5M2Array,
+  Float16Array,
+  Matrix,
+  MatrixBase,
+  PackedMatrix,
+  TensorBase,
+  Vector,
+  VectorBase,
+  VectorView,
+  angular,
+  angularsPacked,
+  angularsSymmetric,
+  dot,
+  dotsPack,
+  dotsPacked,
+  dotsPackedSize,
+  dotsSymmetric,
+  dtypeToString,
+  euclidean,
+  euclideansPacked,
+  euclideansSymmetric,
+  getCapabilities,
+  hamming,
+  hasCapability,
+  inner,
+  isBFloat16Array,
+  isBinaryArray,
+  isE4M3Array,
+  isE5M2Array,
+  isFloat16Array,
+  jaccard,
+  jensenshannon,
+  kullbackleibler,
+  outputDtype,
+  sqeuclidean
+};