picocalc 0.0.4 → 0.0.6

package/dist/index.d.mts

@@ -1,18 +1,14 @@
 import "bigint.bitlength";
-//#region src/lib/types.d.ts
+type RoundingMode = "round" | "truncate";
 interface PrecisionOptions {
   readonly format?: "decimal" | "precise";
   readonly maxDecimals?: number;
-  readonly roundingMode?: "round" | "truncate";
+  readonly roundingMode?: RoundingMode;
 }
-//#endregion
-//#region src/lib/errors.d.ts
-declare class PicocalcError extends Error {
+export declare class PicocalcError extends Error {
   pos?: number;
   constructor(name: string, message: string, pos?: number);
 }
-//#endregion
-//#region src/index.d.ts
 interface CalculateOptions extends PrecisionOptions {
   decimalSeparator?: "." | ",";
 }
@@ -20,5 +16,4 @@ interface CalculateOptions extends PrecisionOptions {
  * The main entry point for the library.
  */
 declare function calculate(expression: string, options?: CalculateOptions): string;
-//#endregion
-export { PicocalcError, calculate };
+export { calculate };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import "bigint.bitlength";
-//#region src/lib/errors.ts
+// src/lib/errors.ts
 var PicocalcError = class extends Error {
 	pos;
 	constructor(name, message, pos) {
@@ -39,39 +39,50 @@ var EmptyExpressionError = class extends InterpreterError {
 		super("Empty expression");
 	}
 };
-var MismatchedParenthesisError = class extends InterpreterError {
-	constructor(pos, message = "Mismatched parenthesis") {
-		super(message, pos);
+var InterpreterRangeError = class extends InterpreterError {
+	constructor(message) {
+		super(message);
 	}
 };
-//#endregion
-//#region src/lib/types.ts
+const ROUNDING_MODE = "round";
+function getBitPrecision(maxDecimals = 30) {
+	return BigInt(maxDecimals * 4 + 32);
+}
+/**
+* Maximum allowed precision
+*/
+const MAX_PRECISION = 5e4;
+// 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];
+// src/lib/utils/e.ts
+function splitSeries(a, b) {
+	if (b - a === 1n) return {
+		n: 1n,
+		d: b
+	};
+	const mid = (a + b) / 2n;
+	const left = splitSeries(a, mid);
+	const right = splitSeries(mid, b);
 	return {
-		n: BigInt(c.replace(".", "")),
-		d: 10n ** BigInt(c.length - c.indexOf(".") - 1)
+		n: left.n * right.d + right.n,
+		d: left.d * right.d
 	};
 }
-//#endregion
-//#region src/lib/utils/gcd.ts
+function computeE(maxDecimals) {
+	let b = 1n;
+	let m = 1n;
+	const t = 1n << getBitPrecision(maxDecimals);
+	while (m < t) {
+		b++;
+		m *= b;
+	}
+	const { n, d } = splitSeries(0n, b);
+	return {
+		n: d + n,
+		d
+	};
+}
+// src/lib/utils/gcd.ts
 /**
 * The Euclidean GCD Algorithm for BigInt.
 */
@@ -88,9 +99,8 @@ function gcd(a, b) {
 	}
 	return a;
 }
-//#endregion
-//#region src/lib/utils/multiply.ts
-function multiply(a, b) {
+// src/lib/utils/multiply.ts
+function multiply(a, b, maxDecimals) {
 	const aN = a.n;
 	const bN = b.n;
 	if (aN === 0n || bN === 0n) return ZERO;
@@ -116,9 +126,9 @@ function multiply(a, b) {
 		}, {
 			n: bE?.n ?? 1n,
 			d: bE?.d ?? 1n
-		}))
+		}, maxDecimals))
 	};
-	if (aC !== void 0 && bC !== void 0) return multiply(toSimpleFraction(a), toSimpleFraction(b));
+	if (aC !== void 0 && bC !== void 0) return multiply(toSimpleFraction(a, maxDecimals), toSimpleFraction(b, maxDecimals), maxDecimals);
 	return {
 		n,
 		d,
@@ -126,8 +136,7 @@ function multiply(a, b) {
 		e: aE ?? bE
 	};
 }
-//#endregion
-//#region src/lib/utils/nthroot.ts
+// src/lib/utils/nthroot.ts
 /**
 * Calculates the integer nth root of a BigInt.
 */
