@c9up/atom 0.1.3

package/src/atlas.ts

@@ -0,0 +1,83 @@
+/**
+ * `@c9up/atom/atlas` — Atlas column-type adapter for {@link Decimal}.
+ *
+ * Wires `Atom.Decimal` into Atlas's `@Column({ prepare, consume })` opt-in
+ * column pipeline. Lives on a sub-export so the default `@c9up/atom` import
+ * surface stays adapter-free.
+ *
+ * Mirrors Adonis Lucid's `@column.prepare` / `@column.consume` pattern —
+ * callbacks are baked into the entity definition; no global registry, no
+ * boot-time wiring.
+ *
+ * Usage:
+ *
+ *     import { Column, Entity, BaseEntity, PrimaryKey } from '@c9up/atlas'
+ *     import { decimalAtlasAdapter } from '@c9up/atom/atlas'
+ *
+ *     @Entity('accounts')
+ *     class Account extends BaseEntity {
+ *       @PrimaryKey() id!: number
+ *       @Column(decimalAtlasAdapter) balance!: Decimal | null
+ *     }
+ *
+ * @implements Story 35.10
+ */
+
+import { Decimal } from "./Decimal.js";
+
+/**
+ * Atlas adapter for postgres `numeric` / `decimal` (and equivalent on mysql /
+ * sqlite) columns. `consume` lifts string/number/bigint DB values into a
+ * {@link Decimal}; `prepare` lowers a `Decimal` back to its lossless string
+ * form for the SQL bind parameter.
+ *
+ * - `consume(null)` / `consume(undefined)` returns `null` so nullable columns
+ *   keep their semantics through the adapter pipeline.
+ * - `prepare(null)` / `prepare(undefined)` returns `null` symmetrically.
+ * - `prepare` rejects anything that is not a `Decimal` — protects against the
+ *   common "I forgot to wrap" footgun where a JS number would otherwise
+ *   silently coerce via `String(x)` and lose precision.
+ *
+ * **Driver requirement:** configure your DB driver to return `numeric` /
+ * `decimal` columns as `string` (postgres-js does this by default; mysql2
+ * needs `decimalNumbers: false`; better-sqlite3 returns whatever the bound
+ * type was). If the driver returns numeric values as JS `number`, precision
+ * is already lost before `consume` is called — `9007199254740993` (one beyond
+ * `Number.MAX_SAFE_INTEGER`) arrives as `9007199254740992` and the adapter
+ * faithfully wraps the rounded value. The "lossless" round-trip claim only
+ * holds when DB → driver → adapter stays in the string/bigint domain.
+ *
+ * The shape `{ prepare, consume }` is spreadable directly into `@Column(...)`:
+ * `@Column(decimalAtlasAdapter)` is identical to
+ * `@Column({ prepare: decimalAtlasAdapter.prepare, consume: decimalAtlasAdapter.consume })`.
+ *
+ * The exported object is `Object.freeze`d so a stray test setup file or
+ * plugin cannot monkey-patch `prepare` / `consume` at runtime and silently
+ * corrupt every repository sharing this import.
+ */
+export const decimalAtlasAdapter = Object.freeze({
+	consume(raw: unknown): Decimal | null {
+		if (raw === null || raw === undefined) return null;
+		if (raw instanceof Decimal) return raw;
+		if (
+			typeof raw === "string" ||
+			typeof raw === "number" ||
+			typeof raw === "bigint"
+		) {
+			return new Decimal(raw);
+		}
+		throw new TypeError(
+			`decimalAtlasAdapter.consume: expected string | number | bigint | Decimal | null, got ${typeof raw}`,
+		);
+	},
+	prepare(value: unknown): string | null {
+		if (value === null || value === undefined) return null;
+		if (!(value instanceof Decimal)) {
+			throw new TypeError(
+				`decimalAtlasAdapter.prepare: expected a Decimal instance, got ${typeof value === "object" ? Object.prototype.toString.call(value) : typeof value}. ` +
+					"Wrap the value with `new Decimal(...)` before assigning to a column tagged with this adapter.",
+			);
+		}
+		return value.toString();
+	},
+});

package/src/index.ts

