picocalc 0.0.2 → 0.0.4

package/LICENSE

@@ -1,21 +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.
+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

@@ -1,3 +1,4 @@
+import "bigint.bitlength";
 //#region src/lib/types.d.ts
 interface PrecisionOptions {
   readonly format?: "decimal" | "precise";
@@ -5,13 +6,19 @@ interface PrecisionOptions {
   readonly roundingMode?: "round" | "truncate";
 }
 //#endregion
+//#region src/lib/errors.d.ts
+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?: "." | ",";
 }
 /**
-* The main entry point for the library.
-*/
+ * The main entry point for the library.
+ */
 declare function calculate(expression: string, options?: CalculateOptions): string;
 //#endregion
-export { calculate };
+export { PicocalcError, calculate };

package/dist/index.mjs

@@ -1,15 +1,15 @@
 import "bigint.bitlength";
 //#region src/lib/errors.ts
-var GenericMathErrror = class extends Error {
+var PicocalcError = class extends Error {
 	pos;
 	constructor(name, message, pos) {
-		if (pos === void 0) super(`${name}: ${message}`);
-		else super(`${name}: ${message} at position ${pos}`);
+		if (pos === void 0) super(message);
+		else super(`${message} at position ${pos}`);
 		this.pos = pos;
 		this.name = name;
 	}
 };
-var InterpreterError = class extends GenericMathErrror {
+var InterpreterError = class extends PicocalcError {
 	constructor(message, pos) {
 		super("InterpreterError", message, pos);
 	}
@@ -403,7 +403,7 @@ function exponentiate(left, right, precision) {
 	if (lN === lD && c === void 0) return ONE;
 	if (rN === "OVERFLOW") return right;
 	if (lN === -lD && c === void 0) {
-		if (rN % 2n) return {
+		if (simplify(right).n % 2n) return {
 			n: -1n,
 			d: 1n
 		};
@@ -552,8 +552,11 @@ const precedence = {
 	SQRT_FN: 8,
 	FACTORIAL: 10
 };
+function isFunctionOp(op) {
+	return op === "ABS_FN" || op === "CEIL_FN" || op === "FLOOR_FN" || op === "SQRT_FN";
+}
 function isUnaryOperation(op) {
-	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || op === "ABS_FN" || op === "CEIL_FN" || op === "FLOOR_FN" || op === "SQRT_FN";
+	return op === "UNARY_PLUS" || op === "UNARY_MINUS" || isFunctionOp(op);
 }
 /**
 * Maximum allowed precision
@@ -673,7 +676,7 @@ function evaluate(tokens, options = {}) {
 	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);
+		while (ops.length > 0 && !isUnary && (isRightAssociative ? precedence[ops.at(-1)] > precedence[currentOp] : precedence[ops.at(-1)] >= precedence[currentOp])) applyOp(pos);
 		ops.push(currentOp);
 	};
 	for (const token of tokens) switch (token.type) {
@@ -712,12 +715,13 @@ function evaluate(tokens, options = {}) {
 			else values.push(getConst(token.id));
 			break;
 		case "LPAREN":
-			ops.push("LPAREN");
+		case "ABS_OPEN":
+			ops.push(token.type);
 			break;
 		case "RPAREN": {
 			let foundMatch = false;
 			while (ops.length > 0) {
-				if (ops[ops.length - 1] === "LPAREN") {
+				if (ops.at(-1) === "LPAREN") {
 					foundMatch = true;
 					break;
 				}
@@ -725,14 +729,14 @@ function evaluate(tokens, options = {}) {
 			}
 			if (!foundMatch) throw new MismatchedParenthesisError(token.pos);
 			ops.pop();
+			const nextOp = ops.at(-1);
+			if (!nextOp) break;
+			if (isFunctionOp(nextOp)) applyOp(token.pos);
 			break;
 		}
-		case "ABS_OPEN":
-			ops.push("ABS_OPEN");
-			break;
 		case "ABS_CLOSE": {
 			while (ops.length > 0) {
-				if (ops[ops.length - 1] === "ABS_OPEN") break;
+				if (ops.at(-1) === "ABS_OPEN") break;
 				applyOp(token.pos);
 			}
 			ops.pop();
@@ -764,19 +768,11 @@ function evaluate(tokens, options = {}) {
 			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);
+			pushOpWithPrecedence(token.type, token.pos);
 			break;
 		case "FUNC":
 			switch (token.id) {
@@ -796,8 +792,8 @@ function evaluate(tokens, options = {}) {
 			break;
 	}
 	while (ops.length > 0) {
-		const top = ops[ops.length - 1];
-		const lastPos = tokens[tokens.length - 1]?.pos ?? 0;
+		const top = ops.at(-1);
+		const lastPos = tokens.at(-1)?.pos ?? 0;
 		if (top === "LPAREN") {
 			ops.pop();
 			continue;
@@ -810,14 +806,11 @@ function evaluate(tokens, options = {}) {
 }
 //#endregion
 //#region src/lib/lexer.ts
-var LexerError = class extends GenericMathErrror {
+var LexerError = class extends PicocalcError {
 	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";
@@ -830,42 +823,49 @@ function isAlpha(ch) {
 * Maximum allowed expression length
 */
 const MAX_EXPRESSION_LENGTH = 75e6;
+const CHAR_MAP = {
+	"(": "LPAREN",
+	")": "RPAREN",
+	"+": "PLUS",
+	"-": "MINUS",
+	"*": "MUL",
+	"/": "DIV",
+	"^": "POW",
+	"!": "FACTORIAL",
+	"|": "PIPE",
+	"%": "MOD"
+};
 /**
 * 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) {
+	for (let index = 0; index < length; index++) {
 		const ch = expression[index];
-		const startPos = index;
-		if (isWhitespace(ch)) {
-			index++;
-			continue;
-		}
+		const pos = index;
+		if (ch === " ") continue;
 		if (isDigit(ch) || ch === decimalSeparator) {
 			let whole = "";
 			let fraction = void 0;
 			let exponent = void 0;
-			const startIdx = index;
+			const consumeDigits = () => {
+				const start = index;
+				while (index < length && isDigit(expression[index])) index++;
+				return expression.slice(start, 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);
+				fraction = consumeDigits();
+				if (fraction.length === 0) throw new LexerError("Expected digit after decimal separator", index);
 			} else {
-				while (index < length && isDigit(expression[index])) index++;
-				whole = expression.slice(startIdx, index);
+				whole = consumeDigits();
 				if (index < length && expression[index] === decimalSeparator) {
 					index++;
-					const fracStart = index;
-					while (index < length && isDigit(expression[index])) index++;
-					fraction = expression.slice(fracStart, index);
+					fraction = consumeDigits();
 				}
 			}
 			if (index < length && (expression[index] === "e" || expression[index] === "E")) {
@@ -878,115 +878,37 @@ function tokenize(expression, options = {}) {
 				}
 				if (lookahead < length && isDigit(expression[lookahead])) {
 					index = lookahead;
-					let expBuffer = sign;
-					while (index < length && isDigit(expression[index])) {
-						expBuffer += expression[index];
-						index++;
-					}
-					exponent = expBuffer;
+					exponent = sign + consumeDigits();
 				}
 			}
 			if (index < length && expression[index] === decimalSeparator) throw new LexerError("Invalid decimal number format", index);
+			index--;
 			tokens.push({
 				type: "NUMBER",
 				whole,
 				fraction,
 				exponent,
-				pos: startPos
+				pos
 			});
 			continue;
 		}
 		if (isAlpha(ch)) {
 			let id = "";
 			while (index < length && isAlpha(expression[index])) id += expression[index++];
+			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
+				pos
 			});
-			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);
+		const type = CHAR_MAP[ch];
+		if (!type) throw new LexerError(`Unexpected character '${ch}'`, index);
+		tokens.push({
+			type,
+			pos
+		});
 	}
 	return tokens;
 }
@@ -1012,7 +934,7 @@ const symbolMap = {
 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;
+	if (t.type === "IDENTIFIER" || t.type === "FUNC" || t.type === "CONST") return t.id;
 	return symbolMap[t.type];
 }
 //#endregion
@@ -1027,13 +949,10 @@ function isOperand(last) {
 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 {
+var ParserError = class extends PicocalcError {
 	constructor(message, pos) {
 		super("ParserError", message, pos);
 	}
@@ -1049,15 +968,16 @@ var UnexpectedOperatorError = class extends ParserError {
 	}
 };
 function resolveIdentifier(token) {
+	const pos = token.pos;
 	if (token.id === "pi" || token.id === "e") return {
 		type: "CONST",
 		id: token.id,
-		pos: token.pos
+		pos
 	};
 	if (token.id === "abs" || token.id === "ceil" || token.id === "floor" || token.id === "sqrt") return {
 		type: "FUNC",
 		id: token.id,
-		pos: token.pos
+		pos
 	};
 	throw new ParserError(`Unknown identifier '${token.id}'`, token.pos);
 }
@@ -1069,53 +989,47 @@ function parse(tokens) {
 		let token = tokens[i];
 		const prev = tokens[i - 1];
 		if (token.type === "IDENTIFIER") token = resolveIdentifier(token);
-		let prevParsed = result[result.length - 1];
+		const pos = token.pos;
+		const isPrevOperand = isOperand(result.at(-1));
 		if (token.type === "PIPE") {
-			if (absStack > 0 && isOperand(prevParsed)) {
+			if (absStack > 0 && isPrevOperand) {
 				result.push({
 					type: "ABS_CLOSE",
-					pos: token.pos
+					pos
 				});
 				absStack--;
-			} else {
-				if (isOperand(prevParsed)) result.push({
-					type: "IMPLICIT_MUL",
-					pos: token.pos
-				});
-				result.push({
-					type: "ABS_OPEN",
-					pos: token.pos
-				});
-				absStack++;
+				continue;
 			}
-			continue;
-		}
-		if (isOperand(prevParsed)) {
-			if (token.type === "LPAREN" || token.type === "FUNC" || token.type === "NUMBER" || token.type === "CONST") result.push({
+			if (isPrevOperand) result.push({
 				type: "IMPLICIT_MUL",
-				pos: token.pos
+				pos
 			});
+			result.push({
+				type: "ABS_OPEN",
+				pos
+			});
+			absStack++;
+			continue;
 		}
-		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 ((token.type === "LPAREN" || token.type === "FUNC" || token.type === "NUMBER" || token.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 (!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",
-			pos: token.pos
+			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];
+	const last = result.at(-1);
+	if (absStack > 0) throw new ParserError("Unclosed absolute value '|'", last?.pos ?? 0);
 	if (last && last.type !== "CONST" && (isBinaryOperator(last) || [
 		"PLUS",
 		"MINUS",
@@ -1132,16 +1046,15 @@ function parse(tokens) {
 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}`;
+	let constantStr = c;
+	if (e) {
+		const num = e.n;
+		const den = e.d ?? 1n;
+		if (num !== den) {
+			const expStr = den === 1n ? `${num}` : `(${num}/${den})`;
+			constantStr = den === 2n * num ? `sqrt(${c})` : `${c}^${expStr}`;
+		}
 	}
-	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}`;
@@ -1165,46 +1078,17 @@ function formatPrecise(v) {
 */
 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;
+	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;
 }
 //#endregion
 //#region src/index.ts
@@ -1215,4 +1099,4 @@ function calculate(expression, options) {
 	return formatResult(evaluate(parse(tokenize(expression, options)), options), options);
 }
 //#endregion
-export { calculate };
+export { PicocalcError, calculate };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "picocalc",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/picocalc/math-parser.git"
+    "url": "git+https://github.com/picocalc/picocalc.git"
   },
   "files": [
     "dist"
@@ -30,12 +30,12 @@
     "bigint.bitlength": "0.2.0"
   },
   "devDependencies": {
-    "@gameroman/config": "0.2.2",
+    "@gameroman/config": "0.2.5",
     "@types/bun": "1.3.14",
-    "oxfmt": "0.57.0",
-    "oxlint": "1.72.0",
+    "oxfmt": "0.58.0",
+    "oxlint": "1.73.0",
     "oxlint-tsgolint": "0.24.0",
-    "tsdown": "0.22.3",
+    "tsdown": "0.22.7",
     "typescript": "6.0.3"
   }
 }