usearch 2.9.2 → 2.10.0

package/simsimd/include/simsimd/types.h

@@ -1,208 +0,0 @@
-#ifndef SIMSIMD_TYPES_H
-#define SIMSIMD_TYPES_H
-
-// Compiling for Arm: SIMSIMD_TARGET_ARM
-#if !defined(SIMSIMD_TARGET_ARM)
-#if defined(__aarch64__) || defined(_M_ARM64)
-#define SIMSIMD_TARGET_ARM 1
-#else
-#define SIMSIMD_TARGET_ARM 0
-#endif // defined(__aarch64__) || defined(_M_ARM64)
-#endif // !defined(SIMSIMD_TARGET_ARM)
-
-// Compiling for x86: SIMSIMD_TARGET_X86
-#if !defined(SIMSIMD_TARGET_X86)
-#if defined(__x86_64__) || defined(_M_X64)
-#define SIMSIMD_TARGET_X86 1
-#else
-#define SIMSIMD_TARGET_X86 0
-#endif // defined(__x86_64__) || defined(_M_X64)
-#endif // !defined(SIMSIMD_TARGET_X86)
-
-// Compiling for Arm: SIMSIMD_TARGET_ARM_NEON
-#if !defined(SIMSIMD_TARGET_ARM_NEON) || !SIMSIMD_TARGET_ARM
-#if defined(__ARM_NEON)
-#define SIMSIMD_TARGET_ARM_NEON SIMSIMD_TARGET_ARM
-#else
-#define SIMSIMD_TARGET_ARM_NEON 0
-#endif // defined(__ARM_NEON)
-#endif // !defined(SIMSIMD_TARGET_ARM_NEON)
-
-// Compiling for Arm: SIMSIMD_TARGET_ARM_SVE
-#if !defined(SIMSIMD_TARGET_ARM_SVE) || !SIMSIMD_TARGET_ARM
-#if defined(__ARM_FEATURE_SVE)
-#define SIMSIMD_TARGET_ARM_SVE SIMSIMD_TARGET_ARM
-#else
-#define SIMSIMD_TARGET_ARM_SVE 0
-#endif // defined(__ARM_FEATURE_SVE)
-#endif // !defined(SIMSIMD_TARGET_ARM_SVE)
-
-// Compiling for x86: SIMSIMD_TARGET_X86_AVX2
-#if !defined(SIMSIMD_TARGET_X86_AVX2) || !SIMSIMD_TARGET_X86
-#if defined(__AVX2__)
-#define SIMSIMD_TARGET_X86_AVX2 1
-#else
-#define SIMSIMD_TARGET_X86_AVX2 0
-#endif // defined(__AVX2__)
-#endif // !defined(SIMSIMD_TARGET_X86_AVX2)
-
-// Compiling for x86: SIMSIMD_TARGET_X86_AVX512
-#if !defined(SIMSIMD_TARGET_X86_AVX512) || !SIMSIMD_TARGET_X86
-#if defined(__AVX512F__) && defined(__AVX512FP16__) && defined(__AVX512VNNI__) && defined(__AVX512VPOPCNTDQ__)
-#define SIMSIMD_TARGET_X86_AVX512 1
-#else
-#define SIMSIMD_TARGET_X86_AVX512 0
-#endif // defined(__AVX512F__) && defined(__AVX512FP16__) && defined(__AVX512VNNI__) && defined(__AVX512VPOPCNTDQ__)
-#endif // !defined(SIMSIMD_TARGET_X86_AVX512)
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#else
-
-#if SIMSIMD_TARGET_ARM_NEON
-#include <arm_neon.h>
-#endif
-
-#if SIMSIMD_TARGET_ARM_SVE
-#include <arm_sve.h>
-#endif
-
-#if SIMSIMD_TARGET_X86_AVX2 || SIMSIMD_TARGET_X86_AVX512
-#include <immintrin.h>
-#endif
-
-#endif
-
-#ifndef SIMSIMD_RSQRT
-#include <math.h>
-#define SIMSIMD_RSQRT(x) (1 / sqrtf(x))
-#endif
-
-#ifndef SIMSIMD_LOG
-#include <math.h>
-#define SIMSIMD_LOG(x) (logf(x))
-#endif
-
-#ifndef SIMSIMD_F32_DIVISION_EPSILON
-#define SIMSIMD_F32_DIVISION_EPSILON (1e-7)
-#endif
-
-#ifndef SIMSIMD_F16_DIVISION_EPSILON
-#define SIMSIMD_F16_DIVISION_EPSILON (1e-3)
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef int simsimd_i32_t;
-typedef float simsimd_f32_t;
-typedef double simsimd_f64_t;
-typedef signed char simsimd_i8_t;
-typedef unsigned char simsimd_b8_t;
-typedef unsigned long long simsimd_u64_t;
-typedef unsigned long long simsimd_size_t;
-
-#if !defined(SIMSIMD_NATIVE_F16) || SIMSIMD_NATIVE_F16
-/**
- *  @brief  Half-precision floating-point type.
- *
- *  - GCC or Clang on 64-bit ARM: `__fp16`, may require `-mfp16-format` option.
- *  - GCC or Clang on 64-bit x86: `_Float16`.
- *  - Default: `unsigned short`.
- */
-#if (defined(__GNUC__) || defined(__clang__)) && (defined(__ARM_ARCH) || defined(__aarch64__)) &&                      \
-    (defined(__ARM_FP16_FORMAT_IEEE))
-#if !defined(SIMSIMD_NATIVE_F16)
-#define SIMSIMD_NATIVE_F16 1
-#endif
-typedef __fp16 simsimd_f16_t;
-#elif ((defined(__GNUC__) || defined(__clang__)) && (defined(__x86_64__) || defined(__i386__)) &&                      \
-       (defined(__SSE2__) || defined(__AVX512F__)))
-typedef _Float16 simsimd_f16_t;
-#if !defined(SIMSIMD_NATIVE_F16)
-#define SIMSIMD_NATIVE_F16 1
-#endif
-#else // Unknown compiler or architecture
-#define SIMSIMD_NATIVE_F16 0
-#endif // Unknown compiler or architecture
-#endif // !SIMSIMD_NATIVE_F16
-
-#if !SIMSIMD_NATIVE_F16
-typedef unsigned short simsimd_f16_t;
-#endif
-
-#define SIMSIMD_IDENTIFY(x) (x)
-
-/**
- *  @brief  Returns the value of the half-precision floating-point number,
- *          potentially decompressed into single-precision.
- */
-#ifndef SIMSIMD_UNCOMPRESS_F16
-#if SIMSIMD_NATIVE_F16
-#define SIMSIMD_UNCOMPRESS_F16(x) SIMSIMD_IDENTIFY(x)
-#else
-#define SIMSIMD_UNCOMPRESS_F16(x) simsimd_uncompress_f16(x)
-#endif
-#endif
-
-typedef union {
-    unsigned i;
-    float f;
-} simsimd_f32i32_t;
-
-/**
- *  @brief  Computes `1/sqrt(x)` using the trick from Quake 3, replacing
- *          magic numbers with the ones suggested by Jan Kadlec.
- */
-inline static simsimd_f32_t simsimd_approximate_inverse_square_root(simsimd_f32_t number) {
-    simsimd_f32i32_t conv;
-    conv.f = number;
-    conv.i = 0x5F1FFFF9 - (conv.i >> 1);
-    conv.f *= 0.703952253f * (2.38924456f - number * conv.f * conv.f);
-    return conv.f;
-}
-
-/**
- *  @brief  Computes `log(x)` using the Mercator series.
- *          The series converges to the natural logarithm for args between -1 and 1.
- *          Published in 1668 in "Logarithmotechnia".
- */
-inline static simsimd_f32_t simsimd_approximate_log(simsimd_f32_t number) {
-    simsimd_f32_t x = number - 1;
-    simsimd_f32_t x2 = x * x;
-    simsimd_f32_t x3 = x * x * x;
-    return x - x2 / 2 + x3 / 3;
-}
-
-/**
- *  @brief  For compilers that don't natively support the `_Float16` type,
- *          upcasts contents into a more conventional `float`.
- *
- *  @warning  This function won't handle boundary conditions well.
- *
- *  https://stackoverflow.com/a/60047308
- *  https://gist.github.com/milhidaka/95863906fe828198f47991c813dbe233
- *  https://github.com/OpenCyphal/libcanard/blob/636795f4bc395f56af8d2c61d3757b5e762bb9e5/canard.c#L811-L834
- */
-inline static float simsimd_uncompress_f16(unsigned short x) {
-    union float_or_unsigned_int_t {
-        float f;
-        unsigned int i;
-    };
-    unsigned int exponent = (x & 0x7C00) >> 10;
-    unsigned int mantissa = (x & 0x03FF) << 13;
-    union float_or_unsigned_int_t mantissa_union;
-    mantissa_union.f = (float)mantissa;
-    unsigned int v = (mantissa_union.i) >> 23;
-    union float_or_unsigned_int_t result_union;
-    result_union.i = (x & 0x8000) << 16 | (exponent != 0) * ((exponent + 112) << 23 | mantissa) |
-                     ((exponent == 0) & (mantissa != 0)) * ((v - 37) << 23 | ((mantissa << (150 - v)) & 0x007FE000));
-    return result_union.f;
-}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif

package/simsimd/javascript/bench.js

@@ -1,127 +0,0 @@
-const benchmark = require('benchmark');
-const math = require('mathjs');
-const usearch = require('usearch');
-const MetricKind = usearch.MetricKind;
-const simsimd = require("./dist/cjs/simsimd.js");
-
-// Assuming the vectors are of the same length
-function cosineDistance(a, b) {
-    let dotProduct = 0;
-    let magA = 0;
-    let magB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        magA += a[i] * a[i];
-        magB += b[i] * b[i];
-    }
-    return 1 - (dotProduct / (Math.sqrt(magA) * Math.sqrt(magB)));
-}
-
-function cosineDistanceMathJS(a, b) {
-    let dotProduct = math.dot(a, b);
-    let magA = math.sqrt(math.dot(a, a));
-    let magB = math.sqrt(math.dot(b, b));
-    return 1 - (dotProduct / (magA * magB));
-}
-
-// Generate random data for testing
-const dimensions = 1536;  // Adjust dimensions as needed
-const array1 = Array.from({ length: dimensions }, () => Math.random() * 100);
-const array2 = Array.from({ length: dimensions }, () => Math.random() * 100);
-const mathm1 = math.matrix(Array.from({ length: dimensions }, () => Math.random() * 100));
-const mathm2 = math.matrix(Array.from({ length: dimensions }, () => Math.random() * 100));
-const floatArray1 = new Float32Array(array1);
-const floatArray2 = new Float32Array(array2);
-const intArray1 = new Int8Array(array1);
-const intArray2 = new Int8Array(array2);
-
-// Generate random batch data for testing
-const batchSize = 1000;
-const matrix1 = Array.from({ length: dimensions * batchSize }, () => Math.random() * 100);
-const matrix2 = Array.from({ length: dimensions * batchSize }, () => Math.random() * 100);
-const floatMatrix1 = new Float32Array(matrix1);
-const floatMatrix2 = new Float32Array(matrix2);
-const intMatrix1 = new Int8Array(matrix1);
-const intMatrix2 = new Int8Array(matrix2);
-
-// Create benchmark suite
-const singleSuite = new benchmark.Suite('Single Vector Processing');
-const batchSuite = new benchmark.Suite('Batch Vector Processing');
-
-// Single-vector processing benchmarks
-singleSuite
-
-    // Pure JavaScript
-    .add('Array of Numbers', () => {
-        cosineDistance(array1, array2);
-    })
-    .add('TypedArray of Float32', () => {
-        cosineDistance(floatArray1, floatArray2);
-    })
-    .add('TypedArray of Int8', () => {
-        cosineDistance(intArray1, intArray2);
-    })
-
-    // Math JS
-    .add('Array of Numbers with MathJS', () => {
-        cosineDistanceMathJS(array1, array2);
-    })
-    .add('MathMatrix with MathJS', () => {
-        cosineDistanceMathJS(mathm1, mathm2);
-    })
-
-    // SimSIMD
-    .add('TypedArray of Float32 with SimSIMD', () => {
-        simsimd.cosine(floatArray1, floatArray2);
-    })
-    .add('TypedArray of Int8 with SimSIMD', () => {
-        simsimd.cosine(intArray1, intArray2);
-    })
-
-    .on('cycle', (event) => {
-        if (event.target.error) {
-            console.error(String(event.target.error));
-        } else {
-            console.log(String(event.target));
-        }
-    })
-    .on('complete', () => {
-        console.log('Fastest Single-Vector Processing is ' + singleSuite.filter('fastest').map('name'));
-    })
-    .run({
-        noCache: true,
-        async: false,
-    });
-
-// Batch-vector processing benchmarks
-batchSuite
-    .add('2D Array of Numbers', () => {
-        for (let i = 0; i < batchSize; i++) {
-            for (let j = 0; j < batchSize; j++) {
-                const start = i * dimensions;
-                const end = start + dimensions;
-                cosineDistance(matrix1.slice(start, end), matrix2.slice(start, end));
-            }
-        }
-    })
-    .add('2D TypedArray of Float32 with exact USearch', () => {
-        usearch.exactSearch(floatMatrix1, floatMatrix2, dimensions, 1, MetricKind.Cos);
-    })
-    .add('2D TypedArray of Int8 with exact USearch', () => {
-        usearch.exactSearch(intMatrix1, intMatrix2, dimensions, 1, MetricKind.Cos);
-    })
-    .on('cycle', (event) => {
-        if (event.target.error) {
-            console.error(String(event.target.error));
-        } else {
-            console.log(String(event.target));
-        }
-    })
-    .on('complete', () => {
-        console.log('Fastest Batch-Vector Processing is ' + batchSuite.filter('fastest').map('name'));
-    })
-    .run({
-        noCache: true,
-        async: false,
-    });
-