@@ -0,0 +1,267 @@
+/**
+ * @c9up/atom — exact decimal arithmetic.
+ * The Rust engine is required (NAPI in Node, WASM in browser) — there is no JS/TS fallback.
+ */
+
+export type {
+	BetweenOptions,
+	DecimalInput,
+	DecimalScaled,
+	DivOptions,
+	MedianOptions,
+	PowOptions,
+	QuantizeOptions,
+	RoundMode,
+	SqrtOptions,
+	StddevOptions,
+	ToMinorUnitsOptions,
+} from "./Decimal.js";
+export { Decimal } from "./Decimal.js";
+export { isNativeAvailable } from "./native.js";
+
+import type { MedianOptions, StddevOptions } from "./Decimal.js";
+import { Decimal, type DecimalInput } from "./Decimal.js";
+
+export function decimal(value: DecimalInput): Decimal {
+	return Decimal.from(value);
+}
+
+function isDecimalIterable(value: unknown): value is Iterable<DecimalInput> {
+	if (typeof value === "string") return false;
+	return (
+		typeof value === "object" && value !== null && Symbol.iterator in value
+	);
+}
+
+function resolveValues(
+	args: [Iterable<DecimalInput>] | DecimalInput[],
+): Iterable<DecimalInput> {
+	if (args.length === 1 && isDecimalIterable(args[0])) {
+		return args[0] as Iterable<DecimalInput>;
+	}
+	return args as DecimalInput[];
+}
+
+function sumImpl(values: Iterable<DecimalInput>): Decimal {
+	let total = Decimal.zero();
+	for (const value of values) {
+		total = total.plus(value);
+	}
+	return total;
+}
+
+function avgImpl(values: Iterable<DecimalInput>): Decimal {
+	let total = Decimal.zero();
+	let count = 0;
+	for (const value of values) {
+		total = total.plus(value);
+		count++;
+	}
+	if (count === 0) {
+		throw new Error("Atom.avg requires at least one value");
+	}
+	return total.div(String(count));
+}
+
+function minImpl(values: Iterable<DecimalInput>): Decimal {
+	const list = [...values].map((value) => new Decimal(value));
+	if (list.length === 0) {
+		throw new Error("Atom.min requires at least one value");
+	}
+	let best = list[0];
+	for (let i = 1; i < list.length; i++) {
+		if (list[i].lt(best)) best = list[i];
+	}
+	return best;
+}
+
+function maxImpl(values: Iterable<DecimalInput>): Decimal {
+	const list = [...values].map((value) => new Decimal(value));
+	if (list.length === 0) {
+		throw new Error("Atom.max requires at least one value");
+	}
+	let best = list[0];
+	for (let i = 1; i < list.length; i++) {
+		if (list[i].gt(best)) best = list[i];
+	}
+	return best;
+}
+
+function medianImpl(
+	values: Iterable<DecimalInput>,
+	options: MedianOptions = {},
+): Decimal {
+	const list = [...values].map((value) => new Decimal(value));
+	if (list.length === 0) {
+		throw new Error("Atom.median requires at least one value");
+	}
+	list.sort((a, b) => a.cmp(b));
+	const mid = Math.floor(list.length / 2);
+	if (list.length % 2 === 1) return list[mid];
+	const precision = options.precision ?? 18;
+	return list[mid - 1].plus(list[mid]).div("2", { precision });
+}
+
+function modeImpl(values: Iterable<DecimalInput>): Decimal[] {
+	const frequencies = new Map<string, number>();
+	for (const value of values) {
+		const key = new Decimal(value).toString();
+		frequencies.set(key, (frequencies.get(key) ?? 0) + 1);
+	}
+	if (frequencies.size === 0) {
+		throw new Error("Atom.mode requires at least one value");
+	}
+	let maxCount = 0;
+	for (const count of frequencies.values()) {
+		if (count > maxCount) maxCount = count;
+	}
+	if (maxCount <= 1) return [];
+	return [...frequencies.entries()]
+		.filter(([, count]) => count === maxCount)
+		.map(([value]) => new Decimal(value))
+		.sort((a, b) => a.cmp(b));
+}
+
+function stddevImpl(
+	values: Iterable<DecimalInput>,
+	options: StddevOptions = {},
+): Decimal {
+	const list = [...values].map((value) => new Decimal(value));
+	if (list.length === 0) {
+		throw new Error("Atom.stddev requires at least one value");
+	}
+	const sample = options.sample ?? false;
+	const precision = options.precision ?? 18;
+	const mode = options.mode ?? "trunc";
+	const divisor = sample ? list.length - 1 : list.length;
+	if (divisor <= 0) {
+		throw new Error("Atom.stddev sample mode requires at least two values");
+	}
+	const mean = avgImpl(list);
+	let sumSquares = Decimal.zero();
+	for (const value of list) {
+		const diff = value.minus(mean);
+		sumSquares = sumSquares.plus(diff.times(diff));
+	}
+	const variance = sumSquares.div(String(divisor), {
+		precision: precision + 8,
+	});
+	return variance.sqrt({ precision, mode });
+}
+
+function parseMedianArgs(
+	args: [Iterable<DecimalInput>, MedianOptions?] | DecimalInput[],
+): { values: Iterable<DecimalInput>; options: MedianOptions } {
+	if (args.length >= 1 && isDecimalIterable(args[0])) {
+		const values = args[0] as Iterable<DecimalInput>;
+		const options =
+			args.length > 1 && typeof args[1] === "object" && args[1] !== null
+				? (args[1] as MedianOptions)
+				: {};
+		return { values, options };
+	}
+	return { values: args as DecimalInput[], options: {} };
+}
+
+function parseStddevArgs(
+	args: [Iterable<DecimalInput>, StddevOptions?] | DecimalInput[],
+): { values: Iterable<DecimalInput>; options: StddevOptions } {
+	if (args.length >= 1 && isDecimalIterable(args[0])) {
+		const values = args[0] as Iterable<DecimalInput>;
+		const options =
+			args.length > 1 && typeof args[1] === "object" && args[1] !== null
+				? (args[1] as StddevOptions)
+				: {};
+		return { values, options };
+	}
+	return { values: args as DecimalInput[], options: {} };
+}
+
+function sumFn(...args: [Iterable<DecimalInput>] | DecimalInput[]): Decimal {
+	return sumImpl(resolveValues(args));
+}
+
+function avgFn(...args: [Iterable<DecimalInput>] | DecimalInput[]): Decimal {
+	return avgImpl(resolveValues(args));
+}
+
+function minFn(...args: [Iterable<DecimalInput>] | DecimalInput[]): Decimal {
+	return minImpl(resolveValues(args));
+}
+
+function maxFn(...args: [Iterable<DecimalInput>] | DecimalInput[]): Decimal {
+	return maxImpl(resolveValues(args));
+}
+
+function modeFn(...args: [Iterable<DecimalInput>] | DecimalInput[]): Decimal[] {
+	return modeImpl(resolveValues(args));
+}
+
+function medianFn(
+	...args: [Iterable<DecimalInput>, MedianOptions?] | DecimalInput[]
+): Decimal {
+	const { values, options } = parseMedianArgs(args);
+	return medianImpl(values, options);
+}
+
+function stddevFn(
+	...args: [Iterable<DecimalInput>, StddevOptions?] | DecimalInput[]
+): Decimal {
+	const { values, options } = parseStddevArgs(args);
+	return stddevImpl(values, options);
+}
+
+/**
+ * Atom — namespace bundling the public functional API.
+ *
+ * Two equivalent ways to access aggregates: `Atom.sum(...)` for namespaced
+ * usage, or named imports (`import { sum } from '@c9up/atom'`).
+ *
+ * @example
+ *   import { Atom, decimal } from '@c9up/atom'
+ *   const total = Atom.sum('1.10', '2.20', '3.33')   // → Decimal('6.63')
+ *   const mean  = Atom.avg(['10', '20', '30'])       // → Decimal('20')
+ *   const value = decimal('99.99').times('0.20')     // → Decimal('19.998')
+ */
+export const Atom = {
+	/** Construct a `Decimal` from a string / number / bigint / Decimal. Alias for `Decimal.from`. */
+	decimal,
+	/** Exact sum of N values. Empty input → `Decimal('0')`. */
+	sum: sumFn,
+	/** Arithmetic mean of N values. Throws on empty input. */
+	avg: avgFn,
+	/** Sorted-middle of N values. Even-length lists return the average of the two middle elements at the configured precision (default 18). Throws on empty input. */
+	median: medianFn,
+	/**
+	 * Statistical mode — values appearing the most often. Returns an array
+	 * (multi-modal lists possible).
+	 *
+	 * **Edge case**: returns `[]` when no value repeats (every value has count 1).
+	 * This is intentional — there is no "mode" in a strictly unique list. If
+	 * your use case requires "first encountered" semantics on unique lists, use
+	 * `[...new Set(values)][0]` instead.
+	 */
+	mode: modeFn,
+	/**
+	 * Standard deviation. `sample: false` (default) computes the population
+	 * stddev (`/ N`); `sample: true` computes the sample stddev (`/ N-1`),
+	 * which requires at least two values. Internal precision is bumped by 8
+	 * extra digits to mitigate compounding rounding error.
+	 */
+	stddev: stddevFn,
+	/** Smallest of N values. Throws on empty input. */
+	min: minFn,
+	/** Largest of N values. Throws on empty input. */
+	max: maxFn,
+	/** Parse a locale-formatted decimal string (e.g. `'1.234,56'` in `fr-FR`). */
+	parseLocale: (value: string, locales?: Intl.LocalesArgument) =>
+		Decimal.parseLocale(value, locales),
+};
+
+export const sum = sumFn;
+export const avg = avgFn;
+export const median = medianFn;
+export const mode = modeFn;
+export const stddev = stddevFn;
+export const min = minFn;
+export const max = maxFn;

