picocalc 0.0.0 → 0.0.1

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,16 @@
+//#region src/lib/interpreter.d.ts
+interface PrecisionOptions {
+  format?: "decimal" | "precise";
+  maxDecimals?: number;
+}
+//#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,1071 @@
+//#region src/lib/constants.ts
+const PI = Math.PI.toString();
+const constants = {
+	e: Math.E.toString(),
+	pi: PI
+};
+//#endregion
+//#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 LexerError = class extends GenericMathErrror {
+	constructor(message, pos) {
+		super("LexerError", message, pos);
+	}
+};
+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 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 UnexpectedEndOfExpressionError = class extends InterpreterError {
+	constructor() {
+		super("Unexpected end of expression");
+	}
+};
+var MismatchedParenthesisError = class extends InterpreterError {
+	constructor(pos, message = "Mismatched parenthesis") {
+		super(message, pos);
+	}
+};
+var InsufficientOperandsError = class extends InterpreterError {
+	constructor(pos) {
+		super("Insufficient operands for operation", pos);
+	}
+};
+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);
+	}
+};
+//#endregion
+//#region src/lib/utils/gcd.ts
+/**
+* Fast Binary GCD (Stein's 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 < 0n ? -a : a;
+	b = b < 0n ? -b : b;
+	let shift = 0n;
+	while (((a | b) & 1n) === 0n) {
+		a >>= 1n;
+		b >>= 1n;
+		shift++;
+	}
+	while ((a & 1n) === 0n) a >>= 1n;
+	do {
+		while ((b & 1n) === 0n) b >>= 1n;
+		if (a > b) [a, b] = [b, a];
+		b = b - a;
+	} while (b !== 0n);
+	return a << shift;
+}
+//#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 {
+		n: 0n,
+		d: 1n,
+		c: v.c
+	};
+	if (v.d === 1n) return v;
+	const common = gcd(v.n, v.d);
+	const sign = v.d < 0n ? -1n : 1n;
+	return {
+		n: v.n / common * sign,
+		d: v.d / common * sign,
+		c: v.c
+	};
+}
+//#endregion
+//#region src/lib/utils/ceil.ts
+/**
+* Returns the smallest integer greater than or equal to a Value.
+*/
+function ceil(v) {
+	const { n, d } = simplify(v);
+	if (d === 1n) return n;
+	const isPositive = n > 0n;
+	const result = n / d;
+	const hasRemainder = n % d !== 0n;
+	return isPositive && hasRemainder ? result + 1n : result;
+}
+//#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 < 0n) 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 a Value.
+*/
+function floor(v) {
+	const { n, d } = simplify(v);
+	if (d === 1n) return n;
+	const isNegative = n < 0n;
+	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) {
+	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/utils/multiply.ts
+function multiply(a, b) {
+	if (a.n === 0n || b.n === 0n) return {
+		n: 0n,
+		d: 1n
+	};
+	let n;
+	let d;
+	let c;
+	if (a.d === 1n && b.d === 1n) {
+		n = a.n * b.n;
+		d = 1n;
+	} else {
+		const g1 = gcd(a.n, b.d);
+		const g2 = gcd(b.n, a.d);
+		n = a.n / g1 * (b.n / g2);
+		d = a.d / g2 * (b.d / g1);
+	}
+	if (a.c === void 0 && b.c !== void 0) c = b.c;
+	else if (a.c !== void 0 && b.c === void 0) c = a.c;
+	return {
+		n,
+		d,
+		c
+	};
+}
+//#endregion
+//#region src/lib/utils/nthroot.ts
+/**
+* Calculates the integer nth root of a BigInt.
+*/
+function iNthRoot(value, n) {
+	if (value < 0n && n % 2n === 0n) throw new InterpreterError("Even root of negative number is not supported yet.");
+	if (value < 0n) return -iNthRoot(-value, n);
+	if (value < 2n) return value;
+	if (n === 1n) return value;
+	let x = 1n << BigInt(value.toString(2).length) / 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 Value (fraction).
+*/
+function nthRoot(v, root, precise = false, precisionDigits = 100) {
+	if (root === 0n) throw new DivisionByZeroError();
+	if (root === 1n) return v;
+	if (v.n < 0n) {
+		if (root % 2n === 0n) throw new InterpreterError(`${root}-th root of negative not supported.`);
+		const positiveResult = nthRoot({
+			n: -v.n,
+			d: v.d
+		}, root, precise, precisionDigits);
+		return {
+			n: -positiveResult.n,
+			d: positiveResult.d
+		};
+	}
+	if (v.n === 0n) return {
+		n: 0n,
+		d: 1n
+	};
+	if (precise) {
+		const rootN = iNthRoot(v.n, root);
+		const rootD = iNthRoot(v.d, root);
+		if (rootN ** root === v.n && rootD ** root === v.d) return simplify({
+			n: rootN,
+			d: rootD
+		});
+	}
+	const scaleFactor = 10n ** (BigInt(precisionDigits) * root);
+	return simplify({
+		n: iNthRoot(v.n * scaleFactor / v.d, root),
+		d: 10n ** BigInt(precisionDigits)
+	});
+}
+//#endregion
+//#region src/lib/utils/sqrt.ts
+/**
+* Calculates the integer square root of a BigInt.
+*/
+function isqrt(value) {
+	if (value < 0n) throw new InterpreterError("Square root of negative not supported yet.");
+	if (value < 2n) return value;
+	let res = 0n;
+	let bit = 1n << BigInt(value.toString(2).length - 1 & -2);
+	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 < 0n) return [false, 0n];
+	const root = isqrt(val);
+	return [root * root === val, root];
+}
+function sqrt(v, precise = false, precisionDigits = 100) {
+	if (v.n < 0n) throw new InterpreterError("Square root of negative not supported yet.");
+	if (v.n === 0n) return {
+		n: 0n,
+		d: 1n
+	};
+	if (precise) {
+		const [nIsSquare, nRoot] = isPerfectSquare(v.n);
+		const [dIsSquare, dRoot] = isPerfectSquare(v.d);
+		if (nIsSquare && dIsSquare) return simplify({
+			n: nRoot,
+			d: dRoot
+		});
+	}
+	const scaleFactor = 10n ** BigInt(precisionDigits * 2);
+	return simplify({
+		n: isqrt(v.n * scaleFactor / v.d),
+		d: 10n ** BigInt(precisionDigits)
+	});
+}
+//#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";
+}
+function getConst(id) {
+	const c = constants[id];
+	return {
+		n: BigInt(c.replace(".", "")),
+		d: 10n ** BigInt(c.length - c.indexOf(".") - 1)
+	};
+}
+/**
+* Maximum allowed precision
+*/
+const MAX_PRECISION = 5e4;
+/**
+* Threshold to prevent denominators from growing infinitely.
+*/
+const SIMPLIFY_THRESHOLD = 10n ** 4000n;
+function evaluate(tokens, options = {}) {
+	if (tokens.length === 0) throw new EmptyExpressionError();
+	const { format } = options;
+	const values = [];
+	const ops = [];
+	const applyOp = (pos) => {
+		const op = ops.pop();
+		if (!op || op === "LPAREN" || op === "ABS_OPEN") return;
+		const right = values.pop();
+		if (right === void 0) throw new UnexpectedEndOfExpressionError();
+		if (isUnaryOperation(op)) switch (op) {
+			case "UNARY_PLUS":
+				values.push(right);
+				return;
+			case "UNARY_MINUS":
+				values.push({
+					n: -right.n,
+					d: right.d,
+					c: right.c
+				});
+				return;
+			case "ABS_FN": {
+				const rN = right.n;
+				values.push({
+					n: rN < 0n ? -rN : rN,
+					d: right.d,
+					c: right.c
+				});
+				return;
+			}
+			case "CEIL_FN":
+				values.push({
+					n: ceil(right),
+					d: 1n
+				});
+				return;
+			case "FLOOR_FN":
+				values.push({
+					n: floor(right),
+					d: 1n
+				});
+				return;
+			case "SQRT_FN": {
+				if (right.c === void 0) {
+					values.push(sqrt(right, format === "precise"));
+					return;
+				}
+				const v = multiply(right, getConst(right.c));
+				values.push(sqrt(v, format === "precise"));
+				return;
+			}
+		}
+		if (op === "FACTORIAL") {
+			const reduced = simplify(right);
+			if (reduced.d !== 1n || reduced.n < 0n) throw new InterpreterError("Factorial is only defined for non-negative integers", pos);
+			if (reduced.n >= 4e5) throw new OverflowError();
+			values.push({
+				n: factorial(reduced.n),
+				d: 1n
+			});
+			return;
+		}
+		const left = values.pop();
+		if (left === void 0) throw new InsufficientOperandsError(pos);
+		let resN;
+		let resD;
+		let resC;
+		const lN = left.n;
+		const lD = left.d;
+		const lC = left.c;
+		const rN = right.n;
+		const rD = right.d;
+		const rC = right.c;
+		switch (op) {
+			case "ADD":
+			case "SUBTRACT": {
+				const isSub = op === "SUBTRACT";
+				if (lN === 0n) {
+					resN = isSub ? -rN : rN;
+					resD = rD;
+					resC = rC;
+					break;
+				}
+				if (rN === 0n) {
+					resN = lN;
+					resD = lD;
+					resC = lC;
+					break;
+				}
+				if (lD === rD) {
+					resN = isSub ? lN - rN : lN + rN;
+					resD = lD;
+				} else {
+					const common = gcd(lD, rD);
+					if (common === 1n) {
+						resN = isSub ? lN * rD - rN * lD : lN * rD + rN * lD;
+						resD = lD * rD;
+					} else {
+						const mLeft = rD / common;
+						const mRight = lD / common;
+						resN = isSub ? lN * mLeft - rN * mRight : lN * mLeft + rN * mRight;
+						resD = lD * mLeft;
+					}
+				}
+				if (lC === rC && resN !== 0n) resC = lC;
+				break;
+			}
+			case "MULTIPLY":
+			case "IMPLICIT_MUL": {
+				const result = multiply(left, right);
+				resN = result.n;
+				resD = result.d;
+				resC = result.c;
+				break;
+			}
+			case "DIVIDE": {
+				const g1 = gcd(lN, rN);
+				const g2 = gcd(rD, lD);
+				resN = lN / g1 * (rD / g2);
+				resD = lD / g2 * (rN / g1);
+				if (lC !== void 0 && rC === void 0) resC = lC;
+				break;
+			}
+			case "MOD": {
+				if (rN === 0n) throw new DivisionByZeroError();
+				const { n, d } = mod({
+					n: lN,
+					d: lD
+				}, {
+					n: rN,
+					d: rD
+				});
+				resN = n;
+				resD = d;
+				break;
+			}
+			case "EXP": {
+				const normalizedExponent = simplify(right);
+				let exponent = normalizedExponent.n;
+				if (exponent === 0n) {
+					resN = 1n;
+					resD = 1n;
+					break;
+				}
+				if (lN === 0n) {
+					if (rN < 0) throw new DivisionByZeroError();
+					resN = 0n;
+					resD = 1n;
+					break;
+				}
+				if (lN === lD && lC === void 0) {
+					resN = 1n;
+					resD = 1n;
+					break;
+				}
+				const exponentD = normalizedExponent.d;
+				if (exponentD === 2n) {
+					const rootResult = sqrt({
+						n: lN ** exponent,
+						d: lD ** exponent
+					}, format === "precise");
+					resN = rootResult.n;
+					resD = rootResult.d;
+					resC = rootResult.c;
+					break;
+				}
+				if (exponentD !== 1n) {
+					const rootResult = nthRoot({
+						n: lN ** exponent,
+						d: lD ** exponent
+					}, exponentD, format === "precise");
+					resN = rootResult.n;
+					resD = rootResult.d;
+					resC = rootResult.c;
+					break;
+				}
+				let baseN = lN;
+				let baseD = lD;
+				if (exponent < 0n) {
+					[baseN, baseD] = [baseD, baseN];
+					exponent = -exponent;
+				}
+				if (exponent === 1n) {
+					resN = baseN;
+					resD = baseD;
+					if (normalizedExponent.c === void 0) resC = lC;
+					break;
+				}
+				if (exponent > 1e4 && (baseN * exponent > 6e6 || baseD * exponent > 6e6)) throw new OverflowError();
+				if (!lC) {
+					resN = baseN ** exponent;
+					resD = baseD ** exponent;
+					break;
+				}
+				const c = getConst(lC);
+				resN = (baseN * c.n) ** exponent;
+				resD = (baseD * c.d) ** exponent;
+				break;
+			}
+		}
+		if (resD > SIMPLIFY_THRESHOLD) values.push(simplify({
+			n: resN,
+			d: resD,
+			c: resC
+		}));
+		else values.push({
+			n: resN,
+			d: resD,
+			c: resC
+		});
+	};
+	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 (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		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 > 2e6) throw new OverflowError();
+					if (expValue >= 0n) n *= 10n ** expValue;
+					else d *= 10n ** -expValue;
+				}
+				if (d === 1n) values.push({
+					n,
+					d: 1n
+				});
+				else values.push(simplify({
+					n,
+					d
+				}));
+				break;
+			}
+			case "CONST":
+				if (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": {
+				let foundMatch = false;
+				while (ops.length > 0) {
+					if (ops[ops.length - 1] === "ABS_OPEN") {
+						foundMatch = true;
+						break;
+					}
+					applyOp(token.pos);
+				}
+				if (!foundMatch) throw new InterpreterError("Mismatched absolute value pipe", token.pos);
+				ops.pop();
+				const val = values.pop();
+				if (val === void 0) throw new UnexpectedEndOfExpressionError();
+				values.push({
+					n: val.n < 0n ? -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 === void 0) throw new UnexpectedEndOfExpressionError();
+	return simplify(finalValue);
+}
+//#endregion
+//#region src/lib/lexer.ts
+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";
+}
+/**
+* Simple lexer (tokenizer).
+*/
+function tokenize(expression, options = {}) {
+	const { decimalSeparator = "." } = options;
+	const tokens = [];
+	let index = 0;
+	const length = expression.length;
+	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;
+			if (ch === decimalSeparator) {
+				whole = "0";
+				index++;
+				const fracStart = index;
+				let fracBuffer = "";
+				while (index < length && isDigit(expression[index])) {
+					fracBuffer += expression[index];
+					index++;
+				}
+				if (index === fracStart) throw new LexerError("Expected digit after decimal separator", index);
+				fraction = fracBuffer;
+			} else {
+				while (index < length && isDigit(expression[index])) {
+					whole += expression[index];
+					index++;
+				}
+				if (index < length && expression[index] === decimalSeparator) {
+					index++;
+					let fracBuffer = "";
+					const fracStart = index;
+					while (index < length && isDigit(expression[index])) {
+						fracBuffer += expression[index];
+						index++;
+					}
+					fraction = index === fracStart ? "0" : fracBuffer;
+				}
+			}
+			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);
+}
+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 ParserError(`Unexpected operator '${getSym(token)}'`, token.pos);
+		}
+		if (token.type === "FACTORIAL") {
+			if (!isOperand(prevParsed) && prevParsed?.type !== "RPAREN") throw new ParserError("Unexpected factorial operator", token.pos);
+		}
+		if (token.type === "RPAREN") {
+			if (prevParsed && (prevParsed.type === "PLUS" || prevParsed.type === "MINUS" || isBinaryOperator(prevParsed))) throw new ParserError(`Unexpected ')' after operator '${getSym(prevParsed)}'`, token.pos);
+			if (prevParsed?.type === "LPAREN") throw new ParserError("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"
+	].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
+const getConstantStr = (coeff, c) => {
+	if (!c) return coeff;
+	if (coeff === "0") return "0";
+	if (coeff === "1") return c;
+	if (coeff === "-1") return `-${c}`;
+	return `${coeff}${c}`;
+};
+/**
+* Converts Result to a Decimal or Fraction String.
+*/
+function formatResult(v, options = {}) {
+	const { n, d, c } = v;
+	if (d === 0n) return "NaN";
+	if (options.format === "precise") {
+		if (d === 1n) return getConstantStr(n.toString(), c);
+		return `${getConstantStr(n.toString(), c)}/${d}`;
+	}
+	const maxDecimals = options.maxDecimals ?? 30;
+	const isNegative = n < 0n;
+	const absN = n < 0n ? -n : n;
+	const 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;
+	while (remainder !== 0n && count < maxDecimals) {
+		remainder *= 10n;
+		fractionalPart += (remainder / d).toString();
+		remainder %= d;
+		count++;
+	}
+	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,36 @@
 {
   "name": "picocalc",
-  "version": "0.0.0"
+  "version": "0.0.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/picocalc/math-parser.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "imports": {
+    "#lib/*": "./src/lib/*.ts"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "bun test",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "build": "tsdown",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@gameroman/config": "0.1.0",
+    "@types/bun": "1.3.14",
+    "oxfmt": "0.53.0",
+    "oxlint": "1.68.0",
+    "oxlint-tsgolint": "0.23.0",
+    "tsdown": "0.22.2",
+    "typescript": "6.0.3"
+  }
 }