package/simsimd/javascript/fallback.ts

@@ -1,193 +0,0 @@
-/**
- * @brief Computes the inner distance of two vectors.
- * @param {Float32Array} a - The first vector.
- * @param {Float32Array} b - The second vector.
- * @returns {number} The inner distance of vectors a and b.
- */
-export function inner(a: Float32Array, b: Float32Array): number {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-
-  let result = 0;
-  for (let i = 0; i < a.length; i++) {
-    result += a[i] * b[i];
-  }
-  return 1 - result;
-}
-
-/**
- * @brief Computes the squared Euclidean distance between two vectors.
- * @param {Float32Array|Int8Array} a - The first vector.
- * @param {Float32Array|Int8Array} b - The second vector.
- * @returns {number} The squared Euclidean distance between vectors a and b.
- */
-export function sqeuclidean(
-  a: Float32Array | Int8Array,
-  b: Float32Array | Int8Array
-): number {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-
-  let result = 0;
-  for (let i = 0; i < a.length; i++) {
-    result += (a[i] - b[i]) * (a[i] - b[i]);
-  }
-  return result;
-}
-
-/**
- * @brief Computes the cosine distance between two vectors.
- * @param {Float32Array|Int8Array} a - The first vector.
- * @param {Float32Array|Int8Array} b - The second vector.
- * @returns {number} The cosine distance between vectors a and b.
- */
-export function cosine(
-  a: Float32Array | Int8Array,
-  b: Float32Array | Int8Array
-): number {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-
-  let dotProduct = 0;
-  let magnitudeA = 0;
-  let magnitudeB = 0;
-
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    magnitudeA += a[i] * a[i];
-    magnitudeB += b[i] * b[i];
-  }
-
-  magnitudeA = Math.sqrt(magnitudeA);
-  magnitudeB = Math.sqrt(magnitudeB);
-
-  if (magnitudeA === 0 || magnitudeB === 0) {
-    console.warn(
-      "Warning: One of the magnitudes is zero. Cosine similarity is undefined."
-    );
-    return 0;
-  }
-
-  return 1 - dotProduct / (magnitudeA * magnitudeB);
-}
-
-/**
- * @brief Computes the bitwise Hamming distance between two vectors.
- * @param {Uint8Array} a - The first vector.
- * @param {Uint8Array} b - The second vector.
- * @returns {number} The Hamming distance between vectors a and b.
- */
-export const hamming = (a: Uint8Array, b: Uint8Array): number => {
-  if (a.length !== b.length) {
-    throw new Error("Arrays must be of the same length");
-  }
-
-  let distance = 0;
-
-  for (let i = 0; i < a.length; i++) {
-    let xor = a[i] ^ b[i]; // XOR operation to find differing bits
-
-    // Count the number of set bits (differing bits)
-    while (xor > 0) {
-      distance += xor & 1;
-      xor >>= 1;
-    }
-  }
-
-  return distance;
-};
-
-/**
- * @brief Computes the bitwise Jaccard similarity coefficient between two vectors.
- * @param {Uint8Array} a - The first vector.
- * @param {Uint8Array} b - The second vector.
- * @returns {number} The Jaccard similarity coefficient between vectors a and b.
- */
-export const jaccard = (a: Uint8Array, b: Uint8Array): number => {
-  if (a.length !== b.length) {
-    throw new Error("Arrays must be of the same length");
-  }
-
-  let intersection = 0;
-  let union = 0;
-
-  for (let i = 0; i < a.length; i++) {
-    let ai = a[i];
-    let bi = b[i];
-
-    // Count the number of set bits in a AND b for intersection
-    let and = ai & bi;
-    while (and > 0) {
-      intersection += and & 1;
-      and >>= 1;
-    }
-
-    // Count the number of set bits in a OR b for union
-    let or = ai | bi;
-    while (or > 0) {
-      union += or & 1;
-      or >>= 1;
-    }
-  }
-
-  if (union === 0) return 0; // Avoid division by zero
-
-  return 1 - intersection / union;
-};
-
-/**
- * @brief Computes the kullbackleibler similarity coefficient between two vectors.
- * @param {Float32Array} a - The first vector.
- * @param {Float32Array} b - The second vector.
- * @returns {number} The Jaccard similarity coefficient between vectors a and b.
- */
-export const kullbackleibler = (a: Float32Array, b: Float32Array): number => {
-  if (a.length !== b.length) {
-    throw new Error("Arrays must be of the same length");
-  }
-
-  let divergence = 0.0;
-
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] > 0) {
-      if (b[i] === 0) {
-        throw new Error(
-          "Division by zero encountered in KL divergence calculation"
-        );
-      }
-      divergence += a[i] * Math.log(a[i] / b[i]);
-    }
-  }
-
-  return divergence;
-};
-
-/**
- * @brief Computes the jensenshannon similarity coefficient between two vectors.
- * @param {Float32Array} a - The first vector.
- * @param {Float32Array} b - The second vector.
- * @returns {number} The Jaccard similarity coefficient between vectors a and b.
- */
-export const jensenshannon = (p: Float32Array, q: Float32Array): number => {
-  if (p.length !== q.length) {
-    throw new Error("Arrays must be of the same length");
-  }
-
-  const m = p.map((value, index) => (value + q[index]) / 2);
-
-  const divergence = 0.5 * kullbackleibler(p, m) + 0.5 * kullbackleibler(q, m);
-  return Math.sqrt(divergence);
-};
-
-export default {
-  sqeuclidean,
-  cosine,
-  inner,
-  hamming,
-  jaccard,
-  kullbackleibler,
-  jensenshannon,
-};

