numkong 7.0.0

package/javascript/dist/cjs/numkong.js

@@ -0,0 +1,523 @@
+"use strict";
+/**
+ * @fileoverview NumKong - Portable mixed-precision BLAS-like vector math library
+ *
+ * NumKong provides SIMD-accelerated distance metrics and vector operations for
+ * x86, ARM, RISC-V, and WASM platforms. The library automatically detects and uses
+ * the best available SIMD instruction set at runtime.
+ *
+ * @module numkong
+ * @author Ash Vardanian
+ *
+ * @example
+ * ```typescript
+ * import { dot, euclidean, Float16Array } from 'numkong';
+ *
+ * // Auto-detected types
+ * const a = new Float32Array([1, 2, 3]);
+ * const b = new Float32Array([4, 5, 6]);
+ * dot(a, b);        // 32
+ * euclidean(a, b);  // 5.196...
+ *
+ * // Custom types with explicit dtype
+ * const c = new Float16Array([1, 2, 3]);
+ * const d = new Float16Array([4, 5, 6]);
+ * dot(c, d, DType.F16); // 32
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBinary = exports.jaccard = exports.hamming = exports.hasCapability = exports.getCapabilities = exports.DType = exports.cast = exports.castF32ToE5M2 = exports.castE5M2ToF32 = exports.castF32ToE4M3 = exports.castE4M3ToF32 = exports.castF32ToBF16 = exports.castBF16ToF32 = exports.castF32ToF16 = exports.castF16ToF32 = exports.outputDtype = exports.PackedMatrix = exports.Matrix = exports.MatrixBase = exports.Vector = exports.VectorView = exports.VectorBase = exports.TensorBase = exports.BinaryArray = exports.E5M2Array = exports.E4M3Array = exports.BFloat16Array = exports.Float16Array = exports.Capability = void 0;
+exports.sqeuclidean = sqeuclidean;
+exports.euclidean = euclidean;
+exports.angular = angular;
+exports.inner = inner;
+exports.dot = dot;
+exports.kullbackleibler = kullbackleibler;
+exports.jensenshannon = jensenshannon;
+exports.dotsPackedSize = dotsPackedSize;
+exports.dotsPack = dotsPack;
+exports.dotsPacked = dotsPacked;
+exports.angularsPacked = angularsPacked;
+exports.euclideansPacked = euclideansPacked;
+exports.dotsSymmetric = dotsSymmetric;
+exports.angularsSymmetric = angularsSymmetric;
+exports.euclideansSymmetric = euclideansSymmetric;
+const node_gyp_build_1 = __importDefault(require("node-gyp-build"));
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const bindings_1 = require("bindings");
+const types_js_1 = require("./types.js");
+Object.defineProperty(exports, "Float16Array", { enumerable: true, get: function () { return types_js_1.Float16Array; } });
+Object.defineProperty(exports, "BFloat16Array", { enumerable: true, get: function () { return types_js_1.BFloat16Array; } });
+Object.defineProperty(exports, "E4M3Array", { enumerable: true, get: function () { return types_js_1.E4M3Array; } });
+Object.defineProperty(exports, "E5M2Array", { enumerable: true, get: function () { return types_js_1.E5M2Array; } });
+Object.defineProperty(exports, "BinaryArray", { enumerable: true, get: function () { return types_js_1.BinaryArray; } });
+Object.defineProperty(exports, "TensorBase", { enumerable: true, get: function () { return types_js_1.TensorBase; } });
+Object.defineProperty(exports, "VectorBase", { enumerable: true, get: function () { return types_js_1.VectorBase; } });
+Object.defineProperty(exports, "VectorView", { enumerable: true, get: function () { return types_js_1.VectorView; } });
+Object.defineProperty(exports, "Vector", { enumerable: true, get: function () { return types_js_1.Vector; } });
+Object.defineProperty(exports, "MatrixBase", { enumerable: true, get: function () { return types_js_1.MatrixBase; } });
+Object.defineProperty(exports, "Matrix", { enumerable: true, get: function () { return types_js_1.Matrix; } });
+Object.defineProperty(exports, "PackedMatrix", { enumerable: true, get: function () { return types_js_1.PackedMatrix; } });
+Object.defineProperty(exports, "DType", { enumerable: true, get: function () { return types_js_1.DType; } });
+Object.defineProperty(exports, "outputDtype", { enumerable: true, get: function () { return types_js_1.outputDtype; } });
+let compiled;
+try {
+    let builddir = getBuildDir(getDirName());
+    compiled = (0, node_gyp_build_1.default)(builddir);
+    // Initialize conversion functions for types.ts
+    (0, types_js_1.setConversionFunctions)({
+        castF16ToF32: compiled.castF16ToF32,
+        castF32ToF16: compiled.castF32ToF16,
+        castBF16ToF32: compiled.castBF16ToF32,
+        castF32ToBF16: compiled.castF32ToBF16,
+        castE4M3ToF32: compiled.castE4M3ToF32,
+        castF32ToE4M3: compiled.castF32ToE4M3,
+        castE5M2ToF32: compiled.castE5M2ToF32,
+        castF32ToE5M2: compiled.castF32ToE5M2,
+        cast: compiled.cast,
+    });
+}
+catch (e) {
+    // Native addon not available
+    // For WASM usage, import the Emscripten module directly (see test/test-wasm.mjs)
+    throw new Error("NumKong native addon not found. Build with `npm run build` or use WASM " +
+        "by importing the Emscripten module directly. See test/test-wasm.mjs for examples.");
+}
+/**
+ * CPU capability bit masks in chronological order (by first commercial silicon).
+ * Use these with getCapabilities() to check for specific SIMD support.
+ */
+exports.Capability = {
+    SERIAL: 1n << 0n, // Always: Fallback
+    NEON: 1n << 1n, // 2013: ARM NEON
+    HASWELL: 1n << 2n, // 2013: Intel AVX2
+    SKYLAKE: 1n << 3n, // 2017: Intel AVX-512
+    NEONHALF: 1n << 4n, // 2017: ARM NEON FP16
+    NEONSDOT: 1n << 5n, // 2017: ARM NEON i8 dot
+    NEONFHM: 1n << 6n, // 2018: ARM NEON FP16 FML
+    ICELAKE: 1n << 7n, // 2019: Intel AVX-512 VNNI
+    GENOA: 1n << 8n, // 2020: Intel/AMD AVX-512 BF16
+    NEONBFDOT: 1n << 9n, // 2020: ARM NEON BF16
+    SVE: 1n << 10n, // 2020: ARM SVE
+    SVEHALF: 1n << 11n, // 2020: ARM SVE FP16
+    SVESDOT: 1n << 12n, // 2020: ARM SVE i8 dot
+    SIERRA: 1n << 13n, // 2021: Intel AVX2+VNNI
+    SVEBFDOT: 1n << 14n, // 2021: ARM SVE BF16
+    SVE2: 1n << 15n, // 2022: ARM SVE2
+    V128RELAXED: 1n << 16n, // 2022: WASM Relaxed SIMD
+    SAPPHIRE: 1n << 17n, // 2023: Intel AVX-512 FP16
+    SAPPHIREAMX: 1n << 18n, // 2023: Intel Sapphire AMX
+    RVV: 1n << 19n, // 2023: RISC-V Vector
+    RVVHALF: 1n << 20n, // 2023: RISC-V Zvfh
+    RVVBF16: 1n << 21n, // 2023: RISC-V Zvfbfwma
+    GRANITEAMX: 1n << 22n, // 2024: Intel Granite AMX FP16
+    TURIN: 1n << 23n, // 2024: AMD Turin AVX-512 CD
+    SME: 1n << 24n, // 2024: ARM SME
+    SME2: 1n << 25n, // 2024: ARM SME2
+    SMEF64: 1n << 26n, // 2024: ARM SME F64
+    SMEFA64: 1n << 27n, // 2024: ARM SME FA64
+    SVE2P1: 1n << 28n, // 2025+: ARM SVE2.1
+    SME2P1: 1n << 29n, // 2025+: ARM SME2.1
+    SMEHALF: 1n << 30n, // 2025+: ARM SME F16F16
+    SMEBF16: 1n << 31n, // 2025+: ARM SME B16B16
+    SMELUT2: 1n << 32n, // 2025+: ARM SME LUTv2
+    RVVBB: 1n << 33n, // 2025+: RISC-V Zvbb
+};
+/** Convert a single FP16 value (as uint16 bits) to FP32 */
+exports.castF16ToF32 = compiled.castF16ToF32;
+/** Convert a single FP32 value to FP16 (returns uint16 bits) */
+exports.castF32ToF16 = compiled.castF32ToF16;
+/** Convert a single BF16 value (as uint16 bits) to FP32 */
+exports.castBF16ToF32 = compiled.castBF16ToF32;
+/** Convert a single FP32 value to BF16 (returns uint16 bits) */
+exports.castF32ToBF16 = compiled.castF32ToBF16;
+/** Convert a single E4M3 value (as uint8 bits) to FP32 */
+exports.castE4M3ToF32 = compiled.castE4M3ToF32;
+/** Convert a single FP32 value to E4M3 (returns uint8 bits) */
+exports.castF32ToE4M3 = compiled.castF32ToE4M3;
+/** Convert a single E5M2 value (as uint8 bits) to FP32 */
+exports.castE5M2ToF32 = compiled.castE5M2ToF32;
+/** Convert a single FP32 value to E5M2 (returns uint8 bits) */
+exports.castF32ToE5M2 = compiled.castF32ToE5M2;
+/** Bulk conversion between different numeric types (modifies destination array in-place) */
+exports.cast = compiled.cast;
+/**
+ * Extract a TypedArray from a TensorBase for the N-API backend.
+ *
+ * The native backend doesn't benefit from zero-copy TensorBase (Node.js TypedArrays
+ * already share process memory), but accepting TensorBase keeps the API uniform.
+ */
+function unwrapTensor(input) {
+    switch (input.dtype) {
+        case types_js_1.DType.F64: return { arr: new Float64Array(input.buffer, input.byteOffset, input.length), dtype: input.dtype };
+        case types_js_1.DType.F32: return { arr: new Float32Array(input.buffer, input.byteOffset, input.length), dtype: input.dtype };
+        case types_js_1.DType.F16:
+        case types_js_1.DType.BF16: return { arr: new Uint16Array(input.buffer, input.byteOffset, input.length), dtype: input.dtype };
+        case types_js_1.DType.I8: return { arr: new Int8Array(input.buffer, input.byteOffset, input.length), dtype: input.dtype };
+        case types_js_1.DType.U8:
+        case types_js_1.DType.U1: return { arr: new Uint8Array(input.buffer, input.byteOffset, input.length), dtype: input.dtype };
+        default: return { arr: new Uint8Array(input.buffer, input.byteOffset, input.length), dtype: input.dtype };
+    }
+}
+/**
+ * Returns the runtime-detected SIMD capabilities as a bitmask.
+ *
+ * The bitmask includes flags for various SIMD instruction sets like AVX2, AVX-512,
+ * ARM NEON, ARM SVE, ARM SME, RISC-V Vector, and WASM SIMD extensions.
+ * Use with Capability constants to check for specific instruction sets.
+ *
+ * @returns {bigint} Bitmask of capability flags (use with Capability constants)
+ *
+ * @example
+ * ```ts
+ * import { getCapabilities, Capability } from 'numkong';
+ *
+ * const caps = getCapabilities();
+ * console.log(`Capabilities: 0x${caps.toString(16)}`);
+ *
+ * // Check for specific SIMD support
+ * if (caps & Capability.HASWELL) {
+ *   console.log('AVX2 available');
+ * }
+ * ```
+ */
+const getCapabilities = () => {
+    return compiled.getCapabilities();
+};
+exports.getCapabilities = getCapabilities;
+/**
+ * Checks if a specific SIMD capability is available at runtime.
+ *
+ * This is a convenience wrapper around getCapabilities() that tests for a single capability.
+ *
+ * @param {bigint} cap - Capability flag to check (from Capability constants)
+ * @returns {boolean} True if the capability is available, false otherwise
+ *
+ * @example
+ * ```ts
+ * import { hasCapability, Capability } from 'numkong';
+ *
+ * if (hasCapability(Capability.HASWELL)) {
+ *   console.log('Intel AVX2 (Haswell) available');
+ * }
+ * if (hasCapability(Capability.NEON)) {
+ *   console.log('ARM NEON available');
+ * }
+ * if (hasCapability(Capability.V128RELAXED)) {
+ *   console.log('WASM Relaxed SIMD available');
+ * }
+ * ```
+ */
+const hasCapability = (cap) => {
+    return ((0, exports.getCapabilities)() & cap) !== 0n;
+};
+exports.hasCapability = hasCapability;
+function sqeuclidean(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.sqeuclidean(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.sqeuclidean(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.sqeuclidean(a, b);
+}
+function euclidean(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.euclidean(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.euclidean(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.euclidean(a, b);
+}
+function angular(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.angular(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.angular(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.angular(a, b);
+}
+function inner(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.inner(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.inner(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.inner(a, b);
+}
+function dot(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.dot(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.dot(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.dot(a, b);
+}
+/**
+ * Computes the bitwise Hamming distance between two vectors.
+ *
+ * Both vectors are treated as bit-packed (u1 dtype), where each byte contains 8 bits.
+ * Use toBinary() to convert numeric arrays to bit-packed format.
+ *
+ * @param {Uint8Array | BinaryArray} a - The first bit-packed vector.
+ * @param {Uint8Array | BinaryArray} b - The second bit-packed vector.
+ * @returns {number} The Hamming distance (number of differing bits) between vectors a and b.
+ */
+const hamming = (a, b) => {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.hamming(u.arr, v.arr);
+    }
+    return compiled.hamming(a, b);
+};
+exports.hamming = hamming;
+/**
+ * Computes the bitwise Jaccard distance between two vectors.
+ *
+ * Both vectors are treated as bit-packed (u1 dtype), where each byte contains 8 bits.
+ * Use toBinary() to convert numeric arrays to bit-packed format.
+ *
+ * @param {Uint8Array | BinaryArray} a - The first bit-packed vector.
+ * @param {Uint8Array | BinaryArray} b - The second bit-packed vector.
+ * @returns {number} The Jaccard distance (1 - Jaccard similarity) between vectors a and b.
+ */
+const jaccard = (a, b) => {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.jaccard(u.arr, v.arr);
+    }
+    return compiled.jaccard(a, b);
+};
+exports.jaccard = jaccard;
+function kullbackleibler(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.kullbackleibler(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.kullbackleibler(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.kullbackleibler(a, b);
+}
+function jensenshannon(a, b, dtype) {
+    if (a instanceof types_js_1.TensorBase) {
+        const u = unwrapTensor(a), v = unwrapTensor(b);
+        return compiled.jensenshannon(u.arr, v.arr, (0, types_js_1.dtypeToString)(u.dtype));
+    }
+    return dtype !== undefined ? compiled.jensenshannon(a, b, (0, types_js_1.dtypeToString)(dtype)) : compiled.jensenshannon(a, b);
+}
+/**
+ * Quantizes a numeric vector into a bit-packed binary representation.
+ *
+ * Converts each element to a single bit: 1 for positive values, 0 for non-positive values.
+ * The bits are packed into bytes (8 bits per byte) in big-endian bit order within each byte.
+ * This is the required format for hamming() and jaccard() distance functions.
+ *
+ * @param {Float32Array | Float64Array | Int8Array} vector - The vector to quantize and pack.
+ * @returns {Uint8Array} A bit-packed array where each byte contains 8 binary values.
+ *
+ * @example
+ * ```ts
+ * const vec = new Float32Array([1.5, -2.3, 0.0, 3.1, -1.0, 2.0, 0.5, -0.5]);
+ * const binary = toBinary(vec);
+ * // Result: Uint8Array([0b10010110]) = [0x96]
+ * //   bits: [1, 0, 0, 1, 0, 1, 1, 0] for elements [+, -, 0, +, -, +, +, -]
+ *
+ * // Use with Hamming distance
+ * const a = toBinary(new Float32Array([1, 2, 3]));
+ * const b = toBinary(new Float32Array([1, -2, 3]));
+ * const dist = hamming(a, b); // Counts differing bits
+ * ```
+ */
+const toBinary = (vector) => {
+    const byteLength = Math.ceil(vector.length / 8);
+    const packedVector = new Uint8Array(byteLength);
+    for (let i = 0; i < vector.length; i++) {
+        if (vector[i] > 0) {
+            const byteIndex = Math.floor(i / 8);
+            const bitPosition = 7 - (i % 8);
+            packedVector[byteIndex] |= (1 << bitPosition);
+        }
+    }
+    return packedVector;
+};
+exports.toBinary = toBinary;
+/**
+ * Extract a TypedArray from a Matrix for passing to the N-API backend.
+ */
+function unwrapMatrix(matrix) {
+    switch (matrix.dtype) {
+        case types_js_1.DType.F64: return { array: new Float64Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols), dtype: matrix.dtype };
+        case types_js_1.DType.F32: return { array: new Float32Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols), dtype: matrix.dtype };
+        case types_js_1.DType.F16:
+        case types_js_1.DType.BF16: return { array: new Uint16Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols), dtype: matrix.dtype };
+        case types_js_1.DType.I8: return { array: new Int8Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols), dtype: matrix.dtype };
+        case types_js_1.DType.U8: return { array: new Uint8Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols), dtype: matrix.dtype };
+        default: return { array: new Uint8Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols), dtype: matrix.dtype };
+    }
+}
+/**
+ * Extract a result TypedArray from a Matrix matching its output dtype.
+ */
+function unwrapResultMatrix(matrix) {
+    switch (matrix.dtype) {
+        case types_js_1.DType.F64: return new Float64Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols);
+        case types_js_1.DType.F32: return new Float32Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols);
+        case types_js_1.DType.I32: return new Int32Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols);
+        case types_js_1.DType.U32: return new Uint32Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols);
+        default: return new Float64Array(matrix.buffer, matrix.byteOffset, matrix.rows * matrix.cols);
+    }
+}
+/**
+ * Query the packed buffer byte count for a given matrix shape and dtype.
+ */
+function dotsPackedSize(width, depth, dtype) {
+    return compiled.dotsPackedSize(width, depth, (0, types_js_1.dtypeToString)(dtype));
+}
+/**
+ * Pack a Matrix for use with packed GEMM-like operations.
+ */
+function dotsPack(matrix) {
+    const { array, dtype } = unwrapMatrix(matrix);
+    const result = compiled.dotsPack(array, matrix.rows, matrix.cols, matrix.rowStride, (0, types_js_1.dtypeToString)(dtype));
+    return new types_js_1.PackedMatrix(result.buffer, result.width, result.depth, matrix.dtype, result.byteLength);
+}
+function packedOperation(compiledName, family, a, packed, out) {
+    if (a.cols !== packed.depth) {
+        throw new Error(`Matrix cols (${a.cols}) must match packed depth (${packed.depth})`);
+    }
+    const outDtype = (0, types_js_1.outputDtype)(family, a.dtype);
+    if (!out) {
+        out = new types_js_1.Matrix(a.rows, packed.width, outDtype);
+    }
+    const aUnwrapped = unwrapMatrix(a);
+    const resultArray = unwrapResultMatrix(out);
+    compiled[compiledName](aUnwrapped.array, packed.buffer, resultArray, a.rows, packed.width, a.cols, a.rowStride, out.rowStride, (0, types_js_1.dtypeToString)(a.dtype));
+    return out;
+}
+function symmetricOperation(compiledName, family, vectors, out, rowStart = 0, rowCount) {
+    const count = rowCount ?? vectors.rows - rowStart;
+    const outDtype = (0, types_js_1.outputDtype)(family, vectors.dtype);
+    if (!out) {
+        out = new types_js_1.Matrix(vectors.rows, vectors.rows, outDtype);
+    }
+    const vectorsUnwrapped = unwrapMatrix(vectors);
+    const resultArray = unwrapResultMatrix(out);
+    compiled[compiledName](vectorsUnwrapped.array, resultArray, vectors.rows, vectors.cols, vectors.rowStride, out.rowStride, rowStart, count, (0, types_js_1.dtypeToString)(vectors.dtype));
+    return out;
+}
+function dotsPacked(a, packed, out) {
+    return packedOperation('dotsPacked', 'dots', a, packed, out);
+}
+function angularsPacked(a, packed, out) {
+    return packedOperation('angularsPacked', 'angulars', a, packed, out);
+}
+function euclideansPacked(a, packed, out) {
+    return packedOperation('euclideansPacked', 'euclideans', a, packed, out);
+}
+function dotsSymmetric(vectors, out, options) {
+    return symmetricOperation('dotsSymmetric', 'dots', vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+function angularsSymmetric(vectors, out, options) {
+    return symmetricOperation('angularsSymmetric', 'angulars', vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+function euclideansSymmetric(vectors, out, options) {
+    return symmetricOperation('euclideansSymmetric', 'euclideans', vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+exports.default = {
+    dot,
+    inner,
+    sqeuclidean,
+    euclidean,
+    angular,
+    hamming: exports.hamming,
+    jaccard: exports.jaccard,
+    kullbackleibler,
+    jensenshannon,
+    toBinary: exports.toBinary,
+    Float16Array: types_js_1.Float16Array,
+    BFloat16Array: types_js_1.BFloat16Array,
+    E4M3Array: types_js_1.E4M3Array,
+    E5M2Array: types_js_1.E5M2Array,
+    BinaryArray: types_js_1.BinaryArray,
+    TensorBase: types_js_1.TensorBase,
+    VectorBase: types_js_1.VectorBase,
+    VectorView: types_js_1.VectorView,
+    Vector: types_js_1.Vector,
+    MatrixBase: types_js_1.MatrixBase,
+    Matrix: types_js_1.Matrix,
+    PackedMatrix: types_js_1.PackedMatrix,
+    castF16ToF32: exports.castF16ToF32,
+    castF32ToF16: exports.castF32ToF16,
+    castBF16ToF32: exports.castBF16ToF32,
+    castF32ToBF16: exports.castF32ToBF16,
+    castE4M3ToF32: exports.castE4M3ToF32,
+    castF32ToE4M3: exports.castF32ToE4M3,
+    castE5M2ToF32: exports.castE5M2ToF32,
+    castF32ToE5M2: exports.castF32ToE5M2,
+    cast: exports.cast,
+    dotsPack,
+    dotsPacked,
+    angularsPacked,
+    euclideansPacked,
+    dotsSymmetric,
+    angularsSymmetric,
+    euclideansSymmetric,
+    dotsPackedSize,
+    outputDtype: types_js_1.outputDtype,
+};
+/**
+ * Finds the directory where the native build of the numkong module is located.
+ * @param {string} dir - The directory to start the search from.
+ */
+function getBuildDir(dir) {
+    if ((0, node_fs_1.existsSync)(path.join(dir, "build")))
+        return dir;
+    if ((0, node_fs_1.existsSync)(path.join(dir, "prebuilds")))
+        return dir;
+    if (path.basename(dir) === ".next") {
+        // special case for next.js on custom node (not vercel)
+        const sideways = path.join(dir, "..", "node_modules", "numkong");
+        if ((0, node_fs_1.existsSync)(sideways))
+            return getBuildDir(sideways);
+    }
+    if (dir === "/")
+        throw new Error("Could not find native build for numkong");
+    return getBuildDir(path.join(dir, ".."));
+}
+function getDirName() {
+    try {
+        if (__dirname)
+            return __dirname;
+    }
+    catch (e) { }
+    return (0, bindings_1.getRoot)((0, bindings_1.getFileName)());
+}

package/javascript/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}