@systemfsoftware/stryker-js-instrumenter 2.0.1 → 3.0.0

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import babel, { File } from "@babel/core";
-import generator from "@babel/generator";
 import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js/Mutant";
 import * as Effect from "effect/Effect";
@@ -7,7 +5,7 @@ import { pipe } from "effect/Function";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as S from "effect/Schema";
-import { createRequire } from "module";
+import { parseSync } from "oxc-parser";
 import path from "path";
 import "@systemfsoftware/stryker-js/Ignorer";
 import { propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js/Schema";
@@ -18,7 +16,7 @@ import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
 /**
 * Instrument.workflow — pure decision for the instrument capability.
 *
-* The heavy lifting (Babel traversal, mutant collection, code generation)
+* The heavy lifting (AST traversal, mutant collection, code generation)
 * happens in `Instrument.ts`'s read phase, which is allowed to be stateful.
 * This decision receives the already-collected mutants as data and wraps them
 * into the decision type. All helpers and schemas live in this file so the
@@ -48,11 +46,9 @@ const FileSchema = S.Struct({
 	content: S.String,
 	mutate: MutateDescriptionSchema
 });
-const PluginSchema = Wire.mint(S.Unknown);
 const IgnorerSchema = Wire.mint(S.Unknown);
 const AstSchema = Wire.mint(S.Unknown);
 const InstrumenterOptionsSchema = Wire.wire({
-	plugins: Wire.mint(S.NullOr(Wire.mint(S.Array(PluginSchema)))),
 	excludedMutations: Wire.mint(S.Array(Wire.mint(S.String))),
 	ignorers: Wire.mint(S.Array(IgnorerSchema)),
 	noHeader: Wire.mint(S.optional(Wire.mint(S.Boolean)))
@@ -81,47 +77,6 @@ const instrumentWorkflow = Workflow.make(InstrumentDecoded, (decoded) => Result.
 	mutants: decoded.mutants,
 	asts: decoded.asts
 })));
-//#endregion
-//#region src/Parser.schema.ts
-var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParseFailed")("ParseFailed", {
-	fileName: S.String,
-	message: S.String,
-	location: S.Struct({
-		line: S.Finite,
-		column: S.Finite
-	}),
-	cause: S.Defect()
-}) {
-	get message() {
-		return `Failed to parse ${this.fileName} at ${this.location.line}:${this.location.column}: ${this.message}`;
-	}
-};
-S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParserNotFound")("ParserNotFound", {
-	fileName: S.String,
-	extension: S.String,
-	cause: S.Defect()
-});
-var SvelteVersionNotSupported = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteVersionNotSupported")("SvelteVersionNotSupported", {
-	version: S.String,
-	fileName: S.String,
-	cause: S.Defect()
-}) {
-	get message() {
-		return `Svelte version ${this.version} is not supported for ${this.fileName} (expected >=3.30)`;
-	}
-};
-var SvelteWalkerNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteWalkerNotFound")("SvelteWalkerNotFound", {
-	fileName: S.String,
-	cause: S.Defect()
-}) {
-	get message() {
-		return `Svelte walker not found for ${this.fileName}`;
-	}
-};
-S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteParseFailed")("SvelteParseFailed", {
-	fileName: S.String,
-	cause: S.Defect()
-});
 S.Literals([
 	"html",
 	"js",
@@ -226,20 +181,538 @@ function isLineBreak(ch) {
 	return ch === CharacterCodes.lineFeed || ch === CharacterCodes.carriageReturn || ch === CharacterCodes.lineSeparator || ch === CharacterCodes.paragraphSeparator;
 }
 //#endregion
+//#region src/estree.ts
+const EXPRESSION_KINDS = /* @__PURE__ */ new Set([
+	"ArrayExpression",
+	"ArrowFunctionExpression",
+	"AwaitExpression",
+	"BinaryExpression",
+	"CallExpression",
+	"ChainExpression",
+	"ClassExpression",
+	"ConditionalExpression",
+	"FunctionExpression",
+	"Identifier",
+	"Import",
+	"ImportExpression",
+	"JSXElement",
+	"JSXFragment",
+	"Literal",
+	"LogicalExpression",
+	"MetaProperty",
+	"NewExpression",
+	"ObjectExpression",
+	"PrivateIdentifier",
+	"SequenceExpression",
+	"Super",
+	"TaggedTemplateExpression",
+	"TemplateLiteral",
+	"ThisExpression",
+	"TSAsExpression",
+	"TSInstantiationExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"UnaryExpression",
+	"UpdateExpression",
+	"YieldExpression"
+]);
+const STATEMENT_KINDS = /* @__PURE__ */ new Set([
+	"BlockStatement",
+	"BreakStatement",
+	"ClassDeclaration",
+	"ContinueStatement",
+	"DebuggerStatement",
+	"DoWhileStatement",
+	"ExportAllDeclaration",
+	"ExportDefaultDeclaration",
+	"ExportNamedDeclaration",
+	"ExpressionStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"FunctionDeclaration",
+	"IfStatement",
+	"ImportDeclaration",
+	"LabeledStatement",
+	"ReturnStatement",
+	"SwitchStatement",
+	"ThrowStatement",
+	"TSExportAssignment",
+	"TSImportEqualsDeclaration",
+	"TSInterfaceDeclaration",
+	"TSModuleDeclaration",
+	"TSTypeAliasDeclaration",
+	"VariableDeclaration",
+	"WhileStatement",
+	"WithStatement"
+]);
+/**
+* The node's [start, end) offsets. oxc is invoked with `range: true`, so every
+* parsed node carries one; synthesized builders omit it.
+*/
+function spanOf(node) {
+	const range = node.range;
+	if (range === void 0) return void 0;
+	return {
+		start: range[0],
+		end: range[1]
+	};
+}
+/**
+* The node's `type` tag, for checks against kinds outside the @types/estree
+* union (TS and JSX extensions oxc emits).
+*/
+function nodeType(node) {
+	return isAstNode(node) ? node.type : void 0;
+}
+function isExpressionKind(node) {
+	return node !== void 0 && node !== null && EXPRESSION_KINDS.has(node.type);
+}
+function isStatementKind(node) {
+	return node !== void 0 && node !== null && STATEMENT_KINDS.has(node.type);
+}
+function mark(node, loc) {
+	if (loc !== void 0) return Object.assign(node, {
+		start: loc.start,
+		end: loc.end
+	});
+	return node;
+}
+function identifier(name, loc) {
+	return mark({
+		type: "Identifier",
+		name
+	}, loc);
+}
+function stringLiteral(value, loc) {
+	return mark({
+		type: "Literal",
+		value
+	}, loc);
+}
+function booleanLiteral(value, loc) {
+	return mark({
+		type: "Literal",
+		value
+	}, loc);
+}
+function regExpLiteral(pattern, flags, loc) {
+	return mark({
+		type: "Literal",
+		value: null,
+		regex: {
+			pattern,
+			flags
+		}
+	}, loc);
+}
+function arrayExpression(elements = [], loc) {
+	const elementList = [];
+	for (const element of elements) if (element !== null) elementList.push(element);
+	return mark({
+		type: "ArrayExpression",
+		elements: elementList
+	}, loc);
+}
+function callExpression(callee, args = [], optional = false, loc) {
+	return mark({
+		type: "CallExpression",
+		callee,
+		arguments: [...args],
+		optional
+	}, loc);
+}
+function newExpression(callee, args = [], loc) {
+	return mark({
+		type: "NewExpression",
+		callee,
+		arguments: [...args]
+	}, loc);
+}
+function memberExpression(object, property, computed = false, optional = false, loc) {
+	return mark({
+		type: "MemberExpression",
+		object,
+		property,
+		computed,
+		optional
+	}, loc);
+}
+function arrowFunctionExpression(params, body, loc) {
+	const fnBody = body;
+	return mark({
+		type: "ArrowFunctionExpression",
+		params: [...params],
+		body: fnBody,
+		async: false,
+		expression: fnBody.type !== "BlockStatement"
+	}, loc);
+}
+function blockStatement(body, loc) {
+	return mark({
+		type: "BlockStatement",
+		body: [...body]
+	}, loc);
+}
+function expressionStatement(expression, loc) {
+	return mark({
+		type: "ExpressionStatement",
+		expression
+	}, loc);
+}
+function ifStatement(test, consequent, alternate, loc) {
+	return mark({
+		type: "IfStatement",
+		test,
+		consequent,
+		alternate: alternate ?? null
+	}, loc);
+}
+function variableDeclarator(id, init, loc) {
+	return mark({
+		type: "VariableDeclarator",
+		id,
+		init
+	}, loc);
+}
+function variableDeclaration(kind, declarations, loc) {
+	return mark({
+		type: "VariableDeclaration",
+		kind,
+		declarations: [...declarations]
+	}, loc);
+}
+function returnStatement(argument, loc) {
+	return mark({
+		type: "ReturnStatement",
+		argument
+	}, loc);
+}
+function sequenceExpression(expressions, loc) {
+	return mark({
+		type: "SequenceExpression",
+		expressions: [...expressions]
+	}, loc);
+}
+function conditionalExpression(test, consequent, alternate, loc) {
+	return mark({
+		type: "ConditionalExpression",
+		test,
+		consequent,
+		alternate
+	}, loc);
+}
+function unaryExpression(operator, argument, loc) {
+	return mark({
+		type: "UnaryExpression",
+		operator,
+		argument,
+		prefix: true
+	}, loc);
+}
+function updateExpression(operator, argument, prefix, loc) {
+	return mark({
+		type: "UpdateExpression",
+		operator,
+		argument,
+		prefix
+	}, loc);
+}
+function templateElement(raw, loc) {
+	return mark({
+		type: "TemplateElement",
+		value: {
+			raw,
+			cooked: raw
+		},
+		tail: true
+	}, loc);
+}
+function templateLiteral(quasis, expressions, loc) {
+	return mark({
+		type: "TemplateLiteral",
+		quasis: [...quasis],
+		expressions: [...expressions]
+	}, loc);
+}
+function switchCase(test, consequent, loc) {
+	return mark({
+		type: "SwitchCase",
+		test,
+		consequent: [...consequent]
+	}, loc);
+}
+/**
+* Deep clone of a plain ESTree node. oxc nodes are JSON-shaped, so
+* Deep clone over plain nodes: no prototypes to preserve.
+*/
+function cloneNode(node) {
+	return structuredClone(node);
+}
+/**
+* Attaches every comment to the node it precedes (`leadingComments`) or, when
+* no node follows it, to the node it trails (`trailingComments`). oxc ships
+* comments flat, and the Stryker directive pass reads `node.leadingComments`,
+* so the flat list is folded into the tree once per transform with the file's
+* line table in hand.
+*/
+function attachComments(root, comments, lineTable) {
+	if (comments.length === 0) return;
+	const nodes = collectNodes(root).filter((entry) => entry.node !== root);
+	nodes.sort((a, b) => a.start - b.start);
+	const leading = /* @__PURE__ */ new Map();
+	const trailing = /* @__PURE__ */ new Map();
+	for (const comment of comments) {
+		const next = nodes.find((entry) => entry.start >= comment.end);
+		if (next !== void 0) pushComment(leading, next.node, comment);
+		else {
+			const previous = nodes.findLast((entry) => entry.end <= comment.start && isStatementKind(entry.node));
+			if (previous !== void 0) pushComment(trailing, previous.node, comment);
+		}
+	}
+	assignComments(leading, lineTable, "leadingComments");
+	assignComments(trailing, lineTable, "trailingComments");
+}
+function assignComments(map, lineTable, field) {
+	for (const [node, list] of map) {
+		const located = list.map((comment) => ({
+			...comment,
+			loc: {
+				start: positionFromLineTable(comment.start, lineTable),
+				end: positionFromLineTable(comment.end, lineTable)
+			}
+		}));
+		Object.assign(node, { [field]: located });
+	}
+}
+function pushComment(map, node, comment) {
+	const list = map.get(node);
+	if (list === void 0) map.set(node, [comment]);
+	else list.push(comment);
+}
+function collectNodes(node) {
+	const out = [];
+	collect$1(node, out);
+	return out;
+}
+function collect$1(node, out) {
+	if (Array.isArray(node)) {
+		for (const item of node) collect$1(item, out);
+		return;
+	}
+	if (!isAstNode(node)) return;
+	const startOffset = node["start"];
+	const endOffset = node["end"];
+	if (typeof startOffset === "number" && typeof endOffset === "number") out.push({
+		node,
+		start: startOffset,
+		end: endOffset
+	});
+	for (const key of Object.keys(node)) {
+		if (key === "leadingComments" || key === "trailingComments") continue;
+		collect$1(node[key], out);
+	}
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function buildLineTable(content) {
+	return computeLineStarts(content);
+}
+function positionFromLineTable(offset, lineTable) {
+	const zeroBased = positionFromOffset(lineTable, offset);
+	return {
+		line: zeroBased.line + 1,
+		column: zeroBased.column
+	};
+}
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"start",
+	"end",
+	"range",
+	"loc",
+	"leadingComments",
+	"trailingComments"
+]);
+function traverse(root, visitors) {
+	visit(root, null, "root", void 0, visitors, {
+		skipped: /* @__PURE__ */ new Set(),
+		stopped: false
+	});
+}
+function visit(node, parentPath, key, listKey, visitors, context) {
+	if (context.stopped) return;
+	if (!isAstNode(node) || context.skipped.has(node)) return;
+	const path = createPath(node, parentPath, key, listKey, context);
+	visitors.enter?.(path);
+	if (context.stopped || context.skipped.has(node)) return;
+	visitChildren(node, path, visitors, context);
+	if (context.stopped) return;
+	visitors.exit?.(path);
+}
+function visitChildren(node, path, visitors, context) {
+	for (const childKey of Object.keys(node)) {
+		if (SKIP_KEYS.has(childKey)) continue;
+		visitChild(node[childKey], path, childKey, visitors, context);
+		if (context.stopped) return;
+	}
+}
+function visitChild(child, path, key, visitors, context) {
+	if (Array.isArray(child)) {
+		for (let i = 0; i < child.length; i++) {
+			visit(child[i], path, key, String(i), visitors, context);
+			if (context.stopped) return;
+		}
+		return;
+	}
+	if (isAstNode(child)) visit(child, path, key, void 0, visitors, context);
+}
+function createPath(node, parentPath, key, listKey, context) {
+	const path = {
+		node,
+		parentPath,
+		parent: parentPath?.node,
+		key,
+		listKey,
+		skip() {
+			context.skipped.add(node);
+		},
+		stop() {
+			context.stopped = true;
+		},
+		find(predicate) {
+			let current = path;
+			while (current !== null) {
+				if (predicate(current)) return current;
+				current = current.parentPath;
+			}
+		},
+		getStatementParent() {
+			let current = parentPath;
+			while (current !== null) {
+				if (isStatementKind(current.node)) return current;
+				current = current.parentPath;
+			}
+		},
+		replaceWith(replacement) {
+			replaceInParent(parentPath, key, listKey, replacement);
+		},
+		is(kind) {
+			return node.type === kind;
+		},
+		isExpression() {
+			return isExpressionKind(node);
+		},
+		isStatement() {
+			return isStatementKind(node);
+		}
+	};
+	return path;
+}
+function replaceInParent(parentPath, key, listKey, replacement) {
+	if (parentPath === null) return;
+	const parent = parentPath.node;
+	if (!isAstNode(parent)) return;
+	if (listKey === void 0) {
+		parent[key] = replacement;
+		return;
+	}
+	const index = Number(listKey);
+	const container = parent[key];
+	if (Array.isArray(container) && Number.isInteger(index)) container[index] = replacement;
+}
+//#endregion
+//#region src/Parser.schema.ts
+var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParseFailed")("ParseFailed", {
+	fileName: S.String,
+	message: S.String,
+	location: S.Struct({
+		line: S.Finite,
+		column: S.Finite
+	}),
+	cause: S.Defect()
+}) {
+	get message() {
+		return `Failed to parse ${this.fileName} at ${this.location.line}:${this.location.column}: ${this.message}`;
+	}
+};
+var ParserNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParserNotFound")("ParserNotFound", {
+	fileName: S.String,
+	extension: S.String,
+	cause: S.Defect()
+}) {
+	get message() {
+		return `No parser registered for ${this.fileName} (extension "${this.extension}")`;
+	}
+};
+var SvelteVersionNotSupported = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteVersionNotSupported")("SvelteVersionNotSupported", {
+	version: S.String,
+	fileName: S.String,
+	cause: S.Defect()
+}) {
+	get message() {
+		return `Svelte version ${this.version} is not supported for ${this.fileName} (expected >=3.30)`;
+	}
+};
+var SvelteWalkerNotFound = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteWalkerNotFound")("SvelteWalkerNotFound", {
+	fileName: S.String,
+	cause: S.Defect()
+}) {
+	get message() {
+		return `Svelte walker not found for ${this.fileName}`;
+	}
+};
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteParseFailed")("SvelteParseFailed", {
+	fileName: S.String,
+	cause: S.Defect()
+});
+//#endregion
 //#region src/Parser.ts
+function parseWithOxc(text, fileName, lang) {
+	const result = parseSync(fileName, text, {
+		lang,
+		range: true
+	});
+	if (result.errors.length > 0) {
+		const first = result.errors[0];
+		const label = first?.labels[0];
+		const position = positionFromLineTable(label?.start ?? 0, buildLineTable(text));
+		throw new ParseFailed({
+			fileName,
+			message: first?.message ?? "unknown parse error",
+			location: position,
+			cause: result.errors.map((error) => error.message)
+		});
+	}
+	return {
+		root: result.program,
+		comments: result.comments
+	};
+}
 /**
-* Parser — all parsers that turn source text into the instrumenter's ASTs.
+* Shifts a parsed script's root span by the offset of the script tag inside
+* the embedding document (html/svelte), so range math against the raw
+* document stays consistent. Child nodes keep their script-relative offsets —
+* mutant positions are re-mapped through the AST's `offset` field.
 */
