@danielsimonjr/mathts-functions 0.1.2 → 0.2.1

package/dist/chunk-KX4KB4LV.js

@@ -0,0 +1,644 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/wasm/integrity.ts
+var ALGO = "sha384";
+async function sha384OfBuffer(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+  let digest;
+  if (isNode) {
+    const { createHash } = await import("crypto");
+    const hash = createHash(ALGO);
+    hash.update(bytes);
+    digest = new Uint8Array(hash.digest());
+  } else {
+    const copy = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(copy).set(bytes);
+    const out = await crypto.subtle.digest("SHA-384", copy);
+    digest = new Uint8Array(out);
+  }
+  let binary = "";
+  for (let i = 0; i < digest.length; i++) binary += String.fromCharCode(digest[i]);
+  const b64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(digest).toString("base64");
+  return `sha384-${b64}`;
+}
+async function loadWasmManifest(wasmPath) {
+  const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+  const manifestPath = wasmPath.replace(/[^/\\]+$/, "wasm-manifest.json");
+  try {
+    if (isNode) {
+      const fs = await import("fs");
+      const { promisify } = await import("util");
+      const readFile = promisify(fs.readFile);
+      const text = await readFile(manifestPath, "utf8");
+      return JSON.parse(text);
+    } else {
+      const res = await fetch(manifestPath);
+      if (!res.ok) return null;
+      return await res.json();
+    }
+  } catch {
+    return null;
+  }
+}
+async function verifyWasmIntegrity(buffer, wasmPath, options = {}) {
+  const fileName = wasmPath.split(/[/\\]/).pop() || wasmPath;
+  const manifest = options.manifest !== void 0 ? options.manifest : await loadWasmManifest(wasmPath);
+  if (!manifest) {
+    if (options.required) {
+      throw new Error(
+        `WASM integrity check failed: no manifest at sibling of "${wasmPath}" (required)`
+      );
+    }
+    if (typeof console !== "undefined") {
+      console.warn(
+        `[wasm-integrity] no manifest found beside "${wasmPath}"; skipping SHA-384 verification (set options.required=true to fail closed)`
+      );
+    }
+    return;
+  }
+  const expected = manifest[fileName];
+  if (!expected) {
+    if (options.required) {
+      throw new Error(`WASM integrity check failed: manifest has no entry for "${fileName}"`);
+    }
+    return;
+  }
+  const actual = await sha384OfBuffer(buffer);
+  if (actual !== expected) {
+    throw new Error(
+      `WASM integrity check failed for "${fileName}": expected ${expected}, got ${actual}`
+    );
+  }
+}
+
+// src/wasm/WasmLoader.ts
+var WasmLoader = class _WasmLoader {
+  static instance = null;
+  wasmModule = null;
+  compiledModule = null;
+  loading = null;
+  isNode;
+  lastMetrics = null;
+  // Memory pool for reusable allocations
+  float64Pool = [];
+  int32Pool = [];
+  maxPoolSize = 32;
+  poolSizeThreshold = 1024 * 1024;
+  // 1MB max per pool entry
+  constructor() {
+    this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+  }
+  static getInstance() {
+    if (!_WasmLoader.instance) {
+      _WasmLoader.instance = new _WasmLoader();
+    }
+    return _WasmLoader.instance;
+  }
+  /**
+   * Load the WASM module
+   */
+  async load(wasmPath) {
+    if (this.wasmModule) {
+      return this.wasmModule;
+    }
+    if (this.loading) {
+      return this.loading;
+    }
+    this.loading = this.loadModule(wasmPath);
+    this.wasmModule = await this.loading;
+    return this.wasmModule;
+  }
+  /**
+   * Precompile the WASM module without instantiation
+   * Useful for build-time or startup optimization
+   */
+  async precompile(wasmPath) {
+    if (this.compiledModule) return;
+    const path = wasmPath || await this.getDefaultWasmPath();
+    const startTime = performance.now();
+    if (this.isNode) {
+      const fs = await import("fs");
+      const { promisify } = await import("util");
+      const readFile = promisify(fs.readFile);
+      const buffer = await readFile(path);
+      await verifyWasmIntegrity(buffer, path);
+      this.compiledModule = await WebAssembly.compile(buffer);
+    } else {
+      const manifest = await loadWasmManifest(path);
+      if (!manifest && typeof WebAssembly.compileStreaming === "function") {
+        this.compiledModule = await WebAssembly.compileStreaming(fetch(path));
+      } else {
+        const response = await fetch(path);
+        const buffer = await response.arrayBuffer();
+        await verifyWasmIntegrity(buffer, path, { manifest });
+        this.compiledModule = await WebAssembly.compile(buffer);
+      }
+    }
+    this.lastMetrics = {
+      fileReadMs: 0,
+      compileMs: performance.now() - startTime,
+      instantiateMs: 0,
+      totalMs: performance.now() - startTime,
+      fromCache: false
+    };
+  }
+  async loadModule(wasmPath) {
+    const path = wasmPath || await this.getDefaultWasmPath();
+    const totalStart = performance.now();
+    if (this.compiledModule) {
+      const instStart = performance.now();
+      const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+      this.lastMetrics = {
+        fileReadMs: 0,
+        compileMs: 0,
+        instantiateMs: performance.now() - instStart,
+        totalMs: performance.now() - totalStart,
+        fromCache: true
+      };
+      return instance.exports;
+    }
+    if (this.isNode) {
+      return this.loadNodeWasm(path, totalStart);
+    } else {
+      return this.loadBrowserWasm(path, totalStart);
+    }
+  }
+  /**
+   * Get the WASM binary path based on the selected backend.
+   * Set MATHTS_WASM_BACKEND=assemblyscript to use the AS binary.
+   * Default is Rust (after migration cutover).
+   *
+   * Filenames were renamed from mathjs.wasm / mathjs-as.wasm during the
+   * mathjs-to-MathTS rebrand; the legacy MATHJS_WASM_BACKEND env var
+   * still works for one release for backward compatibility.
+   *
+   * Returns an async result because the Node branch dynamically imports
+   * `node:url` (fileURLToPath) so the path is resolved relative to this
+   * source file's location rather than process.cwd().
+   */
+  async getDefaultWasmPath() {
+    const useAS = typeof process !== "undefined" && (process.env?.MATHTS_WASM_BACKEND === "assemblyscript" || process.env?.MATHJS_WASM_BACKEND === "assemblyscript");
+    const wasmFile = useAS ? "mathts-as.wasm" : "mathts.wasm";
+    const resolvedUrl = new URL(`../../../lib/wasm/${wasmFile}`, import.meta.url);
+    if (this.isNode) {
+      const { fileURLToPath } = await import("url");
+      return fileURLToPath(resolvedUrl);
+    }
+    return resolvedUrl.href;
+  }
+  async loadNodeWasm(path, totalStart) {
+    const fs = await import("fs");
+    const { promisify } = await import("util");
+    const readFile = promisify(fs.readFile);
+    const readStart = performance.now();
+    const buffer = await readFile(path);
+    const readEnd = performance.now();
+    await verifyWasmIntegrity(buffer, path);
+    const compileStart = performance.now();
+    this.compiledModule = await WebAssembly.compile(buffer);
+    const compileEnd = performance.now();
+    const instStart = performance.now();
+    const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+    const instEnd = performance.now();
+    this.lastMetrics = {
+      fileReadMs: readEnd - readStart,
+      compileMs: compileEnd - compileStart,
+      instantiateMs: instEnd - instStart,
+      totalMs: performance.now() - totalStart,
+      fromCache: false
+    };
+    return instance.exports;
+  }
+  async loadBrowserWasm(path, totalStart) {
+    const manifest = await loadWasmManifest(path);
+    if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
+      const instStart2 = performance.now();
+      const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
+      this.compiledModule = result.module;
+      this.lastMetrics = {
+        fileReadMs: 0,
+        // Combined with compile in streaming
+        compileMs: 0,
+        // Combined in streaming
+        instantiateMs: performance.now() - instStart2,
+        totalMs: performance.now() - totalStart,
+        fromCache: false
+      };
+      return result.instance.exports;
+    }
+    const readStart = performance.now();
+    const response = await fetch(path);
+    const buffer = await response.arrayBuffer();
+    const readEnd = performance.now();
+    await verifyWasmIntegrity(buffer, path, { manifest });
+    const compileStart = performance.now();
+    this.compiledModule = await WebAssembly.compile(buffer);
+    const compileEnd = performance.now();
+    const instStart = performance.now();
+    const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+    const instEnd = performance.now();
+    this.lastMetrics = {
+      fileReadMs: readEnd - readStart,
+      compileMs: compileEnd - compileStart,
+      instantiateMs: instEnd - instStart,
+      totalMs: performance.now() - totalStart,
+      fromCache: false
+    };
+    return instance.exports;
+  }
+  getImports() {
+    return {
+      env: {
+        abort: (msg, file, line, column) => {
+          console.error("WASM abort", { msg, file, line, column });
+          throw new Error("WASM abort");
+        },
+        seed: () => Date.now()
+      },
+      Math,
+      Date
+    };
+  }
+  /**
+   * Get the loaded WASM module
+   */
+  getModule() {
+    return this.wasmModule;
+  }
+  /**
+   * Get the compiled WASM module (for caching/serialization)
+   */
+  getCompiledModule() {
+    return this.compiledModule;
+  }
+  /**
+   * Check if WASM is loaded
+   */
+  isLoaded() {
+    return this.wasmModule !== null;
+  }
+  /**
+   * Check if WASM is precompiled
+   */
+  isPrecompiled() {
+    return this.compiledModule !== null;
+  }
+  /**
+   * Get loading performance metrics
+   */
+  getLoadingMetrics() {
+    return this.lastMetrics;
+  }
+  /**
+   * Allocate Float64Array in WASM memory
+   * Uses memory pooling for frequently reused sizes
+   */
+  allocateFloat64Array(data) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const length = data.length;
+    const byteLength = length * 8;
+    let ptr;
+    if (byteLength <= this.poolSizeThreshold) {
+      const poolEntry = this.getFromPool(this.float64Pool, byteLength);
+      if (poolEntry) {
+        ptr = poolEntry.ptr;
+        poolEntry.inUse = true;
+      } else {
+        ptr = module.__new(byteLength, 2);
+      }
+    } else {
+      ptr = module.__new(byteLength, 2);
+    }
+    const array = new Float64Array(module.memory.buffer, ptr, length);
+    array.set(data);
+    return { ptr, array };
+  }
+  /**
+   * Allocate Float64Array without copying data (for output buffers)
+   */
+  allocateFloat64ArrayEmpty(length) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const byteLength = length * 8;
+    let ptr;
+    if (byteLength <= this.poolSizeThreshold) {
+      const poolEntry = this.getFromPool(this.float64Pool, byteLength);
+      if (poolEntry) {
+        ptr = poolEntry.ptr;
+        poolEntry.inUse = true;
+      } else {
+        ptr = module.__new(byteLength, 2);
+      }
+    } else {
+      ptr = module.__new(byteLength, 2);
+    }
+    const array = new Float64Array(module.memory.buffer, ptr, length);
+    return { ptr, array };
+  }
+  /**
+   * Allocate Int32Array in WASM memory
+   * Uses memory pooling for frequently reused sizes
+   */
+  allocateInt32Array(data) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const length = data.length;
+    const byteLength = length * 4;
+    let ptr;
+    if (byteLength <= this.poolSizeThreshold) {
+      const poolEntry = this.getFromPool(this.int32Pool, byteLength);
+      if (poolEntry) {
+        ptr = poolEntry.ptr;
+        poolEntry.inUse = true;
+      } else {
+        ptr = module.__new(byteLength, 1);
+      }
+    } else {
+      ptr = module.__new(byteLength, 1);
+    }
+    const array = new Int32Array(module.memory.buffer, ptr, length);
+    array.set(data);
+    return { ptr, array };
+  }
+  /**
+   * Allocate Int32Array without copying data (for output buffers)
+   */
+  allocateInt32ArrayEmpty(length) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const byteLength = length * 4;
+    let ptr;
+    if (byteLength <= this.poolSizeThreshold) {
+      const poolEntry = this.getFromPool(this.int32Pool, byteLength);
+      if (poolEntry) {
+        ptr = poolEntry.ptr;
+        poolEntry.inUse = true;
+      } else {
+        ptr = module.__new(byteLength, 1);
+      }
+    } else {
+      ptr = module.__new(byteLength, 1);
+    }
+    const array = new Int32Array(module.memory.buffer, ptr, length);
+    return { ptr, array };
+  }
+  /**
+   * Get a suitable entry from the memory pool
+   */
+  getFromPool(pool, requestedSize) {
+    let bestFit = null;
+    let bestFitWaste = Infinity;
+    for (const entry of pool) {
+      if (!entry.inUse && entry.size >= requestedSize) {
+        const waste = entry.size - requestedSize;
+        if (waste < bestFitWaste && entry.size <= requestedSize * 2) {
+          bestFit = entry;
+          bestFitWaste = waste;
+        }
+      }
+    }
+    return bestFit;
+  }
+  /**
+   * Return allocation to pool for reuse
+   */
+  release(ptr, isFloat64 = true) {
+    const pool = isFloat64 ? this.float64Pool : this.int32Pool;
+    const entry = pool.find((e) => e.ptr === ptr);
+    if (entry) {
+      entry.inUse = false;
+      return;
+    }
+    this.free(ptr);
+  }
+  /**
+   * Free allocated memory (immediate, bypasses pool)
+   */
+  free(ptr) {
+    const module = this.wasmModule;
+    if (!module) return;
+    this.float64Pool = this.float64Pool.filter((e) => e.ptr !== ptr);
+    this.int32Pool = this.int32Pool.filter((e) => e.ptr !== ptr);
+    module.__unpin(ptr);
+  }
+  /**
+   * Clear the memory pool
+   */
+  clearPool() {
+    const module = this.wasmModule;
+    if (!module) return;
+    for (const entry of this.float64Pool) {
+      module.__unpin(entry.ptr);
+    }
+    for (const entry of this.int32Pool) {
+      module.__unpin(entry.ptr);
+    }
+    this.float64Pool = [];
+    this.int32Pool = [];
+  }
+  /**
+   * Get pool statistics
+   */
+  getPoolStats() {
+    const f64InUse = this.float64Pool.filter((e) => e.inUse).length;
+    const f64Bytes = this.float64Pool.reduce((sum, e) => sum + e.size, 0);
+    const i32InUse = this.int32Pool.filter((e) => e.inUse).length;
+    const i32Bytes = this.int32Pool.reduce((sum, e) => sum + e.size, 0);
+    return {
+      float64: {
+        total: this.float64Pool.length,
+        inUse: f64InUse,
+        totalBytes: f64Bytes
+      },
+      int32: {
+        total: this.int32Pool.length,
+        inUse: i32InUse,
+        totalBytes: i32Bytes
+      }
+    };
+  }
+  /**
+   * Run garbage collection
+   */
+  collect() {
+    const module = this.wasmModule;
+    if (!module) return;
+    module.__collect();
+  }
+  /**
+   * Reset the loader (for testing)
+   */
+  reset() {
+    this.clearPool();
+    this.wasmModule = null;
+    this.compiledModule = null;
+    this.loading = null;
+    this.lastMetrics = null;
+  }
+};
+var wasmLoader = WasmLoader.getInstance();
+
+// src/wasm/sort/wasm-bridge.ts
+var WASM_SORT_THRESHOLD = 16384;
+function getWasm() {
+  try {
+    return wasmLoader.getModule();
+  } catch {
+    return null;
+  }
+}
+function cmpNanLast(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  if (a === b) return 0;
+  if (Number.isNaN(a) && Number.isNaN(b)) return 0;
+  if (Number.isNaN(a)) return 1;
+  return -1;
+}
+function sortF64JS(data) {
+  const arr = Array.from(data);
+  arr.sort(cmpNanLast);
+  for (let i = 0; i < arr.length; i++) data[i] = arr[i];
+  return data;
+}
+function argsortF64JS(data) {
+  const n = data.length;
+  const indices = new Int32Array(n);
+  for (let i = 0; i < n; i++) indices[i] = i;
+  const arr = Array.from(indices);
+  arr.sort((i, j) => cmpNanLast(data[i], data[j]));
+  for (let k = 0; k < n; k++) indices[k] = arr[k];
+  return indices;
+}
+function rankF64JS(data) {
+  const n = data.length;
+  const argsort = argsortF64JS(data);
+  const rank = new Int32Array(n);
+  for (let k = 0; k < n; k++) rank[argsort[k]] = k;
+  return rank;
+}
+function sortF64Dispatch(data) {
+  const n = data.length;
+  if (n >= WASM_SORT_THRESHOLD) {
+    const wasm = getWasm();
+    if (wasm) {
+      const rustFn = wasm["sort_f64"];
+      if (typeof rustFn === "function") {
+        try {
+          const alloc = wasmLoader.allocateFloat64Array(data);
+          try {
+            const ret = rustFn(alloc.ptr, n);
+            if (ret >= 0) {
+              data.set(alloc.array);
+              return data;
+            }
+          } finally {
+            wasmLoader.free(alloc.ptr);
+          }
+        } catch {
+        }
+      }
+      const asFn = wasm["sort_f64"];
+      if (typeof asFn === "function") {
+        try {
+          asFn(data);
+          return data;
+        } catch {
+        }
+      }
+    }
+  }
+  return sortF64JS(data);
+}
+function argsortF64Dispatch(data) {
+  const n = data.length;
+  if (n >= WASM_SORT_THRESHOLD) {
+    const wasm = getWasm();
+    if (wasm) {
+      const rustFn = wasm["argsort_f64"];
+      if (typeof rustFn === "function") {
+        try {
+          const inAlloc = wasmLoader.allocateFloat64Array(data);
+          const outAlloc = wasmLoader.allocateInt32ArrayEmpty(n);
+          try {
+            const ret = rustFn(
+              inAlloc.ptr,
+              n,
+              outAlloc.ptr
+            );
+            if (ret >= 0) {
+              return new Int32Array(outAlloc.array);
+            }
+          } finally {
+            wasmLoader.free(inAlloc.ptr);
+            wasmLoader.free(outAlloc.ptr);
+          }
+        } catch {
+        }
+      }
+      const asFn = wasm["argsort_f64"];
+      if (typeof asFn === "function") {
+        try {
+          return asFn(data);
+        } catch {
+        }
+      }
+    }
+  }
+  return argsortF64JS(data);
+}
+function rankF64Dispatch(data) {
+  const n = data.length;
+  if (n >= WASM_SORT_THRESHOLD) {
+    const wasm = getWasm();
+    if (wasm) {
+      const rustFn = wasm["rank_f64"];
+      if (typeof rustFn === "function") {
+        try {
+          const inAlloc = wasmLoader.allocateFloat64Array(data);
+          const outAlloc = wasmLoader.allocateInt32ArrayEmpty(n);
+          try {
+            const ret = rustFn(
+              inAlloc.ptr,
+              n,
+              outAlloc.ptr
+            );
+            if (ret >= 0) {
+              return new Int32Array(outAlloc.array);
+            }
+          } finally {
+            wasmLoader.free(inAlloc.ptr);
+            wasmLoader.free(outAlloc.ptr);
+          }
+        } catch {
+        }
+      }
+      const asFn = wasm["rank_f64"];
+      if (typeof asFn === "function") {
+        try {
+          return asFn(data);
+        } catch {
+        }
+      }
+    }
+  }
+  return rankF64JS(data);
+}
+
+export {
+  __export,
+  wasmLoader,
+  WASM_SORT_THRESHOLD,
+  sortF64JS,
+  argsortF64JS,
+  rankF64JS,
+  sortF64Dispatch,
+  argsortF64Dispatch,
+  rankF64Dispatch
+};