package/simsimd/javascript/lib.c

@@ -1,102 +0,0 @@
-/**
- *  @file       lib.c
- *  @brief      JavaScript bindings for SimSIMD.
- *  @author     Ash Vardanian
- *  @date       October 18, 2023
- *
- *  @copyright  Copyright (c) 2023
- *  @see        NodeJS docs: https://nodejs.org/api/n-api.html
- */
-
-#include <node_api.h>        // `napi_*` functions
-#include <simsimd/simsimd.h> // `simsimd_*` functions
-
-/// @brief  Global variable that caches the CPU capabilities, and is computed just onc, when the module is loaded.
-simsimd_capability_t static_capabilities = simsimd_cap_serial_k;
-
-napi_value runAPI(napi_env env, napi_callback_info info, simsimd_metric_kind_t metric_kind) {
-    size_t argc = 2;
-    napi_value args[2];
-    napi_status status;
-
-    // Get callback info and ensure the argument count is correct
-    status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
-    if (status != napi_ok || argc != 2) {
-        napi_throw_error(env, NULL, "Wrong number of arguments");
-        return NULL;
-    }
-
-    // Obtain the typed arrays from the arguments
-    void *data_a, *data_b;
-    size_t length_a, length_b;
-    napi_typedarray_type type_a, type_b;
-    napi_status status_a, status_b;
-    status_a = napi_get_typedarray_info(env, args[0], &type_a, &length_a, &data_a, NULL, NULL);
-    status_b = napi_get_typedarray_info(env, args[1], &type_b, &length_b, &data_b, NULL, NULL);
-    if (status_a != napi_ok || status_b != napi_ok || type_a != type_b || length_a != length_b) {
-        napi_throw_error(env, NULL, "Both arguments must be typed arrays of matching types and dimensionality");
-        return NULL;
-    }
-    if (type_a != napi_float32_array && type_a != napi_int8_array && type_a != napi_uint8_array) {
-        napi_throw_error(env, NULL, "Only `float32`, `int8` and `uint8` arrays are supported in JavaScript bindings");
-        return NULL;
-    }
-
-    simsimd_datatype_t datatype = simsimd_datatype_unknown_k;
-    switch (type_a) {
-    case napi_float32_array: datatype = simsimd_datatype_f32_k; break;
-    case napi_int8_array: datatype = simsimd_datatype_i8_k; break;
-    case napi_uint8_array: datatype = simsimd_datatype_b8_k; break;
-    default: break;
-    }
-
-    simsimd_metric_punned_t metric = NULL;
-    simsimd_capability_t capability = simsimd_cap_serial_k;
-    simsimd_find_metric_punned(metric_kind, datatype, static_capabilities, simsimd_cap_any_k, &metric, &capability);
-    if (metric == NULL) {
-        napi_throw_error(env, NULL, "Unsupported datatype");
-        return NULL;
-    }
-
-    simsimd_f32_t result = metric(data_a, data_b, length_a, length_b);
-
-    // Convert the result to a JavaScript number
-    napi_value js_result;
-    status = napi_create_double(env, result, &js_result);
-    if (status != napi_ok)
-        return NULL;
-
-    return js_result;
-}
-
-napi_value l2sqAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_sqeuclidean_k); }
-napi_value cosAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_cosine_k); }
-napi_value ipAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_ip_k); }
-napi_value klAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_kl_k); }
-napi_value jsAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_js_k); }
-napi_value hammingAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_hamming_k); }
-napi_value jaccardAPI(napi_env env, napi_callback_info info) { return runAPI(env, info, simsimd_metric_jaccard_k); }
-
-napi_value Init(napi_env env, napi_value exports) {
-
-    // Define an array of property descriptors
-    napi_property_descriptor sqeuclideanDesc = {"sqeuclidean", 0, l2sqAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor innerDesc = {"inner", 0, ipAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor cosineDesc = {"cosine", 0, cosAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor hammingDesc = {"hamming", 0, hammingAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor jaccardDesc = {"jaccard", 0, jaccardAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor klDesc = {"kullbackleibler", 0, klAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor jsDesc = {"jensenshannon", 0, jsAPI, 0, 0, 0, napi_default, 0};
-    napi_property_descriptor properties[] = {
-        sqeuclideanDesc, innerDesc, cosineDesc, hammingDesc, jaccardDesc, klDesc, jsDesc,
-    };
-
-    // Define the properties on the `exports` object
-    size_t propertyCount = sizeof(properties) / sizeof(properties[0]);
-    napi_define_properties(env, exports, propertyCount, properties);
-
-    static_capabilities = simsimd_capabilities();
-    return exports;
-}
-
-NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

package/simsimd/javascript/node-gyp-build.d.ts

@@ -1 +0,0 @@
-declare module "node-gyp-build";