-const { types: types$1, parseAsync } = babel;
-const require = createRequire(import.meta.url);
-function createParser(parserOptions) {
-	const jsParse = createJSParser(parserOptions);
+function shiftScriptOffsets(ast, offset) {
+	const root = ast.root;
+	if (typeof root === "object" && root !== null && "start" in root && "end" in root && typeof root.start === "number" && typeof root.end === "number") {
+		root.start += offset;
+		root.end += offset;
+	}
+}
+function createParser() {
+	const jsParse = createJSParser();
 	async function parse(code, fileName, formatOverride) {
 		const format = getFormat(fileName, formatOverride);
-		if (!format) {
-			const ext = path.extname(fileName).toLowerCase();
-			throw new Error(`Unable to parse ${fileName}. No parser registered for ${ext}!`);
-		}
+		if (!format) throw new ParserNotFound({
+			fileName,
+			extension: path.extname(fileName).toLowerCase(),
+			cause: void 0
+		});
 		switch (format) {
 			case "js": return jsParse(code, fileName);
 			case "tsx": return parseTsx(code, fileName);
@@ -269,97 +742,38 @@ function getFormat(fileName, override) {
 		default: return;
 	}
 }
-function isParserPlugin(value) {
-	return typeof value === "string" || Array.isArray(value);
-}
-function isParserPluginArray(value) {
-	return value.every(isParserPlugin);
-}
-function getParserPlugins(override) {
-	if (override === null) return defaultPlugins;
-	if (isParserPluginArray(override)) return override;
-	throw new Error("Invalid parser plugins: expected ParserPlugin[]");
-}
-const defaultPlugins = [
-	"doExpressions",
-	"objectRestSpread",
-	"classProperties",
-	"exportDefaultFrom",
-	"exportNamespaceFrom",
-	"asyncGenerators",
-	"functionBind",
-	"functionSent",
-	"dynamicImport",
-	"numericSeparator",
-	"importMeta",
-	"optionalCatchBinding",
-	"optionalChaining",
-	"classPrivateProperties",
-	["pipelineOperator", { proposal: "minimal" }],
-	"nullishCoalescingOperator",
-	"bigInt",
-	"throwExpressions",
-	"logicalAssignment",
-	"classPrivateMethods",
-	"v8intrinsic",
-	"partialApplication",
-	["decorators", { decoratorsBeforeExport: false }],
-	"jsx"
-];
-function createJSParser({ plugins: pluginsOverride }) {
+function createJSParser() {
 	return async function parse(text, fileName) {
-		const plugins = getParserPlugins(pluginsOverride);
-		const ast = await parseAsync(text, {
-			parserOpts: { plugins: [...plugins] },
-			filename: fileName,
-			sourceType: "module"
-		});
-		if (ast === null) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
+		const { root, comments } = parseWithOxc(text, fileName, "js");
 		return {
 			originFileName: fileName,
 			rawContent: text,
 			format: "js",
-			root: ast
+			root,
+			comments
 		};
 	};
 }
-/**
-* See https://babeljs.io/docs/en/babel-preset-typescript
-* @param text The text to parse
-* @param fileName The name of the file
-*/
 async function parseTS(text, fileName) {
+	const { root, comments } = parseWithOxc(text, fileName, "ts");
 	return {
 		originFileName: fileName,
 		rawContent: text,
 		format: "ts",
-		root: await parseTSInternal(text, fileName, false)
+		root,
+		comments
 	};
 }
 async function parseTsx(text, fileName) {
+	const { root, comments } = parseWithOxc(text, fileName, "tsx");
 	return {
-		root: await parseTSInternal(text, fileName, true),
+		root,
+		comments,
 		format: "tsx",
 		originFileName: fileName,
 		rawContent: text
 	};
 }
-async function parseTSInternal(text, fileName, isTSX) {
-	const ast = await parseAsync(text, {
-		filename: fileName,
-		parserOpts: { ranges: true },
-		configFile: false,
-		babelrc: false,
-		presets: [[require.resolve("@babel/preset-typescript"), {
-			isTSX,
-			allExtensions: true
-		}]],
-		plugins: [[require.resolve("@babel/plugin-proposal-decorators"), { legacy: true }], [require.resolve("@babel/plugin-transform-explicit-resource-management")]]
-	});
-	if (ast === null) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
-	if (types$1.isProgram(ast)) throw new Error(`Expected ${fileName} to contain a babel.types.file, but was a program`);
-	return ast;
-}
 const TSX_SCRIPT_TYPES = Object.freeze(["tsx", "text/tsx"]);
 const TS_SCRIPT_TYPES = Object.freeze([
 	"ts",
@@ -434,12 +848,7 @@ async function ngHtmlParser(text, fileName, parserContext) {
 		const ast = await parserContext.parse(content, fileName, scriptFormat);
 		if (ast !== null && ast !== void 0) {
 			const offset = el.startSourceSpan.end;
-			const rootStart = ast.root.start;
-			if (rootStart == null) throw new Error("Babel File node without a start offset");
-			const rootEnd = ast.root.end;
-			if (rootEnd == null) throw new Error("Babel File node without an end offset");
-			ast.root.start = rootStart + offset.offset;
-			ast.root.end = rootEnd + offset.offset;
+			shiftScriptOffsets(ast, offset.offset);
 			return {
 				...ast,
 				offset: {
@@ -544,162 +953,2171 @@ async function parseSvelte(text, fileName, context) {
 		});
 		walk = svelteCompilerModule["walk"];
 	}
-	const lineStarts = computeLineStarts(text);
-	const { replacedCode, scriptMap } = await replaceScripts(text);
-	const svelteAst = svelteParse(replacedCode, { filename: fileName });
-	const { remappedModuleScriptRange, remappedScriptRanges } = remapScriptLocations(replacedCode, scriptMap, getModuleScriptRange(svelteAst), getTemplateScriptRanges(svelteAst, walk));
-	const [moduleScript, ...additionalScripts] = await Promise.all([parseTemplateScriptIfDefined(remappedModuleScriptRange), ...remappedScriptRanges.map(parseTemplateScript)]);
-	let root;
-	if (moduleScript === void 0) root = { additionalScripts };
-	else root = {
-		moduleScript,
-		additionalScripts
-	};
-	return {
-		originFileName: fileName,
-		rawContent: text,
-		format: "svelte",
-		root
-	};
-	/**
-	* Replaces script tags with placeholders.
-	* This is needed, because svelte's `parse` doesn't support `lang="ts"`.
-	*/
-	async function replaceScripts(code) {
-		const map = /* @__PURE__ */ new Map();
-		let scriptIndex = 0;
-		return {
-			replacedCode: (await preprocess(code, { script(script) {
-				const scriptName = `script${scriptIndex++}`;
-				map.set(scriptName, script);
-				return { code: scriptName };
-			} })).code,
-			scriptMap: map
-		};
+	const lineStarts = computeLineStarts(text);
+	const { replacedCode, scriptMap } = await replaceScripts(text);
+	const svelteAst = svelteParse(replacedCode, { filename: fileName });
+	const { remappedModuleScriptRange, remappedScriptRanges } = remapScriptLocations(replacedCode, scriptMap, getModuleScriptRange(svelteAst), getTemplateScriptRanges(svelteAst, walk));
+	const [moduleScript, ...additionalScripts] = await Promise.all([parseTemplateScriptIfDefined(remappedModuleScriptRange), ...remappedScriptRanges.map(parseTemplateScript)]);
+	let root;
+	if (moduleScript === void 0) root = { additionalScripts };
+	else root = {
+		moduleScript,
+		additionalScripts
+	};
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "svelte",
+		root
+	};
+	/**
+	* Replaces script tags with placeholders.
+	* This is needed, because svelte's `parse` doesn't support `lang="ts"`.
+	*/
+	async function replaceScripts(code) {
+		const map = /* @__PURE__ */ new Map();
+		let scriptIndex = 0;
+		return {
+			replacedCode: (await preprocess(code, { script(script) {
+				const scriptName = `script${scriptIndex++}`;
+				map.set(scriptName, script);
+				return { code: scriptName };
+			} })).code,
+			scriptMap: map
+		};
+	}
+	function getTemplateScriptRanges(ast, walker) {
+		const ranges = [];
+		if (isPlainRecord(ast) && ast["instance"] !== null && ast["instance"] !== void 0) {
+			const instance = ast["instance"];
+			if (isPlainRecord(instance) && "content" in instance) {
+				const content = instance["content"];
+				if (isRangedProgram(content)) ranges.push({
+					start: content.start,
+					end: content.end,
+					isExpression: false
+				});
+				else throw new Error("Svelte instance script without a source range");
+			}
+		}
+		if (!isPlainRecord(ast) || !("html" in ast)) throw new Error("Svelte AST without html");
+		const html = ast["html"];
+		walker(html, { enter(node) {
+			const scriptRange = tryGetScriptRangeFromElement(node);
+			if (scriptRange) ranges.push(scriptRange);
+			const templateExpression = collectTemplateExpression(node);
+			if (templateExpression) {
+				const { start, end } = templateExpression;
+				ranges.push({
+					start,
+					end,
+					isExpression: true
+				});
+			}
+		} });
+		return ranges;
+	}
+	async function parseTemplateScriptIfDefined(range) {
+		if (range) return parseTemplateScript(range);
+	}
+	async function parseTemplateScript({ start, end, isExpression, format }) {
+		const scriptText = text.slice(start, end);
+		return {
+			ast: {
+				...await context.parse(scriptText, fileName, format),
+				offset: positionFromOffset(lineStarts, start)
+			},
+			range: {
+				start,
+				end
+			},
+			isExpression
+		};
+	}
+}
+function getModuleScriptRange(svelteAst) {
+	if (!isPlainRecord(svelteAst) || !("module" in svelteAst) || svelteAst["module"] === null || svelteAst["module"] === void 0) return;
+	const mod = svelteAst["module"];
+	if (!isPlainRecord(mod) || !("content" in mod)) throw new Error("Svelte module script without a source range");
+	const content = mod["content"];
+	if (!isRangedProgram(content)) throw new Error("Svelte module script without a source range");
+	return {
+		start: content.start,
+		end: content.end,
+		isExpression: false
+	};
+}
+/**
+* Remaps script locations back to the original places using the script map
+*/
+function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges) {
+	const scriptRanges = [moduleScriptRange, ...templateRanges].filter(Predicate.isNotNullish).sort((a, b) => a.start - b.start);
+	let offset = 0;
+	let newModuleScriptRange;
+	const newScriptRanges = scriptRanges.map((range) => {
+		const script = code.substring(range.start, range.end);
+		const actualScript = scriptMap.get(script);
+		const start = range.start + offset;
+		if (actualScript) {
+			let langFormat = "js";
+			if (actualScript.attributes["lang"] === "ts") langFormat = "ts";
+			const scriptRange = {
+				start,
+				end: start + actualScript.content.length,
+				isExpression: range.isExpression,
+				format: langFormat
+			};
+			offset += actualScript.content.length - script.length;
+			if (range === moduleScriptRange) newModuleScriptRange = scriptRange;
+			return scriptRange;
+		} else return {
+			start,
+			end: start + script.length,
+			isExpression: range.isExpression,
+			format: "js"
+		};
+	});
+	return {
+		remappedModuleScriptRange: newModuleScriptRange,
+		remappedScriptRanges: newScriptRanges.filter((range) => range !== newModuleScriptRange)
+	};
+}
+function collectTemplateExpression(node) {
+	if (!isPlainRecord(node) || typeof node["type"] !== "string") return;
+	if (!isTemplateExpressionType(node["type"])) return;
+	if (!("expression" in node)) return;
+	const expression = node["expression"];
+	if (isRangedBaseNode(expression)) return expression;
+}
+//#endregion
+//#region src/print/index.ts
+function printProgram(program, opts = {}) {
+	return new PrintState(opts).printProgram(program);
+}
+function printNode(node, opts = {}) {
+	return new PrintState(opts).printAnyNode(node);
+}
+const PREC = {
+	Sequence: 0,
+	Assignment: 1,
+	Conditional: 2,
+	NullishCoalescing: 3,
+	LogicalOR: 4,
+	LogicalAND: 5,
+	BitwiseOR: 6,
+	BitwiseXOR: 7,
+	BitwiseAND: 8,
+	Equality: 9,
+	Relational: 10,
+	Shift: 11,
+	Additive: 12,
+	Multiplicative: 13,
+	Exponential: 14,
+	Unary: 15,
+	Update: 16,
+	Call: 17,
+	Member: 18,
+	Primary: 19
+};
+function binaryPrec(op) {
+	switch (op) {
+		case "||": return PREC.LogicalOR;
+		case "&&": return PREC.LogicalAND;
+		case "??": return PREC.NullishCoalescing;
+		case "|": return PREC.BitwiseOR;
+		case "^": return PREC.BitwiseXOR;
+		case "&": return PREC.BitwiseAND;
+		case "==":
+		case "!=":
+		case "===":
+		case "!==": return PREC.Equality;
+		case "<":
+		case ">":
+		case "<=":
+		case ">=":
+		case "in":
+		case "instanceof": return PREC.Relational;
+		case "<<":
+		case ">>":
+		case ">>>": return PREC.Shift;
+		case "+":
+		case "-": return PREC.Additive;
+		case "*":
+		case "/":
+		case "%": return PREC.Multiplicative;
+		case "**": return PREC.Exponential;
+		default: return PREC.Additive;
+	}
+}
+function logicalPrec(op) {
+	if (op === "??") return PREC.NullishCoalescing;
+	if (op === "||") return PREC.LogicalOR;
+	return PREC.LogicalAND;
+}
+var PrintState = class {
+	out = "";
+	indentLevel = 0;
+	comments;
+	hashbang;
+	commentIdx = 0;
+	sortedComments;
+	constructor(opts) {
+		this.comments = opts.comments ?? [];
+		this.hashbang = opts.hashbang ?? null;
+		const filtered = this.hashbang ? this.comments.filter((c) => !(c.type === "Line" && c.start === this.hashbang.start)) : this.comments;
+		this.sortedComments = [...filtered].sort((a, b) => a.start - b.start);
+	}
+	printProgram(program) {
+		this.out = "";
+		this.indentLevel = 0;
+		this.commentIdx = 0;
+		if (this.hashbang) this.out += `#!${this.hashbang.value}\n`;
+		this.emitCommentsBefore(this.firstStatementStart(program));
+		for (let i = 0; i < program.body.length; i++) {
+			const stmt = program.body[i];
+			this.emitCommentsBefore(stmt.start ?? -1);
+			this.printStatement(stmt);
+			if (i < program.body.length - 1) this.out += "\n";
+			else this.out += "\n";
+		}
+		this.emitRemainingComments();
+		return this.out;
+	}
+	printAnyNode(node) {
+		this.out = "";
+		this.indentLevel = 0;
+		this.printNode(node, PREC.Sequence);
+		return this.out;
+	}
+	firstStatementStart(program) {
+		if (program.body.length === 0) return Number.POSITIVE_INFINITY;
+		return program.body[0].start ?? Number.POSITIVE_INFINITY;
+	}
+	emitCommentsBefore(pos) {
+		if (pos < 0 || !Number.isFinite(pos)) return;
+		while (this.commentIdx < this.sortedComments.length) {
+			const c = this.sortedComments[this.commentIdx];
+			if (c.start >= pos) break;
+			this.emitComment(c);
+			this.commentIdx++;
+		}
+	}
+	emitRemainingComments() {
+		while (this.commentIdx < this.sortedComments.length) {
+			const c = this.sortedComments[this.commentIdx];
+			this.emitComment(c);
+			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";
+	}
+	needsParens(childPrec, parentPrec, isRight, op) {
+		if (childPrec < parentPrec) return true;
+		if (childPrec > parentPrec) return false;
+		if (op === "**") return !isRight;
+		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) {
+		const saved = this.out;
+		this.out = "";
+		this.printNode(node, prec);
+		const result = this.out;
+		this.out = saved;
+		return result;
+	}
+	printNode(node, prec) {
+		if (!node) return;
+		const t = node.type;
+		if (t === "Literal") {
+			this.printLiteral(node);
+			return;
+		}
+		switch (t) {
+			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);
+				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);
+				if (node.argument === null) {}
+				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.out += "continue";
+				if (node.label) this.out += ` ${node.label.name}`;
+				this.out += ";";
+				break;
+			case "BreakStatement":
+				this.out += "break";
+				if (node.label) this.out += ` ${node.label.name}`;
+				this.out += ";";
+				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: if (isTSTypeNode(t)) this.printTSType(node);
+			else if (t === "TSTypeAnnotation") {
+				this.out += ": ";
+				this.printTSType(node.typeAnnotation);
+			} else if (t === "TSTypeParameterDeclaration") this.printTSTypeParameterDeclaration(node);
+			else if (t === "TSTypeParameterInstantiation") this.printTSTypeParameterInstantiation(node);
+			else if (t === "TSTypeParameter") this.printTSTypeParameter(node);
+			else this.out += `/* unknown:${t} */`;
+		}
+	}
+	printLiteral(node) {
+		if (node.raw != null) {
+			this.out += node.raw;
+			return;
+		}
+		if (node.regex) {
+			this.out += `/${node.regex.pattern}/${node.regex.flags}`;
+			return;
+		}
+		if (node.bigint != null) {
+			this.out += node.bigint;
+			return;
+		}
+		const v = node.value;
+		if (v === null) this.out += "null";
+		else if (typeof v === "string") this.out += JSON.stringify(v);
+		else if (typeof v === "number") this.out += String(v);
+		else if (typeof v === "boolean") this.out += v ? "true" : "false";
+		else if (typeof v === "bigint") this.out += `${v}n`;
+		else this.out += "null";
+	}
+	printIdentifier(node) {
+		this.out += node.name;
+	}
+	printArrayExpression(node) {
+		this.out += "[";
+		for (let i = 0; i < node.elements.length; i++) {
+			if (i > 0) this.out += ", ";
+			const el = node.elements[i];
+			if (el === null) continue;
+			this.printNode(el, PREC.Assignment);
+		}
+		this.out += "]";
+	}
+	printObjectExpression(node) {
+		if (node.properties.length === 0) {
+			this.out += "{}";
+			return;
+		}
+		this.out += "{ ";
+		for (let i = 0; i < node.properties.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printNode(node.properties[i], PREC.Sequence);
+		}
+		this.out += " }";
+	}
+	printProperty(node) {
+		const n = node;
+		const kind = n["kind"];
+		const method = n["method"];
+		const shorthand = n["shorthand"];
+		const computed = n["computed"];
+		const key = n["key"];
+		const value = n["value"];
+		if (kind === "get" || kind === "set") {
+			this.out += `${kind} `;
+			this.printPropertyKey(key, !!computed);
+			this.printFunctionValue(value);
+			return;
+		}
+		if (method) {
+			if (n["async"]) this.out += "async ";
+			if (n["generator"]) this.out += "*";
+			this.printPropertyKey(key, !!computed);
+			this.printFunctionValue(value);
+			return;
+		}
+		if (shorthand && key.type === "Identifier" && value && value.type === "Identifier") {
+			const kName = key.name;
+			if (kName === value.name) {
+				this.out += kName;
+				return;
+			}
+		}
+		const defaultPattern = value;
+		if (shorthand && key.type === "Identifier" && defaultPattern && defaultPattern.type === "AssignmentPattern" && defaultPattern.left.type === "Identifier" && defaultPattern.left.name === key.name) {
+			const kName = key.name;
+			const savedOut = this.out;
+			this.out = "";
+			this.printNode(defaultPattern.right, PREC.Assignment);
+			const rightStr = this.out;
+			this.out = savedOut;
+			this.out += `${kName} = ${rightStr}`;
+			return;
+		}
+		this.printPropertyKey(key, !!computed);
+		this.out += ": ";
+		if (value) this.printNode(value, PREC.Assignment);
+	}
+	printPropertyKey(key, computed) {
+		if (computed) {
+			this.out += "[";
+			this.printNode(key, PREC.Assignment);
+			this.out += "]";
+		} else if (key.type === "Identifier") this.out += key.name;
+		else if (key.type === "PrivateIdentifier") this.out += `#${key.name}`;
+		else if (key.type === "Literal") this.printLiteral(key);
+		else this.printNode(key, PREC.Assignment);
+	}
+	printFunctionValue(fn) {
+		if (!fn) return;
+		if (fn.typeParameters) this.printTSTypeParameterDeclaration(fn.typeParameters);
+		this.out += "(";
+		this.printParams(fn.params);
+		this.out += ")";
+		if (fn.returnType) this.printTSTypeAnnotation(fn.returnType);
+		if (fn.body) {
+			this.out += " ";
+			this.printBlockStatement(fn.body);
+		} else this.out += ";";
+	}
+	printTemplateLiteral(node) {
+		this.out += "`";
+		for (let i = 0; i < node.quasis.length; i++) {
+			const q = node.quasis[i];
+			this.out += q.value.raw;
+			if (!q.tail) {
+				this.out += "${";
+				this.printNode(node.expressions[i], PREC.Sequence);
+				this.out += "}";
+			}
+		}
+		this.out += "`";
+	}
+	printTaggedTemplate(node) {
+		this.printNode(node.tag, PREC.Member);
+		if (node.typeArguments) this.printTSTypeParameterInstantiation(node.typeArguments);
+		this.printTemplateLiteral(node.quasi);
+	}
+	printMemberExpression(node, prec = PREC.Member) {
+		const n = node;
+		const computed = n["computed"];
+		const optional = n["optional"];
+		const object = n["object"];
+		const property = n["property"];
+		const objStr = this.printExpressionToString(object, PREC.Member);
+		const objOut = needsParensForMemberObject(object) ? `(${objStr})` : objStr;
+		if (optional) {
+			if (computed) {
+				this.out += `${objOut}?.[`;
+				this.printNode(property, PREC.Sequence);
+				this.out += "]";
+			} else {
+				const propName = property.type === "Identifier" ? property.name : property.type === "PrivateIdentifier" ? `#${property.name}` : "";
+				if (propName) this.out += `${objOut}?.${propName}`;
+				else {
+					this.out += `${objOut}?.`;
+					this.printNode(property, PREC.Sequence);
+				}
+			}
+		} else if (computed) {
+			this.out += `${objOut}[`;
+			this.printNode(property, PREC.Sequence);
+			this.out += "]";
+		} else {
+			const propName = property.type === "Identifier" ? property.name : property.type === "PrivateIdentifier" ? `#${property.name}` : "";
+			if (propName) this.out += `${objOut}.${propName}`;
+			else {
+				this.out += `${objOut}.`;
+				this.printNode(property, PREC.Sequence);
+			}
+		}
+	}
+	printCallExpression(node, prec) {
+		const calleePrec = PREC.Member;
+		const calleeStr = this.printExpressionToString(node.callee, calleePrec);
+		const calleeNeedsParen = node.callee.type === "SequenceExpression" || node.callee.type === "ConditionalExpression";
+		this.out += calleeNeedsParen ? `(${calleeStr})` : calleeStr;
+		if (node.optional) this.out += "?.";
+		if (node.typeArguments) this.printTSTypeParameterInstantiation(node.typeArguments);
+		this.out += "(";
+		for (let i = 0; i < node.arguments.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printNode(node.arguments[i], PREC.Assignment);
+		}
+		this.out += ")";
+	}
+	printNewExpression(node, prec) {
+		this.out += "new ";
+		const calleeStr = this.printExpressionToString(node.callee, PREC.Member);
+		this.out += calleeStr;
+		if (node.typeArguments) this.printTSTypeParameterInstantiation(node.typeArguments);
+		this.out += "(";
+		for (let i = 0; i < node.arguments.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printNode(node.arguments[i], PREC.Assignment);
+		}
+		this.out += ")";
+	}
+	printMetaProperty(node) {
+		this.out += `${node.meta.name}.${node.property.name}`;
+	}
+	printV8Intrinsic(node) {
+		this.out += `%${node.name.name}(`;
+		for (let i = 0; i < node.arguments.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printNode(node.arguments[i], PREC.Assignment);
+		}
+		this.out += ")";
+	}
+	printImportExpression(node) {
+		this.out += "import";
+		if (node.phase) this.out += `.${node.phase}`;
+		this.out += "(";
+		this.printNode(node.source, PREC.Assignment);
+		if (node.options) {
+			this.out += ", ";
+			this.printNode(node.options, PREC.Assignment);
+		}
+		this.out += ")";
+	}
+	printUpdateExpression(node, prec) {
+		const myPrec = PREC.Update;
+		if (node.prefix) {
+			this.out += node.operator;
+			const argStr = this.printExpressionToString(node.argument, myPrec);
+			const needsParen = needsParensForMemberObject(node.argument);
+			this.out += needsParen ? `(${argStr})` : argStr;
+		} else {
+			const argStr = this.printExpressionToString(node.argument, myPrec);
+			const needsParen = needsParensForMemberObject(node.argument);
+			this.out += needsParen ? `(${argStr})` : argStr;
+			this.out += node.operator;
+		}
+	}
+	printUnaryExpression(node, prec) {
+		const myPrec = PREC.Unary;
+		const op = node.operator;
+		const needsSpace = op === "typeof" || op === "void" || op === "delete";
+		this.out += op + (needsSpace ? " " : "");
+		const argStr = this.printExpressionToString(node.argument, myPrec);
+		const argNeedsParen = node.argument.type === "BinaryExpression" || node.argument.type === "LogicalExpression" || node.argument.type === "ConditionalExpression" || node.argument.type === "SequenceExpression";
+		this.out += argNeedsParen ? `(${argStr})` : argStr;
+	}
+	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 leftStr = this.printExpressionToString(node.left, PREC.Assignment);
+		const annotation = node.left.typeAnnotation;
+		const rightStr = this.printExpressionToString(node.right, PREC.Assignment);
+		let whole = leftStr;
+		if (annotation) {
+			const saved = this.out;
+			this.out = "";
+			this.printTSTypeAnnotation(annotation);
+			whole += this.out;
+			this.out = saved;
+		}
+		whole += ` = ${rightStr}`;
+		if (PREC.Assignment < prec) this.out += `(${whole})`;
+		else this.out += whole;
+	}
+	printObjectPattern(node) {
+		if (node.properties.length === 0) {
+			this.out += "{}";
+			return;
+		}
+		this.out += "{ ";
+		for (let i = 0; i < node.properties.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printNode(node.properties[i], PREC.Sequence);
+		}
+		this.out += " }";
+	}
+	printArrayPattern(node) {
+		this.out += "[";
+		for (let i = 0; i < node.elements.length; i++) {
+			if (i > 0) this.out += ", ";
+			const el = node.elements[i];
+			if (el === null) continue;
+			this.printNode(el, PREC.Assignment);
+		}
+		this.out += "]";
+	}
+	printSequenceExpression(node, prec) {
+		const myPrec = PREC.Sequence;
+		const parts = [];
+		for (const expr of node.expressions) parts.push(this.printExpressionToString(expr, myPrec));
+		const whole = parts.join(", ");
+		if (myPrec < prec) this.out += `(${whole})`;
+		else this.out += whole;
+	}
+	printYieldExpression(node, prec) {
+		PREC.Unary;
+		if (node.delegate) this.out += "yield*";
+		else this.out += "yield";
+		if (node.argument) {
+			this.out += " ";
+			this.printNode(node.argument, PREC.Assignment);
+		}
+	}
+	printArrowFunction(node, prec) {
+		const myPrec = PREC.Assignment;
+		let arrow = "";
+		if (node.async) arrow += "async ";
+		if (node.typeParameters) {
+			const saved = this.out;
+			this.out = "";
+			this.printTSTypeParameterDeclaration(node.typeParameters);
+			const tp = this.out;
+			this.out = saved;
+			arrow += tp;
+		}
+		const singleParam = node.params[0];
+		if (node.params.length === 1 && singleParam?.type === "Identifier" && !singleParam.typeAnnotation && !node.returnType) arrow += singleParam.name;
+		else {
+			arrow += "(";
+			const saved = this.out;
+			this.out = "";
+			this.printParams(node.params);
+			const p = this.out;
+			this.out = saved;
+			arrow += p + ")";
+		}
+		if (node.returnType) {
+			const saved = this.out;
+			this.out = "";
+			this.printTSTypeAnnotation(node.returnType);
+			const rt = this.out;
+			this.out = saved;
+			arrow += rt;
+		}
+		arrow += " => ";
+		if (typeof node.body === "object" && node.body !== null && node.body.type === "BlockStatement") {
+			const saved = this.out;
+			this.out = "";
+			this.printBlockStatement(node.body);
+			const b = this.out;
+			this.out = saved;
+			arrow += b;
+		} else {
+			const saved = this.out;
+			this.out = "";
+			this.printNode(node.body, PREC.Assignment);
+			const b = this.out;
+			this.out = saved;
+			arrow += b;
+		}
+		if (myPrec < prec) this.out += `(${arrow})`;
+		else this.out += arrow;
+	}
+	printFunction(node, _prec) {
+		if (node.declare) this.out += "declare ";
+		if (node.async) this.out += "async ";
+		this.out += "function";
+		if (node.generator) this.out += "*";
+		if (node.id) this.out += ` ${node.id.name}`;
+		if (node.typeParameters) this.printTSTypeParameterDeclaration(node.typeParameters);
+		this.out += "(";
+		this.printParams(node.params);
+		this.out += ")";
+		if (node.returnType) this.printTSTypeAnnotation(node.returnType);
+		if (node.body) {
+			this.out += " ";
+			this.printBlockStatement(node.body);
+		} else this.out += ";";
+	}
+	printClass(node, _prec) {
+		this.printDecorators(node.decorators);
+		if (node.declare) this.out += "declare ";
+		if (node.abstract) this.out += "abstract ";
+		this.out += "class";
+		if (node.id) this.out += ` ${node.id.name}`;
+		if (node.typeParameters) this.printTSTypeParameterDeclaration(node.typeParameters);
+		if (node.superClass) {
+			this.out += " extends ";
+			this.printNode(node.superClass, PREC.Assignment);
+			if (node.superTypeArguments) this.printTSTypeParameterInstantiation(node.superTypeArguments);
+		}
+		if (node.implements && node.implements.length > 0) {
+			this.out += " implements ";
+			for (let i = 0; i < node.implements.length; i++) {
+				if (i > 0) this.out += ", ";
+				const impl = node.implements[i];
+				this.printNode(impl.expression, PREC.Assignment);
+				if (impl.typeArguments) this.printTSTypeParameterInstantiation(impl.typeArguments);
+			}
+		}
+		this.out += " ";
+		this.printClassBody(node.body);
+	}
+	printDecorators(decorators) {
+		if (!decorators || decorators.length === 0) return;
+		for (const d of decorators) {
+			this.out += "@";
+			this.printNode(d.expression, PREC.Member);
+			this.out += " ";
+		}
+	}
+	printJSXElement(node) {
+		this.printJSXOpeningElement(node.openingElement);
+		for (const child of node.children) this.printJSXChild(child);
+		if (node.closingElement) {
+			this.out += `</`;
+			this.printJSXElementName(node.closingElement.name);
+			this.out += ">";
+		}
+	}
+	printJSXFragment(node) {
+		this.out += "<>";
+		for (const child of node.children) this.printJSXChild(child);
+		this.out += "</>";
+	}
+	printJSXOpeningElement(node) {
+		this.out += "<";
+		this.printJSXElementName(node.name);
+		if (node.typeArguments) this.printTSTypeParameterInstantiation(node.typeArguments);
+		for (const attr of node.attributes) {
+			this.out += " ";
+			this.printNode(attr, PREC.Sequence);
+		}
+		this.out += node.selfClosing ? " />" : ">";
+	}
+	printJSXElementName(name) {
+		if (name.type === "JSXIdentifier") this.out += name.name;
+		else if (name.type === "JSXNamespacedName") this.out += `${name.namespace.name}:${name.name.name}`;
+		else 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) {
+		const n = node.name;
+		if (n.type === "JSXIdentifier") this.out += n.name;
+		else this.out += `${n.namespace.name}:${n.name.name}`;
+		if (node.value) {
+			this.out += "=";
+			if (node.value.type === "Literal") this.printLiteral(node.value);
+			else if (node.value.type === "JSXExpressionContainer") {
+				this.out += "{";
+				this.printNode(node.value.expression, PREC.Sequence);
+				this.out += "}";
+			} else this.printNode(node.value, PREC.Sequence);
+		}
+	}
+	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: if (isTSTypeNode(n.type)) {
+				this.printTSType(n);
+				this.out += ";";
+			} else throw new Error(`Printer: unhandled statement kind ${n.type}`);
+		}
+		this.printAttachedComments(n, "trailingComments");
+	}
+	/**
+	* 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;
+		for (const comment of comments) {
+			if (field === "leadingComments") this.out += this.indent();
+			if (comment.type === "Block") this.out += `/*${comment.value}*/`;
+			else this.out += `//${comment.value}`;
+			this.out += field === "leadingComments" ? "\n" : " ";
+		}
+	}
+	printBlockStatement(node) {
+		if (node.body.length === 0) {
+			this.out += "{}";
+			return;
+		}
+		this.out += "{\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()}}`;
+	}
+	printExpressionStatement(node) {
+		if (node.directive) {
+			this.out += JSON.stringify(node.directive) + ";";
+			return;
+		}
+		this.printNode(node.expression, PREC.Sequence);
+		this.out += ";";
+	}
+	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 (";
+		if (node.init) {
+			if (node.init.type === "VariableDeclaration") this.printVariableDeclaration(node.init);
+			else this.printNode(node.init, PREC.Sequence);
+		}
+		this.out += "; ";
+		if (node.test) this.printNode(node.test, PREC.Sequence);
+		this.out += "; ";
+		if (node.update) this.printNode(node.update, PREC.Sequence);
+		this.out += ") ";
+		this.printStatementOrBlock(node.body);
+	}
+	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) {
+		this.out += node.await ? "for await (" : "for (";
+		if (node.left.type === "VariableDeclaration") this.printVariableDeclaration(node.left);
+		else this.printNode(node.left, PREC.Sequence);
+		this.out += " of ";
+		this.printNode(node.right, PREC.Sequence);
+		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.printNode(node.discriminant, PREC.Sequence);
+		this.out += ") {\n";
+		this.indentLevel++;
+		for (const c of node.cases) {
+			this.out += this.indent();
+			if (c.test) {
+				this.out += "case ";
+				this.printNode(c.test, PREC.Sequence);
+				this.out += ":\n";
+			} else this.out += "default:\n";
+			this.indentLevel++;
+			for (const stmt of c.consequent) {
+				this.out += this.indent();
+				this.printStatement(stmt);
+				this.out += "\n";
+			}
+			this.indentLevel--;
+		}
+		this.indentLevel--;
+		this.out += `${this.indent()}}`;
+	}
+	printLabeledStatement(node) {
+		this.out += `${node.label.name}: `;
+		this.printStatement(node.body);
+	}
+	printTryStatement(node) {
+		this.out += "try ";
+		this.printBlockStatement(node.block);
+		if (node.handler) {
+			this.out += " catch";
+			if (node.handler.param) {
+				this.out += " (";
+				if (node.handler.param.type === "Identifier") this.printIdentifierWithOptional(node.handler.param);
+				else this.printNode(node.handler.param, PREC.Sequence);
+				this.out += ")";
+			}
+			this.out += " ";
+			this.printBlockStatement(node.handler.body);
+		}
+		if (node.finalizer) {
+			this.out += " finally ";
+			this.printBlockStatement(node.finalizer);
+		}
+	}
+	printVariableDeclaration(node) {
+		if (node.declare) this.out += "declare ";
+		this.out += `${node.kind} `;
+		for (let i = 0; i < node.declarations.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printVariableDeclarator(node.declarations[i]);
+		}
+	}
+	printVariableDeclarator(node) {
+		const idWithType = node.id;
+		if (idWithType.type === "Identifier" && idWithType.name) {
+			this.out += idWithType.name;
+			if (idWithType.optional) this.out += "?";
+			if (node["definite"]) this.out += "!";
+			if (idWithType.typeAnnotation) this.printTSTypeAnnotation(idWithType.typeAnnotation);
+		} else if (idWithType.type === "Identifier" && idWithType.optional) {
+			this.out += "?";
+			if (node["definite"]) this.out += "!";
+			if (idWithType.typeAnnotation) this.printTSTypeAnnotation(idWithType.typeAnnotation);
+		} else {
+			this.printNode(node.id, PREC.Sequence);
+			if (node["definite"]) this.out += "!";
+			if (idWithType.typeAnnotation) this.printTSTypeAnnotation(idWithType.typeAnnotation);
+		}
+		if (node.init) {
+			this.out += " = ";
+			this.printNode(node.init, PREC.Assignment);
+		}
+	}
+	printParams(params) {
+		for (let i = 0; i < params.length; i++) {
+			if (i > 0) this.out += ", ";
+			const p = params[i];
+			if (p["type"] === "RestElement") {
+				this.out += "...";
+				this.printNode(p["argument"], PREC.Assignment);
+				if (p["typeAnnotation"]) this.printTSTypeAnnotation(p["typeAnnotation"]);
+			} else if (p["type"] === "TSParameterProperty") {
+				const pp = p;
+				this.printDecorators(pp.decorators);
+				if (pp.accessibility) this.out += `${pp.accessibility} `;
+				if (pp.readonly) this.out += "readonly ";
+				if (pp.override) this.out += "override ";
+				if (pp.static) this.out += "static ";
+				const inner = pp.parameter;
+				if (inner["type"] === "Identifier") this.printIdentifierWithOptional(inner);
+				else this.printNode(inner, PREC.Sequence);
+			} else {
+				const fp = p;
+				if (fp["decorators"] && fp["decorators"].length > 0) this.printDecorators(fp["decorators"]);
+				if (fp["type"] === "Identifier") this.printIdentifierWithOptional(fp);
+				else {
+					this.printNode(fp, PREC.Assignment);
+					if (fp["typeAnnotation"]) this.printTSTypeAnnotation(fp["typeAnnotation"]);
+				}
+			}
+		}
+	}
+	printIdentifierWithOptional(node) {
+		this.out += node.name;
+		if (node.optional) this.out += "?";
+		if (node.typeAnnotation) this.printTSTypeAnnotation(node.typeAnnotation);
+	}
+	printClassBody(node) {
+		if (node.body.length === 0) {
+			this.out += "{}";
+			return;
+		}
+		this.out += "{\n";
+		this.indentLevel++;
+		for (const el of node.body) {
+			this.out += this.indent();
+			this.printNode(el, PREC.Sequence);
+			this.out += "\n";
+		}
+		this.indentLevel--;
+		this.out += `${this.indent()}}`;
+	}
+	printMethodDefinition(node) {
+		this.printDecorators(node.decorators);
+		if (node.accessibility) this.out += `${node.accessibility} `;
+		if (node.static) this.out += "static ";
+		if (node.override) this.out += "override ";
+		const fn = node.value;
+		if (fn.async) this.out += "async ";
+		if (fn.generator) this.out += "*";
+		const kind = node.kind;
+		if (kind === "get" || kind === "set") this.out += `${kind} `;
+		else if (kind === "constructor") {}
+		if (node.computed) {
+			this.out += "[";
+			this.printNode(node.key, PREC.Sequence);
+			this.out += "]";
+		} else this.printPropertyKeyForClass(node.key);
+		if (node.optional) this.out += "?";
+		if (fn.typeParameters) this.printTSTypeParameterDeclaration(fn.typeParameters);
+		this.out += "(";
+		this.printParams(fn.params);
+		this.out += ")";
+		if (fn.returnType) this.printTSTypeAnnotation(fn.returnType);
+		if (fn.body) {
+			this.out += " ";
+			this.printBlockStatement(fn.body);
+		} else this.out += ";";
+	}
+	printPropertyDefinition(node) {
+		this.printDecorators(node.decorators);
+		if (node.declare) this.out += "declare ";
+		if (node.accessibility) this.out += `${node.accessibility} `;
+		if (node.static) this.out += "static ";
+		if (node.readonly) this.out += "readonly ";
+		if (node.override) this.out += "override ";
+		if (node.computed) {
+			this.out += "[";
+			this.printNode(node.key, PREC.Sequence);
+			this.out += "]";
+		} else this.printPropertyKeyForClass(node.key);
+		if (node.optional) this.out += "?";
+		if (node.definite) this.out += "!";
+		if (node.typeAnnotation) this.printTSTypeAnnotation(node.typeAnnotation);
+		if (node.value) {
+			this.out += " = ";
+			this.printNode(node.value, PREC.Assignment);
+		}
+		this.out += ";";
+	}
+	printAccessorProperty(node) {
+		this.printDecorators(node.decorators);
+		if (node.accessibility) this.out += `${node.accessibility} `;
+		if (node.static) this.out += "static ";
+		if (node.override) this.out += "override ";
+		this.out += "accessor ";
+		if (node.computed) {
+			this.out += "[";
+			this.printNode(node.key, PREC.Sequence);
+			this.out += "]";
+		} else this.printPropertyKeyForClass(node.key);
+		if (node.definite) this.out += "!";
+		if (node.typeAnnotation) this.printTSTypeAnnotation(node.typeAnnotation);
+		if (node.value) {
+			this.out += " = ";
+			this.printNode(node.value, PREC.Assignment);
+		}
+		this.out += ";";
+	}
+	printPropertyKeyForClass(key, computed = false) {
+		if (computed) {
+			this.out += "[";
+			this.printNode(key, PREC.Sequence);
+			this.out += "]";
+			return;
+		}
+		if (key.type === "Identifier") this.out += key.name;
+		else if (key.type === "PrivateIdentifier") this.out += `#${key.name}`;
+		else if (key.type === "Literal") this.printLiteral(key);
+		else this.printNode(key, PREC.Assignment);
+	}
+	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 kind = node.importKind === "type" ? "type " : "";
+		if (node.specifiers.length === 0) {
+			this.out += `import ${kind}${this.printImportSource(node.source, node.attributes)};`;
+			return;
+		}
+		const specs = node.specifiers;
+		const defaultSpec = specs.find((s) => s.type === "ImportDefaultSpecifier");
+		const namespaceSpec = specs.find((s) => s.type === "ImportNamespaceSpecifier");
+		const namedSpecs = specs.filter((s) => s.type === "ImportSpecifier");
+		this.out += `import ${kind}`;
+		const parts = [];
+		if (defaultSpec) parts.push(defaultSpec.local.name);
+		if (namespaceSpec) parts.push(`* as ${namespaceSpec.local.name}`);
+		if (namedSpecs.length > 0) {
+			const named = namedSpecs.map((s) => {
+				const imported = s.imported;
+				const importedName = imported.type === "Identifier" ? imported.name : imported.value;
+				const inlineType = s.importKind === "type" ? "type " : "";
+				if (importedName === s.local.name) return `${inlineType}${importedName}`;
+				return `${inlineType}${importedName} as ${s.local.name}`;
+			}).join(", ");
+			parts.push(`{ ${named} }`);
+		}
+		this.out += parts.join(", ");
+		this.out += ` from ${this.printImportSource(node.source, node.attributes)};`;
+	}
+	printImportSource(source, attrs) {
+		const raw = source.raw ?? JSON.stringify(source.value);
+		if (attrs.length === 0) return raw;
+		return `${raw} with { ${attrs.map((a) => `${this.printImportAttrKey(a.key)}: ${JSON.stringify(a.value.value)}`).join(", ")} }`;
+	}
+	printImportAttrKey(key) {
+		if (key.type === "Identifier") return key.name;
+		return JSON.stringify(key.value);
+	}
+	printExportNamedDeclaration(node) {
+		if (node.declaration) {
+			this.out += "export ";
+			this.printStatement(node.declaration);
+			return;
+		}
+		this.out += "export ";
+		if (node.exportKind === "type") this.out += "type ";
+		this.out += "{ ";
+		for (let i = 0; i < node.specifiers.length; i++) {
+			if (i > 0) this.out += ", ";
+			const s = node.specifiers[i];
+			const localName = exportNameToString(s.local);
+			const exportedName = exportNameToString(s.exported);
+			const inlineType = s.exportKind === "type" ? "type " : "";
+			if (localName === exportedName) this.out += `${inlineType}${localName}`;
+			else this.out += `${inlineType}${localName} as ${exportedName}`;
+		}
+		this.out += " }";
+		if (node.source) {
+			this.out += ` from ${JSON.stringify(node.source.value)}`;
+			if (node.attributes.length > 0) {
+				const attrStr = node.attributes.map((a) => `${this.printImportAttrKey(a.key)}: ${JSON.stringify(a.value.value)}`).join(", ");
+				this.out += ` with { ${attrStr} }`;
+			}
+		}
+		this.out += ";";
+	}
+	printExportDefaultDeclaration(node) {
+		this.out += "export default ";
+		const decl = node.declaration;
+		if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration" || decl.type === "TSInterfaceDeclaration") this.printStatement(decl);
+		else {
+			this.printNode(decl, PREC.Assignment);
+			this.out += ";";
+		}
+	}
+	printExportAllDeclaration(node) {
+		this.out += "export ";
+		if (node.exportKind === "type") this.out += "type ";
+		this.out += "*";
+		if (node.exported) this.out += ` as ${exportNameToString(node.exported)}`;
+		this.out += ` from ${JSON.stringify(node.source.value)}`;
+		if (node.attributes.length > 0) {
+			const attrStr = node.attributes.map((a) => `${this.printImportAttrKey(a.key)}: ${JSON.stringify(a.value.value)}`).join(", ");
+			this.out += ` with { ${attrStr} }`;
+		}
+		this.out += ";";
+	}
+	printTSTypeAliasDeclaration(node) {
+		if (node.declare) this.out += "declare ";
+		this.out += `type ${node.id.name}`;
+		if (node.typeParameters) this.printTSTypeParameterDeclaration(node.typeParameters);
+		this.out += ` = ${this.printTSTypeToString(node.typeAnnotation)};`;
+	}
+	printTSInterfaceDeclaration(node) {
+		if (node.declare) this.out += "declare ";
+		this.out += `interface ${node.id.name}`;
+		if (node.typeParameters) this.printTSTypeParameterDeclaration(node.typeParameters);
+		if (node.extends.length > 0) {
+			this.out += " extends ";
+			for (let i = 0; i < node.extends.length; i++) {
+				if (i > 0) this.out += ", ";
+				const ex = node.extends[i];
+				this.printNode(ex.expression, PREC.Assignment);
+				if (ex.typeArguments) this.printTSTypeParameterInstantiation(ex.typeArguments);
+			}
+		}
+		this.out += " ";
+		this.printTSInterfaceBody(node.body);
+	}
+	printTSInterfaceBody(node) {
+		if (node.body.length === 0) {
+			this.out += "{}";
+			return;
+		}
+		this.out += "{\n";
+		this.indentLevel++;
+		for (const m of node.body) {
+			this.out += this.indent();
+			this.printTSSignature(m);
+			this.out += "\n";
+		}
+		this.indentLevel--;
+		this.out += `${this.indent()}}`;
+	}
+	printTSSignature(sig) {
+		switch (sig.type) {
+			case "TSPropertySignature": {
+				const n = sig;
+				if (n.readonly) this.out += "readonly ";
+				this.printPropertyKeyForClass(n.key, n.computed === true);
+				if (n.optional) this.out += "?";
+				if (n.typeAnnotation) this.printTSTypeAnnotation(n.typeAnnotation);
+				this.out += ";";
+				break;
+			}
+			case "TSIndexSignature": {
+				const n = sig;
+				if (n.readonly) this.out += "readonly ";
+				if (n.static) this.out += "static ";
+				this.out += "[";
+				for (let i = 0; i < n.parameters.length; i++) {
+					if (i > 0) this.out += ", ";
+					const p = n.parameters[i];
+					this.out += `${p.name}: `;
+					this.printTSType(p.typeAnnotation.typeAnnotation);
+				}
+				this.out += "]";
+				this.printTSTypeAnnotation(n.typeAnnotation);
+				this.out += ";";
+				break;
+			}
+			case "TSCallSignatureDeclaration": {
+				const n = sig;
+				if (n.typeParameters) this.printTSTypeParameterDeclaration(n.typeParameters);
+				this.out += "(";
+				this.printParams(n.params);
+				this.out += ")";
+				if (n.returnType) this.printTSTypeAnnotation(n.returnType);
+				this.out += ";";
+				break;
+			}
+			case "TSConstructSignatureDeclaration": {
+				const n = sig;
+				this.out += "new ";
+				if (n.typeParameters) this.printTSTypeParameterDeclaration(n.typeParameters);
+				this.out += "(";
+				this.printParams(n.params);
+				this.out += ")";
+				if (n.returnType) this.printTSTypeAnnotation(n.returnType);
+				this.out += ";";
+				break;
+			}
+			case "TSMethodSignature": {
+				const n = sig;
+				if (n.kind === "get" || n.kind === "set") this.out += `${n.kind} `;
+				this.printPropertyKeyForClass(n.key, n.computed === true);
+				if (n.optional) this.out += "?";
+				if (n.typeParameters) this.printTSTypeParameterDeclaration(n.typeParameters);
+				this.out += "(";
+				this.printParams(n.params);
+				this.out += ")";
+				if (n.returnType) this.printTSTypeAnnotation(n.returnType);
+				this.out += ";";
+				break;
+			}
+			default: this.out += `/* sig:${sig.type} */;`;
+		}
+	}
+	printTSEnumDeclaration(node) {
+		if (node.declare) this.out += "declare ";
+		if (node.const) this.out += "const ";
+		this.out += `enum ${node.id.name} `;
+		this.out += "{\n";
+		this.indentLevel++;
+		for (const m of node.body.members) {
+			this.out += this.indent();
+			if (m.id.type === "Identifier") this.out += m.id.name;
+			else if (m.id.type === "Literal") this.printLiteral(m.id);
+			else this.printNode(m.id, PREC.Sequence);
+			if (m.initializer) {
+				this.out += " = ";
+				this.printNode(m.initializer, PREC.Assignment);
+			}
+			this.out += ",\n";
+		}
+		this.indentLevel--;
+		this.out += `${this.indent()}}`;
+	}
+	printTSModuleDeclaration(node) {
+		if (node.declare) this.out += "declare ";
+		if (node.global) this.out += "global ";
+		else {
+			const kind = node.kind;
+			this.out += `${kind} `;
+			const id = node.id;
+			if (id.type === "Identifier") this.out += id.name;
+			else if (id.type === "Literal") this.printLiteral(id);
+			else this.printNode(id, PREC.Sequence);
+		}
+		if (node.body) {
+			this.out += " ";
+			this.printTSModuleBlock(node.body);
+		} else this.out += ";";
+	}
+	printTSModuleBlock(node) {
+		this.out += "{\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()}}`;
+	}
+	printTSImportEqualsDeclaration(node) {
+		this.out += `import ${node.importKind === "type" ? "type " : ""}${node.id.name} = `;
+		const ref = node.moduleReference;
+		if (ref.type === "TSExternalModuleReference") this.out += `require(${ref.expression.value ? JSON.stringify(ref.expression.value) : "\"\""})`;
+		else this.printNode(ref, PREC.Sequence);
+		this.out += ";";
+	}
+	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);
+				if (n.typeArguments) this.printTSTypeParameterInstantiation(n.typeArguments);
+				break;
+			}
+			case "TSUnionType": {
+				const n = node;
+				for (let i = 0; i < n.types.length; i++) {
+					if (i > 0) this.out += " | ";
+					this.doPrintTSType(n.types[i]);
+				}
+				break;
+			}
+			case "TSIntersectionType": {
+				const n = node;
+				for (let i = 0; i < n.types.length; i++) {
+					if (i > 0) this.out += " & ";
+					this.doPrintTSType(n.types[i]);
+				}
+				break;
+			}
+			case "TSArrayType": {
+				const n = node;
+				const needsParens = n.elementType.type === "TSUnionType" || n.elementType.type === "TSIntersectionType";
+				if (needsParens) this.out += "(";
+				this.doPrintTSType(n.elementType);
+				if (needsParens) this.out += ")";
+				this.out += "[]";
+				break;
+			}
+			case "TSTypeLiteral": {
+				const n = node;
+				if (n.members.length === 0) this.out += "{}";
+				else {
+					this.out += "{ ";
+					for (let i = 0; i < n.members.length; i++) {
+						if (i > 0) this.out += "; ";
+						this.printTSSignature(n.members[i]);
+						if (this.out.endsWith(";")) this.out = this.out.slice(0, -1);
+					}
+					this.out += " }";
+				}
+				break;
+			}
+			case "TSTupleType": {
+				const n = node;
+				this.out += "[";
+				for (let i = 0; i < n.elementTypes.length; i++) {
+					if (i > 0) this.out += ", ";
+					const el = n.elementTypes[i];
+					if (el.type === "TSRestType") {
+						this.out += "...";
+						this.doPrintTSType(el.typeAnnotation);
+					} else if (el.type === "TSOptionalType") {
+						this.doPrintTSType(el.typeAnnotation);
+						this.out += "?";
+					} else if (el.type === "TSNamedTupleMember") {
+						const m = el;
+						this.out += `${m.label.name}${m.optional ? "?" : ""}: `;
+						const inner = m.elementType;
+						if (inner.type === "TSRestType") {
+							this.out += "...";
+							this.doPrintTSType(inner.typeAnnotation);
+						} else if (inner.type === "TSOptionalType") {
+							this.doPrintTSType(inner.typeAnnotation);
+							this.out += "?";
+						} else this.doPrintTSType(inner);
+					} else this.doPrintTSType(el);
+				}
+				this.out += "]";
+				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}`;
+				if (n.typeParameter.constraint) {
+					this.out += " extends ";
+					this.doPrintTSType(n.typeParameter.constraint);
+				}
+				break;
+			}
+			case "TSTypeQuery": {
+				const n = node;
+				this.out += "typeof ";
+				if (n.exprName.type === "TSImportType") this.doPrintTSType(n.exprName);
+				else this.printTSTypeName(n.exprName);
+				if (n.typeArguments) this.printTSTypeParameterInstantiation(n.typeArguments);
+				break;
+			}
+			case "TSImportType": {
+				const n = node;
+				if (n.options) {
+					this.out += `import(${JSON.stringify(n.source.value)}, `;
+					this.printNode(n.options, PREC.Assignment);
+					this.out += ")";
+				} else this.out += `import(${JSON.stringify(n.source.value)})`;
+				if (n.qualifier) {
+					this.out += ".";
+					this.printTSImportTypeQualifier(n.qualifier);
+				}
+				if (n.typeArguments) this.printTSTypeParameterInstantiation(n.typeArguments);
+				break;
+			}
+			case "TSTypeOperator": {
+				const n = node;
+				this.out += `${n.operator} `;
+				this.doPrintTSType(n.typeAnnotation);
+				break;
+			}
+			case "TSMappedType": {
+				const n = node;
+				this.out += "{ ";
+				if (n.readonly) this.out += n.readonly === true ? "readonly " : `${n.readonly}readonly `;
+				this.out += `[${n.key.name} in `;
+				this.doPrintTSType(n.constraint);
+				if (n.nameType) {
+					this.out += " as ";
+					this.doPrintTSType(n.nameType);
+				}
+				this.out += "]";
+				if (n.optional) this.out += n.optional === true ? "?" : `${n.optional}?`;
+				if (n.typeAnnotation) {
+					this.out += ": ";
+					this.doPrintTSType(n.typeAnnotation);
+				}
+				this.out += " }";
+				break;
+			}
+			case "TSTemplateLiteralType": {
+				const n = node;
+				this.out += "`";
+				for (let i = 0; i < n.quasis.length; i++) {
+					this.out += n.quasis[i].value.raw;
+					if (!n.quasis[i].tail) {
+						this.out += "${";
+						this.doPrintTSType(n.types[i]);
+						this.out += "}";
+					}
+				}
+				this.out += "`";
+				break;
+			}
+			case "TSFunctionType": {
+				const n = node;
+				if (n.typeParameters) this.printTSTypeParameterDeclaration(n.typeParameters);
+				this.out += "(";
+				this.printParams(n.params);
+				this.out += ") => ";
+				this.doPrintTSType(n.returnType.typeAnnotation);
+				break;
+			}
+			case "TSConstructorType": {
+				const n = node;
+				if (n.abstract) this.out += "abstract ";
+				this.out += "new ";
+				if (n.typeParameters) this.printTSTypeParameterDeclaration(n.typeParameters);
+				this.out += "(";
+				this.printParams(n.params);
+				this.out += ") => ";
+				this.doPrintTSType(n.returnType.typeAnnotation);
+				break;
+			}
+			case "TSTypePredicate": {
+				const n = node;
+				if (n.asserts) this.out += "asserts ";
+				if (n.parameterName.type === "TSThisType") this.out += "this";
+				else this.out += n.parameterName.name;
+				if (n.typeAnnotation) {
+					this.out += " is ";
+					this.doPrintTSType(n.typeAnnotation.typeAnnotation);
+				}
+				break;
+			}
+			case "TSIndexedAccessType": {
+				const n = node;
+				this.doPrintTSType(n.objectType);
+				this.out += "[";
+				this.doPrintTSType(n.indexType);
+				this.out += "]";
+				break;
+			}
+			case "TSLiteralType": {
+				const lit = node.literal;
+				if (lit.type === "Literal") this.printLiteral(lit);
+				else if (lit.type === "TemplateLiteral") this.printTemplateLiteral(lit);
+				else if (lit.type === "UnaryExpression") {
+					const u = lit;
+					this.out += u.operator;
+					this.printLiteral(u.argument);
+				} else this.printNode(lit, PREC.Sequence);
+				break;
+			}
+			case "TSParenthesizedType": {
+				const n = node;
+				this.out += "(";
+				this.doPrintTSType(n.typeAnnotation);
+				this.out += ")";
+				break;
+			}
+			case "TSJSDocNullableType": {
+				const n = node;
+				if (n.postfix) {
+					this.doPrintTSType(n.typeAnnotation);
+					this.out += "?";
+				} else {
+					this.out += "?";
+					this.doPrintTSType(n.typeAnnotation);
+				}
+				break;
+			}
+			case "TSJSDocNonNullableType": {
+				const n = node;
+				if (n.postfix) {
+					this.doPrintTSType(n.typeAnnotation);
+					this.out += "!";
+				} else {
+					this.out += "!";
+					this.doPrintTSType(n.typeAnnotation);
+				}
+				break;
+			}
+			case "TSJSDocUnknownType":
+				this.out += "?";
+				break;
+			default: this.out += `/* type:${node.type} */`;
+		}
+	}
+	printTSTypeName(name) {
+		if (!name) return;
+		if (name.type === "Identifier") this.out += name.name;
+		else if (name.type === "TSQualifiedName") {
+			this.printTSTypeName(name.left);
+			this.out += ".";
+			this.out += name.right.name;
+		} else if (name.type === "ThisExpression") this.out += "this";
+		else this.printNode(name, PREC.Sequence);
 	}
