espolar 0.2.1 → 0.3.1

package/dist/index.js

@@ -2,98 +2,134 @@
 const EXPRESSIONS_PRECEDENCE = {
 	ArrayPattern: 20,
 	ObjectPattern: 20,
-	ArrayExpression: 20,
-	TaggedTemplateExpression: 20,
-	ThisExpression: 20,
-	Identifier: 20,
-	TemplateLiteral: 20,
-	Super: 20,
-	SequenceExpression: 20,
-	MemberExpression: 19,
-	MetaProperty: 19,
-	CallExpression: 19,
-	ChainExpression: 19,
-	ImportExpression: 19,
-	NewExpression: 19,
+	ParenthesizedExpression: 18,
+	ThisExpression: 18,
+	Super: 18,
+	Identifier: 18,
+	PrivateIdentifier: 18,
 	Literal: 18,
-	TSSatisfiesExpression: 18,
-	TSInstantiationExpression: 18,
-	TSNonNullExpression: 18,
-	TSTypeAssertion: 18,
-	AwaitExpression: 17,
-	ClassExpression: 17,
-	FunctionExpression: 17,
-	ObjectExpression: 17,
-	UnaryExpression: 16,
-	UpdateExpression: 16,
-	TSAsExpression: 15,
-	BinaryExpression: 14,
-	LogicalExpression: 13,
-	ConditionalExpression: 4,
-	ArrowFunctionExpression: 3,
-	AssignmentExpression: 3,
+	ClassExpression: 18,
+	FunctionExpression: 18,
+	ObjectExpression: 18,
+	ArrayExpression: 18,
+	TemplateLiteral: 18,
+	JSXElement: 18,
+	JSXFragment: 18,
+	MetaProperty: 17,
+	MemberExpression: 17,
+	TSNonNullExpression: 17,
+	ChainExpression: 17,
+	NewExpression: 17,
+	CallExpression: 17,
+	TaggedTemplateExpression: 17,
+	ImportExpression: 17,
+	TSInstantiationExpression: 16.5,
+	UpdateExpression: 15,
+	UnaryExpression: 14,
+	AwaitExpression: 14,
+	TSTypeAssertion: 14,
+	BinaryExpression: 13,
+	TSAsExpression: 9,
+	TSSatisfiesExpression: 9,
+	LogicalExpression: 4,
+	AssignmentExpression: 2,
+	ConditionalExpression: 2,
 	YieldExpression: 2,
-	RestElement: 1
+	ArrowFunctionExpression: 2,
+	SpreadElement: 2,
+	SequenceExpression: 1
 };
 const OPERATOR_PRECEDENCE = {
-	"||": 2,
-	"&&": 3,
-	"??": 4,
-	"|": 5,
-	"^": 6,
-	"&": 7,
-	"==": 8,
-	"!=": 8,
-	"===": 8,
-	"!==": 8,
+	"**": 13,
+	"*": 12,
+	"%": 12,
+	"/": 12,
+	"+": 11,
+	"-": 11,
+	"<<": 10,
+	">>": 10,
+	">>>": 10,
 	"<": 9,
 	">": 9,
 	"<=": 9,
 	">=": 9,
 	in: 9,
 	instanceof: 9,
-	"<<": 10,
-	">>": 10,
-	">>>": 10,
-	"+": 11,
-	"-": 11,
-	"*": 12,
-	"%": 12,
-	"/": 12,
-	"**": 13
+	"==": 8,
+	"!=": 8,
+	"===": 8,
+	"!==": 8,
+	"&": 7,
+	"^": 6,
+	"|": 5,
+	"&&": 4,
+	"??": 3,
+	"||": 3
+};
+const ASSOCIATIVE = {
+	[EXPRESSIONS_PRECEDENCE.MemberExpression]: "left",
+	[EXPRESSIONS_PRECEDENCE.UpdateExpression]: "left",
+	[EXPRESSIONS_PRECEDENCE.UnaryExpression]: "right",
+	[OPERATOR_PRECEDENCE["**"]]: "right",
+	[OPERATOR_PRECEDENCE["*"]]: "left",
+	[OPERATOR_PRECEDENCE["+"]]: "left",
+	[OPERATOR_PRECEDENCE["<"]]: "left",
+	[OPERATOR_PRECEDENCE["==="]]: "left",
+	[OPERATOR_PRECEDENCE["&"]]: "left",
+	[OPERATOR_PRECEDENCE["^"]]: "left",
+	[OPERATOR_PRECEDENCE["|"]]: "left",
+	[OPERATOR_PRECEDENCE["&&"]]: "left",
+	[OPERATOR_PRECEDENCE["||"]]: "left",
+	[EXPRESSIONS_PRECEDENCE.AssignmentExpression]: "right"
 };
+function getPrecedence(node) {
+	if (node.type === "BinaryExpression" || node.type === "LogicalExpression") return OPERATOR_PRECEDENCE[node.operator] ?? EXPRESSIONS_PRECEDENCE[node.type];
+	return EXPRESSIONS_PRECEDENCE[node.type] ?? 20;
+}
+/**
+* Check whether the operand of a Binary/Logical/AssignmentExpression needs parentheses.
+* @param node
+* @param parent
+* @param where
+* @returns
+*/
+function operandOfBinaryExprNeedsParens(node, parent, where) {
+	if (where === "left" && (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") && parent.type === "BinaryExpression") return parent.operator === "&" || parent.operator === "|";
+	if (node.type === "LogicalExpression" && parent.type === "LogicalExpression" && parent.operator === "??" !== (node.operator === "??")) return true;
+	const precedence = getPrecedence(node);
+	const parentPrecedence = getPrecedence(parent);
+	if (parent.type === "BinaryExpression" && parent.operator === "**" && precedence === EXPRESSIONS_PRECEDENCE.UnaryExpression) return true;
+	if (precedence !== parentPrecedence) return precedence < parentPrecedence;
+	if (precedence === EXPRESSIONS_PRECEDENCE.MemberExpression && node.type === "ChainExpression") return true;
+	if (parent.type === "NewExpression" && !validUnparenthesizedNewOperand(node)) return true;
+	return (ASSOCIATIVE[precedence] ?? "left") !== where;
+}
+/**
+* A valid unparenthesized `new` operand must be a member chain
+* which not contains a CallExpression
+*/
+function validUnparenthesizedNewOperand(node) {
+	if (node.type === "ChainExpression" || node.type === "ImportExpression") return false;
+	let cur = node;
+	while (true) if (cur.type === "CallExpression") return false;
+	else if (cur.type === "TSNonNullExpression") cur = cur.expression;
+	else if (cur.type === "MemberExpression") cur = cur.object;
+	else if (cur.type === "TaggedTemplateExpression") cur = cur.tag;
+	else return true;
+}
+function operandOfUnaryExprNeedsParens(node) {
+	return EXPRESSIONS_PRECEDENCE[node.type] < EXPRESSIONS_PRECEDENCE.UnaryExpression;
+}
+function expectAssignmentExprNeedsParen(node) {
+	return EXPRESSIONS_PRECEDENCE[node.type] < EXPRESSIONS_PRECEDENCE.AssignmentExpression;
+}
+function expectLHSExprNeedsParen(node) {
+	return EXPRESSIONS_PRECEDENCE[node.type] < EXPRESSIONS_PRECEDENCE.MemberExpression;
+}
 function commentNeedsNewline(comment) {
 	if (comment.type === "Line") return true;
 	return comment.value.includes("\n");
 }
-function needsParens(node, parent, isRight) {
-	if (node.type === "PrivateIdentifier" || node.type === "Identifier" || node.type === "Super") return false;
-	if (node.type === "LogicalExpression" && parent.type === "LogicalExpression" && parent.operator === "??" !== (node.operator === "??")) return true;
-	const precedence = EXPRESSIONS_PRECEDENCE[node.type] ?? 20;
-	const parentPrecedence = EXPRESSIONS_PRECEDENCE[parent.type] ?? 20;
-	if (precedence !== parentPrecedence) {
-		if (!isRight && precedence === 15 && parentPrecedence === 14 && parent.operator === "**") return false;
-		return precedence < parentPrecedence;
-	}
-	if (precedence !== 13 && precedence !== 14) return false;
-	const nodeOp = node.operator;
-	if (nodeOp === "**" && parent.operator === "**") return !isRight;
-	if (isRight) return OPERATOR_PRECEDENCE[nodeOp] <= OPERATOR_PRECEDENCE[parent.operator];
-	return OPERATOR_PRECEDENCE[nodeOp] < OPERATOR_PRECEDENCE[parent.operator];
-}
-function arrowConciseBodyNeedsWrap(body) {
-	if (body.type === "BlockStatement") return false;
-	switch (body.type) {
-		case "ObjectExpression": return true;
-		case "AssignmentExpression": return body.left.type === "ObjectPattern";
-		case "LogicalExpression": return body.left.type === "ObjectExpression";
-		case "ConditionalExpression": return body.test.type === "ObjectExpression";
-		case "TSAsExpression":
-		case "TSSatisfiesExpression":
-		case "TSNonNullExpression": return body.expression ? arrowConciseBodyNeedsWrap(body.expression) : false;
-		default: return false;
-	}
-}
 const defaultPrinters = {
 	Program: printProgram,
 	Identifier: printIdentifier,
@@ -238,11 +274,48 @@ const defaultPrinters = {
 	TSIntrinsicKeyword: printKeywordType
 };
 function printProgram(program, context) {
-	context.writeNodeListWithSourceGaps(program.body, "\n");
+	context.writeNodeListWithNewLineSep(program.body);
+}
+function canStartExpressionStatement(node) {
+	let lhs;
+	switch (node.type) {
+		default: return true;
+		case "ObjectExpression":
+		case "FunctionExpression":
+		case "ClassExpression":
+		case "ObjectPattern": return false;
+		case "AssignmentExpression":
+		case "LogicalExpression":
+		case "BinaryExpression":
+			lhs = node.left;
+			break;
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+			lhs = node.expression;
+			break;
+		case "CallExpression":
+			lhs = node.callee;
+			break;
+		case "MemberExpression":
+			lhs = node.object;
+			if (node.computed && lhs.type === "Identifier" && lhs.name === "let") return false;
+			break;
+		case "TaggedTemplateExpression":
+			lhs = node.tag;
+			break;
+		case "ConditionalExpression":
+			lhs = node.test;
+			break;
+		case "SequenceExpression": return canStartExpressionStatement(node.expressions[0]);
+		case "UpdateExpression": return canStartExpressionStatement(node.argument);
+		case "ChainExpression": return canStartExpressionStatement(node.expression);
+	}
+	return operandOfBinaryExprNeedsParens(lhs, node, "left") || canStartExpressionStatement(lhs);
 }
 function printExpressionStatement(statement, context) {
 	const expr = statement.expression;
-	if (expr.type === "ObjectExpression" || expr.type === "FunctionExpression" || expr.type === "AssignmentExpression" && expr.left.type === "ObjectPattern") {
+	if (!canStartExpressionStatement(expr)) {
 		context.write("(");
 		context.writeNode(expr);
 		context.write(");");
@@ -266,7 +339,11 @@ function printVariableDeclarator(declarator, context) {
 	if (declarator.definite === true) context.write("!");
 	if (declarator.init) {
 		context.write(" = ");
-		context.writeNode(declarator.init);
+		if (expectAssignmentExprNeedsParen(declarator.init)) {
+			context.write("(");
+			context.writeNode(declarator.init);
+			context.write(")");
+		} else context.writeNode(declarator.init);
 	}
 }
 function printBlockStatement(block, context) {
@@ -274,7 +351,7 @@ function printBlockStatement(block, context) {
 	context.write("{");
 	if (body.length > 0) {
 		context.write("\n");
-		context.writeNodeListWithSourceGaps(body, "\n");
+		context.writeNodeListWithNewLineSep(body);
 		context.write("\n");
 	}
 	context.write("}");
@@ -443,12 +520,14 @@ function printLiteral(literal, context) {
 function printUnaryExpression(expr, context) {
 	context.write(expr.operator);
 	if (expr.operator.length > 1) context.write(" ");
-	const argPrec = EXPRESSIONS_PRECEDENCE[expr.argument.type];
-	if (argPrec != null && argPrec < EXPRESSIONS_PRECEDENCE.UnaryExpression) {
+	if (operandOfUnaryExprNeedsParens(expr.argument)) {
 		context.write("(");
 		context.writeNode(expr.argument);
 		context.write(")");
-	} else context.writeNode(expr.argument);
+	} else {
+		if (expr.operator.length === 1 && (expr.argument.type === "UnaryExpression" || expr.argument.type === "UpdateExpression") && expr.argument.operator.startsWith(expr.operator)) context.write(" ");
+		context.writeNode(expr.argument);
+	}
 }
 function printUpdateExpression(expr, context) {
 	if (expr.prefix === true) {
@@ -465,7 +544,7 @@ function printUpdateExpression(expr, context) {
 function printBinaryExpression(expression, context) {
 	const left = expression.left;
 	const right = expression.right;
-	if (needsParens(left, expression, false)) {
+	if (operandOfBinaryExprNeedsParens(left, expression, "left")) {
 		context.write("(");
 		context.writeNode(left);
 		context.write(")");
@@ -473,14 +552,14 @@ function printBinaryExpression(expression, context) {
 	context.write(" ");
 	context.write(String(expression.operator));
 	context.write(" ");
-	if (needsParens(right, expression, true)) {
+	if (operandOfBinaryExprNeedsParens(right, expression, "right")) {
 		context.write("(");
 		context.writeNode(right);
 		context.write(")");
 	} else context.writeNode(right);
 }
 function printConditionalExpression(expr, context) {
-	if ((EXPRESSIONS_PRECEDENCE[expr.test.type] ?? 20) <= EXPRESSIONS_PRECEDENCE.ConditionalExpression) {
+	if (operandOfBinaryExprNeedsParens(expr.test, expr, "left")) {
 		context.write("(");
 		context.writeNode(expr.test);
 		context.write(")");
@@ -488,39 +567,39 @@ function printConditionalExpression(expr, context) {
 	context.write(" ? ");
 	context.writeNode(expr.consequent);
 	context.write(" : ");
-	context.writeNode(expr.alternate);
+	if (operandOfBinaryExprNeedsParens(expr.alternate, expr, "right")) {
+		context.write("(");
+		context.writeNode(expr.alternate);
+		context.write(")");
+	} else context.writeNode(expr.alternate);
 }
 function printYieldExpression(expr, context) {
 	context.write(expr.delegate === true ? "yield*" : "yield");
 	if (expr.argument) {
 		context.write(" ");
-		const needsParensASi = (context.options.getLeadingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
-		if (needsParensASi) context.write("(");
-		context.writeNode(expr.argument);
-		if (needsParensASi) context.write(")");
+		if (((context.options.getLeadingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false) || expectAssignmentExprNeedsParen(expr.argument)) {
+			context.write("(");
+			context.writeNode(expr.argument);
+			context.write(")");
+		} else context.writeNode(expr.argument);
 	}
 }
 function printAwaitExpression(expr, context) {
 	context.write("await");
-	if (expr.argument) {
-		const argPrec = EXPRESSIONS_PRECEDENCE[expr.argument.type];
-		if (argPrec != null && argPrec < EXPRESSIONS_PRECEDENCE.AwaitExpression) {
-			context.write(" (");
-			context.writeNode(expr.argument);
-			context.write(")");
-		} else {
-			context.write(" ");
-			context.writeNode(expr.argument);
-		}
+	if (expr.argument) if (operandOfUnaryExprNeedsParens(expr.argument)) {
+		context.write(" (");
+		context.writeNode(expr.argument);
+		context.write(")");
+	} else {
+		context.write(" ");
+		context.writeNode(expr.argument);
 	}
 }
 function printSequenceExpression(expr, context) {
-	context.write("(");
 	context.writeNodeList(expr.expressions, ", ");
-	context.write(")");
 }
 function printCallExpression(expression, context) {
-	if ((EXPRESSIONS_PRECEDENCE[expression.callee.type] ?? 20) < EXPRESSIONS_PRECEDENCE.CallExpression) {
+	if (operandOfBinaryExprNeedsParens(expression.callee, expression, "left")) {
 		context.write("(");
 		context.writeNode(expression.callee);
 		context.write(")");
@@ -530,12 +609,12 @@ function printCallExpression(expression, context) {
 	const parenRange = context.options.experimentalGetLeftParenSourceRange?.(expression);
 	if (parenRange) context.writeMapped("(", parenRange.start, parenRange.end);
 	else context.write("(");
-	context.writeNodeList(expression.arguments, ", ");
+	context.writeExpressionListWithCommaSep(expression.arguments);
 	context.write(")");
 }
 function printNewExpression(expression, context) {
 	context.write("new ");
-	if ((EXPRESSIONS_PRECEDENCE[expression.callee.type] ?? 20) < EXPRESSIONS_PRECEDENCE.NewExpression || hasCallExpression(expression.callee)) {
+	if (operandOfBinaryExprNeedsParens(expression.callee, expression, "left")) {
 		context.write("(");
 		context.writeNode(expression.callee);
 		context.write(")");
@@ -544,23 +623,14 @@ function printNewExpression(expression, context) {
 	const parenRange = context.options.experimentalGetLeftParenSourceRange?.(expression);
 	if (parenRange) context.writeMapped("(", parenRange.start, parenRange.end);
 	else context.write("(");
-	context.writeNodeList(expression.arguments, ", ");
+	context.writeExpressionListWithCommaSep(expression.arguments);
 	context.write(")");
 }
-function hasCallExpression(node) {
-	let cur = node;
-	while (cur) {
-		if (cur.type === "CallExpression") return true;
-		if (cur.type === "MemberExpression") cur = cur.object;
-		else return false;
-	}
-	return false;
-}
 function printChainExpression(expression, context) {
 	context.writeNode(expression.expression);
 }
 function printMemberExpression(expression, context) {
-	if ((EXPRESSIONS_PRECEDENCE[expression.object.type] ?? 20) < EXPRESSIONS_PRECEDENCE.MemberExpression) {
+	if (operandOfBinaryExprNeedsParens(expression.object, expression, "left")) {
 		context.write("(");
 		context.writeNode(expression.object);
 		context.write(")");
@@ -587,7 +657,7 @@ function printObjectPattern(pattern, context) {
 }
 function printArrayExpression(array, context) {
 	context.write("[");
-	context.writeNodeList(array.elements, ", ");
+	context.writeExpressionListWithCommaSep(array.elements);
 	context.write("]");
 }
 function printArrayPattern(pattern, context) {
@@ -604,7 +674,7 @@ function printProperty(property, context) {
 			context.writeNode(value);
 			return;
 		}
-		if (value.type === "FunctionExpression") {
+		if (value.type === "FunctionExpression" && (property.method || property.kind !== "init")) {
 			if (property.kind !== "init") context.write(property.kind + " ");
 			if (value.async === true) context.write("async ");
 			if (value.generator === true) context.write("*");
@@ -626,7 +696,6 @@ function printProperty(property, context) {
 			context.writeNode(property.key);
 			context.write("]: ");
 		} else {
-			if (property.kind === "get" || property.kind === "set") context.write(property.kind + " ");
 			context.writeNode(property.key);
 			context.write(": ");
 		}
@@ -635,7 +704,11 @@ function printProperty(property, context) {
 }
 function printSpreadElement(spread, context) {
 	context.write("...");
-	context.writeNode(spread.argument);
+	if (expectAssignmentExprNeedsParen(spread.argument)) {
+		context.write("(");
+		context.writeNode(spread.argument);
+		context.write(")");
+	} else context.writeNode(spread.argument);
 }
 function printRestElement(rest, context) {
 	context.write("...");
@@ -660,7 +733,12 @@ function printTemplateLiteral(node, context) {
 	context.write("`");
 }
 function printTaggedTemplateExpression(node, context) {
-	context.writeNode(node.tag);
+	if (operandOfBinaryExprNeedsParens(node.tag, node, "left")) {
+		context.write("(");
+		context.writeNode(node.tag);
+		context.write(")");
+	} else context.writeNode(node.tag);
+	if (node.typeArguments) context.writeNode(node.typeArguments);
 	context.writeNode(node.quasi);
 }
 function printThisExpression(_node, context) {
@@ -703,6 +781,44 @@ function printFunction(fn, context) {
 		context.writeNode(fn.body);
 	}
 }
+function canStartConciseBody(body) {
+	if (body.type === "BlockStatement" || body.type === "PrivateIdentifier") return true;
+	if (expectAssignmentExprNeedsParen(body)) return false;
+	let lhs;
+	switch (body.type) {
+		default: return true;
+		case "ObjectExpression":
+		case "FunctionExpression":
+		case "ClassExpression":
+		case "ObjectPattern": return false;
+		case "AssignmentExpression":
+		case "LogicalExpression":
+		case "BinaryExpression":
+			lhs = body.left;
+			break;
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+			lhs = body.expression;
+			break;
+		case "CallExpression":
+			lhs = body.callee;
+			break;
+		case "MemberExpression":
+			lhs = body.object;
+			if (body.computed && lhs.type === "Identifier" && lhs.name === "let") return false;
+			break;
+		case "TaggedTemplateExpression":
+			lhs = body.tag;
+			break;
+		case "ConditionalExpression":
+			lhs = body.test;
+			break;
+		case "UpdateExpression": return canStartConciseBody(body.argument);
+		case "ChainExpression": return canStartConciseBody(body.expression);
+	}
+	return operandOfBinaryExprNeedsParens(lhs, body, "left") || canStartConciseBody(lhs);
+}
 function printArrowFunctionExpression(fn, context) {
 	if (fn.async === true) context.write("async ");
 	if (fn.typeParameters) context.writeNode(fn.typeParameters);
@@ -712,7 +828,7 @@ function printArrowFunctionExpression(fn, context) {
 	writeReturnType(fn, context);
 	context.write(" => ");
 	const body = fn.body;
-	if (arrowConciseBodyNeedsWrap(body)) {
+	if (!canStartConciseBody(body)) {
 		context.write("(");
 		context.writeNode(body);
 		context.write(")");
@@ -735,7 +851,11 @@ function printClass(node, context) {
 	}
 	if (node.superClass) {
 		context.write("extends ");
-		context.writeNode(node.superClass);
+		if (expectLHSExprNeedsParen(node.superClass)) {
+			context.write("(");
+			context.writeNode(node.superClass);
+			context.write(")");
+		} else context.writeNode(node.superClass);
 		if (node.superTypeArguments) context.writeNode(node.superTypeArguments);
 		else if (node.superTypeParameters) context.writeNode(node.superTypeParameters);
 	}
@@ -751,7 +871,7 @@ function printClassBody(node, context) {
 	const body = node.body;
 	if (body.length > 0) {
 		context.write("\n");
-		context.writeNodeListWithSourceGaps(body, "\n");
+		context.writeNodeListWithNewLineSep(body);
 		context.write("\n");
 	}
 	context.write("}");
@@ -761,14 +881,28 @@ function printStaticBlock(node, context) {
 	const body = node.body;
 	if (body.length > 0) {
 		context.write("\n");
-		context.writeNodeListWithSourceGaps(body, "\n");
+		context.writeNodeListWithNewLineSep(body);
 		context.write("\n");
 	}
 	context.write("}");
 }
+function validUnparenthesizedDecorator(node) {
+	let current = node;
+	if (current.type === "CallExpression") current = current.callee;
+	if (current.type === "TSInstantiationExpression") current = current.expression;
+	while (true) if (current.type === "Identifier") return true;
+	else if (current.type === "MemberExpression") {
+		if (current.computed) return false;
+		current = current.object;
+	} else return false;
+}
 function printDecorator(node, context) {
 	context.write("@");
-	context.writeNode(node.expression);
+	if (!validUnparenthesizedDecorator(node.expression)) {
+		context.write("(");
+		context.writeNode(node.expression);
+		context.write(")");
+	} else context.writeNode(node.expression);
 	context.write("\n");
 }
 function printPropertyDefinition(node, context) {
@@ -933,7 +1067,7 @@ function printExportSpecifier(node, context) {
 	}
 }
 function printTSAsExpression(expression, context) {
-	if ((EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20) < EXPRESSIONS_PRECEDENCE.TSAsExpression) {
+	if (operandOfBinaryExprNeedsParens(expression.expression, expression, "left")) {
 		context.write("(");
 		context.writeNode(expression.expression);
 		context.write(")");
@@ -942,7 +1076,7 @@ function printTSAsExpression(expression, context) {
 	context.writeNode(expression.typeAnnotation);
 }
 function printTSSatisfiesExpression(expression, context) {
-	if ((EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20) < EXPRESSIONS_PRECEDENCE.TSSatisfiesExpression) {
+	if (operandOfBinaryExprNeedsParens(expression.expression, expression, "left")) {
 		context.write("(");
 		context.writeNode(expression.expression);
 		context.write(")");
@@ -954,14 +1088,18 @@ function printTSTypeAssertion(expression, context) {
 	context.write("<");
 	context.writeNode(expression.typeAnnotation);
 	context.write(">");
-	if ((EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20) < EXPRESSIONS_PRECEDENCE.TSTypeAssertion) {
+	if (operandOfUnaryExprNeedsParens(expression.expression)) {
 		context.write("(");
 		context.writeNode(expression.expression);
 		context.write(")");
 	} else context.writeNode(expression.expression);
 }
 function printTSNonNullExpression(expression, context) {
-	context.writeNode(expression.expression);
+	if (operandOfBinaryExprNeedsParens(expression.expression, expression, "left")) {
+		context.write("(");
+		context.writeNode(expression.expression);
+		context.write(")");
+	} else context.writeNode(expression.expression);
 	context.write("!");
 }
 function printTSTypeAnnotation(annotation, context) {
@@ -1155,7 +1293,12 @@ function printTSTypeQuery(node, context) {
 	context.writeNode(node.exprName);
 }
 function printTSMappedType(node, context) {
-	context.write("{ [");
+	context.write("{ ");
+	if (node.readonly) {
+		if (typeof node.readonly === "string") context.write(node.readonly);
+		context.write("readonly ");
+	}
+	context.write("[");
 	const legacyTp = node.typeParameter;
 	const key = node.key ?? legacyTp?.name;
 	const constraint = node.constraint ?? legacyTp?.constraint;
@@ -1165,7 +1308,15 @@ function printTSMappedType(node, context) {
 		context.write(" in ");
 		context.writeNode(constraint);
 	}
+	if (node.nameType) {
+		context.write(" as ");
+		context.writeNode(node.nameType);
+	}
 	context.write("]");
+	if (node.optional) {
+		if (typeof node.optional === "string") context.write(node.optional);
+		context.write("?");
+	}
 	if (node.typeAnnotation) {
 		context.write(": ");
 		context.writeNode(node.typeAnnotation);
@@ -1262,14 +1413,20 @@ function printTSModuleDeclaration(node, context) {
 		context.write(String(kind) + " ");
 		context.writeNode(node.id);
 	}
-	if (node.body) {
-		if (node.body.type === "TSModuleBlock") context.write(" ");
-		context.writeNode(node.body);
+	let body = node.body;
+	while (body?.type === "TSModuleDeclaration") {
+		context.write(".");
+		context.writeNode(body.id);
+		body = body.body;
+	}
+	if (body) {
+		context.write(" ");
+		context.writeNode(body);
 	}
 }
 function printTSModuleBlock(node, context) {
 	context.write("{\n");
-	context.writeNodeListWithSourceGaps(node.body, "\n");
+	context.writeNodeListWithNewLineSep(node.body);
 	context.write("\n}");
 }
 function printTSDeclareFunction(node, context) {
@@ -1304,7 +1461,11 @@ function printTSNamespaceExportDeclaration(node, context) {
 	context.write(";");
 }
 function printTSInstantiationExpression(node, context) {
-	context.writeNode(node.expression);
+	if (operandOfBinaryExprNeedsParens(node.expression, node, "left")) {
+		context.write("(");
+		context.writeNode(node.expression);
+		context.write(")");
+	} else context.writeNode(node.expression);
 	context.writeNode(node.typeArguments);
 }
 function printTSParenthesizedType(node, context) {
@@ -1320,6 +1481,13 @@ function writeOptionalTypeAnnotation(node, context) {
 	if (node.optional === true) context.write("?");
 	if (node.typeAnnotation) context.writeNode(node.typeAnnotation);
 }
+function writeComment(comment, context) {
+	if (comment.type === "Line") context.write("//" + comment.value + "\n");
+	else {
+		context.write("/*" + comment.value + "*/");
+		if (comment.value.includes("\n")) context.write("\n");
+	}
+}
 //#endregion
 //#region src/mappings.ts
 function getNodeRange(node) {
@@ -1368,13 +1536,6 @@ function toVolarMapping(mapping) {
 }
 //#endregion
 //#region src/printer.ts
-function writeComment(context, comment) {
-	if (comment.type === "Line") context.write("//" + comment.value + "\n");
-	else {
-		context.write("/*" + comment.value + "*/");
-		if (comment.value.includes("\n")) context.write("\n");
-	}
-}
 function print(node, options) {
 	const context = createPrinterContext(options);
 	context.writeNode(node);
@@ -1441,12 +1602,12 @@ function createPrinterContext(options) {
 			const printer = printers[node.type];
 			if (!printer) throw new Error(`No printer registered for node type ${node.type}`);
 			const leadingComments = options.getLeadingComments?.(node);
-			if (leadingComments) for (const c of leadingComments) writeComment(context, c);
+			if (leadingComments) for (const comment of leadingComments) writeComment(comment, context);
 			const generatedStart = generatedOffset;
 			printer(node, context);
 			const generatedEnd = generatedOffset;
 			const trailingComments = options.getTrailingComments?.(node);
-			if (trailingComments) for (const c of trailingComments) writeComment(context, c);
+			if (trailingComments) for (const comment of trailingComments) writeComment(comment, context);
 			const lastMappingGeneratedEnd = mappings.at(-1)?.generatedEnd ?? 0;
 			if (range && lastMappingGeneratedEnd <= generatedStart) appendMapping(range, generatedStart, generatedEnd, getMappingData(node));
 		},
@@ -1462,14 +1623,30 @@ function createPrinterContext(options) {
 				needsSeparator = true;
 			}
 		},
-		writeNodeListWithSourceGaps(nodes, fallbackSeparator) {
+		writeExpressionListWithCommaSep(nodes) {
+			let needsSeparator = false;
+			for (const node of nodes) {
+				if (!node) {
+					if (needsSeparator) context.write(", ");
+					continue;
+				}
+				if (needsSeparator) context.write(", ");
+				if (expectAssignmentExprNeedsParen(node)) {
+					context.write("(");
+					context.writeNode(node);
+					context.write(")");
+				} else context.writeNode(node);
+				needsSeparator = true;
+			}
+		},
+		writeNodeListWithNewLineSep(nodes) {
 			let lastRangeEnd;
 			let wroteNode = false;
 			for (const node of nodes) {
 				if (!node) continue;
 				const range = getNodeRange(node);
 				if (wroteNode) if (lastRangeEnd !== void 0 && range && range.start >= lastRangeEnd) context.writeSource(lastRangeEnd, range.start, getMappingData(null));
-				else context.write(fallbackSeparator);
+				else context.write("\n");
 				context.writeNode(node);
 				wroteNode = true;
 				if (range) lastRangeEnd = range.end;