@@ -148,46 +157,44 @@ function iNthRoot(value, n) {
 /**
 * Calculates the n-th root of a fraction.
 */
-function nthRoot(v, n, precision) {
+function nthRoot(v, n, maxDecimals) {
 	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({
+		const r = nthRoot({
 			n: -v.n,
 			d: v.d
-		}, n, precision);
+		}, n, maxDecimals);
 		return {
-			n: -positiveResult.n,
-			d: positiveResult.d
+			n: -r.n,
+			d: r.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 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);
+	const precisionBits = getBitPrecision(maxDecimals);
+	const scaleFactor = 1n << precisionBits * n;
+	const s = toSimpleFraction(v);
 	return simplify({
-		n: iNthRoot(v.n * scaleFactor / v.d, n),
-		d: 10n ** BigInt(precisionDigits)
+		n: iNthRoot(s.n * scaleFactor / s.d, n),
+		d: 1n << precisionBits
 	});
 }
-//#endregion
-//#region src/lib/utils/simplify.ts
+// src/lib/utils/simplify.ts
 /**
 * Reduces a fraction to its simplest form.
 */
@@ -195,7 +202,7 @@ 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 {
+		if (v.e?.n === 0n || !v.c) return {
 			n: v.n,
 			d: v.d
 		};
@@ -205,7 +212,7 @@ function simplify(v) {
 	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 {
+	if (v.e?.n === 0n || !v.c) return {
 		n,
 		d
 	};
@@ -219,9 +226,12 @@ function simplify(v) {
 /**
 * Resolves any constants and exponents to return a simple fraction.
 */
-function toSimpleFraction(val) {
-	if (!val.c) return val;
-	const c = getConst(val.c);
+function toSimpleFraction(val, maxDecimals) {
+	if (!val.c) return {
+		d: val.d,
+		n: val.n
+	};
+	const c = getConst(val.c, maxDecimals);
 	const expN = val.e?.n ?? 1n;
 	const expD = val.e?.d ?? 1n;
 	const absExpN = expN < 0 ? -expN : expN;
@@ -229,35 +239,123 @@ function toSimpleFraction(val) {
 		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" });
+	if (expD !== 1n) poweredConstant = nthRoot(poweredConstant, expD);
 	return multiply(poweredConstant, {
 		n: val.n,
 		d: val.d
+	}, maxDecimals);
+}
+// src/lib/utils/arctan.ts
+function rawArctanSeries(xScaled, bitPrecision) {
+	const xSqScaled = xScaled * xScaled >> bitPrecision;
+	let currentTerm = xScaled;
+	let totalSum = xScaled;
+	let k = 1n;
+	while (true) {
+		currentTerm = currentTerm * xSqScaled >> bitPrecision;
+		const denominatorFactor = 2n * k + 1n;
+		const termValue = currentTerm / denominatorFactor;
+		if (termValue === 0n) break;
+		if (k % 2n === 1n) totalSum -= termValue;
+		else totalSum += termValue;
+		k++;
+	}
+	return totalSum;
+}
+function arctan(v, maxDecimals) {
+	const { n, d } = v;
+	if (n === 0n) return ZERO;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const isNegative = n < 0n !== d < 0n;
+	const absN = n < 0n ? -n : n;
+	const absD = d < 0n ? -d : d;
+	if (absN === absD) return {
+		c: "pi",
+		n: isNegative ? -1n : 1n,
+		d: 4n
+	};
+	if (absN > absD) {
+		const pi = computePi(maxDecimals);
+		const subArctan = arctan({
+			n: absD,
+			d: absN
+		}, maxDecimals);
+		const resultNum = pi.n * subArctan.d - 2n * subArctan.n * pi.d;
+		const resultDen = 2n * pi.d * subArctan.d;
+		return simplify({
+			n: isNegative ? -resultNum : resultNum,
+			d: resultDen
+		});
+	}
+	if (absN * 2n > absD) {
+		const halfArctan = arctan({
+			n: 1n,
+			d: 2n
+		}, maxDecimals);
+		const remainderArctan = arctan({
+			n: 2n * absN - absD,
+			d: 2n * absD + absN
+		}, maxDecimals);
+		const resultNum = halfArctan.n * remainderArctan.d + remainderArctan.n * halfArctan.d;
+		const resultDen = halfArctan.d * remainderArctan.d;
+		return simplify({
+			n: isNegative ? -resultNum : resultNum,
+			d: resultDen
+		});
+	}
+	const r = rawArctanSeries((absN << bitPrecision) / absD, bitPrecision);
+	return simplify({
+		n: isNegative ? -r : r,
+		d: 1n << bitPrecision
+	});
+}
+// src/lib/utils/pi.ts
+function computePi(maxDecimals) {
+	const p5 = arctan({
+		n: 1n,
+		d: 5n
+	}, maxDecimals);
+	const p239 = arctan({
+		n: 1n,
+		d: 239n
+	}, maxDecimals);
+	return simplify({
+		n: 16n * p5.n * p239.d - 4n * p239.n * p5.d,
+		d: p5.d * p239.d
 	});
 }
-//#endregion
-//#region src/lib/utils/add.ts
-function add(left, right, subtract = false) {
+// src/lib/utils/constants.ts
+const ZERO = {
+	n: 0n,
+	d: 1n
+};
+const ONE = {
+	n: 1n,
+	d: 1n
+};
+function getConst(id, maxDecimals) {
+	if (id === "pi") return computePi(maxDecimals);
+	return computeE(maxDecimals);
+}
+// src/lib/utils/add.ts
+function negate(v) {
+	if (v.n === "OVERFLOW") return v;
+	const { n, d } = v;
+	return {
+		...v,
+		n: d < 0 ? n : -n,
+		d: d < 0 ? -d : d
+	};
+}
+function add(left, right, maxDecimals, subtract = false) {
 	const lN = left.n;
 	const rN = right.n;
-	if (lN === "OVERFLOW") return left;
-	if (rN === "OVERFLOW") return right;
+	if (lN === "OVERFLOW" || rN === 0n) return left;
+	if (rN === "OVERFLOW" || lN === 0n) return subtract ? negate(right) : 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 (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left, maxDecimals), toSimpleFraction(right, maxDecimals), maxDecimals, subtract);
+	let n, d;
 	if (lD === rD) {
 		n = subtract ? lN - rN : lN + rN;
 		d = lD;
@@ -269,7 +367,10 @@ function add(left, right, subtract = false) {
 		d = lD * mLeft;
 	}
 	if (n === 0n) return ZERO;
-	if (c !== rC || e?.n !== rE?.n) return add(toSimpleFraction(left), toSimpleFraction(right), subtract);
+	if (n < 0n && d < 0n) {
+		n = -n;
+		d = -d;
+	}
 	return {
 		n,
 		d,
@@ -277,8 +378,36 @@ function add(left, right, subtract = false) {
 		e
 	};
 }
-//#endregion
-//#region src/lib/utils/ceil.ts
+// src/lib/utils/arctanh.ts
+function rawArctanhSeries(xScaled, bitPrecision) {
+	let currentTerm = xScaled;
+	let totalSum = xScaled;
+	const xSqScaled = xScaled * xScaled >> bitPrecision;
+	let k = 1n;
+	while (true) {
+		currentTerm = currentTerm * xSqScaled >> bitPrecision;
+		const denominatorFactor = 2n * k + 1n;
+		if (currentTerm < denominatorFactor) break;
+		totalSum += currentTerm / denominatorFactor;
+		k++;
+	}
+	return totalSum;
+}
+function arctanh(v, maxDecimals) {
+	const { n, d } = v;
+	if (n === 0n) return ZERO;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const isNegative = n < 0n !== d < 0n;
+	const currentN = n < 0n ? -n : n;
+	const currentD = d < 0n ? -d : d;
+	if (currentN >= currentD) throw new InterpreterRangeError("arctanh argument must be strictly between -1 and 1");
+	const sumScaled = rawArctanhSeries((currentN << bitPrecision) / currentD, bitPrecision);
+	return {
+		n: isNegative ? -sumScaled : sumScaled,
+		d: 1n << bitPrecision
+	};
+}
+// src/lib/utils/ceil.ts
 /**
 * Returns the smallest integer greater than or equal to the value.
 */
@@ -290,9 +419,8 @@ function ceil(v) {
 	const hasRemainder = n % d !== 0n;
 	return isPositive && hasRemainder ? result + 1n : result;
 }
-//#endregion
-//#region src/lib/utils/divide.ts
-function divide(left, right) {
+// src/lib/utils/divide.ts
+function divide(left, right, maxDecimals) {
 	const lN = left.n;
 	const rN = right.n;
 	if (rN === 0n) throw new DivisionByZeroError();
@@ -300,6 +428,7 @@ function divide(left, right) {
 	if (lN === "OVERFLOW" || rN === "OVERFLOW") return OverflowValue;
 	const { d: lD, c: lC, e: lE } = left;
 	const { d: rD, c: rC, e: rE } = right;
+	if (lC !== void 0 && rC !== void 0 && lC !== rC) return divide(toSimpleFraction(left, maxDecimals), toSimpleFraction(right, maxDecimals), maxDecimals);
 	const g1 = gcd(lN, rN);
 	const g2 = gcd(rD, lD);
 	const n = lN / g1 * (rD / g2);
@@ -314,17 +443,14 @@ function divide(left, right) {
 		}, {
 			n: rE?.n ?? 1n,
 			d: rE?.d ?? 1n
-		}, true))
+		}, maxDecimals, true))
 	};
 	const c = lC ?? rC;
 	let e;
 	if (lC !== void 0) e = lE ? {
 		n: lE.n,
 		d: lE.d ?? 1n
-	} : {
-		n: 1n,
-		d: 1n
-	};
+	} : ONE;
 	else if (rC !== void 0) e = {
 		n: -(rE?.n ?? 1n),
 		d: rE?.d ?? 1n
@@ -336,8 +462,7 @@ function divide(left, right) {
 		e
 	};
 }
-//#endregion
-//#region src/lib/utils/sqrt.ts
+// src/lib/utils/sqrt.ts
 /**
 * Calculates the integer square root of a BigInt.
 */
@@ -360,78 +485,158 @@ function isPerfectSquare(val) {
 	const root = isqrt(val);
 	return [root * root === val, root];
 }
-function sqrt(v, precision) {
+function sqrt(v, maxDecimals) {
 	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 [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);
+	const precisionBits = getBitPrecision(maxDecimals);
+	const scaleFactor = 1n << precisionBits * 2n;
+	const s = toSimpleFraction(v);
+	return {
+		n: isqrt(s.n * scaleFactor / s.d),
+		d: 1n << precisionBits
+	};
+}
+// src/lib/utils/ln.ts
+function ln(v, maxDecimals) {
+	const { n, d, c, e } = v;
+	if (n <= 0n || d <= 0n) throw new InterpreterRangeError("Logarithm of non-positive number");
+	if (c === "e" && n === d) return e ? {
+		n: e.n,
+		d: e.d ?? 1n
+	} : ONE;
+	let { n: sN, d: sD } = toSimpleFraction(v);
+	const isReciprocal = sN < sD;
+	if (isReciprocal) [sN, sD] = [sD, sN];
+	let m = 0;
+	while (sN >= 2n * sD) {
+		const val = sqrt({
+			n: sN,
+			d: sD
+		}, maxDecimals);
+		sN = val.n;
+		sD = val.d;
+		m++;
+	}
+	const at = arctanh({
+		n: sN - sD,
+		d: sN + sD
+	}, maxDecimals);
+	let rN = at.n * 2n;
+	if (m > 0) rN <<= BigInt(m);
+	if (isReciprocal) rN = -rN;
 	return simplify({
-		n: isqrt(v.n * scaleFactor / v.d),
-		d: 10n ** BigInt(precisionDigits)
+		n: rN,
+		d: at.d
 	});
 }
-//#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) {
+// src/lib/utils/exp.ts
+function rawExp(v, maxDecimals) {
+	const { n, d } = v;
+	if (n === 0n) return ONE;
+	const scale = 1n << getBitPrecision(maxDecimals);
+	const xScaled = n * scale / d;
+	const ln2Val = ln({
+		n: 2n,
+		d: 1n
+	}, maxDecimals);
+	const ln2Scaled = ln2Val.n * scale / ln2Val.d;
+	let k;
+	if (xScaled >= 0n) k = (xScaled + ln2Scaled / 2n) / ln2Scaled;
+	else k = (xScaled - ln2Scaled / 2n) / ln2Scaled;
+	const rScaled = xScaled - k * ln2Scaled;
+	const isNegativeR = rScaled < 0n;
+	const absRScaled = isNegativeR ? -rScaled : rScaled;
+	let sum = scale;
+	let currentTerm = scale;
+	let factorial = 1n;
+	let i = 1n;
+	while (true) {
+		currentTerm = currentTerm * absRScaled / scale;
+		if (currentTerm === 0n) break;
+		factorial *= i;
+		const termVal = currentTerm / factorial;
+		if (termVal === 0n) break;
+		if (isNegativeR && i % 2n === 1n) sum -= termVal;
+		else sum += termVal;
+		i += 1n;
+	}
+	let finalNum = sum;
+	let finalDen = scale;
+	if (k > 0n) finalNum <<= k;
+	else if (k < 0n) finalDen <<= -k;
+	return {
+		n: finalNum,
+		d: finalDen
+	};
+}
+function exp(v, maxDecimals) {
+	const { n, d, c } = v;
+	if (n === 0n) return ONE;
+	if (!c) return simplify({
+		n: 1n,
+		d: 1n,
+		c: "e",
+		e: {
+			n,
+			d
+		}
+	});
+	return rawExp(toSimpleFraction(v, maxDecimals), maxDecimals);
+}
+function exponentiate(left, right, maxDecimals) {
 	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;
+	const { c, d: lD } = left;
 	if (lN === lD && c === void 0) return ONE;
 	if (rN === "OVERFLOW") return right;
-	if (lN === -lD && c === void 0) {
-		if (simplify(right).n % 2n) return {
+	const rS = simplify(right);
+	if (lN === -lD && c === void 0 && rS.d % 2n) {
+		if (rS.n % 2n) return {
 			n: -1n,
 			d: 1n
 		};
 		return ONE;
 	}
-	const normalizedExp = toSimpleFraction(simplify(right));
+	const normalizedExp = toSimpleFraction(rS, maxDecimals);
+	const dExp = normalizedExp.d;
 	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
-		});
+	if ((dExp >= 100 || lD > 1e3) && (lN !== 1n || rS.c)) {
+		const isNegativeBase = lN < 0;
+		if (isNegativeBase && dExp % 2n === 0n) throw new NotImplementedError(`Even (${dExp}th) root of negative numbers is not implemented yet.`);
+		const l = toSimpleFraction(isNegativeBase ? negate(left) : left, maxDecimals);
+		const r = toSimpleFraction(rS, maxDecimals);
+		const lnBase = ln(l, maxDecimals);
+		const scale = 1n << getBitPrecision(maxDecimals);
+		const p = lnBase.n * scale / lnBase.d * (r.n * scale / r.d) / scale;
+		const pAbs = p < 0 ? -p : p;
+		if (scale > pAbs * 10000000n || pAbs > scale * 10000000n) return OverflowValue;
+		const result = rawExp({
+			n: p,
+			d: scale
+		}, maxDecimals);
+		if (isNegativeBase && normalizedExp.n % 2n !== 0n) return negate(result);
+		return result;
 	}
 	const eN = (left.e?.n ?? 1n) * exponent;
 	let baseN = lN;
@@ -442,7 +647,7 @@ function exponentiate(left, right, precision) {
 	}
 	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;
+	if (baseNDigits * exponent > 10000000n || baseDDigits * exponent > 10000000n || (baseNDigits > 5e3 || baseDDigits > 5e3) && exponent > 10) return OverflowValue;
 	const e = c ? simplify({
 		n: eN,
 		d: left.e?.d ?? 1n
@@ -460,11 +665,10 @@ function exponentiate(left, right, precision) {
 		e
 	};
 	if (dExp === 1n) return v;
-	if (dExp === 2n) return sqrt(v, precision);
-	return nthRoot(v, dExp, precision);
+	if (dExp === 2n) return sqrt(v, maxDecimals);
+	return nthRoot(v, dExp, maxDecimals);
 }
-//#endregion
-//#region src/lib/utils/factorial.ts
+// src/lib/utils/factorial.ts
 function binaryProduct(arr, low, high) {
 	if (low > high) return 1n;
 	if (low === high) return arr[low];
@@ -504,8 +708,7 @@ function factorial(n) {
 	}
 	return binaryProduct(primePowers, 0, primePowers.length - 1);
 }
-//#endregion
-//#region src/lib/utils/floor.ts
+// src/lib/utils/floor.ts
 /**
 * Returns the largest integer less than or equal to the value.
 */
@@ -517,8 +720,7 @@ function floor(v) {
 	const hasRemainder = n % d !== 0n;
 	return isNegative && hasRemainder ? result - 1n : result;
 }
-//#endregion
-//#region src/lib/utils/mod.ts
+// src/lib/utils/mod.ts
 /**
 * Calculates remainder of division.
 */
@@ -532,8 +734,144 @@ function mod(a, b) {
 		d
 	};
 }
-//#endregion
-//#region src/lib/interpreter.ts
+// src/lib/utils/trig.ts
+function roundDiv(numerator, denominator) {
+	const twice = numerator * 2n;
+	const absTwice = twice < 0n ? -twice : twice;
+	const absDenom = denominator < 0n ? -denominator : denominator;
+	const quotient = (absTwice + absDenom) / (2n * absDenom);
+	return twice < 0n !== denominator < 0n ? -quotient : quotient;
+}
+function rawSinSeries(rScaled, bitPrecision) {
+	const rSqScaled = rScaled * rScaled >> bitPrecision;
+	let termValue = rScaled;
+	let totalSum = rScaled;
+	let k = 1n;
+	while (true) {
+		termValue = (termValue * rSqScaled >> bitPrecision) / (2n * k * (2n * k + 1n));
+		if (termValue === 0n) break;
+		if (k % 2n === 1n) totalSum -= termValue;
+		else totalSum += termValue;
+		k++;
+	}
+	return totalSum;
+}
+function rawCosSeries(rScaled, bitPrecision) {
+	const rSqScaled = rScaled * rScaled >> bitPrecision;
+	const scale = 1n << bitPrecision;
+	let termValue = scale;
+	let totalSum = scale;
+	let k = 1n;
+	while (true) {
+		termValue = (termValue * rSqScaled >> bitPrecision) / ((2n * k - 1n) * (2n * k));
+		if (termValue === 0n) break;
+		if (k % 2n === 1n) totalSum -= termValue;
+		else totalSum += termValue;
+		k++;
+	}
+	return totalSum;
+}
+function getHalfPi(maxDecimals) {
+	const { d, n, c } = computePi(maxDecimals);
+	return {
+		c,
+		n,
+		d: d * 2n
+	};
+}
+function sin(v, maxDecimals) {
+	const { n, d, c, e } = v;
+	if (n === 0n) return ZERO;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const scale = 1n << bitPrecision;
+	const isPiLinear = c === "pi" && (e === void 0 || e.n === 1n);
+	let rScaled;
+	let k;
+	if (isPiLinear) {
+		k = roundDiv(2n * n, d);
+		const rN = 2n * n - k * d;
+		if (rN === 0n) {
+			const quadrant = (k % 4n + 4n) % 4n;
+			if (quadrant === 0n || quadrant === 2n) return ZERO;
+			if (quadrant === 1n) return ONE;
+			return {
+				n: -1n,
+				d: 1n
+			};
+		}
+		const piVal = computePi(maxDecimals);
+		rScaled = rN * piVal.n * scale / (2n * d * piVal.d);
+	} else {
+		const simple = toSimpleFraction(v);
+		const halfPi = getHalfPi(maxDecimals);
+		k = roundDiv(simple.n * halfPi.d, simple.d * halfPi.n);
+		const rN = simple.n * halfPi.d - k * halfPi.n * simple.d;
+		const rD = simple.d * halfPi.d;
+		rScaled = rN * scale / rD;
+	}
+	const quadrant = (k % 4n + 4n) % 4n;
+	let resultScaled;
+	let negate = false;
+	if (quadrant === 0n) resultScaled = rawSinSeries(rScaled, bitPrecision);
+	else if (quadrant === 1n) resultScaled = rawCosSeries(rScaled, bitPrecision);
+	else if (quadrant === 2n) {
+		resultScaled = rawSinSeries(rScaled, bitPrecision);
+		negate = true;
+	} else {
+		resultScaled = rawCosSeries(rScaled, bitPrecision);
+		negate = true;
+	}
+	return {
+		n: negate ? -resultScaled : resultScaled,
+		d: scale
+	};
+}
+function cos(v, maxDecimals) {
+	const { n, d, c, e } = v;
+	if (n === 0n) return ONE;
+	const bitPrecision = getBitPrecision(maxDecimals);
+	const scale = 1n << bitPrecision;
+	const isPiLinear = c === "pi" && (e === void 0 || e.n === 1n);
+	let rScaled;
+	let k;
+	if (isPiLinear) {
+		k = roundDiv(2n * n, d);
+		const rN = 2n * n - k * d;
+		if (rN === 0n) {
+			const quadrant = (k % 4n + 4n) % 4n;
+			if (quadrant === 0n || quadrant === 2n) return quadrant === 0n ? ONE : {
+				n: -1n,
+				d: 1n
+			};
+			return ZERO;
+		}
+		const piVal = computePi(maxDecimals);
+		rScaled = rN * piVal.n * scale / (2n * d * piVal.d);
+	} else {
+		const simple = toSimpleFraction(v);
+		const halfPi = getHalfPi(maxDecimals);
+		k = roundDiv(simple.n * halfPi.d, simple.d * halfPi.n);
+		const rN = simple.n * halfPi.d - k * halfPi.n * simple.d;
+		const rD = simple.d * halfPi.d;
+		rScaled = rN * scale / rD;
+	}
+	const quadrant = (k % 4n + 4n) % 4n;
+	let resultScaled;
+	let negate = false;
+	if (quadrant === 0n) resultScaled = rawCosSeries(rScaled, bitPrecision);
+	else if (quadrant === 1n) {
+		resultScaled = rawSinSeries(rScaled, bitPrecision);
+		negate = true;
+	} else if (quadrant === 2n) {
+		resultScaled = rawCosSeries(rScaled, bitPrecision);
+		negate = true;
+	} else resultScaled = rawSinSeries(rScaled, bitPrecision);
+	return {
+		n: negate ? -resultScaled : resultScaled,
+		d: scale
+	};
+}
+// src/lib/interpreter.ts
 const precedence = {
 	LPAREN: 0,
 	ABS_OPEN: 0,
@@ -542,103 +880,94 @@ const precedence = {
 	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
+	UNARY_PLUS: 3,
+	UNARY_MINUS: 3,
+	FN_CALL: 4,
+	EXP: 5,
+	IMPLICIT_MUL: 5,
+	FACTORIAL: 6
 };
 function isFunctionOp(op) {
-	return op === "ABS_FN" || op === "CEIL_FN" || op === "FLOOR_FN" || op === "SQRT_FN";
+	return typeof op === "object";
 }
 function isUnaryOperation(op) {
 	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || isFunctionOp(op);
 }
-/**
-* 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 getOpPrecedence(op) {
+	if (isFunctionOp(op)) return precedence.FN_CALL;
+	return precedence[op];
+}
 function evaluate(tokens, options = {}) {
 	if (tokens.length === 0) throw new EmptyExpressionError();
+	const { maxDecimals } = options;
 	const values = [];
 	const ops = [];
 	const applyOp = (pos) => {
 		const op = ops.pop();
-		if (!op || op === "LPAREN" || op === "ABS_OPEN") return;
+		if (!op || op === "LPAREN" || op === "ABS_OPEN" || op === "UNARY_PLUS") return;
 		const right = values.pop();
-		if (isUnaryOperation(op)) switch (op) {
-			case "UNARY_PLUS":
-				values.push(right);
+		if (isUnaryOperation(op)) {
+			if (op === "UNARY_MINUS") {
+				values.push(negate(right));
 				return;
-			case "UNARY_MINUS": {
-				const rN = right.n;
-				if (rN === "OVERFLOW") {
-					values.push(OverflowValue);
-					return;
-				}
-				values.push({
-					...right,
-					n: -rN
-				});
+			}
+			const { id } = op;
+			if (id === "sqrt") {
+				values.push(sqrt(right, maxDecimals));
 				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
-				});
+			const n = right.n;
+			if (n === "OVERFLOW") {
+				values.push(OverflowValue);
 				return;
 			}
-			case "CEIL_FN":
-				if (right.n === "OVERFLOW") {
-					values.push(OverflowValue);
+			switch (id) {
+				case "abs":
+					values.push({
+						...right,
+						n: n < 0 ? -n : n
+					});
 					return;
-				}
-				values.push({
-					n: ceil(toSimpleFraction(right)),
-					d: 1n
-				});
-				return;
-			case "FLOOR_FN":
-				if (right.n === "OVERFLOW") {
-					values.push(OverflowValue);
+				case "ceil":
+					values.push({
+						n: ceil(toSimpleFraction(right, maxDecimals)),
+						d: 1n
+					});
 					return;
-				}
-				values.push({
-					n: floor(toSimpleFraction(right)),
-					d: 1n
-				});
-				return;
-			case "SQRT_FN":
-				values.push(sqrt(right, options));
-				return;
+				case "floor":
+					values.push({
+						n: floor(toSimpleFraction(right, maxDecimals)),
+						d: 1n
+					});
+					return;
+				case "arctan":
+					values.push(arctan(toSimpleFraction(right, maxDecimals), maxDecimals));
+					return;
+				case "arctanh":
+					values.push(arctanh(toSimpleFraction(right, maxDecimals), maxDecimals));
+					return;
+				case "ln":
+					values.push(ln(right, maxDecimals));
+					return;
+				case "exp":
+					values.push(exp(right, maxDecimals));
+					return;
+				case "sin":
+					values.push(sin(right, maxDecimals));
+					return;
+				case "cos":
+					values.push(cos(right, maxDecimals));
+					return;
+			}
 		}
 		if (op === "FACTORIAL") {
 			if (right.n === "OVERFLOW") {
 				values.push(OverflowValue);
 				return;
 			}
-			const reduced = simplify(right);
+			const reduced = toSimpleFraction(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) {
+			if (reduced.n >= 2e4) {
 				values.push(OverflowValue);
 				return;
 			}
@@ -652,44 +981,44 @@ function evaluate(tokens, options = {}) {
 		switch (op) {
 			case "ADD":
 			case "SUBTRACT":
-				values.push(add(left, right, op === "SUBTRACT"));
+				values.push(add(left, right, maxDecimals, op === "SUBTRACT"));
 				return;
 			case "MULTIPLY":
 			case "IMPLICIT_MUL":
-				values.push(multiply(left, right));
+				values.push(multiply(left, right, maxDecimals));
 				return;
 			case "DIVIDE":
-				values.push(divide(left, right));
+				values.push(divide(left, right, maxDecimals));
 				return;
 			case "MOD":
 				if (left.n === "OVERFLOW" || right.n === "OVERFLOW") {
 					values.push(OverflowValue);
 					return;
 				}
-				values.push(mod(left, right));
+				values.push(mod(toSimpleFraction(left), toSimpleFraction(right)));
 				return;
 			case "EXP":
-				values.push(exponentiate(left, right, options));
+				values.push(exponentiate(left, right, maxDecimals));
 				return;
 		}
 	};
 	const pushOpWithPrecedence = (currentOp, pos) => {
 		const isUnary = isUnaryOperation(currentOp);
 		const isRightAssociative = currentOp === "EXP" || currentOp === "IMPLICIT_MUL";
-		while (ops.length > 0 && !isUnary && (isRightAssociative ? precedence[ops.at(-1)] > precedence[currentOp] : precedence[ops.at(-1)] >= precedence[currentOp])) applyOp(pos);
+		while (ops.length > 0 && !isUnary && (isRightAssociative ? getOpPrecedence(ops.at(-1)) > getOpPrecedence(currentOp) : getOpPrecedence(ops.at(-1)) >= getOpPrecedence(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);
+			if (fl > 5e4) 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);
+				if (token.exponent.length > 5e4) throw new MaximumPrecisionError(token.exponent.length, MAX_PRECISION);
 				const expValue = BigInt(token.exponent);
-				if (expValue > MAX_SCIENTIFIC_NUMBER_EXPONENT) {
+				if (expValue > 3e5) {
 					values.push(OverflowValue);
 					break;
 				}
@@ -707,27 +1036,21 @@ function evaluate(tokens, options = {}) {
 			break;
 		}
 		case "CONST":
-			if (options.format === "precise") values.push({
+			values.push({
 				n: 1n,
 				d: 1n,
 				c: token.id
 			});
-			else values.push(getConst(token.id));
 			break;
 		case "LPAREN":
 		case "ABS_OPEN":
 			ops.push(token.type);
 			break;
 		case "RPAREN": {
-			let foundMatch = false;
 			while (ops.length > 0) {
-				if (ops.at(-1) === "LPAREN") {
-					foundMatch = true;
-					break;
-				}
+				if (ops.at(-1) === "LPAREN") break;
 				applyOp(token.pos);
 			}
-			if (!foundMatch) throw new MismatchedParenthesisError(token.pos);
 			ops.pop();
 			const nextOp = ops.at(-1);
 			if (!nextOp) break;
@@ -774,22 +1097,7 @@ function evaluate(tokens, options = {}) {
 		case "MOD":
 			pushOpWithPrecedence(token.type, 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;
+		case "FUNC": pushOpWithPrecedence(token, token.pos);
 	}
 	while (ops.length > 0) {
 		const top = ops.at(-1);
@@ -804,8 +1112,7 @@ function evaluate(tokens, options = {}) {
 	if (finalValue.n === "OVERFLOW") throw new OverflowError();
 	return simplify(finalValue);
 }
-//#endregion
-//#region src/lib/lexer.ts
+// src/lib/lexer.ts
 var LexerError = class extends PicocalcError {
 	constructor(message, pos) {
 		super("LexerError", message, pos);
@@ -912,8 +1219,7 @@ function tokenize(expression, options = {}) {
 	}
 	return tokens;
 }
-//#endregion
-//#region src/lib/symbol.ts
+// src/lib/symbol.ts
 const symbolMap = {
 	PLUS: "+",
 	UNARY_PLUS: "+",
@@ -937,8 +1243,22 @@ function getSym(t) {
 	if (t.type === "IDENTIFIER" || t.type === "FUNC" || t.type === "CONST") return t.id;
 	return symbolMap[t.type];
 }
-//#endregion
-//#region src/lib/parser.ts
+// src/lib/parser.ts
+const KNOWN_FUNCTIONS = /* @__PURE__ */ new Set([
+	"abs",
+	"arctan",
+	"arctanh",
+	"ceil",
+	"cos",
+	"exp",
+	"floor",
+	"ln",
+	"sin",
+	"sqrt"
+]);
+function isKnownFunctionName(name) {
+	return KNOWN_FUNCTIONS.has(name);
+}
 /**
 * Helper: Is the last token an "operand" (something that can be followed by a closing pipe or implicit mul)?
 */
@@ -974,7 +1294,7 @@ function resolveIdentifier(token) {
 		id: token.id,
 		pos
 	};
-	if (token.id === "abs" || token.id === "ceil" || token.id === "floor" || token.id === "sqrt") return {
+	if (isKnownFunctionName(token.id)) return {
 		type: "FUNC",
 		id: token.id,
 		pos
@@ -989,9 +1309,9 @@ function parse(tokens) {
 		let token = tokens[i];
 		const prev = tokens[i - 1];
 		if (token.type === "IDENTIFIER") token = resolveIdentifier(token);
-		const pos = token.pos;
+		const { pos, type } = token;
 		const isPrevOperand = isOperand(result.at(-1));
-		if (token.type === "PIPE") {
+		if (type === "PIPE") {
 			if (absStack > 0 && isPrevOperand) {
 				result.push({
 					type: "ABS_CLOSE",
@@ -1011,19 +1331,19 @@ function parse(tokens) {
 			absStack++;
 			continue;
 		}
-		if ((token.type === "LPAREN" || token.type === "FUNC" || token.type === "NUMBER" || token.type === "CONST") && isPrevOperand) result.push({
+		if ((type === "LPAREN" || type === "FUNC" || type === "NUMBER" || type === "CONST") && isPrevOperand) result.push({
 			type: "IMPLICIT_MUL",
 			pos
 		});
 		const prevParsed = result.at(-1);
 		if (isBinaryOperator(token) && isUnaryContext(prevParsed)) throw new UnexpectedOperatorError(`Unexpected operator '${getSym(token)}'`, token.pos);
-		if ((token.type === "FACTORIAL" || token.type === "RPAREN") && isUnaryContext(prevParsed)) {
+		if ((type === "FACTORIAL" || type === "RPAREN") && isUnaryContext(prevParsed)) {
 			if (!prevParsed) throw new UnexpectedOperatorError(`Unexpected '${getSym(token)}' at the beginning of expression`, token.pos);
 			throw new UnexpectedOperatorError(`Unexpected '${getSym(token)}' after '${getSym(prevParsed)}'`, 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",
+		if (prev && (prev.type === "NUMBER" || prev.type === "IDENTIFIER" && resolveIdentifier(prev).type === "CONST") && type === "NUMBER") throw new ParserError("Missing operator between numbers", token.pos);
+		if ((type === "PLUS" || type === "MINUS") && isUnaryContext(prevParsed)) result.push({
+			type: type === "PLUS" ? "UNARY_PLUS" : "UNARY_MINUS",
 			pos
 		});
 		else result.push(token);
@@ -1041,8 +1361,20 @@ function parse(tokens) {
 	].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
+// src/lib/decimals.ts
+function toDecimal({ n, d }, { maxDecimals = 30, roundingMode = ROUNDING_MODE }) {
+	if (d === 0n) throw new Error("Division by zero");
+	if (n === 0n) return "0";
+	const isNegative = n < 0n;
+	let resultStr = (((isNegative ? -n : n) * 10n ** BigInt(maxDecimals) + (roundingMode === "round" ? d / 2n : 0n)) / d).toString();
+	if (resultStr.length <= maxDecimals) resultStr = resultStr.padStart(maxDecimals + 1, "0");
+	const splitIdx = resultStr.length - maxDecimals;
+	const integerPart = resultStr.slice(0, splitIdx);
+	const fractionalPart = resultStr.slice(splitIdx).replace(/0+$/, "");
+	const finalResult = fractionalPart ? `${integerPart}.${fractionalPart}` : integerPart;
+	return (isNegative && finalResult !== "0" ? "-" : "") + finalResult;
+}
+// src/utils/format-result.ts
 function getConstantStr(coeff, c, e) {
 	if (coeff === 0n) return "0";
 	if (!c) return `${coeff}`;
@@ -1077,26 +1409,14 @@ function formatPrecise(v) {
 * Converts Result to a Decimal or Fraction String.
 */
 function formatResult(v, options = {}) {
-	const { n, d } = v;
 	if (options.format === "precise") return formatPrecise(v);
-	const { maxDecimals = 30, roundingMode = "round" } = options;
-	const isNegative = n < 0;
-	const factor = 10n ** BigInt(maxDecimals);
-	let resultStr = (((isNegative ? -n : n) * factor + (roundingMode === "round" ? d / 2n : 0n)) / d).toString();
-	if (resultStr.length <= maxDecimals) resultStr = resultStr.padStart(maxDecimals + 1, "0");
-	const splitIdx = resultStr.length - maxDecimals;
-	const integerPart = resultStr.slice(0, splitIdx);
-	const fractionalPart = resultStr.slice(splitIdx).replace(/0+$/, "");
-	const finalResult = fractionalPart ? `${integerPart}.${fractionalPart}` : integerPart;
-	return (isNegative && finalResult !== "0" ? "-" : "") + finalResult;
+	return toDecimal(toSimpleFraction(v, options.maxDecimals), options);
 }
-//#endregion
-//#region src/index.ts
+// 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 { PicocalcError, calculate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picocalc",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,12 +30,12 @@
     "bigint.bitlength": "0.2.0"
   },
   "devDependencies": {
-    "@gameroman/config": "0.2.5",
-    "@types/bun": "1.3.14",
-    "oxfmt": "0.58.0",
-    "oxlint": "1.73.0",
-    "oxlint-tsgolint": "0.24.0",
-    "tsdown": "0.22.7",
-    "typescript": "6.0.3"
+    "@gameroman/config": "0.3.0",
+    "@types/bun": "1.4.4",
+    "oxfmt": "0.77.0",
+    "oxlint": "1.92.0",
+    "oxlint-tsgolint": "7.0.2006",
+    "tsdown": "0.23.5",
+    "typescript": "7.0.2"
   }
 }