package/src/math.ts

@@ -0,0 +1,203 @@
+export interface ParsedDecimal {
+	int: bigint;
+	scale: number;
+}
+
+export function parseDecimal(input: string): ParsedDecimal {
+	const s = input.trim();
+	if (!s) {
+		throw new Error("Invalid decimal: empty string");
+	}
+
+	let sign = 1n;
+	let body = s;
+	if (body.startsWith("-")) {
+		sign = -1n;
+		body = body.slice(1);
+	} else if (body.startsWith("+")) {
+		body = body.slice(1);
+	}
+
+	const parts = body.split(".");
+	if (parts.length > 2) {
+		throw new Error(`Invalid decimal: ${input}`);
+	}
+	const whole = parts[0] ?? "";
+	const frac = parts[1] ?? "";
+	if (!/^\d*$/.test(whole) || !/^\d*$/.test(frac)) {
+		throw new Error(`Invalid decimal: ${input}`);
+	}
+
+	const digits = `${whole}${frac}` || "0";
+	const int = BigInt(digits) * sign;
+	return { int, scale: frac.length };
+}
+
+export function formatDecimal(int: bigint, scale: number): string {
+	if (scale === 0) return int.toString();
+
+	const negative = int < 0n;
+	let s = (negative ? -int : int).toString();
+	if (s.length <= scale) {
+		s = `${"0".repeat(scale + 1 - s.length)}${s}`;
+	}
+
+	const split = s.length - scale;
+	const whole = s.slice(0, split);
+	let frac = s.slice(split);
+	frac = frac.replace(/0+$/, "");
+
+	let out = frac ? `${whole}.${frac}` : whole;
+	if (negative && out !== "0") out = `-${out}`;
+	return out;
+}
+
+export function addTs(a: string, b: string): string {
+	const da = parseDecimal(a);
+	const db = parseDecimal(b);
+	const [ai, bi, scale] = alignScale(da, db);
+	return formatDecimal(ai + bi, scale);
+}
+
+export function subTs(a: string, b: string): string {
+	const da = parseDecimal(a);
+	const db = parseDecimal(b);
+	const [ai, bi, scale] = alignScale(da, db);
+	return formatDecimal(ai - bi, scale);
+}
+
+export function mulTs(a: string, b: string): string {
+	const da = parseDecimal(a);
+	const db = parseDecimal(b);
+	return formatDecimal(da.int * db.int, da.scale + db.scale);
+}
+
+export function divTs(a: string, b: string, precision: number): string {
+	const da = parseDecimal(a);
+	const db = parseDecimal(b);
+	if (db.int === 0n) {
+		throw new Error("Division by zero");
+	}
+	const numerator = da.int * pow10BigInt(precision + db.scale);
+	const denominator = db.int * pow10BigInt(da.scale);
+	const q = numerator / denominator;
+	return formatDecimal(q, precision);
+}
+
+export function cmpTs(a: string, b: string): -1 | 0 | 1 {
+	const da = parseDecimal(a);
+	const db = parseDecimal(b);
+	const [ai, bi] = alignScale(da, db);
+	if (ai < bi) return -1;
+	if (ai > bi) return 1;
+	return 0;
+}
+
+/**
+ * Align two parsed decimals to the same scale by multiplying the less-precise
+ * one by `10^(scaleDelta)`. Exported so `Decimal.ts` can reuse it — previously
+ * both files had their own copy under different names (`alignScale` vs
+ * `alignScaleParts`), which is a maintenance hazard.
+ */
+export function alignScale(
+	a: ParsedDecimal,
+	b: ParsedDecimal,
+): [bigint, bigint, number] {
+	if (a.scale === b.scale) return [a.int, b.int, a.scale];
+	if (a.scale > b.scale) {
+		const factor = pow10BigInt(a.scale - b.scale);
+		return [a.int, b.int * factor, a.scale];
+	}
+	const factor = pow10BigInt(b.scale - a.scale);
+	return [a.int * factor, b.int, b.scale];
+}
+
+/** Exact `10^exp` as a `bigint`. Exported — single definition for the whole TS side. */
+export function pow10BigInt(exp: number): bigint {
+	let acc = 1n;
+	for (let i = 0; i < exp; i++) acc *= 10n;
+	return acc;
+}
+
+/**
+ * Pure-TS modulo — fallback for when the native engine is unavailable. The
+ * Rust `rem` path should be preferred when `isNativeAvailable()`.
+ */
+export function modTs(a: string, b: string): string {
+	const da = parseDecimal(a);
+	const db = parseDecimal(b);
+	if (db.int === 0n) {
+		throw new Error("Division by zero");
+	}
+	const [ai, bi, scale] = alignScale(da, db);
+	return formatDecimal(ai % bi, scale);
+}
+
+/**
+ * Pure-TS integer exponentiation with truncating div for negative exponents.
+ * Mirrors the Rust `pow` contract so the two paths produce identical results.
+ */
+export function powTs(a: string, exp: number, precision: number): string {
+	if (!Number.isInteger(exp)) {
+		throw new Error(`Invalid exponent: ${exp}`);
+	}
+	if (exp === 0) return "1";
+	if (exp < 0) {
+		return divTs("1", powTs(a, -exp, precision), precision);
+	}
+
+	const base = parseDecimal(a);
+	let resultInt = 1n;
+	let resultScale = 0;
+	let currentInt = base.int;
+	let currentScale = base.scale;
+	let e = exp;
+
+	while (e > 0) {
+		if (e & 1) {
+			resultInt *= currentInt;
+			resultScale += currentScale;
+		}
+		e >>= 1;
+		if (e > 0) {
+			currentInt *= currentInt;
+			currentScale *= 2;
+		}
+	}
+	return formatDecimal(resultInt, resultScale);
+}
+
+/**
+ * Pure-TS integer square root via Newton's iteration on BigInt, scaled to
+ * produce `precision` fractional digits. Truncates toward zero; rounding
+ * modes are applied by the caller.
+ */
+export function sqrtTs(a: string, precision: number): string {
+	const parsed = parseDecimal(a);
+	if (parsed.int < 0n) {
+		throw new Error("Cannot compute sqrt of a negative decimal");
+	}
+	if (parsed.int === 0n) return "0";
+
+	const factorExp = 2 * precision - parsed.scale;
+	let radicand = parsed.int;
+	if (factorExp >= 0) {
+		radicand *= pow10BigInt(factorExp);
+	} else {
+		radicand /= pow10BigInt(-factorExp);
+	}
+	const root = bigintSqrt(radicand);
+	return formatDecimal(root, precision);
+}
+
+function bigintSqrt(value: bigint): bigint {
+	if (value < 0n) throw new Error("Cannot compute sqrt of negative bigint");
+	if (value < 2n) return value;
+	let x0 = value;
+	let x1 = (x0 + value / x0) / 2n;
+	while (x1 < x0) {
+		x0 = x1;
+		x1 = (x0 + value / x0) / 2n;
+	}
+	return x0;
+}

