espolar 0.1.0

package/dist/index.js

@@ -0,0 +1,1483 @@
+//#region src/printers.ts
+const EXPRESSIONS_PRECEDENCE = {
+	ArrayPattern: 20,
+	ObjectPattern: 20,
+	ArrayExpression: 20,
+	TaggedTemplateExpression: 20,
+	ThisExpression: 20,
+	Identifier: 20,
+	TemplateLiteral: 20,
+	Super: 20,
+	SequenceExpression: 20,
+	MemberExpression: 19,
+	MetaProperty: 19,
+	CallExpression: 19,
+	ChainExpression: 19,
+	ImportExpression: 19,
+	NewExpression: 19,
+	Literal: 18,
+	TSSatisfiesExpression: 18,
+	TSInstantiationExpression: 18,
+	TSNonNullExpression: 18,
+	TSTypeAssertion: 18,
+	AwaitExpression: 17,
+	ClassExpression: 17,
+	FunctionExpression: 17,
+	ObjectExpression: 17,
+	UnaryExpression: 16,
+	UpdateExpression: 16,
+	TSAsExpression: 15,
+	BinaryExpression: 14,
+	LogicalExpression: 13,
+	ConditionalExpression: 4,
+	ArrowFunctionExpression: 3,
+	AssignmentExpression: 3,
+	YieldExpression: 2,
+	RestElement: 1
+};
+const OPERATOR_PRECEDENCE = {
+	"||": 2,
+	"&&": 3,
+	"??": 4,
+	"|": 5,
+	"^": 6,
+	"&": 7,
+	"==": 8,
+	"!=": 8,
+	"===": 8,
+	"!==": 8,
+	"<": 9,
+	">": 9,
+	"<=": 9,
+	">=": 9,
+	in: 9,
+	instanceof: 9,
+	"<<": 10,
+	">>": 10,
+	">>>": 10,
+	"+": 11,
+	"-": 11,
+	"*": 12,
+	"%": 12,
+	"/": 12,
+	"**": 13
+};
+function commentNeedsNewline(comment) {
+	if (comment.type === "Line") return true;
+	return comment.value.includes("\n");
+}
+function needsParens(node, parent, isRight) {
+	if (node.type === "PrivateIdentifier" || node.type === "Identifier" || node.type === "Super") return false;
+	if (node.type === "LogicalExpression" && parent.type === "LogicalExpression" && parent.operator === "??" !== (node.operator === "??")) return true;
+	const precedence = EXPRESSIONS_PRECEDENCE[node.type] ?? 20;
+	const parentPrecedence = EXPRESSIONS_PRECEDENCE[parent.type] ?? 20;
+	if (precedence !== parentPrecedence) {
+		if (!isRight && precedence === 15 && parentPrecedence === 14 && parent.operator === "**") return false;
+		return precedence < parentPrecedence;
+	}
+	if (precedence !== 13 && precedence !== 14) return false;
+	const nodeOp = node.operator;
+	if (nodeOp === "**" && parent.operator === "**") return !isRight;
+	if (isRight) return OPERATOR_PRECEDENCE[nodeOp] <= OPERATOR_PRECEDENCE[parent.operator];
+	return OPERATOR_PRECEDENCE[nodeOp] < OPERATOR_PRECEDENCE[parent.operator];
+}
+function arrowConciseBodyNeedsWrap(body) {
+	if (body.type === "BlockStatement") return false;
+	switch (body.type) {
+		case "ObjectExpression": return true;
+		case "AssignmentExpression": return body.left.type === "ObjectPattern";
+		case "LogicalExpression": return body.left.type === "ObjectExpression";
+		case "ConditionalExpression": return body.test.type === "ObjectExpression";
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression": return body.expression ? arrowConciseBodyNeedsWrap(body.expression) : false;
+		default: return false;
+	}
+}
+const defaultPrinters = {
+	Program: printProgram,
+	Identifier: printIdentifier,
+	PrivateIdentifier: printPrivateIdentifier,
+	Literal: printLiteral,
+	ExpressionStatement: printExpressionStatement,
+	EmptyStatement: printEmptyStatement,
+	VariableDeclaration: printVariableDeclaration,
+	VariableDeclarator: printVariableDeclarator,
+	BlockStatement: printBlockStatement,
+	ReturnStatement: printReturnStatement,
+	ThrowStatement: printThrowStatement,
+	DebuggerStatement: printDebuggerStatement,
+	BreakStatement: printBreakStatement,
+	ContinueStatement: printContinueStatement,
+	LabeledStatement: printLabeledStatement,
+	WhileStatement: printWhileStatement,
+	DoWhileStatement: printDoWhileStatement,
+	IfStatement: printIfStatement,
+	ForStatement: printForStatement,
+	ForInStatement: printForInStatement,
+	ForOfStatement: printForOfStatement,
+	SwitchStatement: printSwitchStatement,
+	SwitchCase: printSwitchCase,
+	TryStatement: printTryStatement,
+	WithStatement: printWithStatement,
+	FunctionDeclaration: printFunctionDeclaration,
+	FunctionExpression: printFunctionExpression,
+	ArrowFunctionExpression: printArrowFunctionExpression,
+	UnaryExpression: printUnaryExpression,
+	UpdateExpression: printUpdateExpression,
+	BinaryExpression: printBinaryExpression,
+	LogicalExpression: printBinaryExpression,
+	AssignmentExpression: printBinaryExpression,
+	ConditionalExpression: printConditionalExpression,
+	YieldExpression: printYieldExpression,
+	AwaitExpression: printAwaitExpression,
+	SequenceExpression: printSequenceExpression,
+	CallExpression: printCallExpression,
+	NewExpression: printNewExpression,
+	ChainExpression: printChainExpression,
+	MemberExpression: printMemberExpression,
+	ObjectExpression: printObjectExpression,
+	ObjectPattern: printObjectPattern,
+	ArrayExpression: printArrayExpression,
+	ArrayPattern: printArrayPattern,
+	Property: printProperty,
+	SpreadElement: printSpreadElement,
+	RestElement: printRestElement,
+	AssignmentPattern: printAssignmentPattern,
+	TemplateLiteral: printTemplateLiteral,
+	TaggedTemplateExpression: printTaggedTemplateExpression,
+	ThisExpression: printThisExpression,
+	Super: printSuper,
+	MetaProperty: printMetaProperty,
+	ParenthesizedExpression: printParenthesizedExpression,
+	ClassDeclaration: printClassDeclaration,
+	ClassExpression: printClassExpression,
+	ClassBody: printClassBody,
+	StaticBlock: printStaticBlock,
+	PropertyDefinition: printPropertyDefinition,
+	AccessorProperty: printPropertyDefinition,
+	MethodDefinition: printMethodDefinition,
+	Decorator: printDecorator,
+	ImportDeclaration: printImportDeclaration,
+	ImportExpression: printImportExpression,
+	ImportSpecifier: printImportSpecifier,
+	ExportNamedDeclaration: printExportNamedDeclaration,
+	ExportDefaultDeclaration: printExportDefaultDeclaration,
+	ExportAllDeclaration: printExportAllDeclaration,
+	ExportSpecifier: printExportSpecifier,
+	TSAsExpression: printTSAsExpression,
+	TSSatisfiesExpression: printTSSatisfiesExpression,
+	TSTypeAssertion: printTSTypeAssertion,
+	TSNonNullExpression: printTSNonNullExpression,
+	TSTypeAnnotation: printTSTypeAnnotation,
+	TSTypeAliasDeclaration: printTSTypeAliasDeclaration,
+	TSInterfaceDeclaration: printTSInterfaceDeclaration,
+	TSExpressionWithTypeArguments: printTSExpressionWithTypeArguments,
+	TSClassImplements: printTSExpressionWithTypeArguments,
+	TSInterfaceHeritage: printTSExpressionWithTypeArguments,
+	TSFunctionType: printTSFunctionType,
+	TSConstructorType: printTSConstructorType,
+	TSMethodSignature: printTSMethodSignature,
+	TSCallSignatureDeclaration: printTSCallSignatureDeclaration,
+	TSConstructSignatureDeclaration: printTSConstructSignatureDeclaration,
+	TSIndexSignature: printTSIndexSignature,
+	TSPropertySignature: printTSPropertySignature,
+	TSTypeParameterDeclaration: printTypeParameterDeclaration,
+	TSTypeParameterInstantiation: printTypeParameterInstantiation,
+	TSTypeParameter: printTSTypeParameter,
+	TSTypeReference: printTSTypeReference,
+	TSQualifiedName: printTSQualifiedName,
+	TSUnionType: printJoinedTypes,
+	TSIntersectionType: printJoinedTypes,
+	TSArrayType: printTSArrayType,
+	TSTupleType: printTSTupleType,
+	TSNamedTupleMember: printTSNamedTupleMember,
+	TSTypeLiteral: printTSTypeLiteral,
+	TSTypeOperator: printTSTypeOperator,
+	TSTypePredicate: printTSTypePredicate,
+	TSTypeQuery: printTSTypeQuery,
+	TSMappedType: printTSMappedType,
+	TSConditionalType: printTSConditionalType,
+	TSInferType: printTSInferType,
+	TSIndexedAccessType: printTSIndexedAccessType,
+	TSOptionalType: printTSOptionalType,
+	TSRestType: printTSRestType,
+	TSThisType: printTSThisType,
+	TSLiteralType: printTSLiteralType,
+	TSTemplateLiteralType: printTSTemplateLiteralType,
+	TSImportType: printTSImportType,
+	TSImportEqualsDeclaration: printTSImportEqualsDeclaration,
+	TSExternalModuleReference: printTSExternalModuleReference,
+	TSEnumDeclaration: printTSEnumDeclaration,
+	TSEnumMember: printTSEnumMember,
+	TSModuleDeclaration: printTSModuleDeclaration,
+	TSModuleBlock: printTSModuleBlock,
+	TSDeclareFunction: printTSDeclareFunction,
+	TSParameterProperty: printTSParameterProperty,
+	TSAbstractMethodDefinition: printMethodDefinition,
+	TSAbstractPropertyDefinition: printPropertyDefinition,
+	TSAbstractAccessorProperty: printPropertyDefinition,
+	TSExportAssignment: printTSExportAssignment,
+	TSNamespaceExportDeclaration: printTSNamespaceExportDeclaration,
+	TSInstantiationExpression: printTSInstantiationExpression,
+	TSParenthesizedType: printTSParenthesizedType,
+	TSInterfaceBody: printTSInterfaceBody,
+	TSStringKeyword: printKeywordType,
+	TSNumberKeyword: printKeywordType,
+	TSBooleanKeyword: printKeywordType,
+	TSVoidKeyword: printKeywordType,
+	TSUnknownKeyword: printKeywordType,
+	TSAnyKeyword: printKeywordType,
+	TSNeverKeyword: printKeywordType,
+	TSNullKeyword: printKeywordType,
+	TSUndefinedKeyword: printKeywordType,
+	TSObjectKeyword: printKeywordType,
+	TSSymbolKeyword: printKeywordType,
+	TSBigIntKeyword: printKeywordType,
+	TSIntrinsicKeyword: printKeywordType
+};
+function printProgram(program, context) {
+	context.writeNodeListWithSourceGaps(program.body, "\n");
+}
+function printExpressionStatement(statement, context) {
+	const expr = statement.expression;
+	if (expr.type === "ObjectExpression" || expr.type === "FunctionExpression" || expr.type === "AssignmentExpression" && expr.left.type === "ObjectPattern") {
+		context.write("(");
+		context.writeNode(expr);
+		context.write(");");
+	} else {
+		context.writeNode(expr);
+		context.write(";");
+	}
+}
+function printEmptyStatement(_statement, context) {
+	context.write(";");
+}
+function printVariableDeclaration(declaration, context) {
+	if (declaration.declare === true) context.write("declare ");
+	context.write(String(declaration.kind));
+	context.write(" ");
+	context.writeNodeList(declaration.declarations, ", ");
+	context.write(";");
+}
+function printVariableDeclarator(declarator, context) {
+	context.writeNode(declarator.id);
+	if (declarator.definite === true) context.write("!");
+	if (declarator.init) {
+		context.write(" = ");
+		context.writeNode(declarator.init);
+	}
+}
+function printBlockStatement(block, context) {
+	const body = block.body;
+	context.write("{");
+	if (body.length > 0) {
+		context.write("\n");
+		context.writeNodeListWithSourceGaps(body, "\n");
+		context.write("\n");
+	}
+	context.write("}");
+}
+function printReturnStatement(statement, context) {
+	context.write("return");
+	if (statement.argument) {
+		context.write(" ");
+		const needsParensASi = (context.getLeadingComments?.(statement.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		if (needsParensASi) context.write("(");
+		context.writeNode(statement.argument);
+		if (needsParensASi) context.write(")");
+	}
+	context.write(";");
+}
+function printThrowStatement(statement, context) {
+	context.write("throw ");
+	if (statement.argument) {
+		const needsParensASi = (context.getLeadingComments?.(statement.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		if (needsParensASi) context.write("(");
+		context.writeNode(statement.argument);
+		if (needsParensASi) context.write(")");
+	}
+	context.write(";");
+}
+function printDebuggerStatement(_statement, context) {
+	context.write("debugger;");
+}
+function printBreakStatement(statement, context) {
+	context.write("break");
+	if (statement.label) {
+		context.write(" ");
+		context.writeNode(statement.label);
+	}
+	context.write(";");
+}
+function printContinueStatement(statement, context) {
+	context.write("continue");
+	if (statement.label) {
+		context.write(" ");
+		context.writeNode(statement.label);
+	}
+	context.write(";");
+}
+function printLabeledStatement(statement, context) {
+	context.writeNode(statement.label);
+	context.write(": ");
+	context.writeNode(statement.body);
+}
+function printWhileStatement(statement, context) {
+	context.write("while (");
+	context.writeNode(statement.test);
+	context.write(") ");
+	context.writeNode(statement.body);
+}
+function printDoWhileStatement(statement, context) {
+	context.write("do ");
+	context.writeNode(statement.body);
+	context.write(" while (");
+	context.writeNode(statement.test);
+	context.write(");");
+}
+function printIfStatement(statement, context) {
+	context.write("if (");
+	context.writeNode(statement.test);
+	context.write(") ");
+	context.writeNode(statement.consequent);
+	if (statement.alternate) {
+		context.write(" else ");
+		context.writeNode(statement.alternate);
+	}
+}
+function printForStatement(statement, context) {
+	context.write("for (");
+	if (statement.init) if (statement.init.type === "VariableDeclaration") printVariableDeclarationFor(statement.init, context);
+	else context.writeNode(statement.init);
+	context.write("; ");
+	if (statement.test) context.writeNode(statement.test);
+	context.write("; ");
+	if (statement.update) context.writeNode(statement.update);
+	context.write(") ");
+	context.writeNode(statement.body);
+}
+function printForInStatement(statement, context) {
+	context.write("for (");
+	if (statement.left.type === "VariableDeclaration") printVariableDeclarationFor(statement.left, context);
+	else context.writeNode(statement.left);
+	context.write(" in ");
+	context.writeNode(statement.right);
+	context.write(") ");
+	context.writeNode(statement.body);
+}
+function printForOfStatement(statement, context) {
+	context.write("for ");
+	if (statement.await === true) context.write("await ");
+	context.write("(");
+	if (statement.left.type === "VariableDeclaration") printVariableDeclarationFor(statement.left, context);
+	else context.writeNode(statement.left);
+	context.write(" of ");
+	context.writeNode(statement.right);
+	context.write(") ");
+	context.writeNode(statement.body);
+}
+function printVariableDeclarationFor(declaration, context) {
+	context.write(String(declaration.kind));
+	context.write(" ");
+	context.writeNodeList(declaration.declarations, ", ");
+}
+function printSwitchStatement(statement, context) {
+	context.write("switch (");
+	context.writeNode(statement.discriminant);
+	context.write(") {");
+	for (const case_ of statement.cases) context.writeNode(case_);
+	context.write("}");
+}
+function printSwitchCase(case_, context) {
+	if (case_.test) {
+		context.write("\ncase ");
+		context.writeNode(case_.test);
+		context.write(":");
+	} else context.write("\ndefault:");
+	for (const stmt of case_.consequent) {
+		context.write("\n");
+		context.writeNode(stmt);
+	}
+}
+function printTryStatement(statement, context) {
+	context.write("try ");
+	context.writeNode(statement.block);
+	if (statement.handler) {
+		context.write(" catch");
+		if (statement.handler.param) {
+			context.write(" (");
+			context.writeNode(statement.handler.param);
+			context.write(") ");
+		} else context.write(" ");
+		context.writeNode(statement.handler.body);
+	}
+	if (statement.finalizer) {
+		context.write(" finally ");
+		context.writeNode(statement.finalizer);
+	}
+}
+function printWithStatement(statement, context) {
+	context.write("with (");
+	context.writeNode(statement.object);
+	context.write(") ");
+	context.writeNode(statement.body);
+}
+function printIdentifier(identifier, context) {
+	context.write(String(identifier.name));
+	writeOptionalTypeAnnotation(identifier, context);
+}
+function printPrivateIdentifier(identifier, context) {
+	context.write("#");
+	context.write(String(identifier.name));
+}
+function printLiteral(literal, context) {
+	if (typeof literal.raw === "string") {
+		context.write(literal.raw);
+		return;
+	}
+	const l = literal;
+	context.write(JSON.stringify(l.value));
+}
+function printUnaryExpression(expr, context) {
+	context.write(expr.operator);
+	if (expr.operator.length > 1) context.write(" ");
+	const argPrec = EXPRESSIONS_PRECEDENCE[expr.argument.type];
+	if (argPrec != null && argPrec < EXPRESSIONS_PRECEDENCE.UnaryExpression) {
+		context.write("(");
+		context.writeNode(expr.argument);
+		context.write(")");
+	} else context.writeNode(expr.argument);
+}
+function printUpdateExpression(expr, context) {
+	if (expr.prefix === true) {
+		context.write(expr.operator);
+		context.writeNode(expr.argument);
+	} else {
+		const needsParensASi = (context.getTrailingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		if (needsParensASi) context.write("(");
+		context.writeNode(expr.argument);
+		if (needsParensASi) context.write(")");
+		context.write(expr.operator);
+	}
+}
+function printBinaryExpression(expression, context) {
+	const left = expression.left;
+	const right = expression.right;
+	if (needsParens(left, expression, false)) {
+		context.write("(");
+		context.writeNode(left);
+		context.write(")");
+	} else context.writeNode(left);
+	context.write(" ");
+	context.write(String(expression.operator));
+	context.write(" ");
+	if (needsParens(right, expression, true)) {
+		context.write("(");
+		context.writeNode(right);
+		context.write(")");
+	} else context.writeNode(right);
+}
+function printConditionalExpression(expr, context) {
+	if ((EXPRESSIONS_PRECEDENCE[expr.test.type] ?? 20) <= EXPRESSIONS_PRECEDENCE.ConditionalExpression) {
+		context.write("(");
+		context.writeNode(expr.test);
+		context.write(")");
+	} else context.writeNode(expr.test);
+	context.write(" ? ");
+	context.writeNode(expr.consequent);
+	context.write(" : ");
+	context.writeNode(expr.alternate);
+}
+function printYieldExpression(expr, context) {
+	context.write(expr.delegate === true ? "yield*" : "yield");
+	if (expr.argument) {
+		context.write(" ");
+		const needsParensASi = (context.getLeadingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		if (needsParensASi) context.write("(");
+		context.writeNode(expr.argument);
+		if (needsParensASi) context.write(")");
+	}
+}
+function printAwaitExpression(expr, context) {
+	context.write("await");
+	if (expr.argument) {
+		const argPrec = EXPRESSIONS_PRECEDENCE[expr.argument.type];
+		if (argPrec != null && argPrec < EXPRESSIONS_PRECEDENCE.AwaitExpression) {
+			context.write(" (");
+			context.writeNode(expr.argument);
+			context.write(")");
+		} else {
+			context.write(" ");
+			context.writeNode(expr.argument);
+		}
+	}
+}
+function printSequenceExpression(expr, context) {
+	context.write("(");
+	context.writeNodeList(expr.expressions, ", ");
+	context.write(")");
+}
+function printCallExpression(expression, context) {
+	if ((EXPRESSIONS_PRECEDENCE[expression.callee.type] ?? 20) < EXPRESSIONS_PRECEDENCE.CallExpression) {
+		context.write("(");
+		context.writeNode(expression.callee);
+		context.write(")");
+	} else context.writeNode(expression.callee);
+	if (expression.typeArguments) context.writeNode(expression.typeArguments);
+	context.write(expression.optional === true ? "?.(" : "(");
+	context.writeNodeList(expression.arguments, ", ");
+	context.write(")");
+}
+function printNewExpression(expression, context) {
+	context.write("new ");
+	if ((EXPRESSIONS_PRECEDENCE[expression.callee.type] ?? 20) < EXPRESSIONS_PRECEDENCE.NewExpression || hasCallExpression(expression.callee)) {
+		context.write("(");
+		context.writeNode(expression.callee);
+		context.write(")");
+	} else context.writeNode(expression.callee);
+	if (expression.typeArguments) context.writeNode(expression.typeArguments);
+	context.write("(");
+	context.writeNodeList(expression.arguments, ", ");
+	context.write(")");
+}
+function hasCallExpression(node) {
+	let cur = node;
+	while (cur) {
+		if (cur.type === "CallExpression") return true;
+		if (cur.type === "MemberExpression") cur = cur.object;
+		else return false;
+	}
+	return false;
+}
+function printChainExpression(expression, context) {
+	context.writeNode(expression.expression);
+}
+function printMemberExpression(expression, context) {
+	if ((EXPRESSIONS_PRECEDENCE[expression.object.type] ?? 20) < EXPRESSIONS_PRECEDENCE.MemberExpression) {
+		context.write("(");
+		context.writeNode(expression.object);
+		context.write(")");
+	} else context.writeNode(expression.object);
+	if (expression.computed === true) {
+		context.write(expression.optional === true ? "?.[" : "[");
+		context.writeNode(expression.property);
+		context.write("]");
+	} else {
+		context.write(expression.optional === true ? "?." : ".");
+		context.writeNode(expression.property);
+	}
+}
+function printObjectExpression(object, context) {
+	context.write("{ ");
+	context.writeNodeList(object.properties, ", ");
+	context.write(" }");
+}
+function printObjectPattern(pattern, context) {
+	context.write("{ ");
+	context.writeNodeList(pattern.properties, ", ");
+	context.write(" }");
+	writeOptionalTypeAnnotation(pattern, context);
+}
+function printArrayExpression(array, context) {
+	context.write("[");
+	context.writeNodeList(array.elements, ", ");
+	context.write("]");
+}
+function printArrayPattern(pattern, context) {
+	context.write("[");
+	context.writeNodeList(pattern.elements, ", ");
+	context.write("]");
+	writeOptionalTypeAnnotation(pattern, context);
+}
+function printProperty(property, context) {
+	if (property.type === "Property") {
+		const value = property.value;
+		const valNode = value.type === "AssignmentPattern" ? value.left : value;
+		if (!property.computed && property.kind === "init" && property.key.type === "Identifier" && valNode.type === "Identifier" && property.key.name === valNode.name) {
+			context.writeNode(value);
+			return;
+		}
+		if (value.type === "FunctionExpression") {
+			if (property.kind !== "init") context.write(property.kind + " ");
+			if (value.async === true) context.write("async ");
+			if (value.generator === true) context.write("*");
+			if (property.computed === true) {
+				context.write("[");
+				context.writeNode(property.key);
+				context.write("]");
+			} else context.writeNode(property.key);
+			context.write("(");
+			context.writeNodeList(value.params, ", ");
+			context.write(")");
+			writeReturnType(value, context);
+			context.write(" ");
+			context.writeNode(value.body);
+			return;
+		}
+		if (property.computed === true) {
+			context.write("[");
+			context.writeNode(property.key);
+			context.write("]: ");
+		} else {
+			if (property.kind === "get" || property.kind === "set") context.write(property.kind + " ");
+			context.writeNode(property.key);
+			context.write(": ");
+		}
+		context.writeNode(property.value);
+	}
+}
+function printSpreadElement(spread, context) {
+	context.write("...");
+	context.writeNode(spread.argument);
+}
+function printRestElement(rest, context) {
+	context.write("...");
+	context.writeNode(rest.argument);
+	writeOptionalTypeAnnotation(rest, context);
+}
+function printAssignmentPattern(pattern, context) {
+	context.writeNode(pattern.left);
+	context.write(" = ");
+	context.writeNode(pattern.right);
+}
+function printTemplateLiteral(node, context) {
+	context.write("`");
+	const { quasis, expressions } = node;
+	for (let i = 0; i < expressions.length; i++) {
+		context.write(quasis[i].value.raw);
+		context.write("${");
+		context.writeNode(expressions[i]);
+		context.write("}");
+	}
+	context.write(quasis[quasis.length - 1].value.raw);
+	context.write("`");
+}
+function printTaggedTemplateExpression(node, context) {
+	context.writeNode(node.tag);
+	context.writeNode(node.quasi);
+}
+function printThisExpression(_node, context) {
+	context.write("this");
+}
+function printSuper(_node, context) {
+	context.write("super");
+}
+function printMetaProperty(node, context) {
+	context.writeNode(node.meta);
+	context.write(".");
+	context.writeNode(node.property);
+}
+function printParenthesizedExpression(node, context) {
+	context.write("(");
+	context.writeNode(node.expression);
+	context.write(")");
+}
+function printFunctionDeclaration(node, context) {
+	printFunction(node, context);
+}
+function printFunctionExpression(node, context) {
+	printFunction(node, context);
+}
+function printFunction(fn, context) {
+	if (fn.async === true) context.write("async ");
+	context.write("function");
+	if (fn.generator === true) context.write("*");
+	if (fn.id) {
+		context.write(" ");
+		context.writeNode(fn.id);
+	}
+	if (fn.typeParameters) context.writeNode(fn.typeParameters);
+	context.write("(");
+	context.writeNodeList(fn.params, ", ");
+	context.write(")");
+	writeReturnType(fn, context);
+	if (fn.body) {
+		context.write(" ");
+		context.writeNode(fn.body);
+	}
+}
+function printArrowFunctionExpression(fn, context) {
+	if (fn.async === true) context.write("async ");
+	if (fn.typeParameters) context.writeNode(fn.typeParameters);
+	context.write("(");
+	context.writeNodeList(fn.params, ", ");
+	context.write(")");
+	writeReturnType(fn, context);
+	context.write(" => ");
+	const body = fn.body;
+	if (arrowConciseBodyNeedsWrap(body)) {
+		context.write("(");
+		context.writeNode(body);
+		context.write(")");
+	} else context.writeNode(body);
+}
+function printClassDeclaration(node, context) {
+	printClass(node, context);
+}
+function printClassExpression(node, context) {
+	printClass(node, context);
+}
+function printClass(node, context) {
+	if (node.decorators) for (const d of node.decorators) context.writeNode(d);
+	if (node.declare === true) context.write("declare ");
+	if (node.abstract === true) context.write("abstract ");
+	context.write("class ");
+	if (node.id) {
+		context.writeNode(node.id);
+		context.write(" ");
+	}
+	if (node.superClass) {
+		context.write("extends ");
+		context.writeNode(node.superClass);
+		if (node.superTypeArguments) context.writeNode(node.superTypeArguments);
+		else if (node.superTypeParameters) context.writeNode(node.superTypeParameters);
+	}
+	if (node.implements && node.implements.length > 0) {
+		context.write(" implements ");
+		context.writeNodeList(node.implements, ", ");
+	}
+	if (node.superClass || node.implements && node.implements.length > 0) context.write(" ");
+	context.writeNode(node.body);
+}
+function printClassBody(node, context) {
+	context.write("{");
+	const body = node.body;
+	if (body.length > 0) {
+		context.write("\n");
+		context.writeNodeListWithSourceGaps(body, "\n");
+		context.write("\n");
+	}
+	context.write("}");
+}
+function printStaticBlock(node, context) {
+	context.write("static {");
+	const body = node.body;
+	if (body.length > 0) {
+		context.write("\n");
+		context.writeNodeListWithSourceGaps(body, "\n");
+		context.write("\n");
+	}
+	context.write("}");
+}
+function printDecorator(node, context) {
+	context.write("@");
+	context.writeNode(node.expression);
+	context.write("\n");
+}
+function printPropertyDefinition(node, context) {
+	if (node.decorators) for (const d of node.decorators) context.writeNode(d);
+	if (node.type === "TSAbstractPropertyDefinition" || "abstract" in node && node.abstract === true) context.write("abstract ");
+	if (node.accessibility) context.write(node.accessibility + " ");
+	if (node.static === true) context.write("static ");
+	if (node.override === true) context.write("override ");
+	if (node.readonly === true) context.write("readonly ");
+	if (node.type === "AccessorProperty" || node.type === "TSAbstractAccessorProperty" || "accessor" in node && node.accessor === true) context.write("accessor ");
+	if (node.computed === true) {
+		context.write("[");
+		context.writeNode(node.key);
+		context.write("]");
+	} else context.writeNode(node.key);
+	if (node.typeAnnotation) if ("accessor" in node && node.accessor === true) context.writeNode(node.typeAnnotation);
+	else {
+		context.write(": ");
+		context.writeNode(node.typeAnnotation.typeAnnotation);
+	}
+	if (node.value) {
+		context.write(" = ");
+		context.writeNode(node.value);
+	}
+	context.write(";");
+}
+function printMethodDefinition(node, context) {
+	const def = node;
+	if (def.decorators) for (const d of def.decorators) context.writeNode(d);
+	if (def.accessibility) context.write(def.accessibility + " ");
+	if (def.static === true) context.write("static ");
+	if (def.override === true) context.write("override ");
+	if (node.type === "TSAbstractMethodDefinition" || "abstract" in def && def.abstract === true) context.write("abstract ");
+	if (def.kind === "get" || def.kind === "set") context.write(def.kind + " ");
+	if (def.value.async === true) context.write("async ");
+	if (def.value.generator === true) context.write("*");
+	if (def.computed === true) {
+		context.write("[");
+		context.writeNode(def.key);
+		context.write("]");
+	} else context.writeNode(def.key);
+	context.write("(");
+	context.writeNodeList(def.value.params, ", ");
+	context.write(")");
+	writeReturnType(def.value, context);
+	if (def.value.body) {
+		context.write(" ");
+		context.writeNode(def.value.body);
+	} else context.write(";");
+}
+function printImportDeclaration(node, context) {
+	context.write("import ");
+	if (node.importKind === "type") context.write("type ");
+	const specifiers = node.specifiers;
+	if (specifiers.length === 0) {
+		context.writeNode(node.source);
+		context.write(";");
+		return;
+	}
+	let wroteDefault = false;
+	for (const s of specifiers) if (s.type === "ImportDefaultSpecifier") {
+		context.writeNode(s.local);
+		wroteDefault = true;
+	}
+	let namespaceSpec;
+	const namedSpecs = [];
+	for (const s of specifiers) if (s.type === "ImportNamespaceSpecifier") namespaceSpec = s;
+	else if (s.type === "ImportSpecifier") namedSpecs.push(s);
+	if (namespaceSpec) {
+		if (wroteDefault) context.write(", ");
+		context.write("* as ");
+		context.writeNode(namespaceSpec.local);
+	}
+	if (namedSpecs.length > 0) {
+		if (wroteDefault || namespaceSpec) context.write(", ");
+		context.write("{ ");
+		context.writeNodeList(namedSpecs, ", ");
+		context.write(" }");
+	}
+	context.write(" from ");
+	context.writeNode(node.source);
+	if (node.attributes && node.attributes.length > 0) {
+		context.write(" with { ");
+		context.writeNodeList(node.attributes, ", ");
+		context.write(" }");
+	}
+	context.write(";");
+}
+function printImportExpression(node, context) {
+	context.write("import(");
+	context.writeNode(node.source);
+	if (node.options) {
+		context.write(", ");
+		context.writeNode(node.options);
+	}
+	context.write(")");
+}
+function printImportSpecifier(node, context) {
+	if (node.importKind === "type") context.write("type ");
+	if (node.local.type === "Identifier" && node.imported.type === "Identifier" && node.local.name !== node.imported.name) {
+		context.writeNode(node.imported);
+		context.write(" as ");
+	}
+	context.writeNode(node.local);
+}
+function printExportNamedDeclaration(node, context) {
+	if (node.declaration) {
+		let decl = node.declaration;
+		if ("decorators" in decl && decl.decorators && decl.decorators.length > 0) {
+			const { decorators, ...rest } = decl;
+			for (const d of decorators) context.writeNode(d);
+			decl = rest;
+		}
+		context.write("export ");
+		if (node.exportKind === "type") context.write("type ");
+		context.writeNode(decl);
+		if (decl.type !== "FunctionDeclaration" && decl.type !== "ClassDeclaration" && decl.type !== "VariableDeclaration" && decl.type !== "TSModuleDeclaration" && decl.type !== "TSEnumDeclaration" && decl.type !== "TSTypeAliasDeclaration" && decl.type !== "TSInterfaceDeclaration" && decl.type !== "TSDeclareFunction") context.write(";");
+		return;
+	}
+	context.write("export ");
+	if (node.exportKind === "type") context.write("type ");
+	context.write("{ ");
+	context.writeNodeList(node.specifiers, ", ");
+	context.write(" }");
+	if (node.source) {
+		context.write(" from ");
+		context.writeNode(node.source);
+	}
+	context.write(";");
+}
+function printExportDefaultDeclaration(node, context) {
+	let decl = node.declaration;
+	if ("decorators" in decl && decl.decorators && decl.decorators.length > 0) {
+		for (const d of decl.decorators) context.writeNode(d);
+		const { decorators: _, ...rest } = decl;
+		decl = rest;
+	}
+	context.write("export default ");
+	context.writeNode(decl);
+	if (decl.type !== "FunctionDeclaration" && decl.type !== "ClassDeclaration" && decl.type !== "ClassExpression") context.write(";");
+}
+function printExportAllDeclaration(node, context) {
+	context.write(node.exportKind === "type" ? "export type * " : "export * ");
+	if (node.exported) {
+		context.write("as ");
+		context.writeNode(node.exported);
+		context.write(" ");
+	}
+	context.write("from ");
+	context.writeNode(node.source);
+	context.write(";");
+}
+function printExportSpecifier(node, context) {
+	if (node.exportKind === "type") context.write("type ");
+	context.writeNode(node.local);
+	if (node.local.type === "Identifier" && node.exported.type === "Identifier" && node.local.name !== node.exported.name) {
+		context.write(" as ");
+		context.writeNode(node.exported);
+	}
+}
+function printTSAsExpression(expression, context) {
+	if ((EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20) < EXPRESSIONS_PRECEDENCE.TSAsExpression) {
+		context.write("(");
+		context.writeNode(expression.expression);
+		context.write(")");
+	} else context.writeNode(expression.expression);
+	context.write(" as ");
+	context.writeNode(expression.typeAnnotation);
+}
+function printTSSatisfiesExpression(expression, context) {
+	if ((EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20) < EXPRESSIONS_PRECEDENCE.TSSatisfiesExpression) {
+		context.write("(");
+		context.writeNode(expression.expression);
+		context.write(")");
+	} else context.writeNode(expression.expression);
+	context.write(" satisfies ");
+	context.writeNode(expression.typeAnnotation);
+}
+function printTSTypeAssertion(expression, context) {
+	context.write("<");
+	context.writeNode(expression.typeAnnotation);
+	context.write(">");
+	if ((EXPRESSIONS_PRECEDENCE[expression.expression.type] ?? 20) < EXPRESSIONS_PRECEDENCE.TSTypeAssertion) {
+		context.write("(");
+		context.writeNode(expression.expression);
+		context.write(")");
+	} else context.writeNode(expression.expression);
+}
+function printTSNonNullExpression(expression, context) {
+	context.writeNode(expression.expression);
+	context.write("!");
+}
+function printTSTypeAnnotation(annotation, context) {
+	context.write(": ");
+	context.writeNode(annotation.typeAnnotation);
+}
+function printTSTypeAliasDeclaration(alias, context) {
+	if (alias.declare === true) context.write("declare ");
+	context.write("type ");
+	context.writeNode(alias.id);
+	if (alias.typeParameters) context.writeNode(alias.typeParameters);
+	context.write(" = ");
+	context.writeNode(alias.typeAnnotation);
+	context.write(";");
+}
+function printTSInterfaceDeclaration(node, context) {
+	const declaration = node;
+	if (declaration.declare === true) context.write("declare ");
+	context.write("interface ");
+	context.writeNode(declaration.id);
+	if (declaration.typeParameters) context.writeNode(declaration.typeParameters);
+	const heritage = declaration.extends ?? [];
+	if (heritage.length > 0) {
+		context.write(" extends ");
+		context.writeNodeList(heritage, ", ");
+	}
+	context.write(" ");
+	context.writeNode(declaration.body);
+}
+function printTSExpressionWithTypeArguments(node, context) {
+	context.writeNode(node.expression);
+	if (node.typeArguments) context.writeNode(node.typeArguments);
+	if (node.typeParameters) context.writeNode(node.typeParameters);
+}
+function printTSInterfaceBody(body, context) {
+	context.write("{");
+	const members = body.body;
+	if (members.length > 0) {
+		context.write(" ");
+		context.writeNodeList(members, " ");
+		context.write(" ");
+	}
+	context.write("}");
+}
+function printTSPropertySignature(signature, context) {
+	if (signature.readonly === true) context.write("readonly ");
+	if (signature.computed === true) {
+		context.write("[");
+		context.writeNode(signature.key);
+		context.write("]");
+	} else context.writeNode(signature.key);
+	if (signature.optional === true) context.write("?");
+	if (signature.typeAnnotation) context.writeNode(signature.typeAnnotation);
+	context.write(";");
+}
+function printTypeParameterDeclaration(declaration, context) {
+	context.write("<");
+	context.writeNodeList(declaration.params, ", ");
+	context.write(">");
+}
+function printTypeParameterInstantiation(instantiation, context) {
+	context.write("<");
+	context.writeNodeList(instantiation.params, ", ");
+	context.write(">");
+}
+function printTSTypeParameter(parameter, context) {
+	if (parameter.const === true) context.write("const ");
+	if (parameter.in === true) context.write("in ");
+	if (parameter.out === true) context.write("out ");
+	if (typeof parameter.name === "string") context.write(parameter.name);
+	else context.writeNode(parameter.name);
+	if (parameter.constraint) {
+		context.write(" extends ");
+		context.writeNode(parameter.constraint);
+	}
+	if (parameter.default) {
+		context.write(" = ");
+		context.writeNode(parameter.default);
+	}
+}
+function printTSFunctionType(type, context) {
+	if (type.typeParameters) context.writeNode(type.typeParameters);
+	context.write("(");
+	if (type.params) context.writeNodeList(type.params, ", ");
+	else if (type.parameters) context.writeNodeList(type.parameters, ", ");
+	context.write(")");
+	context.write(" => ");
+	writeReturnType(type, context, { tsArrowType: true });
+}
+function printTSConstructorType(type, context) {
+	context.write("new ");
+	if (type.typeParameters) context.writeNode(type.typeParameters);
+	context.write("(");
+	if (type.params) context.writeNodeList(type.params, ", ");
+	else if (type.parameters) context.writeNodeList(type.parameters, ", ");
+	context.write(")");
+	context.write(" => ");
+	writeReturnType(type, context, { tsArrowType: true });
+}
+function printTSMethodSignature(signature, context) {
+	if (signature.readonly === true) context.write("readonly ");
+	if (signature.computed === true) {
+		context.write("[");
+		context.writeNode(signature.key);
+		context.write("]");
+	} else context.writeNode(signature.key);
+	if (signature.optional === true) context.write("?");
+	if (signature.typeParameters) context.writeNode(signature.typeParameters);
+	context.write("(");
+	if (signature.params) context.writeNodeList(signature.params, ", ");
+	else if (signature.parameters) context.writeNodeList(signature.parameters, ", ");
+	context.write(")");
+	writeReturnType(signature, context);
+	context.write(";");
+}
+function printTSCallSignatureDeclaration(signature, context) {
+	if (signature.typeParameters) context.writeNode(signature.typeParameters);
+	context.write("(");
+	if (signature.params) context.writeNodeList(signature.params, ", ");
+	else if (signature.parameters) context.writeNodeList(signature.parameters, ", ");
+	context.write(")");
+	writeReturnType(signature, context);
+	context.write(";");
+}
+function printTSConstructSignatureDeclaration(signature, context) {
+	context.write("new ");
+	if (signature.typeParameters) context.writeNode(signature.typeParameters);
+	context.write("(");
+	if (signature.params) context.writeNodeList(signature.params, ", ");
+	else if (signature.parameters) context.writeNodeList(signature.parameters, ", ");
+	context.write(")");
+	writeReturnType(signature, context);
+	context.write(";");
+}
+function printTSIndexSignature(signature, context) {
+	context.write("[");
+	if (signature.parameters) context.writeNodeList(signature.parameters, ", ");
+	context.write("]");
+	writeReturnType(signature, context);
+	context.write(";");
+}
+function writeReturnType(node, context, options) {
+	let ret = node.returnType ?? node.typeAnnotation;
+	if (options?.tsArrowType) ret = ret?.typeAnnotation;
+	if (ret) context.writeNode(ret);
+}
+function printTSTypeReference(reference, context) {
+	context.writeNode(reference.typeName);
+	if (reference.typeArguments) context.writeNode(reference.typeArguments);
+}
+function printTSQualifiedName(name, context) {
+	context.writeNode(name.left);
+	context.write(".");
+	context.writeNode(name.right);
+}
+function printJoinedTypes(joined, context) {
+	context.writeNodeList(joined.types, joined.type === "TSUnionType" ? " | " : " & ");
+}
+function printTSArrayType(array, context) {
+	context.writeNode(array.elementType);
+	context.write("[]");
+}
+function printTSTupleType(node, context) {
+	context.write("[");
+	context.writeNodeList(node.elementTypes, ", ");
+	context.write("]");
+}
+function printTSNamedTupleMember(node, context) {
+	context.writeNode(node.label);
+	context.write(": ");
+	context.writeNode(node.elementType);
+}
+function printTSTypeLiteral(literal, context) {
+	context.write("{ ");
+	context.writeNodeList(literal.members, " ");
+	context.write(" }");
+}
+function printTSTypeOperator(node, context) {
+	context.write(node.operator + " ");
+	if (node.typeAnnotation) context.writeNode(node.typeAnnotation);
+}
+function printTSTypePredicate(node, context) {
+	if (node.asserts === true) context.write("asserts ");
+	if (node.parameterName) context.writeNode(node.parameterName);
+	else if (node.typeAnnotation) context.writeNode(node.typeAnnotation);
+	if (node.asserts !== true || node.typeAnnotation) context.write(" is ");
+	if (node.typeAnnotation) context.writeNode(node.typeAnnotation.typeAnnotation);
+}
+function printTSTypeQuery(node, context) {
+	context.write("typeof ");
+	context.writeNode(node.exprName);
+}
+function printTSMappedType(node, context) {
+	context.write("{ [");
+	const legacyTp = node.typeParameter;
+	const key = node.key ?? legacyTp?.name;
+	const constraint = node.constraint ?? legacyTp?.constraint;
+	if (key) if (typeof key === "string") context.write(key);
+	else context.writeNode(key);
+	if (constraint) {
+		context.write(" in ");
+		context.writeNode(constraint);
+	}
+	context.write("]");
+	if (node.typeAnnotation) {
+		context.write(": ");
+		context.writeNode(node.typeAnnotation);
+	}
+	context.write(" }");
+}
+function printTSConditionalType(node, context) {
+	context.writeNode(node.checkType);
+	context.write(" extends ");
+	context.writeNode(node.extendsType);
+	context.write(" ? ");
+	context.writeNode(node.trueType);
+	context.write(" : ");
+	context.writeNode(node.falseType);
+}
+function printTSInferType(node, context) {
+	context.write("infer ");
+	context.writeNode(node.typeParameter);
+}
+function printTSIndexedAccessType(node, context) {
+	context.writeNode(node.objectType);
+	context.write("[");
+	context.writeNode(node.indexType);
+	context.write("]");
+}
+function printTSOptionalType(node, context) {
+	context.writeNode(node.typeAnnotation);
+	context.write("?");
+}
+function printTSRestType(node, context) {
+	context.write("...");
+	context.writeNode(node.typeAnnotation);
+}
+function printTSThisType(_node, context) {
+	context.write("this");
+}
+function printTSLiteralType(literal, context) {
+	context.writeNode(literal.literal);
+}
+function printTSTemplateLiteralType(node, context) {
+	context.write("`");
+	const { quasis, types } = node;
+	for (let i = 0; i < types.length; i++) {
+		context.write(quasis[i].value.raw);
+		context.write("${");
+		context.writeNode(types[i]);
+		context.write("}");
+	}
+	context.write(quasis[quasis.length - 1].value.raw);
+	context.write("`");
+}
+function printTSImportType(node, context) {
+	context.write("import(");
+	context.writeNode(node.argument);
+	context.write(")");
+	if (node.qualifier) {
+		context.write(".");
+		context.writeNode(node.qualifier);
+	}
+}
+function printTSImportEqualsDeclaration(node, context) {
+	context.write("import ");
+	context.writeNode(node.id);
+	context.write(" = ");
+	context.writeNode(node.moduleReference);
+	context.write(";");
+}
+function printTSExternalModuleReference(node, context) {
+	context.write("require(");
+	context.writeNode(node.expression);
+	context.write(")");
+}
+function printTSEnumDeclaration(node, context) {
+	if (node.declare === true) context.write("declare ");
+	if (node.const === true) context.write("const ");
+	context.write("enum ");
+	context.writeNode(node.id);
+	context.write(" { ");
+	context.writeNodeList(node.members, ", ");
+	context.write(" }");
+}
+function printTSEnumMember(node, context) {
+	context.writeNode(node.id);
+	if (node.initializer) {
+		context.write(" = ");
+		context.writeNode(node.initializer);
+	}
+}
+function printTSModuleDeclaration(node, context) {
+	if (node.declare === true) context.write("declare ");
+	if (node.global === true) context.write("global");
+	else {
+		const kind = node.kind ?? (node.id && node.id.type === "Literal" ? "module" : "namespace");
+		context.write(String(kind) + " ");
+		context.writeNode(node.id);
+	}
+	if (node.body) {
+		if (node.body.type === "TSModuleBlock") context.write(" ");
+		context.writeNode(node.body);
+	}
+}
+function printTSModuleBlock(node, context) {
+	context.write("{\n");
+	context.writeNodeListWithSourceGaps(node.body, "\n");
+	context.write("\n}");
+}
+function printTSDeclareFunction(node, context) {
+	context.write("declare ");
+	if (node.async === true) context.write("async ");
+	context.write("function");
+	if (node.generator === true) context.write("*");
+	if (node.id) {
+		context.write(" ");
+		context.writeNode(node.id);
+	}
+	if (node.typeParameters) context.writeNode(node.typeParameters);
+	context.write("(");
+	context.writeNodeList(node.params, ", ");
+	context.write(")");
+	writeReturnType(node, context);
+	context.write(";");
+}
+function printTSParameterProperty(node, context) {
+	if (node.accessibility) context.write(node.accessibility + " ");
+	if (node.readonly === true) context.write("readonly ");
+	context.writeNode(node.parameter);
+}
+function printTSExportAssignment(node, context) {
+	context.write("export = ");
+	context.writeNode(node.expression);
+	context.write(";");
+}
+function printTSNamespaceExportDeclaration(node, context) {
+	context.write("export as namespace ");
+	context.writeNode(node.id);
+	context.write(";");
+}
+function printTSInstantiationExpression(node, context) {
+	context.writeNode(node.expression);
+	context.writeNode(node.typeArguments);
+}
+function printTSParenthesizedType(node, context) {
+	context.write("(");
+	context.writeNode(node.typeAnnotation);
+	context.write(")");
+}
+function printKeywordType(node, context) {
+	const keyword = node.type.slice(2, -7).toLowerCase();
+	context.write(keyword);
+}
+function writeOptionalTypeAnnotation(node, context) {
+	if (node.optional === true) context.write("?");
+	if (node.typeAnnotation) context.writeNode(node.typeAnnotation);
+}
+//#endregion
+//#region src/mappings.ts
+function getNodeRange(node) {
+	if (Array.isArray(node.range) && node.range.length === 2) {
+		const [start, end] = node.range;
+		if (Number.isInteger(start) && Number.isInteger(end) && start <= end) return {
+			start,
+			end
+		};
+	}
+	const { start, end } = node;
+	if (typeof start === "number" && typeof end === "number" && Number.isInteger(start) && Number.isInteger(end) && start <= end) return {
+		start,
+		end
+	};
+}
+function pushMapping(mappings, mapping, combineMappingData) {
+	const previous = mappings.at(-1);
+	if (previous && canMerge(previous, mapping)) {
+		previous.sourceEnd = mapping.sourceEnd;
+		previous.generatedEnd = mapping.generatedEnd;
+		previous.data = combineMappingData(previous.data, mapping.data);
+		return;
+	}
+	mappings.push(mapping);
+}
+function canMerge(left, right) {
+	return left.sourceStart + left.sourceEnd === right.sourceStart && left.generatedStart + left.generatedEnd === right.generatedStart;
+}
+function toVolarMapping(mapping) {
+	const sourceLength = mapping.sourceEnd - mapping.sourceStart;
+	const generatedLength = mapping.generatedEnd - mapping.generatedStart;
+	return {
+		sourceOffsets: [mapping.sourceStart],
+		generatedOffsets: [mapping.generatedStart],
+		lengths: [sourceLength],
+		generatedLengths: generatedLength !== sourceLength ? [generatedLength] : void 0,
+		data: mapping.data
+	};
+}
+//#endregion
+//#region src/printer.ts
+function writeComment(context, comment) {
+	if (comment.type === "Line") context.write("//" + comment.value + "\n");
+	else {
+		context.write("/*" + comment.value + "*/");
+		if (comment.value.includes("\n")) context.write("\n");
+	}
+}
+function print(node, options) {
+	const context = createPrinterContext(options);
+	context.writeNode(node);
+	return context.result();
+}
+function defaultIsUntouched(node) {
+	return getNodeRange(node) || false;
+}
+function defaultGetMappingData(node) {
+	return {};
+}
+function defaultCombineMappingData(left, right) {
+	return right;
+}
+function createPrinterContext(options) {
+	const chunks = [];
+	const mappings = [];
+	let generatedOffset = 0;
+	const isUntouched = options.isUntouched ?? defaultIsUntouched;
+	const getMappingData = options.getMappingData ?? defaultGetMappingData;
+	const combineMappingData = options.combineMappingData ?? (options.getMappingData ? (left) => left : defaultCombineMappingData);
+	const printers = {
+		...defaultPrinters,
+		...options.printers
+	};
+	const getLeadingComments = options.getLeadingComments ?? (() => void 0);
+	const getTrailingComments = options.getTrailingComments ?? (() => void 0);
+	const appendMapping = (sourceRange, generatedStart, generatedEnd, data) => {
+		pushMapping(mappings, {
+			sourceStart: sourceRange.start,
+			sourceEnd: sourceRange.end,
+			generatedStart,
+			generatedEnd,
+			data
+		}, combineMappingData);
+	};
+	const context = {
+		source: options.source,
+		get generatedOffset() {
+			return generatedOffset;
+		},
+		write(text) {
+			if (text.length === 0) return;
+			chunks.push(text);
+			generatedOffset += text.length;
+		},
+		writeNode(node) {
+			if (!node) return;
+			const range = getNodeRange(node);
+			const untouchedRet = isUntouched(node);
+			if (untouchedRet) {
+				const sourceRange = untouchedRet === true ? range : untouchedRet;
+				if (!sourceRange) throw new Error(`Node of type ${node.type} is marked as untouched but does not have valid source offsets`);
+				context.writeSource(sourceRange.start, sourceRange.end, getMappingData(node));
+				return;
+			}
+			const printer = printers[node.type];
+			if (!printer) throw new Error(`No printer registered for node type ${node.type}`);
+			const leadingComments = getLeadingComments(node);
+			if (leadingComments) for (const c of leadingComments) writeComment(context, c);
+			const generatedStart = generatedOffset;
+			printer(node, context);
+			const generatedEnd = generatedOffset;
+			const trailingComments = getTrailingComments(node);
+			if (trailingComments) for (const c of trailingComments) writeComment(context, c);
+			const lastMappingGeneratedEnd = mappings.at(-1)?.generatedEnd ?? 0;
+			if (range && lastMappingGeneratedEnd <= generatedStart) appendMapping(range, generatedStart, generatedEnd, getMappingData(node));
+		},
+		writeNodeList(nodes, separator) {
+			let needsSeparator = false;
+			for (const node of nodes) {
+				if (!node) {
+					if (needsSeparator) context.write(separator);
+					continue;
+				}
+				if (needsSeparator) context.write(separator);
+				context.writeNode(node);
+				needsSeparator = true;
+			}
+		},
+		writeNodeListWithSourceGaps(nodes, fallbackSeparator) {
+			let lastRangeEnd;
+			let wroteNode = false;
+			for (const node of nodes) {
+				if (!node) continue;
+				const range = getNodeRange(node);
+				if (wroteNode) if (lastRangeEnd !== void 0 && range && range.start >= lastRangeEnd) context.writeSource(lastRangeEnd, range.start, getMappingData(null));
+				else context.write(fallbackSeparator);
+				context.writeNode(node);
+				wroteNode = true;
+				if (range) lastRangeEnd = range.end;
+				else lastRangeEnd = void 0;
+			}
+		},
+		writePreservedNode(node) {
+			const range = getNodeRange(node);
+			if (!range) throw new Error(`Cannot preserve node ${node.type} without source offsets`);
+			context.writeSource(range.start, range.end, getMappingData(node));
+		},
+		getLeadingComments,
+		getTrailingComments,
+		writeSource(start, end, data) {
+			if (end <= start) return;
+			const generatedStart = generatedOffset;
+			context.write(options.source.slice(start, end));
+			appendMapping({
+				start,
+				end
+			}, generatedStart, generatedOffset, data);
+		},
+		result() {
+			return {
+				code: chunks.join(""),
+				mappings: mappings.map(toVolarMapping)
+			};
+		}
+	};
+	return context;
+}
+//#endregion
+export { defaultCombineMappingData, defaultGetMappingData, defaultIsUntouched, print };