@systemfsoftware/stryker-js-instrumenter 0.2.0 → 2.0.0

package/dist/index.mjs

@@ -1,29 +1,365 @@
-import { PluginKind, commonTokens, declareClassPlugin, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
-import path from "path";
-import { INSTRUMENTER_CONSTANTS as ID } from "@systemfsoftware/stryker-js-plugin-api/core";
-import babel, { File, types } from "@babel/core";
-import { deepFreeze, notEmpty, propertyPath } from "@systemfsoftware/stryker-js-util";
-import { satisfies } from "semver";
+import babel, { File } from "@babel/core";
 import generator from "@babel/generator";
-import * as weaponRegex from "weapon-regex";
-import "@systemfsoftware/stryker-js-plugin-api/ignore";
-import "@systemfsoftware/stryker-js-plugin-api/logging";
+import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
+import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js/Mutant";
+import * as Effect from "effect/Effect";
+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";
-//#region src/instrumenter-tokens.ts
-const instrumenterTokens = Object.freeze({
-	createParser: "instrumenterCreateParser",
-	print: "instrumenterPrint",
-	transform: "instrumenterTransform"
+import path from "path";
+import "@systemfsoftware/stryker-js/Ignorer";
+import { propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js/Schema";
+import * as Option from "effect/Option";
+import path$1 from "node:path";
+import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/Instrument.workflow.ts
+/**
+* Instrument.workflow — pure decision for the instrument capability.
+*
+* The heavy lifting (Babel 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
+* decision body only reaches parameters, const locals, same-file declarations,
+* and the sealed pure effect surface.
+*/
+var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/InstrumentError")("InstrumentError", {
+	message: S.String,
+	cause: S.Defect()
+}) {
+	get message() {
+		if (this.message.length === 0) return "Instrumenter failure";
+		return this.message;
+	}
+};
+const PositionSchema = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const RangeSchema = S.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+const MutateDescriptionSchema = S.Union([S.Boolean, S.Array(RangeSchema)]);
+const FileSchema = S.Struct({
+	name: S.String,
+	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)))
+});
+var InstrumentCommand = class extends S.TaggedClass()("InstrumentCommand", {
+	files: S.Array(FileSchema),
+	options: InstrumenterOptionsSchema
+}) {};
+var InstrumentDecoded = class extends S.TaggedClass()("InstrumentDecoded", {
+	files: S.Array(FileSchema),
+	options: InstrumenterOptionsSchema,
+	asts: S.Array(AstSchema),
+	mutants: S.Array(Mutant)
+}) {};
+var InstrumentDecision = class extends S.TaggedClass()("InstrumentDecision", {
+	files: S.Array(FileSchema),
+	mutants: S.Array(Mutant),
+	asts: S.Array(AstSchema)
+}) {};
+var InstrumentResult = class extends S.TaggedClass()("InstrumentResult", {
+	files: S.Array(FileSchema),
+	mutants: S.Array(Mutant)
+}) {};
+const instrumentWorkflow = Workflow.make(InstrumentDecoded, (decoded) => Result.succeed(InstrumentDecision.make({
+	files: decoded.files,
+	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",
+	"ts",
+	"tsx",
+	"svelte"
+]);
 //#endregion
-//#region src/parsers/parse-error.ts
-var ParseError = class extends Error {
-	constructor(message, fileName, location) {
-		super(`Parse error in ${fileName} (${location.line}:${location.column}) ${message}`);
+//#region src/Syntax.ts
+/**
+* Determines if a location (needle) is included in an other location (haystack)
+* @param haystack The range to look in
+* @param needle the range to search for
+*/
+function locationIncluded(haystack, needle) {
+	const startIncluded = haystack.start.line < needle.start.line || haystack.start.line === needle.start.line && haystack.start.column <= needle.start.column;
+	const endIncluded = haystack.end.line > needle.end.line || haystack.end.line === needle.end.line && haystack.end.column >= needle.end.column;
+	return startIncluded && endIncluded;
+}
+/**
+* Determines if two locations overlap with each other
+*/
+function locationOverlaps(a, b) {
+	const startIncluded = a.start.line < b.end.line || a.start.line === b.end.line && a.start.column <= b.end.column;
+	const endIncluded = a.end.line > b.start.line || a.end.line === b.start.line && a.end.column >= b.start.column;
+	return startIncluded && endIncluded;
+}
+function computeLineStarts(text) {
+	const result = [];
+	let pos = 0;
+	let lineStart = 0;
+	while (pos < text.length) {
+		const ch = text.charCodeAt(pos);
+		pos++;
+		switch (ch) {
+			case CharacterCodes.carriageReturn:
+				if (text.charCodeAt(pos) === CharacterCodes.lineFeed) pos++;
+				result.push(lineStart);
+				lineStart = pos;
+				break;
+			case CharacterCodes.lineFeed:
+				result.push(lineStart);
+				lineStart = pos;
+				break;
+			default: if (ch > CharacterCodes.maxAsciiCharacter && isLineBreak(ch)) {
+				result.push(lineStart);
+				lineStart = pos;
+			}
+		}
+	}
+	result.push(lineStart);
+	return result;
+}
+function positionFromOffset(lineStarts, offset) {
+	const lineNumber = computeLineOfPosition(lineStarts, offset);
+	const lineStart = lineStarts[lineNumber];
+	if (lineStart === void 0) throw new Error("Line start not found for computed line number");
+	return {
+		line: lineNumber,
+		column: offset - lineStart
+	};
+}
+function computeLineOfPosition(lineStarts, offset) {
+	let lineNumber = binarySearch(lineStarts, offset);
+	if (lineNumber < 0) {
+		lineNumber = ~lineNumber - 1;
+		if (lineNumber === -1) throw new Error("position cannot precede the beginning of the file");
+	}
+	return lineNumber;
+}
+function binarySearch(array, value) {
+	if (!array.length) return -1;
+	let low = 0;
+	let high = array.length - 1;
+	while (low <= high) {
+		const middle = low + (high - low >> 1);
+		const midValue = array[middle];
+		if (midValue === void 0) throw new Error("Binary search middle value is missing");
+		switch (compare(midValue, value)) {
+			case -1:
+				low = middle + 1;
+				break;
+			case 0: return middle;
+			case 1: high = middle - 1;
+		}
 	}
+	return ~low;
+}
+function compare(a, b) {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+const CharacterCodes = {
+	lineFeed: 10,
+	carriageReturn: 13,
+	maxAsciiCharacter: 127,
+	lineSeparator: 8232,
+	paragraphSeparator: 8233
 };
+function isLineBreak(ch) {
+	return ch === CharacterCodes.lineFeed || ch === CharacterCodes.carriageReturn || ch === CharacterCodes.lineSeparator || ch === CharacterCodes.paragraphSeparator;
+}
 //#endregion
-//#region src/parsers/html-parser.ts
+//#region src/Parser.ts
+/**
+* Parser — all parsers that turn source text into the instrumenter's ASTs.
+*/
+const { types: types$1, parseAsync } = babel;
+const require = createRequire(import.meta.url);
+function createParser(parserOptions) {
+	const jsParse = createJSParser(parserOptions);
+	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}!`);
+		}
+		switch (format) {
+			case "js": return jsParse(code, fileName);
+			case "tsx": return parseTsx(code, fileName);
+			case "ts": return parseTS(code, fileName);
+			case "html": return parseHtml(code, fileName, { parse });
+			case "svelte": return parseSvelte(code, fileName, { parse });
+		}
+		throw new Error(`Unsupported format: ${String(format)}`);
+	}
+	return parse;
+}
+function getFormat(fileName, override) {
+	if (override) return override;
+	else switch (path.extname(fileName).toLowerCase()) {
+		case ".js":
+		case ".jsx":
+		case ".mjs":
+		case ".cjs": return "js";
+		case ".mts":
+		case ".cts":
+		case ".ts": return "ts";
+		case ".tsx": return "tsx";
+		case ".vue":
+		case ".html":
+		case ".htm": return "html";
+		case ".svelte": return "svelte";
+		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 }) {
+	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`);
+		return {
+			originFileName: fileName,
+			rawContent: text,
+			format: "js",
+			root: ast
+		};
+	};
+}
+/**
+* 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) {
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "ts",
+		root: await parseTSInternal(text, fileName, false)
+	};
+}
+async function parseTsx(text, fileName) {
+	return {
+		root: await parseTSInternal(text, fileName, true),
+		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",
@@ -36,7 +372,7 @@ const JS_SCRIPT_TYPES = Object.freeze([
 	"javascript",
 	"module"
 ]);
-async function parse$2(text, originFileName, context) {
+async function parseHtml(text, originFileName, context) {
 	return {
 		originFileName,
 		rawContent: text,
@@ -53,29 +389,55 @@ async function ngHtmlParser(text, fileName, parserContext) {
 	});
 	if (errors.length !== 0) {
 		const firstError = errors[0];
-		if (firstError === void 0) throw new Error("HTML parser reported errors but first error is missing");
-		throw new ParseError(firstError.msg, fileName, toSourceLocation(firstError.span.start));
+		if (firstError === void 0) throw new ParseFailed({
+			fileName,
+			message: "HTML parser reported errors but first error is missing",
+			location: {
+				line: 0,
+				column: 0
+			},
+			cause: errors
+		});
+		throw new ParseFailed({
+			fileName,
+			message: firstError.msg,
+			location: toSourceLocation(firstError.span.start),
+			cause: firstError
+		});
 	}
 	const scriptsAsPromised = [];
-	ngParser.visitAll(new class extends ngParser.RecursiveVisitor {
-		visitElement(el, context) {
+	const scriptCollector = {
+		visitElement: (el, context) => {
 			const scriptFormat = getScriptType(el);
 			if (scriptFormat) scriptsAsPromised.push(parseScript(el, scriptFormat));
-			super.visitElement(el, context);
-		}
-	}(), rootNodes);
+			ngParser.visitAll(scriptCollector, el.children, context);
+		},
+		visitAttribute: () => void 0,
+		visitText: () => void 0,
+		visitComment: () => void 0,
+		visitDocType: () => void 0,
+		visitExpansion: () => void 0,
+		visitExpansionCase: () => void 0,
+		visitBlock: () => void 0,
+		visitBlockParameter: () => void 0,
+		visitLetDeclaration: () => void 0,
+		visitCdata: () => void 0,
+		visitComponent: () => void 0,
+		visitDirective: () => void 0
+	};
+	ngParser.visitAll(scriptCollector, rootNodes);
 	return { scripts: await Promise.all(scriptsAsPromised) };
 	async function parseScript(el, scriptFormat) {
 		const endSourceSpan = el.endSourceSpan;
-		if (endSourceSpan === null || endSourceSpan === void 0) throw new Error("HTML element without an end source span");
+		if (endSourceSpan == null) throw new Error("HTML element without an end source span");
 		const content = text.substring(el.startSourceSpan.end.offset, endSourceSpan.start.offset);
 		const ast = await parserContext.parse(content, fileName, scriptFormat);
-		if (ast) {
+		if (ast !== null && ast !== void 0) {
 			const offset = el.startSourceSpan.end;
 			const rootStart = ast.root.start;
-			if (rootStart === null || rootStart === void 0) throw new Error("Babel File node without a start offset");
+			if (rootStart == null) throw new Error("Babel File node without a start offset");
 			const rootEnd = ast.root.end;
-			if (rootEnd === null || rootEnd === void 0) throw new Error("Babel File node without an end offset");
+			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;
 			return {
@@ -108,151 +470,221 @@ function getScriptType(element) {
 		}
 	}
 }
-//#endregion
-//#region src/parsers/js-parser.ts
-const { types: types$15, parseAsync: parseAsync$1 } = babel;
-function isParserPlugin(value) {
-	return typeof value === "string" || Array.isArray(value);
+function parseVersion(version) {
+	const match = /^(\d+)\.(\d+)(?:\.\d+)?/.exec(version);
+	if (!match) return;
+	const major = Number.parseInt(match[1] ?? "", 10);
+	const minor = Number.parseInt(match[2] ?? "", 10);
+	if (Number.isNaN(major) || Number.isNaN(minor)) return;
+	return {
+		major,
+		minor
+	};
 }
-function isParserPluginArray(value) {
-	return value.every(isParserPlugin);
+function isSupportedSvelteVersion(version) {
+	const parsed = parseVersion(version);
+	if (parsed === void 0) return false;
+	return parsed.major > 3 || parsed.major === 3 && parsed.minor >= 30;
 }
-function getParserPlugins(override) {
-	if (override === null || override === void 0) return defaultPlugins;
-	if (isParserPluginArray(override)) return override;
-	throw new Error("Invalid parser plugins: expected ParserPlugin[]");
+function isSvelteV5OrLater(version) {
+	const parsed = parseVersion(version);
+	if (parsed === void 0) return false;
+	return parsed.major >= 5;
 }
-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 createParser$1({ plugins: pluginsOverride }) {
-	return async function parse(text, fileName) {
-		const plugins = getParserPlugins(pluginsOverride);
-		const ast = await parseAsync$1(text, {
-			parserOpts: { plugins: [...plugins] },
-			filename: fileName,
-			sourceType: "module"
-		});
-		if (ast === null || ast === void 0) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
-		if (types$15.isProgram(ast)) throw new Error(`Expected ${fileName} to contain a babel.types.file, but was a program`);
-		return {
-			originFileName: fileName,
-			rawContent: text,
-			format: "js",
-			root: ast
-		};
-	};
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null;
 }
-//#endregion
-//#region src/util/position-converter.ts
-/**
-* A class that can convert a string offset back to line / column.
-* Grabbed from TypeScript code base
-* @see https://github.com/microsoft/TypeScript/blob/aa9b6953441b53f8b14072c047f0519b611150c4/src/compiler/scanner.ts#L503
-*/
-var PositionConverter = class {
-	text;
-	_lineStarts;
-	get lineStarts() {
-		if (!this._lineStarts) this._lineStarts = this.computeLineStarts(this.text);
-		return this._lineStarts;
-	}
-	constructor(text) {
-		this.text = text;
-	}
-	positionFromOffset(offset) {
-		const lineNumber = this.computeLineOfPosition(offset);
-		const lineStart = this.lineStarts[lineNumber];
-		if (lineStart === void 0) throw new Error("Line start not found for computed line number");
-		return {
-			line: lineNumber,
-			column: offset - lineStart
-		};
-	}
-	computeLineOfPosition(offset) {
-		let lineNumber = binarySearch(this.lineStarts, offset);
-		if (lineNumber < 0) {
-			lineNumber = ~lineNumber - 1;
-			if (lineNumber === -1) throw new Error("position cannot precede the beginning of the file");
-		}
-		return lineNumber;
-	}
-	computeLineStarts(text) {
-		const result = [];
-		let pos = 0;
-		let lineStart = 0;
-		while (pos < text.length) {
-			const ch = text.charCodeAt(pos);
-			pos++;
-			switch (ch) {
-				case 13:
-					if (text.charCodeAt(pos) === 10) pos++;
-					result.push(lineStart);
-					lineStart = pos;
-					break;
-				case 10:
-					result.push(lineStart);
-					lineStart = pos;
-					break;
-				default: if (ch > 127 && isLineBreak(ch)) {
-					result.push(lineStart);
-					lineStart = pos;
-				}
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function isRangedProgram(value) {
+	return isPlainRecord(value) && typeof value["start"] === "number" && typeof value["end"] === "number";
+}
+function isWalkFunction(value) {
+	return typeof value === "function";
+}
+function isRangedBaseNode(value) {
+	return isPlainRecord(value) && typeof value["type"] === "string" && typeof value["start"] === "number" && typeof value["end"] === "number";
+}
+function isTemplateExpressionType(type) {
+	return type === "MustacheTag" || type === "RawMustacheTag" || type === "IfBlock" || type === "ConstTag" || type === "EachBlock" || type === "AwaitBlock" || type === "KeyBlock" || type === "EventHandler";
+}
+function tryGetScriptRangeFromElement(node) {
+	if (!isPlainRecord(node) || node["type"] !== "Element" || node["name"] !== "script") return;
+	const children = node["children"];
+	if (!isUnknownArray(children) || children.length === 0) return;
+	const firstChild = children[0];
+	if (!isPlainRecord(firstChild) || firstChild["type"] !== "Text" || typeof firstChild["start"] !== "number" || typeof firstChild["end"] !== "number") return;
+	return {
+		start: firstChild["start"],
+		end: firstChild["end"],
+		isExpression: false
+	};
+}
+async function parseSvelte(text, fileName, context) {
+	const { parse: svelteParse, preprocess, VERSION } = await import("svelte/compiler");
+	let walk;
+	if (!isSupportedSvelteVersion(VERSION)) throw new SvelteVersionNotSupported({
+		version: VERSION,
+		fileName,
+		cause: `Expected >=3.30`
+	});
+	if (isSvelteV5OrLater(VERSION)) {
+		const walkerModule = await import(import.meta.resolve("estree-walker"));
+		if (!isPlainRecord(walkerModule) || !isWalkFunction(walkerModule["walk"])) throw new SvelteWalkerNotFound({
+			fileName,
+			cause: "estree-walker module without walk export"
+		});
+		walk = walkerModule["walk"];
+	} else {
+		const svelteCompilerModule = await import("svelte/compiler");
+		if (!isPlainRecord(svelteCompilerModule) || !isWalkFunction(svelteCompilerModule["walk"])) throw new SvelteWalkerNotFound({
+			fileName,
+			cause: "svelte/compiler module without walk export"
+		});
+		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
+		};
+	}
+	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");
 			}
 		}
-		result.push(lineStart);
-		return result;
+		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;
 	}
-};
-function binarySearch(array, value) {
-	if (!array.length) return -1;
-	let low = 0;
-	let high = array.length - 1;
-	while (low <= high) {
-		const middle = low + (high - low >> 1);
-		const midValue = array[middle];
-		if (midValue === void 0) throw new Error("Binary search middle value is missing");
-		switch (compare(midValue, value)) {
-			case -1:
-				low = middle + 1;
-				break;
-			case 0: return middle;
-			case 1: high = middle - 1;
-		}
+	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
+		};
 	}
-	return ~low;
 }
-function compare(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
+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
+	};
 }
