picocalc 0.0.0 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roman A
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+//#region src/lib/types.d.ts
+interface PrecisionOptions {
+  readonly format?: "decimal" | "precise";
+  readonly maxDecimals?: number;
+  readonly roundingMode?: "round" | "truncate";
+}
+//#endregion
+//#region src/index.d.ts
+interface CalculateOptions extends PrecisionOptions {
+  decimalSeparator?: "." | ",";
+}
+/**
+* The main entry point for the library.
+*/
+declare function calculate(expression: string, options?: CalculateOptions): string;
+//#endregion
+export { calculate };

package/dist/index.mjs

@@ -0,0 +1,1218 @@
+import "bigint.bitlength";
+//#region src/lib/errors.ts
+var GenericMathErrror = class extends Error {
+	pos;
+	constructor(name, message, pos) {
+		if (pos === void 0) super(`${name}: ${message}`);
+		else super(`${name}: ${message} at position ${pos}`);
+		this.pos = pos;
+		this.name = name;
+	}
+};
+var InterpreterError = class extends GenericMathErrror {
+	constructor(message, pos) {
+		super("InterpreterError", message, pos);
+	}
+};
+var MaximumPrecisionError = class extends InterpreterError {
+	constructor(precision, maxPrecision) {
+		super(`Exceeded maximum precision of ${maxPrecision} digits (${precision})`);
+	}
+};
+var NotImplementedError = class extends InterpreterError {
+	constructor(message, pos) {
+		super(message, pos);
+	}
+};
+var OverflowError = class extends InterpreterError {
+	constructor() {
+		super("Overflow");
+	}
+};
+var DivisionByZeroError = class extends InterpreterError {
+	constructor() {
+		super("Division by zero");
+	}
+};
+var EmptyExpressionError = class extends InterpreterError {
+	constructor() {
+		super("Empty expression");
+	}
+};
+var MismatchedParenthesisError = class extends InterpreterError {
+	constructor(pos, message = "Mismatched parenthesis") {
+		super(message, pos);
+	}
+};
+//#endregion
+//#region src/lib/types.ts
+const OverflowValue = { n: "OVERFLOW" };
+//#endregion
+//#region src/lib/utils/constants.ts
+const PI = Math.PI.toString();
+const E = Math.E.toString();
+const ZERO = {
+	n: 0n,
+	d: 1n
+};
+const ONE = {
+	n: 1n,
+	d: 1n
+};
+const constants = {
+	e: E,
+	pi: PI
+};
+function getConst(id) {
+	const c = constants[id];
+	return {
+		n: BigInt(c.replace(".", "")),
+		d: 10n ** BigInt(c.length - c.indexOf(".") - 1)
+	};
+}
+//#endregion
+//#region src/lib/utils/gcd.ts
+/**
+* The Euclidean GCD Algorithm for BigInt.
+*/
+function gcd(a, b) {
+	if (a === b) return a;
+	if (a === 1n || b === 1n) return 1n;
+	if (a === 0n) return b;
+	if (b === 0n) return a;
+	a = a < 0 ? -a : a;
+	b = b < 0 ? -b : b;
+	while (b > 0) {
+		a %= b;
+		[a, b] = [b, a];
+	}
+	return a;
+}
+//#endregion
+//#region src/lib/utils/multiply.ts
+function multiply(a, b) {
+	const aN = a.n;
+	const bN = b.n;
+	if (aN === 0n || bN === 0n) return ZERO;
+	if (aN === "OVERFLOW") return a;
+	if (bN === "OVERFLOW") return b;
+	const { d: aD, c: aC, e: aE } = a;
+	const { d: bD, c: bC, e: bE } = b;
+	const g1 = gcd(aN, bD);
+	const g2 = gcd(bN, aD);
+	const n = aN / g1 * (bN / g2);
+	const d = aD / g2 * (bD / g1);
+	if (aC === void 0 && bC === void 0) return {
+		n,
+		d
+	};
+	if (aC === bC) return {
+		n,
+		d,
+		c: aC,
+		e: simplify(add({
+			n: aE?.n ?? 1n,
+			d: aE?.d ?? 1n
+		}, {
+			n: bE?.n ?? 1n,
+			d: bE?.d ?? 1n
+		}))
+	};
+	if (aC !== void 0 && bC !== void 0) return multiply(toSimpleFraction(a), toSimpleFraction(b));
+	return {
+		n,
+		d,
+		c: aC ?? bC,
+		e: aE ?? bE
+	};
+}
+//#endregion
+//#region src/lib/utils/nthroot.ts
+/**
+* Calculates the integer nth root of a BigInt.
+*/
+function iNthRoot(value, n) {
+	if (value < 0 && n % 2n === 0n) throw new NotImplementedError(`Even (${n}th) root of negative numbers is not implemented yet.`);
+	if (value < 0) return -iNthRoot(-value, n);
+	if (value < 2n) return value;
+	if (n === 1n) return value;
+	let x = 1n << BigInt.bitLength(value) / n + 1n;
+	const nMinus1 = n - 1n;
+	while (true) {
+		const nextX = (nMinus1 * x + value / x ** nMinus1) / n;
+		if (nextX >= x) break;
+		x = nextX;
+	}
+	return x;
+}
+/**
+* Calculates the n-th root of a fraction.
+*/
+function nthRoot(v, n, precision) {
+	if (n === 0n) throw new DivisionByZeroError();
+	if (n === 1n) return v;
+	if (v.n < 0) {
+		if (n % 2n === 0n) throw new NotImplementedError(`Even (${n}th) root of negative numbers is not implemented yet.`);
+		const positiveResult = nthRoot({
+			n: -v.n,
+			d: v.d
+		}, n, precision);
+		return {
+			n: -positiveResult.n,
+			d: positiveResult.d
+		};
+	}
+	if (v.n === 0n) return ZERO;
+	if (precision.format === "precise") {
+		const rootN = iNthRoot(v.n, n);
+		const rootD = iNthRoot(v.d, n);
+		if (rootN ** n === v.n && rootD ** n === v.d) {
+			const e = simplify({
+				n: v.e?.n ?? 1n,
+				d: (v.e?.d ?? 1n) * n
+			});
+			return simplify({
+				n: rootN,
+				d: rootD,
+				c: v.c,
+				e
+			});
+		}
+	}
+	const precisionDigits = Math.max(10, (precision.maxDecimals ?? 30) * 3);
+	const scaleFactor = 10n ** (BigInt(precisionDigits) * n);
+	return simplify({
+		n: iNthRoot(v.n * scaleFactor / v.d, n),
+		d: 10n ** BigInt(precisionDigits)
+	});
+}
+//#endregion
+//#region src/lib/utils/simplify.ts
+/**
+* Reduces a fraction to its simplest form.
+*/
+function simplify(v) {
+	if (v.d === 0n) throw new DivisionByZeroError();
+	if (v.n === 0n) return ZERO;
+	if (v.d === 1n) {
+		if (v.e?.n === 0n) return {
+			n: v.n,
+			d: v.d
+		};
+		return v;
+	}
+	const common = gcd(v.n, v.d);
+	const sign = v.d < 0 ? -1n : 1n;
+	const n = v.n / common * sign;
+	const d = v.d / common * sign;
+	if (v.e?.n === 0n) return {
+		n,
+		d
+	};
+	return {
+		n,
+		d,
+		c: v.c,
+		e: v.e
+	};
+}
+/**
+* Resolves any constants and exponents to return a simple fraction.
+*/
+function toSimpleFraction(val) {
+	if (!val.c) return val;
+	const c = getConst(val.c);
+	const expN = val.e?.n ?? 1n;
+	const expD = val.e?.d ?? 1n;
+	const absExpN = expN < 0 ? -expN : expN;
+	let poweredConstant = {
+		n: expN < 0 ? c.d ** absExpN : c.n ** absExpN,
+		d: expN < 0 ? c.n ** absExpN : c.d ** absExpN
+	};
+	if (expD !== 1n) poweredConstant = nthRoot(poweredConstant, expD, { format: "precise" });
+	return multiply(poweredConstant, {
+		n: val.n,
+		d: val.d
+	});
+}
+//#endregion
+//#region src/lib/utils/add.ts
+function add(left, right, subtract = false) {
+	const lN = left.n;
+	const rN = right.n;
+	if (lN === "OVERFLOW") return left;
+	if (rN === "OVERFLOW") return right;
+	const { d: lD, c, e } = left;
+	const { d: rD, c: rC, e: rE } = right;
+	if (lN === 0n) return {
+		n: subtract ? -rN : rN,
+		d: rD,
+		c: rC,
+		e: rE
+	};
+	if (rN === 0n) return {
+		n: lN,
+		d: lD,
+		c,
+		e
+	};
+	let n;
+	let d;
+	if (lD === rD) {
+		n = subtract ? lN - rN : lN + rN;
+		d = lD;
+	} else {
+		const common = gcd(lD, rD);
+		const mLeft = rD / common;
+		const mRight = lD / common;
+		n = subtract ? lN * mLeft - rN * mRight : lN * mLeft + rN * mRight;
+		d = lD * mLeft;
+	}
+	if (n === 0n) return ZERO;
+	if (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left), toSimpleFraction(right), subtract);
+	return {
+		n,
+		d,
+		c,
+		e
+	};
+}
+//#endregion
+//#region src/lib/utils/ceil.ts
+/**
+* Returns the smallest integer greater than or equal to the value.
+*/
+function ceil(v) {
+	const { n, d } = simplify(v);
+	if (d === 1n) return n;
+	const isPositive = n > 0;
+	const result = n / d;
+	const hasRemainder = n % d !== 0n;
+	return isPositive && hasRemainder ? result + 1n : result;
+}
+//#endregion
+//#region src/lib/utils/divide.ts
+function divide(left, right) {
+	const lN = left.n;
+	const rN = right.n;
+	if (rN === 0n) throw new DivisionByZeroError();
+	if (lN === 0n) return ZERO;
+	if (lN === "OVERFLOW" || rN === "OVERFLOW") return OverflowValue;
+	const { d: lD, c: lC, e: lE } = left;
+	const { d: rD, c: rC, e: rE } = right;
+	const g1 = gcd(lN, rN);
+	const g2 = gcd(rD, lD);
+	const n = lN / g1 * (rD / g2);
+	const d = lD / g2 * (rN / g1);
+	if (lC !== void 0 && lC === rC) return {
+		n,
+		d,
+		c: lC,
+		e: simplify(add({
+			n: lE?.n ?? 1n,
+			d: lE?.d ?? 1n
+		}, {
+			n: rE?.n ?? 1n,
+			d: rE?.d ?? 1n
+		}, true))
+	};
+	const c = lC ?? rC;
+	let e;
+	if (lC !== void 0) e = lE ? {
+		n: lE.n,
+		d: lE.d ?? 1n
+	} : {
+		n: 1n,
+		d: 1n
+	};
+	else if (rC !== void 0) e = {
+		n: -(rE?.n ?? 1n),
+		d: rE?.d ?? 1n
+	};
+	return {
+		n,
+		d,
+		c,
+		e
+	};
+}
+//#endregion
+//#region src/lib/utils/sqrt.ts
+/**
+* Calculates the integer square root of a BigInt.
+*/
+function isqrt(value) {
+	if (value < 0) throw new NotImplementedError("Square root of negative numbers is not implemented yet.");
+	if (value < 2n) return value;
+	let res = 0n;
+	let bit = 1n << (BigInt.bitLength(value) & -2n);
+	while (bit !== 0n) {
+		if (value >= res + bit) {
+			value -= res + bit;
+			res = (res >> 1n) + bit;
+		} else res >>= 1n;
+		bit >>= 2n;
+	}
+	return res;
+}
+function isPerfectSquare(val) {
+	if (val < 0) return [false, 0n];
+	const root = isqrt(val);
+	return [root * root === val, root];
+}
+function sqrt(v, precision) {
+	if (v.n === "OVERFLOW") return v;
+	if (v.n < 0) throw new NotImplementedError("Square root of negative numbers is not implemented yet.");
+	if (v.n === 0n) return ZERO;
+	if (precision.format === "precise") {
+		const [nIsSquare, n] = isPerfectSquare(v.n);
+		const [dIsSquare, d] = isPerfectSquare(v.d);
+		if (nIsSquare && dIsSquare) {
+			const e = simplify({
+				n: v.e?.n ?? 1n,
+				d: (v.e?.d ?? 1n) * 2n
+			});
+			return simplify({
+				n,
+				d,
+				c: v.c,
+				e
+			});
+		}
+	}
+	const precisionDigits = Math.max(10, (precision.maxDecimals ?? 30) * 3);
+	const scaleFactor = 10n ** BigInt(precisionDigits * 2);
+	return simplify({
+		n: isqrt(v.n * scaleFactor / v.d),
+		d: 10n ** BigInt(precisionDigits)
+	});
+}
+//#endregion
+//#region src/lib/utils/exponentiate.ts
+/**
+* Maximum digits allowed for the result of exponentiation
+*/
+const MAX_EXPONENT_RESULT_DIGITS = 10000000n;
+function exponentiate(left, right, precision) {
+	const rN = right.n;
+	if (rN === 0n) return ONE;
+	const lN = left.n;
+	if (lN === "OVERFLOW") return left;
+	const lD = left.d;
+	const c = left.c;
+	if (lN === lD && c === void 0) return ONE;
+	if (rN === "OVERFLOW") return right;
+	if (lN === -lD && c === void 0) {
+		if (rN % 2n) return {
+			n: -1n,
+			d: 1n
+		};
+		return ONE;
+	}
+	const normalizedExp = toSimpleFraction(simplify(right));
+	let exponent = normalizedExp.n;
+	if (lN === 0n) {
+		if (exponent < 0) throw new DivisionByZeroError();
+		return ZERO;
+	}
+	const dExp = normalizedExp.d;
+	if (dExp >= 100) {
+		let baseFloat = Number(lN) / Number(lD);
+		if (c) baseFloat *= Number(constants[c]);
+		const expFloat = Number(exponent) / Number(dExp);
+		const resultFloat = baseFloat ** expFloat;
+		if (!Number.isFinite(resultFloat)) return OverflowValue;
+		const [integerPart, fractionalPart] = resultFloat.toString().split(".");
+		if (!fractionalPart) return simplify({
+			n: BigInt(integerPart),
+			d: 1n
+		});
+		const denominator = 10n ** BigInt(fractionalPart.length);
+		return simplify({
+			n: BigInt(integerPart + fractionalPart),
+			d: denominator
+		});
+	}
+	const eN = (left.e?.n ?? 1n) * exponent;
+	let baseN = lN;
+	let baseD = lD;
+	if (exponent < 0) {
+		exponent = -exponent;
+		[baseN, baseD] = [baseD, baseN];
+	}
+	const baseNDigits = BigInt.bitLength(baseN);
+	const baseDDigits = BigInt.bitLength(baseD);
+	if (baseNDigits * exponent > MAX_EXPONENT_RESULT_DIGITS || baseDDigits * exponent > MAX_EXPONENT_RESULT_DIGITS || (baseNDigits > 5e3 || baseDDigits > 5e3) && exponent > 10) return OverflowValue;
+	const e = c ? simplify({
+		n: eN,
+		d: left.e?.d ?? 1n
+	}) : void 0;
+	if (dExp === exponent) return {
+		n: baseN,
+		d: baseD,
+		c,
+		e
+	};
+	const v = {
+		n: baseN ** exponent,
+		d: baseD ** exponent,
+		c,
+		e
+	};
+	if (dExp === 1n) return v;
+	if (dExp === 2n) return sqrt(v, precision);
+	return nthRoot(v, dExp, precision);
+}
+//#endregion
+//#region src/lib/utils/factorial.ts
+function binaryProduct(arr, low, high) {
+	if (low > high) return 1n;
+	if (low === high) return arr[low];
+	const mid = Math.floor((low + high) / 2);
+	return binaryProduct(arr, low, mid) * binaryProduct(arr, mid + 1, high);
+}
+function getPrimes(limit) {
+	const sieve = new Uint8Array(limit + 1).fill(1);
+	sieve[0] = sieve[1] = 0;
+	for (let i = 2; i * i <= limit; i++) if (sieve[i]) for (let j = i * i; j <= limit; j += i) sieve[j] = 0;
+	const result = [];
+	for (let i = 2; i <= limit; i++) if (sieve[i]) result.push(i);
+	return result;
+}
+/**
+* Calculates factorial.
+*/
+function factorial(n) {
+	if (n < 0) return null;
+	if (n === 0n || n === 1n) return 1n;
+	if (n < 1000n) {
+		let result = 1n;
+		for (let i = 2n; i <= n; i++) result *= i;
+		return result;
+	}
+	const primes = getPrimes(Number(n));
+	const primePowers = [];
+	for (const p of primes) {
+		let exponent = 0n;
+		let currentN = n;
+		const pBig = BigInt(p);
+		while (currentN >= pBig) {
+			currentN /= pBig;
+			exponent += currentN;
+		}
+		primePowers.push(pBig ** exponent);
+	}
+	return binaryProduct(primePowers, 0, primePowers.length - 1);
+}
+//#endregion
+//#region src/lib/utils/floor.ts
+/**
+* Returns the largest integer less than or equal to the value.
+*/
+function floor(v) {
+	const { n, d } = simplify(v);
+	if (d === 1n) return n;
+	const isNegative = n < 0;
+	const result = n / d;
+	const hasRemainder = n % d !== 0n;
+	return isNegative && hasRemainder ? result - 1n : result;
+}
+//#endregion
+//#region src/lib/utils/mod.ts
+/**
+* Calculates remainder of division.
+*/
+function mod(a, b) {
+	if (b.n === 0n) throw new DivisionByZeroError();
+	const d = a.d * b.d / gcd(a.d, b.d);
+	const n1 = a.n * (d / a.d);
+	const n2 = b.n * (d / b.d);
+	return {
+		n: (n1 % n2 + n2) % n2,
+		d
+	};
+}
+//#endregion
+//#region src/lib/interpreter.ts
+const precedence = {
+	LPAREN: 0,
+	ABS_OPEN: 0,
+	ADD: 1,
+	SUBTRACT: 1,
+	MULTIPLY: 2,
+	DIVIDE: 2,
+	MOD: 2,
+	UNARY_PLUS: 4,
+	UNARY_MINUS: 4,
+	EXP: 6,
+	IMPLICIT_MUL: 6,
+	ABS_FN: 8,
+	CEIL_FN: 8,
+	FLOOR_FN: 8,
+	SQRT_FN: 8,
+	FACTORIAL: 10
+};
+function isUnaryOperation(op) {
+	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || op === "ABS_FN" || op === "CEIL_FN" || op === "FLOOR_FN" || op === "SQRT_FN";
+}
+/**
+* Maximum allowed precision
+*/
+const MAX_PRECISION = 5e4;
+/**
+* Maximum allowed factorial
+*/
+const MAX_FACTORIAL = 2e4;
+/**
+* Maximum allowed exponent for scientific number notation
+*/
+const MAX_SCIENTIFIC_NUMBER_EXPONENT = 3e5;
+function evaluate(tokens, options = {}) {
+	if (tokens.length === 0) throw new EmptyExpressionError();
+	const values = [];
+	const ops = [];
+	const applyOp = (pos) => {
+		const op = ops.pop();
+		if (!op || op === "LPAREN" || op === "ABS_OPEN") return;
+		const right = values.pop();
+		if (isUnaryOperation(op)) switch (op) {
+			case "UNARY_PLUS":
+				values.push(right);
+				return;
+			case "UNARY_MINUS": {
+				const rN = right.n;
+				if (rN === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
+				values.push({
+					...right,
+					n: -rN
+				});
+				return;
+			}
+			case "ABS_FN": {
+				const rN = right.n;
+				if (rN === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
+				const n = rN < 0 ? -rN : rN;
+				values.push({
+					...right,
+					n
+				});
+				return;
+			}
+			case "CEIL_FN":
+				if (right.n === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
+				values.push({
+					n: ceil(toSimpleFraction(right)),
+					d: 1n
+				});
+				return;
+			case "FLOOR_FN":
+				if (right.n === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
+				values.push({
+					n: floor(toSimpleFraction(right)),
+					d: 1n
+				});
+				return;
+			case "SQRT_FN":
+				values.push(sqrt(right, options));
+				return;
+		}
+		if (op === "FACTORIAL") {
+			if (right.n === "OVERFLOW") {
+				values.push(OverflowValue);
+				return;
+			}
+			const reduced = simplify(right);
+			if (reduced.d !== 1n || reduced.n < 0) throw new NotImplementedError("Factorial is only implemented for non-negative integers.", pos);
+			if (reduced.n >= MAX_FACTORIAL) {
+				values.push(OverflowValue);
+				return;
+			}
+			values.push({
+				n: factorial(reduced.n),
+				d: 1n
+			});
+			return;
+		}
+		const left = values.pop();
+		switch (op) {
+			case "ADD":
+			case "SUBTRACT":
+				values.push(add(left, right, op === "SUBTRACT"));
+				return;
+			case "MULTIPLY":
+			case "IMPLICIT_MUL":
+				values.push(multiply(left, right));
+				return;
+			case "DIVIDE":
+				values.push(divide(left, right));
+				return;
+			case "MOD":
+				if (left.n === "OVERFLOW" || right.n === "OVERFLOW") {
+					values.push(OverflowValue);
+					return;
+				}
+				values.push(mod(left, right));
+				return;
+			case "EXP":
+				values.push(exponentiate(left, right, options));
+				return;
+		}
+	};
+	const pushOpWithPrecedence = (currentOp, pos) => {
+		const isUnary = isUnaryOperation(currentOp);
+		const isRightAssociative = currentOp === "EXP" || currentOp === "IMPLICIT_MUL";
+		while (ops.length > 0 && !isUnary && (isRightAssociative ? precedence[ops[ops.length - 1]] > precedence[currentOp] : precedence[ops[ops.length - 1]] >= precedence[currentOp])) applyOp(pos);
+		ops.push(currentOp);
+	};
+	for (const token of tokens) switch (token.type) {
+		case "NUMBER": {
+			const frac = token.fraction || "";
+			const fl = frac.length;
+			if (fl > MAX_PRECISION) throw new MaximumPrecisionError(fl, MAX_PRECISION);
+			let n = BigInt(token.whole + frac);
+			let d = fl === 0 ? 1n : 10n ** BigInt(fl);
+			if (token.exponent) {
+				if (token.exponent.length > MAX_PRECISION) throw new MaximumPrecisionError(token.exponent.length, MAX_PRECISION);
+				const expValue = BigInt(token.exponent);
+				if (expValue > MAX_SCIENTIFIC_NUMBER_EXPONENT) {
+					values.push(OverflowValue);
+					break;
+				}
+				if (expValue >= 0) n *= 10n ** expValue;
+				else d *= 10n ** -expValue;
+			}
+			if (d === 1n) values.push({
+				n,
+				d: 1n
+			});
+			else values.push({
+				n,
+				d
+			});
+			break;
+		}
+		case "CONST":
+			if (options.format === "precise") values.push({
+				n: 1n,
+				d: 1n,
+				c: token.id
+			});
+			else values.push(getConst(token.id));
+			break;
+		case "LPAREN":
+			ops.push("LPAREN");
+			break;
+		case "RPAREN": {
+			let foundMatch = false;
+			while (ops.length > 0) {
+				if (ops[ops.length - 1] === "LPAREN") {
+					foundMatch = true;
+					break;
+				}
+				applyOp(token.pos);
+			}
+			if (!foundMatch) throw new MismatchedParenthesisError(token.pos);
+			ops.pop();
+			break;
+		}
+		case "ABS_OPEN":
+			ops.push("ABS_OPEN");
+			break;
+		case "ABS_CLOSE": {
+			while (ops.length > 0) {
+				if (ops[ops.length - 1] === "ABS_OPEN") break;
+				applyOp(token.pos);
+			}
+			ops.pop();
+			const val = values.pop();
+			if (val.n === "OVERFLOW") {
+				values.push(OverflowValue);
+				break;
+			}
+			values.push({
+				n: val.n < 0 ? -val.n : val.n,
+				d: val.d,
+				c: val.c
+			});
+			break;
+		}
+		case "PLUS":
+			pushOpWithPrecedence("ADD", token.pos);
+			break;
+		case "MINUS":
+			pushOpWithPrecedence("SUBTRACT", token.pos);
+			break;
+		case "MUL":
+			pushOpWithPrecedence("MULTIPLY", token.pos);
+			break;
+		case "DIV":
+			pushOpWithPrecedence("DIVIDE", token.pos);
+			break;
+		case "POW":
+			pushOpWithPrecedence("EXP", token.pos);
+			break;
+		case "UNARY_PLUS":
+			pushOpWithPrecedence("UNARY_PLUS", token.pos);
+			break;
+		case "UNARY_MINUS":
+			pushOpWithPrecedence("UNARY_MINUS", token.pos);
+			break;
+		case "IMPLICIT_MUL":
+			pushOpWithPrecedence("IMPLICIT_MUL", token.pos);
+			break;
+		case "FACTORIAL":
+			pushOpWithPrecedence("FACTORIAL", token.pos);
+			break;
+		case "MOD":
+			pushOpWithPrecedence("MOD", token.pos);
+			break;
+		case "FUNC":
+			switch (token.id) {
+				case "abs":
+					pushOpWithPrecedence("ABS_FN", token.pos);
+					break;
+				case "ceil":
+					pushOpWithPrecedence("CEIL_FN", token.pos);
+					break;
+				case "floor":
+					pushOpWithPrecedence("FLOOR_FN", token.pos);
+					break;
+				case "sqrt":
+					pushOpWithPrecedence("SQRT_FN", token.pos);
+					break;
+			}
+			break;
+	}
+	while (ops.length > 0) {
+		const top = ops[ops.length - 1];
+		const lastPos = tokens[tokens.length - 1]?.pos ?? 0;
+		if (top === "LPAREN") {
+			ops.pop();
+			continue;
+		}
+		applyOp(lastPos);
+	}
+	const finalValue = values.pop();
+	if (finalValue.n === "OVERFLOW") throw new OverflowError();
+	return simplify(finalValue);
+}
+//#endregion
+//#region src/lib/lexer.ts
+var LexerError = class extends GenericMathErrror {
+	constructor(message, pos) {
+		super("LexerError", message, pos);
+	}
+};
+function isWhitespace(ch) {
+	return ch === " ";
+}
+function isDigit(ch) {
+	if (ch === void 0) return false;
+	return ch >= "0" && ch <= "9";
+}
+function isAlpha(ch) {
+	if (ch === void 0) return false;
+	return ch >= "a" && ch <= "z";
+}
+/**
+* Maximum allowed expression length
+*/
+const MAX_EXPRESSION_LENGTH = 75e6;
+/**
+* Simple lexer (tokenizer).
+*/
+function tokenize(expression, options = {}) {
+	const { decimalSeparator = "." } = options;
+	const tokens = [];
+	let index = 0;
+	const length = expression.length;
+	if (length > MAX_EXPRESSION_LENGTH) throw new LexerError(`Expression length (${length}) exceeds the maximum allowed limit of ${MAX_EXPRESSION_LENGTH}`, 0);
+	while (index < length) {
+		const ch = expression[index];
+		const startPos = index;
+		if (isWhitespace(ch)) {
+			index++;
+			continue;
+		}
+		if (isDigit(ch) || ch === decimalSeparator) {
+			let whole = "";
+			let fraction = void 0;
+			let exponent = void 0;
+			const startIdx = index;
+			if (ch === decimalSeparator) {
+				whole = "0";
+				index++;
+				const fracStart = index;
+				while (index < length && isDigit(expression[index])) index++;
+				if (index === fracStart) throw new LexerError("Expected digit after decimal separator", index);
+				fraction = expression.slice(fracStart, index);
+			} else {
+				while (index < length && isDigit(expression[index])) index++;
+				whole = expression.slice(startIdx, index);
+				if (index < length && expression[index] === decimalSeparator) {
+					index++;
+					const fracStart = index;
+					while (index < length && isDigit(expression[index])) index++;
+					fraction = expression.slice(fracStart, index);
+				}
+			}
+			if (index < length && (expression[index] === "e" || expression[index] === "E")) {
+				let lookahead = index + 1;
+				let sign = "";
+				const next = expression[lookahead];
+				if (lookahead < length && (next === "+" || next === "-")) {
+					sign = next;
+					lookahead++;
+				}
+				if (lookahead < length && isDigit(expression[lookahead])) {
+					index = lookahead;
+					let expBuffer = sign;
+					while (index < length && isDigit(expression[index])) {
+						expBuffer += expression[index];
+						index++;
+					}
+					exponent = expBuffer;
+				}
+			}
+			if (index < length && expression[index] === decimalSeparator) throw new LexerError("Invalid decimal number format", index);
+			tokens.push({
+				type: "NUMBER",
+				whole,
+				fraction,
+				exponent,
+				pos: startPos
+			});
+			continue;
+		}
+		if (isAlpha(ch)) {
+			let id = "";
+			while (index < length && isAlpha(expression[index])) id += expression[index++];
+			tokens.push({
+				type: "IDENTIFIER",
+				id,
+				pos: startPos
+			});
+			continue;
+		}
+		if (ch === "(") {
+			tokens.push({
+				type: "LPAREN",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === ")") {
+			tokens.push({
+				type: "RPAREN",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "+") {
+			tokens.push({
+				type: "PLUS",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "-") {
+			tokens.push({
+				type: "MINUS",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "*") {
+			tokens.push({
+				type: "MUL",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "/") {
+			tokens.push({
+				type: "DIV",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "^") {
+			tokens.push({
+				type: "POW",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "!") {
+			tokens.push({
+				type: "FACTORIAL",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "|") {
+			tokens.push({
+				type: "PIPE",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		if (ch === "%") {
+			tokens.push({
+				type: "MOD",
+				pos: startPos
+			});
+			index++;
+			continue;
+		}
+		throw new LexerError(`Unexpected character '${ch}'`, index);
+	}
+	return tokens;
+}
+//#endregion
+//#region src/lib/symbol.ts
+const symbolMap = {
+	PLUS: "+",
+	UNARY_PLUS: "+",
+	MINUS: "-",
+	UNARY_MINUS: "-",
+	MUL: "*",
+	DIV: "/",
+	LPAREN: "(",
+	RPAREN: ")",
+	POW: "^",
+	IMPLICIT_MUL: "",
+	FACTORIAL: "!",
+	ABS_CLOSE: "|",
+	ABS_OPEN: "|",
+	PIPE: "|",
+	MOD: "%"
+};
+const prettifyNumber = (t) => t.fraction ? `${t.whole}.${t.fraction}` : t.whole;
+function getSym(t) {
+	if (t.type === "NUMBER") return prettifyNumber(t);
+	if (t.type === "IDENTIFIER") return t.id;
+	return symbolMap[t.type];
+}
+//#endregion
+//#region src/lib/parser.ts
+/**
+* Helper: Is the last token an "operand" (something that can be followed by a closing pipe or implicit mul)?
+*/
+function isOperand(last) {
+	if (!last) return false;
+	return last.type === "NUMBER" || last.type === "CONST" || last.type === "RPAREN" || last.type === "ABS_CLOSE" || last.type === "FACTORIAL";
+}
+function isBinaryOperator(token) {
+	return token.type === "MUL" || token.type === "DIV" || token.type === "POW" || token.type === "MOD";
+}
+/**
+* Helper: Does the current context allow a +/- to be unary?
+*/
+function isUnaryContext(last) {
+	return !isOperand(last);
+}
+var ParserError = class extends GenericMathErrror {
+	constructor(message, pos) {
+		super("ParserError", message, pos);
+	}
+};
+var IncompleteExpressionError = class extends ParserError {
+	constructor(message, pos) {
+		super(`Incomplete expression: ${message}`, pos);
+	}
+};
+var UnexpectedOperatorError = class extends ParserError {
+	constructor(message, pos) {
+		super(`Unexpected operator: ${message}`, pos);
+	}
+};
+function resolveIdentifier(token) {
+	if (token.id === "pi" || token.id === "e") return {
+		type: "CONST",
+		id: token.id,
+		pos: token.pos
+	};
+	if (token.id === "abs" || token.id === "ceil" || token.id === "floor" || token.id === "sqrt") return {
+		type: "FUNC",
+		id: token.id,
+		pos: token.pos
+	};
+	throw new ParserError(`Unknown identifier '${token.id}'`, token.pos);
+}
+function parse(tokens) {
+	if (tokens.length === 0) return [];
+	const result = [];
+	let absStack = 0;
+	for (let i = 0; i < tokens.length; i++) {
+		let token = tokens[i];
+		const prev = tokens[i - 1];
+		if (token.type === "IDENTIFIER") token = resolveIdentifier(token);
+		let prevParsed = result[result.length - 1];
+		if (token.type === "PIPE") {
+			if (absStack > 0 && isOperand(prevParsed)) {
+				result.push({
+					type: "ABS_CLOSE",
+					pos: token.pos
+				});
+				absStack--;
+			} else {
+				if (isOperand(prevParsed)) result.push({
+					type: "IMPLICIT_MUL",
+					pos: token.pos
+				});
+				result.push({
+					type: "ABS_OPEN",
+					pos: token.pos
+				});
+				absStack++;
+			}
+			continue;
+		}
+		if (isOperand(prevParsed)) {
+			if (token.type === "LPAREN" || token.type === "FUNC" || token.type === "NUMBER" || token.type === "CONST") result.push({
+				type: "IMPLICIT_MUL",
+				pos: token.pos
+			});
+		}
+		prevParsed = result[result.length - 1];
+		if (isBinaryOperator(token)) {
+			if (isUnaryContext(prevParsed)) throw new UnexpectedOperatorError(`Unexpected operator '${getSym(token)}'`, token.pos);
+		}
+		if (token.type === "FACTORIAL") {
+			if (!isOperand(prevParsed) && prevParsed?.type !== "RPAREN") throw new UnexpectedOperatorError("Unexpected factorial operator", token.pos);
+		}
+		if (token.type === "RPAREN") {
+			if (prevParsed && (prevParsed.type === "PLUS" || prevParsed.type === "MINUS" || isBinaryOperator(prevParsed))) throw new UnexpectedOperatorError(`Unexpected ')' after operator '${getSym(prevParsed)}'`, token.pos);
+			if (prevParsed?.type === "LPAREN") throw new UnexpectedOperatorError("Unexpected ')' after '('", token.pos);
+		}
+		if (prev && (prev.type === "NUMBER" || prev.type === "IDENTIFIER" && resolveIdentifier(prev).type === "CONST") && token.type === "NUMBER") throw new ParserError("Missing operator between numbers", token.pos);
+		if ((token.type === "PLUS" || token.type === "MINUS") && isUnaryContext(prevParsed)) result.push({
+			type: token.type === "PLUS" ? "UNARY_PLUS" : "UNARY_MINUS",
+			pos: token.pos
+		});
+		else result.push(token);
+	}
+	if (absStack > 0) throw new ParserError("Unclosed absolute value '|'", result[result.length - 1]?.pos ?? 0);
+	const last = result[result.length - 1];
+	if (last && last.type !== "CONST" && (isBinaryOperator(last) || [
+		"PLUS",
+		"MINUS",
+		"UNARY_PLUS",
+		"UNARY_MINUS",
+		"FUNC",
+		"ABS_OPEN",
+		"LPAREN"
+	].includes(last.type))) throw new IncompleteExpressionError(`trailing operator '${last.type === "FUNC" ? last.id : getSym(last)}'`, last.pos);
+	return result;
+}
+//#endregion
+//#region src/utils/format-result.ts
+function getConstantStr(coeff, c, e) {
+	if (coeff === 0n) return "0";
+	if (!c) return `${coeff}`;
+	const isOne = e && e.n === 1n && (e.d === void 0 || e.d === 1n);
+	if (!e || isOne) {
+		if (coeff === 1n) return c;
+		if (coeff === -1n) return `-${c}`;
+		return `${coeff}${c}`;
+	}
+	const num = e.n;
+	const den = e.d ?? 1n;
+	const expStr = den === 1n ? `${num}` : `(${num}/${den})`;
+	const constantStr = den === 2n * num ? `sqrt(${c})` : `${c}^${expStr}`;
+	if (coeff === 1n) return constantStr;
+	if (coeff === -1n) return `-${constantStr}`;
+	return `${coeff}${constantStr}`;
+}
+function formatPrecise(v) {
+	const { n, d, c, e } = v;
+	if (n === 0n) return "0";
+	const isNegative = n < 0;
+	const absN = isNegative ? -n : n;
+	const numSign = isNegative ? "-" : "";
+	if (c && e && e.n < 0n) return `${numSign}${absN}/${getConstantStr(d, c, {
+		n: -e.n,
+		d: e.d
+	})}`;
+	const numeratorStr = getConstantStr(absN, c, e);
+	if (d === 1n) return `${numSign}${numeratorStr}`;
+	return `${numSign}${numeratorStr}/${d}`;
+}
+/**
+* Converts Result to a Decimal or Fraction String.
+*/
+function formatResult(v, options = {}) {
+	const { n, d } = v;
+	if (d === 0n) return "NaN";
+	if (options.format === "precise") return formatPrecise(v);
+	const { maxDecimals = 30, roundingMode = "round" } = options;
+	const isNegative = n < 0;
+	const absN = isNegative ? -n : n;
+	let integerPart = (absN / d).toString();
+	let remainder = absN % d;
+	if (remainder === 0n) {
+		const res = (isNegative ? "-" : "") + integerPart;
+		return res === "-0" ? "0" : res;
+	}
+	let fractionalPart = "";
+	let count = 0;
+	const targetLength = maxDecimals + 1;
+	while (remainder !== 0n && count < targetLength) {
+		remainder *= 10n;
+		fractionalPart += (remainder / d).toString();
+		remainder %= d;
+		count++;
+	}
+	const nexDigitStr = fractionalPart[maxDecimals];
+	if (nexDigitStr) {
+		const nextDigit = parseInt(nexDigitStr, 10);
+		fractionalPart = fractionalPart.slice(0, maxDecimals);
+		if (roundingMode === "round" && nextDigit >= 5) {
+			const incremented = (BigInt(fractionalPart) + 1n).toString();
+			if (incremented.length > fractionalPart.length) {
+				integerPart = (BigInt(integerPart) + 1n).toString();
+				fractionalPart = incremented.slice(1);
+			} else fractionalPart = incremented.padStart(fractionalPart.length, "0");
+		}
+	}
+	let lastNonZero = -1;
+	for (let i = fractionalPart.length - 1; i >= 0; i--) if (fractionalPart[i] !== "0") {
+		lastNonZero = i;
+		break;
+	}
+	const finalFraction = lastNonZero === -1 ? "" : fractionalPart.slice(0, lastNonZero + 1);
+	const result = finalFraction === "" ? integerPart : `${integerPart}.${finalFraction}`;
+	return (isNegative && result !== "0" ? "-" : "") + result;
+}
+//#endregion
+//#region src/index.ts
+/**
+* The main entry point for the library.
+*/
+function calculate(expression, options) {
+	return formatResult(evaluate(parse(tokenize(expression, options)), options), options);
+}
+//#endregion
+export { calculate };

package/package.json

@@ -1,4 +1,41 @@
 {
   "name": "picocalc",
-  "version": "0.0.0"
+  "version": "0.0.2",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/picocalc/math-parser.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "imports": {
+    "#src": "./src/index.ts",
+    "#lib/*": "./src/lib/*.ts"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "bench": "bun --cpu-prof-md --cpu-prof-dir ./bench/profiles bench/index.ts",
+    "test": "bun test --dots",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "build": "tsdown",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "bigint.bitlength": "0.2.0"
+  },
+  "devDependencies": {
+    "@gameroman/config": "0.2.2",
+    "@types/bun": "1.3.14",
+    "oxfmt": "0.57.0",
+    "oxlint": "1.72.0",
+    "oxlint-tsgolint": "0.24.0",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3"
+  }
 }