@danielsimonjr/mathts-core 0.19.0 → 0.21.0

package/dist/{unit-l_r8z5Fv.js → unit-D3yD3jbu.js}

@@ -1,4 +1,23 @@
 //#region src/types/complex.ts
+const HYPERBOLIC_OVERFLOW_ARG = 700;
+function createTanFamilyMethod(name, sign, hyperbolic) {
+	const method = function() {
+		const t = (hyperbolic ? this.im : this.re) * 2;
+		const h = (hyperbolic ? this.re : this.im) * 2;
+		let s;
+		let q;
+		if (Math.abs(h) > HYPERBOLIC_OVERFLOW_ARG) {
+			s = 2 * Math.sin(t) * Math.exp(-Math.abs(h));
+			q = Math.sign(h);
+		} else {
+			const d = Math.cosh(h) + sign * Math.cos(t);
+			s = Math.sin(t) / d;
+			q = Math.sinh(h) / d;
+		}
+		return hyperbolic ? new Complex(q, s * sign) : new Complex(s, q * sign);
+	};
+	return Object.defineProperty(method, "name", { value: name });
+}
 function isComplex$1(value) {
 	return value instanceof Complex;
 }
@@ -18,6 +37,35 @@ var Complex = class Complex {
 		this.re = re;
 		this.im = im;
 	}