-function isLineBreak(ch) {
-	return ch === 10 || ch === 13 || ch === 8232 || ch === 8233;
+/**
+* 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/util/babel-generator.ts
+//#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
@@ -263,142 +695,319 @@ function isLineBreak(ch) {
 * time. Resolving both shapes once keeps the printers and the mutant's
 * replacement code identical under either layout.
 */
-const generate = typeof generator === "function" ? generator : generator.default;
-//#endregion
-//#region src/mutant.ts
-const { traverse: traverse$2 } = babel;
-var Mutant$1 = class {
-	id;
-	fileName;
-	original;
-	offset;
-	replacementCode;
-	replacement;
-	mutatorName;
-	ignoreReason;
-	constructor(id, fileName, original, specs, offset = {
-		column: 0,
-		line: 0
-	}) {
-		this.id = id;
-		this.fileName = fileName;
-		this.original = original;
-		this.offset = offset;
-		this.replacement = specs.replacement;
-		this.mutatorName = specs.mutatorName;
-		this.ignoreReason = specs.ignoreReason;
-		this.replacementCode = generate(this.replacement).code;
-	}
-	toApiMutant() {
-		const loc = this.original.loc;
-		if (loc === void 0 || loc === null) throw new Error("Babel node without a source location");
-		return {
-			fileName: this.fileName,
-			id: this.id,
-			location: toApiLocation(loc, this.offset),
-			mutatorName: this.mutatorName,
-			replacement: this.replacementCode,
-			...this.ignoreReason === void 0 ? {} : { statusReason: this.ignoreReason },
-			...this.ignoreReason === void 0 ? {} : { status: "Ignored" }
-		};
-	}
-	/**
-	* Applies the mutant in (a copy of) the AST, without changing provided AST.
-	* Can the tree itself (in which case the replacement is returned),
-	* or can be nested in the given tree.
-	*
-	* Returns a plain node rather than the argument's own type: whether the
-	* replacement fits a given position is the placer's claim, and the placer
-	* checks it with a Babel predicate. A generic return would have to assert it
-	* here, where nothing can check it.
-	* @param originalTree The original node, which will be treated as readonly
-	*/
-	applied(originalTree) {
-		if (originalTree === this.original) return this.replacement;
-		else {
-			const mutatedAst = deepCloneNode(originalTree);
-			let applied = false;
-			const { original, replacement } = this;
-			traverse$2(mutatedAst, {
-				noScope: true,
-				enter(path) {
-					if (eqNode(path.node, original)) {
-						path.replaceWith(replacement);
-						path.stop();
-						applied = true;
-					}
-				}
-			});
-			if (!applied) throw new Error(`Could not apply mutant ${JSON.stringify(this.replacement)}.`);
-			return mutatedAst;
-		}
-	}
-};
-function toApiLocation(source, offset) {
-	return {
-		start: toPosition(source.start, offset),
-		end: toPosition(source.end, offset)
-	};
-}
-function toPosition(source, offset) {
-	return {
-		column: source.column + (source.line === 1 ? offset.column : 0),
-		line: source.line + offset.line - 1
-	};
+function resolveGenerate$1() {
+	if (typeof generator === "function") return generator;
+	return generator.default;
 }
-//#endregion
-//#region src/mutators/arithmetic-operator-mutator.ts
-const arithmeticOperatorReplacements = Object.freeze({
-	"+": "-",
-	"-": "+",
-	"*": "/",
-	"/": "*",
-	"%": "*"
-});
-const arithmeticOperatorMutator = {
-	name: "ArithmeticOperator",
-	*mutate(path) {
-		if (path.isBinaryExpression() && isSupported$3(path.node.operator, path.node)) {
-			const mutatedOperator = arithmeticOperatorReplacements[path.node.operator];
-			const replacement = deepCloneNode(path.node);
-			replacement.operator = mutatedOperator;
-			yield replacement;
-		}
+const generate$2 = resolveGenerate$1();
+function print(file) {
+	const context = { print };
+	switch (file.format) {
+		case "js": return jsPrint(file, context);
+		case "ts": return tsPrint(file, context);
+		case "tsx": return tsPrint(file, context);
+		case "html": return htmlPrint(file, context);
+		case "svelte": return sveltePrint(file, context);
 	}
+}
+const jsPrint = (file) => {
+	return generate$2(file.root, { sourceMaps: false }).code;
 };
-function isSupported$3(operator, node) {
-	if (!Object.keys(arithmeticOperatorReplacements).includes(operator)) return false;
-	const stringTypes = ["StringLiteral", "TemplateLiteral"];
-	const leftType = node.left.type === "BinaryExpression" ? node.left.right.type : node.left.type;
-	if (stringTypes.includes(node.right.type) || stringTypes.includes(leftType)) return false;
-	return true;
+const tsPrint = (file) => {
+	return generate$2(file.root, {
+		decoratorsBeforeExport: true,
+		sourceMaps: false
+	}).code;
+};
+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;
 }
-//#endregion
-//#region src/mutators/array-declaration-mutator.ts
-const { types: types$14 } = babel;
-const arrayDeclarationMutator = {
-	name: "ArrayDeclaration",
-	*mutate(path) {
-		if (path.isArrayExpression()) yield path.node.elements.length ? types$14.arrayExpression() : types$14.arrayExpression([types$14.stringLiteral("Stryker was here")]);
-		if ((path.isCallExpression() || path.isNewExpression()) && types$14.isIdentifier(path.node.callee) && path.node.callee.name === "Array") {
-			const mutatedCallArgs = path.node.arguments.length ? [] : [types$14.arrayExpression()];
-			yield types$14.isNewExpression(path.node) ? types$14.newExpression(deepCloneNode(path.node.callee), mutatedCallArgs) : types$14.callExpression(deepCloneNode(path.node.callee), mutatedCallArgs);
-		}
+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 htmlPrint = (ast, context) => {
+	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart$1(a) - getScriptStart$1(b));
+	let currentIndex = 0;
+	let html = "";
+	for (const script of sortedScripts) {
+		html += ast.rawContent.substring(currentIndex, getScriptStart$1(script));
+		html += "\n";
+		html += context.print(script, context);
+		html += "\n";
+		currentIndex = getScriptEnd$1(script);
 	}
+	html += ast.rawContent.substr(currentIndex);
+	return html;
 };
-//#endregion
-//#region src/mutators/arrow-function-mutator.ts
-const { types: types$13 } = babel;
-const arrowFunctionMutator = {
-	name: "ArrowFunction",
-	*mutate(path) {
-		if (path.isArrowFunctionExpression() && !types$13.isBlockStatement(path.node.body) && !(types$13.isIdentifier(path.node.body) && path.node.body.name === "undefined")) yield types$13.arrowFunctionExpression([], types$13.identifier("undefined"));
+const sveltePrint = ({ root, rawContent }, context) => {
+	let currentIndex = 0;
+	let outputText = "";
+	const sortedScripts = [root.moduleScript, ...root.additionalScripts].filter(Predicate.isNotNullish).sort((a, b) => a.range.start - b.range.start);
+	for (const script of sortedScripts) if (script.isExpression) {
+		const codeWithoutSemicolon = context.print(script.ast, context).slice(0, -1);
+		outputText += rawContent.substring(currentIndex, script.range.start) + codeWithoutSemicolon;
+		currentIndex = script.range.end;
+	} else {
+		outputText += rawContent.substring(currentIndex, script.range.start);
+		outputText += "\n";
+		outputText += context.print(script.ast, context);
+		outputText += "\n";
+		currentIndex = script.range.end;
 	}
+	outputText += rawContent.substring(currentIndex);
+	return outputText;
 };
 //#endregion
-//#region src/mutators/assignment-operator-mutator.ts
-const assignmentOperatorReplacements = Object.freeze({
-	"+=": "-=",
+//#region src/Mutator.ts
+/**
+* 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);
+}
+function eqNode(a, b) {
+	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
+}
+function createMutant(id, fileName, original, specs, offset = {
+	column: 0,
+	line: 0
+}) {
+	return {
+		id,
+		fileName,
+		original,
+		offset,
+		replacement: specs.replacement,
+		mutatorName: specs.mutatorName,
+		ignoreReason: specs.ignoreReason,
+		replacementCode: generate$1(specs.replacement, { sourceMaps: false }).code
+	};
+}
+function applyMutant(mutant, originalTree) {
+	if (originalTree === mutant.original) return mutant.replacement;
+	const mutatedAst = deepCloneNode(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;
+			}
+		}
+	});
+	return applied;
+}
+/**
+* The mutations of a regular expression pattern.
+*
+* Pure: a pattern and its flags in, replacement patterns out. No I/O, no clock,
+* no throwing — a pattern this cannot parse yields no mutants, which is the
+* honest answer for a literal whose syntax the engine does not model.
+*
+* The transformation set is fixed and small, and each member changes exactly
+* one thing about the pattern:
+*
+* | family                  | example                  |
+* | ----------------------- | ------------------------ |
+* | anchor removal          | `^abc$` -> `abc$`, `^abc` |
+* | character class negation| `[abc]` <-> `[^abc]`      |
+* | predefined class negation| `\d` <-> `\D`, `\p{L}` <-> `\P{L}` |
+* | quantifier removal      | `a+`, `a*`, `a{2,3}` -> `a` |
+* | lookaround negation     | `(?=a)` <-> `(?!a)`, `(?<=a)` <-> `(?<!a)` |
+*
+* Alternation and grouping are deliberately untouched: swapping a branch or
+* dropping a group produces mutants that survive for reasons unrelated to the
+* test suite's strength, which inflates a score rather than measuring one.
+*
+* The order is part of the contract, because a mutant's identity in a report is
+* its position: anchors first, then each remaining position left to right with
+* quantifier removal ahead of class negation.
+*/
+function mutateRegexPattern(pattern, flags) {
+	if (pattern.length === 0) return [];
+	try {
+		const f = flags ?? "";
+		const ast = new RegExpParser().parsePattern(pattern, void 0, void 0, {
+			unicode: f.includes("u"),
+			unicodeSets: f.includes("v")
+		});
+		const bol = [];
+		const eol = [];
+		const rest = [];
+		visitRegExpAST(ast, {
+			onAssertionEnter(node) {
+				if (node.kind === "start") {
+					const splice = {
+						start: node.start,
+						end: node.end,
+						text: ""
+					};
+					if ((pattern.slice(0, splice.start) + splice.text + pattern.slice(splice.end)).length === 0) return;
+					bol.push(splice);
+				} else if (node.kind === "end") {
+					const splice = {
+						start: node.start,
+						end: node.end,
+						text: ""
+					};
+					if ((pattern.slice(0, splice.start) + splice.text + pattern.slice(splice.end)).length === 0) return;
+					eol.push(splice);
+				} else if (node.kind === "lookahead" || node.kind === "lookbehind") {
+					let offset;
+					if (node.kind === "lookahead") offset = 2;
+					else offset = 3;
+					const pos = node.start + offset;
+					let text;
+					if (node.negate) text = "=";
+					else text = "!";
+					rest.push({
+						start: pos,
+						end: pos + 1,
+						text,
+						priority: 1
+					});
+				}
+			},
+			onCharacterClassEnter(node) {
+				const pos = node.start + 1;
+				if (node.negate) rest.push({
+					start: pos,
+					end: pos + 1,
+					text: "",
+					priority: 1
+				});
+				else rest.push({
+					start: pos,
+					end: pos,
+					text: "^",
+					priority: 1
+				});
+			},
+			onCharacterSetEnter(node) {
+				if (node.kind === "digit" || node.kind === "space" || node.kind === "word") {
+					const pos = node.start + 1;
+					const cur = node.raw[1] ?? "";
+					let toggled;
+					if (cur === cur.toUpperCase()) toggled = cur.toLowerCase();
+					else toggled = cur.toUpperCase();
+					rest.push({
+						start: pos,
+						end: pos + 1,
+						text: toggled,
+						priority: 2
+					});
+				} else if (node.kind === "property") {
+					const pos = node.start + 1;
+					const cur = node.raw[1] ?? "";
+					let toggled;
+					if (cur === "p") toggled = "P";
+					else toggled = "p";
+					rest.push({
+						start: pos,
+						end: pos + 1,
+						text: toggled,
+						priority: 2
+					});
+				}
+			},
+			onQuantifierEnter(node) {
+				rest.push({
+					start: node.start,
+					end: node.end,
+					text: node.element.raw,
+					priority: 0
+				});
+			}
+		});
+		rest.sort((a, b) => a.start - b.start || a.priority - b.priority);
+		return [
+			...bol,
+			...eol,
+			...rest
+		].map((s) => pattern.slice(0, s.start) + s.text + pattern.slice(s.end));
+	} catch {
+		return [];
+	}
+}
+const arithmeticOperatorReplacements = Object.freeze({
+	"+": "-",
+	"-": "+",
+	"*": "/",
+	"/": "*",
+	"%": "*"
+});
+const arithmeticOperatorMutator = function* (node, _context) {
+	if (t$1.isBinaryExpression(node) && isSupportedArithmeticOperator(node.operator, node)) {
+		const mutatedOperator = arithmeticOperatorReplacements[node.operator];
+		const replacement = deepCloneNode(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;
+	return true;
+}
+const arrayDeclarationMutator = function* (node, _context) {
+	if (babelTypes$2.isArrayExpression(node)) {
+		let replacement;
+		if (node.elements.length > 0) replacement = babelTypes$2.arrayExpression();
+		else replacement = babelTypes$2.arrayExpression([babelTypes$2.stringLiteral("Stryker was here")]);
+		yield replacement;
+	}
+	if ((babelTypes$2.isCallExpression(node) || babelTypes$2.isNewExpression(node)) && babelTypes$2.isIdentifier(node.callee) && node.callee.name === "Array") {
+		let mutatedCallArgs;
+		if (node.arguments.length > 0) mutatedCallArgs = [];
+		else mutatedCallArgs = [babelTypes$2.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);
+		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"));
+};
+const assignmentOperatorReplacements = Object.freeze({
+	"+=": "-=",
 	"-=": "+=",
 	"*=": "/=",
 	"/=": "*=",
@@ -417,90 +1026,71 @@ const stringAssignmentTypes = Object.freeze([
 	"||=",
 	"??="
 ]);
-const assignmentOperatorMutator = {
-	name: "AssignmentOperator",
-	*mutate(path) {
-		if (path.isAssignmentExpression() && isSupportedAssignmentOperator(path.node.operator) && isSupported$2(path.node)) {
-			const mutatedOperator = assignmentOperatorReplacements[path.node.operator];
-			const replacement = deepCloneNode(path.node);
-			replacement.operator = mutatedOperator;
-			yield replacement;
-		}
+const assignmentOperatorMutator = function* (node, _context) {
+	if (babelTypes$2.isAssignmentExpression(node) && isSupportedAssignmentOperator(node.operator) && isSupportedAssignmentExpression(node)) {
+		const mutatedOperator = assignmentOperatorReplacements[node.operator];
+		const replacement = deepCloneNode(node);
+		replacement.operator = mutatedOperator;
+		yield replacement;
 	}
 };
 function isSupportedAssignmentOperator(operator) {
 	return Object.keys(assignmentOperatorReplacements).includes(operator);
 }
-function isSupported$2(node) {
+function isSupportedAssignmentExpression(node) {
 	if (stringTypes.includes(node.right.type) && !stringAssignmentTypes.includes(node.operator)) return false;
 	return true;
 }
-//#endregion
-//#region src/mutators/block-statement-mutator.ts
-const { types: types$12 } = babel;
-const blockStatementMutator = {
-	name: "BlockStatement",
-	*mutate(path) {
-		if (path.isBlockStatement() && isValid(path)) yield types$12.blockStatement([]);
-	}
+const blockStatementMutator = function* (node, context) {
+	if (babelTypes$2.isBlockStatement(node) && isValid(node, context)) yield babelTypes$2.blockStatement([]);
 };
-function isValid(path) {
-	return !isEmpty(path) && !isInvalidConstructorBody(path);
-}
-function isEmpty(path) {
-	return !path.node.body.length;
-}
-/**
-* Checks to see if a statement is an invalid constructor body
-* @example
-* // Invalid!
-* class Foo extends Bar {
-*   constructor(public baz: string) {
-*     super(42);
-*   }
-* }
-* @example
-* // Invalid!
-* class Foo extends Bar {
-*   public baz = 'string';
-*   constructor() {
-*     super(42);
-*   }
-* }
-* @see https://github.com/stryker-mutator/stryker-js/issues/2314
-* @see https://github.com/stryker-mutator/stryker-js/issues/2474
-*/
-function isInvalidConstructorBody(blockStatement) {
-	return Boolean(blockStatement.parentPath.isClassMethod() && blockStatement.parentPath.node.kind === "constructor" && (containsTSParameterProperties(blockStatement.parentPath) || containsInitializedClassProperties(blockStatement.parentPath)) && hasSuperExpression(blockStatement));
-}
-function containsTSParameterProperties(constructor) {
-	return constructor.node.params.some((param) => types$12.isTSParameterProperty(param));
-}
-function containsInitializedClassProperties(constructor) {
-	return constructor.parentPath.isClassBody() && constructor.parentPath.node.body.some((classMember) => types$12.isClassProperty(classMember) && classMember.value);
-}
-function hasSuperExpression(constructor) {
-	let hasSuper = false;
-	constructor.traverse({ Super(path) {
-		if (path.parentPath.isCallExpression()) {
-			path.stop();
-			hasSuper = true;
-		}
-	} });
-	return hasSuper;
-}
-//#endregion
-//#region src/mutators/boolean-literal-mutator.ts
-const { types: types$11 } = babel;
-const booleanLiteralMutator = {
-	name: "BooleanLiteral",
-	*mutate(path) {
-		if (path.isBooleanLiteral()) yield types$11.booleanLiteral(!path.node.value);
-		if (path.isUnaryExpression() && path.node.operator === "!" && path.node.prefix) yield deepCloneNode(path.node.argument);
-	}
+function isValid(node, context) {
+	return !isEmpty(node) && !isInvalidConstructorBody(node, context);
+}
+function isEmpty(node) {
+	return node.body.length === 0;
+}
+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));
+	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);
+}
+function hasSuperExpression(block) {
+	return containsSuperCall(block);
+}
+function isSuperType(node) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "Super";
+}
+function isSuperCallExpression(node) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "CallExpression" && Predicate.hasProperty(node, "callee") && isSuperType(node["callee"]);
+}
+function containsSuperCall(node) {
+	if (typeof node !== "object" || node === null) return false;
+	if (isSuperType(node) || isSuperCallExpression(node)) return true;
+	return hasSuperInChildren(node);
+}
+function hasSuperInChildren(node) {
+	for (const key of Object.keys(node)) {
+		if (!Predicate.hasProperty(node, key)) continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const element of value) if (containsSuperCall(element)) return true;
+		} else if (typeof value === "object" && value !== null && containsSuperCall(value)) return true;
+	}
+	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);
 };
-//#endregion
-//#region src/mutators/conditional-expression-mutator.ts
 const booleanOperators = Object.freeze([
 	"!=",
 	"!==",
@@ -513,54 +1103,53 @@ const booleanOperators = Object.freeze([
 	">=",
 	"||"
 ]);
-const { types: types$10 } = babel;
-const conditionalExpressionMutator = {
-	name: "ConditionalExpression",
-	*mutate(path) {
-		if (isTestOfLoop(path)) yield types$10.booleanLiteral(false);
-		else if (isTestOfCondition(path)) {
-			yield types$10.booleanLiteral(true);
-			yield types$10.booleanLiteral(false);
-		} else if (isBooleanExpression(path)) {
-			if (path.parent?.type === "LogicalExpression") {
-				if (path.parent.operator === "||") {
-					yield types$10.booleanLiteral(false);
-					return;
-				}
-				if (path.parent.operator === "&&") {
-					yield types$10.booleanLiteral(true);
-					return;
-				}
+const conditionalExpressionMutator = function* (node, context) {
+	if (isTestOfLoop(node, context)) yield babelTypes$2.booleanLiteral(false);
+	else if (isTestOfCondition(node, context)) {
+		yield babelTypes$2.booleanLiteral(true);
+		yield babelTypes$2.booleanLiteral(false);
+	} else if (isBooleanExpression(node)) {
+		const parent = context.parent;
+		if (parent !== void 0 && babelTypes$2.isLogicalExpression(parent)) {
+			if (parent.operator === "||") {
+				yield babelTypes$2.booleanLiteral(false);
+				return;
+			}
+			if (parent.operator === "&&") {
+				yield babelTypes$2.booleanLiteral(true);
+				return;
 			}
-			yield types$10.booleanLiteral(true);
-			yield types$10.booleanLiteral(false);
-		} else if (path.isForStatement() && !path.node.test) {
-			const replacement = deepCloneNode(path.node);
-			replacement.test = types$10.booleanLiteral(false);
-			yield replacement;
-		} else if (path.isSwitchCase() && path.node.consequent.length > 0) {
-			const replacement = deepCloneNode(path.node);
-			replacement.consequent = [];
-			yield replacement;
 		}
+		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 replacement;
+	} else if (babelTypes$2.isSwitchCase(node) && node.consequent.length > 0) {
+		const replacement = deepCloneNode(node);
+		replacement.consequent = [];
+		yield replacement;
 	}
 };
-function isTestOfLoop(path) {
-	const { parentPath } = path;
-	if (!parentPath) return false;
-	return (parentPath.isForStatement() || parentPath.isWhileStatement() || parentPath.isDoWhileStatement()) && parentPath.node.test === path.node;
-}
-function isTestOfCondition(path) {
-	const { parentPath } = path;
-	if (!parentPath) return false;
-	return parentPath.isIfStatement() && parentPath.node.test === path.node;
+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;
+	return false;
+}
+function isTestOfCondition(node, context) {
+	const parent = context.parent;
+	if (parent === void 0) return false;
+	return babelTypes$2.isIfStatement(parent) && 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);
+	return false;
 }
-function isBooleanExpression(path) {
-	return (path.isBinaryExpression() || path.isLogicalExpression()) && booleanOperators.includes(path.node.operator);
-}
-//#endregion
-//#region src/mutators/equality-operator-mutator.ts
-const { types: t$2 } = babel;
 const operators = {
 	"<": ["<=", ">="],
 	"<=": ["<", ">"],
@@ -574,329 +1163,502 @@ const operators = {
 function isEqualityOperator(operator) {
 	return Object.keys(operators).includes(operator);
 }
-const equalityOperatorMutator = {
-	name: "EqualityOperator",
-	*mutate(path) {
-		if (path.isBinaryExpression() && isEqualityOperator(path.node.operator)) for (const mutableOperator of operators[path.node.operator]) {
-			const replacement = t$2.cloneNode(path.node, true);
-			replacement.operator = mutableOperator;
-			yield replacement;
-		}
+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);
+		replacement.operator = mutableOperator;
+		yield replacement;
 	}
 };
-//#endregion
-//#region src/mutators/logical-operator-mutator.ts
 const logicalOperatorReplacements = Object.freeze({
 	"&&": "||",
 	"||": "&&",
 	"??": "&&"
 });
-const logicalOperatorMutator = {
-	name: "LogicalOperator",
-	*mutate(path) {
-		if (path.isLogicalExpression() && isSupported$1(path.node.operator)) {
-			const mutatedOperator = logicalOperatorReplacements[path.node.operator];
-			const replacement = deepCloneNode(path.node);
-			replacement.operator = mutatedOperator;
-			yield replacement;
-		}
+const logicalOperatorMutator = function* (node, _context) {
+	if (babelTypes$2.isLogicalExpression(node) && isSupportedLogicalOperator(node.operator)) {
+		const mutatedOperator = logicalOperatorReplacements[node.operator];
+		const replacement = deepCloneNode(node);
+		replacement.operator = mutatedOperator;
+		yield replacement;
 	}
 };
-function isSupported$1(operator) {
+function isSupportedLogicalOperator(operator) {
 	return Object.keys(logicalOperatorReplacements).includes(operator);
 }
-//#endregion
-//#region src/mutators/method-expression-mutator.ts
-const { types: types$9 } = babel;
-const replacements = /* @__PURE__ */ new Map([
-	["charAt", null],
-	["endsWith", "startsWith"],
-	["every", "some"],
-	["filter", null],
-	["reverse", null],
-	["slice", null],
-	["sort", null],
-	["substr", null],
-	["substring", null],
-	["toLocaleLowerCase", "toLocaleUpperCase"],
-	["toLowerCase", "toUpperCase"],
-	["trim", null],
-	["trimEnd", "trimStart"],
-	["min", "max"],
-	["setDate", "setTime"],
-	["setFullYear", "setMonth"],
-	["setHours", "setMinutes"],
-	["setSeconds", "setMilliseconds"],
-	["setUTCDate", "setTime"],
-	["setUTCFullYear", "setUTCMonth"],
-	["setUTCHours", "setUTCMinutes"],
-	["setUTCSeconds", "setUTCMilliseconds"]
-]);
-const noReverseRemplacements = ["getUTCDate", "setUTCDate"];
-for (const [key, value] of Array.from(replacements)) if (value && !noReverseRemplacements.includes(key)) replacements.set(value, key);
-const methodExpressionMutator = {
-	name: "MethodExpression",
-	*mutate(path) {
-		if (!(path.isCallExpression() || path.isOptionalCallExpression())) return;
-		const { callee } = path.node;
-		if (!(types$9.isMemberExpression(callee) || types$9.isOptionalMemberExpression(callee)) || !types$9.isIdentifier(callee.property)) return;
-		const newName = replacements.get(callee.property.name);
-		if (newName === void 0) return;
-		if (newName === null) {
-			yield deepCloneNode(callee.object);
-			return;
-		}
-		const nodeArguments = path.node.arguments.map((argumentNode) => deepCloneNode(argumentNode));
-		const mutatedCallee = types$9.isMemberExpression(callee) ? types$9.memberExpression(deepCloneNode(callee.object), types$9.identifier(newName), false, callee.optional) : types$9.optionalMemberExpression(deepCloneNode(callee.object), types$9.identifier(newName), false, callee.optional);
-		yield types$9.isCallExpression(path.node) ? types$9.callExpression(mutatedCallee, nodeArguments) : types$9.optionalCallExpression(mutatedCallee, nodeArguments, path.node.optional);
-	}
+const baseReplacements = {
+	charAt: null,
+	endsWith: "startsWith",
+	every: "some",
+	filter: null,
+	reverse: null,
+	slice: null,
+	sort: null,
+	substr: null,
+	substring: null,
+	toLocaleLowerCase: "toLocaleUpperCase",
+	toLowerCase: "toUpperCase",
+	trim: null,
+	trimEnd: "trimStart",
+	min: "max",
+	setDate: "setTime",
+	setFullYear: "setMonth",
+	setHours: "setMinutes",
+	setSeconds: "setMilliseconds",
+	setUTCDate: "setTime",
+	setUTCFullYear: "setUTCMonth",
+	setUTCHours: "setUTCMinutes",
+	setUTCSeconds: "setUTCMilliseconds"
 };
-//#endregion
-//#region src/mutators/object-literal-mutator.ts
-const { types: types$8 } = babel;
-const objectLiteralMutator = {
-	name: "ObjectLiteral",
-	*mutate(path) {
-		if (path.isObjectExpression() && path.node.properties.length > 0) yield types$8.objectExpression([]);
-	}
+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;
+	const { callee } = node;
+	if (!(babelTypes$2.isMemberExpression(callee) || babelTypes$2.isOptionalMemberExpression(callee)) || !babelTypes$2.isIdentifier(callee.property)) return;
+	const newName = replacements.get(callee.property.name);
+	if (newName === void 0) return;
+	if (newName === null) {
+		yield deepCloneNode(callee.object);
+		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);
 };
-//#endregion
-//#region src/mutators/optional-chaining-mutator.ts
-const { types: t$1 } = babel;
-/**
-* Mutates optional chaining operators
-* Note that the AST for optional chaining might not be what you expect. Nodes of type `OptionalMemberExpression` can be either optional or not-optional
-*
-* For example: In this expression: `foo?.bar.baz` the `.baz` member expression is of type `OptionalMemberExpression`, because it is part of an optional chain, but is is _not_ optional.
-* Only the `.bar` optional member expression is optional.
-*
-* @example
-* foo?.bar -> foo.bar
-* foo?.[1] -> foo[1]
-* foo?.() -> foo()
-*/
-const optionalChainingMutator = {
-	name: "OptionalChaining",
-	*mutate(path) {
-		if (path.isOptionalMemberExpression() && path.node.optional) yield t$1.optionalMemberExpression(t$1.cloneNode(path.node.object, true), t$1.cloneNode(path.node.property, true), path.node.computed, false);
-		if (path.isOptionalCallExpression() && path.node.optional) yield t$1.optionalCallExpression(t$1.cloneNode(path.node.callee, true), path.node.arguments.map((arg) => t$1.cloneNode(arg, true)), false);
-	}
+const objectLiteralMutator = function* (node, _context) {
+	if (babelTypes$2.isObjectExpression(node) && node.properties.length > 0) yield babelTypes$2.objectExpression([]);
 };
-//#endregion
-//#region src/mutators/regex-mutator.ts
-const { types: types$7 } = babel;
-/**
-* Checks that a string literal is an obvious regex string literal
-* @param path The string literal to checks
-* @example
-* new RegExp("\\d{4}");
-*/
-function isObviousRegexString(path) {
-	return path.parentPath.isNewExpression() && types$7.isIdentifier(path.parentPath.node.callee) && path.parentPath.node.callee.name === RegExp.name && path.parentPath.node.arguments[0] === path.node;
-}
-function getFlags(path) {
-	if (types$7.isStringLiteral(path.node.arguments[1])) return path.node.arguments[1].value;
-}
-const weaponRegexOptions = { mutationLevels: [1] };
-const regexMutator = {
-	name: "Regex",
-	*mutate(path) {
-		if (path.isRegExpLiteral()) for (const replacementPattern of mutatePattern(path.node.pattern, path.node.flags)) yield types$7.regExpLiteral(replacementPattern, path.node.flags);
-		else if (path.isStringLiteral() && isObviousRegexString(path)) {
-			const parentPath = path.parentPath;
-			if (parentPath.isNewExpression()) {
-				const flags = getFlags(parentPath);
-				for (const replacementPattern of mutatePattern(path.node.value, flags)) yield types$7.stringLiteral(replacementPattern);
-			}
+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);
+};
+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)) {
+		const parent = context.parent;
+		if (parent !== void 0 && babelTypes$2.isNewExpression(parent)) {
+			const flags = getFlags(parent);
+			for (const replacementPattern of mutateRegexPattern(node.value, flags)) yield babelTypes$2.stringLiteral(replacementPattern);
 		}
 	}
 };
-function mutatePattern(pattern, flags) {
-	if (pattern.length) try {
-		return weaponRegex.mutate(pattern, flags, weaponRegexOptions).map((mutant) => mutant.pattern);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : typeof err === "string" ? err : JSON.stringify(err) ?? "Unknown error";
-		console.error(`[RegexMutator]: The Regex parser of weapon-regex couldn't parse this regex pattern: "${pattern}". Please report this issue at https://github.com/stryker-mutator/weapon-regex/issues. Inner error: ${message}`);
-	}
-	return [];
-}
-//#endregion
-//#region src/mutators/string-literal-mutator.ts
-const { types: types$6 } = babel;
-const stringLiteralMutator = {
-	name: "StringLiteral",
-	*mutate(path) {
-		if (path.isTemplateLiteral()) {
-			const firstQuasi = path.node.quasis[0];
-			if (firstQuasi === void 0) throw new Error("Template literal without quasis");
-			const replacement = path.node.quasis.length === 1 && firstQuasi.value.raw.length === 0 ? "Stryker was here!" : "";
-			yield types$6.templateLiteral([types$6.templateElement({ raw: replacement })], []);
-		}
-		if (path.isStringLiteral() && isValidParent(path)) yield types$6.stringLiteral(path.node.value.length === 0 ? "Stryker was here!" : "");
+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;
+	return parent.arguments[0] === node;
+}
+function getFlags(node) {
+	const secondArg = node.arguments[1];
+	if (secondArg !== void 0 && babelTypes$2.isStringLiteral(secondArg)) return secondArg.value;
+}
+const stringLiteralMutator = function* (node, context) {
+	if (babelTypes$2.isTemplateLiteral(node)) {
+		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 })], []);
+	}
+	if (babelTypes$2.isStringLiteral(node) && isValidParent(node, context)) {
+		let replacement;
+		if (node.value.length === 0) replacement = "Stryker was here!";
+		else replacement = "";
+		yield babelTypes$2.stringLiteral(replacement);
 	}
 };
-function isValidParent(child) {
-	const { parent } = child;
+function isValidParent(child, context) {
+	const parent = context.parent;
+	if (parent === void 0) return true;
 	return !isImportExportRelated(parent) && !isJsxOrExpressionRelated(parent) && !isObjectOrClassPropertyKey(parent, child) && !isDisallowedCallExpression(parent);
 }
 function isImportExportRelated(parent) {
-	return types$6.isImportDeclaration(parent) || types$6.isExportDeclaration(parent) || types$6.isImportOrExportDeclaration(parent) || types$6.isTSExternalModuleReference(parent);
+	return babelTypes$2.isImportDeclaration(parent) || babelTypes$2.isExportDeclaration(parent) || babelTypes$2.isImportOrExportDeclaration(parent) || babelTypes$2.isTSExternalModuleReference(parent);
 }
 function isJsxOrExpressionRelated(parent) {
-	return types$6.isJSXAttribute(parent) || types$6.isExpressionStatement(parent) || types$6.isTSLiteralType(parent) || types$6.isObjectMethod(parent);
+	return babelTypes$2.isJSXAttribute(parent) || babelTypes$2.isExpressionStatement(parent) || babelTypes$2.isTSLiteralType(parent) || babelTypes$2.isObjectMethod(parent);
 }
 function isObjectOrClassPropertyKey(parent, child) {
-	return types$6.isObjectProperty(parent) && parent.key === child.node || types$6.isClassProperty(parent) && parent.key === child.node;
+	return babelTypes$2.isObjectProperty(parent) && parent.key === child || babelTypes$2.isClassProperty(parent) && parent.key === child;
 }
 function isDisallowedCallExpression(parent) {
 	return isRequireCall(parent) || isSymbolCall(parent) || isImportCall(parent);
 }
 function isRequireCall(parent) {
-	return types$6.isCallExpression(parent) && types$6.isIdentifier(parent.callee, { name: "require" });
+	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isIdentifier(parent.callee, { name: "require" });
 }
 function isSymbolCall(parent) {
-	return types$6.isCallExpression(parent) && types$6.isIdentifier(parent.callee, { name: "Symbol" });
+	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isIdentifier(parent.callee, { name: "Symbol" });
 }
 function isImportCall(parent) {
-	return types$6.isCallExpression(parent) && types$6.isImport(parent.callee);
+	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isImport(parent.callee);
 }
-//#endregion
-//#region src/mutators/unary-operator-mutator.ts
-const { types: types$5 } = babel;
-var UnaryOperator = /* @__PURE__ */ function(UnaryOperator) {
-	UnaryOperator["+"] = "-";
-	UnaryOperator["-"] = "+";
-	UnaryOperator["~"] = "";
-	return UnaryOperator;
-}(UnaryOperator || {});
-const unaryOperatorMutator = {
-	name: "UnaryOperator",
-	*mutate(path) {
-		if (path.isUnaryExpression() && isSupported(path.node.operator) && path.node.prefix) {
-			const mutatedOperator = UnaryOperator[path.node.operator];
-			yield isPlusOrMinus(mutatedOperator) ? types$5.unaryExpression(mutatedOperator, deepCloneNode(path.node.argument)) : deepCloneNode(path.node.argument);
-		}
+const UnaryOperator = {
+	"+": "-",
+	"-": "+",
+	"~": ""
+};
+const unaryOperatorMutator = function* (node, _context) {
+	if (babelTypes$2.isUnaryExpression(node) && 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);
+		yield replacement;
 	}
 };
-function isSupported(operator) {
+function isSupportedUnaryOperator(operator) {
 	return Object.keys(UnaryOperator).includes(operator);
 }
 function isPlusOrMinus(operator) {
 	return operator === "-" || operator === "+";
 }
+const UpdateOperators = {
+	"++": "--",
+	"--": "++"
+};
+const updateOperatorMutator = function* (node, _context) {
+	if (babelTypes$2.isUpdateExpression(node)) yield babelTypes$2.updateExpression(UpdateOperators[node.operator], deepCloneNode(node.argument), node.prefix);
+};
+/**
+* Every mutator this instrumenter can apply, named explicitly.
+*
+* This list is deliberately hand-written rather than self-registering. A
+* registry populated by import side effects — each mutator module calling
+* `registerMutator(self)` at module scope — makes the mutant population depend
+* on which imports were evaluated: import order decides the order, a bundler
+* that judges a side-effect-only import unused drops a mutator entirely, and
+* anything reading the array before the last import finished sees a short list.
+* Every one of those failures REMOVES mutants, which RAISES the mutation score,
+* so the tool reports a better number for doing less work and nothing anywhere
+* says so.
+*
+* Naming each mutator here costs one line when a mutator is added and makes
+* that line a compile-checked import instead of a runtime effect.
+*/
+const allMutators = Object.freeze({
+	ArithmeticOperator: arithmeticOperatorMutator,
+	ArrayDeclaration: arrayDeclarationMutator,
+	ArrowFunction: arrowFunctionMutator,
+	AssignmentOperator: assignmentOperatorMutator,
+	BlockStatement: blockStatementMutator,
+	BooleanLiteral: booleanLiteralMutator,
+	ConditionalExpression: conditionalExpressionMutator,
+	EqualityOperator: equalityOperatorMutator,
+	LogicalOperator: logicalOperatorMutator,
+	MethodExpression: methodExpressionMutator,
+	ObjectLiteral: objectLiteralMutator,
+	OptionalChaining: optionalChainingMutator,
+	Regex: regexMutator,
+	StringLiteral: stringLiteralMutator,
+	UnaryOperator: unaryOperatorMutator,
+	UpdateOperator: updateOperatorMutator
+});
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/PlacementFailed")("PlacementFailed", {
+	fileName: S.String,
+	placerName: S.String,
+	mutantIds: S.Array(S.String),
+	cause: S.Defect()
+});
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/TransformFailed")("TransformFailed", {
+	fileName: S.String,
+	cause: S.Defect()
+});
 //#endregion
-//#region src/mutators/update-operator-mutator.ts
-const { types: types$4 } = babel;
-var UpdateOperators = /* @__PURE__ */ function(UpdateOperators) {
-	UpdateOperators["++"] = "--";
-	UpdateOperators["--"] = "++";
-	return UpdateOperators;
-}(UpdateOperators || {});
-//#endregion
-//#region src/mutators/mutate.ts
-const allMutators = [
-	arithmeticOperatorMutator,
-	arrayDeclarationMutator,
-	arrowFunctionMutator,
-	blockStatementMutator,
-	booleanLiteralMutator,
-	conditionalExpressionMutator,
-	equalityOperatorMutator,
-	logicalOperatorMutator,
-	methodExpressionMutator,
-	objectLiteralMutator,
-	stringLiteralMutator,
-	unaryOperatorMutator,
-	{
-		name: "UpdateOperator",
-		*mutate(path) {
-			if (path.isUpdateExpression()) yield types$4.updateExpression(UpdateOperators[path.node.operator], deepCloneNode(path.node.argument), path.node.prefix);
+//#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";
+function createMutantCollector() {
+	return [];
+}
+function collect(collector, fileName, original, mutable, offset = {
+	line: 0,
+	column: 0
+}) {
+	const mutant = createMutant(collector.length.toString(), fileName, original, mutable, offset);
+	collector.push(mutant);
+	return mutant;
+}
+function hasPlacedMutants(collector, fileName) {
+	return collector.some((mutant) => mutant.fileName === fileName && mutant.ignoreReason === void 0);
+}
+const WILDCARD = "all";
+const DEFAULT_REASON = "Ignored using a comment";
+const strykerCommentDirectiveRegex = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z, ]+)(?::(.+)?)?/;
+const rootRule = { kind: "Root" };
+function findIgnoreReason(rule, mutatorName, line) {
+	const lower = mutatorName.toLowerCase();
+	let current = rule;
+	for (;;) switch (current.kind) {
+		case "Root": return;
+		case "Ignore": {
+			const lineMatches = current.line === void 0 || current.line === line;
+			const mutatorMatches = current.mutatorNames.includes(lower) || current.mutatorNames.includes(WILDCARD);
+			if (lineMatches && mutatorMatches) return current.ignoreReason;
+			current = current.previous;
+			break;
+		}
+		case "Restore": {
+			const lineMatches = current.line === void 0 || current.line === line;
+			const mutatorMatches = current.mutatorNames.includes(lower) || current.mutatorNames.includes(WILDCARD);
+			if (lineMatches && mutatorMatches) return;
+			current = current.previous;
+			break;
 		}
-	},
-	regexMutator,
-	optionalChainingMutator,
-	assignmentOperatorMutator
-];
-//#endregion
-//#region src/transformers/mutant-collector.ts
-var MutantCollector = class {
-	_mutants = [];
-	get mutants() {
-		return this._mutants;
 	}
-	/**
-	* Adds mutants to the internal mutant list.
-	* @param fileName file name that houses the mutant
-	* @param original The node to mutate
-	* @param mutables the named node mutation to be added
-	* @param contextPath the context where these mutants are found and should be placed as close by as possible
-	* @param offset offset of mutant nodes
-	* @returns The mutant (for testability)
-	*/
-	collect(fileName, original, mutable, offset = {
-		line: 0,
-		column: 0
-	}) {
-		const mutant = new Mutant$1(this._mutants.length.toString(), fileName, original, mutable, offset);
-		this._mutants.push(mutant);
-		return mutant;
+}
+function processStrykerDirectives(rule, node, allMutatorNames, originFileName) {
+	const leadingComments = node.leadingComments;
+	if (!leadingComments) return {
+		rule,
+		warnings: []
+	};
+	let current = rule;
+	const warnings = [];
+	for (const comment of leadingComments) {
+		const matchResult = strykerCommentDirectiveRegex.exec(comment.value);
+		if (!matchResult) continue;
+		const directiveType = matchResult[1];
+		const scope = matchResult[2];
+		const mutators = matchResult[3];
+		const optionalReason = matchResult[4];
+		if (directiveType === void 0 || mutators === void 0) throw new Error("Stryker directive without directive type or mutators");
+		let mutatorNames = mutators.split(",").map((mutator) => mutator.trim());
+		for (const mutator of mutatorNames) {
+			if (mutator === WILDCARD) continue;
+			if (!allMutatorNames.includes(mutator.toLowerCase())) {
+				const commentLoc = comment.loc;
+				if (commentLoc == null) throw new Error("Comment without location");
+				let directiveLabel;
+				if (scope !== void 0 && scope !== "") directiveLabel = `${directiveType} ${scope}`;
+				else directiveLabel = directiveType;
+				warnings.push(`Unused 'Stryker ${directiveLabel}' directive. Mutator with name '${mutator}' not found. Directive found at: ${originFileName}:${commentLoc.start.line}:${commentLoc.start.column}.`);
+			}
+		}
+		mutatorNames = mutatorNames.map((mutator) => mutator.toLowerCase());
+		const reason = (optionalReason ?? DEFAULT_REASON).trim();
+		current = applyDirective(current, directiveType, scope, mutatorNames, reason, node.loc);
 	}
-	hasPlacedMutants(fileName) {
-		return this.mutants.some((mutant) => mutant.fileName === fileName && !mutant.ignoreReason);
+	return {
+		rule: current,
+		warnings
+	};
+}
+function applyDirective(rule, directiveType, scope, mutatorNames, reason, loc) {
+	switch (directiveType) {
+		case "disable": return applyDisable(rule, scope, mutatorNames, reason, loc);
+		case "restore": return applyRestore(rule, scope, mutatorNames, loc);
+		default: return rule;
+	}
+}
+function applyDisable(rule, scope, mutatorNames, reason, loc) {
+	switch (scope) {
+		case "next-line": return {
+			kind: "Ignore",
+			mutatorNames,
+			line: getLine(loc),
+			ignoreReason: reason,
+			previous: rule
+		};
+		case void 0:
+		default: return {
+			kind: "Ignore",
+			mutatorNames,
+			line: void 0,
+			ignoreReason: reason,
+			previous: rule
+		};
 	}
-};
-//#endregion
-//#region src/mutant-placers/mutant-placer.ts
+}
+function applyRestore(rule, scope, mutatorNames, loc) {
+	switch (scope) {
+		case "next-line": return {
+			kind: "Restore",
+			mutatorNames,
+			line: getLine(loc),
+			previous: rule
+		};
+		case void 0:
+		default: return {
+			kind: "Restore",
+			mutatorNames,
+			line: void 0,
+			previous: rule
+		};
+	}
+}
+function getLine(loc) {
+	if (loc == null) throw new Error("Babel node without location");
+	return loc.start.line;
+}
+function toIgnorerPath(path) {
+	let parentResult = null;
+	if (path.parentPath !== null) parentResult = toIgnorerPath(path.parentPath);
+	return {
+		node: path.node,
+		parentPath: parentResult,
+		isObjectExpression() {
+			return path.isObjectExpression();
+		},
+		isCallExpression() {
+			return path.isCallExpression() || path.isOptionalCallExpression();
+		},
+		isClassProperty() {
+			return path.isClassProperty();
+		},
+		isClassPrivateProperty() {
+			return path.isClassPrivateProperty();
+		},
+		isClassAccessorProperty() {
+			return path.isClassAccessorProperty();
+		}
+	};
+}
 /**
-* 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.
+* 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 nodeOfKind(mutant, node, isKind, kind) {
-	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
-	return node;
+function createBabelFile(filename, code, ast) {
+	return new File({ filename }, {
+		code,
+		ast
+	});
+}
+function isTypeNode(path) {
+	return path.isTypeAnnotation() || flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path) || isDeclareModule(path);
 }
-//#endregion
-//#region src/mutant-placers/expression-mutant-placer.ts
-const { types: types$3 } = babel;
 /**
-* Will set the identifier of anonymous function expressions if is located in a variable declaration.
-* Will treat input as readonly. Returns undefined if not needed.
+* Determines whether or not it is a declare variable statement node.
 * @example
-* const a = function() { }
-* becomes
-* const a = function a() {}
+* declare const foo: 'foo';
 */
-function classOrFunctionExpressionNamedIfNeeded(path) {
-	if ((path.isFunctionExpression() || path.isClassExpression()) && !path.node.id) {
-		if (path.parentPath.isVariableDeclarator() && types$3.isIdentifier(path.parentPath.node.id)) {
-			path.node.id = path.parentPath.node.id;
-			return path.node;
-		} else if (path.parentPath.isObjectProperty() && types$3.isIdentifier(path.parentPath.node.key) && path.getStatementParent()?.isVariableDeclaration()) {
-			path.node.id = path.parentPath.node.key;
-			return path.node;
-		}
-	}
+function isDeclareVariableStatement(path) {
+	return path.isVariableDeclaration() && path.node.declare === true;
 }
 /**
-* Will set the identifier of anonymous arrow function expressions if is located in a variable declaration.
-* Will treat input as readonly. Returns undefined if not needed.
+* Determines whether or not a node is a string literal that is the name of a module.
 * @example
-* const a = () => { }
-* becomes
-* const a = (() => { const a = () => {}; return a; })()
+* declare module "express" {};
 */
-function arrowFunctionExpressionNamedIfNeeded(path) {
-	if (path.isArrowFunctionExpression() && path.parentPath.isVariableDeclarator() && types$3.isIdentifier(path.parentPath.node.id)) return types$3.callExpression(types$3.arrowFunctionExpression([], types$3.blockStatement([types$3.variableDeclaration("const", [types$3.variableDeclarator(path.parentPath.node.id, path.node)]), types$3.returnStatement(path.parentPath.node.id)])), []);
+function isDeclareModule(path) {
+	return path.isTSModuleDeclaration() && (path.node.declare ?? false);
 }
-function nameIfAnonymous(path) {
-	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowFunctionExpressionNamedIfNeeded(path) ?? path.node;
+const tsTypeAnnotationNodeTypes = Object.freeze([
+	"TSAsExpression",
+	"TSInterfaceDeclaration",
+	"TSTypeAnnotation",
+	"TSTypeAliasDeclaration",
+	"TSEnumDeclaration",
+	"TSDeclareFunction",
+	"TSTypeParameterInstantiation",
+	"TSTypeParameterDeclaration"
+]);
+const flowTypeAnnotationNodeTypes = Object.freeze([
+	"DeclareClass",
+	"DeclareFunction",
+	"DeclareInterface",
+	"DeclareModule",
+	"DeclareModuleExports",
+	"DeclareTypeAlias",
+	"DeclareOpaqueType",
+	"DeclareVariable",
+	"DeclareExportDeclaration",
+	"DeclareExportAllDeclaration",
+	"InterfaceDeclaration",
+	"OpaqueType",
+	"TypeAlias",
+	"InterfaceDeclaration"
+]);
+function isImportDeclaration(path) {
+	return babelTypes$1.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
 }
-function isMemberOrCallOrNonNullExpression(path) {
-	return isCallExpression(path) || isMemberOrNonNullExpression(path);
+/**
+* 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)]);
 }
-function isMemberOrNonNullExpression(path) {
+/**
+* Returns a sequence of mutation coverage counters with an optional last expression.
+*
+* @example (global.__coverMutant__(0, 1), 40 + 2)
+* @param mutants The mutants for which covering syntax needs to be generated
+* @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)];
+	if (targetExpression) sequence.push(targetExpression);
+	return babelTypes$1.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.
+*/
+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}`;
+	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;
+}
+/**
+* Will set the identifier of anonymous function expressions if is located in a variable declaration.
+* Will treat input as readonly. Returns undefined if not needed.
+* @example
+* const a = function() { }
+* becomes
+* 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;
+			return path.node;
+		} else if (path.parentPath.isObjectProperty() && babelTypes$1.isIdentifier(path.parentPath.node.key) && path.getStatementParent()?.isVariableDeclaration() === true) return path.node;
+	}
+}
+/**
+* Will set the identifier of anonymous arrow function expressions if is located in a variable declaration.
+* Will treat input as readonly. Returns undefined if not needed.
+* @example
+* const a = () => { }
+* becomes
+* 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)])), []);
+}
+function nameIfAnonymous(path) {
+	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowFunctionExpressionNamedIfNeeded(path) ?? path.node;
+}
+function isMemberOrCallOrNonNullExpression(path) {
+	return isCallExpression(path) || isMemberOrNonNullExpression(path);
+}
+function isMemberOrNonNullExpression(path) {
 	return isMemberExpression(path) || path.isTSNonNullExpression();
 }
 function isMemberExpression(path) {
@@ -954,258 +1716,295 @@ function isValidExpression(path) {
 		return parent.isAssignmentExpression() && parent.node.left === path.node;
 	}
 }
-/**
-* Places the mutants with a conditional expression: `global.activeMutant === 1? mutatedCode : originalCode`;
-*/
-const expressionMutantPlacer = {
-	name: "expressionMutantPlacer",
-	canPlace(path) {
-		return path.isExpression() && isValidExpression(path);
-	},
-	place(path, appliedMutants) {
-		let expression = nameIfAnonymous(path);
-		expression = mutationCoverageSequenceExpression(appliedMutants.keys(), expression);
-		for (const [mutant, appliedMutant] of appliedMutants) expression = types$3.conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, types$3.isExpression, "an expression"), expression);
-		path.replaceWith(expression);
-	}
-};
-//#endregion
-//#region src/mutant-placers/statement-mutant-placer.ts
-const { types: t } = babel;
-/**
-* Mutant placer that places mutants in statements that allow it.
-* It uses an `if` statement to do so
-*/
-const statementMutantPlacer = {
-	name: "statementMutantPlacer",
-	canPlace(path) {
-		return path.isStatement();
+const allMutantPlacers = Object.freeze([
+	{
+		name: "expressionMutantPlacer",
+		canPlace(path) {
+			return path.isExpression() && isValidExpression(path);
+		},
+		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);
+			path.replaceWith(expression);
+		}
 	},
-	place(path, appliedMutants) {
-		let statement = t.blockStatement([t.expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...path.isBlockStatement() ? path.node.body : [path.node]]);
-		for (const [mutant, appliedMutant] of appliedMutants) statement = t.ifStatement(mutantTestExpression(mutant.id), t.blockStatement([nodeOfKind(mutant, appliedMutant, t.isStatement, "a statement")]), statement);
-		path.replaceWith(path.isBlockStatement() ? t.blockStatement([statement]) : statement);
-	}
-};
-//#endregion
-//#region src/mutant-placers/switch-case-mutant-placer.ts
-/**
-* Places the mutants with consequent of a SwitchCase node. Uses an if-statement to do so.
-* @example
-*  case 'foo':
-*    if (stryMutAct_9fa48(0)) {} else {
-*      stryCov_9fa48(0);
-*      console.log('bar');
-*      break;
-*   }
-*/
-const switchCaseMutantPlacer = {
-	name: "switchCaseMutantPlacer",
-	canPlace(path) {
-		return path.isSwitchCase();
+	{
+		name: "statementMutantPlacer",
+		canPlace(path) {
+			return path.isStatement();
+		},
+		place(path, appliedMutants) {
+			const bodyStatements = [t.expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys()))];
+			if (path.isBlockStatement()) 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]));
+			else path.replaceWith(statement);
+		}
 	},
-	place(path, appliedMutants) {
-		let consequence = babel.types.blockStatement([babel.types.expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...path.node.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);
+	{
+		name: "switchCaseMutantPlacer",
+		canPlace(path) {
+			return path.isSwitchCase();
+		},
+		place(path, appliedMutants) {
+			let consequence = babel.types.blockStatement([babel.types.expressionStatement(mutationCoverageSequenceExpression(appliedMutants.keys())), ...path.node.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);
+			}
+			path.replaceWith(babel.types.switchCase(path.node.test, [consequence]));
 		}
-		path.replaceWith(babel.types.switchCase(path.node.test, [consequence]));
 	}
-};
-//#endregion
-//#region src/mutant-placers/throw-placement-error.ts
-function throwPlacementError(error, nodePath, placer, mutants, fileName) {
-	const location = `${path.relative(process.cwd(), fileName)}:${nodePath.node.loc?.start.line}:${nodePath.node.loc?.start.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 https://github.com/stryker-mutator/stryker-js/issues/new?assignees=&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=${encodeURIComponent(message)}. Original error: ${error.stack}`;
-	let builtError = new Error(errorMessage);
-	try {
-		builtError = nodePath.buildCodeFrameError(errorMessage);
-	} catch {}
-	throw builtError;
-}
-//#endregion
-//#region src/mutant-placers/index.ts
-const allMutantPlacers = Object.freeze([
-	expressionMutantPlacer,
-	statementMutantPlacer,
-	switchCaseMutantPlacer
 ]);
-//#endregion
-//#region src/util/babel-file.ts
+const ANGULAR_SIGNAL_IO_FUNCTIONS = Object.freeze([
+	"input",
+	"model",
+	"output"
+]);
+const ANGULAR_SIGNAL_QUERY_FUNCTIONS = Object.freeze([
+	"contentChild",
+	"contentChildren",
+	"viewChild",
+	"viewChildren"
+]);
+const INPUT_MODEL_OUTPUT_CONFIG_MSG = "Angular signal based input, model and output functions configuration object cannot be mutated as that causes issues with the Angular compiler.";
+const SIGNAL_QUERY_OPTIONS_MSG = "Angular signal query options object cannot be mutated as that causes issues with the Angular compiler.";
+function shouldIgnore(path) {
+	for (let current = path; current; current = current.parentPath) {
+		if (isInputModelOrOutputConfigurationObject(current)) return Option.some(INPUT_MODEL_OUTPUT_CONFIG_MSG);
+		if (isSignalQueryOptionsObject(current)) return Option.some(SIGNAL_QUERY_OPTIONS_MSG);
+	}
+	return Option.none();
+}
+const angularIgnorer = { shouldIgnore };
+function isClassFieldLike(path) {
+	return path.isClassProperty() || path.isClassPrivateProperty() || path.isClassAccessorProperty();
+}
+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 (!Predicate.hasProperty(callNode, "callee") || !Predicate.hasProperty(callNode, "arguments")) return false;
+	const callee = callNode["callee"];
+	const args = callNode["arguments"];
+	if (!Array.isArray(args)) return false;
+	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;
+	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 (!Predicate.hasProperty(callNode, "callee") || !Predicate.hasProperty(callNode, "arguments")) return false;
+	const callee = callNode["callee"];
+	const args = callNode["arguments"];
+	if (!Array.isArray(args)) return false;
+	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;
+}
+function isIdentifierWithName(node, name) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "Identifier" && Predicate.hasProperty(node, "name") && node["name"] === name;
+}
+function isIdentifierIn(node, names) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "Identifier" && Predicate.hasProperty(node, "name") && typeof node["name"] === "string" && names.includes(node["name"]);
+}
+function isMemberExpressionWithIdentifier(node, objectNames, propertyName) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "MemberExpression" && Predicate.hasProperty(node, "object") && Predicate.hasProperty(node, "property") && isIdentifierIn(node["object"], objectNames) && isIdentifierWithName(node["property"], propertyName);
+}
+const strykerPlugins = [];
+const frameworkPluginsFileUrl = import.meta.url;
 /**
-* 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.
+* Returns syntax for the header if JS/TS files
 */
-function createBabelFile(filename, code, ast) {
-	return new File({ filename }, {
-		code,
-		ast
-	});
-}
-//#endregion
-//#region src/transformers/directive-bookkeeper.ts
-const WILDCARD = "all";
-const DEFAULT_REASON = "Ignored using a comment";
-var IgnoreRule = class {
-	mutatorNames;
-	line;
-	ignoreReason;
-	previousRule;
-	constructor(mutatorNames, line, ignoreReason, previousRule) {
-		this.mutatorNames = mutatorNames;
-		this.line = line;
-		this.ignoreReason = ignoreReason;
-		this.previousRule = previousRule;
-	}
-	matches(mutatorName, line) {
-		const lineMatches = () => this.line === void 0 || this.line === line;
-		const mutatorMatches = () => this.mutatorNames.includes(mutatorName) || this.mutatorNames.includes(WILDCARD);
-		return lineMatches() && mutatorMatches();
-	}
-	findIgnoreReason(mutatorName, line) {
-		if (this.matches(mutatorName, line)) return this.ignoreReason;
-		return this.previousRule.findIgnoreReason(mutatorName, line);
-	}
+const parsedInstrumentationHeader = babel.parse(`// @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} = {});
+  if (ns.${INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT} === undefined && g.process && g.process.env && g.process.env.${INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT_ENV_VARIABLE}) {
+    ns.${INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT} = g.process.env.${INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT_ENV_VARIABLE};
+  }
+  function retrieveNS(){
+    return ns;
+  }
+  ${STRYKER_NAMESPACE_HELPER} = retrieveNS;
+  return retrieveNS();
 };
-var RestoreRule = class extends IgnoreRule {
-	constructor(mutatorNames, line, previousRule) {
-		super(mutatorNames, line, void 0, previousRule);
-	}
+${STRYKER_NAMESPACE_HELPER}();
+
+var ${COVER_MUTANT_HELPER} = function() {
+  var ns = ${STRYKER_NAMESPACE_HELPER}();
+  var cov = ns.${INSTRUMENTER_CONSTANTS.MUTATION_COVERAGE_OBJECT} || (ns.${INSTRUMENTER_CONSTANTS.MUTATION_COVERAGE_OBJECT} = { static: {}, perTest: {} });
+  function cover() {
+    var c = cov.static;
+    if (ns.${INSTRUMENTER_CONSTANTS.CURRENT_TEST_ID}) {
+      c = cov.perTest[ns.${INSTRUMENTER_CONSTANTS.CURRENT_TEST_ID}] = cov.perTest[ns.${INSTRUMENTER_CONSTANTS.CURRENT_TEST_ID}] || {};
+    }
+    var a = arguments;
+    for(var i=0; i < a.length; i++){
+      c[a[i]] = (c[a[i]] || 0) + 1;
+    }
+  }
+  ${COVER_MUTANT_HELPER} = cover;
+  cover.apply(null, arguments);
 };
-const rootRule = { findIgnoreReason() {} };
-/**
-* Responsible for the bookkeeping of "// Stryker" directives like "disable" and "restore".
-*/
-var DirectiveBookkeeper = class {
-	logger;
-	allMutators;
-	originFileName;
-	strykerCommentDirectiveRegex = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z, ]+)(?::(.+)?)?/;
-	currentIgnoreRule = rootRule;
-	allMutatorNames;
-	constructor(logger, allMutators, originFileName) {
-		this.logger = logger;
-		this.allMutators = allMutators;
-		this.originFileName = originFileName;
-		this.allMutatorNames = this.allMutators.map((x) => x.name.toLowerCase());
-	}
-	processStrykerDirectives({ loc, leadingComments }) {
-		if (!leadingComments) return;
-		for (const comment of leadingComments) {
-			const matchResult = this.strykerCommentDirectiveRegex.exec(comment.value);
-			if (!matchResult) continue;
-			const directiveType = matchResult[1];
-			const scope = matchResult[2];
-			const mutators = matchResult[3];
-			const optionalReason = matchResult[4];
-			if (directiveType === void 0 || mutators === void 0) throw new Error("Stryker directive without directive type or mutators");
-			let mutatorNames = mutators.split(",").map((mutator) => mutator.trim());
-			this.warnAboutUnusedDirective(mutatorNames, directiveType, scope, comment);
-			mutatorNames = mutatorNames.map((mutator) => mutator.toLowerCase());
-			const reason = (optionalReason ?? DEFAULT_REASON).trim();
-			this.applyDirective(directiveType, scope, mutatorNames, reason, loc);
-		}
+var ${IS_MUTANT_ACTIVE_HELPER} = function(id) {
+  var ns = ${STRYKER_NAMESPACE_HELPER}();
+  function isActive(id) {
+    if (ns.${INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT} === id) {
+      if (ns.${INSTRUMENTER_CONSTANTS.HIT_COUNT} !== void 0 && ++ns.${INSTRUMENTER_CONSTANTS.HIT_COUNT} > ns.${INSTRUMENTER_CONSTANTS.HIT_LIMIT}) {
+        throw new Error('Stryker: Hit count limit reached (' + ns.${INSTRUMENTER_CONSTANTS.HIT_COUNT} + ')');
+      }
+      return true;
+    }
+    return false;
+  }
+  ${IS_MUTANT_ACTIVE_HELPER} = isActive;
+  return isActive(id);
+}`, {
+	configFile: false,
+	browserslistConfigFile: false,
+	env: { targets: {} }
+});
+if (!babelTypes$1.isFile(parsedInstrumentationHeader)) throw new Error("Instrumentation header parsed as non-File");
+const instrumentationBabelHeader = parsedInstrumentationHeader.program.body;
+deepFreeze(instrumentationBabelHeader);
+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;
+	if (Array.isArray(leadingComments)) {
+		const firstHeader = instrumentationBabelHeader[0];
+		if (firstHeader === void 0) throw new Error("Instrumentation header is empty");
+		const cloned = babelTypes$1.cloneNode(firstHeader, true, false);
+		cloned.leadingComments = leadingComments;
+		header = [cloned, ...instrumentationBabelHeader.slice(1)];
 	}
-	applyDirective(directiveType, scope, mutatorNames, reason, loc) {
-		switch (directiveType) {
-			case "disable":
-				this.applyDisable(scope, mutatorNames, reason, loc);
-				break;
-			case "restore": this.applyRestore(scope, mutatorNames, loc);
+	root.program.body.unshift(...header);
+}
+function deepFreeze(value) {
+	if (value !== null && typeof value === "object") {
+		if (Array.isArray(value)) {
+			for (const item of value) deepFreeze(item);
+			return Object.freeze(value);
 		}
-	}
-	applyDisable(scope, mutatorNames, reason, loc) {
-		switch (scope) {
-			case "next-line":
-				this.currentIgnoreRule = new IgnoreRule(mutatorNames, this.getLine(loc), reason, this.currentIgnoreRule);
-				break;
-			case void 0:
-			default: this.currentIgnoreRule = new IgnoreRule(mutatorNames, void 0, reason, this.currentIgnoreRule);
+		if (value instanceof RegExp) return Object.freeze(value);
+		if (value instanceof Map) {
+			for (const [k, v] of value.entries()) {
+				deepFreeze(k);
+				deepFreeze(v);
+			}
+			return Object.freeze(value);
 		}
-	}
-	applyRestore(scope, mutatorNames, loc) {
-		switch (scope) {
-			case "next-line":
-				this.currentIgnoreRule = new RestoreRule(mutatorNames, this.getLine(loc), this.currentIgnoreRule);
-				break;
-			case void 0:
-			default: this.currentIgnoreRule = new RestoreRule(mutatorNames, void 0, this.currentIgnoreRule);
+		if (value instanceof Set) {
+			for (const v of value.values()) deepFreeze(v);
+			return Object.freeze(value);
 		}
+		for (const v of Object.values(value)) deepFreeze(v);
+		return Object.freeze(value);
 	}
-	getLine(loc) {
-		if (loc === void 0 || loc === null || loc.start === null || loc.start === void 0) throw new Error("Babel node without location");
-		return loc.start.line;
-	}
-	findIgnoreReason(line, mutatorName) {
-		mutatorName = mutatorName.toLowerCase();
-		return this.currentIgnoreRule.findIgnoreReason(mutatorName, line);
-	}
-	warnAboutUnusedDirective(mutators, directiveType, scope, comment) {
-		for (const mutator of mutators) {
-			if (mutator === WILDCARD) continue;
-			if (!this.allMutatorNames.includes(mutator.toLowerCase())) {
-				const commentLoc = comment.loc;
-				if (commentLoc === void 0 || commentLoc === null || commentLoc.start === null || commentLoc.start === void 0) throw new Error("Comment without location");
-				this.logger.warn(`Unused 'Stryker ${scope ? directiveType + " " + scope : directiveType}' directive. Mutator with name '${mutator}' not found. Directive found at: ${this.originFileName}:${commentLoc.start.line}:${commentLoc.start.column}.`);
-			}
-		}
+	return value;
+}
+function transform(ast, mutantCollector, transformerContext) {
+	const context = {
+		...transformerContext,
+		transform
+	};
+	switch (ast.format) {
+		case "html": return transformHtml(ast, mutantCollector, context);
+		case "js":
+		case "ts":
+		case "tsx": return transformBabel(ast, mutantCollector, context);
+		case "svelte": return transformSvelte(ast, mutantCollector, context);
 	}
+}
+const transformHtml = ({ root }, mutantCollector, context) => {
+	const warnings = [];
+	root.scripts.forEach((ast) => {
+		warnings.push(...context.transform(ast, mutantCollector, context));
+	});
+	return warnings;
 };
-//#endregion
-//#region src/transformers/ignorer-bookkeeper.ts
-/**
-* Responsible for keeping track of the active ignore message and node using the configured ignore-plugins.
-*/
-var IgnorerBookkeeper = class {
-	ignorers;
-	activeIgnored;
-	get currentIgnoreMessage() {
-		return this.activeIgnored?.message;
-	}
-	constructor(ignorers) {
-		this.ignorers = ignorers;
-	}
-	enterNode(path) {
-		if (!this.activeIgnored) this.ignorers.forEach((ignorer) => {
-			const message = ignorer.shouldIgnore(path);
-			if (message) this.activeIgnored = {
-				node: path.node,
-				message
+const moduleScript = `<script context="module">
+\n<\/script>\n`;
+const transformSvelte = (svelte, mutantCollector, context) => {
+	const warnings = [];
+	const { root, originFileName } = svelte;
+	[root.moduleScript, ...root.additionalScripts].filter(Predicate.isNotNullish).forEach((script) => {
+		warnings.push(...context.transform(script.ast, mutantCollector, {
+			...context,
+			options: {
+				...context.options,
+				noHeader: true
+			}
+		}));
+	});
+	if (hasPlacedMutants(mutantCollector, originFileName)) {
+		if (!root.moduleScript) {
+			root.moduleScript = {
+				ast: {
+					format: "js",
+					root: babelTypes$1.file(babelTypes$1.program([])),
+					rawContent: "",
+					originFileName
+				},
+				range: {
+					start: 26,
+					end: 26
+				},
+				isExpression: false
 			};
-		});
-	}
-	leaveNode(path) {
-		if (this.activeIgnored?.node === path.node) this.activeIgnored = void 0;
+			svelte.rawContent = `${moduleScript}${svelte.rawContent}`;
+			svelte.root.additionalScripts.forEach((script) => {
+				script.range.start += moduleScript.length;
+				script.range.end += moduleScript.length;
+			});
+		}
+		placeHeader(root.moduleScript.ast.root);
 	}
+	return warnings;
 };
-//#endregion
-//#region src/transformers/babel-transformer.ts
 const { traverse: traverse$1 } = babel;
-const transformBabel = ({ root, originFileName, rawContent, offset }, mutantCollector, { options, mutateDescription, logger }, mutators = allMutators, mutantPlacers = allMutantPlacers) => {
+const transformBabel = ({ root, originFileName, rawContent, offset }, mutantCollector, { options, mutateDescription }, mutators = allMutators, mutantPlacers = allMutantPlacers) => {
 	const file = createBabelFile(originFileName, rawContent, root);
 	const placementMap = /* @__PURE__ */ new Map();
-	const directiveBookkeeper = new DirectiveBookkeeper(logger, mutators, originFileName);
-	const ignorerBookkeeper = new IgnorerBookkeeper(options.ignorers);
+	let directiveRule = rootRule;
+	const mutatorEntries = Object.entries(mutators);
+	const allMutatorNames = mutatorEntries.map(([name]) => name.toLowerCase());
+	const warnings = [];
 	traverse$1(file.ast, {
 		enter(path) {
-			directiveBookkeeper.processStrykerDirectives(path.node);
+			const result = processStrykerDirectives(directiveRule, path.node, allMutatorNames, originFileName);
+			directiveRule = result.rule;
+			warnings.push(...result.warnings);
 			if (shouldSkip(path)) path.skip();
 			else {
-				ignorerBookkeeper.enterNode(path);
 				addToPlacementMapIfPossible(path);
 				if (shouldMutate(path)) {
 					const mutantsToPlace = collectMutants(path);
-					if (mutantsToPlace.length) {
+					if (mutantsToPlace.length > 0) {
 						const placementPath = path.find((ancestor) => placementMap.has(ancestor.node));
 						if (placementPath) {
 							const placement = placementMap.get(placementPath.node);
 							if (placement === void 0) throw new Error("Placement not found for node");
 							const { appliedMutants } = placement;
-							mutantsToPlace.forEach((mutant) => appliedMutants.set(mutant, mutant.applied(placementPath.node)));
+							mutantsToPlace.forEach((mutant) => appliedMutants.set(mutant, applyMutant(mutant, placementPath.node)));
 						} else throw new Error(`Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${JSON.stringify(mutantsToPlace, null, 2)}`);
 					}
 				}
@@ -1213,669 +2012,139 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 		},
 		exit(path) {
 			placeMutantsIfNeeded(path);
-			ignorerBookkeeper.leaveNode(path);
 		}
 	});
 	placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
-	/**
-	* If this node can be used to place mutants on, add to the placement map
-	*/
+	return warnings;
 	function addToPlacementMapIfPossible(path) {
 		const placer = mutantPlacers.find((p) => p.canPlace(path));
-		if (placer) placementMap.set(path.node, {
+		if (placer !== void 0) placementMap.set(path.node, {
 			appliedMutants: /* @__PURE__ */ new Map(),
 			placer
 		});
 	}
-	/**
-	* Don't traverse import declarations, decorators and nodes that don't have overlap with the selected mutation ranges
-	*/
 	function shouldSkip(path) {
-		return isTypeNode(path) || isImportDeclaration(path) || path.isDecorator() || !mutateDescription || Array.isArray(mutateDescription) && mutateDescription.every((range) => !locationOverlaps(range, getNodeLocation(path.node)));
+		return isTypeNode(path) || isImportDeclaration(path) || path.isDecorator() || mutateDescription === false || Array.isArray(mutateDescription) && mutateDescription.every((range) => {
+			return !locationOverlaps(range, getNodeLocation(path.node));
+		});
 	}
 	function shouldMutate(path) {
-		return mutateDescription === true || Array.isArray(mutateDescription) && mutateDescription.some((range) => locationIncluded(range, getNodeLocation(path.node)));
+		return mutateDescription === true || Array.isArray(mutateDescription) && mutateDescription.some((range) => {
+			return locationIncluded(range, getNodeLocation(path.node));
+		});
 	}
-	/**
-	* Place mutants that are assigned to the current node path (on exit)
-	*/
 	function placeMutantsIfNeeded(path) {
 		const mutantsPlacement = placementMap.get(path.node);
-		if (mutantsPlacement?.appliedMutants.size) try {
+		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);
 		}
 	}
-	/**
-	* Collect the mutants for the current node and return the non-ignored.
-	*/
+	function ignoreMessageFor(path) {
+		const view = toIgnorerPath(path);
+		for (const ignorer of options.ignorers) {
+			const result = ignorer.shouldIgnore(view);
+			if (Option.isSome(result)) return result.value;
+		}
+	}
 	function collectMutants(path) {
-		return [...mutate(path)].map((mutable) => mutantCollector.collect(originFileName, path.node, mutable, offset)).filter((mutant) => !mutant.ignoreReason);
+		return [...mutate(path)].map((mutable) => collect(mutantCollector, originFileName, path.node, mutable, offset)).filter((mutant) => mutant.ignoreReason === void 0);
 	}
-	/**
-	* Generate mutants for the current node.
-	* @yields {Mutable} A mutable describing the mutant to be placed
-	*/
-	function* mutate(node) {
-		for (const mutator of mutators) for (const replacement of mutator.mutate(node)) {
-			const ignoreReason = directiveBookkeeper.findIgnoreReason(getNodeLocation(node.node).start.line, mutator.name) ?? findExcludedMutatorIgnoreReason(mutator.name) ?? ignorerBookkeeper.currentIgnoreMessage;
-			yield {
+	function* mutate(path) {
+		const context = toMutatorContext(path);
+		for (const [mutatorName, mutate] of mutatorEntries) for (const replacement of mutate(path.node, context)) {
+			const ignoreReason = findIgnoreReason(directiveRule, mutatorName, getNodeLocation(path.node).start.line) ?? findExcludedMutatorIgnoreReason(mutatorName) ?? ignoreMessageFor(path);
+			const mutableEntry = {
 				replacement,
-				mutatorName: mutator.name,
-				...ignoreReason === void 0 ? {} : { ignoreReason }
-			};
-		}
-		function findExcludedMutatorIgnoreReason(mutatorName) {
-			if (options.excludedMutations.includes(mutatorName)) return `Ignored because of excluded mutation "${mutatorName}"`;
-			else return;
-		}
-	}
-};
-function getNodeLocation(node) {
-	const loc = node.loc;
-	if (loc === void 0 || loc === null || loc.start === null || loc.start === void 0 || loc.end === null || loc.end === void 0) throw new Error("Babel node without location");
-	return loc;
-}
-function toError(value) {
-	if (value instanceof Error) return value;
-	return new Error("Unexpected error", { cause: value });
-}
-//#endregion
-//#region src/transformers/html-transformer.ts
-const transformHtml = ({ root }, mutantCollector, context) => {
-	root.scripts.forEach((ast) => {
-		context.transform(ast, mutantCollector, context);
-	});
-};
-//#endregion
-//#region src/transformers/svelte-transformer.ts
-const moduleScript = `<script context="module">
-\n<\/script>\n`;
-const transformSvelte = (svelte, mutantCollector, context) => {
-	const { root, originFileName } = svelte;
-	[root.moduleScript, ...root.additionalScripts].filter(notEmpty).forEach((script) => {
-		context.transform(script.ast, mutantCollector, {
-			...context,
-			options: {
-				...context.options,
-				noHeader: true
-			}
-		});
-	});
-	if (mutantCollector.hasPlacedMutants(originFileName)) {
-		if (!root.moduleScript) {
-			root.moduleScript = {
-				ast: {
-					format: "js",
-					root: types.file(types.program([])),
-					rawContent: "",
-					originFileName
-				},
-				range: {
-					start: 26,
-					end: 26
-				},
-				isExpression: false
-			};
-			svelte.rawContent = `${moduleScript}${svelte.rawContent}`;
-			svelte.root.additionalScripts.forEach((script) => {
-				script.range.start += moduleScript.length;
-				script.range.end += moduleScript.length;
-			});
-		}
-		placeHeader(root.moduleScript.ast.root);
-	}
-};
-//#endregion
-//#region src/transformers/transformer.ts
-/**
-* Transform the AST by generating mutants and placing them in the AST.
-* Supports all AST formats supported by Stryker.
-* @param ast The Abstract Syntax Tree
-* @param mutantCollector the mutant collector that will be used to register and administer mutants
-* @param transformerContext the options used during transforming
-*/
-function transform(ast, mutantCollector, transformerContext) {
-	const context = {
-		...transformerContext,
-		transform
-	};
-	switch (ast.format) {
-		case "html":
-			transformHtml(ast, mutantCollector, context);
-			break;
-		case "js":
-		case "ts":
-		case "tsx":
-			transformBabel(ast, mutantCollector, context);
-			break;
-		case "svelte": transformSvelte(ast, mutantCollector, context);
-	}
-}
-//#endregion
-//#region src/util/syntax-helpers.ts
-const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
-const COVER_MUTANT_HELPER = "stryCov_9fa48";
-const IS_MUTANT_ACTIVE_HELPER = "stryMutAct_9fa48";
-const { types: types$2, traverse } = babel;
-/**
-* Returns syntax for the header if JS/TS files
-*/
-const parsedInstrumentationHeader = babel.parse(`function ${STRYKER_NAMESPACE_HELPER}(){
-  var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
-  var ns = g.${ID.NAMESPACE} || (g.${ID.NAMESPACE} = {});
-  if (ns.${ID.ACTIVE_MUTANT} === undefined && g.process && g.process.env && g.process.env.${ID.ACTIVE_MUTANT_ENV_VARIABLE}) {
-    ns.${ID.ACTIVE_MUTANT} = g.process.env.${ID.ACTIVE_MUTANT_ENV_VARIABLE};
-  }
-  function retrieveNS(){
-    return ns;
-  }
-  ${STRYKER_NAMESPACE_HELPER} = retrieveNS;
-  return retrieveNS();
-}
-${STRYKER_NAMESPACE_HELPER}();
-
-function ${COVER_MUTANT_HELPER}() {
-  var ns = ${STRYKER_NAMESPACE_HELPER}();
-  var cov = ns.${ID.MUTATION_COVERAGE_OBJECT} || (ns.${ID.MUTATION_COVERAGE_OBJECT} = { static: {}, perTest: {} });
-  function cover() {
-    var c = cov.static;
-    if (ns.${ID.CURRENT_TEST_ID}) {
-      c = cov.perTest[ns.${ID.CURRENT_TEST_ID}] = cov.perTest[ns.${ID.CURRENT_TEST_ID}] || {};
-    }
-    var a = arguments;
-    for(var i=0; i < a.length; i++){
-      c[a[i]] = (c[a[i]] || 0) + 1;
-    }
-  }
-  ${COVER_MUTANT_HELPER} = cover;
-  cover.apply(null, arguments);
-}
-function ${IS_MUTANT_ACTIVE_HELPER}(id) {
-  var ns = ${STRYKER_NAMESPACE_HELPER}();
-  function isActive(id) {
-    if (ns.${ID.ACTIVE_MUTANT} === id) {
-      if (ns.${ID.HIT_COUNT} !== void 0 && ++ns.${ID.HIT_COUNT} > ns.${ID.HIT_LIMIT}) {
-        throw new Error('Stryker: Hit count limit reached (' + ns.${ID.HIT_COUNT} + ')');
-      }
-      return true;
-    }
-    return false;
-  }
-  ${IS_MUTANT_ACTIVE_HELPER} = isActive;
-  return isActive(id);
-}`, {
-	configFile: false,
-	browserslistConfigFile: false,
-	env: { targets: {} }
-});
-if (!types$2.isFile(parsedInstrumentationHeader)) throw new Error("Instrumentation header parsed as non-File");
-const instrumentationBabelHeader = parsedInstrumentationHeader.program.body;
-deepFreeze(instrumentationBabelHeader);
-/**
-* returns syntax for `global.activeMutant === $mutantId`
-* @param mutantId The id of the mutant to switch
-*/
-function mutantTestExpression(mutantId) {
-	return types$2.callExpression(types$2.identifier(IS_MUTANT_ACTIVE_HELPER), [types$2.stringLiteral(mutantId)]);
-}
-function eqLocation(a, b) {
-	function eqPosition(start, end) {
-		return start.column === end.column && start.line === end.line;
-	}
-	return eqPosition(a.start, b.start) && eqPosition(a.end, b.end);
-}
-function eqNode(a, b) {
-	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
-}
-/**
-* Returns a sequence of mutation coverage counters with an optional last expression.
-*
-* @example (global.__coverMutant__(0, 1), 40 + 2)
-* @param mutants The mutants for which covering syntax needs to be generated
-* @param targetExpression The original expression
-*/
-function mutationCoverageSequenceExpression(mutants, targetExpression) {
-	const mutantIds = [...mutants].map((mutant) => types$2.stringLiteral(mutant.id));
-	const sequence = [types$2.callExpression(types$2.identifier(COVER_MUTANT_HELPER), mutantIds)];
-	if (targetExpression) sequence.push(targetExpression);
-	return types$2.sequenceExpression(sequence);
-}
-function isTypeNode(path) {
-	return path.isTypeAnnotation() || flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path) || isDeclareModule(path);
-}
-/**
-* 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;
-}
-/**
-* 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);
-}
-const tsTypeAnnotationNodeTypes = Object.freeze([
-	"TSAsExpression",
-	"TSInterfaceDeclaration",
-	"TSTypeAnnotation",
-	"TSTypeAliasDeclaration",
-	"TSEnumDeclaration",
-	"TSDeclareFunction",
-	"TSTypeParameterInstantiation",
-	"TSTypeParameterDeclaration"
-]);
-const flowTypeAnnotationNodeTypes = Object.freeze([
-	"DeclareClass",
-	"DeclareFunction",
-	"DeclareInterface",
-	"DeclareModule",
-	"DeclareModuleExports",
-	"DeclareTypeAlias",
-	"DeclareOpaqueType",
-	"DeclareVariable",
-	"DeclareExportDeclaration",
-	"DeclareExportAllDeclaration",
-	"InterfaceDeclaration",
-	"OpaqueType",
-	"TypeAlias",
-	"InterfaceDeclaration"
-]);
-function isImportDeclaration(path) {
-	return types$2.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
-}
-/**
-* Determines if a location (needle) is included in an other location (haystack)
-* @param haystack The range to look in
-* @param needle the range to search for
-*/
-function locationIncluded(haystack, needle) {
-	const startIncluded = haystack.start.line < needle.start.line || haystack.start.line === needle.start.line && haystack.start.column <= needle.start.column;
-	const endIncluded = haystack.end.line > needle.end.line || haystack.end.line === needle.end.line && haystack.end.column >= needle.end.column;
-	return startIncluded && endIncluded;
-}
-/**
-* Determines if two locations overlap with each other
-*/
-function locationOverlaps(a, b) {
-	const startIncluded = a.start.line < b.end.line || a.start.line === b.end.line && a.start.column <= b.end.column;
-	const endIncluded = a.end.line > b.start.line || a.end.line === b.start.line && a.end.column >= b.start.column;
-	return startIncluded && endIncluded;
-}
-/**
-* Helper for `types.cloneNode(node, deep: true, withoutLocations: false);`
-*/
-function deepCloneNode(node) {
-	return types$2.cloneNode(node, true, false);
-}
-function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
-	if (mutantCollector.hasPlacedMutants(originFileName) && !options.noHeader) placeHeader(root);
-}
-function placeHeader(root) {
-	let header = instrumentationBabelHeader;
-	const leadingComments = root.program.body[0]?.leadingComments;
-	if (Array.isArray(leadingComments)) {
-		const firstHeader = instrumentationBabelHeader[0];
-		if (firstHeader === void 0) throw new Error("Instrumentation header is empty");
-		const cloned = types$2.cloneNode(firstHeader, true, false);
-		cloned.leadingComments = leadingComments;
-		header = [cloned, ...instrumentationBabelHeader.slice(1)];
-	}
-	root.program.body.unshift(...header);
-}
-//#endregion
-//#region src/parsers/svelte-parser.ts
-const MIN_SVELTE_VERSION = ">=3.30";
-function isPlainRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function isUnknownArray(value) {
-	return Array.isArray(value);
-}
-function isRangedProgram(value) {
-	return isPlainRecord(value) && typeof value["start"] === "number" && typeof value["end"] === "number";
-}
-function isWalkFunction(value) {
-	return typeof value === "function";
-}
-function isRangedBaseNode(value) {
-	return isPlainRecord(value) && typeof value["type"] === "string" && typeof value["start"] === "number" && typeof value["end"] === "number";
-}
-function isTemplateExpressionType(type) {
-	return type === "MustacheTag" || type === "RawMustacheTag" || type === "IfBlock" || type === "ConstTag" || type === "EachBlock" || type === "AwaitBlock" || type === "KeyBlock" || type === "EventHandler";
-}
-function tryGetScriptRangeFromElement(node) {
-	if (!isPlainRecord(node) || node["type"] !== "Element" || node["name"] !== "script") return;
-	const children = node["children"];
-	if (!isUnknownArray(children) || children.length === 0) return;
-	const firstChild = children[0];
-	if (!isPlainRecord(firstChild) || firstChild["type"] !== "Text" || typeof firstChild["start"] !== "number" || typeof firstChild["end"] !== "number") return;
-	return {
-		start: firstChild["start"],
-		end: firstChild["end"],
-		isExpression: false
-	};
-}
-async function parse$1(text, fileName, context) {
-	const { parse: svelteParse, preprocess, VERSION } = await import("./compiler-Ck-td5Ds.mjs");
-	let walk;
-	if (!satisfies(VERSION, MIN_SVELTE_VERSION)) throw new Error(`Svelte version ${VERSION} not supported. Expected: ${MIN_SVELTE_VERSION} (processing file ${fileName})`);
-	if (satisfies(VERSION, ">=5")) {
-		const walkerModule = await import(import.meta.resolve("estree-walker", import.meta.resolve("svelte")));
-		if (!isPlainRecord(walkerModule) || !isWalkFunction(walkerModule["walk"])) throw new Error("estree-walker module without walk export");
-		walk = walkerModule["walk"];
-	} else {
-		const svelteCompilerModule = await import("./compiler-Ck-td5Ds.mjs");
-		if (!isPlainRecord(svelteCompilerModule) || !isWalkFunction(svelteCompilerModule["walk"])) throw new Error("svelte/compiler module without walk export");
-		walk = svelteCompilerModule["walk"];
-	}
-	const positionConverter = new PositionConverter(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)]);
-	return {
-		originFileName: fileName,
-		rawContent: text,
-		format: "svelte",
-		root: {
-			...moduleScript === void 0 ? {} : { moduleScript },
-			additionalScripts
-		}
-	};
-	/**
-	* 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);
+				mutatorName
+			};
+			if (ignoreReason !== void 0) mutableEntry.ignoreReason = ignoreReason;
+			yield mutableEntry;
+		}
+		function findExcludedMutatorIgnoreReason(mutatorName) {
+			if (options.excludedMutations.includes(mutatorName)) return `Ignored because of excluded mutation "${mutatorName}"`;
+			else return;
+		}
 	}
-	async function parseTemplateScript({ start, end, isExpression, format }) {
-		const scriptText = text.slice(start, end);
-		return {
-			ast: {
-				...await context.parse(scriptText, fileName, format),
-				offset: positionConverter.positionFromOffset(start)
-			},
-			range: {
-				start,
-				end
-			},
-			isExpression
-		};
+};
+function toMutatorContext(path) {
+	const ancestors = [];
+	let current = path.parentPath;
+	while (current !== null) {
+		ancestors.push(current.node);
+		current = current.parentPath;
 	}
-}
-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
+		parent: ancestors[0],
+		grandParent: ancestors[1],
+		ancestors
 	};
 }
-/**
-* Remaps script locations back to the original places using the script map
-*/
-function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges) {
-	const scriptRanges = [moduleScriptRange, ...templateRanges].filter(notEmpty).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) {
-			const scriptRange = {
-				start,
-				end: start + actualScript.content.length,
-				isExpression: range.isExpression,
-				format: actualScript.attributes["lang"] === "ts" ? "ts" : "js"
-			};
-			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"
-		};
-	});
+function getNodeLocation(node) {
+	const loc = node.loc;
+	if (loc == null) throw new Error("Babel node without location");
 	return {
-		remappedModuleScriptRange: newModuleScriptRange,
-		remappedScriptRanges: newScriptRanges.filter((range) => range !== newModuleScriptRange)
+		start: {
+			line: loc.start.line,
+			column: loc.start.column
+		},
+		end: {
+			line: loc.end.line,
+			column: loc.end.column
+		}
 	};
 }
-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 toError(value) {
+	if (value instanceof Error) return value;
+	return new Error("Unexpected error", { cause: value });
 }
 //#endregion
-//#region src/parsers/ts-parser.ts
-const { types: types$1, parseAsync } = babel;
-const require = createRequire(import.meta.url);
+//#region src/Instrument.ts
 /**
-* See https://babeljs.io/docs/en/babel-preset-typescript
-* @param text The text to parse
-* @param fileName The name of the file
+* Instrument — the instrument capability: Cell description, file/mutant types and the instrument entry point.
 */
-async function parseTS(text, fileName) {
-	return {
-		originFileName: fileName,
-		rawContent: text,
-		format: "ts",
-		root: await parse(text, fileName, false)
+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"
+	});
 }
-async function parseTsx(text, fileName) {
+function toApiLocation(source, offset) {
 	return {
-		root: await parse(text, fileName, true),
-		format: "tsx",
-		originFileName: fileName,
-		rawContent: text
+		start: toPosition(source.start, offset),
+		end: toPosition(source.end, offset)
 	};
 }
-async function parse(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;
-}
-//#endregion
-//#region src/parsers/create-parser.ts
-function createParser(parserOptions) {
-	const jsParse = createParser$1(parserOptions);
-	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}!`);
-		}
-		switch (format) {
-			case "js": return jsParse(code, fileName);
-			case "tsx": return parseTsx(code, fileName);
-			case "ts": return parseTS(code, fileName);
-			case "html": return parse$2(code, fileName, { parse });
-			case "svelte": return parse$1(code, fileName, { parse });
-			default: throw new Error(`Unsupported format: ${String(format)}`);
-		}
-	}
-	return parse;
-}
-function getFormat(fileName, override) {
-	if (override) return override;
-	else switch (path.extname(fileName).toLowerCase()) {
-		case ".js":
-		case ".jsx":
-		case ".mjs":
-		case ".cjs": return "js";
-		case ".mts":
-		case ".cts":
-		case ".ts": return "ts";
-		case ".tsx": return "tsx";
-		case ".vue":
-		case ".html":
-		case ".htm": return "html";
-		case ".svelte": return "svelte";
-		default: return;
-	}
-}
-//#endregion
-//#region src/printers/html-printer.ts
-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;
-}
-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 print$4 = (ast, context) => {
-	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart$1(a) - getScriptStart$1(b));
-	let currentIndex = 0;
-	let html = "";
-	for (const script of sortedScripts) {
-		html += ast.rawContent.substring(currentIndex, getScriptStart$1(script));
-		html += "\n";
-		html += context.print(script, context);
-		html += "\n";
-		currentIndex = getScriptEnd$1(script);
-	}
-	html += ast.rawContent.substr(currentIndex);
-	return html;
-};
-//#endregion
-//#region src/printers/js-printer.ts
-const print$3 = (file) => {
-	return generate(file.root, { sourceMaps: false }).code;
-};
-//#endregion
-//#region src/printers/svelte-printer.ts
-const print$2 = ({ root, rawContent }, context) => {
-	let currentIndex = 0;
-	let outputText = "";
-	const sortedScripts = [root.moduleScript, ...root.additionalScripts].filter(notEmpty).sort((a, b) => a.range.start - b.range.start);
-	for (const script of sortedScripts) if (script.isExpression) {
-		const codeWithoutSemicolon = context.print(script.ast, context).slice(0, -1);
-		outputText += rawContent.substring(currentIndex, script.range.start) + codeWithoutSemicolon;
-		currentIndex = script.range.end;
-	} else {
-		outputText += rawContent.substring(currentIndex, script.range.start);
-		outputText += "\n";
-		outputText += context.print(script.ast, context);
-		outputText += "\n";
-		currentIndex = script.range.end;
-	}
-	outputText += rawContent.substring(currentIndex);
-	return outputText;
-};
-//#endregion
-//#region src/printers/ts-printer.ts
-const print$1 = (file) => {
-	return generate(file.root, {
-		decoratorsBeforeExport: true,
-		sourceMaps: false
-	}).code;
-};
-//#endregion
-//#region src/printers/index.ts
-function print(file) {
-	const context = { print };
-	switch (file.format) {
-		case "js": return print$3(file, context);
-		case "ts": return print$1(file, context);
-		case "tsx": return print$1(file, context);
-		case "html": return print$4(file, context);
-		case "svelte": return print$2(file, context);
-	}
-}
-//#endregion
-//#region src/create-instrumenter.ts
-createInstrumenter.inject = tokens(commonTokens.injector);
-function createInstrumenter(injector) {
-	return injector.provideValue(instrumenterTokens.print, print).provideValue(instrumenterTokens.createParser, createParser).provideValue(instrumenterTokens.transform, transform).injectClass(Instrumenter);
+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
+	};
 }
-//#endregion
-//#region src/disable-type-checks.ts
 const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
 const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
 const startingCommentRegex = /(^\s*\/\*.*?\*\/)/gs;
-/**
-* Disables TypeScript type checking for a single file by inserting `// @ts-nocheck` commands.
-* It also does this for *.js files, as they can be type checked by typescript as well.
-* Other file types are silently ignored
-*
-* @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#-ts-nocheck-in-typescript-files
-*/
 async function disableTypeChecks(file, options) {
 	const format = getFormat(file.name);
 	if (!format) return file;
@@ -1944,7 +2213,7 @@ function disableTypeCheckingInHtml(ast) {
 	return html;
 }
 function disableTypeCheckingInSvelte(ast) {
-	const sortedScripts = [ast.root.moduleScript, ...ast.root.additionalScripts].filter(notEmpty).sort((a, b) => a.range.start - b.range.start);
+	const sortedScripts = [ast.root.moduleScript, ...ast.root.additionalScripts].filter(Predicate.isNotNullish).sort((a, b) => a.range.start - b.range.start);
 	let currentIndex = 0;
 	let html = "";
 	for (const script of sortedScripts) {
@@ -1958,23 +2227,23 @@ function disableTypeCheckingInSvelte(ast) {
 	return html;
 }
 function removeTSDirectives(text, comments) {
-	const directiveRanges = comments?.map(tryParseTSDirective).filter(notEmpty).sort((a, b) => a.startPos - b.startPos);
-	if (directiveRanges) {
-		let currentIndex = 0;
-		let pruned = "";
-		for (const directiveRange of directiveRanges) {
-			pruned += text.substring(currentIndex, directiveRange.startPos);
-			currentIndex = directiveRange.endPos;
-		}
-		pruned += text.substring(currentIndex);
-		return pruned;
-	} else return text;
+	if (comments === null || comments === void 0) return text;
+	const directiveRanges = comments.map(tryParseTSDirective).filter(Predicate.isNotNullish).sort((a, b) => a.startPos - b.startPos);
+	if (directiveRanges.length === 0) return text;
+	let currentIndex = 0;
+	let pruned = "";
+	for (const directiveRange of directiveRanges) {
+		pruned += text.substring(currentIndex, directiveRange.startPos);
+		currentIndex = directiveRange.endPos;
+	}
+	pruned += text.substring(currentIndex);
+	return pruned;
 }
 function tryParseTSDirective(comment) {
 	const match = commentDirectiveRegEx.exec(comment.value);
-	if (match) {
+	if (match !== null) {
 		const start = comment.start;
-		if (start === void 0 || start === null) throw new Error("Comment without start");
+		if (start == null) 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];
@@ -1986,120 +2255,9 @@ function tryParseTSDirective(comment) {
 		};
 	}
 }
-//#endregion
-//#region src/frameworks/angular-ignorer.ts
-const ANGULAR_SIGNAL_IO_FUNCTIONS = Object.freeze([
-	"input",
-	"model",
-	"output"
-]);
-const ANGULAR_SIGNAL_QUERY_FUNCTIONS = Object.freeze([
-	"contentChild",
-	"contentChildren",
-	"viewChild",
-	"viewChildren"
-]);
-const INPUT_MODEL_OUTPUT_CONFIG_MSG = "Angular signal based input, model and output functions configuration object cannot be mutated as that causes issues with the Angular compiler.";
-const SIGNAL_QUERY_OPTIONS_MSG = "Angular signal query options object cannot be mutated as that causes issues with the Angular compiler.";
-var AngularIgnorer = class {
-	shouldIgnore(path) {
-		if (this.isInputModelOrOutputConfigurationObject(path)) return INPUT_MODEL_OUTPUT_CONFIG_MSG;
-		if (this.isSignalQueryOptionsObject(path)) return SIGNAL_QUERY_OPTIONS_MSG;
-	}
-	#isClassFieldLike(path) {
-		return path.isClassProperty() || path.isClassPrivateProperty() || path.isClassAccessorProperty();
-	}
-	/**
-	* Determines if the given path is a configuration object for an Angular input, model or output function.
-	* This solves the "Argument needs to be statically analyzable." error
-	*/
-	isInputModelOrOutputConfigurationObject(path) {
-		if (!path.isObjectExpression() || !path.parentPath.isCallExpression() || !path.parentPath.parentPath.isClassProperty()) return false;
-		const callExpression = path.parentPath;
-		const objectExpression = path;
-		const isRequiredSignalIOFunction = callExpression.node.callee.type === "MemberExpression" && callExpression.node.callee.object.type === "Identifier" && ANGULAR_SIGNAL_IO_FUNCTIONS.includes(callExpression.node.callee.object.name) && callExpression.node.callee.property.type === "Identifier" && callExpression.node.callee.property.name === "required";
-		const isSignalIOFunction = callExpression.node.callee.type === "Identifier" && ANGULAR_SIGNAL_IO_FUNCTIONS.includes(callExpression.node.callee.name);
-		const isOutput = callExpression.node.callee.type === "Identifier" && callExpression.node.callee.name === "output";
-		if (isRequiredSignalIOFunction || isOutput) return callExpression.node.arguments.length >= 1 && callExpression.node.arguments[0] === objectExpression.node;
-		if (isSignalIOFunction) return callExpression.node.arguments.length >= 2 && callExpression.node.arguments[1] === objectExpression.node;
-		return false;
-	}
-	/**
-	* Determines if the given path is a configuration object for an Angular signal query function.
-	* This solves the "Argument needs to be statically analyzable." error
-	*/
-	isSignalQueryOptionsObject(path) {
-		if (!path.isObjectExpression() || !path.parentPath.isCallExpression() || !this.#isClassFieldLike(path.parentPath.parentPath)) return false;
-		const callExpression = path.parentPath;
-		const objectExpression = path;
-		const callee = callExpression.node.callee;
-		const isQueryFn = callee.type === "Identifier" && ANGULAR_SIGNAL_QUERY_FUNCTIONS.includes(callee.name);
-		const isRequiredQueryFn = callee.type === "MemberExpression" && callee.object.type === "Identifier" && ANGULAR_SIGNAL_QUERY_FUNCTIONS.includes(callee.object.name) && callee.property.type === "Identifier" && callee.property.name === "required";
-		if (!isQueryFn && !isRequiredQueryFn) return false;
-		return callExpression.node.arguments.length >= 2 && callExpression.node.arguments[1] === objectExpression.node;
-	}
-};
-//#endregion
-//#region src/frameworks/index.ts
-const strykerPlugins = [declareClassPlugin(PluginKind.Ignore, "angular", AngularIgnorer)];
-const frameworkPluginsFileUrl = import.meta.url;
-//#endregion
-//#region src/instrumenter.ts
-/**
-* The instrumenter is responsible for
-* * Generating mutants based on source files
-* * Instrumenting the source code with the mutants placed in `mutant switches`.
-* * Adding mutant coverage expressions in the source code.
-* @see https://github.com/stryker-mutator/stryker-js/issues/1514
-*/
-var Instrumenter = class {
-	logger;
-	_createParser;
-	_print;
-	_transform;
-	static inject = tokens(commonTokens.logger, instrumenterTokens.createParser, instrumenterTokens.print, instrumenterTokens.transform);
-	constructor(logger, _createParser = createParser, _print = print, _transform = transform) {
-		this.logger = logger;
-		this._createParser = _createParser;
-		this._print = _print;
-		this._transform = _transform;
-	}
-	async instrument(files, options) {
-		this.logger.debug("Instrumenting %d source files with mutants", files.length);
-		const mutantCollector = new MutantCollector();
-		const outFiles = [];
-		let mutantCount = 0;
-		const parse = this._createParser(options);
-		for (const { name, mutate, content } of files) {
-			const ast = await parse(content, name);
-			this._transform(ast, mutantCollector, {
-				options,
-				mutateDescription: toBabelLineNumber(mutate),
-				logger: this.logger
-			});
-			const mutatedContent = this._print(ast);
-			outFiles.push({
-				name,
-				mutate,
-				content: mutatedContent
-			});
-			if (this.logger.isDebugEnabled()) {
-				const nrOfMutantsInFile = mutantCollector.mutants.length - mutantCount;
-				mutantCount = mutantCollector.mutants.length;
-				this.logger.debug(`Instrumented ${path.relative(process.cwd(), name)} (${nrOfMutantsInFile} mutant(s))`);
-			}
-		}
-		const mutants = mutantCollector.mutants.map((mutant) => mutant.toApiMutant());
-		this.logger.info("Instrumented %d source file(s) with %d mutant(s)", files.length, mutants.length);
-		return {
-			files: outFiles,
-			mutants
-		};
-	}
-};
 function toBabelLineNumber(range) {
 	if (typeof range === "boolean") return range;
-	else return range.map(({ start, end }) => ({
+	return range.map(({ start, end }) => ({
 		start: {
 			column: start.column,
 			line: start.line + 1
@@ -2110,5 +2268,115 @@ function toBabelLineNumber(range) {
 		}
 	}));
 }
+function isIgnorerService(value) {
+	return typeof value === "object" && value !== null && "shouldIgnore" in value && typeof value.shouldIgnore === "function";
+}
+function toTransformerOptions(options) {
+	const base = {
+		excludedMutations: [...options.excludedMutations],
+		ignorers: options.ignorers.filter(isIgnorerService)
+	};
+	if (options.noHeader !== void 0) return {
+		...base,
+		noHeader: options.noHeader
+	};
+	return base;
+}
+function isAst(value) {
+	return typeof value === "object" && value !== null && "format" in value && "root" in value;
+}
+const instrumentDescription = pipe(Cell.read((command) => Effect.gen(function* () {
+	const files = command.files;
+	const options = command.options;
+	const parse = createParser(options);
+	const asts = [];
+	for (const { name, content } of files) {
+		const ast = yield* Effect.tryPromise({
+			try: () => parse(content, name),
+			catch: (cause) => new InstrumentError({
+				message: `Failed to parse ${name}`,
+				cause
+			})
+		});
+		asts.push(ast);
+	}
+	const collector = createMutantCollector();
+	const workAsts = asts.filter(isAst);
+	for (let i = 0; i < workAsts.length; i++) {
+		const ast = workAsts[i];
+		const file = files[i];
+		if (ast === void 0 || file === void 0) continue;
+		yield* Effect.try({
+			try: () => transform(ast, collector, {
+				options: toTransformerOptions(options),
+				mutateDescription: toBabelLineNumber(file.mutate)
+			}),
+			catch: (cause) => new InstrumentError({
+				message: `Failed to transform ${file.name}`,
+				cause
+			})
+		});
+	}
+	return {
+		files,
+		options,
+		asts,
+		mutants: yield* Effect.try({
+			try: () => collector.map(toApiMutant),
+			catch: (cause) => new InstrumentError({
+				message: "Failed to instrument",
+				cause
+			})
+		})
+	};
+})), Cell.decode((raw) => Result.succeed(InstrumentDecoded.make({
+	files: raw.files,
+	options: raw.options,
+	asts: raw.asts,
+	mutants: raw.mutants
+}))), Cell.decide(instrumentWorkflow), Cell.encode((outcome) => outcome), Cell.write((outcome) => Result.match(outcome, {
+	onFailure: (error) => Effect.fail(error),
+	onSuccess: (decision) => Effect.try({
+		try: () => {
+			const files = decision.files;
+			const asts = decision.asts;
+			const outFiles = [];
+			const isAstValue = (value) => typeof value === "object" && value !== null && "format" in value && "root" in value;
+			for (let i = 0; i < asts.length; i++) {
+				const maybeAst = asts[i];
+				const maybeFile = files[i];
+				if (maybeAst === void 0 || maybeFile === void 0) continue;
+				if (!isAstValue(maybeAst)) continue;
+				const ast = maybeAst;
+				const file = maybeFile;
+				const mutatedContent = print(ast);
+				outFiles.push({
+					name: file.name,
+					mutate: file.mutate,
+					content: mutatedContent
+				});
+			}
+			return InstrumentResult.make({
+				files: outFiles,
+				mutants: decision.mutants
+			});
+		},
+		catch: (cause) => new InstrumentError({
+			message: "Failed to print",
+			cause
+		})
+	})
+})));
+const instrument = (files, options) => {
+	const schemaFiles = files.map((file) => ({
+		name: file.name,
+		content: file.content,
+		mutate: file.mutate
+	}));
+	return Cell.apply(instrumentDescription, InstrumentCommand.make({
+		files: schemaFiles,
+		options
+	}));
+};
 //#endregion
-export { Instrumenter, createInstrumenter, disableTypeChecks, frameworkPluginsFileUrl, strykerPlugins };
+export { angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };