@systemfsoftware/stryker-js-instrumenter 7.1.0 → 8.0.1

package/dist/index.mjs

@@ -1,4 +1,3 @@
-import { a as isErrnoException, c as Mutant, d as MutantStatusSchema, f as RunOptionsFields, h as PositionSchema, i as errorToString, l as MutantActivationSchema, m as OpenEndLocationSchema, n as INSTRUMENTER_CONSTANTS, o as isMutant, p as LocationSchema, r as causeText, s as normalizeFileName, t as ERROR_CODES, u as MutantRunOptionsSchema } from "./Mutant-DnhV_fpo.mjs";
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
@@ -8,6 +7,59 @@ import * as Option from "effect/Option";
 import { walk } from "oxc-walker";
 import { Schema } from "effect";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/Location.schema.ts
+const PositionSchema = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const LocationSchema = S.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+const OpenEndLocationSchema = S.Struct({
+	start: PositionSchema,
+	end: S.optional(PositionSchema)
+});
+//#endregion
+//#region src/Mutant.schema.ts
+const MutantStatusSchema = S.Literals([
+	"Killed",
+	"Survived",
+	"NoCoverage",
+	"CompileError",
+	"RuntimeError",
+	"Timeout",
+	"Ignored",
+	"Pending"
+]);
+var Mutant = class extends S.TaggedClass()("Mutant", {
+	id: S.NonEmptyString,
+	fileName: S.NonEmptyString,
+	mutatorName: S.NonEmptyString,
+	replacement: S.String,
+	location: LocationSchema,
+	status: S.optional(MutantStatusSchema),
+	statusReason: S.optional(S.String),
+	coveredBy: S.optional(S.Array(S.String)),
+	static: S.optional(S.Boolean),
+	testsCompleted: S.optional(S.Finite),
+	description: S.optional(S.String)
+}) {};
+const RunOptionsFields = {
+	timeout: S.Finite,
+	disableBail: S.Boolean
+};
+const MutantActivationSchema = S.Literals(["runtime", "static"]);
+const MutantRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	activeMutant: Mutant,
+	sandboxFileName: S.String,
+	mutantActivation: MutantActivationSchema,
+	reloadEnvironment: S.Boolean,
+	testFilter: S.optionalKey(S.Array(S.String)),
+	hitLimit: S.optionalKey(S.Finite)
+});
+//#endregion
 //#region src/Instrument.schema.ts
 var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/Instrument.schema/InstrumentError")("InstrumentError", {
 	message: S.String,