+	static {
+		for (const [name, sign, hyperbolic] of [
+			[
+				"tan",
+				1,
+				false
+			],
+			[
+				"cot",
+				-1,
+				false
+			],
+			[
+				"tanh",
+				1,
+				true
+			],
+			[
+				"coth",
+				-1,
+				true
+			]
+		]) Object.defineProperty(Complex.prototype, name, {
+			value: createTanFamilyMethod(name, sign, hyperbolic),
+			writable: true,
+			configurable: true,
+			enumerable: false
+		});
+	}
 	static fromPolar(r, theta) {
 		const cosT = Math.cos(theta);
 		const sinT = Math.sin(theta);
@@ -231,18 +279,6 @@ var Complex = class Complex {
 	cos() {
 		return new Complex(Math.cos(this.re) * Math.cosh(this.im), -Math.sin(this.re) * Math.sinh(this.im));
 	}
-	tan() {
-		const x2 = this.re * 2;
-		const y2 = this.im * 2;
-		const d = Math.cos(x2) + Math.cosh(y2);
-		return new Complex(Math.sin(x2) / d, Math.sinh(y2) / d);
-	}
-	cot() {
-		const x2 = this.re * 2;
-		const y2 = this.im * 2;
-		const d = Math.cosh(y2) - Math.cos(x2);
-		return new Complex(Math.sin(x2) / d, -Math.sinh(y2) / d);
-	}
 	sec() {
 		return this.cos().inverse();
 	}
@@ -255,18 +291,6 @@ var Complex = class Complex {
 	cosh() {
 		return new Complex(Math.cosh(this.re) * Math.cos(this.im), Math.sinh(this.re) * Math.sin(this.im));
 	}
-	tanh() {
-		const x2 = this.re * 2;
-		const y2 = this.im * 2;
-		const d = Math.cosh(x2) + Math.cos(y2);
-		return new Complex(Math.sinh(x2) / d, Math.sin(y2) / d);
-	}
-	coth() {
-		const x2 = this.re * 2;
-		const y2 = this.im * 2;
-		const d = Math.cosh(x2) - Math.cos(y2);
-		return new Complex(Math.sinh(x2) / d, -Math.sin(y2) / d);
-	}
 	sech() {
 		return this.cosh().inverse();
 	}
@@ -720,6 +744,12 @@ function _toNumberOrDefault(value, defaultValue) {
 function hasOwnProperty(object, property) {
 	return !!object && Object.hasOwnProperty.call(object, property);
 }
+function isPollutingKey(prop) {
+	return prop in Object.prototype || prop in Function.prototype;
+}
+function isPrototypeKey(prop) {
+	return prop === "__proto__";
+}
 function endsWith(text, search) {
 	const start = text.length - search.length;
 	return text.substring(start, text.length) === search;
@@ -770,12 +800,12 @@ function clone(x) {
 }
 function mapObject(object, callback) {
 	const clone = {};
-	for (const key in object) if (hasOwnProperty(object, key)) clone[key] = callback(object[key]);
+	for (const key in object) if (hasOwnProperty(object, key) && !isPrototypeKey(key)) clone[key] = callback(object[key]);
 	return clone;
 }
 function extend(a, b) {
 	const target = a;
-	for (const prop in b) if (hasOwnProperty(b, prop)) target[prop] = b[prop];
+	for (const prop in b) if (hasOwnProperty(b, prop) && !isPrototypeKey(prop)) target[prop] = b[prop];
 	return a;
 }
 function deepExtend(a, b) {
@@ -795,7 +825,7 @@ function deepExtend(a, b) {
 		}
 		return a;
 	}
-	for (const prop in b) if (hasOwnProperty(b, prop) && !(prop in Object.prototype) && !(prop in Function.prototype)) {
+	for (const prop in b) if (hasOwnProperty(b, prop) && !isPollutingKey(prop)) {
 		const bValue = b[prop];
 		const aValue = a[prop];
 		if (bValue && bValue.constructor === Object) {
@@ -835,7 +865,7 @@ function deepFlatten(nestedObject) {
 	return flattenedObject;
 }
 function _deepFlatten(nestedObject, flattenedObject) {
-	for (const prop in nestedObject) if (hasOwnProperty(nestedObject, prop)) {
+	for (const prop in nestedObject) if (hasOwnProperty(nestedObject, prop) && !isPrototypeKey(prop)) {
 		const value = nestedObject[prop];
 		if (typeof value === "object" && value !== null) _deepFlatten(value, flattenedObject);
 		else flattenedObject[prop] = value;
@@ -1217,23 +1247,20 @@ var Fraction = class Fraction {
 			denominator: this.denominator
 		};
 	}
-	add(other) {
+	addSub(other, combine) {
 		if (other instanceof Fraction) {
-			if (this.denominator === other.denominator) return new Fraction(this.numerator + other.numerator, this.denominator);
-			const num = this.numerator * other.denominator + other.numerator * this.denominator;
+			if (this.denominator === other.denominator) return new Fraction(combine(this.numerator, other.numerator), this.denominator);
+			const num = combine(this.numerator * other.denominator, other.numerator * this.denominator);
 			const den = this.denominator * other.denominator;
 			return new Fraction(num, den);
 		}
-		return this.add(Fraction.fromNumber(Number(other.valueOf())));
+		return this.addSub(Fraction.fromNumber(Number(other.valueOf())), combine);
+	}
+	add(other) {
+		return this.addSub(other, (a, b) => a + b);
 	}
 	subtract(other) {
-		if (other instanceof Fraction) {
-			if (this.denominator === other.denominator) return new Fraction(this.numerator - other.numerator, this.denominator);
-			const num = this.numerator * other.denominator - other.numerator * this.denominator;
-			const den = this.denominator * other.denominator;
-			return new Fraction(num, den);
-		}
-		return this.subtract(Fraction.fromNumber(Number(other.valueOf())));
+		return this.addSub(other, (a, b) => a - b);
 	}
 	multiply(other) {
 		if (other instanceof Fraction) return new Fraction(this.numerator * other.numerator, this.denominator * other.denominator);
@@ -1323,15 +1350,20 @@ var Fraction = class Fraction {
 		return this.numerator === 1n || this.numerator === -1n;
 	}
 	floor() {
-		if (this.denominator === 1n) return this;
-		const quot = this.numerator / this.denominator;
-		if (this.numerator >= 0n || this.numerator % this.denominator === 0n) return new Fraction(quot, 1n);
-		return new Fraction(quot - 1n, 1n);
+		return this.truncBound("floor");
 	}
 	ceil() {
+		return this.truncBound("ceil");
+	}
+	truncBound(toward) {
 		if (this.denominator === 1n) return this;
 		const quot = this.numerator / this.denominator;
-		if (this.numerator <= 0n || this.numerator % this.denominator === 0n) return new Fraction(quot, 1n);
+		const exact = this.numerator % this.denominator === 0n;
+		if (toward === "floor") {
+			if (this.numerator >= 0n || exact) return new Fraction(quot, 1n);
+			return new Fraction(quot - 1n, 1n);
+		}
+		if (this.numerator <= 0n || exact) return new Fraction(quot, 1n);
 		return new Fraction(quot + 1n, 1n);
 	}
 	round() {
@@ -2074,33 +2106,25 @@ var BigNumber = class BigNumber {
 		else if (reduced.compareTo(BIGNUMBER_PI.negate()) < 0) reduced = reduced.add(twoPi);
 		return reduced;
 	}
-	_sinTaylor() {
+	_alternatingEvenTaylor(initialTerm, initialSum, denom) {
 		const precision = globalConfig.precision;
-		let term = this.clone();
-		let sum = this.clone();
+		let term = initialTerm;
+		let sum = initialSum;
 		const xSquared = this.multiply(this);
 		const maxIter = precision + 20;
 		for (let n = 1; n <= maxIter; n++) {
-			term = term.multiply(xSquared).divide(BigNumber.fromNumber(2 * n * (2 * n + 1))).negate();
+			term = term.multiply(xSquared).divide(BigNumber.fromNumber(denom(n))).negate();
 			const newSum = sum.add(term);
 			if (sum.equals(newSum)) break;
 			sum = newSum;
 		}
 		return sum.roundToPrecision(precision);
 	}
+	_sinTaylor() {
+		return this._alternatingEvenTaylor(this.clone(), this.clone(), (n) => 2 * n * (2 * n + 1));
+	}
 	_cosTaylor() {
-		const precision = globalConfig.precision;
-		let term = BigNumber.fromNumber(1);
-		let sum = BigNumber.fromNumber(1);
-		const xSquared = this.multiply(this);
-		const maxIter = precision + 20;
-		for (let n = 1; n <= maxIter; n++) {
-			term = term.multiply(xSquared).divide(BigNumber.fromNumber((2 * n - 1) * (2 * n))).negate();
-			const newSum = sum.add(term);
-			if (sum.equals(newSum)) break;
-			sum = newSum;
-		}
-		return sum.roundToPrecision(precision);
+		return this._alternatingEvenTaylor(BigNumber.fromNumber(1), BigNumber.fromNumber(1), (n) => (2 * n - 1) * (2 * n));
 	}
 	_atanTaylor() {
 		const precision = globalConfig.precision;
@@ -3633,7 +3657,7 @@ const UNIT_ROWS = Object.freeze({
 	},
 	psi: {
 		base: "PRESSURE",
-		prefixes: "NONE",
+		prefixes: "SHORT",
 		scale: "lbf/inch^2"
 	},
 	atm: {
@@ -3648,7 +3672,7 @@ const UNIT_ROWS = Object.freeze({
 	},
 	torr: {
 		base: "PRESSURE",
-		prefixes: "NONE",
+		prefixes: "SHORT",
 		scale: "standard_atmosphere/760"
 	},
 	mmHg: {
@@ -3949,6 +3973,7 @@ const UNIT_ROW_ALIASES = Object.freeze({
 	rods: "rod",
 	chains: "chain",
 	angstroms: "angstrom",
+	Angstrom: "angstrom",
 	lt: "l",
 	litres: "litre",
 	liter: "litre",
@@ -4038,6 +4063,7 @@ const UNIT_ROW_ALIASES = Object.freeze({
 	bit: "bits",
 	byte: "bytes",
 	calories: "calorie",
+	d: "day",
 	G: "gauss",
 	Gauss: "gauss",
 	poise: "P",
@@ -4052,6 +4078,14 @@ const UNIT_ROW_ALIASES = Object.freeze({
 	Ohm: "ohm",
 	Å: "angstrom"
 });
+const REFUSED_UNIT_SPELLINGS = Object.freeze({
+	dB: "dB is a logarithmic unit; give the quantity in its linear unit, or a reference level",
+	dBm: "dBm is a logarithmic unit (decibels over 1 mW); give watts",
+	dBW: "dBW is a logarithmic unit (decibels over 1 W); give watts",
+	Np: "Np is a logarithmic unit (the neper); give the quantity in its linear unit, or a reference level",
+	Mach: "Mach is a ratio to the local speed of sound; give m/s, or the ratio as a bare number",
+	mach: "mach is a ratio to the local speed of sound; give m/s, or the ratio as a bare number"
+});
 const namedCache = /* @__PURE__ */ new Map();
 function namedExactScale(name) {
 	const cached = namedCache.get(name);
@@ -4402,7 +4436,11 @@ const createUnitClass = /* #__PURE__ */ factory("Unit", [
 				if (uStr === null) throw new UnitParseError("Unexpected \"" + oldC + "\" in \"" + text + "\" at index " + index.toString());
 			} else break;
 			const res = _findUnit(uStr);
-			if (res === null) throw new UnitParseError("Unit \"" + uStr + "\" not found.");
+			if (res === null) {
+				const refused = Object.hasOwn(REFUSED_UNIT_SPELLINGS, uStr) ? REFUSED_UNIT_SPELLINGS[uStr] : void 0;
+				if (refused !== void 0) throw new UnitParseError("Unit \"" + uStr + "\" is refused: " + refused);
+				throw new UnitParseError("Unit \"" + uStr + "\" not found.");
+			}
 			let power = powerMultiplierCurrent * powerMultiplierStackProduct;
 			skipWhitespace();
 			if (parseCharacter("^")) {
@@ -5728,7 +5766,10 @@ const createUnitClass = /* #__PURE__ */ factory("Unit", [
 			if (aliases) for (let i = 0; i < aliases.length; i++) Unit.deleteUnit(aliases[i]);
 		}
 		let lastUnit;
-		for (const key in obj) if (hasOwnProperty(obj, key)) lastUnit = Unit.createUnitSingle(key, obj[key]);
+		for (const key in obj) if (hasOwnProperty(obj, key)) {
+			if (isPollutingKey(key)) throw new TypeError(`unsafe unit name '${key}'`);
+			lastUnit = Unit.createUnitSingle(key, obj[key]);
+		}
 		return lastUnit;
 	};
 	Unit.createUnitSingle = function(name, obj) {
@@ -5914,4 +5955,4 @@ const unitDependencies = {
 //#region src/types/unit/index.ts
 const Unit = createUnitClass(unitDependencies);
 //#endregion
-export { BIGNUMBER_LN2 as $, log1p as $t, irrationalPower as A, isRegExp as An, isLegacyFactory as At, addScalar as B, I as Bn, warnOnce as Bt, decimalExactScale as C, isIndex as Cn, canDefineProperty as Ct, exactScaleToNumber as D, isNumber as Dn, deepStrictEqual as Dt, exactScaleOf as E, isNull as En, deepFlatten as Et, ratioExactScale as F, typeOf as Fn, set as Ft, multiplyScalar as G, copysign as Gt, equal as H, asinh as Ht, readScaleExpression as I, COMPLEX_NEG_ONE as In, traverse as It, round as J, expm1 as Jt, number as K, cosh as Kt, DimensionMismatchError as L, COMPLEX_ONE as Ln, endsWith as Lt, multiplyExactScales as M, isString as Mn, mapObject as Mt, namedIrrationalScale as N, isUndefined as Nn, pick as Nt, exactScalesEqual as O, isObject as On, extend as Ot, powerExactScale as P, isUnit as Pn, pickShallow as Pt, BIGNUMBER_LN10 as Q, log10 as Qt, UnitParseError as R, COMPLEX_ZERO as Rn, hasOwnProperty as Rt, clearExactScaleNumberCache as S, isFunction as Sn, MathjsError as St, exactScaleNumberCacheSize as T, isMatrix as Tn, deepExtend as Tt, fix as U, atanh as Ut, divideScalar as V, isComplex$1 as Vn, acosh as Vt, isNumeric as W, cbrt as Wt, DEFAULT_CONFIG as X, isInteger as Xt, subtractScalar$1 as Y, format as Yt, BIGNUMBER_E as Z, isPowZeroAtInfinity as Zt, NAMED_IRRATIONALS as _, isCollection as _n, factory as _t, UNIT_PREFIX_SETS as a, sign as an, BigNumber as at, addExactScales as b, isDenseMatrix as bn, sortFactories as bt, getUnitPrefix as c, tanh as cn, FRACTION_NEG_ONE as ct, readUnitScale as d, toFixed as dn, FRACTION_THIRD as dt, log2 as en, BIGNUMBER_NEG_ONE as et, unitPrefixExactScale as f, toPrecision as fn, FRACTION_ZERO as ft, LN2_EXACT_SCALE as g, isBoolean as gn, create as gt, unitRowValue as h, isBigNumber$1 as hn, assertDependencies as ht, NAMED_SCALES as i, safeNumberType as in, BIGNUMBER_ZERO as it, isRationalScale as j, isSparseMatrix as jn, lazy as jt, formatExactScale as k, isRange as kn, get as kt, getUnitRow as l, toEngineering as ln, FRACTION_ONE as lt, unitRowExactScale as m, isBigInt as mn, isFraction as mt, unitDependencies as n, normalizeFormatOptions as nn, BIGNUMBER_PI as nt, UNIT_ROWS as o, sinh as on, isBigNumber as ot, unitRowExactOffset as p, isArray as pn, Fraction as pt, pow as q, digits as qt, createUnitClass as r, roundDigits as rn, BIGNUMBER_TEN as rt, UNIT_ROW_ALIASES as s, splitNumber as sn, FRACTION_HALF as st, Unit as t, nearlyEqual as tn, BIGNUMBER_ONE as tt, namedExactScale as u, toExponential as un, FRACTION_QUARTER as ut, PI_EXACT_SCALE as v, isComplex as vn, isFactory as vt, divideExactScales as w, isMap as wn, clone as wt, binaryExactScale as x, isFraction$1 as xn, stripOptionalNotation as xt, UNIT_EXACT_SCALE as y, isDate as yn, isOptionalDependency as yt, abs as z, Complex as zn, memoize as zt };
+export { BIGNUMBER_LN10 as $, log10 as $t, formatExactScale as A, isRange as An, get as At, abs as B, Complex as Bn, memoize as Bt, clearExactScaleNumberCache as C, isFunction as Cn, MathjsError as Ct, exactScaleOf as D, isNull as Dn, deepFlatten as Dt, exactScaleNumberCacheSize as E, isMatrix as En, deepExtend as Et, powerExactScale as F, isUnit as Fn, pickShallow as Ft, isNumeric as G, cbrt as Gt, divideScalar as H, isComplex$1 as Hn, acosh as Ht, ratioExactScale as I, typeOf as In, set as It, pow as J, digits as Jt, multiplyScalar as K, copysign as Kt, readScaleExpression as L, COMPLEX_NEG_ONE as Ln, traverse as Lt, isRationalScale as M, isSparseMatrix as Mn, lazy as Mt, multiplyExactScales as N, isString as Nn, mapObject as Nt, exactScaleToNumber as O, isNumber as On, deepStrictEqual as Ot, namedIrrationalScale as P, isUndefined as Pn, pick as Pt, BIGNUMBER_E as Q, isPowZeroAtInfinity as Qt, DimensionMismatchError as R, COMPLEX_ONE as Rn, endsWith as Rt, binaryExactScale as S, isFraction$1 as Sn, stripOptionalNotation as St, divideExactScales as T, isMap as Tn, clone as Tt, equal as U, asinh as Ut, addScalar as V, I as Vn, warnOnce as Vt, fix as W, atanh as Wt, subtractScalar$1 as X, format as Xt, round as Y, expm1 as Yt, DEFAULT_CONFIG as Z, isInteger as Zt, LN2_EXACT_SCALE as _, isBoolean as _n, create as _t, REFUSED_UNIT_SPELLINGS as a, safeNumberType as an, BIGNUMBER_ZERO as at, UNIT_EXACT_SCALE as b, isDate as bn, isOptionalDependency as bt, UNIT_ROW_ALIASES as c, splitNumber as cn, FRACTION_HALF as ct, namedExactScale as d, toExponential as dn, FRACTION_QUARTER as dt, log1p as en, BIGNUMBER_LN2 as et, readUnitScale as f, toFixed as fn, FRACTION_THIRD as ft, unitRowValue as g, isBigNumber$1 as gn, assertDependencies as gt, unitRowExactScale as h, isBigInt as hn, isFraction as ht, NAMED_SCALES as i, roundDigits as in, BIGNUMBER_TEN as it, irrationalPower as j, isRegExp as jn, isLegacyFactory as jt, exactScalesEqual as k, isObject as kn, extend as kt, getUnitPrefix as l, tanh as ln, FRACTION_NEG_ONE as lt, unitRowExactOffset as m, isArray as mn, Fraction as mt, unitDependencies as n, nearlyEqual as nn, BIGNUMBER_ONE as nt, UNIT_PREFIX_SETS as o, sign as on, BigNumber as ot, unitPrefixExactScale as p, toPrecision as pn, FRACTION_ZERO as pt, number as q, cosh as qt, createUnitClass as r, normalizeFormatOptions as rn, BIGNUMBER_PI as rt, UNIT_ROWS as s, sinh as sn, isBigNumber as st, Unit as t, log2 as tn, BIGNUMBER_NEG_ONE as tt, getUnitRow as u, toEngineering as un, FRACTION_ONE as ut, NAMED_IRRATIONALS as v, isCollection as vn, factory as vt, decimalExactScale as w, isIndex as wn, canDefineProperty as wt, addExactScales as x, isDenseMatrix as xn, sortFactories as xt, PI_EXACT_SCALE as y, isComplex as yn, isFactory as yt, UnitParseError as z, COMPLEX_ZERO as zn, hasOwnProperty as zt };

package/dist/wasm-as-header.d.ts

@@ -0,0 +1,17 @@
+/**
+ * AssemblyScript managed ArrayBuffer + typed-array header allocation.
+ *
+ * Shared by `functions` WASM bridges and `matrix` AS backend allocation.
+ * Exported only from `@danielsimonjr/mathts-core/internal`.
+ */
+export interface AsHeaderRuntime {
+    __new(size: number, id: number): number;
+    __pin(ptr: number): number;
+    memory: WebAssembly.Memory;
+}
+/** Pin a data buffer and write the 12-byte AS typed-array header. */
+export declare function allocAsHeader(mod: AsHeaderRuntime, byteLength: number, typeId: number): {
+    headerPtr: number;
+    bufferPtr: number;
+};
+//# sourceMappingURL=wasm-as-header.d.ts.map

package/dist/wasm-as-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-as-header.d.ts","sourceRoot":"","sources":["../src/wasm-as-header.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACxC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;CAC5B;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAC3B,GAAG,EAAE,eAAe,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GACb;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAS1C"}

package/dist/wasm-loader.d.ts

@@ -39,7 +39,7 @@
  *
  * @module @danielsimonjr/mathts-core/internal (wasm-loader)
  */
-import type { WasmManifest } from './types/wasm-loader.js';
+import type { LoadingMetrics, WasmManifest } from './types/wasm-loader.js';
 export type { WasmManifest };
 /**
  * Compute the SHA-384 digest of a buffer and return base64 encoding,
@@ -94,4 +94,36 @@ export declare function resolvePackagedWasm(metaUrl: string, wasmFile: string):
 export declare function defaultWasmLocation(metaUrl: string, wasmFile: string, opts?: {
     browser?: boolean;
 }): Promise<string>;
+/**
+ * Shared load / instantiate orchestration for the two package-local
+ * `WasmLoader` singletons (`functions` and `matrix`). Subclasses keep their own
+ * `WasmModule` ABI type and path resolution; the Node and browser load arms
+ * (`precompile`, `loadNodeWasm`, `loadBrowserWasm`) live here and call
+ * {@link verifyWasmIntegrity} before every compile/instantiate (G45–G47, P6-10).
+ */
+export declare abstract class WasmModuleLoader<TModule> {
+    protected wasmModule: TModule | null;
+    protected compiledModule: WebAssembly.Module | null;
+    protected loading: Promise<TModule> | null;
+    protected isNode: boolean;
+    protected lastMetrics: LoadingMetrics | null;
+    protected constructor();
+    /**
+     * Load the WASM module (cached; concurrent callers share one in-flight promise).
+     */
+    load(wasmPath?: string): Promise<TModule>;
+    private loadModule;
+    protected abstract getDefaultWasmPath(): Promise<string>;
+    /**
+     * Precompile the WASM module without instantiation.
+     * Useful for build-time or startup optimization.
+     *
+     * Same integrity rule as `load()`: the bytes are hashed against the manifest before
+     * `WebAssembly.compile`. The browser arm streams only when no manifest exists.
+     */
+    precompile(wasmPath?: string): Promise<void>;
+    protected loadNodeWasm(path: string, totalStart: number): Promise<TModule>;
+    protected loadBrowserWasm(path: string, totalStart: number): Promise<TModule>;
+    protected getImports(): WebAssembly.Imports;
+}
 //# sourceMappingURL=wasm-loader.d.ts.map

package/dist/wasm-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-loader.d.ts","sourceRoot":"","sources":["../src/wasm-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,YAAY,EAAE,CAAC;AAI7B;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBtF;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAmBrF;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,GAAG,UAAU,EAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnE,OAAO,CAAC,IAAI,CAAC,CAmCf;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmBxB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,OAAO,CAAC,MAAM,CAAC,CAmBjB"}
+{"version":3,"file":"wasm-loader.d.ts","sourceRoot":"","sources":["../src/wasm-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,CAAC;AAI7B;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBtF;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAmBrF;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,GAAG,UAAU,EAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnE,OAAO,CAAC,IAAI,CAAC,CAmCf;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmBxB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED;;;;;;GAMG;AACH,8BAAsB,gBAAgB,CAAC,OAAO;IAC5C,SAAS,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAAQ;IAC5C,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,GAAG,IAAI,CAAQ;IAC3D,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAQ;IAClD,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1B,SAAS,CAAC,WAAW,EAAE,cAAc,GAAG,IAAI,CAAQ;IAEpD,SAAS,eAER;IAED;;OAEG;IACU,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAwBrD;YAEa,UAAU;IAwBxB,SAAS,CAAC,QAAQ,CAAC,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzD;;;;;;OAMG;IACU,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCxD;IAED,UAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA8B/E;IAED,UAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA+ClF;IAED,SAAS,CAAC,UAAU,IAAI,WAAW,CAAC,OAAO,CAY1C;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-core",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Core types, utilities, and configuration for MathTS",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -39,6 +39,7 @@
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
+    "fast-check": "^4.9.0",
     "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"