@danielsimonjr/mathts-functions 0.68.4 → 0.69.0

package/dist/chunk-5A2EZLXV.js

@@ -1,597 +0,0 @@
-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
-import {
-  sha384OfBuffer,
-  loadWasmManifest,
-  verifyWasmIntegrity
-} from "@danielsimonjr/mathts-core/internal";
-
-// src/wasm/resolve.ts
-import { resolvePackagedWasm, defaultWasmLocation } from "@danielsimonjr/mathts-core/internal";
-async function resolveBrowserWasm(metaUrl, wasmFile) {
-  let dir = new URL(".", metaUrl);
-  for (let depth = 0; depth < 8; depth++) {
-    const candidates = [new URL(`wasm/${wasmFile}`, dir), new URL(`dist/wasm/${wasmFile}`, dir)];
-    for (const candidate of candidates) {
-      try {
-        const res = await fetch(candidate.href, { method: "HEAD" });
-        if (res.ok) return candidate.href;
-      } catch {
-      }
-    }
-    const parent = new URL("../", dir);
-    if (parent.href === dir.href) break;
-    dir = parent;
-  }
-  return new URL(`./wasm/${wasmFile}`, metaUrl).href;
-}
-
-// src/wasm/WasmLoader.ts
-var WasmLoader = class _WasmLoader {
-  static instance = null;
-  wasmModule = null;
-  compiledModule = null;
-  loading = null;
-  isNode;
-  lastMetrics = null;
-  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);
-    try {
-      this.wasmModule = await this.loading;
-    } catch (error) {
-      this.compiledModule = null;
-      throw error;
-    } finally {
-      this.loading = null;
-    }
-    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.
-   *
-   * AssemblyScript is the sole WASM backend (`mathts-as.wasm`); the legacy
-   * native WASM toolchain was removed (migration complete 2026-06-26).
-   *
-   * 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(). The browser branch
-   * probes candidate URLs with `fetch(..., { method: 'HEAD' })` for the same
-   * reason Node walks the filesystem — see {@link resolveBrowserWasm}.
-   */
-  async getDefaultWasmPath() {
-    const wasmFile = "mathts-as.wasm";
-    if (this.isNode) {
-      const packaged = await resolvePackagedWasm(import.meta.url, wasmFile);
-      if (packaged) return packaged;
-      return defaultWasmLocation(import.meta.url, wasmFile);
-    }
-    return resolveBrowserWasm(import.meta.url, wasmFile);
-  }
-  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;
-  }
-  /**
-   * Run garbage collection
-   */
-  collect() {
-    const module = this.wasmModule;
-    if (!module) return;
-    module.__collect();
-  }
-  /**
-   * Reset the loader (for testing)
-   */
-  reset() {
-    this.wasmModule = null;
-    this.compiledModule = null;
-    this.loading = null;
-    this.lastMetrics = null;
-  }
-};
-var wasmLoader = WasmLoader.getInstance();
-var INTEGRITY_FAILURE = "WASM integrity check failed";
-async function loadWasm(wasmPath) {
-  try {
-    await wasmLoader.load(wasmPath);
-    return true;
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith(INTEGRITY_FAILURE)) throw error;
-    return false;
-  }
-}
-function isWasmLoaded() {
-  return wasmLoader.isLoaded();
-}
-
-// src/wasm/policy.ts
-var WASM_DISPATCH_POLICY = {
-  // Element-wise (public `abs`, `sin`, ... on a Float64Array).
-  array_abs_ptr: { min: 1024 },
-  // 0.76/0.55 · 0.44/0.42 · 0.54/0.54 · 0.49/0.71
-  array_log10_ptr: { min: 1024 },
-  // 0.89/0.82 · 0.70/0.77 · 0.70/0.72 · 0.76/0.83
-  array_sin_ptr: { min: 1024, max: 131072 },
-  // 0.76/0.77 · 0.72/0.75 · (0.92/0.81 · 0.79/0.96)
-  array_log1p_ptr: { min: 1024, max: 16384 },
-  // 0.82/0.88 · (1.09/1.24 ...)
-  array_cos_ptr: { min: 16384 },
-  // (1.54/0.79) · 0.64/0.61 · 0.62/0.62 · 0.79/0.69
-  array_atanh_ptr: { min: 16384 },
-  // (0.93/0.85) · 0.70/0.73 · 0.77/0.78 · 0.81/0.83
-  array_log_ptr: { min: 16384 },
-  // (0.92/0.86) · 0.80/0.77 · 0.80/0.79 · 0.84/0.83
-  array_sec_ptr: { min: 16384, max: 1048576 },
-  // 0.76/0.79 · 0.76/0.83 · (0.90/0.88)
-  // A fused chain keeps its data in WASM memory between ops: (sin, exp) 0.36-0.49 and
-  // (tanh, expm1), both of which lose alone, 0.64-0.77, at every size.
-  fused_chain: { min: 1024 },
-  // Least-squares fits (public polyFit / chebyshevFit / legendreFit): 0.34-0.67.
-  poly_fit_f64: { min: 1024 },
-  cheb_fit_f64: { min: 1024 },
-  legendre_fit_f64: { min: 1024 },
-  // Only the largest measured size wins: lgamma 0.77/0.78, sort (median, quantile)
-  // 0.78/0.81 and 0.77/0.79 at 1M; 131K was 0.90-1.05.
-  lgamma_f64: { min: 1048576 },
-  sort_f64: { min: 1048576 }
-};
-var overrides = null;
-function wasmPolicyAllows(kernel, n) {
-  const own = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
-  const band = overrides !== null && own(overrides, kernel) ? overrides[kernel] : overrides !== null && own(overrides, "*") ? overrides["*"] : WASM_DISPATCH_POLICY[kernel];
-  return band != null && n >= band.min && (band.max === void 0 || n < band.max);
-}
-
-// src/wasm/bridges/common.ts
-function getWasm() {
-  try {
-    return wasmLoader.getModule();
-  } catch {
-    return null;
-  }
-}
-function isAsWasm(wasm) {
-  return !!wasm && typeof wasm["array_sin_ptr"] === "function";
-}
-var scratchBase = -1;
-function ensureScratch(mem, need) {
-  if (scratchBase < 0) scratchBase = mem.buffer.byteLength;
-  if (scratchBase + need > mem.buffer.byteLength) {
-    mem.grow(Math.ceil((scratchBase + need - mem.buffer.byteLength) / 65536));
-  }
-  return scratchBase;
-}
-function runUnaryPtr(mem, fn, xs) {
-  const n = xs.length;
-  try {
-    const need = 2 * n * 8;
-    const base = ensureScratch(mem, need);
-    const inOff = base;
-    const outOff = base + n * 8;
-    new Float64Array(mem.buffer, inOff, n).set(xs);
-    fn(inOff, outOff, n);
-    const result = new Float64Array(n);
-    result.set(new Float64Array(mem.buffer, outOff, n));
-    return result;
-  } catch {
-    return null;
-  }
-}
-function runChainPtr(mem, fns, xs) {
-  const n = xs.length;
-  try {
-    const need = 2 * n * 8;
-    const base = ensureScratch(mem, need);
-    const bufA = base;
-    const bufB = base + n * 8;
-    new Float64Array(mem.buffer, bufA, n).set(xs);
-    let cur = bufA;
-    let other = bufB;
-    for (const fn of fns) {
-      fn(cur, other, n);
-      const t = cur;
-      cur = other;
-      other = t;
-    }
-    const result = new Float64Array(n);
-    result.set(new Float64Array(mem.buffer, cur, n));
-    return result;
-  } catch {
-    return null;
-  }
-}
-var AS_ID_ARRAY_BUFFER = 1;
-var AS_ID_FLOAT64_ARRAY = 5;
-var AS_ID_INT32_ARRAY = 6;
-var AS_HEADER_BYTES = 12;
-function resetAsHeap(mod) {
-  if (typeof mod.heap_reset === "function") mod.heap_reset();
-}
-function asAllocHeader(mod, byteLength, typeId) {
-  const bufferPtr = mod.__pin(mod.__new(byteLength, AS_ID_ARRAY_BUFFER)) >>> 0;
-  const headerPtr = mod.__new(AS_HEADER_BYTES, typeId) >>> 0;
-  mod.__pin(headerPtr);
-  const dv = new DataView(mod.memory.buffer);
-  dv.setUint32(headerPtr + 0, bufferPtr, true);
-  dv.setUint32(headerPtr + 4, bufferPtr, true);
-  dv.setUint32(headerPtr + 8, byteLength, true);
-  return { headerPtr, bufferPtr };
-}
-function asUnpin(mod, a) {
-  mod.__unpin(a.headerPtr);
-  mod.__unpin(a.bufferPtr);
-}
-function asReadReturnedF64(mod, headerPtr) {
-  const dv = new DataView(mod.memory.buffer);
-  const dataStart = dv.getUint32((headerPtr >>> 0) + 4, true);
-  const byteLength = dv.getUint32((headerPtr >>> 0) + 8, true);
-  return new Float64Array(new Float64Array(mod.memory.buffer, dataStart, byteLength >>> 3));
-}
-function asReadReturnedI32(mod, headerPtr) {
-  const dv = new DataView(mod.memory.buffer);
-  const dataStart = dv.getUint32((headerPtr >>> 0) + 4, true);
-  const byteLength = dv.getUint32((headerPtr >>> 0) + 8, true);
-  return new Int32Array(new Int32Array(mod.memory.buffer, dataStart, byteLength >>> 2));
-}
-function withAsF64(wasm, inputs, body) {
-  const mod = wasm;
-  if (typeof mod.__new !== "function" || typeof mod.__unpin !== "function") return null;
-  const allocs = [];
-  try {
-    const headers = [];
-    for (const arr of inputs) {
-      const a = asAllocHeader(mod, arr.length * 8, AS_ID_FLOAT64_ARRAY);
-      new Float64Array(mod.memory.buffer, a.bufferPtr, arr.length).set(arr);
-      allocs.push(a);
-      headers.push(a.headerPtr);
-    }
-    return body(mod, headers);
-  } catch {
-    return null;
-  } finally {
-    for (const a of allocs) {
-      try {
-        asUnpin(mod, a);
-      } catch {
-      }
-    }
-    try {
-      resetAsHeap(mod);
-    } catch {
-    }
-  }
-}
-function withAsI32(wasm, inputs, body) {
-  const mod = wasm;
-  if (typeof mod.__new !== "function" || typeof mod.__unpin !== "function") return null;
-  const allocs = [];
-  try {
-    const headers = [];
-    for (const arr of inputs) {
-      const a = asAllocHeader(mod, arr.length * 4, AS_ID_INT32_ARRAY);
-      new Int32Array(mod.memory.buffer, a.bufferPtr, arr.length).set(arr);
-      allocs.push(a);
-      headers.push(a.headerPtr);
-    }
-    return body(mod, headers);
-  } catch {
-    return null;
-  } finally {
-    for (const a of allocs) {
-      try {
-        asUnpin(mod, a);
-      } catch {
-      }
-    }
-    try {
-      resetAsHeap(mod);
-    } catch {
-    }
-  }
-}
-function makeUnaryArrayDispatch(cfg) {
-  return (xs) => {
-    if (xs.length >= cfg.threshold && wasmPolicyAllows(cfg.name, xs.length)) {
-      const wasm = getWasm();
-      if (wasm && isAsWasm(wasm)) {
-        const out = withAsF64(
-          wasm,
-          [xs],
-          (mod, [h]) => asReadReturnedF64(mod, mod[cfg.name](h))
-        );
-        if (out) return out;
-      }
-    }
-    return cfg.js(xs);
-  };
-}
-
-// src/wasm/sort/wasm-bridge.ts
-var WASM_SORT_THRESHOLD = 16384;
-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 && wasmPolicyAllows("sort_f64", n)) {
-    const wasm = getWasm();
-    if (wasm && isAsWasm(wasm)) {
-      try {
-        const sorted = withAsF64(
-          wasm,
-          [data],
-          (mod, [h]) => asReadReturnedF64(mod, mod["sort_f64"](h))
-        );
-        if (sorted && sorted.length === n) {
-          data.set(sorted);
-          return data;
-        }
-      } catch {
-      }
-    }
-  }
-  return sortF64JS(data);
-}
-function argsortF64Dispatch(data) {
-  const n = data.length;
-  if (n >= WASM_SORT_THRESHOLD && wasmPolicyAllows("argsort_f64", n)) {
-    const wasm = getWasm();
-    if (wasm && isAsWasm(wasm)) {
-      try {
-        const idx = withAsF64(
-          wasm,
-          [data],
-          (mod, [h]) => asReadReturnedI32(mod, mod["argsort_f64"](h))
-        );
-        if (idx && idx.length === n) return idx;
-      } catch {
-      }
-    }
-  }
-  return argsortF64JS(data);
-}
-function rankF64Dispatch(data) {
-  const n = data.length;
-  if (n >= WASM_SORT_THRESHOLD && wasmPolicyAllows("rank_f64", n)) {
-    const wasm = getWasm();
-    if (wasm && isAsWasm(wasm)) {
-      try {
-        const ranks = withAsF64(
-          wasm,
-          [data],
-          (mod, [h]) => asReadReturnedI32(mod, mod["rank_f64"](h))
-        );
-        if (ranks && ranks.length === n) return ranks;
-      } catch {
-      }
-    }
-  }
-  return rankF64JS(data);
-}
-
-export {
-  __export,
-  loadWasm,
-  isWasmLoaded,
-  wasmPolicyAllows,
-  getWasm,
-  isAsWasm,
-  runUnaryPtr,
-  runChainPtr,
-  asReadReturnedF64,
-  asReadReturnedI32,
-  withAsF64,
-  withAsI32,
-  makeUnaryArrayDispatch,
-  WASM_SORT_THRESHOLD,
-  sortF64JS,
-  argsortF64JS,
-  rankF64JS,
-  sortF64Dispatch,
-  argsortF64Dispatch,
-  rankF64Dispatch
-};

package/dist/wasm-bridge-74YOKWIS.js

@@ -1,18 +0,0 @@
-import {
-  WASM_SORT_THRESHOLD,
-  argsortF64Dispatch,
-  argsortF64JS,
-  rankF64Dispatch,
-  rankF64JS,
-  sortF64Dispatch,
-  sortF64JS
-} from "./chunk-5A2EZLXV.js";
-export {
-  WASM_SORT_THRESHOLD,
-  argsortF64Dispatch,
-  argsortF64JS,
-  rankF64Dispatch,
-  rankF64JS,
-  sortF64Dispatch,
-  sortF64JS
-};