@@ -130,6 +182,7 @@ const EXPRESSION_KINDS = /* @__PURE__ */ new Set([
 	"JSXFragment",
 	"Literal",
 	"LogicalExpression",
+	"MemberExpression",
 	"MetaProperty",
 	"NewExpression",
 	"ObjectExpression",
@@ -267,7 +320,7 @@ function memberExpression(object, property, optional, loc) {
 	}, loc);
 }
 function arrowFunctionExpression(params, body, loc) {
-	const fnBody = body;
+	const fnBody = arrowFunctionBody(body);
 	return mark({
 		type: "ArrowFunctionExpression",
 		id: null,
@@ -278,6 +331,16 @@ function arrowFunctionExpression(params, body, loc) {
 		expression: fnBody.type !== "BlockStatement"
 	}, loc);
 }
+function arrowFunctionBody(body) {
+	if (isArrowBody(body)) return body;
+	throw new Error(`Invalid arrow function body: ${body.type}`);
+}
+function isArrowBody(body) {
+	return isBlockStatementNode(body) || isExpressionKind(body);
+}
+function isBlockStatementNode(node) {
+	return nodeType(node) === "BlockStatement";
+}
 function blockStatement(body, loc) {
 	return mark({
 		type: "BlockStatement",
@@ -429,9 +492,13 @@ function pushComment(map, node, comment) {
 	else list.push(comment);
 }
 const isNodeList = (value) => Array.isArray(value);
+const walkableNode = (node) => {
+	if (isAstNode(node)) return node;
+	throw new Error("Expected an AST node to walk");
+};
 const walker = (root, visitors) => {
 	const ancestors = [];
-	walk(root, {
+	walk(walkableNode(root), {
 		enter(node) {
 			visitors.enter?.(node, [...ancestors]);
 			ancestors.push(node);
@@ -478,7 +545,7 @@ function isCommentKey(key) {
 function traverse(root, visitors) {
 	const stack = [];
 	try {
-		walk(root, {
+		walk(walkableNode(root), {
 			enter(node, _parent, context) {
 				readPath(stack, node, this, context, visitors);
 			},
@@ -511,8 +578,11 @@ function notify(visitor, path) {
 const relay = (visitor, path) => {
 	if (path !== void 0) visitor(path);
 };
+const keyOf = (context) => {
+	if (typeof context.key === "string") return context.key;
+};
 function createPath(node, parentPath, controls, context) {
-	const key = typeof context.key === "string" ? context.key : void 0;
+	const key = keyOf(context);
 	const path = {
 		node,
 		parentPath,
@@ -652,7 +722,7 @@ function hasContent(value) {
 function hasHtml(value) {
 	return hasField(value, "html");
 }
-function fieldOf(value, key) {
+function fieldOf$1(value, key) {
 	return Match.value(value).pipe(Match.when(isPlainRecord, (record) => record[key]), Match.orElse(() => void 0));
 }
 function appendIfDefined(values, value) {
@@ -736,7 +806,8 @@ const dotBeforeSlash = (dot, slash) => dot >= 0 && dot > slash;
 const extensionOf = (fileName) => {
 	const dot = fileName.lastIndexOf(".");
 	const slash = Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\"));
-	return dotBeforeSlash(dot, slash) ? fileName.slice(dot).toLowerCase() : "";
+	if (!dotBeforeSlash(dot, slash)) return "";
+	return fileName.slice(dot).toLowerCase();
 };
 function createJSParser() {
 	return (text, fileName) => Effect.map(parseWithOxc(text, fileName, "js"), ({ root, comments }) => ({
@@ -1043,7 +1114,7 @@ function htmlRootOf(ast) {
 	}));
 }
 function instanceScriptRange(ast) {
-	return Match.value(fieldOf(ast, "instance")).pipe(Match.when(hasContent, (instance) => scriptContentRange(instance["content"], INSTANCE_RANGE_MISSING)), Match.orElse(() => void 0));
+	return Match.value(fieldOf$1(ast, "instance")).pipe(Match.when(hasContent, (instance) => scriptContentRange(instance["content"], INSTANCE_RANGE_MISSING)), Match.orElse(() => void 0));
 }
 function scriptContentRange(content, missingRange) {
 	return Match.value(content).pipe(Match.when(isRange, (range) => ({
@@ -1055,7 +1126,7 @@ function scriptContentRange(content, missingRange) {
 	}));
 }
 function getModuleScriptRange(svelteAst) {
-	return Match.value(fieldOf(svelteAst, "module")).pipe(Match.when(void 0, () => void 0), Match.when(null, () => void 0), Match.orElse((block) => moduleBlockRange(block)));
+	return Match.value(fieldOf$1(svelteAst, "module")).pipe(Match.when(void 0, () => void 0), Match.when(null, () => void 0), Match.orElse((block) => moduleBlockRange(block)));
 }
 function moduleBlockRange(block) {
 	return Match.value(block).pipe(Match.when(hasContent, (record) => scriptContentRange(record["content"], MODULE_RANGE_MISSING)), Match.orElse(() => {
@@ -1113,10 +1184,10 @@ function scriptFormatOf(script) {
 //#endregion
 //#region src/print/index.ts
 function printProgram(program, opts = {}) {
-	return new PrintState(opts).printProgram(program);
+	return renderProgram(createState(opts), program);
 }
 function printNode(node, opts = {}) {
-	return new PrintState(opts).printAnyNode(node);
+	return renderAnyNode(createState(opts), node);
 }
 const PREC = {
 	Sequence: 0,
@@ -1178,1740 +1249,1728 @@ const LOGICAL_PRECEDENCE = {
 function logicalPrec(op) {
 	return LOGICAL_PRECEDENCE[op] ?? PREC.LogicalAND;
 }
-var PrintState = class {
-	out = "";
-	indentLevel = 0;
-	hashbang;
-	commentIdx = 0;
-	sortedComments;
-	constructor(opts) {
-		this.hashbang = opts.hashbang ?? null;
-		this.sortedComments = [...sortedCommentsWithoutHashbang(opts.comments, this.hashbang), END_OF_COMMENTS];
-	}
-	printProgram(program) {
-		this.out = "";
-		this.indentLevel = 0;
-		this.commentIdx = 0;
-		this.printHashbang();
-		this.emitCommentsBefore(program.body[0]?.start);
-		this.printProgramBody(program.body);
-		this.emitCommentsBefore(void 0);
-		return this.out;
-	}
-	printAnyNode(node) {
-		this.out = "";
-		this.indentLevel = 0;
-		this.printNode(node, PREC.Sequence);
-		return this.out;
-	}
-	printHashbang() {
-		if (this.hashbang) this.out += `#!${this.hashbang.value}\n`;
-	}
-	printProgramBody(body) {
-		body.forEach((statement) => this.printProgramStatement(statement));
-	}
-	printProgramStatement(statement) {
-		this.emitCommentsBefore(statement.start ?? -1);
-		this.printStatement(statement);
-		this.out += "\n";
-	}
-	printJumpStatement(keyword, label) {
-		this.out += keyword;
-		if (label) this.out += ` ${label.name}`;
-		this.out += ";";
-	}
-	/** Emits every pending comment that starts before `pos`; an absent bound admits every comment. */
-	emitCommentsBefore(pos) {
-		this.emitPendingCommentsBefore(pos ?? EVERY_COMMENT_POSITION);
-	}
-	emitPendingCommentsBefore(pos) {
-		for (let comment = this.sortedComments[this.commentIdx]; comment.start < pos; comment = this.sortedComments[this.commentIdx]) {
-			this.emitComment(comment);
-			this.commentIdx++;
-		}
-	}
-	emitComment(c) {
-		if (c.type === "Line") this.out += `//${c.value}\n`;
-		else this.out += `/*${c.value}*/\n`;
-	}
-	indent() {
-		return "  ".repeat(this.indentLevel);
-	}
-	nl() {
-		this.out += "\n";
-	}
-	/** Renders a fragment to a string without disturbing the pending output. */
-	capture(render) {
-		const saved = this.out;
-		this.out = "";
-		render();
-		const result = this.out;
-		this.out = saved;
-		return result;
-	}
-	needsParens(childPrec, parentPrec, isRight, op) {
-		switch (childPrec === parentPrec) {
-			case true: return this.equalPrecedenceNeedsParens(isRight, op);
-			default: return childPrec < parentPrec;
-		}
-	}
-	/** Equal precedence — associativity decides. */
-	equalPrecedenceNeedsParens(isRight, op) {
-		switch (op) {
-			case "**": return !isRight;
-			default: return isRight;
-		}
-	}
-	wrapIfNeeded(node, prec, parentPrec, isRight, op) {
-		const inner = this.printExpressionToString(node, prec);
-		if (this.needsParens(prec, parentPrec, isRight, op)) return `(${inner})`;
-		return inner;
-	}
-	printExpressionToString(node, prec) {
-		return this.capture(() => this.printNode(node, prec));
-	}
-	sequenceNodeText(node) {
-		return this.capture(() => this.printNode(node, PREC.Sequence));
-	}
-	assignmentNodeText(node) {
-		return this.capture(() => this.printNode(node, PREC.Assignment));
+function createState(opts) {
+	const hashbang = opts.hashbang ?? null;
+	return {
+		out: "",
+		indentLevel: 0,
+		hashbang,
+		commentIdx: 0,
+		sortedComments: [...sortedCommentsWithoutHashbang(opts.comments, hashbang), END_OF_COMMENTS]
+	};
+}
+function renderProgram(state, program) {
+	state.out = "";
+	state.indentLevel = 0;
+	state.commentIdx = 0;
+	printHashbang(state);
+	emitCommentsBefore(state, program.body[0]?.start);
+	printProgramBody(state, program.body);
+	emitCommentsBefore(state, void 0);
+	return state.out;
+}
+function renderAnyNode(state, node) {
+	state.out = "";
+	state.indentLevel = 0;
+	printNodePrec(state, node, PREC.Sequence);
+	return state.out;
+}
+function printHashbang(state) {
+	if (state.hashbang !== null) state.out += `#!${state.hashbang.value}\n`;
+}
+function printProgramBody(state, body) {
+	body.forEach((statement) => printProgramStatement(state, statement));
+}
+function printProgramStatement(state, statement) {
+	emitCommentsBefore(state, statement.start ?? -1);
+	printStatement(state, statement);
+	state.out += "\n";
+}
+function printJumpStatement(state, keyword, label) {
+	state.out += keyword;
+	if (label !== null) state.out += ` ${label.name}`;
+	state.out += ";";
+}
+function emitCommentsBefore(state, pos) {
+	emitPendingCommentsBefore(state, pos ?? EVERY_COMMENT_POSITION);
+}
+function emitPendingCommentsBefore(state, pos) {
+	let comment = state.sortedComments[state.commentIdx];
+	while (isCommentBefore(comment, pos)) {
+		emitComment(state, comment);
+		state.commentIdx++;
+		comment = state.sortedComments[state.commentIdx];
+	}
+}
+function isCommentBefore(comment, pos) {
+	return comment !== void 0 && comment.start < pos;
+}
+function emitComment(state, c) {
+	if (c.type === "Line") state.out += `//${c.value}\n`;
+	else state.out += `/*${c.value}*/\n`;
+}
+function indent(state) {
+	return "  ".repeat(state.indentLevel);
+}
+function capture(state, render) {
+	const saved = state.out;
+	state.out = "";
+	render();
+	const result = state.out;
+	state.out = saved;
+	return result;
+}
+function needsParens(childPrec, parentPrec, isRight, op) {
+	if (childPrec === parentPrec) return equalPrecedenceNeedsParens(isRight, op);
+	return childPrec < parentPrec;
+}
+function equalPrecedenceNeedsParens(isRight, op) {
+	if (op === "**") return !isRight;
+	return isRight;
+}
+function wrapIfNeeded(state, node, prec, parentPrec, isRight, op) {
+	const inner = printExpressionToString(state, node, prec);
+	if (needsParens(prec, parentPrec, isRight, op)) return `(${inner})`;
+	return inner;
+}
+function printExpressionToString(state, node, prec) {
+	return capture(state, () => printNodePrec(state, node, prec));
+}
+function sequenceNodeText(state, node) {
+	return capture(state, () => printNodePrec(state, node, PREC.Sequence));
+}
+function assignmentNodeText(state, node) {
+	return capture(state, () => printNodePrec(state, node, PREC.Assignment));
+}
+function nodeListText(state, nodes, prec) {
+	return nodes.map((node) => capture(state, () => printNodePrec(state, node, prec))).join(", ");
+}
+function wrappedExpressionText(state, node, prec, wrappedKinds) {
+	const printed = printExpressionToString(state, node, prec);
+	if (wrappedKinds[node.type] === true) return `(${printed})`;
+	return printed;
+}
+function printNodePrec(state, node, prec) {
+	if (node == null) return;
+	dispatchNode(state, node, prec);
+}
+function dispatchNode(state, node, prec) {
+	switch (node.type) {
+		case "Literal":
+			printLiteral(state, node);
+			break;
+		case "Identifier":
+			printIdentifier(state, node);
+			break;
+		case "PrivateIdentifier":
+			state.out += `#${node.name}`;
+			break;
+		case "ThisExpression":
+			state.out += "this";
+			break;
+		case "Super":
+			state.out += "super";
+			break;
+		case "ArrayExpression":
+			printArrayExpression(state, node);
+			break;
+		case "ObjectExpression":
+			printObjectExpression(state, node);
+			break;
+		case "Property":
+			printProperty(state, node);
+			break;
+		case "TemplateLiteral":
+			printTemplateLiteral(state, node);
+			break;
+		case "TemplateElement":
+			state.out += node.value.raw;
+			break;
+		case "TaggedTemplateExpression":
+			printTaggedTemplate(state, node);
+			break;
+		case "MemberExpression":
+			printMemberExpression(state, node, prec);
+			break;
+		case "CallExpression":
+			printCallExpression(state, node, prec);
+			break;
+		case "NewExpression":
+			printNewExpression(state, node, prec);
+			break;
+		case "MetaProperty":
+			printMetaProperty(state, node);
+			break;
+		case "SpreadElement":
+			state.out += "...";
+			printNodePrec(state, node.argument, PREC.Assignment);
+			break;
+		case "RestElement":
+			state.out += "...";
+			printNodePrec(state, node.argument, PREC.Assignment);
+			break;
+		case "UpdateExpression":
+			printUpdateExpression(state, node, prec);
+			break;
+		case "UnaryExpression":
+			printUnaryExpression(state, node, prec);
+			break;
+		case "BinaryExpression":
+			printBinaryExpression(state, node, prec);
+			break;
+		case "LogicalExpression":
+			printLogicalExpression(state, node, prec);
+			break;
+		case "ConditionalExpression":
+			printConditionalExpression(state, node, prec);
+			break;
+		case "AssignmentExpression":
+			printAssignmentExpression(state, node, prec);
+			break;
+		case "AssignmentPattern":
+			printAssignmentPattern(state, node, prec);
+			break;
+		case "ObjectPattern":
+			printObjectPattern(state, node);
+			break;
+		case "ArrayPattern":
+			printArrayPattern(state, node);
+			break;
+		case "SequenceExpression":
+			printSequenceExpression(state, node, prec);
+			break;
+		case "AwaitExpression":
+			state.out += "await ";
+			printNodePrec(state, node.argument, PREC.Unary);
+			break;
+		case "YieldExpression":
+			printYieldExpression(state, node, prec);
+			break;
+		case "ChainExpression":
+			printNodePrec(state, node.expression, prec);
+			break;
+		case "ParenthesizedExpression":
+			state.out += "(";
+			printNodePrec(state, node.expression, PREC.Sequence);
+			state.out += ")";
+			break;
+		case "ImportExpression":
+			printImportExpression(state, node);
+			break;
+		case "V8IntrinsicExpression":
+			printV8Intrinsic(state, node);
+			break;
+		case "ArrowFunctionExpression":
+			printArrowFunction(state, node, prec);
+			break;
+		case "FunctionExpression":
+		case "FunctionDeclaration":
+		case "TSDeclareFunction":
+		case "TSEmptyBodyFunctionExpression":
+			printFunction(state, node, prec);
+			break;
+		case "ClassDeclaration":
+		case "ClassExpression":
+			printClass(state, node, prec);
+			break;
+		case "JSXElement":
+			printJSXElement(state, node);
+			break;
+		case "JSXFragment":
+			printJSXFragment(state, node);
+			break;
+		case "JSXOpeningElement":
+			printJSXOpeningElement(state, node);
+			break;
+		case "JSXClosingElement": break;
+		case "JSXIdentifier":
+			state.out += node.name;
+			break;
+		case "JSXNamespacedName":
+			state.out += `${node.namespace.name}:${node.name.name}`;
+			break;
+		case "JSXMemberExpression":
+			printJSXMemberExpression(state, node);
+			break;
+		case "JSXAttribute":
+			printJSXAttribute(state, node);
+			break;
+		case "JSXSpreadAttribute":
+			state.out += "{...";
+			printNodePrec(state, node.argument, PREC.Assignment);
+			state.out += "}";
+			break;
+		case "JSXExpressionContainer":
+			state.out += "{";
+			printNodePrec(state, node.expression, PREC.Sequence);
+			state.out += "}";
+			break;
+		case "JSXEmptyExpression": break;
+		case "JSXText":
+			state.out += node.value;
+			break;
+		case "JSXSpreadChild":
+			state.out += "{...";
+			printNodePrec(state, node.expression, PREC.Assignment);
+			state.out += "}";
+			break;
+		case "TSAsExpression":
+			printTSAsExpression(state, node, prec);
+			break;
+		case "TSSatisfiesExpression":
+			printTSSatisfiesExpression(state, node, prec);
+			break;
+		case "TSTypeAssertion":
+			printTSTypeAssertion(state, node, prec);
+			break;
+		case "TSNonNullExpression":
+			printNodePrec(state, node.expression, PREC.Member);
+			state.out += "!";
+			break;
+		case "TSInstantiationExpression":
+			printTSInstantiationExpression(state, node, prec);
+			break;
+		case "BlockStatement":
+			printBlockStatement(state, node);
+			break;
+		case "EmptyStatement":
+			state.out += ";";
+			break;
+		case "ExpressionStatement":
+			printExpressionStatement(state, node);
+			break;
+		case "IfStatement":
+			printIfStatement(state, node);
+			break;
+		case "DoWhileStatement":
+			printDoWhileStatement(state, node);
+			break;
+		case "WhileStatement":
+			printWhileStatement(state, node);
+			break;
+		case "ForStatement":
+			printForStatement(state, node);
+			break;
+		case "ForInStatement":
+			printForInStatement(state, node);
+			break;
+		case "ForOfStatement":
+			printForOfStatement(state, node);
+			break;
+		case "ContinueStatement":
+			printJumpStatement(state, "continue", node.label);
+			break;
+		case "BreakStatement":
+			printJumpStatement(state, "break", node.label);
+			break;
+		case "ReturnStatement":
+			printReturnStatement(state, node);
+			break;
+		case "WithStatement":
+			printWithStatement(state, node);
+			break;
+		case "SwitchStatement":
+			printSwitchStatement(state, node);
+			break;
+		case "SwitchCase": break;
+		case "LabeledStatement":
+			printLabeledStatement(state, node);
+			break;
+		case "ThrowStatement":
+			state.out += "throw ";
+			printNodePrec(state, node.argument, PREC.Sequence);
+			state.out += ";";
+			break;
+		case "TryStatement":
+			printTryStatement(state, node);
+			break;
+		case "CatchClause": break;
+		case "DebuggerStatement":
+			state.out += "debugger;";
+			break;
+		case "VariableDeclaration":
+			printVariableDeclaration(state, node);
+			break;
+		case "VariableDeclarator":
+			printVariableDeclarator(state, node);
+			break;
+		case "ClassBody":
+			printClassBody(state, node);
+			break;
+		case "MethodDefinition":
+		case "TSAbstractMethodDefinition":
+			printMethodDefinition(state, node);
+			break;
+		case "PropertyDefinition":
+		case "TSAbstractPropertyDefinition":
+			printPropertyDefinition(state, node);
+			break;
+		case "AccessorProperty":
+		case "TSAbstractAccessorProperty":
+			printAccessorProperty(state, node);
+			break;
+		case "StaticBlock":
+			printStaticBlock(state, node);
+			break;
+		case "ImportDeclaration":
+			printImportDeclaration(state, node);
+			break;
+		case "ExportNamedDeclaration":
+			printExportNamedDeclaration(state, node);
+			break;
+		case "ExportDefaultDeclaration":
+			printExportDefaultDeclaration(state, node);
+			break;
+		case "ExportAllDeclaration":
+			printExportAllDeclaration(state, node);
+			break;
+		case "Decorator":
+			state.out += "@";
+			printNodePrec(state, node.expression, PREC.Member);
+			break;
+		case "TSTypeAliasDeclaration":
+			printTSTypeAliasDeclaration(state, node);
+			break;
+		case "TSInterfaceDeclaration":
+			printTSInterfaceDeclaration(state, node);
+			break;
+		case "TSEnumDeclaration":
+			printTSEnumDeclaration(state, node);
+			break;
+		case "TSModuleDeclaration":
+			printTSModuleDeclaration(state, node);
+			break;
+		case "TSImportEqualsDeclaration":
+			printTSImportEqualsDeclaration(state, node);
+			break;
+		case "TSExportAssignment":
+			state.out += `export = `;
+			printNodePrec(state, node.expression, PREC.Sequence);
+			state.out += ";";
+			break;
+		case "TSNamespaceExportDeclaration":
+			state.out += `export as namespace ${node.id.name};`;
+			break;
+		case "Program":
+		case "ExportSpecifier":
+		case "Hashbang":
+		case "ImportAttribute":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier":
+		case "ImportSpecifier":
+		case "JSXClosingFragment":
+		case "JSXOpeningFragment":
+		case "TSAnyKeyword":
+		case "TSArrayType":
+		case "TSBigIntKeyword":
+		case "TSBooleanKeyword":
+		case "TSCallSignatureDeclaration":
+		case "TSClassImplements":
+		case "TSConditionalType":
+		case "TSConstructSignatureDeclaration":
+		case "TSConstructorType":
+		case "TSEnumBody":
+		case "TSEnumMember":
+		case "TSExternalModuleReference":
+		case "TSFunctionType":
+		case "TSImportType":
+		case "TSIndexSignature":
+		case "TSIndexedAccessType":
+		case "TSInferType":
+		case "TSInterfaceBody":
+		case "TSInterfaceHeritage":
+		case "TSIntersectionType":
+		case "TSIntrinsicKeyword":
+		case "TSJSDocNonNullableType":
+		case "TSJSDocNullableType":
+		case "TSJSDocUnknownType":
+		case "TSLiteralType":
+		case "TSMappedType":
+		case "TSMethodSignature":
+		case "TSModuleBlock":
+		case "TSNamedTupleMember":
+		case "TSNeverKeyword":
+		case "TSNullKeyword":
+		case "TSNumberKeyword":
+		case "TSObjectKeyword":
+		case "TSOptionalType":
+		case "TSParameterProperty":
+		case "TSParenthesizedType":
+		case "TSPropertySignature":
+		case "TSQualifiedName":
+		case "TSRestType":
+		case "TSStringKeyword":
+		case "TSSymbolKeyword":
+		case "TSTemplateLiteralType":
+		case "TSThisType":
+		case "TSTupleType":
+		case "TSTypeAnnotation":
+		case "TSTypeLiteral":
+		case "TSTypeOperator":
+		case "TSTypeParameter":
+		case "TSTypeParameterDeclaration":
+		case "TSTypeParameterInstantiation":
+		case "TSTypePredicate":
+		case "TSTypeQuery":
+		case "TSTypeReference":
+		case "TSUndefinedKeyword":
+		case "TSUnionType":
+		case "TSUnknownKeyword":
+		case "TSVoidKeyword": printUnclassifiedNode(state, node, node.type);
+	}
+}
+function printUnclassifiedNode(state, node, kind) {
+	if (isTSType(node)) {
+		printTSType(state, node);
+		return;
+	}
+	printTypeHolderNode(state, node, kind);
+}
+function printTypeHolderNode(state, node, kind) {
+	switch (kind) {
+		case "TSTypeAnnotation":
+			printTypeAnnotationHolder(state, node);
+			break;
+		case "TSTypeParameterDeclaration":
+			printTypeParameterDeclarationHolder(state, node);
+			break;
+		case "TSTypeParameterInstantiation":
+			printTypeParameterInstantiationHolder(state, node);
+			break;
+		case "TSTypeParameter":
+			printTypeParameterHolder(state, node);
+			break;
+		default: state.out += `/* unknown:${kind} */`;
+	}
+}
+function printTypeAnnotationHolder(state, node) {
+	if (isNodeOfKind(node, "TSTypeAnnotation")) {
+		state.out += ": ";
+		printTSType(state, node.typeAnnotation);
+	}
+}
+function printTypeParameterDeclarationHolder(state, node) {
+	if (isNodeOfKind(node, "TSTypeParameterDeclaration")) printTSTypeParameterDeclaration(state, node);
+}
+function printTypeParameterInstantiationHolder(state, node) {
+	if (isNodeOfKind(node, "TSTypeParameterInstantiation")) printTSTypeParameterInstantiation(state, node);
+}
+function printTypeParameterHolder(state, node) {
+	if (isNodeOfKind(node, "TSTypeParameter")) printTSTypeParameter(state, node);
+}
+function printLiteral(state, node) {
+	state.out += literalText(node);
+}
+function printIdentifier(state, node) {
+	state.out += node.name;
+}
+function printArrayExpression(state, node) {
+	state.out += `[${node.elements.map((element) => arrayElementText(state, element)).join(", ")}]`;
+}
+function arrayElementText(state, element) {
+	if (element === null) return "";
+	return assignmentNodeText(state, element);
+}
+function printObjectExpression(state, node) {
+	switch (node.properties.length) {
+		case 0:
+			state.out += "{}";
+			break;
+		default: state.out += `{ ${nodeListText(state, node.properties, PREC.Sequence)} }`;
+	}
+}
+function printProperty(state, node) {
+	switch (propertyForm(node)) {
+		case "accessor":
+			state.out += `${node.kind} `;
+			state.out += propertyKeyText(state, node.key, node.computed === true, PREC.Assignment);
+			printFunctionValueTail(state, node.value);
+			break;
+		case "method":
+			state.out += propertyKeyText(state, node.key, node.computed === true, PREC.Assignment);
+			printFunctionValueTail(state, node.value);
+			break;
+		case "shorthand":
+			state.out += identifierNameText(node.key);
+			break;
+		case "shorthandDefault":
+			printShorthandDefaultProperty(state, node);
+			break;
+		default:
+			state.out += propertyKeyText(state, node.key, node.computed === true, PREC.Assignment);
+			state.out += ": ";
+			printNodePrec(state, node.value, PREC.Assignment);
+	}
+}
+function printFunctionValueTail(state, value) {
+	if (isFunctionNode(value)) printFunctionTail(state, value);
+}
+function printShorthandDefaultProperty(state, node) {
+	if (!isAssignmentPattern(node.value)) return;
+	const right = assignmentNodeText(state, node.value.right);
+	state.out += `${identifierNameText(node.key)} = ${right}`;
+}
+function propertyKeyText(state, key, computed, computedPrec) {
+	if (computed) return `[${capture(state, () => printNodePrec(state, key, computedPrec))}]`;
+	return plainPropertyKeyText(state, key);
+}
+function plainPropertyKeyText(state, key) {
+	switch (nodeKind(key)) {
+		case "Identifier": return identifierNameText(key);
+		case "PrivateIdentifier": return privateIdentifierText(key);
+		case "Literal": return literalCapture(state, key);
+		default: return capture(state, () => printNodePrec(state, key, PREC.Assignment));
+	}
+}
+function printFunctionTail(state, fn) {
+	state.out += typeParametersText(state, fn.typeParameters);
+	state.out += `(${paramsText(state, fn.params)})`;
+	state.out += typeAnnotationText(state, fn.returnType);
+	state.out += functionBodyText(state, fn);
+}
+function functionBodyText(state, fn) {
+	const body = fn.body;
+	if (body !== null) return ` ${capture(state, () => printBlockStatement(state, body))}`;
+	return ";";
+}
+function paramsText(state, params) {
+	return capture(state, () => printParams(state, params));
+}
+function typeParametersText(state, params) {
+	if (params == null) return "";
+	return capture(state, () => printTSTypeParameterDeclaration(state, params));
+}
+function typeArgumentsText(state, args) {
+	if (args == null) return "";
+	return capture(state, () => printTSTypeParameterInstantiation(state, args));
+}
+function typeAnnotationText(state, annotation) {
+	if (annotation == null) return "";
+	return capture(state, () => printTSTypeAnnotation(state, annotation));
+}
+function printTemplateLiteral(state, node) {
+	state.out += `\`${node.quasis.map((quasi, index) => quasiText(state, quasi, node.expressions[index])).join("")}\``;
+}
+function quasiText(state, quasi, expression) {
+	if (quasi.tail) return quasi.value.raw;
+	return `${quasi.value.raw}\${${sequenceNodeText(state, expression)}}`;
+}
+function printTaggedTemplate(state, node) {
+	printNodePrec(state, node.tag, PREC.Member);
+	if (node.typeArguments != null) printTSTypeParameterInstantiation(state, node.typeArguments);
+	printTemplateLiteral(state, node.quasi);
+}
+function printMemberExpression(state, node, _prec) {
+	state.out += wrappedExpressionText(state, node.object, PREC.Member, MEMBER_OBJECT_WRAPPED_KINDS);
+	state.out += flagText(node.optional, "?.");
+	state.out += memberSelectorText(state, node);
+}
+function memberSelectorText(state, access) {
+	if (access.computed) return `[${sequenceNodeText(state, access.property)}]`;
+	return `${flagText(!access.optional, ".")}${memberPropertyText(state, access.property)}`;
+}
+function memberPropertyText(state, property) {
+	switch (nodeKind(property)) {
+		case "Identifier": return identifierNameText(property);
+		case "PrivateIdentifier": return privateIdentifierText(property);
+		default: return sequenceNodeText(state, property);
+	}
+}
+function printCallExpression(state, node, _prec) {
+	state.out += wrappedExpressionText(state, node.callee, PREC.Member, CALLEE_WRAPPED_KINDS);
+	state.out += flagText(node.optional, "?.");
+	state.out += typeArgumentsText(state, node.typeArguments);
+	state.out += `(${nodeListText(state, node.arguments, PREC.Assignment)})`;
+}
+function printNewExpression(state, node, _prec) {
+	state.out += "new ";
+	state.out += printExpressionToString(state, node.callee, PREC.Member);
+	state.out += typeArgumentsText(state, node.typeArguments);
+	state.out += `(${nodeListText(state, node.arguments, PREC.Assignment)})`;
+}
+function printMetaProperty(state, node) {
+	state.out += `${node.meta.name}.${node.property.name}`;
+}
+function printV8Intrinsic(state, node) {
+	state.out += `%${node.name.name}(${nodeListText(state, node.arguments, PREC.Assignment)})`;
+}
+function printImportExpression(state, node) {
+	state.out += `import${flagText(node.phase, `.${node.phase}`)}(`;
+	state.out += assignmentNodeText(state, node.source);
+	state.out += flagText(node.options, `, ${assignmentNodeText(state, node.options)}`);
+	state.out += ")";
+}
+function printUpdateExpression(state, node, _prec) {
+	const operand = wrappedExpressionText(state, node.argument, PREC.Update, MEMBER_OBJECT_WRAPPED_KINDS);
+	if (node.prefix) {
+		state.out += `${node.operator}${operand}`;
+		return;
+	}
+	state.out += `${operand}${node.operator}`;
+}
+function printUnaryExpression(state, node, _prec) {
+	state.out += node.operator;
+	state.out += flagText(UNARY_WORD_OPERATORS[node.operator] === true, " ");
+	state.out += wrappedExpressionText(state, node.argument, PREC.Unary, UNARY_OPERAND_WRAPPED_KINDS);
+}
+function printBinaryExpression(state, node, prec) {
+	const myPrec = binaryPrec(node.operator);
+	const leftStr = wrapIfNeeded(state, node.left, precOf(node.left), myPrec, false, node.operator);
+	const rightStr = wrapIfNeeded(state, node.right, precOf(node.right), myPrec, true, node.operator);
+	const whole = `${leftStr} ${node.operator} ${rightStr}`;
+	if (myPrec < prec) state.out += `(${whole})`;
+	else state.out += whole;
+}
+function printLogicalExpression(state, node, prec) {
+	const myPrec = logicalPrec(node.operator);
+	const leftStr = wrapIfNeeded(state, node.left, precOf(node.left), myPrec, false, node.operator);
+	const rightStr = wrapIfNeeded(state, node.right, precOf(node.right), myPrec, true, node.operator);
+	const whole = `${leftStr} ${node.operator} ${rightStr}`;
+	if (myPrec < prec) state.out += `(${whole})`;
+	else state.out += whole;
+}
+function printConditionalExpression(state, node, prec) {
+	const myPrec = PREC.Conditional;
+	const whole = `${wrapIfNeeded(state, node.test, precOf(node.test), myPrec, false)} ? ${printExpressionToString(state, node.consequent, PREC.Assignment)} : ${printExpressionToString(state, node.alternate, PREC.Assignment)}`;
+	if (myPrec < prec) state.out += `(${whole})`;
+	else state.out += whole;
+}
+function printAssignmentExpression(state, node, prec) {
+	const myPrec = PREC.Assignment;
+	const leftStr = printExpressionToString(state, node.left, myPrec);
+	const rightStr = printExpressionToString(state, node.right, myPrec - .1);
+	const whole = `${leftStr} ${node.operator} ${rightStr}`;
+	if (myPrec < prec) state.out += `(${whole})`;
+	else state.out += whole;
+}
+function printAssignmentPattern(state, node, prec) {
+	const leftText = printExpressionToString(state, node.left, PREC.Assignment) + typeAnnotationText(state, bindingTypeAnnotation(node.left));
+	const rightText = printExpressionToString(state, node.right, PREC.Assignment);
+	state.out += parenthesizedIf(PREC.Assignment < prec, `${leftText} = ${rightText}`);
+}
+function printObjectPattern(state, node) {
+	switch (node.properties.length) {
+		case 0:
+			state.out += "{}";
+			break;
+		default: state.out += `{ ${nodeListText(state, node.properties, PREC.Sequence)} }`;
+	}
+}
+function printArrayPattern(state, node) {
+	state.out += `[${node.elements.map((element) => arrayElementText(state, element)).join(", ")}]`;
+}
+function printSequenceExpression(state, node, prec) {
+	const whole = node.expressions.map((expression) => printExpressionToString(state, expression, PREC.Sequence)).join(", ");
+	state.out += parenthesizedIf(PREC.Sequence < prec, whole);
+}
+function printYieldExpression(state, node, _prec) {
+	if (node.delegate) state.out += "yield*";
+	else state.out += "yield";
+	state.out += flagText(node.argument, ` ${assignmentNodeText(state, node.argument)}`);
+}
+function printArrowFunction(state, node, prec) {
+	const arrow = `${flagText(node.async, "async ")}${typeParametersText(state, node.typeParameters)}${arrowParamsText(state, node)}${typeAnnotationText(state, node.returnType)} => ${arrowBodyText(state, node)}`;
+	state.out += parenthesizedIf(PREC.Assignment < prec, arrow);
+}
+function arrowParamsText(state, node) {
+	const bareParam = bareArrowParamName(node);
+	if (bareParam.length === 0) return `(${paramsText(state, node.params)})`;
+	return bareParam;
+}
+function arrowBodyText(state, node) {
+	const body = node.body;
+	if (arrowBodyIsBlock(body)) return capture(state, () => printBlockStatement(state, body));
+	return assignmentNodeText(state, body);
+}
+function printFunction(state, node, _prec) {
+	state.out += functionHeaderText(node);
+	printFunctionTail(state, node);
+}
+function printClass(state, node, _prec) {
+	state.out += capture(state, () => printDecorators(state, node.decorators));
+	state.out += `${flagText(node.declare, "declare ")}${flagText(node.abstract, "abstract ")}class${namedDeclarationText(node)}`;
+	state.out += typeParametersText(state, node.typeParameters);
+	state.out += classHeritageText(state, node);
+	state.out += classImplementsText(state, node);
+	state.out += " ";
+	printClassBody(state, node.body);
+}
+function classHeritageText(state, node) {
+	if (node.superClass !== null) return ` extends ${assignmentNodeText(state, node.superClass)}${typeArgumentsText(state, node.superTypeArguments)}`;
+	return "";
+}
+function classImplementsText(state, node) {
+	const rendered = (node.implements ?? []).map((heritage) => heritageText(state, heritage)).join(", ");
+	return flagText(rendered, ` implements ${rendered}`);
+}
+function heritageText(state, heritage) {
+	return `${assignmentNodeText(state, heritage.expression)}${typeArgumentsText(state, heritage.typeArguments)}`;
+}
+function printDecorators(state, decorators) {
+	const rendered = (decorators ?? []).map((decorator) => decoratorText(state, decorator)).join(" ");
+	state.out += flagText(rendered, `${rendered} `);
+}
+function decoratorText(state, decorator) {
+	return `@${capture(state, () => printNodePrec(state, decorator.expression, PREC.Member))}`;
+}
+function printJSXElement(state, node) {
+	printJSXOpeningElement(state, node.openingElement);
+	node.children.forEach((child) => printJSXChild(state, child));
+	printJSXClosingElement(state, node);
+}
+function printJSXClosingElement(state, node) {
+	if (node.closingElement === null) return;
+	state.out += `</${jsxElementNameText(state, node.closingElement.name)}>`;
+}
+function printJSXFragment(state, node) {
+	state.out += "<>";
+	for (const child of node.children) printJSXChild(state, child);
+	state.out += "</>";
+}
+function printJSXOpeningElement(state, node) {
+	state.out += `<${jsxElementNameText(state, node.name)}`;
+	state.out += typeArgumentsText(state, node.typeArguments);
+	state.out += node.attributes.map((attribute) => ` ${sequenceNodeText(state, attribute)}`).join("");
+	if (node.selfClosing) {
+		state.out += " />";
+		return;
 	}
-	nodeListText(nodes, prec) {
-		return nodes.map((node) => this.capture(() => this.printNode(node, prec))).join(", ");
+	state.out += ">";
+}
+function jsxElementNameText(state, name) {
+	switch (name.type) {
+		case "JSXIdentifier": return name.name;
+		case "JSXNamespacedName": return `${name.namespace.name}:${name.name.name}`;
+		case "JSXMemberExpression": return capture(state, () => printJSXMemberExpression(state, name));
 	}
-	wrappedExpressionText(node, prec, wrappedKinds) {
-		const printed = this.printExpressionToString(node, prec);
-		switch (wrappedKinds[node.type] === true) {
-			case true: return `(${printed})`;
-			default: return printed;
-		}
+}
+function printJSXMemberExpression(state, node) {
+	const obj = node.object;
+	if (obj.type === "JSXIdentifier") {
+		state.out += `${obj.name}.${node.property.name}`;
+		return;
 	}
-	printNode(node, prec) {
-		const kind = nodeKind(node);
-		switch (kind) {
-			case ABSENT_NODE_KIND: return;
-			case "Literal":
-				this.printLiteral(node);
-				break;
-			case "Identifier":
-				this.printIdentifier(node);
-				break;
-			case "PrivateIdentifier":
-				this.out += `#${node.name}`;
-				break;
-			case "ThisExpression":
-				this.out += "this";
-				break;
-			case "Super":
-				this.out += "super";
-				break;
-			case "ArrayExpression":
-				this.printArrayExpression(node);
-				break;
-			case "ObjectExpression":
-				this.printObjectExpression(node);
-				break;
-			case "Property":
-				this.printProperty(node);
-				break;
-			case "TemplateLiteral":
-				this.printTemplateLiteral(node);
-				break;
-			case "TemplateElement":
-				this.out += node.value.raw;
-				break;
-			case "TaggedTemplateExpression":
-				this.printTaggedTemplate(node);
-				break;
-			case "MemberExpression":
-				this.printMemberExpression(node, prec);
-				break;
-			case "CallExpression":
-				this.printCallExpression(node, prec);
-				break;
-			case "NewExpression":
-				this.printNewExpression(node, prec);
-				break;
-			case "MetaProperty":
-				this.printMetaProperty(node);
-				break;
-			case "SpreadElement":
-				this.out += "...";
-				this.printNode(node.argument, PREC.Assignment);
-				break;
-			case "RestElement":
-				this.out += "...";
-				this.printNode(node.argument, PREC.Assignment);
-				break;
-			case "UpdateExpression":
-				this.printUpdateExpression(node, prec);
-				break;
-			case "UnaryExpression":
-				this.printUnaryExpression(node, prec);
-				break;
-			case "BinaryExpression":
-				this.printBinaryExpression(node, prec);
-				break;
-			case "LogicalExpression":
-				this.printLogicalExpression(node, prec);
-				break;
-			case "ConditionalExpression":
-				this.printConditionalExpression(node, prec);
-				break;
-			case "AssignmentExpression":
-				this.printAssignmentExpression(node, prec);
-				break;
-			case "AssignmentPattern":
-				this.printAssignmentPattern(node, prec);
-				break;
-			case "ObjectPattern":
-				this.printObjectPattern(node);
-				break;
-			case "ArrayPattern":
-				this.printArrayPattern(node);
-				break;
-			case "SequenceExpression":
-				this.printSequenceExpression(node, prec);
-				break;
-			case "AwaitExpression":
-				this.out += "await ";
-				this.printNode(node.argument, PREC.Unary);
-				break;
-			case "YieldExpression":
-				this.printYieldExpression(node, prec);
-				break;
-			case "ChainExpression":
-				this.printNode(node.expression, prec);
-				break;
-			case "ParenthesizedExpression":
-				this.out += "(";
-				this.printNode(node.expression, PREC.Sequence);
-				this.out += ")";
-				break;
-			case "ImportExpression":
-				this.printImportExpression(node);
-				break;
-			case "V8IntrinsicExpression":
-				this.printV8Intrinsic(node);
-				break;
-			case "ArrowFunctionExpression":
-				this.printArrowFunction(node, prec);
-				break;
-			case "FunctionExpression":
-			case "FunctionDeclaration":
-			case "TSDeclareFunction":
-			case "TSEmptyBodyFunctionExpression":
-				this.printFunction(node, prec);
-				break;
-			case "ClassDeclaration":
-			case "ClassExpression":
-				this.printClass(node, prec);
-				break;
-			case "JSXElement":
-				this.printJSXElement(node);
-				break;
-			case "JSXFragment":
-				this.printJSXFragment(node);
-				break;
-			case "JSXOpeningElement":
-				this.printJSXOpeningElement(node);
-				break;
-			case "JSXClosingElement": break;
-			case "JSXIdentifier":
-				this.out += node.name;
-				break;
-			case "JSXNamespacedName":
-				this.out += `${node.namespace.name}:${node.name.name}`;
-				break;
-			case "JSXMemberExpression":
-				this.printJSXMemberExpression(node);
-				break;
-			case "JSXAttribute":
-				this.printJSXAttribute(node);
-				break;
-			case "JSXSpreadAttribute":
-				this.out += "{...";
-				this.printNode(node.argument, PREC.Assignment);
-				this.out += "}";
-				break;
-			case "JSXExpressionContainer":
-				this.out += "{";
-				this.printNode(node.expression, PREC.Sequence);
-				this.out += "}";
-				break;
-			case "JSXEmptyExpression": break;
-			case "JSXText":
-				this.out += node.value;
-				break;
-			case "JSXSpreadChild":
-				this.out += "{...";
-				this.printNode(node.expression, PREC.Assignment);
-				this.out += "}";
-				break;
-			case "TSAsExpression":
-				this.printTSAsExpression(node, prec);
-				break;
-			case "TSSatisfiesExpression":
-				this.printTSSatisfiesExpression(node, prec);
-				break;
-			case "TSTypeAssertion":
-				this.printTSTypeAssertion(node, prec);
-				break;
-			case "TSNonNullExpression":
-				this.printNode(node.expression, PREC.Member);
-				this.out += "!";
-				break;
-			case "TSInstantiationExpression":
-				this.printTSInstantiationExpression(node, prec);
-				break;
-			case "BlockStatement":
-				this.printBlockStatement(node);
-				break;
-			case "EmptyStatement":
-				this.out += ";";
-				break;
-			case "ExpressionStatement":
-				this.printExpressionStatement(node);
-				break;
-			case "IfStatement":
-				this.printIfStatement(node);
-				break;
-			case "DoWhileStatement":
-				this.printDoWhileStatement(node);
-				break;
-			case "WhileStatement":
-				this.printWhileStatement(node);
-				break;
-			case "ForStatement":
-				this.printForStatement(node);
-				break;
-			case "ForInStatement":
-				this.printForInStatement(node);
-				break;
-			case "ForOfStatement":
-				this.printForOfStatement(node);
-				break;
-			case "ContinueStatement":
-				this.printJumpStatement("continue", node.label);
-				break;
-			case "BreakStatement":
-				this.printJumpStatement("break", node.label);
-				break;
-			case "ReturnStatement":
-				this.printReturnStatement(node);
-				break;
-			case "WithStatement":
-				this.printWithStatement(node);
-				break;
-			case "SwitchStatement":
-				this.printSwitchStatement(node);
-				break;
-			case "SwitchCase": break;
-			case "LabeledStatement":
-				this.printLabeledStatement(node);
-				break;
-			case "ThrowStatement":
-				this.out += "throw ";
-				this.printNode(node.argument, PREC.Sequence);
-				this.out += ";";
-				break;
-			case "TryStatement":
-				this.printTryStatement(node);
-				break;
-			case "CatchClause": break;
-			case "DebuggerStatement":
-				this.out += "debugger;";
-				break;
-			case "VariableDeclaration":
-				this.printVariableDeclaration(node);
-				break;
-			case "VariableDeclarator":
-				this.printVariableDeclarator(node);
-				break;
-			case "ClassBody":
-				this.printClassBody(node);
-				break;
-			case "MethodDefinition":
-			case "TSAbstractMethodDefinition":
-				this.printMethodDefinition(node);
-				break;
-			case "PropertyDefinition":
-			case "TSAbstractPropertyDefinition":
-				this.printPropertyDefinition(node);
-				break;
-			case "AccessorProperty":
-			case "TSAbstractAccessorProperty":
-				this.printAccessorProperty(node);
-				break;
-			case "StaticBlock":
-				this.printStaticBlock(node);
-				break;
-			case "ImportDeclaration":
-				this.printImportDeclaration(node);
-				break;
-			case "ExportNamedDeclaration":
-				this.printExportNamedDeclaration(node);
-				break;
-			case "ExportDefaultDeclaration":
-				this.printExportDefaultDeclaration(node);
-				break;
-			case "ExportAllDeclaration":
-				this.printExportAllDeclaration(node);
-				break;
-			case "Decorator":
-				this.out += "@";
-				this.printNode(node.expression, PREC.Member);
-				break;
-			case "TSTypeAliasDeclaration":
-				this.printTSTypeAliasDeclaration(node);
-				break;
-			case "TSInterfaceDeclaration":
-				this.printTSInterfaceDeclaration(node);
-				break;
-			case "TSEnumDeclaration":
-				this.printTSEnumDeclaration(node);
-				break;
-			case "TSModuleDeclaration":
-				this.printTSModuleDeclaration(node);
-				break;
-			case "TSImportEqualsDeclaration":
-				this.printTSImportEqualsDeclaration(node);
-				break;
-			case "TSExportAssignment":
-				this.out += `export = `;
-				this.printNode(node.expression, PREC.Sequence);
-				this.out += ";";
-				break;
-			case "TSNamespaceExportDeclaration":
-				this.out += `export as namespace ${node.id.name};`;
-				break;
-			default: this.printUnclassifiedNode(node, kind);
-		}
+	printJSXMemberExpression(state, obj);
+	state.out += `.${node.property.name}`;
+}
+function printJSXAttribute(state, node) {
+	state.out += jsxAttributeNameText(node.name);
+	state.out += jsxAttributeValueClauseText(state, node.value);
+}
+function jsxAttributeValueClauseText(state, value) {
+	if (value === null) return "";
+	return `=${jsxAttributeValueText(state, value)}`;
+}
+function jsxAttributeValueText(state, value) {
+	switch (value.type) {
+		case "Literal": return capture(state, () => printLiteral(state, value));
+		case "JSXExpressionContainer": return `{${sequenceNodeText(state, value.expression)}}`;
+		case "JSXElement":
+		case "JSXFragment": return sequenceNodeText(state, value);
 	}
-	/** TS type nodes and the wrappers that carry them, which oxc kinds apart from expressions. */
-	printUnclassifiedNode(node, kind) {
-		if (isTSTypeNode(kind)) {
-			this.printTSType(node);
+}
+function printJSXChild(state, child) {
+	switch (child.type) {
+		case "JSXText":
+			state.out += child.value;
 			return;
-		}
-		this.printTypeHolderNode(node, kind);
-	}
-	printTypeHolderNode(node, kind) {
-		switch (kind) {
-			case "TSTypeAnnotation":
-				this.out += ": ";
-				this.printTSType(node.typeAnnotation);
-				break;
-			case "TSTypeParameterDeclaration":
-				this.printTSTypeParameterDeclaration(node);
-				break;
-			case "TSTypeParameterInstantiation":
-				this.printTSTypeParameterInstantiation(node);
-				break;
-			case "TSTypeParameter":
-				this.printTSTypeParameter(node);
-				break;
-			default: this.out += `/* unknown:${kind} */`;
-		}
-	}
-	printLiteral(node) {
-		this.out += literalText(node);
-	}
-	printIdentifier(node) {
-		this.out += node.name;
-	}
-	printArrayExpression(node) {
-		this.out += `[${node.elements.map((element) => this.arrayElementText(element)).join(", ")}]`;
-	}
-	arrayElementText(element) {
-		switch (element === null) {
-			case true: return "";
-			default: return this.assignmentNodeText(element);
-		}
-	}
-	printObjectExpression(node) {
-		switch (node.properties.length) {
-			case 0:
-				this.out += "{}";
-				break;
-			default: this.out += `{ ${this.nodeListText(node.properties, PREC.Sequence)} }`;
-		}
-	}
-	printProperty(node) {
-		const fields = node;
-		switch (propertyForm(fields)) {
-			case "accessor":
-				this.out += `${fields.kind} `;
-				this.out += this.propertyKeyText(fields.key, fields.computed === true, PREC.Assignment);
-				this.printFunctionTail(fields.value);
-				break;
-			case "method":
-				this.out += `${flagText(fields.async, "async ")}${flagText(fields.generator, "*")}`;
-				this.out += this.propertyKeyText(fields.key, fields.computed === true, PREC.Assignment);
-				this.printFunctionTail(fields.value);
-				break;
-			case "shorthand":
-				this.out += identifierName(fields.key);
-				break;
-			case "shorthandDefault":
-				this.printShorthandDefaultProperty(fields);
-				break;
-			default:
-				this.out += this.propertyKeyText(fields.key, fields.computed === true, PREC.Assignment);
-				this.out += ": ";
-				this.printNode(fields.value, PREC.Assignment);
-		}
-	}
-	printShorthandDefaultProperty(fields) {
-		const right = this.assignmentNodeText(fields.value.right);
-		this.out += `${identifierName(fields.key)} = ${right}`;
-	}
-	propertyKeyText(key, computed, computedPrec) {
-		switch (computed) {
-			case true: return `[${this.capture(() => this.printNode(key, computedPrec))}]`;
-			default: return this.plainPropertyKeyText(key);
-		}
-	}
-	plainPropertyKeyText(key) {
-		switch (key.type) {
-			case "Identifier": return key.name;
-			case "PrivateIdentifier": return `#${key.name}`;
-			case "Literal": return this.capture(() => this.printLiteral(key));
-			default: return this.capture(() => this.printNode(key, PREC.Assignment));
-		}
-	}
-	printPropertyKeyForClass(key, computed) {
-		this.out += this.propertyKeyText(key, computed, PREC.Sequence);
-	}
-	printFunctionTail(fn) {
-		this.out += this.typeParametersText(fn.typeParameters);
-		this.out += `(${this.paramsText(fn.params)})`;
-		this.out += this.typeAnnotationText(fn.returnType);
-		this.out += this.functionBodyText(fn);
-	}
-	functionBodyText(fn) {
-		switch (Boolean(fn.body)) {
-			case true: return ` ${this.capture(() => this.printBlockStatement(fn.body))}`;
-			default: return ";";
-		}
-	}
-	paramsText(params) {
-		return this.capture(() => this.printParams(params));
-	}
-	typeParametersText(params) {
-		switch (Boolean(params)) {
-			case true: return this.capture(() => this.printTSTypeParameterDeclaration(params));
-			default: return "";
-		}
-	}
-	typeArgumentsText(args) {
-		switch (Boolean(args)) {
-			case true: return this.capture(() => this.printTSTypeParameterInstantiation(args));
-			default: return "";
-		}
-	}
-	typeAnnotationText(annotation) {
-		switch (Boolean(annotation)) {
-			case true: return this.capture(() => this.printTSTypeAnnotation(annotation));
-			default: return "";
-		}
-	}
-	printTemplateLiteral(node) {
-		this.out += `\`${node.quasis.map((quasi, index) => this.quasiText(quasi, node.expressions[index])).join("")}\``;
-	}
-	quasiText(quasi, expression) {
-		switch (quasi.tail) {
-			case true: return quasi.value.raw;
-			default: return `${quasi.value.raw}\${${this.sequenceNodeText(expression)}}`;
-		}
-	}
-	printTaggedTemplate(node) {
-		this.printNode(node.tag, PREC.Member);
-		if (node.typeArguments) this.printTSTypeParameterInstantiation(node.typeArguments);
-		this.printTemplateLiteral(node.quasi);
-	}
-	printMemberExpression(node, _prec) {
-		const access = node;
-		this.out += this.wrappedExpressionText(access.object, PREC.Member, MEMBER_OBJECT_WRAPPED_KINDS);
-		this.out += flagText(access.optional, "?.");
-		this.out += this.memberSelectorText(access);
-	}
-	memberSelectorText(access) {
-		switch (access.computed) {
-			case true: return `[${this.sequenceNodeText(access.property)}]`;
-			default: return `${flagText(!access.optional, ".")}${this.memberPropertyText(access.property)}`;
-		}
-	}
-	memberPropertyText(property) {
-		switch (property.type) {
-			case "Identifier": return property.name;
-			case "PrivateIdentifier": return `#${property.name}`;
-			default: return this.sequenceNodeText(property);
-		}
-	}
-	printCallExpression(node, _prec) {
-		this.out += this.wrappedExpressionText(node.callee, PREC.Member, CALLEE_WRAPPED_KINDS);
-		this.out += flagText(node.optional, "?.");
-		this.out += this.typeArgumentsText(node.typeArguments);
-		this.out += `(${this.nodeListText(node.arguments, PREC.Assignment)})`;
-	}
-	printNewExpression(node, _prec) {
-		this.out += "new ";
-		this.out += this.printExpressionToString(node.callee, PREC.Member);
-		this.out += this.typeArgumentsText(node.typeArguments);
-		this.out += `(${this.nodeListText(node.arguments, PREC.Assignment)})`;
-	}
-	printMetaProperty(node) {
-		this.out += `${node.meta.name}.${node.property.name}`;
-	}
-	printV8Intrinsic(node) {
-		this.out += `%${node.name.name}(${this.nodeListText(node.arguments, PREC.Assignment)})`;
-	}
-	printImportExpression(node) {
-		this.out += `import${flagText(node.phase, `.${node.phase}`)}(`;
-		this.out += this.assignmentNodeText(node.source);
-		this.out += flagText(node.options, `, ${this.assignmentNodeText(node.options)}`);
-		this.out += ")";
-	}
-	printUpdateExpression(node, _prec) {
-		const operand = this.wrappedExpressionText(node.argument, PREC.Update, MEMBER_OBJECT_WRAPPED_KINDS);
-		switch (node.prefix) {
-			case true:
-				this.out += `${node.operator}${operand}`;
-				break;
-			default: this.out += `${operand}${node.operator}`;
-		}
-	}
-	printUnaryExpression(node, _prec) {
-		this.out += node.operator;
-		this.out += flagText(UNARY_WORD_OPERATORS[node.operator] === true, " ");
-		this.out += this.wrappedExpressionText(node.argument, PREC.Unary, UNARY_OPERAND_WRAPPED_KINDS);
-	}
-	printBinaryExpression(node, prec) {
-		const myPrec = binaryPrec(node.operator);
-		const leftStr = this.wrapIfNeeded(node.left, precOf(node.left), myPrec, false, node.operator);
-		const rightStr = this.wrapIfNeeded(node.right, precOf(node.right), myPrec, true, node.operator);
-		const whole = `${leftStr} ${node.operator} ${rightStr}`;
-		if (myPrec < prec) this.out += `(${whole})`;
-		else this.out += whole;
-	}
-	printLogicalExpression(node, prec) {
-		const myPrec = logicalPrec(node.operator);
-		const leftStr = this.wrapIfNeeded(node.left, precOf(node.left), myPrec, false, node.operator);
-		const rightStr = this.wrapIfNeeded(node.right, precOf(node.right), myPrec, true, node.operator);
-		const whole = `${leftStr} ${node.operator} ${rightStr}`;
-		if (myPrec < prec) this.out += `(${whole})`;
-		else this.out += whole;
-	}
-	printConditionalExpression(node, prec) {
-		const myPrec = PREC.Conditional;
-		const whole = `${this.wrapIfNeeded(node.test, precOf(node.test), myPrec, false)} ? ${this.printExpressionToString(node.consequent, PREC.Assignment)} : ${this.printExpressionToString(node.alternate, PREC.Assignment)}`;
-		if (myPrec < prec) this.out += `(${whole})`;
-		else this.out += whole;
-	}
-	printAssignmentExpression(node, prec) {
-		const myPrec = PREC.Assignment;
-		const leftStr = this.printExpressionToString(node.left, myPrec);
-		const rightStr = this.printExpressionToString(node.right, myPrec - .1);
-		const whole = `${leftStr} ${node.operator} ${rightStr}`;
-		if (myPrec < prec) this.out += `(${whole})`;
-		else this.out += whole;
-	}
-	printAssignmentPattern(node, prec) {
-		const left = node.left;
-		const leftText = this.printExpressionToString(node.left, PREC.Assignment) + this.typeAnnotationText(left.typeAnnotation);
-		const rightText = this.printExpressionToString(node.right, PREC.Assignment);
-		this.out += parenthesizedIf(PREC.Assignment < prec, `${leftText} = ${rightText}`);
-	}
-	printObjectPattern(node) {
-		switch (node.properties.length) {
-			case 0:
-				this.out += "{}";
-				break;
-			default: this.out += `{ ${this.nodeListText(node.properties, PREC.Sequence)} }`;
-		}
-	}
-	printArrayPattern(node) {
-		this.out += `[${node.elements.map((element) => this.arrayElementText(element)).join(", ")}]`;
-	}
-	printSequenceExpression(node, prec) {
-		const whole = node.expressions.map((expression) => this.printExpressionToString(expression, PREC.Sequence)).join(", ");
-		this.out += parenthesizedIf(PREC.Sequence < prec, whole);
-	}
-	printYieldExpression(node, _prec) {
-		switch (Boolean(node.delegate)) {
-			case true:
-				this.out += "yield*";
-				break;
-			default: this.out += "yield";
-		}
-		this.out += flagText(node.argument, ` ${this.assignmentNodeText(node.argument)}`);
-	}
-	printArrowFunction(node, prec) {
-		const arrow = `${flagText(node.async, "async ")}${this.typeParametersText(node.typeParameters)}${this.arrowParamsText(node)}${this.typeAnnotationText(node.returnType)} => ${this.arrowBodyText(node)}`;
-		this.out += parenthesizedIf(PREC.Assignment < prec, arrow);
-	}
-	arrowParamsText(node) {
-		const bareParam = bareArrowParamName(node);
-		switch (bareParam.length) {
-			case 0: return `(${this.paramsText(node.params)})`;
-			default: return bareParam;
-		}
-	}
-	arrowBodyText(node) {
-		switch (arrowBodyIsBlock(node.body)) {
-			case true: return this.capture(() => this.printBlockStatement(node.body));
-			default: return this.assignmentNodeText(node.body);
-		}
-	}
-	printFunction(node, _prec) {
-		this.out += functionHeaderText(node);
-		this.printFunctionTail(node);
-	}
-	printClass(node, _prec) {
-		this.out += this.capture(() => this.printDecorators(node.decorators));
-		this.out += `${flagText(node.declare, "declare ")}${flagText(node.abstract, "abstract ")}class${namedDeclarationText(node)}`;
-		this.out += this.typeParametersText(node.typeParameters);
-		this.out += this.classHeritageText(node);
-		this.out += this.classImplementsText(node);
-		this.out += " ";
-		this.printClassBody(node.body);
-	}
-	classHeritageText(node) {
-		switch (Boolean(node.superClass)) {
-			case true: return ` extends ${this.assignmentNodeText(node.superClass)}${this.typeArgumentsText(node.superTypeArguments)}`;
-			default: return "";
-		}
-	}
-	classImplementsText(node) {
-		const rendered = (node.implements ?? []).map((heritage) => this.heritageText(heritage)).join(", ");
-		return flagText(rendered, ` implements ${rendered}`);
-	}
-	heritageText(heritage) {
-		return `${this.assignmentNodeText(heritage.expression)}${this.typeArgumentsText(heritage.typeArguments)}`;
-	}
-	printDecorators(decorators) {
-		const rendered = (decorators ?? []).map((decorator) => this.decoratorText(decorator)).join(" ");
-		this.out += flagText(rendered, `${rendered} `);
-	}
-	decoratorText(decorator) {
-		return `@${this.capture(() => this.printNode(decorator.expression, PREC.Member))}`;
-	}
-	printJSXElement(node) {
-		this.printJSXOpeningElement(node.openingElement);
-		node.children.forEach((child) => this.printJSXChild(child));
-		this.printJSXClosingElement(node);
-	}
-	printJSXClosingElement(node) {
-		if (!node.closingElement) return;
-		this.out += `</${this.jsxElementNameText(node.closingElement.name)}>`;
-	}
-	printJSXFragment(node) {
-		this.out += "<>";
-		for (const child of node.children) this.printJSXChild(child);
-		this.out += "</>";
-	}
-	printJSXOpeningElement(node) {
-		this.out += `<${this.jsxElementNameText(node.name)}`;
-		this.out += this.typeArgumentsText(node.typeArguments);
-		this.out += node.attributes.map((attribute) => ` ${this.sequenceNodeText(attribute)}`).join("");
-		switch (node.selfClosing) {
-			case true:
-				this.out += " />";
-				break;
-			default: this.out += ">";
-		}
-	}
-	jsxElementNameText(name) {
-		switch (name.type) {
-			case "JSXIdentifier": return name.name;
-			case "JSXNamespacedName": return `${name.namespace.name}:${name.name.name}`;
-			default: return this.capture(() => this.printJSXMemberExpression(name));
-		}
-	}
-	printJSXMemberExpression(node) {
-		const obj = node.object;
-		if (obj.type === "JSXIdentifier") this.out += `${obj.name}.${node.property.name}`;
-		else {
-			this.printJSXMemberExpression(obj);
-			this.out += `.${node.property.name}`;
-		}
-	}
-	printJSXAttribute(node) {
-		this.out += jsxAttributeNameText(node.name);
-		this.out += this.jsxAttributeValueClauseText(node.value);
-	}
-	jsxAttributeValueClauseText(value) {
-		switch (nodeKind(value)) {
-			case ABSENT_NODE_KIND: return "";
-			default: return `=${this.jsxAttributeValueText(value)}`;
-		}
-	}
-	jsxAttributeValueText(value) {
-		switch (value.type) {
-			case "Literal": return this.capture(() => this.printLiteral(value));
-			case "JSXExpressionContainer": {
-				const container = value;
-				return `{${this.sequenceNodeText(container.expression)}}`;
-			}
-			default: return this.sequenceNodeText(value);
-		}
-	}
-	printJSXChild(child) {
-		switch (child.type) {
-			case "JSXText":
-				this.out += child.value;
-				break;
-			case "JSXElement":
-				this.printJSXElement(child);
-				break;
-			case "JSXFragment":
-				this.printJSXFragment(child);
-				break;
-			case "JSXExpressionContainer":
-				this.out += "{";
-				this.printNode(child.expression, PREC.Sequence);
-				this.out += "}";
-				break;
-			case "JSXSpreadChild":
-				this.out += "{...";
-				this.printNode(child.expression, PREC.Assignment);
-				this.out += "}";
-				break;
-			default: this.printNode(child, PREC.Sequence);
-		}
-	}
-	printTSAsExpression(node, prec) {
-		const myPrec = PREC.Relational;
-		const whole = `${this.printExpressionToString(node.expression, myPrec)} as ${this.printTSTypeToString(node.typeAnnotation)}`;
-		if (myPrec < prec) this.out += `(${whole})`;
-		else this.out += whole;
-	}
-	printTSSatisfiesExpression(node, prec) {
-		const myPrec = PREC.Relational;
-		const whole = `${this.printExpressionToString(node.expression, myPrec)} satisfies ${this.printTSTypeToString(node.typeAnnotation)}`;
-		if (myPrec < prec) this.out += `(${whole})`;
-		else this.out += whole;
-	}
-	printTSTypeAssertion(node, _prec) {
-		this.out += `<${this.printTSTypeToString(node.typeAnnotation)}>`;
-		this.printNode(node.expression, PREC.Unary);
-	}
-	printTSInstantiationExpression(node, _prec) {
-		this.printNode(node.expression, PREC.Member);
-		this.printTSTypeParameterInstantiation(node.typeArguments);
-	}
-	printStatement(node) {
-		const n = node;
-		this.printAttachedComments(n, "leadingComments");
-		switch (n.type) {
-			case "BlockStatement":
-				this.printBlockStatement(n);
-				break;
-			case "VariableDeclaration":
-				this.printVariableDeclaration(n);
-				this.out += ";";
-				break;
-			case "FunctionDeclaration":
-			case "TSDeclareFunction":
-				this.printFunction(n, PREC.Sequence);
-				break;
-			case "ClassDeclaration":
-				this.printClass(n, PREC.Sequence);
-				break;
-			case "ExpressionStatement":
-				this.printExpressionStatement(n);
-				break;
-			case "IfStatement":
-				this.printIfStatement(n);
-				break;
-			case "ForStatement":
-				this.printForStatement(n);
-				break;
-			case "ForInStatement":
-				this.printForInStatement(n);
-				break;
-			case "ForOfStatement":
-				this.printForOfStatement(n);
-				break;
-			case "WhileStatement":
-				this.printWhileStatement(n);
-				break;
-			case "DoWhileStatement":
-				this.printDoWhileStatement(n);
-				break;
-			case "ReturnStatement":
-				this.printReturnStatement(n);
-				break;
-			case "ThrowStatement":
-				this.out += "throw ";
-				this.printNode(n.argument, PREC.Sequence);
-				this.out += ";";
-				break;
-			case "TryStatement":
-				this.printTryStatement(n);
-				break;
-			case "SwitchStatement":
-				this.printSwitchStatement(n);
-				break;
-			case "LabeledStatement":
-				this.printLabeledStatement(n);
-				break;
-			case "BreakStatement":
-			case "ContinueStatement":
-			case "DebuggerStatement":
-			case "EmptyStatement":
-				this.printNode(n, PREC.Sequence);
-				break;
-			case "WithStatement":
-				this.printWithStatement(n);
-				break;
-			case "ImportDeclaration":
-				this.printImportDeclaration(n);
-				break;
-			case "ExportNamedDeclaration":
-				this.printExportNamedDeclaration(n);
-				break;
-			case "ExportDefaultDeclaration":
-				this.printExportDefaultDeclaration(n);
-				break;
-			case "ExportAllDeclaration":
-				this.printExportAllDeclaration(n);
-				break;
-			case "TSTypeAliasDeclaration":
-				this.printTSTypeAliasDeclaration(n);
-				break;
-			case "TSInterfaceDeclaration":
-				this.printTSInterfaceDeclaration(n);
-				break;
-			case "TSEnumDeclaration":
-				this.printTSEnumDeclaration(n);
-				break;
-			case "TSModuleDeclaration":
-				this.printTSModuleDeclaration(n);
-				break;
-			case "TSImportEqualsDeclaration":
-				this.printTSImportEqualsDeclaration(n);
-				break;
-			case "TSExportAssignment":
-			case "TSNamespaceExportDeclaration":
-				this.printNode(n, PREC.Sequence);
-				break;
-			default: this.printUnhandledStatement(n);
-		}
-		this.printAttachedComments(n, "trailingComments");
-	}
-	printUnhandledStatement(node) {
-		if (!isTSTypeNode(node.type)) throw new Error(`Printer: unhandled statement kind ${node.type}`);
-		this.printTSType(node);
-		this.out += ";";
-	}
-	/**
-	* Emits the comments `attachComments` folded into the tree
-	* (`leadingComments` before the statement, `trailingComments` on the
-	* statement's last line). The flat `opts.comments` path only serves direct
-	* `printProgram` calls on freshly parsed trees; instrumented trees carry
-	* their comments attached to nodes.
-	*/
-	printAttachedComments(node, field) {
-		const comments = node[field];
-		if (!Array.isArray(comments)) return;
-		comments.forEach((comment) => this.printAttachedComment(comment, field));
-	}
-	printAttachedComment(comment, field) {
-		switch (field) {
-			case "leadingComments":
-				this.out += `${this.indent()}${commentText(comment)}\n`;
-				break;
-			default: this.out += `${commentText(comment)} `;
-		}
-	}
-	printBlockStatement(node) {
-		switch (node.body.length) {
-			case 0:
-				this.out += "{}";
-				break;
-			default:
-				this.out += "{\n";
-				this.out += this.indentedBodyText(node.body, (statement) => this.printStatement(statement));
-				this.out += `${this.indent()}}`;
-		}
-	}
-	printExpressionStatement(node) {
-		if (this.isDirective(node.directive)) {
-			this.out += JSON.stringify(node.directive) + ";";
+		case "JSXElement":
+			printJSXElement(state, child);
 			return;
-		}
-		this.printNode(node.expression, PREC.Sequence);
-		this.out += ";";
-	}
-	isDirective(directive) {
-		return directive != null && directive !== "";
-	}
-	printIfStatement(node) {
-		this.out += "if (";
-		this.printNode(node.test, PREC.Sequence);
-		this.out += ") ";
-		this.printStatementOrBlock(node.consequent);
-		if (node.alternate) {
-			this.out += " else ";
-			this.printStatementOrBlock(node.alternate);
-		}
-	}
-	printStatementOrBlock(node) {
-		if (node.type === "BlockStatement") this.printBlockStatement(node);
-		else this.printStatement(node);
-	}
-	printWhileStatement(node) {
-		this.out += "while (";
-		this.printNode(node.test, PREC.Sequence);
-		this.out += ") ";
-		this.printStatementOrBlock(node.body);
-	}
-	printDoWhileStatement(node) {
-		this.out += "do ";
-		this.printStatementOrBlock(node.body);
-		this.out += " while (";
-		this.printNode(node.test, PREC.Sequence);
-		this.out += ");";
-	}
-	printForStatement(node) {
-		this.out += "for (";
-		this.printDeclarationOrExpression(node.init);
-		this.out += "; ";
-		this.out += this.optionalSequenceText(node.test);
-		this.out += "; ";
-		this.out += this.optionalSequenceText(node.update);
-		this.out += ") ";
-		this.printStatementOrBlock(node.body);
-	}
-	printDeclarationOrExpression(node) {
-		switch (nodeKind(node)) {
-			case "VariableDeclaration":
-				this.printVariableDeclaration(node);
-				break;
-			case ABSENT_NODE_KIND: break;
-			default: this.printNode(node, PREC.Sequence);
-		}
-	}
-	optionalSequenceText(node) {
-		switch (nodeKind(node)) {
-			case ABSENT_NODE_KIND: return "";
-			default: return this.sequenceNodeText(node);
-		}
-	}
-	printForInStatement(node) {
-		this.out += "for (";
-		if (node.left.type === "VariableDeclaration") this.printVariableDeclaration(node.left);
-		else this.printNode(node.left, PREC.Sequence);
-		this.out += " in ";
-		this.printNode(node.right, PREC.Sequence);
-		this.out += ") ";
-		this.printStatementOrBlock(node.body);
-	}
-	printForOfStatement(node) {
-		switch (node.await) {
-			case true:
-				this.out += "for await (";
-				break;
-			default: this.out += "for (";
-		}
-		this.printDeclarationOrExpression(node.left);
-		this.out += " of ";
-		this.out += this.sequenceNodeText(node.right);
-		this.out += ") ";
-		this.printStatementOrBlock(node.body);
-	}
-	printReturnStatement(node) {
-		if (node.argument) {
-			this.out += "return ";
-			this.printNode(node.argument, PREC.Sequence);
-			this.out += ";";
-		} else this.out += "return;";
-	}
-	printWithStatement(node) {
-		this.out += "with (";
-		this.printNode(node.object, PREC.Sequence);
-		this.out += ") ";
-		this.printStatementOrBlock(node.body);
-	}
-	printSwitchStatement(node) {
-		this.out += `switch (${this.sequenceNodeText(node.discriminant)}) {\n`;
-		this.indentLevel++;
-		this.out += node.cases.map((switchCase) => `${this.indent()}${this.capture(() => this.printSwitchCase(switchCase))}`).join("");
-		this.indentLevel--;
-		this.out += `${this.indent()}}`;
-	}
-	printSwitchCase(node) {
-		this.out += this.switchCaseHeaderText(node);
-		this.out += this.indentedBodyText(node.consequent, (statement) => this.printStatement(statement));
-	}
-	switchCaseHeaderText(node) {
-		switch (Boolean(node.test)) {
-			case true: return `case ${this.sequenceNodeText(node.test)}:\n`;
-			default: return "default:\n";
-		}
-	}
-	printLabeledStatement(node) {
-		this.out += `${node.label.name}: `;
-		this.printStatement(node.body);
-	}
-	printTryStatement(node) {
-		this.out += "try ";
-		this.printBlockStatement(node.block);
-		this.printCatchClause(node.handler);
-		this.printFinallyClause(node.finalizer);
-	}
-	printCatchClause(handler) {
-		if (!handler) return;
-		this.out += ` catch${this.catchParamText(handler.param)} `;
-		this.printBlockStatement(handler.body);
-	}
-	catchParamText(param) {
-		switch (nodeKind(param)) {
-			case ABSENT_NODE_KIND: return "";
-			default: return ` (${this.catchParamBodyText(param)})`;
-		}
-	}
-	catchParamBodyText(param) {
-		switch (param.type) {
-			case "Identifier": return this.identifierWithOptionalText(param);
-			default: return this.sequenceNodeText(param);
-		}
-	}
-	printFinallyClause(finalizer) {
-		if (!finalizer) return;
-		this.out += " finally ";
-		this.printBlockStatement(finalizer);
-	}
-	printVariableDeclaration(node) {
-		this.out += `${flagText(node.declare, "declare ")}${node.kind} `;
-		this.out += node.declarations.map((declaration) => this.variableDeclaratorText(declaration)).join(", ");
-	}
-	variableDeclaratorText(node) {
-		return this.capture(() => this.printVariableDeclarator(node));
-	}
-	printVariableDeclarator(node) {
-		const id = node.id;
-		const declarator = node;
-		this.out += this.bindingTargetText(id);
-		this.out += flagText(declarator.definite, "!");
-		this.out += this.typeAnnotationText(id.typeAnnotation);
-		this.out += this.initializerText(node.init);
-	}
-	bindingTargetText(id) {
-		switch (id.type) {
-			case "Identifier": return `${bindingNameText(id)}${flagText(id.optional, "?")}`;
-			default: return this.sequenceNodeText(id);
-		}
-	}
-	identifierWithOptionalText(node) {
-		return `${bindingNameText(node)}${flagText(node.optional, "?")}${this.typeAnnotationText(node.typeAnnotation)}`;
-	}
-	printParams(params) {
-		this.out += params.map((param) => this.paramText(param)).join(", ");
-	}
-	paramText(param) {
-		switch (parameterForm(param)) {
-			case "rest": return this.restParamText(param);
-			case "property": return this.parameterPropertyText(param);
-			default: return this.formalParameterText(param);
-		}
-	}
-	restParamText(param) {
-		return `...${this.assignmentNodeText(param["argument"])}${this.typeAnnotationText(param["typeAnnotation"])}`;
-	}
-	parameterPropertyText(param) {
-		return `${this.capture(() => this.printDecorators(param["decorators"]))}${parameterPropertyModifiers(param)}${this.parameterPropertyTargetText(param["parameter"])}`;
-	}
-	parameterPropertyTargetText(parameter) {
-		switch (nodeKind(parameter)) {
-			case "Identifier": return this.identifierWithOptionalText(parameter);
-			default: return this.sequenceNodeText(parameter);
-		}
-	}
-	formalParameterText(param) {
-		return `${this.capture(() => this.printDecorators(param["decorators"]))}${this.formalParameterBodyText(param)}`;
-	}
-	formalParameterBodyText(param) {
-		switch (param["type"] === "Identifier") {
-			case true: return this.identifierWithOptionalText(param);
-			default: return `${this.assignmentNodeText(param)}${this.typeAnnotationText(param["typeAnnotation"])}`;
-		}
-	}
-	printClassBody(node) {
-		switch (node.body.length) {
-			case 0:
-				this.out += "{}";
-				break;
-			default:
-				this.out += "{\n";
-				this.out += this.indentedBodyText(node.body, (element) => this.printNode(element, PREC.Sequence));
-				this.out += `${this.indent()}}`;
-		}
-	}
-	indentedBodyText(items, print) {
-		this.indentLevel++;
-		const body = items.map((item) => `${this.indent()}${this.capture(() => print(item))}\n`).join("");
-		this.indentLevel--;
-		return body;
-	}
-	printMethodDefinition(node) {
-		const fn = node.value;
-		this.out += this.capture(() => this.printDecorators(node.decorators));
-		this.out += methodDefinitionPrefix(node, fn);
-		this.out += this.propertyKeyText(node.key, node.computed === true, PREC.Sequence);
-		this.out += flagText(node.optional, "?");
-		this.printFunctionTail(fn);
-	}
-	printPropertyDefinition(node) {
-		this.out += this.capture(() => this.printDecorators(node.decorators));
-		this.out += propertyDefinitionModifiers(node);
-		this.out += this.propertyKeyText(node.key, node.computed === true, PREC.Sequence);
-		this.out += flagText(node.optional, "?");
-		this.out += flagText(node.definite, "!");
-		this.out += this.typeAnnotationText(node.typeAnnotation);
-		this.out += this.initializerText(node.value);
-		this.out += ";";
-	}
-	printAccessorProperty(node) {
-		this.out += this.capture(() => this.printDecorators(node.decorators));
-		this.out += flagText(node.accessibility, `${node.accessibility} `);
-		this.out += flagText(node.static, "static ");
-		this.out += flagText(node.override, "override ");
-		this.out += "accessor ";
-		this.out += this.propertyKeyText(node.key, node.computed === true, PREC.Sequence);
-		this.out += flagText(node.definite, "!");
-		this.out += this.typeAnnotationText(node.typeAnnotation);
-		this.out += this.initializerText(node.value);
-		this.out += ";";
-	}
-	initializerText(value) {
-		return flagText(value, ` = ${this.assignmentNodeText(value)}`);
-	}
-	printStaticBlock(node) {
-		this.out += "static {\n";
-		this.indentLevel++;
-		for (const stmt of node.body) {
-			this.out += this.indent();
-			this.printStatement(stmt);
-			this.out += "\n";
-		}
-		this.indentLevel--;
-		this.out += `${this.indent()}}`;
-	}
-	printImportDeclaration(node) {
-		const source = this.printImportSource(node.source, node.attributes);
-		this.out += `import ${importKindText(node)}${this.importClauseText(node, source)};`;
-	}
-	importClauseText(node, source) {
-		switch (node.specifiers.length === 0) {
-			case true: return source;
-			default: return `${importBindingsText(node.specifiers)} from ${source}`;
-		}
-	}
-	printImportSource(source, attrs) {
-		return `${source.raw ?? JSON.stringify(source.value)}${importAttributesText(attrs)}`;
-	}
-	printExportNamedDeclaration(node) {
-		switch (node.declaration === null) {
-			case false:
-				this.out += `export ${this.capture(() => this.printStatement(node.declaration))}`;
-				break;
-			default: this.out += `export ${flagText(node.exportKind === "type", "type ")}{ ${node.specifiers.map((specifier) => exportSpecifierText(specifier)).join(", ")} }${this.exportSourceClauseText(node)};`;
-		}
-	}
-	exportSourceClauseText(node) {
-		if (!node.source) return "";
-		return ` from ${JSON.stringify(node.source.value)}${importAttributesText(node.attributes)}`;
-	}
-	printExportDefaultDeclaration(node) {
-		const declaration = node.declaration;
-		this.out += "export default ";
-		switch (BARE_DEFAULT_EXPORT_KINDS[declaration.type] === true) {
-			case true:
-				this.printStatement(declaration);
-				break;
-			default:
-				this.printNode(declaration, PREC.Assignment);
-				this.out += ";";
-		}
-	}
-	printExportAllDeclaration(node) {
-		this.out += `export ${flagText(node.exportKind === "type", "type ")}*${exportedNameClauseText(node.exported)}`;
-		this.out += ` from ${JSON.stringify(node.source.value)}${importAttributesText(node.attributes)};`;
-	}
-	printTSTypeAliasDeclaration(node) {
-		this.out += `${flagText(node.declare, "declare ")}type ${node.id.name}${this.typeParametersText(node.typeParameters)} = ${this.printTSTypeToString(node.typeAnnotation)};`;
-	}
-	printTSInterfaceDeclaration(node) {
-		this.out += `${flagText(node.declare, "declare ")}interface ${node.id.name}${this.typeParametersText(node.typeParameters)}`;
-		this.out += this.interfaceExtendsText(node.extends);
-		this.out += " ";
-		this.printTSInterfaceBody(node.body);
-	}
-	interfaceExtendsText(extensions) {
-		const rendered = extensions.map((heritage) => this.heritageText(heritage)).join(", ");
-		return flagText(rendered, ` extends ${rendered}`);
-	}
-	printTSInterfaceBody(node) {
-		switch (node.body.length) {
-			case 0:
-				this.out += "{}";
-				break;
-			default:
-				this.out += "{\n";
-				this.out += this.indentedBodyText(node.body, (member) => this.printTSSignature(member));
-				this.out += `${this.indent()}}`;
-		}
-	}
-	printTSSignature(sig) {
-		switch (sig.type) {
-			case "TSPropertySignature":
-				this.printTSPropertySignature(sig);
-				break;
-			case "TSIndexSignature":
-				this.printTSIndexSignature(sig);
-				break;
-			case "TSCallSignatureDeclaration":
-				this.printTSCallSignature(sig);
-				break;
-			case "TSConstructSignatureDeclaration":
-				this.printTSConstructSignature(sig);
-				break;
-			case "TSMethodSignature":
-				this.printTSMethodSignature(sig);
-				break;
-			default: this.out += `/* sig:${sig.type} */;`;
-		}
-	}
-	printTSPropertySignature(node) {
-		this.out += `${flagText(node.readonly, "readonly ")}${this.propertyKeyText(node.key, node.computed === true, PREC.Sequence)}${flagText(node.optional, "?")}${this.typeAnnotationText(node.typeAnnotation)};`;
-	}
-	printTSIndexSignature(node) {
-		const parameters = node.parameters.map((parameter) => this.indexParameterText(parameter)).join(", ");
-		this.out += `${flagText(node.readonly, "readonly ")}${flagText(node.static, "static ")}[${parameters}]${this.typeAnnotationText(node.typeAnnotation)};`;
-	}
-	indexParameterText(parameter) {
-		const annotation = parameter.typeAnnotation;
-		return `${parameter.name}: ${this.printTSTypeToString(annotation.typeAnnotation)}`;
-	}
-	printTSCallSignature(node) {
-		this.out += `${this.typeParametersText(node.typeParameters)}(${this.paramsText(node.params)})${this.typeAnnotationText(node.returnType)};`;
-	}
-	printTSConstructSignature(node) {
-		this.out += `new ${this.typeParametersText(node.typeParameters)}(${this.paramsText(node.params)})${this.typeAnnotationText(node.returnType)};`;
-	}
-	printTSMethodSignature(node) {
-		this.out += `${methodKindText(node.kind)}${this.propertyKeyText(node.key, node.computed === true, PREC.Sequence)}${flagText(node.optional, "?")}${this.typeParametersText(node.typeParameters)}(${this.paramsText(node.params)})${this.typeAnnotationText(node.returnType)};`;
-	}
-	printTSEnumDeclaration(node) {
-		this.out += `${flagText(node.declare, "declare ")}${flagText(node.const, "const ")}enum ${node.id.name} {\n`;
-		this.out += this.indentedBodyText(node.body.members, (member) => this.printEnumMember(member));
-		this.out += `${this.indent()}}`;
-	}
-	printEnumMember(member) {
-		this.out += `${this.identifierOrLiteralNameText(member.id)}${this.initializerText(member.initializer)},`;
-	}
-	identifierOrLiteralNameText(id) {
-		switch (id.type) {
-			case "Identifier": return id.name;
-			case "Literal": return this.capture(() => this.printLiteral(id));
-			default: return this.sequenceNodeText(id);
-		}
-	}
-	printTSModuleDeclaration(node) {
-		this.out += `${flagText(node.declare, "declare ")}${this.moduleHeaderText(node)}${this.moduleBodyText(node)}`;
-	}
-	moduleHeaderText(node) {
-		switch (Boolean(node.global)) {
-			case true: return "global ";
-			default: return `${node.kind} ${this.identifierOrLiteralNameText(node.id)}`;
-		}
-	}
-	moduleBodyText(node) {
-		switch (Boolean(node.body)) {
-			case true: return ` ${this.capture(() => this.printTSModuleBlock(node.body))}`;
-			default: return ";";
-		}
-	}
-	printTSModuleBlock(node) {
-		this.out += "{\n";
-		this.out += this.indentedBodyText(node.body, (statement) => this.printStatement(statement));
-		this.out += `${this.indent()}}`;
-	}
-	printTSImportEqualsDeclaration(node) {
-		this.out += `import ${flagText(node.importKind === "type", "type ")}${node.id.name} = ${this.moduleReferenceText(node.moduleReference)};`;
-	}
-	moduleReferenceText(reference) {
-		switch (reference.type) {
-			case "TSExternalModuleReference": return `require(${externalModuleArgumentText(reference.expression.value)})`;
-			default: return this.sequenceNodeText(reference);
-		}
-	}
-	printTSType(node) {
-		this.out += this.printTSTypeToString(node);
-	}
-	printTSTypeToString(node) {
-		const saved = this.out;
-		this.out = "";
-		this.doPrintTSType(node);
-		const result = this.out;
-		this.out = saved;
-		return result;
-	}
-	doPrintTSType(node) {
-		switch (node.type) {
-			case "TSAnyKeyword":
-				this.out += "any";
-				break;
-			case "TSStringKeyword":
-				this.out += "string";
-				break;
-			case "TSBooleanKeyword":
-				this.out += "boolean";
-				break;
-			case "TSNumberKeyword":
-				this.out += "number";
-				break;
-			case "TSBigIntKeyword":
-				this.out += "bigint";
-				break;
-			case "TSSymbolKeyword":
-				this.out += "symbol";
-				break;
-			case "TSVoidKeyword":
-				this.out += "void";
-				break;
-			case "TSUndefinedKeyword":
-				this.out += "undefined";
-				break;
-			case "TSNullKeyword":
-				this.out += "null";
-				break;
-			case "TSNeverKeyword":
-				this.out += "never";
-				break;
-			case "TSUnknownKeyword":
-				this.out += "unknown";
-				break;
-			case "TSObjectKeyword":
-				this.out += "object";
-				break;
-			case "TSIntrinsicKeyword":
-				this.out += "intrinsic";
-				break;
-			case "TSThisType":
-				this.out += "this";
-				break;
-			case "TSTypeReference": {
-				const n = node;
-				this.printTSTypeName(n.typeName);
-				this.out += this.typeArgumentsText(n.typeArguments);
-				break;
-			}
-			case "TSUnionType": {
-				const n = node;
-				this.out += this.tSTypeListText(n.types, " | ");
-				break;
-			}
-			case "TSIntersectionType": {
-				const n = node;
-				this.out += this.tSTypeListText(n.types, " & ");
-				break;
-			}
-			case "TSArrayType": {
-				const n = node;
-				this.out += `${this.arrayElementTypeText(n.elementType)}[]`;
-				break;
-			}
-			case "TSTypeLiteral": {
-				const n = node;
-				this.printTSTypeLiteral(n.members);
-				break;
-			}
-			case "TSTupleType": {
-				const n = node;
-				this.printTupleType(n.elementTypes);
-				break;
-			}
-			case "TSConditionalType": {
-				const n = node;
-				this.doPrintTSType(n.checkType);
-				this.out += " extends ";
-				this.doPrintTSType(n.extendsType);
-				this.out += " ? ";
-				this.doPrintTSType(n.trueType);
-				this.out += " : ";
-				this.doPrintTSType(n.falseType);
-				break;
-			}
-			case "TSInferType": {
-				const n = node;
-				this.out += `infer ${n.typeParameter.name.name}`;
-				this.printTypeClause(" extends ", n.typeParameter.constraint);
-				break;
-			}
-			case "TSTypeQuery": {
-				const n = node;
-				this.out += "typeof ";
-				this.printTypeQueryName(n);
-				this.out += this.typeArgumentsText(n.typeArguments);
-				break;
-			}
-			case "TSImportType":
-				this.printTSImportType(node);
-				break;
-			case "TSTypeOperator": {
-				const n = node;
-				this.out += `${n.operator} `;
-				this.doPrintTSType(n.typeAnnotation);
-				break;
-			}
-			case "TSMappedType":
-				this.printMappedType(node);
-				break;
-			case "TSTemplateLiteralType":
-				this.printTSTemplateLiteral(node);
-				break;
-			case "TSFunctionType":
-				this.printTSFunctionType(node);
-				break;
-			case "TSConstructorType":
-				this.printTSConstructorType(node);
-				break;
-			case "TSTypePredicate":
-				this.printTSTypePredicate(node);
-				break;
-			case "TSIndexedAccessType": {
-				const n = node;
-				this.doPrintTSType(n.objectType);
-				this.out += "[";
-				this.doPrintTSType(n.indexType);
-				this.out += "]";
-				break;
-			}
-			case "TSLiteralType":
-				this.printTSLiteralType(node.literal);
-				break;
-			case "TSParenthesizedType": {
-				const n = node;
-				this.out += "(";
-				this.doPrintTSType(n.typeAnnotation);
-				this.out += ")";
-				break;
-			}
-			case "TSJSDocNullableType":
-				this.printJSDocPostfixModifier(node, "?");
-				break;
-			case "TSJSDocNonNullableType":
-				this.printJSDocPostfixModifier(node, "!");
-				break;
-			case "TSJSDocUnknownType":
-				this.out += "?";
-				break;
-			default: this.out += `/* type:${node.type} */`;
-		}
-	}
-	tSTypeListText(types, separator) {
-		return types.map((type) => this.printTSTypeToString(type)).join(separator);
-	}
-	arrayElementTypeText(type) {
-		const printed = this.printTSTypeToString(type);
-		switch (ARRAY_ELEMENT_WRAPPED_KINDS[type.type] === true) {
-			case true: return `(${printed})`;
-			default: return printed;
-		}
-	}
-	printTSTypeLiteral(members) {
-		const rendered = members.map((member) => this.signatureText(member)).join("; ");
-		switch (members.length) {
-			case 0:
-				this.out += "{}";
-				break;
-			default: this.out += `{ ${rendered} }`;
-		}
-	}
-	signatureText(member) {
-		const printed = this.capture(() => this.printTSSignature(member));
-		switch (printed.endsWith(";")) {
-			case true: return printed.slice(0, -1);
-			default: return printed;
-		}
-	}
-	printTupleType(elements) {
-		this.out += `[${elements.map((element) => this.capture(() => this.printTupleElement(element))).join(", ")}]`;
-	}
-	printTupleElement(element) {
-		const tupleElement = element;
-		switch (tupleElement.type) {
-			case "TSRestType":
-				this.out += "...";
-				this.doPrintTSType(tupleElement.typeAnnotation);
-				break;
-			case "TSOptionalType":
-				this.doPrintTSType(tupleElement.typeAnnotation);
-				this.out += "?";
-				break;
-			case "TSNamedTupleMember":
-				this.printNamedTupleMember(tupleElement);
-				break;
-			default: this.doPrintTSType(tupleElement);
-		}
-	}
-	printNamedTupleMember(member) {
-		this.out += `${member.label.name}${flagText(member.optional, "?")}: `;
-		this.printTupleElement(member.elementType);
-	}
-	printTypeClause(keyword, type) {
-		if (!type) return;
-		this.out += keyword;
-		this.doPrintTSType(type);
-	}
-	printTypeQueryName(node) {
-		switch (node.exprName.type) {
-			case "TSImportType":
-				this.doPrintTSType(node.exprName);
-				break;
-			default: this.printTSTypeName(node.exprName);
-		}
-	}
-	printTSImportType(node) {
-		this.printTSImportTypeSource(node);
-		if (node.qualifier) {
-			this.out += ".";
-			this.printTSImportTypeQualifier(node.qualifier);
-		}
-		this.out += this.typeArgumentsText(node.typeArguments);
-	}
-	printTSImportTypeSource(node) {
-		this.out += `import(${JSON.stringify(node.source.value)}`;
-		this.out += flagText(node.options, `, ${this.assignmentNodeText(node.options)}`);
-		this.out += ")";
-	}
-	printMappedType(node) {
-		this.out += "{ ";
-		this.printMappedTypeModifier(node.readonly, "readonly ");
-		this.out += `[${node.key.name} in `;
-		this.doPrintTSType(node.constraint);
-		this.printTypeClause(" as ", node.nameType);
-		this.out += "]";
-		this.printMappedTypeModifier(node.optional, "?");
-		this.printTypeClause(": ", node.typeAnnotation);
-		this.out += " }";
-	}
-	printMappedTypeModifier(modifier, rendered) {
-		switch (modifier) {
-			case true:
-				this.out += rendered;
-				break;
-			case "+":
-				this.out += `+${rendered}`;
-				break;
-			case "-": this.out += `-${rendered}`;
-		}
-	}
-	printTSTemplateLiteral(node) {
-		this.out += `\`${node.quasis.map((quasi, index) => this.templateTypeQuasiText(quasi, node.types[index])).join("")}\``;
-	}
-	templateTypeQuasiText(quasi, type) {
-		switch (quasi.tail) {
-			case true: return quasi.value.raw;
-			default: return `${quasi.value.raw}\${${this.printTSTypeToString(type)}}`;
-		}
-	}
-	printTSFunctionType(node) {
-		this.out += `${this.typeParametersText(node.typeParameters)}(${this.paramsText(node.params)}) => ${this.printTSTypeToString(node.returnType.typeAnnotation)}`;
-	}
-	printTSConstructorType(node) {
-		this.out += `${flagText(node.abstract, "abstract ")}new ${this.typeParametersText(node.typeParameters)}(${this.paramsText(node.params)}) => ${this.printTSTypeToString(node.returnType.typeAnnotation)}`;
-	}
-	printTSTypePredicate(node) {
-		this.out += flagText(node.asserts, "asserts ");
-		this.out += typePredicateParameterText(node.parameterName);
-		this.printPredicateAnnotation(node);
-	}
-	printPredicateAnnotation(node) {
-		if (!node.typeAnnotation) return;
-		this.printTypeClause(" is ", node.typeAnnotation.typeAnnotation);
-	}
-	printTSLiteralType(literal) {
-		switch (nodeKind(literal)) {
-			case "Literal":
-				this.printLiteral(literal);
-				break;
-			case "TemplateLiteral":
-				this.printTemplateLiteral(literal);
-				break;
-			case "UnaryExpression":
-				this.printTSLiteralUnary(literal);
-				break;
-			default: this.printNode(literal, PREC.Sequence);
-		}
-	}
-	printTSLiteralUnary(unary) {
-		this.out += unary.operator;
-		this.printLiteral(unary.argument);
-	}
-	printJSDocPostfixModifier(node, marker) {
-		switch (Boolean(node.postfix)) {
-			case true:
-				this.doPrintTSType(node.typeAnnotation);
-				this.out += marker;
-				break;
-			default:
-				this.out += marker;
-				this.doPrintTSType(node.typeAnnotation);
-		}
-	}
-	printTSTypeName(name) {
-		switch (nodeKind(name)) {
-			case "TSQualifiedName": {
-				const qualified = name;
-				this.printTSTypeName(qualified.left);
-				this.out += `.${qualified.right.name}`;
-				break;
-			}
-			default: this.out += this.tSTypeNameLeafText(name);
-		}
-	}
-	tSTypeNameLeafText(name) {
-		switch (nodeKind(name)) {
-			case "Identifier": return name.name;
-			case "ThisExpression": return "this";
-			default: return this.sequenceNodeText(name);
-		}
+		case "JSXFragment":
+			printJSXFragment(state, child);
+			return;
+		case "JSXExpressionContainer":
+			state.out += "{";
+			printNodePrec(state, child.expression, PREC.Sequence);
+			state.out += "}";
+			return;
+		case "JSXSpreadChild":
+			state.out += "{...";
+			printNodePrec(state, child.expression, PREC.Assignment);
+			state.out += "}";
+	}
+}
+function printTSAsExpression(state, node, prec) {
+	const myPrec = PREC.Relational;
+	const whole = `${printExpressionToString(state, node.expression, myPrec)} as ${printTSTypeToString(state, node.typeAnnotation)}`;
+	if (myPrec < prec) state.out += `(${whole})`;
+	else state.out += whole;
+}
+function printTSSatisfiesExpression(state, node, prec) {
+	const myPrec = PREC.Relational;
+	const whole = `${printExpressionToString(state, node.expression, myPrec)} satisfies ${printTSTypeToString(state, node.typeAnnotation)}`;
+	if (myPrec < prec) state.out += `(${whole})`;
+	else state.out += whole;
+}
+function printTSTypeAssertion(state, node, _prec) {
+	state.out += `<${printTSTypeToString(state, node.typeAnnotation)}>`;
+	printNodePrec(state, node.expression, PREC.Unary);
+}
+function printTSInstantiationExpression(state, node, _prec) {
+	printNodePrec(state, node.expression, PREC.Member);
+	printTSTypeParameterInstantiation(state, node.typeArguments);
+}
+function printStatement(state, node) {
+	printAttachedComments(state, node, "leadingComments");
+	printStatementKind(state, node);
+	printAttachedComments(state, node, "trailingComments");
+}
+function printStatementKind(state, node) {
+	switch (node.type) {
+		case "BlockStatement":
+			printBlockStatement(state, node);
+			break;
+		case "VariableDeclaration":
+			printVariableDeclaration(state, node);
+			state.out += ";";
+			break;
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "TSDeclareFunction":
+		case "TSEmptyBodyFunctionExpression":
+			printFunction(state, node, PREC.Sequence);
+			break;
+		case "ClassDeclaration":
+		case "ClassExpression":
+			printClass(state, node, PREC.Sequence);
+			break;
+		case "ExpressionStatement":
+			printExpressionStatement(state, node);
+			break;
+		case "IfStatement":
+			printIfStatement(state, node);
+			break;
+		case "ForStatement":
+			printForStatement(state, node);
+			break;
+		case "ForInStatement":
+			printForInStatement(state, node);
+			break;
+		case "ForOfStatement":
+			printForOfStatement(state, node);
+			break;
+		case "WhileStatement":
+			printWhileStatement(state, node);
+			break;
+		case "DoWhileStatement":
+			printDoWhileStatement(state, node);
+			break;
+		case "ReturnStatement":
+			printReturnStatement(state, node);
+			break;
+		case "ThrowStatement":
+			state.out += "throw ";
+			printNodePrec(state, node.argument, PREC.Sequence);
+			state.out += ";";
+			break;
+		case "TryStatement":
+			printTryStatement(state, node);
+			break;
+		case "SwitchStatement":
+			printSwitchStatement(state, node);
+			break;
+		case "LabeledStatement":
+			printLabeledStatement(state, node);
+			break;
+		case "BreakStatement":
+		case "ContinueStatement":
+		case "DebuggerStatement":
+		case "EmptyStatement":
+			printNodePrec(state, node, PREC.Sequence);
+			break;
+		case "WithStatement":
+			printWithStatement(state, node);
+			break;
+		case "ImportDeclaration":
+			printImportDeclaration(state, node);
+			break;
+		case "ExportNamedDeclaration":
+			printExportNamedDeclaration(state, node);
+			break;
+		case "ExportDefaultDeclaration":
+			printExportDefaultDeclaration(state, node);
+			break;
+		case "ExportAllDeclaration":
+			printExportAllDeclaration(state, node);
+			break;
+		case "TSTypeAliasDeclaration":
+			printTSTypeAliasDeclaration(state, node);
+			break;
+		case "TSInterfaceDeclaration":
+			printTSInterfaceDeclaration(state, node);
+			break;
+		case "TSEnumDeclaration":
+			printTSEnumDeclaration(state, node);
+			break;
+		case "TSModuleDeclaration":
+			printTSModuleDeclaration(state, node);
+			break;
+		case "TSImportEqualsDeclaration":
+			printTSImportEqualsDeclaration(state, node);
+			break;
+		case "TSExportAssignment":
+		case "TSNamespaceExportDeclaration": printNodePrec(state, node, PREC.Sequence);
+	}
+}
+function printAttachedComments(state, node, field) {
+	const comments = node[field];
+	if (comments === void 0) return;
+	comments.forEach((comment) => printAttachedComment(state, comment, field));
+}
+function printAttachedComment(state, comment, field) {
+	if (field === "leadingComments") {
+		state.out += `${indent(state)}${commentText(comment)}\n`;
+		return;
+	}
+	state.out += `${commentText(comment)} `;
+}
+function printBlockStatement(state, node) {
+	switch (node.body.length) {
+		case 0:
+			state.out += "{}";
+			break;
+		default:
+			state.out += "{\n";
+			state.out += indentedBodyText(state, node.body, (statement) => printStatement(state, statement));
+			state.out += `${indent(state)}}`;
+	}
+}
+function printExpressionStatement(state, node) {
+	if (isDirective(node.directive)) {
+		state.out += JSON.stringify(node.directive) + ";";
+		return;
+	}
+	printNodePrec(state, node.expression, PREC.Sequence);
+	state.out += ";";
+}
+function isDirective(directive) {
+	return directive != null && directive !== "";
+}
+function printIfStatement(state, node) {
+	state.out += "if (";
+	printNodePrec(state, node.test, PREC.Sequence);
+	state.out += ") ";
+	printStatementOrBlock(state, node.consequent);
+	if (node.alternate !== null) {
+		state.out += " else ";
+		printStatementOrBlock(state, node.alternate);
+	}
+}
+function printStatementOrBlock(state, node) {
+	if (node.type === "BlockStatement") {
+		printBlockStatement(state, node);
+		return;
+	}
+	printStatement(state, node);
+}
+function printWhileStatement(state, node) {
+	state.out += "while (";
+	printNodePrec(state, node.test, PREC.Sequence);
+	state.out += ") ";
+	printStatementOrBlock(state, node.body);
+}
+function printDoWhileStatement(state, node) {
+	state.out += "do ";
+	printStatementOrBlock(state, node.body);
+	state.out += " while (";
+	printNodePrec(state, node.test, PREC.Sequence);
+	state.out += ");";
+}
+function printForStatement(state, node) {
+	state.out += "for (";
+	printDeclarationOrExpression(state, node.init);
+	state.out += "; ";
+	state.out += optionalSequenceText(state, node.test);
+	state.out += "; ";
+	state.out += optionalSequenceText(state, node.update);
+	state.out += ") ";
+	printStatementOrBlock(state, node.body);
+}
+function printDeclarationOrExpression(state, node) {
+	if (node == null) return;
+	printDeclarationOrExpressionNode(state, node);
+}
+function printDeclarationOrExpressionNode(state, node) {
+	if (node.type === "VariableDeclaration") {
+		printVariableDeclaration(state, node);
+		return;
+	}
+	printNodePrec(state, node, PREC.Sequence);
+}
+function optionalSequenceText(state, node) {
+	if (node == null) return "";
+	return sequenceNodeText(state, node);
+}
+function printForInStatement(state, node) {
+	state.out += "for (";
+	if (node.left.type === "VariableDeclaration") printVariableDeclaration(state, node.left);
+	else printNodePrec(state, node.left, PREC.Sequence);
+	state.out += " in ";
+	printNodePrec(state, node.right, PREC.Sequence);
+	state.out += ") ";
+	printStatementOrBlock(state, node.body);
+}
+function printForOfStatement(state, node) {
+	if (node.await) state.out += "for await (";
+	else state.out += "for (";
+	printDeclarationOrExpression(state, node.left);
+	state.out += " of ";
+	state.out += sequenceNodeText(state, node.right);
+	state.out += ") ";
+	printStatementOrBlock(state, node.body);
+}
+function printReturnStatement(state, node) {
+	if (node.argument !== null) {
+		state.out += "return ";
+		printNodePrec(state, node.argument, PREC.Sequence);
+		state.out += ";";
+		return;
+	}
+	state.out += "return;";
+}
+function printWithStatement(state, node) {
+	state.out += "with (";
+	printNodePrec(state, node.object, PREC.Sequence);
+	state.out += ") ";
+	printStatementOrBlock(state, node.body);
+}
+function printSwitchStatement(state, node) {
+	state.out += `switch (${sequenceNodeText(state, node.discriminant)}) {\n`;
+	state.indentLevel++;
+	state.out += node.cases.map((switchCase) => `${indent(state)}${capture(state, () => printSwitchCase(state, switchCase))}`).join("");
+	state.indentLevel--;
+	state.out += `${indent(state)}}`;
+}
+function printSwitchCase(state, node) {
+	state.out += switchCaseHeaderText(state, node);
+	state.out += indentedBodyText(state, node.consequent, (statement) => printStatement(state, statement));
+}
+function switchCaseHeaderText(state, node) {
+	if (node.test !== null) return `case ${sequenceNodeText(state, node.test)}:\n`;
+	return "default:\n";
+}
+function printLabeledStatement(state, node) {
+	state.out += `${node.label.name}: `;
+	printStatement(state, node.body);
+}
+function printTryStatement(state, node) {
+	state.out += "try ";
+	printBlockStatement(state, node.block);
+	printCatchClause(state, node.handler);
+	printFinallyClause(state, node.finalizer);
+}
+function printCatchClause(state, handler) {
+	if (handler == null) return;
+	state.out += ` catch${catchParamText(state, handler.param)} `;
+	printBlockStatement(state, handler.body);
+}
+function catchParamText(state, param) {
+	if (param == null) return "";
+	return ` (${catchParamBodyText(state, param)})`;
+}
+function catchParamBodyText(state, param) {
+	if (param.type === "Identifier") return identifierWithOptionalText(state, param);
+	return sequenceNodeText(state, param);
+}
+function printFinallyClause(state, finalizer) {
+	if (finalizer == null) return;
+	state.out += " finally ";
+	printBlockStatement(state, finalizer);
+}
+function printVariableDeclaration(state, node) {
+	state.out += `${flagText(node.declare, "declare ")}${node.kind} `;
+	state.out += node.declarations.map((declaration) => variableDeclaratorText(state, declaration)).join(", ");
+}
+function variableDeclaratorText(state, node) {
+	return capture(state, () => printVariableDeclarator(state, node));
+}
+function printVariableDeclarator(state, node) {
+	state.out += bindingTargetText(state, node.id);
+	state.out += flagText(node.definite, "!");
+	state.out += typeAnnotationText(state, bindingTypeAnnotation(node.id));
+	state.out += initializerText(state, node.init);
+}
+function bindingTargetText(state, id) {
+	if (id.type === "Identifier") return `${bindingNameText(id)}${flagText(id.optional, "?")}`;
+	return sequenceNodeText(state, id);
+}
+function identifierWithOptionalText(state, node) {
+	return `${bindingNameText(node)}${flagText(node.optional, "?")}${typeAnnotationText(state, node.typeAnnotation)}`;
+}
+function printParams(state, params) {
+	state.out += params.map((param) => paramText(state, param)).join(", ");
+}
+function paramText(state, param) {
+	switch (param.type) {
+		case "RestElement": return restParamText(state, param);
+		case "TSParameterProperty": return parameterPropertyText(state, param);
+		case "Identifier":
+		case "ObjectPattern":
+		case "ArrayPattern":
+		case "AssignmentPattern": return formalParameterText(state, param);
+	}
+}
+function restParamText(state, param) {
+	return `...${assignmentNodeText(state, param.argument)}${typeAnnotationText(state, param.typeAnnotation)}`;
+}
+function parameterPropertyText(state, param) {
+	return `${capture(state, () => printDecorators(state, param.decorators))}${parameterPropertyModifiers(param)}${parameterPropertyTargetText(state, param.parameter)}`;
+}
+function parameterPropertyTargetText(state, parameter) {
+	if (parameter.type === "Identifier") return identifierWithOptionalText(state, parameter);
+	return sequenceNodeText(state, parameter);
+}
+function formalParameterText(state, param) {
+	return `${capture(state, () => printDecorators(state, param.decorators))}${formalParameterBodyText(state, param)}`;
+}
+function formalParameterBodyText(state, param) {
+	if (param.type === "Identifier") return identifierWithOptionalText(state, param);
+	return `${assignmentNodeText(state, param)}${typeAnnotationText(state, bindingTypeAnnotation(param))}`;
+}
+function printClassBody(state, node) {
+	switch (node.body.length) {
+		case 0:
+			state.out += "{}";
+			break;
+		default:
+			state.out += "{\n";
+			state.out += indentedBodyText(state, node.body, (element) => printNodePrec(state, element, PREC.Sequence));
+			state.out += `${indent(state)}}`;
+	}
+}
+function indentedBodyText(state, items, print) {
+	state.indentLevel++;
+	const body = items.map((item) => `${indent(state)}${capture(state, () => print(item))}\n`).join("");
+	state.indentLevel--;
+	return body;
+}
+function printMethodDefinition(state, node) {
+	const fn = node.value;
+	state.out += capture(state, () => printDecorators(state, node.decorators));
+	state.out += methodDefinitionPrefix(node, fn);
+	state.out += propertyKeyText(state, node.key, node.computed === true, PREC.Sequence);
+	state.out += flagText(node.optional, "?");
+	printFunctionTail(state, fn);
+}
+function printPropertyDefinition(state, node) {
+	state.out += capture(state, () => printDecorators(state, node.decorators));
+	state.out += propertyDefinitionModifiers(node);
+	state.out += propertyKeyText(state, node.key, node.computed === true, PREC.Sequence);
+	state.out += flagText(node.optional, "?");
+	state.out += flagText(node.definite, "!");
+	state.out += typeAnnotationText(state, node.typeAnnotation);
+	state.out += initializerText(state, node.value);
+	state.out += ";";
+}
+function printAccessorProperty(state, node) {
+	state.out += capture(state, () => printDecorators(state, node.decorators));
+	state.out += flagText(node.accessibility, `${node.accessibility} `);
+	state.out += flagText(node.static, "static ");
+	state.out += flagText(node.override, "override ");
+	state.out += "accessor ";
+	state.out += propertyKeyText(state, node.key, node.computed === true, PREC.Sequence);
+	state.out += flagText(node.definite, "!");
+	state.out += typeAnnotationText(state, node.typeAnnotation);
+	state.out += initializerText(state, node.value);
+	state.out += ";";
+}
+function initializerText(state, value) {
+	return flagText(value, ` = ${assignmentNodeText(state, value)}`);
+}
+function printStaticBlock(state, node) {
+	state.out += "static {\n";
+	state.indentLevel++;
+	for (const stmt of node.body) {
+		state.out += indent(state);
+		printStatement(state, stmt);
+		state.out += "\n";
+	}
+	state.indentLevel--;
+	state.out += `${indent(state)}}`;
+}
+function printImportDeclaration(state, node) {
+	const source = printImportSource(node.source, node.attributes);
+	state.out += `import ${importKindText(node)}${importClauseText(node, source)};`;
+}
+function importClauseText(node, source) {
+	if (node.specifiers.length === 0) return source;
+	return `${importBindingsText(node.specifiers)} from ${source}`;
+}
+function printImportSource(source, attrs) {
+	return `${source.raw ?? JSON.stringify(source.value)}${importAttributesText(attrs)}`;
+}
+function printExportNamedDeclaration(state, node) {
+	const declaration = node.declaration;
+	if (declaration !== null) {
+		state.out += `export ${capture(state, () => printStatement(state, declaration))}`;
+		return;
+	}
+	state.out += `export ${flagText(node.exportKind === "type", "type ")}{ ${node.specifiers.map((specifier) => exportSpecifierText(specifier)).join(", ")} }${exportSourceClauseText(node)};`;
+}
+function exportSourceClauseText(node) {
+	if (node.source === null) return "";
+	return ` from ${JSON.stringify(node.source.value)}${importAttributesText(node.attributes)}`;
+}
+function printExportDefaultDeclaration(state, node) {
+	state.out += "export default ";
+	printExportDefaultDeclarationBody(state, node.declaration);
+}
+function printExportDefaultDeclarationBody(state, declaration) {
+	if (isBareDefaultExport(declaration)) {
+		printStatement(state, declaration);
+		return;
+	}
+	printNodePrec(state, declaration, PREC.Assignment);
+	state.out += ";";
+}
+function printExportAllDeclaration(state, node) {
+	state.out += `export ${flagText(node.exportKind === "type", "type ")}*${exportedNameClauseText(node.exported)}`;
+	state.out += ` from ${JSON.stringify(node.source.value)}${importAttributesText(node.attributes)};`;
+}
+function printTSTypeAliasDeclaration(state, node) {
+	state.out += `${flagText(node.declare, "declare ")}type ${node.id.name}${typeParametersText(state, node.typeParameters)} = ${printTSTypeToString(state, node.typeAnnotation)};`;
+}
+function printTSInterfaceDeclaration(state, node) {
+	state.out += `${flagText(node.declare, "declare ")}interface ${node.id.name}${typeParametersText(state, node.typeParameters)}`;
+	state.out += interfaceExtendsText(state, node.extends);
+	state.out += " ";
+	printTSInterfaceBody(state, node.body);
+}
+function interfaceExtendsText(state, extensions) {
+	const rendered = extensions.map((heritage) => heritageText(state, heritage)).join(", ");
+	return flagText(rendered, ` extends ${rendered}`);
+}
+function printTSInterfaceBody(state, node) {
+	switch (node.body.length) {
+		case 0:
+			state.out += "{}";
+			break;
+		default:
+			state.out += "{\n";
+			state.out += indentedBodyText(state, node.body, (member) => printTSSignature(state, member));
+			state.out += `${indent(state)}}`;
+	}
+}
+function printTSSignature(state, sig) {
+	switch (sig.type) {
+		case "TSPropertySignature":
+			printTSPropertySignature(state, sig);
+			return;
+		case "TSIndexSignature":
+			printTSIndexSignature(state, sig);
+			return;
+		case "TSCallSignatureDeclaration":
+			printTSCallSignature(state, sig);
+			return;
+		case "TSConstructSignatureDeclaration":
+			printTSConstructSignature(state, sig);
+			return;
+		case "TSMethodSignature": printTSMethodSignature(state, sig);
 	}
-	printTSImportTypeQualifier(qualifier) {
-		switch (nodeKind(qualifier)) {
-			case ABSENT_NODE_KIND: break;
-			case "Identifier":
-				this.out += qualifier.name;
-				break;
-			default: {
-				const qualified = qualifier;
-				this.printTSImportTypeQualifier(qualified.left);
-				this.out += `.${qualified.right.name}`;
-			}
-		}
+}
+function printTSPropertySignature(state, node) {
+	state.out += `${flagText(node.readonly, "readonly ")}${propertyKeyText(state, node.key, node.computed === true, PREC.Sequence)}${flagText(node.optional, "?")}${typeAnnotationText(state, node.typeAnnotation)};`;
+}
+function printTSIndexSignature(state, node) {
+	const parameters = node.parameters.map((parameter) => indexParameterText(state, parameter)).join(", ");
+	state.out += `${flagText(node.readonly, "readonly ")}${flagText(node.static, "static ")}[${parameters}]${typeAnnotationText(state, node.typeAnnotation)};`;
+}
+function indexParameterText(state, parameter) {
+	return `${parameter.name}: ${printTSTypeToString(state, parameter.typeAnnotation.typeAnnotation)}`;
+}
+function printTSCallSignature(state, node) {
+	state.out += `${typeParametersText(state, node.typeParameters)}(${paramsText(state, node.params)})${typeAnnotationText(state, node.returnType)};`;
+}
+function printTSConstructSignature(state, node) {
+	state.out += `new ${typeParametersText(state, node.typeParameters)}(${paramsText(state, node.params)})${typeAnnotationText(state, node.returnType)};`;
+}
+function printTSMethodSignature(state, node) {
+	state.out += `${methodKindText(node.kind)}${propertyKeyText(state, node.key, node.computed === true, PREC.Sequence)}${flagText(node.optional, "?")}${typeParametersText(state, node.typeParameters)}(${paramsText(state, node.params)})${typeAnnotationText(state, node.returnType)};`;
+}
+function printTSEnumDeclaration(state, node) {
+	state.out += `${flagText(node.declare, "declare ")}${flagText(node.const, "const ")}enum ${node.id.name} {\n`;
+	state.out += indentedBodyText(state, node.body.members, (member) => printEnumMember(state, member));
+	state.out += `${indent(state)}}`;
+}
+function printEnumMember(state, member) {
+	state.out += `${identifierOrLiteralNameText(state, member.id)}${initializerText(state, member.initializer)},`;
+}
+function identifierOrLiteralNameText(state, id) {
+	switch (nodeKind(id)) {
+		case "Identifier": return identifierNameText(id);
+		case "Literal": return literalCapture(state, id);
+		default: return sequenceNodeText(state, id);
 	}
-	printTSTypeAnnotation(node) {
-		this.out += ": ";
-		this.doPrintTSType(node.typeAnnotation);
+}
+function printTSModuleDeclaration(state, node) {
+	state.out += `${flagText(node.declare, "declare ")}${moduleHeaderText(state, node)}${moduleBodyText(state, node)}`;
+}
+function moduleHeaderText(state, node) {
+	if (node.global) return "global ";
+	return `${node.kind} ${identifierOrLiteralNameText(state, node.id)}`;
+}
+function moduleBodyText(state, node) {
+	const body = node.body;
+	if (body !== null) return ` ${capture(state, () => printTSModuleBlock(state, body))}`;
+	return ";";
+}
+function printTSModuleBlock(state, node) {
+	state.out += "{\n";
+	state.out += indentedBodyText(state, node.body, (statement) => printStatement(state, statement));
+	state.out += `${indent(state)}}`;
+}
+function printTSImportEqualsDeclaration(state, node) {
+	state.out += `import ${flagText(node.importKind === "type", "type ")}${node.id.name} = ${moduleReferenceText(state, node.moduleReference)};`;
+}
+function moduleReferenceText(state, reference) {
+	if (reference.type === "TSExternalModuleReference") return `require(${externalModuleArgumentText(reference.expression.value)})`;
+	return sequenceNodeText(state, reference);
+}
+function printTSType(state, node) {
+	state.out += printTSTypeToString(state, node);
+}
+function printTSTypeToString(state, node) {
+	const saved = state.out;
+	state.out = "";
+	doPrintTSType(state, node);
+	const result = state.out;
+	state.out = saved;
+	return result;
+}
+function doPrintTSType(state, node) {
+	switch (node.type) {
+		case "TSAnyKeyword":
+			state.out += "any";
+			break;
+		case "TSStringKeyword":
+			state.out += "string";
+			break;
+		case "TSBooleanKeyword":
+			state.out += "boolean";
+			break;
+		case "TSNumberKeyword":
+			state.out += "number";
+			break;
+		case "TSBigIntKeyword":
+			state.out += "bigint";
+			break;
+		case "TSSymbolKeyword":
+			state.out += "symbol";
+			break;
+		case "TSVoidKeyword":
+			state.out += "void";
+			break;
+		case "TSUndefinedKeyword":
+			state.out += "undefined";
+			break;
+		case "TSNullKeyword":
+			state.out += "null";
+			break;
+		case "TSNeverKeyword":
+			state.out += "never";
+			break;
+		case "TSUnknownKeyword":
+			state.out += "unknown";
+			break;
+		case "TSObjectKeyword":
+			state.out += "object";
+			break;
+		case "TSIntrinsicKeyword":
+			state.out += "intrinsic";
+			break;
+		case "TSThisType":
+			state.out += "this";
+			break;
+		case "TSTypeReference":
+			printTSTypeName(state, node.typeName);
+			state.out += typeArgumentsText(state, node.typeArguments);
+			break;
+		case "TSUnionType":
+			state.out += tSTypeListText(state, node.types, " | ");
+			break;
+		case "TSIntersectionType":
+			state.out += tSTypeListText(state, node.types, " & ");
+			break;
+		case "TSArrayType":
+			state.out += `${arrayElementTypeText(state, node.elementType)}[]`;
+			break;
+		case "TSTypeLiteral":
+			printTSTypeLiteral(state, node.members);
+			break;
+		case "TSTupleType":
+			printTupleType(state, node.elementTypes);
+			break;
+		case "TSConditionalType":
+			doPrintTSType(state, node.checkType);
+			state.out += " extends ";
+			doPrintTSType(state, node.extendsType);
+			state.out += " ? ";
+			doPrintTSType(state, node.trueType);
+			state.out += " : ";
+			doPrintTSType(state, node.falseType);
+			break;
+		case "TSInferType":
+			state.out += `infer ${node.typeParameter.name.name}`;
+			printTypeClause(state, " extends ", node.typeParameter.constraint);
+			break;
+		case "TSTypeQuery":
+			state.out += "typeof ";
+			printTypeQueryName(state, node);
+			state.out += typeArgumentsText(state, node.typeArguments);
+			break;
+		case "TSImportType":
+			printTSImportType(state, node);
+			break;
+		case "TSTypeOperator":
+			state.out += `${node.operator} `;
+			doPrintTSType(state, node.typeAnnotation);
+			break;
+		case "TSMappedType":
+			printMappedType(state, node);
+			break;
+		case "TSTemplateLiteralType":
+			printTSTemplateLiteral(state, node);
+			break;
+		case "TSFunctionType":
+			printTSFunctionType(state, node);
+			break;
+		case "TSConstructorType":
+			printTSConstructorType(state, node);
+			break;
+		case "TSTypePredicate":
+			printTSTypePredicate(state, node);
+			break;
+		case "TSIndexedAccessType":
+			doPrintTSType(state, node.objectType);
+			state.out += "[";
+			doPrintTSType(state, node.indexType);
+			state.out += "]";
+			break;
+		case "TSNamedTupleMember":
+			printNamedTupleMember(state, node);
+			break;
+		case "TSLiteralType":
+			printTSLiteralType(state, node.literal);
+			break;
+		case "TSParenthesizedType":
+			state.out += "(";
+			doPrintTSType(state, node.typeAnnotation);
+			state.out += ")";
+			break;
+		case "TSJSDocNullableType":
+			printJSDocPostfixModifier(state, node, "?");
+			break;
+		case "TSJSDocNonNullableType":
+			printJSDocPostfixModifier(state, node, "!");
+			break;
+		case "TSJSDocUnknownType": state.out += "?";
+	}
+}
+function tSTypeListText(state, types, separator) {
+	return types.map((type) => printTSTypeToString(state, type)).join(separator);
+}
+function arrayElementTypeText(state, type) {
+	const printed = printTSTypeToString(state, type);
+	if (ARRAY_ELEMENT_WRAPPED_KINDS[type.type] === true) return `(${printed})`;
+	return printed;
+}
+function printTSTypeLiteral(state, members) {
+	const rendered = members.map((member) => signatureText(state, member)).join("; ");
+	switch (members.length) {
+		case 0:
+			state.out += "{}";
+			break;
+		default: state.out += `{ ${rendered} }`;
+	}
+}
+function signatureText(state, member) {
+	const printed = capture(state, () => printTSSignature(state, member));
+	if (printed.endsWith(";")) return printed.slice(0, -1);
+	return printed;
+}
+function printTupleType(state, elements) {
+	state.out += `[${elements.map((element) => capture(state, () => printTupleElement(state, element))).join(", ")}]`;
+}
+function printTupleElement(state, element) {
+	switch (nodeKind(element)) {
+		case "TSRestType":
+			printRestTupleElement(state, element);
+			break;
+		case "TSOptionalType":
+			printOptionalTupleElement(state, element);
+			break;
+		case "TSNamedTupleMember":
+			printNamedTupleElement(state, element);
+			break;
+		default: printTupleElementType(state, element);
+	}
+}
+function printRestTupleElement(state, element) {
+	if (isNodeOfKind(element, "TSRestType")) {
+		state.out += "...";
+		doPrintTSType(state, element.typeAnnotation);
+	}
+}
+function printOptionalTupleElement(state, element) {
+	if (isNodeOfKind(element, "TSOptionalType")) {
+		doPrintTSType(state, element.typeAnnotation);
+		state.out += "?";
+	}
+}
+function printNamedTupleElement(state, element) {
+	if (isNodeOfKind(element, "TSNamedTupleMember")) printNamedTupleMember(state, element);
+}
+function printTupleElementType(state, element) {
+	if (isTSType(element)) doPrintTSType(state, element);
+}
+function printNamedTupleMember(state, member) {
+	state.out += `${member.label.name}${flagText(member.optional, "?")}: `;
+	printTupleElement(state, member.elementType);
+}
+function printTypeClause(state, keyword, type) {
+	if (type == null) return;
+	state.out += keyword;
+	doPrintTSType(state, type);
+}
+function printTypeQueryName(state, node) {
+	const exprName = node.exprName;
+	if (exprName.type === "TSImportType") {
+		doPrintTSType(state, exprName);
+		return;
+	}
+	printTSTypeName(state, exprName);
+}
+function printTSTypeName(state, name) {
+	if (name.type === "TSQualifiedName") {
+		printTSTypeName(state, name.left);
+		state.out += `.${name.right.name}`;
+		return;
+	}
+	state.out += tSTypeNameLeafText(state, name);
+}
+function tSTypeNameLeafText(state, name) {
+	switch (name.type) {
+		case "Identifier": return name.name;
+		case "ThisExpression": return "this";
+		case "TSQualifiedName": return sequenceNodeText(state, name);
+	}
+}
+function printTSImportTypeQualifier(state, qualifier) {
+	if (qualifier === null) return;
+	printTSImportTypeQualifierNode(state, qualifier);
+}
+function printTSImportTypeQualifierNode(state, qualifier) {
+	if (qualifier.type === "Identifier") {
+		state.out += qualifier.name;
+		return;
+	}
+	printTSImportTypeQualifier(state, qualifier.left);
+	state.out += `.${qualifier.right.name}`;
+}
+function printTSImportType(state, node) {
+	printTSImportTypeSource(state, node);
+	if (node.qualifier !== null) {
+		state.out += ".";
+		printTSImportTypeQualifier(state, node.qualifier);
+	}
+	state.out += typeArgumentsText(state, node.typeArguments);
+}
+function printTSImportTypeSource(state, node) {
+	state.out += `import(${JSON.stringify(node.source.value)}`;
+	state.out += flagText(node.options, `, ${assignmentNodeText(state, node.options)}`);
+	state.out += ")";
+}
+function printMappedType(state, node) {
+	state.out += "{ ";
+	printMappedTypeModifier(state, node.readonly, "readonly ");
+	state.out += `[${node.key.name} in `;
+	doPrintTSType(state, node.constraint);
+	printTypeClause(state, " as ", node.nameType);
+	state.out += "]";
+	printMappedTypeModifier(state, node.optional, "?");
+	printTypeClause(state, ": ", node.typeAnnotation);
+	state.out += " }";
+}
+function printMappedTypeModifier(state, modifier, rendered) {
+	switch (modifier) {
+		case true:
+			state.out += rendered;
+			break;
+		case "+":
+			state.out += `+${rendered}`;
+			break;
+		case "-": state.out += `-${rendered}`;
 	}
-	printTSTypeParameterDeclaration(node) {
-		this.out += `<${node.params.map((param) => this.capture(() => this.printTSTypeParameter(param))).join(", ")}>`;
+}
+function printTSTemplateLiteral(state, node) {
+	state.out += `\`${node.quasis.map((quasi, index) => templateTypeQuasiText(state, quasi, node.types[index])).join("")}\``;
+}
+function templateTypeQuasiText(state, quasi, type) {
+	switch (quasi.tail) {
+		case true: return quasi.value.raw;
+		case false: return templateTypeText(state, quasi, type);
 	}
-	printTSTypeParameterInstantiation(node) {
-		this.out += `<${node.params.map((param) => this.printTSTypeToString(param)).join(", ")}>`;
+}
+function templateTypeText(state, quasi, type) {
+	if (type === void 0) throw new Error("Printer: template literal type has no type for its quasi");
+	return `${quasi.value.raw}\${${printTSTypeToString(state, type)}}`;
+}
+function printTSFunctionType(state, node) {
+	state.out += `${typeParametersText(state, node.typeParameters)}(${paramsText(state, node.params)}) => ${printTSTypeToString(state, node.returnType.typeAnnotation)}`;
+}
+function printTSConstructorType(state, node) {
+	state.out += `${flagText(node.abstract, "abstract ")}new ${typeParametersText(state, node.typeParameters)}(${paramsText(state, node.params)}) => ${printTSTypeToString(state, node.returnType.typeAnnotation)}`;
+}
+function printTSTypePredicate(state, node) {
+	state.out += flagText(node.asserts, "asserts ");
+	state.out += typePredicateParameterText(node.parameterName);
+	printPredicateAnnotation(state, node);
+}
+function printPredicateAnnotation(state, node) {
+	if (node.typeAnnotation === null) return;
+	printTypeClause(state, " is ", node.typeAnnotation.typeAnnotation);
+}
+function printTSLiteralType(state, literal) {
+	switch (literal.type) {
+		case "Literal":
+			printLiteral(state, literal);
+			return;
+		case "TemplateLiteral":
+			printTemplateLiteral(state, literal);
+			return;
+		case "UnaryExpression": printTSLiteralUnary(state, literal);
 	}
-	printTSTypeParameter(node) {
-		this.out += typeParameterModifiersText(node);
-		this.out += node.name.name;
-		this.printTypeClause(" extends ", node.constraint);
-		this.printTypeClause(" = ", node.default);
+}
+function printTSLiteralUnary(state, unary) {
+	state.out += unary.operator;
+	if (isLiteralNode(unary.argument)) printLiteral(state, unary.argument);
+}
+function printJSDocPostfixModifier(state, node, marker) {
+	if (node.postfix) {
+		doPrintTSType(state, node.typeAnnotation);
+		state.out += marker;
+		return;
 	}
-};
+	state.out += marker;
+	doPrintTSType(state, node.typeAnnotation);
+}
+function printTSTypeAnnotation(state, node) {
+	state.out += ": ";
+	doPrintTSType(state, node.typeAnnotation);
+}
+function printTSTypeParameterDeclaration(state, node) {
+	state.out += `<${node.params.map((param) => capture(state, () => printTSTypeParameter(state, param))).join(", ")}>`;
+}
+function printTSTypeParameterInstantiation(state, node) {
+	state.out += `<${node.params.map((param) => printTSTypeToString(state, param)).join(", ")}>`;
+}
+function printTSTypeParameter(state, node) {
+	state.out += typeParameterModifiersText(node);
+	state.out += node.name.name;
+	printTypeClause(state, " extends ", node.constraint);
+	printTypeClause(state, " = ", node.default);
+}
 const TS_TYPE_NODE_KINDS = {
 	TSAnyKeyword: true,
 	TSStringKeyword: true,
@@ -2956,13 +3015,65 @@ const TS_TYPE_NODE_KINDS = {
 function isTSTypeNode(kind) {
 	return TS_TYPE_NODE_KINDS[kind] === true;
 }
+function isTSType(node) {
+	return isTSTypeNode(node.type);
+}
+function isNodeOfKind(node, kind) {
+	return node.type === kind;
+}
+const FUNCTION_KINDS = {
+	FunctionDeclaration: true,
+	FunctionExpression: true,
+	TSDeclareFunction: true,
+	TSEmptyBodyFunctionExpression: true
+};
+function isFunctionNode(node) {
+	return FUNCTION_KINDS[node.type] === true;
+}
+function isAssignmentPattern(node) {
+	return node.type === "AssignmentPattern";
+}
+function isLiteralNode(node) {
+	return node.type === "Literal";
+}
+const ABSENT_NODE_KIND = "\0absent";
+function nodeKind(node) {
+	if (node == null) return ABSENT_NODE_KIND;
+	return node.type;
+}
+function isIdentifierNode(node) {
+	if (node == null) return false;
+	return node.type === "Identifier";
+}
+function isPrivateIdentifierNode(node) {
+	if (node == null) return false;
+	return node.type === "PrivateIdentifier";
+}
+function isAssignmentPatternNode(node) {
+	if (node == null) return false;
+	return node.type === "AssignmentPattern";
+}
+function identifierName(node) {
+	if (isIdentifierNode(node)) return node.name;
+}
+function identifierNameText(node) {
+	return identifierName(node) ?? "";
+}
+function privateIdentifierText(node) {
+	if (isPrivateIdentifierNode(node)) return `#${node.name}`;
+	return "";
+}
+function literalCapture(state, node) {
+	if (isLiteralNode(node)) return capture(state, () => printLiteral(state, node));
+	return capture(state, () => printNodePrec(state, node, PREC.Assignment));
+}
 function precOf(node) {
-	switch (node.type) {
+	switch (nodeKind(node)) {
 		case "SequenceExpression": return PREC.Sequence;
 		case "AssignmentExpression": return PREC.Assignment;
 		case "ConditionalExpression": return PREC.Conditional;
-		case "LogicalExpression": return logicalPrec(node.operator);
-		case "BinaryExpression": return binaryPrec(node.operator);
+		case "LogicalExpression": return logicalPrecOf(node);
+		case "BinaryExpression": return binaryPrecOf(node);
 		case "UnaryExpression":
 		case "AwaitExpression":
 		case "YieldExpression": return PREC.Unary;
@@ -2976,6 +3087,14 @@ function precOf(node) {
 		default: return PREC.Primary;
 	}
 }
+function logicalPrecOf(node) {
+	if (node.type === "LogicalExpression") return logicalPrec(node.operator);
+	return PREC.Primary;
+}
+function binaryPrecOf(node) {
+	if (node.type === "BinaryExpression") return binaryPrec(node.operator);
+	return PREC.Primary;
+}
 const EVERY_COMMENT_POSITION = Number.POSITIVE_INFINITY;
 const END_OF_COMMENTS = {
 	type: "Line",
@@ -2987,52 +3106,9 @@ function sortedCommentsWithoutHashbang(comments, hashbang) {
 	return [...withoutHashbangComment(comments ?? [], hashbang)].sort((a, b) => a.start - b.start);
 }
 function withoutHashbangComment(comments, hashbang) {
-	switch (hashbang) {
-		case null: return comments;
-		default: {
-			const { start } = hashbang;
-			return comments.filter((comment) => !(comment.type === "Line" && comment.start === start));
-		}
-	}
-}
-const ABSENT_NODE_KIND = "\0absent";
-const ABSENT_NODE = { type: ABSENT_NODE_KIND };
-function nodeKind(node) {
-	return (node ?? ABSENT_NODE).type;
-}
-function propertyForm(fields) {
-	switch (true) {
-		case fields.kind === "get":
-		case fields.kind === "set": return "accessor";
-		case fields.method === true: return "method";
-		case isShorthandMatch(fields): return "shorthand";
-		case isShorthandDefaultMatch(fields): return "shorthandDefault";
-		default: return "verbose";
-	}
-}
-function isShorthandMatch(fields) {
-	return fields.shorthand === true && namesMatch(identifierName(fields.key), identifierName(fields.value));
-}
-function isShorthandDefaultMatch(fields) {
-	return fields.shorthand === true && namesMatch(identifierName(fields.key), defaultTargetName(fields.value));
-}
-function identifierName(node) {
-	switch (nodeKind(node)) {
-		case "Identifier": return node.name;
-		default: return;
-	}
-}
-function defaultTargetName(node) {
-	switch (nodeKind(node)) {
-		case "AssignmentPattern": return identifierName(node.left);
-		default: return;
-	}
-}
-function namesMatch(key, value) {
-	switch (value) {
-		case void 0: return false;
-		default: return key === value;
-	}
+	if (hashbang === null) return comments;
+	const { start } = hashbang;
+	return comments.filter((comment) => !(comment.type === "Line" && comment.start === start));
 }
 const MEMBER_OBJECT_WRAPPED_KINDS = {
 	SequenceExpression: true,
@@ -3060,41 +3136,64 @@ const UNARY_WORD_OPERATORS = {
 	void: true,
 	delete: true
 };
+const ARRAY_ELEMENT_WRAPPED_KINDS = {
+	TSUnionType: true,
+	TSIntersectionType: true
+};
 function parenthesizedIf(wrap, text) {
-	switch (wrap) {
-		case true: return `(${text})`;
-		default: return text;
-	}
+	if (wrap) return `(${text})`;
+	return text;
 }
 function jsxAttributeNameText(name) {
-	switch (name.type) {
-		case "JSXIdentifier": return name.name;
-		default: return `${name.namespace.name}:${name.name.name}`;
-	}
+	if (name.type === "JSXIdentifier") return name.name;
+	return `${name.namespace.name}:${name.name.name}`;
 }
-const BARE_DEFAULT_EXPORT_KINDS = {
-	FunctionDeclaration: true,
-	ClassDeclaration: true,
-	TSInterfaceDeclaration: true
-};
-const ARRAY_ELEMENT_WRAPPED_KINDS = {
-	TSUnionType: true,
-	TSIntersectionType: true
+function propertyForm(fields) {
+	if (isAccessorKind(fields)) return "accessor";
+	return propertyFormWithoutAccessor(fields);
+}
+function isAccessorKind(fields) {
+	return fields.kind === "get" || fields.kind === "set";
+}
+function propertyFormWithoutAccessor(fields) {
+	if (fields.method === true) return "method";
+	return propertyFormShorthand(fields);
+}
+function propertyFormShorthand(fields) {
+	if (isShorthandMatch(fields)) return "shorthand";
+	return propertyFormDefault(fields);
+}
+function propertyFormDefault(fields) {
+	if (isShorthandDefaultMatch(fields)) return "shorthandDefault";
+	return "verbose";
+}
+function isShorthandMatch(fields) {
+	return fields.shorthand === true && namesMatch(identifierName(fields.key), identifierName(fields.value));
+}
+function isShorthandDefaultMatch(fields) {
+	return fields.shorthand === true && namesMatch(identifierName(fields.key), defaultTargetName(fields.value));
+}
+function defaultTargetName(node) {
+	if (isAssignmentPatternNode(node)) return identifierName(node.left);
+}
+function namesMatch(key, value) {
+	if (value === void 0) return false;
+	return key === value;
+}
+const BINDING_TYPE_ANNOTATION_KINDS = {
+	Identifier: true,
+	ObjectPattern: true,
+	ArrayPattern: true
 };
-function typeParameterModifiersText(node) {
-	return `${flagText(node.in, "in ")}${flagText(node.out, "out ")}${flagText(node.const, "const ")}`;
+function bindingTypeAnnotation(node) {
+	if (isBindingTypeAnnotationCarrier(node)) return node.typeAnnotation;
 }
-function typePredicateParameterText(parameterName) {
-	switch (parameterName.type) {
-		case "TSThisType": return "this";
-		default: return parameterName.name;
-	}
+function isBindingTypeAnnotationCarrier(node) {
+	return BINDING_TYPE_ANNOTATION_KINDS[node.type] === true;
 }
-function externalModuleArgumentText(value) {
-	switch (Boolean(value)) {
-		case true: return JSON.stringify(value);
-		default: return "\"\"";
-	}
+function bindingNameText(node) {
+	if (node.name === void 0) return "";
+	return node.name;
 }
 const EXPORT_NAME_TEXTS = {
 	Identifier: (name) => name.name ?? "",
@@ -3129,32 +3228,31 @@ function namedSpecifierText(specifier) {
 	return `${flagText(specifier.importKind === "type", "type ")}${alias}`;
 }
 function importLocalName(specifier) {
-	switch (nodeKind(specifier)) {
-		case ABSENT_NODE_KIND: return "";
-		default: return specifier.local.name;
-	}
+	if (specifier === void 0) return "";
+	return specifier.local.name;
 }
 function importedNameText(imported) {
-	switch (nodeKind(imported)) {
-		case "Identifier": return imported.name;
-		default: return imported.value;
-	}
+	if (imported === void 0) return "";
+	return importedNameOf(imported);
+}
+function importedNameOf(imported) {
+	if (imported.type === "Identifier") return nameOrEmpty(imported.name);
+	return nameOrEmpty(imported.value);
+}
+function nameOrEmpty(value) {
+	return value ?? "";
 }
 function exportAliasText(localName, exportedName) {
-	switch (localName === exportedName) {
-		case true: return localName;
-		default: return `${localName} as ${exportedName}`;
-	}
+	if (localName === exportedName) return localName;
+	return `${localName} as ${exportedName}`;
 }
 function exportSpecifierText(specifier) {
 	const alias = exportAliasText(exportNameToString(specifier.local), exportNameToString(specifier.exported));
 	return `${flagText(specifier.exportKind === "type", "type ")}${alias}`;
 }
 function exportedNameClauseText(exported) {
-	switch (nodeKind(exported)) {
-		case ABSENT_NODE_KIND: return "";
-		default: return ` as ${exportNameToString(exported)}`;
-	}
+	if (exported == null) return "";
+	return ` as ${exportNameToString(exported)}`;
 }
 function importAttributesText(attrs) {
 	const rendered = attrs.map((attribute) => importAttributeText(attribute)).join(", ");
@@ -3164,17 +3262,13 @@ function importAttributeText(attribute) {
 	return `${importAttrKeyText(attribute.key)}: ${JSON.stringify(attribute.value.value)}`;
 }
 function importAttrKeyText(key) {
-	switch (key.type) {
-		case "Identifier": return key.name;
-		default: return JSON.stringify(key.value);
-	}
+	if (key.type === "Identifier") return key.name;
+	return JSON.stringify(key.value);
 }
 function bareArrowParamName(node) {
 	const name = singleParamName(node);
-	switch (name) {
-		case "": return "";
-		default: return flagText(node.returnType == null, name);
-	}
+	if (name === "") return "";
+	return flagText(node.returnType == null, name);
 }
 function singleParamName(node) {
 	switch (node.params.length) {
@@ -3183,49 +3277,33 @@ function singleParamName(node) {
 	}
 }
 function bareParameterName(param) {
-	const fields = param;
-	switch (true) {
-		case fields === void 0: return "";
-		case fields.type !== "Identifier": return "";
-		case fields.typeAnnotation != null: return "";
-		case fields.name === void 0: return "";
-		default: return fields.name;
-	}
+	if (param === void 0) return "";
+	return bareParameterNameOf(param);
+}
+function bareParameterNameOf(param) {
+	if (!isUnannotatedIdentifier(param)) return "";
+	return param.name;
+}
+function isUnannotatedIdentifier(param) {
+	if (param.type !== "Identifier") return false;
+	return param.typeAnnotation == null;
 }
 function arrowBodyIsBlock(body) {
-	return nodeKind(body) === "BlockStatement";
+	return body.type === "BlockStatement";
 }
 function functionHeaderText(node) {
 	return `${flagText(node.declare, "declare ")}${flagText(node.async, "async ")}function${flagText(node.generator, "*")}${namedDeclarationText(node)}`;
 }
 function namedDeclarationText(node) {
-	switch (Boolean(node.id)) {
-		case true: return ` ${node.id.name}`;
-		default: return "";
-	}
-}
-function bindingNameText(node) {
-	switch (node.name) {
-		case void 0: return "";
-		default: return node.name;
-	}
-}
-function parameterForm(param) {
-	switch (true) {
-		case param["type"] === "RestElement": return "rest";
-		case param["type"] === "TSParameterProperty": return "property";
-		default: return "formal";
-	}
+	if (node.id == null) return "";
+	return ` ${node.id.name}`;
 }
 function parameterPropertyModifiers(param) {
-	const accessibility = param["accessibility"];
-	return `${flagText(accessibility, `${accessibility} `)}${flagText(param["readonly"], "readonly ")}${flagText(param["override"], "override ")}${flagText(param["static"], "static ")}`;
+	return `${flagText(param.accessibility, `${param.accessibility} `)}${flagText(param.readonly, "readonly ")}${flagText(param.override, "override ")}${flagText(param.static, "static ")}`;
 }
 function commentText(comment) {
-	switch (comment.type) {
-		case "Block": return `/*${comment.value}*/`;
-		default: return `//${comment.value}`;
-	}
+	if (comment.type === "Block") return `/*${comment.value}*/`;
+	return `//${comment.value}`;
 }
 function methodDefinitionPrefix(node, fn) {
 	return `${flagText(node.accessibility, `${node.accessibility} `)}${flagText(node.static, "static ")}${flagText(node.override, "override ")}${flagText(fn.async, "async ")}${flagText(fn.generator, "*")}${methodKindText(node.kind)}`;
@@ -3241,28 +3319,56 @@ function propertyDefinitionModifiers(node) {
 	return `${flagText(node.declare, "declare ")}${flagText(node.accessibility, `${node.accessibility} `)}${flagText(node.static, "static ")}${flagText(node.readonly, "readonly ")}${flagText(node.override, "override ")}`;
 }
 function literalText(node) {
-	switch (true) {
-		case node.raw != null: return node.raw;
-		case node.regex != null: return `/${node.regex.pattern}/${node.regex.flags}`;
-		case node.bigint != null: return node.bigint;
-		default: return valueLiteralText(node.value);
-	}
+	if (node.raw != null) return node.raw;
+	return literalWithoutRaw(node);
+}
+function literalWithoutRaw(node) {
+	if (node.regex != null) return `/${node.regex.pattern}/${node.regex.flags}`;
+	return literalWithoutRegex(node);
+}
+function literalWithoutRegex(node) {
+	if (node.bigint != null) return node.bigint;
+	return valueLiteralText(node.value);
 }
 function valueLiteralText(value) {
 	switch (typeof value) {
 		case "string": return JSON.stringify(value);
-		case "number":
+		case "number": return String(value);
 		case "boolean": return String(value);
 		case "bigint": return `${value}n`;
-		default: return "null";
+		case "symbol":
+		case "undefined":
+		case "object":
+		case "function": return "null";
 	}
 }
 function flagText(present, text) {
 	switch (Boolean(present)) {
 		case true: return text;
-		default: return "";
+		case false: return "";
 	}
 }
+function typeParameterModifiersText(node) {
+	return `${flagText(node.in, "in ")}${flagText(node.out, "out ")}${flagText(node.const, "const ")}`;
+}
+function typePredicateParameterText(parameterName) {
+	if (parameterName.type === "TSThisType") return "this";
+	return parameterName.name;
+}
+function externalModuleArgumentText(value) {
+	switch (Boolean(value)) {
+		case true: return JSON.stringify(value);
+		case false: return "\"\"";
+	}
+}
+const BARE_DEFAULT_EXPORT_KINDS = {
+	FunctionDeclaration: true,
+	ClassDeclaration: true,
+	TSInterfaceDeclaration: true
+};
+function isBareDefaultExport(node) {
+	return BARE_DEFAULT_EXPORT_KINDS[node.type] === true;
+}
 //#endregion
 //#region src/Printer.ts
 /**
@@ -3345,6 +3451,76 @@ function appendStatement(state, script, rawContent, context) {
 	};
 }
 //#endregion
+//#region src/Mutant.ts
+const isMutant = (value) => S.is(Mutant)(value);
+const INSTRUMENTER_CONSTANTS = Object.freeze({
+	NAMESPACE: "__stryker__",
+	MUTATION_COVERAGE_OBJECT: "mutantCoverage",
+	ACTIVE_MUTANT: "activeMutant",
+	CURRENT_TEST_ID: "currentTestId",
+	HIT_COUNT: "hitCount",
+	HIT_LIMIT: "hitLimit",
+	ACTIVE_MUTANT_ENV_VARIABLE: "__STRYKER_ACTIVE_MUTANT__"
+});
+function normalizeFileName(fileName) {
+	return fileName.replace(/\\/g, "/");
+}
+const hasText = (value) => Predicate.isString(value) && value.length > 0;
+const textIfNonEmpty = (value) => Option.getOrUndefined(Option.filter(Option.fromUndefinedOr(value), hasText));
+const fieldOf = (value, key) => Match.value(key in value).pipe(Match.when(true, () => {
+	return Reflect.get(value, key);
+}), Match.orElse(() => void 0));
+const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
+function isErrnoException(error) {
+	return Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
+}
+const isEmptyNumber = (value) => Match.value(value).pipe(Match.when(0, () => true), Match.orElse(Number.isNaN));
+const isEmptyError = (error) => Match.value(error).pipe(Match.when(Match.undefined, () => true), Match.when(Match.null, () => true), Match.when(Match.string, (text) => text.length === 0), Match.when(Match.number, isEmptyNumber), Match.when(Match.boolean, (value) => !value), Match.orElse(() => false));
+const formatErrnoException = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
+const formatError = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), Match.orElse(() => `${error.name}: ${error.message}`));
+const isJsonPrimitive = (value) => Match.value(value).pipe(Match.when(Match.number, () => true), Match.when(Match.boolean, () => true), Match.when(Match.bigint, () => true), Match.orElse(() => false));
+const jsonText = (error) => {
+	try {
+		return textIfNonEmpty(JSON.stringify(error));
+	} catch {
+		return;
+	}
+};
+const isNonPlaceholderText = (text) => Match.value({
+	hasLength: text.length > 0,
+	isPlaceholder: text === "[object Object]"
+}).pipe(Match.when({
+	hasLength: true,
+	isPlaceholder: false
+}, () => true), Match.orElse(() => false));
+const isUsableText = (value) => Match.value(value).pipe(Match.when(Match.string, isNonPlaceholderText), Match.orElse(() => false));
+const usableText = (value) => Match.value(value).pipe(Match.when(isUsableText, (text) => text), Match.orElse(() => ""));
+const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pipe(Match.when(Match.instanceOf(Function), (callable) => {
+	try {
+		return usableText(Reflect.apply(callable, value, []));
+	} catch {
+		return "";
+	}
+}), Match.orElse(() => ""));
+const isObjectType = (cause) => typeof cause === "object";
+const toStringText = (error) => Match.value(error).pipe(Match.when(Match.null, () => ""), Match.when(isObjectType, (value) => objectToStringText(value)), Match.orElse(() => ""));
+const stringifyRest = (error) => Match.value(jsonText(error)).pipe(Match.when(hasText, (json) => json), Match.orElse(() => toStringText(error)));
+const stringifyNonError = (error) => Match.value(error).pipe(Match.when(Match.string, (text) => text), Match.when(isJsonPrimitive, (primitive) => JSON.stringify(primitive)), Match.orElse(() => stringifyRest(error)));
+const errorText = (error) => Match.value(error).pipe(Match.when(isErrnoException, formatErrnoException), Match.orElse(() => formatError(error)));
+function errorToString(error) {
+	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
+}
+const ERROR_CODES = Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
+const errorNameOf = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), (error) => textIfNonEmpty(error.name)), Match.orElse(() => void 0));
+const tagOf = (value) => Match.value(textIfNonEmpty(fieldOf(value, "_tag"))).pipe(Match.when(hasText, (tag) => tag), Match.orElse(() => errorNameOf(value)));
+const textWithNested = (own, nested) => Match.value(own).pipe(Match.when(hasText, (text) => appendNested(text, nested)), Match.orElse(() => nested));
+const appendNested = (own, nested) => Match.value(nested).pipe(Match.when(hasText, (text) => `${own}: ${text}`), Match.orElse(() => own));
+const errorMessage = (error) => Match.value(error.message.length > 0).pipe(Match.when(true, () => error.message), Match.orElse(() => tagOf(error)));
+const errorMessageOrTag = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), errorMessage), Match.orElse(() => tagOf(value)));
+const messageText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match.when(hasText, (message) => message), Match.orElse(() => errorMessageOrTag(value)));
+const ownCauseText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match.when(hasText, (reason) => reason), Match.orElse(() => messageText(value)));
+const causeText = (cause, depth) => Match.value(cause).pipe(Match.when(() => depth > 4, () => void 0), Match.when(Match.undefined, () => void 0), Match.when(Match.null, () => void 0), Match.when(Match.string, textIfNonEmpty), Match.when(isObjectType, (value) => textWithNested(ownCauseText(value), causeText(fieldOf(value, "cause"), depth + 1))), Match.orElse(() => void 0));
+//#endregion
 //#region src/Mutator.ts
 /**
 * Mutator — every mutation operator and its registry.
@@ -4065,7 +4241,9 @@ function regexFlags(parent) {
 const PLACEHOLDER = "Stryker was here!";
 const stringLiteralMutator = (node, context) => Match.value(node).pipe(Match.when(isTemplateLiteral, (template) => templateMutants(template)), Match.when(isStringLiteral, (literal) => mutantsWhen(isValidParent(literal, context), () => [stringLiteral(replacementText(literal.value.length === 0))])), Match.orElse(() => NO_MUTANTS));
 function templateMutants(template) {
-	return Match.value(template.quasis[0]).pipe(Match.when(void 0, () => NO_MUTANTS), Match.orElse((first) => [emptyOrPlaceholderTemplate(template, first)]));
+	const first = template.quasis[0];
+	if (first === void 0) return NO_MUTANTS;
+	return [emptyOrPlaceholderTemplate(template, first)];
 }
 function emptyOrPlaceholderTemplate(template, first) {
 	return templateLiteral([templateElement(replacementText([template.quasis.length === 1, first.value.raw.length === 0].every(Boolean)))], []);
@@ -4255,7 +4433,13 @@ function processStrykerDirectives(rule, node, allMutatorNames, originFileName) {
 	};
 }
 function attachedComments(node) {
-	return node.leadingComments ?? NO_COMMENTS;
+	return leadingCommentsOn(node) ?? NO_COMMENTS;
+}
+function leadingCommentsOn(value) {
+	if (isCommentBearing(value)) return value.leadingComments;
+}
+function isCommentBearing(value) {
+	return Predicate.hasProperty(value, "leadingComments");
 }
 /** A comment that matched the directive grammar, decoded into the fields a rule needs. */
 function parseStrykerDirective(comment) {
@@ -4334,7 +4518,6 @@ function isDeclared(node) {
 	return "declare" in node && node.declare === true;
 }
 const tsTypeAnnotationNodeTypes = Object.freeze([
-	"TSAsExpression",
 	"TSInterfaceDeclaration",
 	"TSTypeAnnotation",
 	"TSTypeAliasDeclaration",
@@ -4371,16 +4554,35 @@ function mutationCoverageSequenceExpression(mutants, targetExpression) {
 	return sequenceExpression(sequence);
 }
 function nodeOfKind(mutant, node, isKind, kind) {
-	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
-	return node;
+	return narrowNode(node, isKind, `Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
+}
+function narrowNode(node, isKind, message) {
+	if (isKind(node)) return node;
+	throw new Error(message);
+}
+function expressionOf(node) {
+	return narrowNode(node, isExpressionKind, `Expected an expression, got ${node.type}`);
+}
+function statementOf(node) {
+	return narrowNode(node, isStatementKind, `Expected a statement, got ${node.type}`);
+}
+function isSwitchCase(node) {
+	return nodeType(node) === "SwitchCase";
+}
+function switchCaseOf(node) {
+	return narrowNode(node, isSwitchCase, `Expected a switch case, got ${node.type}`);
 }
 function throwPlacementError(error, nodePath, placer, mutants, fileName, lineTable, basePath) {
 	const message = `${placer.name} could not place mutants with type(s): "${placementListFormat.format(mutants.map((mutant) => mutant.mutatorName))}"`;
 	const errorMessage = `${placementLocation(nodePath.node, fileName, lineTable, basePath)} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using \`mutator.excludedMutations\`). Original error: ${error.stack}`;
 	throw new Error(errorMessage);
 }
+const fileNameWithin = (basePath, fileName) => {
+	if (basePath === void 0) return fileName;
+	return relativeTo(basePath, fileName);
+};
 function placementLocation(node, fileName, lineTable, basePath) {
-	const relativeFile = basePath === void 0 ? fileName : relativeTo(basePath, fileName);
+	const relativeFile = fileNameWithin(basePath, fileName);
 	const position = Option.map(Option.fromNullishOr(spanOf(node)), (span) => positionFromLineTable(span.start, lineTable));
 	return Option.match(position, {
 		onNone: () => `${relativeFile}:undefined:undefined`,
@@ -4391,12 +4593,14 @@ const placementListFormat = new Intl.ListFormat("en");
 const normalizeSeparators = (value) => value.replace(/\\/g, "/");
 const withTrailingSlash = (basePath) => {
 	const normalized = normalizeSeparators(basePath);
-	return normalized.endsWith("/") ? normalized : `${normalized}/`;
+	if (normalized.endsWith("/")) return normalized;
+	return `${normalized}/`;
 };
 const relativeTo = (basePath, fileName) => {
 	const prefix = withTrailingSlash(basePath);
 	const normalizedFile = normalizeSeparators(fileName);
-	return normalizedFile.startsWith(prefix) ? normalizedFile.slice(prefix.length) : fileName;
+	if (!normalizedFile.startsWith(prefix)) return fileName;
+	return normalizedFile.slice(prefix.length);
 };
 function classOrFunctionExpressionNamedIfNeeded(path) {
 	return Match.value(path.node).pipe(Match.when(isAnonymousFunctionOrClass, (node) => nameFromParent(path, node)), Match.orElse(() => void 0));
@@ -4456,7 +4660,7 @@ function nameIfAnonymous(path) {
 	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowNameOrNode(path);
 }
 function arrowNameOrNode(path) {
-	return arrowFunctionExpressionNamedIfNeeded(path) ?? path.node;
+	return arrowFunctionExpressionNamedIfNeeded(path) ?? expressionOf(path.node);
 }
 function isChainLink(node) {
 	return [
@@ -4558,7 +4762,7 @@ const statementMutantPlacer = {
 function statementsOf(path) {
 	const node = path.node;
 	if (node.type === "BlockStatement") return node.body;
-	return [node];
+	return [statementOf(node)];
 }
 function guardedStatement(statement, entry) {
 	return ifStatement(mutantTestExpression(entry[0].id), blockStatement([nodeOfKind(entry[0], entry[1], isStatementKind, "a statement")]), statement);
@@ -4575,10 +4779,10 @@ const allMutantPlacers = Object.freeze([
 			return nodeType(path.node) === "SwitchCase";
 		},
 		place(path, appliedMutants) {
-			const currentCase = path.node;
+			const currentCase = switchCaseOf(path.node);
 			let consequence = blockStatement([expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...currentCase.consequent]);
 			for (const [mutant, appliedMutant] of appliedMutants) {
-				const appliedCase = nodeOfKind(mutant, appliedMutant, (candidate) => nodeType(candidate) === "SwitchCase", "a switch case");
+				const appliedCase = nodeOfKind(mutant, appliedMutant, isSwitchCase, "a switch case");
 				consequence = ifStatement(mutantTestExpression(mutant.id), blockStatement(appliedCase.consequent), consequence);
 			}
 			path.replaceWith(switchCase(currentCase.test, [consequence]));
@@ -4655,12 +4859,11 @@ const headerFor = (root) => Effect.map(instrumentationHeader, (header) => Option
 	onSome: (leadingComments) => [commentedHeader(leadingComments, header), ...header.slice(1)]
 }));
 function leadingCommentsOf(root) {
-	const firstStatement = root.body[0];
-	return Option.filter(Option.fromNullishOr(firstStatement?.leadingComments), isCommentArray);
+	return Option.filter(Option.some(leadingCommentsOn(root.body[0])), isCommentArray);
 }
 function commentedHeader(leadingComments, header) {
 	const cloned = cloneNode(Option.getOrThrowWith(Option.fromNullishOr(header[0]), () => /* @__PURE__ */ new Error("Instrumentation header is empty")));
-	cloned.leadingComments = leadingComments;
+	Object.assign(cloned, { leadingComments });
 	return cloned;
 }
 function deepFreeze(value) {