-	function getTemplateScriptRanges(ast, walker) {
-		const ranges = [];
-		if (isPlainRecord(ast) && ast["instance"] !== null && ast["instance"] !== void 0) {
-			const instance = ast["instance"];
-			if (isPlainRecord(instance) && "content" in instance) {
-				const content = instance["content"];
-				if (isRangedProgram(content)) ranges.push({
-					start: content.start,
-					end: content.end,
-					isExpression: false
-				});
-				else throw new Error("Svelte instance script without a source range");
-			}
+	printTSImportTypeQualifier(q) {
+		if (!q) return;
+		if (q.type === "Identifier") this.out += q.name;
+		else {
+			const qq = q;
+			this.printTSImportTypeQualifier(qq.left);
+			this.out += `.${qq.right.name}`;
 		}
-		if (!isPlainRecord(ast) || !("html" in ast)) throw new Error("Svelte AST without html");
-		const html = ast["html"];
-		walker(html, { enter(node) {
-			const scriptRange = tryGetScriptRangeFromElement(node);
-			if (scriptRange) ranges.push(scriptRange);
-			const templateExpression = collectTemplateExpression(node);
-			if (templateExpression) {
-				const { start, end } = templateExpression;
-				ranges.push({
-					start,
-					end,
-					isExpression: true
-				});
-			}
-		} });
-		return ranges;
 	}
-	async function parseTemplateScriptIfDefined(range) {
-		if (range) return parseTemplateScript(range);
+	printTSTypeAnnotation(node) {
+		this.out += ": ";
+		this.doPrintTSType(node.typeAnnotation);
 	}
-	async function parseTemplateScript({ start, end, isExpression, format }) {
-		const scriptText = text.slice(start, end);
-		return {
-			ast: {
-				...await context.parse(scriptText, fileName, format),
-				offset: positionFromOffset(lineStarts, start)
-			},
-			range: {
-				start,
-				end
-			},
-			isExpression
-		};
+	printTSTypeParameterDeclaration(node) {
+		this.out += "<";
+		for (let i = 0; i < node.params.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.printTSTypeParameter(node.params[i]);
+		}
+		this.out += ">";
+	}
+	printTSTypeParameterInstantiation(node) {
+		this.out += "<";
+		for (let i = 0; i < node.params.length; i++) {
+			if (i > 0) this.out += ", ";
+			this.doPrintTSType(node.params[i]);
+		}
+		this.out += ">";
+	}
+	printTSTypeParameter(node) {
+		if (node.in) this.out += "in ";
+		if (node.out) this.out += "out ";
+		if (node.const) this.out += "const ";
+		this.out += node.name.name;
+		if (node.constraint) {
+			this.out += " extends ";
+			this.doPrintTSType(node.constraint);
+		}
+		if (node.default) {
+			this.out += " = ";
+			this.doPrintTSType(node.default);
+		}
+	}
+};
+function exportNameToString(name) {
+	if (name.type === "Identifier") return name.name;
+	return name.value ?? "";
+}
+function isTSTypeNode(t) {
+	return t === "TSAnyKeyword" || t === "TSStringKeyword" || t === "TSBooleanKeyword" || t === "TSNumberKeyword" || t === "TSBigIntKeyword" || t === "TSSymbolKeyword" || t === "TSVoidKeyword" || t === "TSUndefinedKeyword" || t === "TSNullKeyword" || t === "TSNeverKeyword" || t === "TSUnknownKeyword" || t === "TSObjectKeyword" || t === "TSIntrinsicKeyword" || t === "TSThisType" || t === "TSTypeReference" || t === "TSUnionType" || t === "TSIntersectionType" || t === "TSArrayType" || t === "TSTypeLiteral" || t === "TSTupleType" || t === "TSNamedTupleMember" || t === "TSOptionalType" || t === "TSRestType" || t === "TSConditionalType" || t === "TSInferType" || t === "TSTypeQuery" || t === "TSImportType" || t === "TSTypeOperator" || t === "TSMappedType" || t === "TSTemplateLiteralType" || t === "TSFunctionType" || t === "TSConstructorType" || t === "TSTypePredicate" || t === "TSIndexedAccessType" || t === "TSLiteralType" || t === "TSParenthesizedType" || t === "TSJSDocNullableType" || t === "TSJSDocNonNullableType" || t === "TSJSDocUnknownType";
+}
+function precOf(node) {
+	switch (node.type) {
+		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 "UnaryExpression":
+		case "AwaitExpression":
+		case "YieldExpression": return PREC.Unary;
+		case "UpdateExpression": return PREC.Update;
+		case "CallExpression":
+		case "NewExpression":
+		case "TaggedTemplateExpression":
+		case "ImportExpression": return PREC.Call;
+		case "MemberExpression":
+		case "ChainExpression": return PREC.Member;
+		default: return PREC.Primary;
 	}
 }
-function getModuleScriptRange(svelteAst) {
-	if (!isPlainRecord(svelteAst) || !("module" in svelteAst) || svelteAst["module"] === null || svelteAst["module"] === void 0) return;
-	const mod = svelteAst["module"];
-	if (!isPlainRecord(mod) || !("content" in mod)) throw new Error("Svelte module script without a source range");
-	const content = mod["content"];
-	if (!isRangedProgram(content)) throw new Error("Svelte module script without a source range");
-	return {
-		start: content.start,
-		end: content.end,
-		isExpression: false
-	};
-}
-/**
-* Remaps script locations back to the original places using the script map
-*/
-function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges) {
-	const scriptRanges = [moduleScriptRange, ...templateRanges].filter(Predicate.isNotNullish).sort((a, b) => a.start - b.start);
-	let offset = 0;
-	let newModuleScriptRange;
-	const newScriptRanges = scriptRanges.map((range) => {
-		const script = code.substring(range.start, range.end);
-		const actualScript = scriptMap.get(script);
-		const start = range.start + offset;
-		if (actualScript) {
-			let langFormat = "js";
-			if (actualScript.attributes["lang"] === "ts") langFormat = "ts";
-			const scriptRange = {
-				start,
-				end: start + actualScript.content.length,
-				isExpression: range.isExpression,
-				format: langFormat
-			};
-			offset += actualScript.content.length - script.length;
-			if (range === moduleScriptRange) newModuleScriptRange = scriptRange;
-			return scriptRange;
-		} else return {
-			start,
-			end: start + script.length,
-			isExpression: range.isExpression,
-			format: "js"
-		};
-	});
-	return {
-		remappedModuleScriptRange: newModuleScriptRange,
-		remappedScriptRanges: newScriptRanges.filter((range) => range !== newModuleScriptRange)
-	};
-}
-function collectTemplateExpression(node) {
-	if (!isPlainRecord(node) || typeof node["type"] !== "string") return;
-	if (!isTemplateExpressionType(node["type"])) return;
-	if (!("expression" in node)) return;
-	const expression = node["expression"];
-	if (isRangedBaseNode(expression)) return expression;
+function needsParensForMemberObject(node) {
+	return node.type === "SequenceExpression" || node.type === "AssignmentExpression" || node.type === "ConditionalExpression" || node.type === "LogicalExpression" || node.type === "BinaryExpression" || node.type === "UnaryExpression" || node.type === "UpdateExpression" || node.type === "AwaitExpression" || node.type === "YieldExpression";
 }
 //#endregion
 //#region src/Printer.ts
 /**
-* Printer — turns the instrumenter's ASTs back into source text.
-*/
-/**
-* `@babel/generator` is CommonJS. Under Node's own ESM interop a default import
-* of it is the module's `exports` object, so the code generator sits behind
-* `.default` — the shape upstream reaches for, because upstream ships one
-* emitted file per source file. This package ships a bundle, where the default
-* import is already the function and `.default` is `undefined`, which fails at
-* the first mutant with `generator is not a function` rather than at build
-* time. Resolving both shapes once keeps the printers and the mutant's
-* replacement code identical under either layout.
+* Printer — turns the instrumenter's ASTs back into source text. The owned
+* ESTree printer (`./print/index.js`) renders; the script-root offsets that
+* html/svelte slicing needs come from the parsed `range`.
 */
-function resolveGenerate$1() {
-	if (typeof generator === "function") return generator;
-	return generator.default;
-}
-const generate$2 = resolveGenerate$1();
 function print(file) {
 	const context = { print };
 	switch (file.format) {
@@ -710,24 +3128,34 @@ function print(file) {
 		case "svelte": return sveltePrint(file, context);
 	}
 }
+const hashbangOf = (root) => {
+	if (!("hashbang" in root)) return null;
+	const hashbang = root["hashbang"];
+	if (typeof hashbang !== "object" || hashbang === null) return null;
+	if (!("type" in hashbang && hashbang.type === "Hashbang")) return null;
+	if (!("value" in hashbang && typeof hashbang.value === "string")) return null;
+	if (!("start" in hashbang && typeof hashbang.start === "number")) return null;
+	return {
+		type: "Hashbang",
+		value: hashbang.value,
+		start: hashbang.start
+	};
+};
 const jsPrint = (file) => {
-	return generate$2(file.root, { sourceMaps: false }).code;
+	return printProgram(file.root, { hashbang: hashbangOf(file.root) });
 };
 const tsPrint = (file) => {
-	return generate$2(file.root, {
-		decoratorsBeforeExport: true,
-		sourceMaps: false
-	}).code;
+	return printProgram(file.root, { hashbang: hashbangOf(file.root) });
 };
 function getScriptStart$1(script) {
-	const start = script.root.start;
-	if (start === void 0 || start === null) throw new Error("Script AST root without start");
-	return start;
+	const span = spanOf(script.root);
+	if (span === void 0) throw new Error("Script AST root without start");
+	return span.start;
 }
 function getScriptEnd$1(script) {
-	const end = script.root.end;
-	if (end === void 0 || end === null) throw new Error("Script AST root without end");
-	return end;
+	const span = spanOf(script.root);
+	if (span === void 0) throw new Error("Script AST root without end");
+	return span.end;
 }
 const htmlPrint = (ast, context) => {
 	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart$1(a) - getScriptStart$1(b));
@@ -766,71 +3194,95 @@ const sveltePrint = ({ root, rawContent }, context) => {
 /**
 * Mutator — every mutation operator and its registry.
 */
-const { traverse: babelTraverse, types: babelTypes$2 } = babel;
-const t$1 = babelTypes$2;
-function isGeneratorFn(value) {
-	return typeof value === "function";
-}
-function hasDefault(value) {
-	if (typeof value !== "object" || value === null) return false;
-	if (!("default" in value)) return false;
-	return typeof Reflect.get(value, "default") === "function";
-}
-let generateExport;
-const candidate = generator;
-if (isGeneratorFn(candidate)) generateExport = candidate;
-else if (hasDefault(candidate)) generateExport = candidate.default;
-else throw new Error("Missing generator");
-const generate$1 = generateExport;
-function deepCloneNode(node) {
-	return babelTypes$2.cloneNode(node, true, false);
-}
-function eqPosition(a, b) {
-	return a.line === b.line && a.column === b.column;
-}
-function eqLocation(a, b) {
-	return eqPosition(a.start, b.start) && eqPosition(a.end, b.end);
-}
+/**
+* Node identity: same kind, same span. oxc nodes always carry a range
+* (parsed with `range: true`), which is a stronger identity than the old
+* estree line/column loc.
+*/
 function eqNode(a, b) {
-	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
+	const spanA = spanOf(a);
+	const spanB = spanOf(b);
+	return a.type === b.type && spanA !== void 0 && spanB !== void 0 && spanA.start === spanB.start && spanA.end === spanB.end;
 }
 function createMutant(id, fileName, original, specs, offset = {
 	column: 0,
 	line: 0
-}) {
+}, lineTable = buildLineTable("")) {
 	return {
 		id,
 		fileName,
 		original,
 		offset,
+		lineTable,
 		replacement: specs.replacement,
 		mutatorName: specs.mutatorName,
 		ignoreReason: specs.ignoreReason,
-		replacementCode: generate$1(specs.replacement, { sourceMaps: false }).code
+		replacementCode: printNode(specs.replacement)
+	};
+}
+function toApiMutant(mutant) {
+	const start = nodeOffset(mutant, "start");
+	const end = nodeOffset(mutant, "end");
+	const baseFields = {
+		fileName: mutant.fileName,
+		id: mutant.id,
+		location: toApiLocation(start, end, mutant.lineTable, mutant.offset),
+		mutatorName: mutant.mutatorName,
+		replacement: mutant.replacementCode
 	};
+	if (mutant.ignoreReason !== void 0) return Mutant.make({
+		...baseFields,
+		statusReason: mutant.ignoreReason,
+		status: "Ignored"
+	});
+	return Mutant.make(baseFields);
+}
+function nodeOffset(mutant, edge) {
+	const value = spanOf(mutant.original)?.[edge];
+	if (typeof value !== "number") throw new Error(`Node without a ${edge} offset`);
+	return value;
 }
 function applyMutant(mutant, originalTree) {
 	if (originalTree === mutant.original) return mutant.replacement;
-	const mutatedAst = deepCloneNode(originalTree);
+	const mutatedAst = cloneNode(originalTree);
 	const { original, replacement } = mutant;
 	if (hasReplaced(mutatedAst, original, replacement) === false) throw new Error(`Could not apply mutant ${JSON.stringify(replacement)}.`);
 	return mutatedAst;
 }
 function hasReplaced(root, original, replacement) {
 	let applied = false;
-	babelTraverse(root, {
-		noScope: true,
-		enter(path) {
-			if (eqNode(path.node, original)) {
-				path.replaceWith(replacement);
-				path.stop();
-				applied = true;
-			}
+	traverse(root, { enter(path) {
+		if (applied) {
+			path.stop();
+			return;
 		}
-	});
+		if (eqNode(path.node, original)) {
+			path.replaceWith(replacement);
+			applied = true;
+			path.stop();
+		}
+	} });
 	return applied;
 }
 /**
+* Converts a node span to the API location: offsets become positions via the
+* file's line table, then the embedding-document offset (html/svelte) applies.
+*/
+function toApiLocation(startOffset, endOffset, lineTable, offset) {
+	return {
+		start: toPosition(positionFromLineTable(startOffset, lineTable), offset),
+		end: toPosition(positionFromLineTable(endOffset, lineTable), offset)
+	};
+}
+function toPosition(source, offset) {
+	let columnOffset = 0;
+	if (source.line === 1) columnOffset = offset.column;
+	return {
+		column: source.column + columnOffset,
+		line: source.line + offset.line - 1
+	};
+}
+/**
 * The mutations of a regular expression pattern.
 *
 * Pure: a pattern and its flags in, replacement patterns out. No I/O, no clock,
@@ -970,41 +3422,39 @@ const arithmeticOperatorReplacements = Object.freeze({
 	"%": "*"
 });
 const arithmeticOperatorMutator = function* (node, _context) {
-	if (t$1.isBinaryExpression(node) && isSupportedArithmeticOperator(node.operator, node)) {
+	if (node.type === "BinaryExpression" && isSupportedArithmeticOperator(node.operator, node)) {
 		const mutatedOperator = arithmeticOperatorReplacements[node.operator];
-		const replacement = deepCloneNode(node);
+		const replacement = cloneNode(node);
 		replacement.operator = mutatedOperator;
 		yield replacement;
 	}
 };
 function isSupportedArithmeticOperator(operator, node) {
 	if (!Object.keys(arithmeticOperatorReplacements).includes(operator)) return false;
-	const stringTypes = ["StringLiteral", "TemplateLiteral"];
-	let leftType;
-	if (t$1.isBinaryExpression(node.left)) leftType = node.left.right.type;
-	else leftType = node.left.type;
-	if (stringTypes.includes(node.right.type) || stringTypes.includes(leftType)) return false;
+	let leftOperand = node.left;
+	if (node.left.type === "BinaryExpression") leftOperand = node.left.right;
+	if (isStringLike(node.right) || isStringLike(leftOperand)) return false;
 	return true;
 }
 const arrayDeclarationMutator = function* (node, _context) {
-	if (babelTypes$2.isArrayExpression(node)) {
+	if (node.type === "ArrayExpression") {
 		let replacement;
-		if (node.elements.length > 0) replacement = babelTypes$2.arrayExpression();
-		else replacement = babelTypes$2.arrayExpression([babelTypes$2.stringLiteral("Stryker was here")]);
+		if (node.elements.length > 0) replacement = arrayExpression();
+		else replacement = arrayExpression([stringLiteral("Stryker was here")]);
 		yield replacement;
 	}
-	if ((babelTypes$2.isCallExpression(node) || babelTypes$2.isNewExpression(node)) && babelTypes$2.isIdentifier(node.callee) && node.callee.name === "Array") {
+	if ((node.type === "CallExpression" || node.type === "NewExpression") && node.callee.type === "Identifier" && node.callee.name === "Array") {
 		let mutatedCallArgs;
 		if (node.arguments.length > 0) mutatedCallArgs = [];
-		else mutatedCallArgs = [babelTypes$2.arrayExpression()];
+		else mutatedCallArgs = [arrayExpression()];
 		let replacement;
-		if (babelTypes$2.isNewExpression(node)) replacement = babelTypes$2.newExpression(deepCloneNode(node.callee), mutatedCallArgs);
-		else replacement = babelTypes$2.callExpression(deepCloneNode(node.callee), mutatedCallArgs);
+		if (node.type === "NewExpression") replacement = newExpression(cloneNode(node.callee), mutatedCallArgs);
+		else replacement = callExpression(cloneNode(node.callee), mutatedCallArgs);
 		yield replacement;
 	}
 };
 const arrowFunctionMutator = function* (node, _context) {
-	if (babelTypes$2.isArrowFunctionExpression(node) && !babelTypes$2.isBlockStatement(node.body) && !(babelTypes$2.isIdentifier(node.body) && node.body.name === "undefined")) yield babelTypes$2.arrowFunctionExpression([], babelTypes$2.identifier("undefined"));
+	if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement" && !(node.body.type === "Identifier" && node.body.name === "undefined")) yield arrowFunctionExpression([], identifier("undefined"));
 };
 const assignmentOperatorReplacements = Object.freeze({
 	"+=": "-=",
@@ -1020,16 +3470,20 @@ const assignmentOperatorReplacements = Object.freeze({
 	"||=": "&&=",
 	"??=": "&&="
 });
-const stringTypes = Object.freeze(["StringLiteral", "TemplateLiteral"]);
+function isStringLike(node) {
+	if (node === null || node === void 0) return false;
+	if (nodeType(node) === "TemplateLiteral") return true;
+	return nodeType(node) === "Literal" && typeof node.value === "string";
+}
 const stringAssignmentTypes = Object.freeze([
 	"&&=",
 	"||=",
 	"??="
 ]);
 const assignmentOperatorMutator = function* (node, _context) {
-	if (babelTypes$2.isAssignmentExpression(node) && isSupportedAssignmentOperator(node.operator) && isSupportedAssignmentExpression(node)) {
+	if (node.type === "AssignmentExpression" && isSupportedAssignmentOperator(node.operator) && isSupportedAssignmentExpression(node)) {
 		const mutatedOperator = assignmentOperatorReplacements[node.operator];
-		const replacement = deepCloneNode(node);
+		const replacement = cloneNode(node);
 		replacement.operator = mutatedOperator;
 		yield replacement;
 	}
@@ -1038,11 +3492,11 @@ function isSupportedAssignmentOperator(operator) {
 	return Object.keys(assignmentOperatorReplacements).includes(operator);
 }
 function isSupportedAssignmentExpression(node) {
-	if (stringTypes.includes(node.right.type) && !stringAssignmentTypes.includes(node.operator)) return false;
+	if (isStringLike(node.right) && !stringAssignmentTypes.includes(node.operator)) return false;
 	return true;
 }
 const blockStatementMutator = function* (node, context) {
-	if (babelTypes$2.isBlockStatement(node) && isValid(node, context)) yield babelTypes$2.blockStatement([]);
+	if (node.type === "BlockStatement" && isValid(node, context)) yield blockStatement([]);
 };
 function isValid(node, context) {
 	return !isEmpty(node) && !isInvalidConstructorBody(node, context);
@@ -1052,16 +3506,16 @@ function isEmpty(node) {
 }
 function isInvalidConstructorBody(node, context) {
 	const parent = context.parent;
-	if (parent === void 0 || !babelTypes$2.isClassMethod(parent) || parent.kind !== "constructor") return false;
-	const hasParamProps = parent.params.some((param) => babelTypes$2.isTSParameterProperty(param));
+	if (parent === void 0 || parent.type !== "MethodDefinition" || parent.kind !== "constructor") return false;
+	const hasParamProps = parent.value.params.some((param) => param !== null && nodeType(param) === "TSParameterProperty");
 	const hasInitProps = containsInitializedClassProperties(parent, context);
 	const hasSuper = hasSuperExpression(node);
 	return (hasParamProps || hasInitProps) && hasSuper;
 }
 function containsInitializedClassProperties(constructor, context) {
 	const grandParent = context.grandParent;
-	if (grandParent === void 0 || !babelTypes$2.isClassBody(grandParent)) return false;
-	return grandParent.body.some((classMember) => babelTypes$2.isClassProperty(classMember) && classMember.value !== null && classMember.value !== void 0);
+	if (grandParent === void 0 || grandParent.type !== "ClassBody") return false;
+	return grandParent.body.some((classMember) => classMember.type === "PropertyDefinition" && classMember.value !== null && classMember.value !== void 0);
 }
 function hasSuperExpression(block) {
 	return containsSuperCall(block);
@@ -1088,8 +3542,8 @@ function hasSuperInChildren(node) {
 	return false;
 }
 const booleanLiteralMutator = function* (node, _context) {
-	if (babelTypes$2.isBooleanLiteral(node)) yield babelTypes$2.booleanLiteral(!node.value);
-	if (babelTypes$2.isUnaryExpression(node) && node.operator === "!" && node.prefix) yield deepCloneNode(node.argument);
+	if (node.type === "Literal" && typeof node.value === "boolean") yield booleanLiteral(!node.value);
+	if (node.type === "UnaryExpression" && node.operator === "!" && node.prefix) yield cloneNode(node.argument);
 };
 const booleanOperators = Object.freeze([
 	"!=",
@@ -1104,50 +3558,50 @@ const booleanOperators = Object.freeze([
 	"||"
 ]);
 const conditionalExpressionMutator = function* (node, context) {
-	if (isTestOfLoop(node, context)) yield babelTypes$2.booleanLiteral(false);
+	if (isTestOfLoop(node, context)) yield booleanLiteral(false);
 	else if (isTestOfCondition(node, context)) {
-		yield babelTypes$2.booleanLiteral(true);
-		yield babelTypes$2.booleanLiteral(false);
+		yield booleanLiteral(true);
+		yield booleanLiteral(false);
 	} else if (isBooleanExpression(node)) {
 		const parent = context.parent;
-		if (parent !== void 0 && babelTypes$2.isLogicalExpression(parent)) {
+		if (parent !== void 0 && parent.type === "LogicalExpression") {
 			if (parent.operator === "||") {
-				yield babelTypes$2.booleanLiteral(false);
+				yield booleanLiteral(false);
 				return;
 			}
 			if (parent.operator === "&&") {
-				yield babelTypes$2.booleanLiteral(true);
+				yield booleanLiteral(true);
 				return;
 			}
 		}
-		yield babelTypes$2.booleanLiteral(true);
-		yield babelTypes$2.booleanLiteral(false);
-	} else if (babelTypes$2.isForStatement(node) && node.test === null) {
-		const replacement = deepCloneNode(node);
-		replacement.test = babelTypes$2.booleanLiteral(false);
+		yield booleanLiteral(true);
+		yield booleanLiteral(false);
+	} else if (node.type === "ForStatement" && node.test === null) {
+		const replacement = cloneNode(node);
+		if (replacement.type === "ForStatement") replacement.test = booleanLiteral(false);
 		yield replacement;
-	} else if (babelTypes$2.isSwitchCase(node) && node.consequent.length > 0) {
-		const replacement = deepCloneNode(node);
-		replacement.consequent = [];
+	} else if (node.type === "SwitchCase" && node.consequent.length > 0) {
+		const replacement = cloneNode(node);
+		if (replacement.type === "SwitchCase") replacement.consequent = [];
 		yield replacement;
 	}
 };
 function isTestOfLoop(node, context) {
 	const parent = context.parent;
 	if (parent === void 0) return false;
-	if (babelTypes$2.isForStatement(parent) && parent.test === node) return true;
-	if (babelTypes$2.isWhileStatement(parent) && parent.test === node) return true;
-	if (babelTypes$2.isDoWhileStatement(parent) && parent.test === node) return true;
+	if (parent.type === "ForStatement" && parent.test === node) return true;
+	if (parent.type === "WhileStatement" && parent.test === node) return true;
+	if (parent.type === "DoWhileStatement" && parent.test === node) return true;
 	return false;
 }
 function isTestOfCondition(node, context) {
 	const parent = context.parent;
 	if (parent === void 0) return false;
-	return babelTypes$2.isIfStatement(parent) && parent.test === node;
+	return parent.type === "IfStatement" && parent.test === node;
 }
 function isBooleanExpression(node) {
-	if (babelTypes$2.isBinaryExpression(node)) return booleanOperators.includes(node.operator);
-	if (babelTypes$2.isLogicalExpression(node)) return booleanOperators.includes(node.operator);
+	if (node.type === "BinaryExpression") return booleanOperators.includes(node.operator);
+	if (node.type === "LogicalExpression") return booleanOperators.includes(node.operator);
 	return false;
 }
 const operators = {
@@ -1164,8 +3618,8 @@ function isEqualityOperator(operator) {
 	return Object.keys(operators).includes(operator);
 }
 const equalityOperatorMutator = function* (node, _context) {
-	if (t$1.isBinaryExpression(node) && isEqualityOperator(node.operator)) for (const mutableOperator of operators[node.operator]) {
-		const replacement = t$1.cloneNode(node, true);
+	if (node.type === "BinaryExpression" && isEqualityOperator(node.operator)) for (const mutableOperator of operators[node.operator]) {
+		const replacement = cloneNode(node);
 		replacement.operator = mutableOperator;
 		yield replacement;
 	}
@@ -1176,9 +3630,9 @@ const logicalOperatorReplacements = Object.freeze({
 	"??": "&&"
 });
 const logicalOperatorMutator = function* (node, _context) {
-	if (babelTypes$2.isLogicalExpression(node) && isSupportedLogicalOperator(node.operator)) {
+	if (node.type === "LogicalExpression" && isSupportedLogicalOperator(node.operator)) {
 		const mutatedOperator = logicalOperatorReplacements[node.operator];
-		const replacement = deepCloneNode(node);
+		const replacement = cloneNode(node);
 		replacement.operator = mutatedOperator;
 		yield replacement;
 	}
@@ -1214,62 +3668,71 @@ const noReverseReplacements = ["getUTCDate", "setUTCDate"];
 const replacements = new Map(Object.entries(baseReplacements));
 for (const [key, value] of Object.entries(baseReplacements)) if (value !== null && !noReverseReplacements.includes(key)) replacements.set(value, key);
 const methodExpressionMutator = function* (node, _context) {
-	if (!(babelTypes$2.isCallExpression(node) || babelTypes$2.isOptionalCallExpression(node))) return;
+	if (node.type !== "CallExpression") return;
 	const { callee } = node;
-	if (!(babelTypes$2.isMemberExpression(callee) || babelTypes$2.isOptionalMemberExpression(callee)) || !babelTypes$2.isIdentifier(callee.property)) return;
+	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return;
 	const newName = replacements.get(callee.property.name);
 	if (newName === void 0) return;
+	if (callee.object.type === "Super") return;
 	if (newName === null) {
-		yield deepCloneNode(callee.object);
+		yield callExpression(cloneNode(callee.object), [], callee.optional === true);
 		return;
 	}
-	const nodeArguments = node.arguments.map((argumentNode) => deepCloneNode(argumentNode));
-	let mutatedCallee;
-	if (babelTypes$2.isMemberExpression(callee)) mutatedCallee = babelTypes$2.memberExpression(deepCloneNode(callee.object), babelTypes$2.identifier(newName), false, callee.optional);
-	else mutatedCallee = babelTypes$2.optionalMemberExpression(deepCloneNode(callee.object), babelTypes$2.identifier(newName), false, callee.optional);
-	if (babelTypes$2.isCallExpression(node)) yield babelTypes$2.callExpression(mutatedCallee, nodeArguments);
-	else yield babelTypes$2.optionalCallExpression(mutatedCallee, nodeArguments, node.optional);
+	const nodeArguments = [];
+	for (const argumentNode of node.arguments) if (argumentNode.type !== "SpreadElement") nodeArguments.push(cloneNode(argumentNode));
+	yield callExpression(memberExpression(cloneNode(callee.object), identifier(newName), false, callee.optional === true), nodeArguments, node.optional === true);
 };
 const objectLiteralMutator = function* (node, _context) {
-	if (babelTypes$2.isObjectExpression(node) && node.properties.length > 0) yield babelTypes$2.objectExpression([]);
+	if (node.type === "ObjectExpression" && node.properties.length > 0) yield {
+		type: "ObjectExpression",
+		properties: []
+	};
 };
 const optionalChainingMutator = function* (node, _context) {
-	if (t$1.isOptionalMemberExpression(node) && node.optional) yield t$1.optionalMemberExpression(t$1.cloneNode(node.object, true), t$1.cloneNode(node.property, true), node.computed, false);
-	if (t$1.isOptionalCallExpression(node) && node.optional) yield t$1.optionalCallExpression(t$1.cloneNode(node.callee, true), node.arguments.map((arg) => t$1.cloneNode(arg, true)), false);
+	if (node.type === "MemberExpression" && node.optional) {
+		const replacement = cloneNode(node);
+		replacement.optional = false;
+		yield replacement;
+	}
+	if (node.type === "CallExpression" && node.optional) {
+		const replacement = cloneNode(node);
+		replacement.optional = false;
+		yield replacement;
+	}
 };
 const regexMutator = function* (node, context) {
-	if (babelTypes$2.isRegExpLiteral(node)) for (const replacementPattern of mutateRegexPattern(node.pattern, node.flags)) yield babelTypes$2.regExpLiteral(replacementPattern, node.flags);
-	else if (babelTypes$2.isStringLiteral(node) && isObviousRegexString(node, context)) {
+	if (nodeType(node) === "Literal" && "regex" in node && node.regex !== null && node.regex !== void 0) for (const replacementPattern of mutateRegexPattern(node.regex.pattern, node.regex.flags)) yield regExpLiteral(replacementPattern, node.regex.flags);
+	else if (nodeType(node) === "Literal" && "value" in node && typeof node.value === "string" && isObviousRegexString(node, context)) {
 		const parent = context.parent;
-		if (parent !== void 0 && babelTypes$2.isNewExpression(parent)) {
+		if (parent !== void 0 && parent.type === "NewExpression") {
 			const flags = getFlags(parent);
-			for (const replacementPattern of mutateRegexPattern(node.value, flags)) yield babelTypes$2.stringLiteral(replacementPattern);
+			for (const replacementPattern of mutateRegexPattern(node.value, flags)) yield stringLiteral(replacementPattern);
 		}
 	}
 };
 function isObviousRegexString(node, context) {
 	const parent = context.parent;
-	if (parent === void 0 || !babelTypes$2.isNewExpression(parent) || !babelTypes$2.isIdentifier(parent.callee) || parent.callee.name !== RegExp.name) return false;
+	if (parent === void 0 || parent.type !== "NewExpression" || parent.callee.type !== "Identifier" || parent.callee.name !== RegExp.name) return false;
 	return parent.arguments[0] === node;
 }
 function getFlags(node) {
 	const secondArg = node.arguments[1];
-	if (secondArg !== void 0 && babelTypes$2.isStringLiteral(secondArg)) return secondArg.value;
+	if (secondArg !== void 0 && secondArg.type === "Literal" && typeof secondArg.value === "string") return secondArg.value;
 }
 const stringLiteralMutator = function* (node, context) {
-	if (babelTypes$2.isTemplateLiteral(node)) {
+	if (node.type === "TemplateLiteral") {
 		const firstQuasi = node.quasis[0];
 		if (firstQuasi === void 0) return;
 		let replacement;
 		if (node.quasis.length === 1 && firstQuasi.value.raw.length === 0) replacement = "Stryker was here!";
 		else replacement = "";
-		yield babelTypes$2.templateLiteral([babelTypes$2.templateElement({ raw: replacement })], []);
+		yield templateLiteral([templateElement(replacement)], []);
 	}
-	if (babelTypes$2.isStringLiteral(node) && isValidParent(node, context)) {
+	if (nodeType(node) === "Literal" && "value" in node && typeof node.value === "string" && isValidParent(node, context)) {
 		let replacement;
 		if (node.value.length === 0) replacement = "Stryker was here!";
 		else replacement = "";
-		yield babelTypes$2.stringLiteral(replacement);
+		yield stringLiteral(replacement);
 	}
 };
 function isValidParent(child, context) {
@@ -1278,25 +3741,25 @@ function isValidParent(child, context) {
 	return !isImportExportRelated(parent) && !isJsxOrExpressionRelated(parent) && !isObjectOrClassPropertyKey(parent, child) && !isDisallowedCallExpression(parent);
 }
 function isImportExportRelated(parent) {
-	return babelTypes$2.isImportDeclaration(parent) || babelTypes$2.isExportDeclaration(parent) || babelTypes$2.isImportOrExportDeclaration(parent) || babelTypes$2.isTSExternalModuleReference(parent);
+	return nodeType(parent) === "ImportDeclaration" || nodeType(parent) === "ExportNamedDeclaration" || nodeType(parent) === "ExportDefaultDeclaration" || nodeType(parent) === "ExportAllDeclaration" || nodeType(parent) === "TSExternalModuleReference";
 }
 function isJsxOrExpressionRelated(parent) {
-	return babelTypes$2.isJSXAttribute(parent) || babelTypes$2.isExpressionStatement(parent) || babelTypes$2.isTSLiteralType(parent) || babelTypes$2.isObjectMethod(parent);
+	return nodeType(parent) === "JSXAttribute" || nodeType(parent) === "ExpressionStatement" || nodeType(parent) === "TSLiteralType" || parent.type === "Property" && parent.method === true;
 }
 function isObjectOrClassPropertyKey(parent, child) {
-	return babelTypes$2.isObjectProperty(parent) && parent.key === child || babelTypes$2.isClassProperty(parent) && parent.key === child;
+	return (parent.type === "Property" || parent.type === "PropertyDefinition") && nodeType(parent.key) !== void 0 && parent.key === child;
 }
 function isDisallowedCallExpression(parent) {
 	return isRequireCall(parent) || isSymbolCall(parent) || isImportCall(parent);
 }
 function isRequireCall(parent) {
-	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isIdentifier(parent.callee, { name: "require" });
+	return parent.type === "CallExpression" && nodeType(parent.callee) === "Identifier" && "name" in parent.callee && parent.callee.name === "require";
 }
 function isSymbolCall(parent) {
-	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isIdentifier(parent.callee, { name: "Symbol" });
+	return parent.type === "CallExpression" && nodeType(parent.callee) === "Identifier" && "name" in parent.callee && parent.callee.name === "Symbol";
 }
 function isImportCall(parent) {
-	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isImport(parent.callee);
+	return parent.type === "CallExpression" && nodeType(parent.callee) === "Import";
 }
 const UnaryOperator = {
 	"+": "-",
@@ -1304,11 +3767,11 @@ const UnaryOperator = {
 	"~": ""
 };
 const unaryOperatorMutator = function* (node, _context) {
-	if (babelTypes$2.isUnaryExpression(node) && isSupportedUnaryOperator(node.operator) && node.prefix) {
+	if (node.type === "UnaryExpression" && isSupportedUnaryOperator(node.operator) && node.prefix) {
 		const mutatedOperator = UnaryOperator[node.operator];
 		let replacement;
-		if (isPlusOrMinus(mutatedOperator)) replacement = babelTypes$2.unaryExpression(mutatedOperator, deepCloneNode(node.argument));
-		else replacement = deepCloneNode(node.argument);
+		if (isPlusOrMinus(mutatedOperator)) replacement = unaryExpression(mutatedOperator, cloneNode(node.argument));
+		else replacement = cloneNode(node.argument);
 		yield replacement;
 	}
 };
@@ -1323,7 +3786,7 @@ const UpdateOperators = {
 	"--": "++"
 };
 const updateOperatorMutator = function* (node, _context) {
-	if (babelTypes$2.isUpdateExpression(node)) yield babelTypes$2.updateExpression(UpdateOperators[node.operator], deepCloneNode(node.argument), node.prefix);
+	if (node.type === "UpdateExpression") yield updateExpression(UpdateOperators[node.operator], cloneNode(node.argument), node.prefix);
 };
 /**
 * Every mutator this instrumenter can apply, named explicitly.
@@ -1371,11 +3834,6 @@ S.TaggedError("@systemfsoftware/stryker-js-instrumenter/TransformFailed")("Trans
 });
 //#endregion
 //#region src/Transformer.ts
-/**
-* Transformer — traverses ASTs, asks mutators for mutants and placers to instrument them.
-*/
-const { types: babelTypes$1 } = babel;
-const t = babelTypes$1;
 const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
 const COVER_MUTANT_HELPER = "stryCov_9fa48";
 const IS_MUTANT_ACTIVE_HELPER = "stryMutAct_9fa48";
@@ -1385,8 +3843,8 @@ function createMutantCollector() {
 function collect(collector, fileName, original, mutable, offset = {
 	line: 0,
 	column: 0
-}) {
-	const mutant = createMutant(collector.length.toString(), fileName, original, mutable, offset);
+}, lineTable = buildLineTable("")) {
+	const mutant = createMutant(collector.length.toString(), fileName, original, mutable, offset, lineTable);
 	collector.push(mutant);
 	return mutant;
 }
@@ -1448,7 +3906,7 @@ function processStrykerDirectives(rule, node, allMutatorNames, originFileName) {
 		}
 		mutatorNames = mutatorNames.map((mutator) => mutator.toLowerCase());
 		const reason = (optionalReason ?? DEFAULT_REASON).trim();
-		current = applyDirective(current, directiveType, scope, mutatorNames, reason, node.loc);
+		current = applyDirective(current, directiveType, scope, mutatorNames, reason, comment.loc);
 	}
 	return {
 		rule: current,
@@ -1499,62 +3957,52 @@ function applyRestore(rule, scope, mutatorNames, loc) {
 	}
 }
 function getLine(loc) {
-	if (loc == null) throw new Error("Babel node without location");
+	if (loc == null) throw new Error("Comment without location");
 	return loc.start.line;
 }
 function toIgnorerPath(path) {
 	let parentResult = null;
 	if (path.parentPath !== null) parentResult = toIgnorerPath(path.parentPath);
+	const node = path.node;
 	return {
 		node: path.node,
 		parentPath: parentResult,
 		isObjectExpression() {
-			return path.isObjectExpression();
+			return nodeType(node) === "ObjectExpression";
 		},
 		isCallExpression() {
-			return path.isCallExpression() || path.isOptionalCallExpression();
+			return nodeType(node) === "CallExpression";
 		},
 		isClassProperty() {
-			return path.isClassProperty();
+			return nodeType(node) === "PropertyDefinition";
 		},
 		isClassPrivateProperty() {
-			return path.isClassPrivateProperty();
+			return nodeType(node) === "PropertyDefinition" && Predicate.hasProperty(node, "key") && nodeType(PredicateRecord.key(node)) === "PrivateIdentifier";
 		},
 		isClassAccessorProperty() {
-			return path.isClassAccessorProperty();
+			return nodeType(node) === "AccessorProperty";
 		}
 	};
 }
-/**
-* Wraps a parsed AST the way Babel's own pipeline does, so
-* `NodePath#buildCodeFrameError` can render a code frame
-* (https://github.com/babel/babel/issues/11889). Without the wrapper a
-* placement failure reports no source context.
-*/
-function createBabelFile(filename, code, ast) {
-	return new File({ filename }, {
-		code,
-		ast
-	});
-}
+const PredicateRecord = { key: (node) => Predicate.hasProperty(node, "key") ? node["key"] : void 0 };
 function isTypeNode(path) {
-	return path.isTypeAnnotation() || flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path) || isDeclareModule(path);
+	return flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path.node) || isDeclareModule(path.node);
 }
 /**
 * Determines whether or not it is a declare variable statement node.
 * @example
 * declare const foo: 'foo';
 */
-function isDeclareVariableStatement(path) {
-	return path.isVariableDeclaration() && path.node.declare === true;
+function isDeclareVariableStatement(node) {
+	return nodeType(node) === "VariableDeclaration" && "declare" in node && node.declare === true;
 }
 /**
 * Determines whether or not a node is a string literal that is the name of a module.
 * @example
 * declare module "express" {};
 */
-function isDeclareModule(path) {
-	return path.isTSModuleDeclaration() && (path.node.declare ?? false);
+function isDeclareModule(node) {
+	return nodeType(node) === "TSModuleDeclaration" && "declare" in node && node.declare === true;
 }
 const tsTypeAnnotationNodeTypes = Object.freeze([
 	"TSAsExpression",
@@ -1579,18 +4027,17 @@ const flowTypeAnnotationNodeTypes = Object.freeze([
 	"DeclareExportAllDeclaration",
 	"InterfaceDeclaration",
 	"OpaqueType",
-	"TypeAlias",
-	"InterfaceDeclaration"
+	"TypeAlias"
 ]);
 function isImportDeclaration(path) {
-	return babelTypes$1.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
+	return nodeType(path.node) === "TSImportEqualsDeclaration" || path.node.type === "ImportDeclaration";
 }
 /**
 * returns syntax for `global.activeMutant === $mutantId`
 * @param mutantId The id of the mutant to switch
 */
 function mutantTestExpression(mutantId) {
-	return babelTypes$1.callExpression(babelTypes$1.identifier(IS_MUTANT_ACTIVE_HELPER), [babelTypes$1.stringLiteral(mutantId)]);
+	return callExpression(identifier(IS_MUTANT_ACTIVE_HELPER), [stringLiteral(mutantId)]);
 }
 /**
 * Returns a sequence of mutation coverage counters with an optional last expression.
@@ -1600,30 +4047,26 @@ function mutantTestExpression(mutantId) {
 * @param targetExpression The original expression
 */
 function mutationCoverageSequenceExpression(mutants, targetExpression) {
-	const mutantIds = [...mutants].map((mutant) => babelTypes$1.stringLiteral(mutant.id));
-	const sequence = [babelTypes$1.callExpression(babelTypes$1.identifier(COVER_MUTANT_HELPER), mutantIds)];
+	const mutantIds = [...mutants].map((mutant) => stringLiteral(mutant.id));
+	const sequence = [callExpression(identifier(COVER_MUTANT_HELPER), mutantIds)];
 	if (targetExpression) sequence.push(targetExpression);
-	return babelTypes$1.sequenceExpression(sequence);
+	return sequenceExpression(sequence);
 }
 /**
-* Narrows an applied mutant to the node kind a placer emits. `applied()` hands
-* back a plain node — whether it fits this position is the placer's claim, and
-* `canPlace` is what established it, so a mismatch here means the placer was
-* handed a mutant it never accepted.
+* Verifies the placer's claim: `canPlace` established the node kind, so a
+* mismatch here means the placer was handed a mutant it never accepted.
 */
 function nodeOfKind(mutant, node, isKind, kind) {
 	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
 	return node;
 }
-function throwPlacementError(error, nodePath, placer, mutants, fileName) {
-	const location = `${path$1.relative(process.cwd(), fileName)}:${nodePath.node.loc?.start.line}:${nodePath.node.loc?.start.column}`;
+function throwPlacementError(error, nodePath, placer, mutants, fileName, lineTable) {
+	const span = spanOf(nodePath.node);
+	const position = span !== void 0 ? positionFromLineTable(span.start, lineTable) : void 0;
+	const location = `${path$1.relative(process.cwd(), fileName)}:${position?.line}:${position?.column}`;
 	const message = `${placer.name} could not place mutants with type(s): "${new Intl.ListFormat("en").format(mutants.map((mutant) => mutant.mutatorName))}"`;
 	const errorMessage = `${location} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using ${propertyPath()("mutator", "excludedMutations")}). Please report this issue at ${strykerReportBugUrl(message)}. Original error: ${error.stack}`;
-	let builtError = new Error(errorMessage);
-	try {
-		builtError = nodePath.buildCodeFrameError(errorMessage);
-	} catch {}
-	throw builtError;
+	throw new Error(errorMessage);
 }
 /**
 * Will set the identifier of anonymous function expressions if is located in a variable declaration.
@@ -1634,11 +4077,15 @@ function throwPlacementError(error, nodePath, placer, mutants, fileName) {
 * const a = function a() {}
 */
 function classOrFunctionExpressionNamedIfNeeded(path) {
-	if ((path.isFunctionExpression() || path.isClassExpression()) && !path.node.id) {
-		if (path.parentPath.isVariableDeclarator() && babelTypes$1.isIdentifier(path.parentPath.node.id)) {
-			path.node.id = path.parentPath.node.id;
+	const kind = nodeType(path.node);
+	if ((kind === "FunctionExpression" || kind === "ClassExpression") && !("id" in path.node) === false && path.node["id"] !== null) {}
+	if ((kind === "FunctionExpression" || kind === "ClassExpression") && "id" in path.node && path.node.id == null) {
+		const parentPath = path.parentPath;
+		if (parentPath !== null && parentPath.node.type === "VariableDeclarator" && parentPath.node.id.type === "Identifier") {
+			path.node.id = parentPath.node.id;
 			return path.node;
-		} else if (path.parentPath.isObjectProperty() && babelTypes$1.isIdentifier(path.parentPath.node.key) && path.getStatementParent()?.isVariableDeclaration() === true) return path.node;
+		}
+		if (parentPath !== null && parentPath.node.type === "Property" && parentPath.node.key.type === "Identifier" && path.getStatementParent()?.node.type === "VariableDeclaration") return path.node;
 	}
 }
 /**
@@ -1650,26 +4097,32 @@ function classOrFunctionExpressionNamedIfNeeded(path) {
 * const a = (() => { const a = () => {}; return a; })()
 */
 function arrowFunctionExpressionNamedIfNeeded(path) {
-	if (path.isArrowFunctionExpression() && path.parentPath.isVariableDeclarator() && babelTypes$1.isIdentifier(path.parentPath.node.id)) return babelTypes$1.callExpression(babelTypes$1.arrowFunctionExpression([], babelTypes$1.blockStatement([babelTypes$1.variableDeclaration("const", [babelTypes$1.variableDeclarator(path.parentPath.node.id, path.node)]), babelTypes$1.returnStatement(path.parentPath.node.id)])), []);
+	const parentPath = path.parentPath;
+	if (path.node.type === "ArrowFunctionExpression" && parentPath !== null && parentPath.node.type === "VariableDeclarator" && parentPath.node.id.type === "Identifier") {
+		const declaratorId = parentPath.node.id;
+		return callExpression(arrowFunctionExpression([], blockStatement([variableDeclaration("const", [variableDeclarator(declaratorId, path.node)]), returnStatement(declaratorId)])), []);
+	}
 }
 function nameIfAnonymous(path) {
 	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowFunctionExpressionNamedIfNeeded(path) ?? path.node;
 }
 function isMemberOrCallOrNonNullExpression(path) {
-	return isCallExpression(path) || isMemberOrNonNullExpression(path);
+	return isCallExpressionNode(path) || isMemberOrNonNullExpression(path);
 }
 function isMemberOrNonNullExpression(path) {
-	return isMemberExpression(path) || path.isTSNonNullExpression();
+	return isMemberExpressionNode(path) || nodeType(path?.node) === "TSNonNullExpression";
 }
-function isMemberExpression(path) {
-	return path.isMemberExpression() || path.isOptionalMemberExpression();
+function isMemberExpressionNode(path) {
+	return nodeType(path?.node) === "MemberExpression";
 }
-function isCallExpression(path) {
-	return path.isCallExpression() || path.isOptionalCallExpression();
+function isCallExpressionNode(path) {
+	return nodeType(path?.node) === "CallExpression";
 }
 function isValidExpression(path) {
 	const parent = path.parentPath;
-	return !isObjectPropertyKey() && !isPartOfChain() && !parent.isTaggedTemplateExpression() && !isPartOfDeleteExpression() && !isPartOfAssignmentExpression();
+	if (parent === null) return true;
+	const parentNode = parent.node;
+	return !isObjectPropertyKey() && !isPartOfChain() && !(parentNode.type === "TaggedTemplateExpression") && !isPartOfDeleteExpression() && !isPartOfAssignmentExpression();
 	/**
 	* Determines if the expression is property of an object.
 	* @example
@@ -1678,7 +4131,7 @@ function isValidExpression(path) {
 	* };
 	*/
 	function isObjectPropertyKey() {
-		return parent.isObjectProperty() && parent.node.key === path.node;
+		return parentNode.type === "Property" && parentNode.key === path.node;
 	}
 	/**
 	* Determines if the expression is part of a call/member chain.
@@ -1694,7 +4147,7 @@ function isValidExpression(path) {
 	* bar?.baz[0]
 	*/
 	function isPartOfChain() {
-		return isMemberOrCallOrNonNullExpression(path) && (isMemberExpression(parent) && !(parent.node.computed && parent.node.property === path.node) || parent.isTSNonNullExpression() || isCallExpression(parent) && parent.node.callee === path.node);
+		return isMemberOrCallOrNonNullExpression(path) && (isMemberExpressionNode(parent) && !(parentNode.type === "MemberExpression" && parentNode.computed && parentNode.property === path.node) || nodeType(parentNode) === "TSNonNullExpression" || isCallExpressionNode(parent) && parentNode.type === "CallExpression" && parentNode.callee === path.node);
 	}
 	/**
 	* Determines if the expression is part of a delete expression.
@@ -1703,7 +4156,7 @@ function isValidExpression(path) {
 	* delete foo.bar;
 	*/
 	function isPartOfDeleteExpression() {
-		return parent.isUnaryExpression() && parent.node.operator === "delete";
+		return parentNode.type === "UnaryExpression" && parentNode.operator === "delete";
 	}
 	/**
 	* Determines if the expression is part of an assignment expression.
@@ -1713,7 +4166,7 @@ function isValidExpression(path) {
 	* initialNodes.filter((n) => n.id === 'tiptilt')[0].className = tiptiltState;
 	*/
 	function isPartOfAssignmentExpression() {
-		return parent.isAssignmentExpression() && parent.node.left === path.node;
+		return parentNode.type === "AssignmentExpression" && parentNode.left === path.node;
 	}
 }
 const allMutantPlacers = Object.freeze([
@@ -1725,7 +4178,7 @@ const allMutantPlacers = Object.freeze([
 		place(path, appliedMutants) {
 			let expression = nameIfAnonymous(path);
 			expression = mutationCoverageSequenceExpression(appliedMutants.keys(), expression);
-			for (const [mutant, appliedMutant] of appliedMutants) expression = babelTypes$1.conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, babelTypes$1.isExpression, "an expression"), expression);
+			for (const [mutant, appliedMutant] of appliedMutants) expression = conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, isExpressionKind, "an expression"), expression);
 			path.replaceWith(expression);
 		}
 	},
@@ -1735,27 +4188,28 @@ const allMutantPlacers = Object.freeze([
 			return path.isStatement();
 		},
 		place(path, appliedMutants) {
-			const bodyStatements = [t.expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys()))];
-			if (path.isBlockStatement()) bodyStatements.push(...path.node.body);
+			const bodyStatements = [expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys()))];
+			if (path.node.type === "BlockStatement") bodyStatements.push(...path.node.body);
 			else bodyStatements.push(path.node);
-			let statement = t.blockStatement(bodyStatements);
-			for (const [mutant, appliedMutant] of appliedMutants) statement = t.ifStatement(mutantTestExpression(mutant.id), t.blockStatement([nodeOfKind(mutant, appliedMutant, t.isStatement, "a statement")]), statement);
-			if (path.isBlockStatement()) path.replaceWith(t.blockStatement([statement]));
+			let statement = blockStatement(bodyStatements);
+			for (const [mutant, appliedMutant] of appliedMutants) statement = ifStatement(mutantTestExpression(mutant.id), blockStatement([nodeOfKind(mutant, appliedMutant, isStatementKind, "a statement")]), statement);
+			if (path.node.type === "BlockStatement") path.replaceWith(blockStatement([statement]));
 			else path.replaceWith(statement);
 		}
 	},
 	{
 		name: "switchCaseMutantPlacer",
 		canPlace(path) {
-			return path.isSwitchCase();
+			return nodeType(path.node) === "SwitchCase";
 		},
 		place(path, appliedMutants) {
-			let consequence = babel.types.blockStatement([babel.types.expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...path.node.consequent]);
+			const currentCase = path.node;
+			let consequence = blockStatement([expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...currentCase.consequent]);
 			for (const [mutant, appliedMutant] of appliedMutants) {
-				const switchCase = nodeOfKind(mutant, appliedMutant, babel.types.isSwitchCase, "a switch case");
-				consequence = babel.types.ifStatement(mutantTestExpression(mutant.id), babel.types.blockStatement(switchCase.consequent), consequence);
+				const appliedCase = nodeOfKind(mutant, appliedMutant, (candidate) => nodeType(candidate) === "SwitchCase", "a switch case");
+				consequence = ifStatement(mutantTestExpression(mutant.id), blockStatement(appliedCase.consequent), consequence);
 			}
-			path.replaceWith(babel.types.switchCase(path.node.test, [consequence]));
+			path.replaceWith(switchCase(currentCase.test, [consequence]));
 		}
 	}
 ]);
@@ -1781,15 +4235,17 @@ function shouldIgnore(path) {
 }
 const angularIgnorer = { shouldIgnore };
 function isClassFieldLike(path) {
-	return path.isClassProperty() || path.isClassPrivateProperty() || path.isClassAccessorProperty();
+	const kind = nodeType(path.node);
+	if (kind === "PropertyDefinition" || kind === "AccessorProperty") return true;
+	return kind === "PropertyDefinition" && Predicate.hasProperty(path.node, "key") && nodeType(path.node["key"]) === "PrivateIdentifier";
 }
 function isInputModelOrOutputConfigurationObject(path) {
 	const parent = path.parentPath;
 	const grandParent = parent?.parentPath;
-	if (!path.isObjectExpression() || parent === null || parent === void 0 || !parent.isCallExpression() || grandParent === null || grandParent === void 0 || !grandParent.isClassProperty()) return false;
-	const callExpression = parent;
-	const objectExpression = path;
-	const callNode = callExpression.node;
+	if (nodeType(path.node) !== "ObjectExpression" || parent === null || parent === void 0 || nodeType(parent.node) !== "CallExpression" || grandParent === null || grandParent === void 0 || nodeType(grandParent.node) !== "PropertyDefinition") return false;
+	const callExpressionPath = parent;
+	const objectExpressionPath = path;
+	const callNode = callExpressionPath.node;
 	if (!Predicate.hasProperty(callNode, "callee") || !Predicate.hasProperty(callNode, "arguments")) return false;
 	const callee = callNode["callee"];
 	const args = callNode["arguments"];
@@ -1797,17 +4253,17 @@ function isInputModelOrOutputConfigurationObject(path) {
 	const isRequiredSignalIOFunction = isMemberExpressionWithIdentifier(callee, ANGULAR_SIGNAL_IO_FUNCTIONS, "required");
 	const isSignalIOFunction = isIdentifierIn(callee, ANGULAR_SIGNAL_IO_FUNCTIONS);
 	const isOutput = isIdentifierWithName(callee, "output");
-	if (isRequiredSignalIOFunction || isOutput) return args.length >= 1 && args[0] === objectExpression.node;
-	if (isSignalIOFunction) return args.length >= 2 && args[1] === objectExpression.node;
+	if (isRequiredSignalIOFunction || isOutput) return args.length >= 1 && args[0] === objectExpressionPath.node;
+	if (isSignalIOFunction) return args.length >= 2 && args[1] === objectExpressionPath.node;
 	return false;
 }
 function isSignalQueryOptionsObject(path) {
 	const parent = path.parentPath;
 	const grandParent = parent?.parentPath;
-	if (!path.isObjectExpression() || parent === null || parent === void 0 || !parent.isCallExpression() || grandParent === null || grandParent === void 0 || !isClassFieldLike(grandParent)) return false;
-	const callExpression = parent;
-	const objectExpression = path;
-	const callNode = callExpression.node;
+	if (nodeType(path.node) !== "ObjectExpression" || parent === null || parent === void 0 || nodeType(parent.node) !== "CallExpression" || grandParent === null || grandParent === void 0 || !isClassFieldLike(grandParent)) return false;
+	const callExpressionPath = parent;
+	const objectExpressionPath = path;
+	const callNode = callExpressionPath.node;
 	if (!Predicate.hasProperty(callNode, "callee") || !Predicate.hasProperty(callNode, "arguments")) return false;
 	const callee = callNode["callee"];
 	const args = callNode["arguments"];
@@ -1815,7 +4271,7 @@ function isSignalQueryOptionsObject(path) {
 	const isQueryFn = isIdentifierIn(callee, ANGULAR_SIGNAL_QUERY_FUNCTIONS);
 	const isRequiredQueryFn = isMemberExpressionWithIdentifier(callee, ANGULAR_SIGNAL_QUERY_FUNCTIONS, "required");
 	if (!isQueryFn && !isRequiredQueryFn) return false;
-	return args.length >= 2 && args[1] === objectExpression.node;
+	return args.length >= 2 && args[1] === objectExpressionPath.node;
 }
 function isIdentifierWithName(node, name) {
 	return Predicate.hasProperty(node, "type") && node["type"] === "Identifier" && Predicate.hasProperty(node, "name") && node["name"] === name;
@@ -1829,9 +4285,11 @@ function isMemberExpressionWithIdentifier(node, objectNames, propertyName) {
 const strykerPlugins = [];
 const frameworkPluginsFileUrl = import.meta.url;
 /**
-* Returns syntax for the header if JS/TS files
+* The instrumentation header: parsed once with oxc, frozen, shared. The
+* `globalThis` implementation is based on core-js's — see
+* https://github.com/stryker-mutator/stryker-js/issues/4035
 */
-const parsedInstrumentationHeader = babel.parse(`// @ts-nocheck
+const parsedInstrumentationHeader = parseSync("instrumenter-header.js", `// @ts-nocheck
 var ${STRYKER_NAMESPACE_HELPER} = function(){
   var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
   var ns = g.${INSTRUMENTER_CONSTANTS.NAMESPACE} || (g.${INSTRUMENTER_CONSTANTS.NAMESPACE} = {});
@@ -1876,27 +4334,26 @@ var ${IS_MUTANT_ACTIVE_HELPER} = function(id) {
   ${IS_MUTANT_ACTIVE_HELPER} = isActive;
   return isActive(id);
 }`, {
-	configFile: false,
-	browserslistConfigFile: false,
-	env: { targets: {} }
+	lang: "js",
+	range: true
 });
-if (!babelTypes$1.isFile(parsedInstrumentationHeader)) throw new Error("Instrumentation header parsed as non-File");
-const instrumentationBabelHeader = parsedInstrumentationHeader.program.body;
-deepFreeze(instrumentationBabelHeader);
+if (parsedInstrumentationHeader.errors.length > 0) throw new Error("Instrumentation header failed to parse");
+const instrumentationHeader = parsedInstrumentationHeader.program.body;
+deepFreeze(instrumentationHeader);
 function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
 	if (hasPlacedMutants(mutantCollector, originFileName) && options.noHeader !== true) placeHeader(root);
 }
 function placeHeader(root) {
-	let header = instrumentationBabelHeader;
-	const leadingComments = root.program.body[0]?.leadingComments;
+	let header = instrumentationHeader;
+	const leadingComments = root.body[0]?.leadingComments;
 	if (Array.isArray(leadingComments)) {
-		const firstHeader = instrumentationBabelHeader[0];
+		const firstHeader = instrumentationHeader[0];
 		if (firstHeader === void 0) throw new Error("Instrumentation header is empty");
-		const cloned = babelTypes$1.cloneNode(firstHeader, true, false);
+		const cloned = cloneNode(firstHeader);
 		cloned.leadingComments = leadingComments;
-		header = [cloned, ...instrumentationBabelHeader.slice(1)];
+		header = [cloned, ...instrumentationHeader.slice(1)];
 	}
-	root.program.body.unshift(...header);
+	root.body.unshift(...header);
 }
 function deepFreeze(value) {
 	if (value !== null && typeof value === "object") {
@@ -1930,7 +4387,7 @@ function transform(ast, mutantCollector, transformerContext) {
 		case "html": return transformHtml(ast, mutantCollector, context);
 		case "js":
 		case "ts":
-		case "tsx": return transformBabel(ast, mutantCollector, context);
+		case "tsx": return transformScript(ast, mutantCollector, context);
 		case "svelte": return transformSvelte(ast, mutantCollector, context);
 	}
 }
@@ -1960,7 +4417,8 @@ const transformSvelte = (svelte, mutantCollector, context) => {
 			root.moduleScript = {
 				ast: {
 					format: "js",
-					root: babelTypes$1.file(babelTypes$1.program([])),
+					root: emptyProgram(),
+					comments: [],
 					rawContent: "",
 					originFileName
 				},
@@ -1980,15 +4438,22 @@ const transformSvelte = (svelte, mutantCollector, context) => {
 	}
 	return warnings;
 };
-const { traverse: traverse$1 } = babel;
-const transformBabel = ({ root, originFileName, rawContent, offset }, mutantCollector, { options, mutateDescription }, mutators = allMutators, mutantPlacers = allMutantPlacers) => {
-	const file = createBabelFile(originFileName, rawContent, root);
+function emptyProgram() {
+	return {
+		type: "Program",
+		sourceType: "module",
+		body: []
+	};
+}
+const transformScript = ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription }, mutators = allMutators, mutantPlacers = allMutantPlacers) => {
+	const lineTable = buildLineTable(rawContent);
+	attachComments(root, comments, lineTable);
 	const placementMap = /* @__PURE__ */ new Map();
 	let directiveRule = rootRule;
 	const mutatorEntries = Object.entries(mutators);
 	const allMutatorNames = mutatorEntries.map(([name]) => name.toLowerCase());
 	const warnings = [];
-	traverse$1(file.ast, {
+	traverse(root, {
 		enter(path) {
 			const result = processStrykerDirectives(directiveRule, path.node, allMutatorNames, originFileName);
 			directiveRule = result.rule;
@@ -2024,7 +4489,7 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 		});
 	}
 	function shouldSkip(path) {
-		return isTypeNode(path) || isImportDeclaration(path) || path.isDecorator() || mutateDescription === false || Array.isArray(mutateDescription) && mutateDescription.every((range) => {
+		return isTypeNode(path) || isImportDeclaration(path) || nodeType(path.node) === "Decorator" || mutateDescription === false || Array.isArray(mutateDescription) && mutateDescription.every((range) => {
 			return !locationOverlaps(range, getNodeLocation(path.node));
 		});
 	}
@@ -2033,13 +4498,21 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 			return locationIncluded(range, getNodeLocation(path.node));
 		});
 	}
+	function getNodeLocation(node) {
+		const span = spanOf(node);
+		if (span === void 0) throw new Error("Node without a span");
+		return {
+			start: positionFromLineTable(span.start, lineTable),
+			end: positionFromLineTable(span.end, lineTable)
+		};
+	}
 	function placeMutantsIfNeeded(path) {
 		const mutantsPlacement = placementMap.get(path.node);
 		if (mutantsPlacement !== void 0 && mutantsPlacement.appliedMutants.size > 0) try {
 			mutantsPlacement.placer.place(path, mutantsPlacement.appliedMutants);
 			path.skip();
 		} catch (error) {
-			throwPlacementError(toError(error), path, mutantsPlacement.placer, [...mutantsPlacement.appliedMutants.keys()], originFileName);
+			throwPlacementError(toError(error), path, mutantsPlacement.placer, [...mutantsPlacement.appliedMutants.keys()], originFileName, lineTable);
 		}
 	}
 	function ignoreMessageFor(path) {
@@ -2050,7 +4523,7 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 		}
 	}
 	function collectMutants(path) {
-		return [...mutate(path)].map((mutable) => collect(mutantCollector, originFileName, path.node, mutable, offset)).filter((mutant) => mutant.ignoreReason === void 0);
+		return [...mutate(path)].map((mutable) => collect(mutantCollector, originFileName, path.node, mutable, offset, lineTable)).filter((mutant) => mutant.ignoreReason === void 0);
 	}
 	function* mutate(path) {
 		const context = toMutatorContext(path);
@@ -2082,20 +4555,6 @@ function toMutatorContext(path) {
 		ancestors
 	};
 }
-function getNodeLocation(node) {
-	const loc = node.loc;
-	if (loc == null) throw new Error("Babel node without location");
-	return {
-		start: {
-			line: loc.start.line,
-			column: loc.start.column
-		},
-		end: {
-			line: loc.end.line,
-			column: loc.end.column
-		}
-	};
-}
 function toError(value) {
 	if (value instanceof Error) return value;
 	return new Error("Unexpected error", { cause: value });
@@ -2105,60 +4564,23 @@ function toError(value) {
 /**
 * Instrument — the instrument capability: Cell description, file/mutant types and the instrument entry point.
 */
-const { traverse, types: babelTypes } = babel;
-function resolveGenerate() {
-	if (typeof generator === "function") return generator;
-	return generator.default;
-}
-resolveGenerate();
-function toApiMutant(mutant) {
-	const loc = mutant.original.loc;
-	if (loc === void 0 || loc === null) throw new Error("Babel node without a source location");
-	const base = {
-		fileName: mutant.fileName,
-		id: mutant.id,
-		location: toApiLocation(loc, mutant.offset),
-		mutatorName: mutant.mutatorName,
-		replacement: mutant.replacementCode
-	};
-	if (mutant.ignoreReason === void 0) return Mutant.make(base);
-	return Mutant.make({
-		...base,
-		statusReason: mutant.ignoreReason,
-		status: "Ignored"
-	});
-}
-function toApiLocation(source, offset) {
-	return {
-		start: toPosition(source.start, offset),
-		end: toPosition(source.end, offset)
-	};
-}
-function toPosition(source, offset) {
-	let columnOffset = 0;
-	if (source.line === 1) columnOffset = offset.column;
-	return {
-		column: source.column + columnOffset,
-		line: source.line + offset.line - 1
-	};
-}
 const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
 const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
 const startingCommentRegex = /(^\s*\/\*.*?\*\/)/gs;
-async function disableTypeChecks(file, options) {
+async function disableTypeChecks(file) {
 	const format = getFormat(file.name);
 	if (!format) return file;
 	if (isJSFileWithoutTSDirectives(file, format)) return {
 		...file,
 		content: prefixWithNoCheck(file.content)
 	};
-	const ast = await createParser(options)(file.content, file.name);
+	const ast = await createParser()(file.content, file.name);
 	switch (ast.format) {
 		case "js":
 		case "ts":
 		case "tsx": return {
 			...file,
-			content: disableTypeCheckingInBabelAst(ast)
+			content: disableTypeCheckingInScript(ast)
 		};
 		case "html": return {
 			...file,
@@ -2173,8 +4595,8 @@ async function disableTypeChecks(file, options) {
 function isJSFileWithoutTSDirectives(file, format) {
 	return (format === "ts" || format === "js") && !tsDirectiveLikeRegEx.test(file.content);
 }
-function disableTypeCheckingInBabelAst(ast) {
-	return prefixWithNoCheck(removeTSDirectives(ast.rawContent, ast.root.comments));
+function disableTypeCheckingInScript(ast) {
+	return prefixWithNoCheck(removeTSDirectives(ast.rawContent, ast.comments));
 }
 function prefixWithNoCheck(code) {
 	if (code.startsWith("#")) {
@@ -2189,14 +4611,14 @@ function prefixWithNoCheck(code) {
 	}
 }
 function getScriptStart(script) {
-	const start = script.root.start;
-	if (start === void 0 || start === null) throw new Error("Script AST root without start");
-	return start;
+	const span = spanOf(script.root);
+	if (span === void 0) throw new Error("Script AST root without start");
+	return span.start;
 }
 function getScriptEnd(script) {
-	const end = script.root.end;
-	if (end === void 0 || end === null) throw new Error("Script AST root without end");
-	return end;
+	const span = spanOf(script.root);
+	if (span === void 0) throw new Error("Script AST root without end");
+	return span.end;
 }
 function disableTypeCheckingInHtml(ast) {
 	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart(a) - getScriptStart(b));
@@ -2205,7 +4627,7 @@ function disableTypeCheckingInHtml(ast) {
 	for (const script of sortedScripts) {
 		html += ast.rawContent.substring(currentIndex, getScriptStart(script));
 		html += "\n";
-		html += prefixWithNoCheck(removeTSDirectives(script.rawContent, script.root.comments));
+		html += prefixWithNoCheck(removeTSDirectives(script.rawContent, script.comments));
 		html += "\n";
 		currentIndex = getScriptEnd(script);
 	}
@@ -2219,7 +4641,7 @@ function disableTypeCheckingInSvelte(ast) {
 	for (const script of sortedScripts) {
 		html += ast.rawContent.substring(currentIndex, script.range.start);
 		html += "\n";
-		html += prefixWithNoCheck(removeTSDirectives(script.ast.rawContent, script.ast.root.comments));
+		html += prefixWithNoCheck(removeTSDirectives(script.ast.rawContent, script.ast.comments));
 		html += "\n";
 		currentIndex = script.range.end;
 	}
@@ -2243,7 +4665,7 @@ function tryParseTSDirective(comment) {
 	const match = commentDirectiveRegEx.exec(comment.value);
 	if (match !== null) {
 		const start = comment.start;
-		if (start == null) throw new Error("Comment without start");
+		if (start === void 0) throw new Error("Comment without start");
 		const directivePrefix = match[1];
 		if (directivePrefix === void 0) throw new Error("TS directive match without prefix");
 		const directiveName = match[2];
@@ -2255,7 +4677,7 @@ function tryParseTSDirective(comment) {
 		};
 	}
 }
-function toBabelLineNumber(range) {
+function toOneBasedLineNumber(range) {
 	if (typeof range === "boolean") return range;
 	return range.map(({ start, end }) => ({
 		start: {
@@ -2288,7 +4710,7 @@ function isAst(value) {
 const instrumentDescription = pipe(Cell.read((command) => Effect.gen(function* () {
 	const files = command.files;
 	const options = command.options;
-	const parse = createParser(options);
+	const parse = createParser();
 	const asts = [];
 	for (const { name, content } of files) {
 		const ast = yield* Effect.tryPromise({
@@ -2309,7 +4731,7 @@ const instrumentDescription = pipe(Cell.read((command) => Effect.gen(function* (
 		yield* Effect.try({
 			try: () => transform(ast, collector, {
 				options: toTransformerOptions(options),
-				mutateDescription: toBabelLineNumber(file.mutate)
+				mutateDescription: toOneBasedLineNumber(file.mutate)
 			}),
 			catch: (cause) => new InstrumentError({
 				message: `Failed to transform ${file.name}`,