package/src/native.ts

@@ -0,0 +1,104 @@
+/**
+ * Universal engine loader — auto-detects Node (NAPI) vs Browser (WASM).
+ *
+ * - **Node**: loads the prebuilt `.node` binary via `createRequire` (sync, fast)
+ * - **Browser**: loads the `.wasm` binary via the wasm-pack JS glue (async init on
+ *   first module import via top-level await, then sync function calls)
+ *
+ * The consumer imports `nativeAtom()` and gets the same `NativeAtom` interface
+ * regardless of the environment. No conditional imports needed at the call site.
+ */
+
+export interface NativeAtom {
+	add(a: string, b: string): string;
+	sub(a: string, b: string): string;
+	mul(a: string, b: string): string;
+	div(a: string, b: string, precision: number): string;
+	rem(a: string, b: string): string;
+	pow(a: string, exp: number, precision: number): string;
+	sqrt(a: string, precision: number): string;
+	cmp(a: string, b: string): number;
+}
+
+let native: NativeAtom | undefined;
+let loadError: unknown;
+
+const isNode =
+	typeof globalThis.process !== "undefined" &&
+	typeof globalThis.process.versions?.node === "string";
+
+if (isNode) {
+	// Node path: load NAPI binary (sync).
+	try {
+		const { createRequire } = await import("node:module");
+		const { dirname, join } = await import("node:path");
+		const { fileURLToPath } = await import("node:url");
+		const { arch, platform } = await import("node:process");
+
+		const nodeRequire = createRequire(import.meta.url);
+		const currentDir = dirname(fileURLToPath(import.meta.url));
+
+		const platformMap: Record<string, string> = {
+			"linux-x64": "linux-x64-gnu",
+			"linux-arm64": "linux-arm64-gnu",
+			"darwin-x64": "darwin-x64",
+			"darwin-arm64": "darwin-arm64",
+			"win32-x64": "win32-x64-msvc",
+		};
+
+		const suffix = platformMap[`${platform}-${arch}`];
+		if (suffix) {
+			native = nodeRequire(join(currentDir, `../index.${suffix}.node`));
+		}
+	} catch (e) {
+		loadError = e;
+	}
+} else {
+	// Browser path: load WASM (async init, then sync calls).
+	try {
+		const wasm: { default: () => Promise<unknown> } & NativeAtom = await import(
+			"../wasm/atom_engine_wasm.js"
+		);
+		await wasm.default();
+		native = wasm;
+	} catch (e) {
+		loadError = e;
+	}
+}
+
+/** Whether the native engine (NAPI or WASM) loaded successfully. */
+export function isNativeAvailable(): boolean {
+	if (overrideNative === null) return false;
+	if (overrideNative !== undefined) return true;
+	return native !== undefined;
+}
+
+export function nativeAtom(): NativeAtom {
+	if (overrideNative !== undefined) {
+		if (overrideNative === null) {
+			throw new Error(
+				"[ATOM_NAPI_DISABLED] Native engine is disabled (test override)",
+			);
+		}
+		return overrideNative;
+	}
+	if (!native) {
+		throw new Error(
+			`[ATOM_ENGINE_NOT_FOUND] Decimal engine not available.\n` +
+				`  Environment: ${isNode ? "Node" : "Browser"}\n` +
+				`  Reason: ${loadError ?? "binary not found"}\n` +
+				`  Fix (Node): cd packages/atom && pnpm build:napi\n` +
+				`  Fix (Browser): cd packages/atom && pnpm build:wasm`,
+		);
+	}
+	return native;
+}
+
+// Test override (unchanged from before)
+let overrideNative: NativeAtom | null | undefined;
+
+export function __overrideNativeForTesting(
+	impl: NativeAtom | null | undefined,
+): void {
+	overrideNative = impl;
+}

package/wasm/atom_engine_wasm.d.ts

@@ -0,0 +1,19 @@
+// Hand-written stub for the wasm-pack-generated glue file. Lets `tsc --noEmit`
+// pass on a fresh checkout before `pnpm build:wasm` has been run. wasm-pack
+// will overwrite this file with its real generated declarations on the next
+// `build:wasm`; the runtime shape stays compatible.
+//
+// Story 52.1 review patch (2026-05-09): typecheck was broken on a fresh
+// checkout because src/native.ts:60 imports this glue file, and `tsc` could
+// not find it without first running `build:wasm`.
+
+export default function init(): Promise<unknown>;
+
+export function add(a: string, b: string): string;
+export function sub(a: string, b: string): string;
+export function mul(a: string, b: string): string;
+export function div(a: string, b: string, precision: number): string;
+export function rem(a: string, b: string): string;
+export function pow(a: string, exp: number, precision: number): string;
+export function sqrt(a: string, precision: number): string;
+export function cmp(a: string, b: string): number;