npm - @systemfsoftware/stryker-js-instrumenter - Versions diffs - 1.0.0 → 2.0.1 - Mend

@systemfsoftware/stryker-js-instrumenter 1.0.0 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,15 +1,88 @@
+import babel, { File } from "@babel/core";
+import generator from "@babel/generator";
+import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
+import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js/Mutant";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
 import * as Predicate from "effect/Predicate";
-import { INSTRUMENTER_CONSTANTS, propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js-plugin-api/core";
-import path from "path";
+import * as Result from "effect/Result";
 import * as S from "effect/Schema";
-import babel, { File, types } from "@babel/core";
 import { createRequire } from "module";
+import path from "path";
+import "@systemfsoftware/stryker-js/Ignorer";
+import { propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js/Schema";
 import * as Option from "effect/Option";
-import "@systemfsoftware/stryker-js-plugin-api/ignore";
-import generator from "@babel/generator";
+import path$1 from "node:path";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
-import * as Effect from "effect/Effect";
-//#region src/parsers/parse-error.schema.ts
+//#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,
@@ -28,178 +101,54 @@ S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParserNotFound")("Parser
 	extension: S.String,
 	cause: S.Defect()
 });
-//#endregion
-//#region src/parsers/html-parser.ts
-const TSX_SCRIPT_TYPES = Object.freeze(["tsx", "text/tsx"]);
-const TS_SCRIPT_TYPES = Object.freeze([
-	"ts",
-	"text/typescript",
-	"typescript"
-]);
-const JS_SCRIPT_TYPES = Object.freeze([
-	"js",
-	"text/javascript",
-	"javascript",
-	"module"
-]);
-async function parse$2(text, originFileName, context) {
-	return {
-		originFileName,
-		rawContent: text,
-		format: "html",
-		root: await ngHtmlParser(text, originFileName, context)
-	};
-}
-async function ngHtmlParser(text, fileName, parserContext) {
-	const ngParser = await import("angular-html-parser");
-	const { rootNodes, errors } = ngParser.parse(text, {
-		canSelfClose: true,
-		allowHtmComponentClosingTags: true,
-		isTagNameCaseSensitive: true
-	});
-	if (errors.length !== 0) {
-		const firstError = errors[0];
-		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 = [];
-	const scriptCollector = {
-		visitElement: (el, context) => {
-			const scriptFormat = getScriptType(el);
-			if (scriptFormat) scriptsAsPromised.push(parseScript(el, scriptFormat));
-			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");
-		const content = text.substring(el.startSourceSpan.end.offset, endSourceSpan.start.offset);
-		const ast = await parserContext.parse(content, fileName, scriptFormat);
-		if (ast) {
-			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");
-			const rootEnd = ast.root.end;
-			if (rootEnd === null || rootEnd === void 0) throw new Error("Babel File node without an end offset");
-			ast.root.start = rootStart + offset.offset;
-			ast.root.end = rootEnd + offset.offset;
-			return {
-				...ast,
-				offset: {
-					column: offset.offset,
-					line: offset.line
-				}
-			};
-		}
-		return ast;
+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)`;
 	}
-}
-function toSourceLocation({ line, col }) {
-	return {
-		line: line + 1,
-		column: col
-	};
-}
-function getScriptType(element) {
-	if (element.name === "script") {
-		if (!element.attrs.some((attr) => attr.name === "src")) {
-			const type = element.attrs.find((attr) => attr.name === "type") ?? element.attrs.find((attr) => attr.name === "lang");
-			if (type) {
-				const typeToLower = type.value.toLowerCase();
-				if (TSX_SCRIPT_TYPES.includes(typeToLower)) return "tsx";
-				if (TS_SCRIPT_TYPES.includes(typeToLower)) return "ts";
-				if (JS_SCRIPT_TYPES.includes(typeToLower)) return "js";
-			} else return "js";
-		}
+};
+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/js-parser.ts
-const { types: types$20, parseAsync: parseAsync$1 } = babel;
-function isParserPlugin(value) {
-	return typeof value === "string" || Array.isArray(value);
-}
-function isParserPluginArray(value) {
-	return value.every(isParserPlugin);
-}
-function getParserPlugins(override) {
-	if (override === null || override === void 0) return defaultPlugins;
-	if (isParserPluginArray(override)) return override;
-	throw new Error("Invalid parser plugins: expected ParserPlugin[]");
+//#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;
 }
-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$20.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
-		};
-	};
+/**
+* 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;
 }
-//#endregion
-//#region src/syntax/position-converter.ts
 function computeLineStarts(text) {
 	const result = [];
 	let pos = 0;
@@ -262,7 +211,9 @@ function binarySearch(array, value) {
 	return ~low;
 }
 function compare(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
 }
 const CharacterCodes = {
 	lineFeed: 10,
@@ -275,36 +226,256 @@ function isLineBreak(ch) {
 	return ch === CharacterCodes.lineFeed || ch === CharacterCodes.carriageReturn || ch === CharacterCodes.lineSeparator || ch === CharacterCodes.paragraphSeparator;
 }
 //#endregion
-//#region src/parsers/svelte-parser.schema.ts
-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}`;
+//#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)}`);
 	}
-};
-S.TaggedError("@systemfsoftware/stryker-js-instrumenter/SvelteParseFailed")("SvelteParseFailed", {
-	fileName: S.String,
-	cause: S.Defect()
-});
-//#endregion
-//#region src/parsers/svelte-parser.ts
-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 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",
+	"text/typescript",
+	"typescript"
+]);
+const JS_SCRIPT_TYPES = Object.freeze([
+	"js",
+	"text/javascript",
+	"javascript",
+	"module"
+]);
+async function parseHtml(text, originFileName, context) {
+	return {
+		originFileName,
+		rawContent: text,
+		format: "html",
+		root: await ngHtmlParser(text, originFileName, context)
+	};
+}
+async function ngHtmlParser(text, fileName, parserContext) {
+	const ngParser = await import("angular-html-parser");
+	const { rootNodes, errors } = ngParser.parse(text, {
+		canSelfClose: true,
+		allowHtmComponentClosingTags: true,
+		isTagNameCaseSensitive: true
+	});
+	if (errors.length !== 0) {
+		const firstError = errors[0];
+		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 = [];
+	const scriptCollector = {
+		visitElement: (el, context) => {
+			const scriptFormat = getScriptType(el);
+			if (scriptFormat) scriptsAsPromised.push(parseScript(el, scriptFormat));
+			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) 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 !== null && ast !== void 0) {
+			const offset = el.startSourceSpan.end;
+			const rootStart = ast.root.start;
+			if (rootStart == null) throw new Error("Babel File node without a start offset");
+			const rootEnd = ast.root.end;
+			if (rootEnd == null) throw new Error("Babel File node without an end offset");
+			ast.root.start = rootStart + offset.offset;
+			ast.root.end = rootEnd + offset.offset;
+			return {
+				...ast,
+				offset: {
+					column: offset.offset,
+					line: offset.line
+				}
+			};
+		}
+		return ast;
+	}
+}
+function toSourceLocation({ line, col }) {
+	return {
+		line: line + 1,
+		column: col
+	};
+}
+function getScriptType(element) {
+	if (element.name === "script") {
+		if (!element.attrs.some((attr) => attr.name === "src")) {
+			const type = element.attrs.find((attr) => attr.name === "type") ?? element.attrs.find((attr) => attr.name === "lang");
+			if (type) {
+				const typeToLower = type.value.toLowerCase();
+				if (TSX_SCRIPT_TYPES.includes(typeToLower)) return "tsx";
+				if (TS_SCRIPT_TYPES.includes(typeToLower)) return "ts";
+				if (JS_SCRIPT_TYPES.includes(typeToLower)) return "js";
+			} else return "js";
+		}
+	}
+}
+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
@@ -350,7 +521,7 @@ function tryGetScriptRangeFromElement(node) {
 		isExpression: false
 	};
 }
-async function parse$1(text, fileName, context) {
+async function parseSvelte(text, fileName, context) {
 	const { parse: svelteParse, preprocess, VERSION } = await import("svelte/compiler");
 	let walk;
 	if (!isSupportedSvelteVersion(VERSION)) throw new SvelteVersionNotSupported({
@@ -359,7 +530,7 @@ async function parse$1(text, fileName, context) {
 		cause: `Expected >=3.30`
 	});
 	if (isSvelteV5OrLater(VERSION)) {
-		const walkerModule = await import(import.meta.resolve("estree-walker", import.meta.resolve("svelte")));
+		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"
@@ -378,14 +549,17 @@ async function parse$1(text, fileName, context) {
 	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: {
-			...moduleScript === void 0 ? {} : { moduleScript },
-			additionalScripts
-		}
+		root
 	};
 	/**
 	* Replaces script tags with placeholders.
@@ -476,11 +650,13 @@ function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges
 		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: actualScript.attributes["lang"] === "ts" ? "ts" : "js"
+				format: langFormat
 			};
 			offset += actualScript.content.length - script.length;
 			if (range === moduleScriptRange) newModuleScriptRange = scriptRange;
@@ -505,140 +681,44 @@ function collectTemplateExpression(node) {
 	if (isRangedBaseNode(expression)) return expression;
 }
 //#endregion
-//#region src/parsers/ts-parser.ts
-const { types: types$19, parseAsync } = babel;
-const require = createRequire(import.meta.url);
+//#region src/Printer.ts
 /**
-* See https://babeljs.io/docs/en/babel-preset-typescript
-* @param text The text to parse
-* @param fileName The name of the file
+* Printer — turns the instrumenter's ASTs back into source text.
 */
-async function parseTS(text, fileName) {
-	return {
-		originFileName: fileName,
-		rawContent: text,
-		format: "ts",
-		root: await parse(text, fileName, false)
-	};
+/**
+* `@babel/generator` is CommonJS. Under Node's own ESM interop a default import
+* of it is the module's `exports` object, so the code generator sits behind
+* `.default` — the shape upstream reaches for, because upstream ships one
+* emitted file per source file. This package ships a bundle, where the default
+* import is already the function and `.default` is `undefined`, which fails at
+* the first mutant with `generator is not a function` rather than at build
+* time. Resolving both shapes once keeps the printers and the mutant's
+* replacement code identical under either layout.
+*/
+function resolveGenerate$1() {
+	if (typeof generator === "function") return generator;
+	return generator.default;
 }
-async function parseTsx(text, fileName) {
-	return {
-		root: await parse(text, fileName, true),
-		format: "tsx",
-		originFileName: fileName,
-		rawContent: text
-	};
-}
-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$19.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/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;
-	if (isJSFileWithoutTSDirectives(file, format)) return {
-		...file,
-		content: prefixWithNoCheck(file.content)
-	};
-	const ast = await createParser(options)(file.content, file.name);
-	switch (ast.format) {
-		case "js":
-		case "ts":
-		case "tsx": return {
-			...file,
-			content: disableTypeCheckingInBabelAst(ast)
-		};
-		case "html": return {
-			...file,
-			content: disableTypeCheckingInHtml(ast)
-		};
-		case "svelte": return {
-			...file,
-			content: disableTypeCheckingInSvelte(ast)
-		};
-	}
-}
-function isJSFileWithoutTSDirectives(file, format) {
-	return (format === "ts" || format === "js") && !tsDirectiveLikeRegEx.test(file.content);
-}
-function disableTypeCheckingInBabelAst(ast) {
-	return prefixWithNoCheck(removeTSDirectives(ast.rawContent, ast.root.comments));
-}
-function prefixWithNoCheck(code) {
-	if (code.startsWith("#")) {
-		const newLineIndex = code.indexOf("\n");
-		if (newLineIndex > 0) return `${code.substring(0, newLineIndex)}\n// @ts-nocheck\n${code.substring(newLineIndex + 1)}`;
-		else return code;
-	} else {
-		startingCommentRegex.lastIndex = 0;
-		const leadingComment = startingCommentRegex.exec(code)?.[1];
-		if (leadingComment === void 0) return `// @ts-nocheck\n${code}`;
-		return `${leadingComment.concat("\n")}// @ts-nocheck\n${code.substring(leadingComment.length)}`;
-	}
+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;
+};
+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");
@@ -649,158 +729,62 @@ function getScriptEnd$1(script) {
 	if (end === void 0 || end === null) throw new Error("Script AST root without end");
 	return end;
 }
-function disableTypeCheckingInHtml(ast) {
+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 += prefixWithNoCheck(removeTSDirectives(script.rawContent, script.root.comments));
+		html += context.print(script, context);
 		html += "\n";
 		currentIndex = getScriptEnd$1(script);
 	}
-	html += ast.rawContent.substring(currentIndex);
+	html += ast.rawContent.substr(currentIndex);
 	return html;
-}
-function disableTypeCheckingInSvelte(ast) {
-	const sortedScripts = [ast.root.moduleScript, ...ast.root.additionalScripts].filter(Predicate.isNotNullish).sort((a, b) => a.range.start - b.range.start);
+};
+const sveltePrint = ({ root, rawContent }, context) => {
 	let currentIndex = 0;
-	let html = "";
-	for (const script of sortedScripts) {
-		html += ast.rawContent.substring(currentIndex, script.range.start);
-		html += "\n";
-		html += prefixWithNoCheck(removeTSDirectives(script.ast.rawContent, script.ast.root.comments));
-		html += "\n";
+	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;
 	}
-	html += ast.rawContent.substring(currentIndex);
-	return html;
-}
-function removeTSDirectives(text, comments) {
-	const directiveRanges = comments?.map(tryParseTSDirective).filter(Predicate.isNotNullish).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;
-}
-function tryParseTSDirective(comment) {
-	const match = commentDirectiveRegEx.exec(comment.value);
-	if (match) {
-		const start = comment.start;
-		if (start === void 0 || 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];
-		if (directiveName === void 0) throw new Error("TS directive match without directive name");
-		const directiveStartPos = start + directivePrefix.length + 2;
-		return {
-			startPos: directiveStartPos,
-			endPos: directiveStartPos + directiveName.length + 1
-		};
-	}
-}
-//#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.";
-function shouldIgnore(path) {
-	if (isInputModelOrOutputConfigurationObject(path)) return Option.some(INPUT_MODEL_OUTPUT_CONFIG_MSG);
-	if (isSignalQueryOptionsObject(path)) 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);
-}
-//#endregion
-//#region src/frameworks/index.ts
-const strykerPlugins = [];
-const frameworkPluginsFileUrl = import.meta.url;
-//#endregion
-//#region src/babel/babel-generator.ts
-/**
-* `@babel/generator` is CommonJS. Under Node's own ESM interop a default import
-* of it is the module's `exports` object, so the code generator sits behind
-* `.default` — the shape upstream reaches for, because upstream ships one
-* emitted file per source file. This package ships a bundle, where the default
-* import is already the function and `.default` is `undefined`, which fails at
-* the first mutant with `generator is not a function` rather than at build
-* time. Resolving both shapes once keeps the printers and the mutant's
-* replacement code identical under either layout.
-*/
-const generate = typeof generator === "function" ? generator : generator.default;
+	outputText += rawContent.substring(currentIndex);
+	return outputText;
+};
 //#endregion
-//#region src/babel/clone.ts
-const { types: types$18 } = babel;
+//#region src/Mutator.ts
 /**
-* Helper for `types.cloneNode(node, deep: true, withoutLocations: false);`
+* 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 types$18.cloneNode(node, true, false);
+	return babelTypes$2.cloneNode(node, true, false);
 }
-//#endregion
-//#region src/babel/equality.ts
 function eqPosition(a, b) {
 	return a.line === b.line && a.column === b.column;
 }
@@ -810,9 +794,6 @@ function eqLocation(a, b) {
 function eqNode(a, b) {
 	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
 }
-//#endregion
-//#region src/mutant.ts
-const { traverse: traverse$1 } = babel;
 function createMutant(id, fileName, original, specs, offset = {
 	column: 0,
 	line: 0
@@ -825,40 +806,19 @@ function createMutant(id, fileName, original, specs, offset = {
 		replacement: specs.replacement,
 		mutatorName: specs.mutatorName,
 		ignoreReason: specs.ignoreReason,
-		replacementCode: generate(specs.replacement).code
-	};
-}
-function toApiMutant(mutant) {
-	const loc = mutant.original.loc;
-	if (loc === void 0 || loc === null) throw new Error("Babel node without a source location");
-	return {
-		fileName: mutant.fileName,
-		id: mutant.id,
-		location: toApiLocation(loc, mutant.offset),
-		mutatorName: mutant.mutatorName,
-		replacement: mutant.replacementCode,
-		...mutant.ignoreReason === void 0 ? {} : { statusReason: mutant.ignoreReason },
-		...mutant.ignoreReason === void 0 ? {} : { status: "Ignored" }
+		replacementCode: generate$1(specs.replacement, { sourceMaps: false }).code
 	};
 }
-/**
-* 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 mutant the mutant to apply
-* @param originalTree The original node, which will be treated as readonly
-*/
 function applyMutant(mutant, originalTree) {
 	if (originalTree === mutant.original) return mutant.replacement;
 	const mutatedAst = deepCloneNode(originalTree);
-	let applied = false;
 	const { original, replacement } = mutant;
-	traverse$1(mutatedAst, {
+	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)) {
@@ -868,54 +828,140 @@ function applyMutant(mutant, originalTree) {
 			}
 		}
 	});
-	if (!applied) throw new Error(`Could not apply mutant ${JSON.stringify(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
-	};
+	return applied;
 }
-//#endregion
-//#region src/transformers/mutant-collector.ts
-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);
-}
-//#endregion
-//#region src/babel/babel-file.ts
 /**
-* 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.
+* 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 createBabelFile(filename, code, ast) {
-	return new File({ filename }, {
-		code,
-		ast
-	});
+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 [];
+	}
 }
-//#endregion
-//#region src/mutators/arithmetic-operator-mutator.ts
-const { types: t$3 } = babel;
 const arithmeticOperatorReplacements = Object.freeze({
 	"+": "-",
 	"-": "+",
@@ -924,39 +970,42 @@ const arithmeticOperatorReplacements = Object.freeze({
 	"%": "*"
 });
 const arithmeticOperatorMutator = function* (node, _context) {
-	if (t$3.isBinaryExpression(node) && isSupported$3(node.operator, node)) {
+	if (t$1.isBinaryExpression(node) && isSupportedArithmeticOperator(node.operator, node)) {
 		const mutatedOperator = arithmeticOperatorReplacements[node.operator];
 		const replacement = deepCloneNode(node);
 		replacement.operator = mutatedOperator;
 		yield replacement;
 	}
 };
-function isSupported$3(operator, node) {
+function isSupportedArithmeticOperator(operator, node) {
 	if (!Object.keys(arithmeticOperatorReplacements).includes(operator)) return false;
 	const stringTypes = ["StringLiteral", "TemplateLiteral"];
-	const leftType = t$3.isBinaryExpression(node.left) ? node.left.right.type : node.left.type;
+	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;
 }
-//#endregion
-//#region src/mutators/array-declaration-mutator.ts
-const { types: types$17 } = babel;
 const arrayDeclarationMutator = function* (node, _context) {
-	if (types$17.isArrayExpression(node)) yield node.elements.length ? types$17.arrayExpression() : types$17.arrayExpression([types$17.stringLiteral("Stryker was here")]);
-	if ((types$17.isCallExpression(node) || types$17.isNewExpression(node)) && types$17.isIdentifier(node.callee) && node.callee.name === "Array") {
-		const mutatedCallArgs = node.arguments.length ? [] : [types$17.arrayExpression()];
-		yield types$17.isNewExpression(node) ? types$17.newExpression(deepCloneNode(node.callee), mutatedCallArgs) : types$17.callExpression(deepCloneNode(node.callee), mutatedCallArgs);
+	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;
 	}
 };
-//#endregion
-//#region src/mutators/arrow-function-mutator.ts
-const { types: types$16 } = babel;
 const arrowFunctionMutator = function* (node, _context) {
-	if (types$16.isArrowFunctionExpression(node) && !types$16.isBlockStatement(node.body) && !(types$16.isIdentifier(node.body) && node.body.name === "undefined")) yield types$16.arrowFunctionExpression([], types$16.identifier("undefined"));
+	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"));
 };
-//#endregion
-//#region src/mutators/assignment-operator-mutator.ts
-const { types: types$15 } = babel;
 const assignmentOperatorReplacements = Object.freeze({
 	"+=": "-=",
 	"-=": "+=",
@@ -978,7 +1027,7 @@ const stringAssignmentTypes = Object.freeze([
 	"??="
 ]);
 const assignmentOperatorMutator = function* (node, _context) {
-	if (types$15.isAssignmentExpression(node) && isSupportedAssignmentOperator(node.operator) && isSupported$2(node)) {
+	if (babelTypes$2.isAssignmentExpression(node) && isSupportedAssignmentOperator(node.operator) && isSupportedAssignmentExpression(node)) {
 		const mutatedOperator = assignmentOperatorReplacements[node.operator];
 		const replacement = deepCloneNode(node);
 		replacement.operator = mutatedOperator;
@@ -988,15 +1037,12 @@ const assignmentOperatorMutator = function* (node, _context) {
 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$14 } = babel;
 const blockStatementMutator = function* (node, context) {
-	if (types$14.isBlockStatement(node) && isValid(node, context)) yield types$14.blockStatement([]);
+	if (babelTypes$2.isBlockStatement(node) && isValid(node, context)) yield babelTypes$2.blockStatement([]);
 };
 function isValid(node, context) {
 	return !isEmpty(node) && !isInvalidConstructorBody(node, context);
@@ -1006,16 +1052,16 @@ function isEmpty(node) {
 }
 function isInvalidConstructorBody(node, context) {
 	const parent = context.parent;
-	if (parent === void 0 || !types$14.isClassMethod(parent) || parent.kind !== "constructor") return false;
-	const hasParamProps = parent.params.some((param) => types$14.isTSParameterProperty(param));
+	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 || !types$14.isClassBody(grandParent)) return false;
-	return grandParent.body.some((classMember) => types$14.isClassProperty(classMember) && classMember.value !== null && classMember.value !== void 0);
+	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);
@@ -1041,15 +1087,10 @@ function hasSuperInChildren(node) {
 	}
 	return false;
 }
-//#endregion
-//#region src/mutators/boolean-literal-mutator.ts
-const { types: types$13 } = babel;
 const booleanLiteralMutator = function* (node, _context) {
-	if (types$13.isBooleanLiteral(node)) yield types$13.booleanLiteral(!node.value);
-	if (types$13.isUnaryExpression(node) && node.operator === "!" && node.prefix) yield deepCloneNode(node.argument);
+	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([
 	"!=",
 	"!==",
@@ -1062,31 +1103,30 @@ const booleanOperators = Object.freeze([
 	">=",
 	"||"
 ]);
-const { types: types$12 } = babel;
 const conditionalExpressionMutator = function* (node, context) {
-	if (isTestOfLoop(node, context)) yield types$12.booleanLiteral(false);
+	if (isTestOfLoop(node, context)) yield babelTypes$2.booleanLiteral(false);
 	else if (isTestOfCondition(node, context)) {
-		yield types$12.booleanLiteral(true);
-		yield types$12.booleanLiteral(false);
+		yield babelTypes$2.booleanLiteral(true);
+		yield babelTypes$2.booleanLiteral(false);
 	} else if (isBooleanExpression(node)) {
 		const parent = context.parent;
-		if (parent !== void 0 && types$12.isLogicalExpression(parent)) {
+		if (parent !== void 0 && babelTypes$2.isLogicalExpression(parent)) {
 			if (parent.operator === "||") {
-				yield types$12.booleanLiteral(false);
+				yield babelTypes$2.booleanLiteral(false);
 				return;
 			}
 			if (parent.operator === "&&") {
-				yield types$12.booleanLiteral(true);
+				yield babelTypes$2.booleanLiteral(true);
 				return;
 			}
 		}
-		yield types$12.booleanLiteral(true);
-		yield types$12.booleanLiteral(false);
-	} else if (types$12.isForStatement(node) && node.test === null) {
+		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 = types$12.booleanLiteral(false);
+		replacement.test = babelTypes$2.booleanLiteral(false);
 		yield replacement;
-	} else if (types$12.isSwitchCase(node) && node.consequent.length > 0) {
+	} else if (babelTypes$2.isSwitchCase(node) && node.consequent.length > 0) {
 		const replacement = deepCloneNode(node);
 		replacement.consequent = [];
 		yield replacement;
@@ -1095,24 +1135,21 @@ const conditionalExpressionMutator = function* (node, context) {
 function isTestOfLoop(node, context) {
 	const parent = context.parent;
 	if (parent === void 0) return false;
-	if (types$12.isForStatement(parent) && parent.test === node) return true;
-	if (types$12.isWhileStatement(parent) && parent.test === node) return true;
-	if (types$12.isDoWhileStatement(parent) && parent.test === node) return true;
+	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 types$12.isIfStatement(parent) && parent.test === node;
+	return babelTypes$2.isIfStatement(parent) && parent.test === node;
 }
 function isBooleanExpression(node) {
-	if (types$12.isBinaryExpression(node)) return booleanOperators.includes(node.operator);
-	if (types$12.isLogicalExpression(node)) return booleanOperators.includes(node.operator);
+	if (babelTypes$2.isBinaryExpression(node)) return booleanOperators.includes(node.operator);
+	if (babelTypes$2.isLogicalExpression(node)) return booleanOperators.includes(node.operator);
 	return false;
 }
-//#endregion
-//#region src/mutators/equality-operator-mutator.ts
-const { types: t$2 } = babel;
 const operators = {
 	"<": ["<=", ">="],
 	"<=": ["<", ">"],
@@ -1127,34 +1164,28 @@ function isEqualityOperator(operator) {
 	return Object.keys(operators).includes(operator);
 }
 const equalityOperatorMutator = function* (node, _context) {
-	if (t$2.isBinaryExpression(node) && isEqualityOperator(node.operator)) for (const mutableOperator of operators[node.operator]) {
-		const replacement = t$2.cloneNode(node, true);
+	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 { types: types$11 } = babel;
 const logicalOperatorReplacements = Object.freeze({
 	"&&": "||",
 	"||": "&&",
 	"??": "&&"
 });
 const logicalOperatorMutator = function* (node, _context) {
-	if (types$11.isLogicalExpression(node) && isSupported$1(node.operator)) {
+	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$10 } = babel;
 const baseReplacements = {
 	charAt: null,
 	endsWith: "startsWith",
@@ -1180,270 +1211,135 @@ const baseReplacements = {
 	setUTCSeconds: "setUTCMilliseconds"
 };
 const noReverseReplacements = ["getUTCDate", "setUTCDate"];
-const replacements = { ...baseReplacements };
-for (const key of Object.keys(baseReplacements)) {
-	const value = baseReplacements[key];
-	if (value !== null && value !== void 0 && !noReverseReplacements.includes(key)) replacements[value] = key;
-}
+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 (!(types$10.isCallExpression(node) || types$10.isOptionalCallExpression(node))) return;
+	if (!(babelTypes$2.isCallExpression(node) || babelTypes$2.isOptionalCallExpression(node))) return;
 	const { callee } = node;
-	if (!(types$10.isMemberExpression(callee) || types$10.isOptionalMemberExpression(callee)) || !types$10.isIdentifier(callee.property)) return;
-	const newName = replacements[callee.property.name];
+	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));
-	const mutatedCallee = types$10.isMemberExpression(callee) ? types$10.memberExpression(deepCloneNode(callee.object), types$10.identifier(newName), false, callee.optional) : types$10.optionalMemberExpression(deepCloneNode(callee.object), types$10.identifier(newName), false, callee.optional);
-	yield types$10.isCallExpression(node) ? types$10.callExpression(mutatedCallee, nodeArguments) : types$10.optionalCallExpression(mutatedCallee, nodeArguments, node.optional);
+	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/object-literal-mutator.ts
-const { types: types$9 } = babel;
 const objectLiteralMutator = function* (node, _context) {
-	if (types$9.isObjectExpression(node) && node.properties.length > 0) yield types$9.objectExpression([]);
+	if (babelTypes$2.isObjectExpression(node) && node.properties.length > 0) yield babelTypes$2.objectExpression([]);
 };
-//#endregion
-//#region src/mutators/optional-chaining-mutator.ts
-const { types: t$1 } = babel;
 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);
 };
-//#endregion
-//#region src/mutators/regex-mutation.ts
+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 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, 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 babelTypes$2.isImportDeclaration(parent) || babelTypes$2.isExportDeclaration(parent) || babelTypes$2.isImportOrExportDeclaration(parent) || babelTypes$2.isTSExternalModuleReference(parent);
+}
+function isJsxOrExpressionRelated(parent) {
+	return babelTypes$2.isJSXAttribute(parent) || babelTypes$2.isExpressionStatement(parent) || babelTypes$2.isTSLiteralType(parent) || babelTypes$2.isObjectMethod(parent);
+}
+function isObjectOrClassPropertyKey(parent, child) {
+	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 babelTypes$2.isCallExpression(parent) && babelTypes$2.isIdentifier(parent.callee, { name: "require" });
+}
+function isSymbolCall(parent) {
+	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isIdentifier(parent.callee, { name: "Symbol" });
+}
+function isImportCall(parent) {
+	return babelTypes$2.isCallExpression(parent) && babelTypes$2.isImport(parent.callee);
+}
+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 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);
+};
 /**
-* 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)` |
+* Every mutator this instrumenter can apply, named explicitly.
 *
-* 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.
+* 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.
 *
-* 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") {
-					const offset = node.kind === "lookahead" ? 2 : 3;
-					const pos = node.start + offset;
-					const text = node.negate ? "=" : "!";
-					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] ?? "";
-					const toggled = cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase();
-					rest.push({
-						start: pos,
-						end: pos + 1,
-						text: toggled,
-						priority: 2
-					});
-				} else if (node.kind === "property") {
-					const pos = node.start + 1;
-					const toggled = (node.raw[1] ?? "") === "p" ? "P" : "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 [];
-	}
-}
-//#endregion
-//#region src/mutators/regex-mutator.ts
-const { types: types$8 } = babel;
-const regexMutator = function* (node, context) {
-	if (types$8.isRegExpLiteral(node)) for (const replacementPattern of mutateRegexPattern(node.pattern, node.flags)) yield types$8.regExpLiteral(replacementPattern, node.flags);
-	else if (types$8.isStringLiteral(node) && isObviousRegexString(node, context)) {
-		const parent = context.parent;
-		if (parent !== void 0 && types$8.isNewExpression(parent)) {
-			const flags = getFlags(parent);
-			for (const replacementPattern of mutateRegexPattern(node.value, flags)) yield types$8.stringLiteral(replacementPattern);
-		}
-	}
-};
-function isObviousRegexString(node, context) {
-	const parent = context.parent;
-	if (parent === void 0 || !types$8.isNewExpression(parent) || !types$8.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 && types$8.isStringLiteral(secondArg)) return secondArg.value;
-}
-//#endregion
-//#region src/mutators/string-literal-mutator.ts
-const { types: types$7 } = babel;
-const stringLiteralMutator = function* (node, context) {
-	if (types$7.isTemplateLiteral(node)) {
-		const firstQuasi = node.quasis[0];
-		if (firstQuasi === void 0) return;
-		const replacement = node.quasis.length === 1 && firstQuasi.value.raw.length === 0 ? "Stryker was here!" : "";
-		yield types$7.templateLiteral([types$7.templateElement({ raw: replacement })], []);
-	}
-	if (types$7.isStringLiteral(node) && isValidParent(node, context)) yield types$7.stringLiteral(node.value.length === 0 ? "Stryker was here!" : "");
-};
-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$7.isImportDeclaration(parent) || types$7.isExportDeclaration(parent) || types$7.isImportOrExportDeclaration(parent) || types$7.isTSExternalModuleReference(parent);
-}
-function isJsxOrExpressionRelated(parent) {
-	return types$7.isJSXAttribute(parent) || types$7.isExpressionStatement(parent) || types$7.isTSLiteralType(parent) || types$7.isObjectMethod(parent);
-}
-function isObjectOrClassPropertyKey(parent, child) {
-	return types$7.isObjectProperty(parent) && parent.key === child || types$7.isClassProperty(parent) && parent.key === child;
-}
-function isDisallowedCallExpression(parent) {
-	return isRequireCall(parent) || isSymbolCall(parent) || isImportCall(parent);
-}
-function isRequireCall(parent) {
-	return types$7.isCallExpression(parent) && types$7.isIdentifier(parent.callee, { name: "require" });
-}
-function isSymbolCall(parent) {
-	return types$7.isCallExpression(parent) && types$7.isIdentifier(parent.callee, { name: "Symbol" });
-}
-function isImportCall(parent) {
-	return types$7.isCallExpression(parent) && types$7.isImport(parent.callee);
-}
-//#endregion
-//#region src/mutators/unary-operator-mutator.ts
-const { types: types$6 } = babel;
-const UnaryOperator = {
-	"+": "-",
-	"-": "+",
-	"~": ""
-};
-const unaryOperatorMutator = function* (node, _context) {
-	if (types$6.isUnaryExpression(node) && isSupported(node.operator) && node.prefix) {
-		const mutatedOperator = UnaryOperator[node.operator];
-		yield isPlusOrMinus(mutatedOperator) ? types$6.unaryExpression(mutatedOperator, deepCloneNode(node.argument)) : deepCloneNode(node.argument);
-	}
-};
-function isSupported(operator) {
-	return Object.keys(UnaryOperator).includes(operator);
-}
-function isPlusOrMinus(operator) {
-	return operator === "-" || operator === "+";
-}
-//#endregion
-//#region src/mutators/update-operator-mutator.ts
-const { types: types$5 } = babel;
-const UpdateOperators = {
-	"++": "--",
-	"--": "++"
-};
-const updateOperatorMutator = function* (node, _context) {
-	if (types$5.isUpdateExpression(node)) yield types$5.updateExpression(UpdateOperators[node.operator], deepCloneNode(node.argument), node.prefix);
-};
-//#endregion
-//#region src/mutators/registry.ts
-/**
-* 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.
+* 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,
@@ -1463,107 +1359,184 @@ const allMutators = Object.freeze({
 	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/babel/instrumentation-header.ts
-const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
-const COVER_MUTANT_HELPER$1 = "stryCov_9fa48";
-const IS_MUTANT_ACTIVE_HELPER$1 = "stryMutAct_9fa48";
-const { types: types$4 } = babel;
+//#region src/Transformer.ts
 /**
-* Returns syntax for the header if JS/TS files
+* Transformer — traverses ASTs, asks mutators for mutants and placers to instrument them.
 */
-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.${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();
-}
-${STRYKER_NAMESPACE_HELPER}();
-function ${COVER_MUTANT_HELPER$1}() {
-  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$1} = cover;
-  cover.apply(null, arguments);
+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 ${IS_MUTANT_ACTIVE_HELPER$1}(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$1} = isActive;
-  return isActive(id);
-}`, {
-	configFile: false,
-	browserslistConfigFile: false,
-	env: { targets: {} }
-});
-if (!types$4.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) placeHeader(root);
+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 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$4.cloneNode(firstHeader, true, false);
-		cloned.leadingComments = leadingComments;
-		header = [cloned, ...instrumentationBabelHeader.slice(1)];
-	}
-	root.program.body.unshift(...header);
+function hasPlacedMutants(collector, fileName) {
+	return collector.some((mutant) => mutant.fileName === fileName && mutant.ignoreReason === void 0);
 }
-function deepFreeze(value) {
-	if (value !== null && typeof value === "object") {
-		if (Array.isArray(value)) {
-			for (const item of value) deepFreeze(item);
-			return Object.freeze(value);
-		}
-		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);
-		}
-		if (value instanceof Set) {
-			for (const v of value.values()) deepFreeze(v);
-			return Object.freeze(value);
+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;
 		}
-		for (const v of Object.values(value)) deepFreeze(v);
-		return Object.freeze(value);
 	}
-	return value;
 }
-//#endregion
-//#region src/babel/type-guards.ts
-const { types: types$3 } = babel;
+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);
+	}
+	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
+		};
+	}
+}
+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();
+		}
+	};
+}
+/**
+* Wraps a parsed AST the way Babel's own pipeline does, so
+* `NodePath#buildCodeFrameError` can render a code frame
+* (https://github.com/babel/babel/issues/11889). Without the wrapper a
+* placement failure reports no source context.
+*/
+function createBabelFile(filename, code, ast) {
+	return new File({ filename }, {
+		code,
+		ast
+	});
+}
 function isTypeNode(path) {
 	return path.isTypeAnnotation() || flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path) || isDeclareModule(path);
 }
@@ -1610,19 +1583,14 @@ const flowTypeAnnotationNodeTypes = Object.freeze([
 	"InterfaceDeclaration"
 ]);
 function isImportDeclaration(path) {
-	return types$3.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
+	return babelTypes$1.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
 }
-//#endregion
-//#region src/mutant-placers/mutant-expression.ts
-const { types: types$2 } = babel;
-const COVER_MUTANT_HELPER = "stryCov_9fa48";
-const IS_MUTANT_ACTIVE_HELPER = "stryMutAct_9fa48";
 /**
 * 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)]);
+	return babelTypes$1.callExpression(babelTypes$1.identifier(IS_MUTANT_ACTIVE_HELPER), [babelTypes$1.stringLiteral(mutantId)]);
 }
 /**
 * Returns a sequence of mutation coverage counters with an optional last expression.
@@ -1632,13 +1600,11 @@ function mutantTestExpression(mutantId) {
 * @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)];
+	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 types$2.sequenceExpression(sequence);
+	return babelTypes$1.sequenceExpression(sequence);
 }
-//#endregion
-//#region src/mutant-placers/mutant-placer.ts
 /**
 * 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
@@ -1649,9 +1615,16 @@ function nodeOfKind(mutant, node, isKind, kind) {
 	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
 	return node;
 }
-//#endregion
-//#region src/mutant-placers/expression-mutant-placer.ts
-const { types: types$1 } = babel;
+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.
@@ -1662,13 +1635,10 @@ const { types: types$1 } = babel;
 */
 function classOrFunctionExpressionNamedIfNeeded(path) {
 	if ((path.isFunctionExpression() || path.isClassExpression()) && !path.node.id) {
-		if (path.parentPath.isVariableDeclarator() && types$1.isIdentifier(path.parentPath.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() && types$1.isIdentifier(path.parentPath.node.key) && path.getStatementParent()?.isVariableDeclaration()) {
-			path.node.id = path.parentPath.node.key;
-			return path.node;
-		}
+		} else if (path.parentPath.isObjectProperty() && babelTypes$1.isIdentifier(path.parentPath.node.key) && path.getStatementParent()?.isVariableDeclaration() === true) return path.node;
 	}
 }
 /**
@@ -1680,7 +1650,7 @@ function classOrFunctionExpressionNamedIfNeeded(path) {
 * const a = (() => { const a = () => {}; return a; })()
 */
 function arrowFunctionExpressionNamedIfNeeded(path) {
-	if (path.isArrowFunctionExpression() && path.parentPath.isVariableDeclarator() && types$1.isIdentifier(path.parentPath.node.id)) return types$1.callExpression(types$1.arrowFunctionExpression([], types$1.blockStatement([types$1.variableDeclaration("const", [types$1.variableDeclarator(path.parentPath.node.id, path.node)]), types$1.returnStatement(path.parentPath.node.id)])), []);
+	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;
@@ -1746,285 +1716,285 @@ 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$1.conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, types$1.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 ${strykerReportBugUrl(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/syntax/location.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;
+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();
 }
-/**
-* 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;
+const angularIgnorer = { shouldIgnore };
+function isClassFieldLike(path) {
+	return path.isClassProperty() || path.isClassPrivateProperty() || path.isClassAccessorProperty();
 }
-//#endregion
-//#region src/transformers/directive-bookkeeper.ts
-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;
-	while (true) 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;
-		}
-	}
+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 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 === void 0 || commentLoc === null || commentLoc.start === null || commentLoc.start === void 0) throw new Error("Comment without location");
-				warnings.push(`Unused 'Stryker ${scope ? directiveType + " " + scope : directiveType}' 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);
-	}
-	return {
-		rule: current,
-		warnings
-	};
+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 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 isIdentifierWithName(node, name) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "Identifier" && Predicate.hasProperty(node, "name") && node["name"] === name;
 }
-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
-		};
-	}
+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 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 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);
 }
-function 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;
+const strykerPlugins = [];
+const frameworkPluginsFileUrl = import.meta.url;
+/**
+* Returns syntax for the header if JS/TS files
+*/
+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();
+};
+${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);
+};
+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);
 }
-//#endregion
-//#region src/transformers/ignorer-bookkeeper.ts
-function createIgnorerBookkeeper(ignorers) {
-	return {
-		ignorers,
-		activeIgnored: void 0
-	};
+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)];
+	}
+	root.program.body.unshift(...header);
 }
-function currentIgnoreMessage(bookkeeper) {
-	return bookkeeper.activeIgnored?.message;
-}
-function enterNode(bookkeeper, path) {
-	if (bookkeeper.activeIgnored !== void 0) return bookkeeper;
-	const view = toIgnorerPath(path);
-	for (const ignorer of bookkeeper.ignorers) {
-		const result = ignorer.shouldIgnore(view);
-		if (Option.isSome(result)) return {
-			...bookkeeper,
-			activeIgnored: {
-				node: path.node,
-				message: result.value
+function deepFreeze(value) {
+	if (value !== null && typeof value === "object") {
+		if (Array.isArray(value)) {
+			for (const item of value) deepFreeze(item);
+			return Object.freeze(value);
+		}
+		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);
+		}
+		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);
 	}
-	return bookkeeper;
+	return value;
 }
-function leaveNode(bookkeeper, path) {
-	if (bookkeeper.activeIgnored?.node === path.node) return {
-		...bookkeeper,
-		activeIgnored: void 0
+function transform(ast, mutantCollector, transformerContext) {
+	const context = {
+		...transformerContext,
+		transform
 	};
-	return bookkeeper;
+	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);
+	}
 }
-function toIgnorerPath(path) {
-	return {
-		node: path.node,
-		parentPath: path.parentPath ? toIgnorerPath(path.parentPath) : null,
-		isObjectExpression() {
-			return path.isObjectExpression();
-		},
-		isCallExpression() {
-			return path.isCallExpression() || path.isOptionalCallExpression();
-		},
-		isClassProperty() {
-			return path.isClassProperty();
-		},
-		isClassPrivateProperty() {
-			return path.isClassPrivateProperty();
-		},
-		isClassAccessorProperty() {
-			return path.isClassAccessorProperty();
+const transformHtml = ({ root }, mutantCollector, context) => {
+	const warnings = [];
+	root.scripts.forEach((ast) => {
+		warnings.push(...context.transform(ast, mutantCollector, context));
+	});
+	return warnings;
+};
+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
+			};
+			svelte.rawContent = `${moduleScript}${svelte.rawContent}`;
+			svelte.root.additionalScripts.forEach((script) => {
+				script.range.start += moduleScript.length;
+				script.range.end += moduleScript.length;
+			});
 		}
-	};
-}
-//#endregion
-//#region src/transformers/babel-transformer.ts
-const { traverse } = babel;
+		placeHeader(root.moduleScript.ast.root);
+	}
+	return warnings;
+};
+const { traverse: traverse$1 } = babel;
 const transformBabel = ({ root, originFileName, rawContent, offset }, mutantCollector, { options, mutateDescription }, mutators = allMutators, mutantPlacers = allMutantPlacers) => {
 	const file = createBabelFile(originFileName, rawContent, root);
 	const placementMap = /* @__PURE__ */ new Map();
 	let directiveRule = rootRule;
 	const mutatorEntries = Object.entries(mutators);
 	const allMutatorNames = mutatorEntries.map(([name]) => name.toLowerCase());
-	let ignorerState = createIgnorerBookkeeper(options.ignorers);
 	const warnings = [];
-	traverse(file.ast, {
+	traverse$1(file.ast, {
 		enter(path) {
 			const result = processStrykerDirectives(directiveRule, path.node, allMutatorNames, originFileName);
 			directiveRule = result.rule;
 			warnings.push(...result.warnings);
 			if (shouldSkip(path)) path.skip();
 			else {
-				ignorerState = enterNode(ignorerState, path);
 				addToPlacementMapIfPossible(path);
 				if (shouldMutate(path)) {
 					const mutantsToPlace = collectMutants(path);
@@ -2042,7 +2012,6 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 		},
 		exit(path) {
 			placeMutantsIfNeeded(path);
-			ignorerState = leaveNode(ignorerState, path);
 		}
 	});
 	placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
@@ -2055,10 +2024,14 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 		});
 	}
 	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));
+		});
 	}
 	function placeMutantsIfNeeded(path) {
 		const mutantsPlacement = placementMap.get(path.node);
@@ -2069,18 +2042,26 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 			throwPlacementError(toError(error), path, mutantsPlacement.placer, [...mutantsPlacement.appliedMutants.keys()], originFileName);
 		}
 	}
+	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) => collect(mutantCollector, 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);
 	}
 	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) ?? currentIgnoreMessage(ignorerState);
-			yield {
+			const ignoreReason = findIgnoreReason(directiveRule, mutatorName, getNodeLocation(path.node).start.line) ?? findExcludedMutatorIgnoreReason(mutatorName) ?? ignoreMessageFor(path);
+			const mutableEntry = {
 				replacement,
-				mutatorName,
-				...ignoreReason === void 0 ? {} : { ignoreReason }
+				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}"`;
@@ -2091,7 +2072,7 @@ const transformBabel = ({ root, originFileName, rawContent, offset }, mutantColl
 function toMutatorContext(path) {
 	const ancestors = [];
 	let current = path.parentPath;
-	while (current !== null && current !== void 0) {
+	while (current !== null) {
 		ancestors.push(current.node);
 		current = current.parentPath;
 	}
@@ -2103,91 +2084,110 @@ function toMutatorContext(path) {
 }
 function getNodeLocation(node) {
 	const loc = node.loc;
-	if (loc === null || loc === void 0 || loc.start === null || loc.start === void 0 || loc.end === null || loc.end === void 0) throw new Error("Babel node without location");
-	return loc;
+	if (loc == null) throw new Error("Babel node without location");
+	return {
+		start: {
+			line: loc.start.line,
+			column: loc.start.column
+		},
+		end: {
+			line: loc.end.line,
+			column: loc.end.column
+		}
+	};
 }
 function toError(value) {
 	if (value instanceof Error) return value;
 	return new Error("Unexpected error", { cause: value });
 }
 //#endregion
-//#region src/transformers/html-transformer.ts
-const transformHtml = ({ root }, mutantCollector, context) => {
-	const warnings = [];
-	root.scripts.forEach((ast) => {
-		warnings.push(...context.transform(ast, mutantCollector, context));
-	});
-	return warnings;
-};
-//#endregion
-//#region src/transformers/svelte-transformer.ts
-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
-			}
-		}));
+//#region src/Instrument.ts
+/**
+* Instrument — the instrument capability: Cell description, file/mutant types and the instrument entry point.
+*/
+const { traverse, types: babelTypes } = babel;
+function resolveGenerate() {
+	if (typeof generator === "function") return generator;
+	return generator.default;
+}
+resolveGenerate();
+function toApiMutant(mutant) {
+	const loc = mutant.original.loc;
+	if (loc === void 0 || loc === null) throw new Error("Babel node without a source location");
+	const base = {
+		fileName: mutant.fileName,
+		id: mutant.id,
+		location: toApiLocation(loc, mutant.offset),
+		mutatorName: mutant.mutatorName,
+		replacement: mutant.replacementCode
+	};
+	if (mutant.ignoreReason === void 0) return Mutant.make(base);
+	return Mutant.make({
+		...base,
+		statusReason: mutant.ignoreReason,
+		status: "Ignored"
 	});
-	if (hasPlacedMutants(mutantCollector, 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);
-	}
-	return warnings;
-};
-//#endregion
-//#region src/transformers/transformer.ts
-function transform(ast, mutantCollector, transformerContext) {
-	const context = {
-		...transformerContext,
-		transform
+}
+function toApiLocation(source, offset) {
+	return {
+		start: toPosition(source.start, offset),
+		end: toPosition(source.end, offset)
+	};
+}
+function toPosition(source, offset) {
+	let columnOffset = 0;
+	if (source.line === 1) columnOffset = offset.column;
+	return {
+		column: source.column + columnOffset,
+		line: source.line + offset.line - 1
+	};
+}
+const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
+const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
+const startingCommentRegex = /(^\s*\/\*.*?\*\/)/gs;
+async function disableTypeChecks(file, options) {
+	const format = getFormat(file.name);
+	if (!format) return file;
+	if (isJSFileWithoutTSDirectives(file, format)) return {
+		...file,
+		content: prefixWithNoCheck(file.content)
 	};
+	const ast = await createParser(options)(file.content, file.name);
 	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);
+		case "tsx": return {
+			...file,
+			content: disableTypeCheckingInBabelAst(ast)
+		};
+		case "html": return {
+			...file,
+			content: disableTypeCheckingInHtml(ast)
+		};
+		case "svelte": return {
+			...file,
+			content: disableTypeCheckingInSvelte(ast)
+		};
 	}
 }
-//#endregion
-//#region src/instrument-error.schema.ts
-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;
+function isJSFileWithoutTSDirectives(file, format) {
+	return (format === "ts" || format === "js") && !tsDirectiveLikeRegEx.test(file.content);
+}
+function disableTypeCheckingInBabelAst(ast) {
+	return prefixWithNoCheck(removeTSDirectives(ast.rawContent, ast.root.comments));
+}
+function prefixWithNoCheck(code) {
+	if (code.startsWith("#")) {
+		const newLineIndex = code.indexOf("\n");
+		if (newLineIndex > 0) return `${code.substring(0, newLineIndex)}\n// @ts-nocheck\n${code.substring(newLineIndex + 1)}`;
+		else return code;
+	} else {
+		startingCommentRegex.lastIndex = 0;
+		const leadingComment = startingCommentRegex.exec(code)?.[1];
+		if (leadingComment === void 0) return `// @ts-nocheck\n${code}`;
+		return `${leadingComment.concat("\n")}// @ts-nocheck\n${code.substring(leadingComment.length)}`;
 	}
-};
-//#endregion
-//#region src/printers/html-printer.ts
+}
 function getScriptStart(script) {
 	const start = script.root.start;
 	if (start === void 0 || start === null) throw new Error("Script AST root without start");
@@ -2198,75 +2198,99 @@ function getScriptEnd(script) {
 	if (end === void 0 || end === null) throw new Error("Script AST root without end");
 	return end;
 }
-const print$4 = (ast, context) => {
+function disableTypeCheckingInHtml(ast) {
 	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart(a) - getScriptStart(b));
 	let currentIndex = 0;
 	let html = "";
 	for (const script of sortedScripts) {
 		html += ast.rawContent.substring(currentIndex, getScriptStart(script));
 		html += "\n";
-		html += context.print(script, context);
+		html += prefixWithNoCheck(removeTSDirectives(script.rawContent, script.root.comments));
 		html += "\n";
 		currentIndex = getScriptEnd(script);
 	}
-	html += ast.rawContent.substr(currentIndex);
+	html += ast.rawContent.substring(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) => {
+}
+function disableTypeCheckingInSvelte(ast) {
+	const sortedScripts = [ast.root.moduleScript, ...ast.root.additionalScripts].filter(Predicate.isNotNullish).sort((a, b) => a.range.start - b.range.start);
 	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";
+	let html = "";
+	for (const script of sortedScripts) {
+		html += ast.rawContent.substring(currentIndex, script.range.start);
+		html += "\n";
+		html += prefixWithNoCheck(removeTSDirectives(script.ast.rawContent, script.ast.root.comments));
+		html += "\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);
+	html += ast.rawContent.substring(currentIndex);
+	return html;
+}
+function removeTSDirectives(text, comments) {
+	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;
 }
-//#endregion
-//#region src/instrumenter.ts
-const instrument = Effect.fn("Instrumenter.instrument")(function* (files, options) {
-	yield* Effect.annotateCurrentSpan({ "instrumenter.file.count": files.length });
-	yield* Effect.logDebug(`Instrumenting ${files.length} source files with mutants`);
-	const collector = createMutantCollector();
-	const outFiles = [];
-	let mutantCount = 0;
+function tryParseTSDirective(comment) {
+	const match = commentDirectiveRegEx.exec(comment.value);
+	if (match !== null) {
+		const start = comment.start;
+		if (start == null) throw new Error("Comment without start");
+		const directivePrefix = match[1];
+		if (directivePrefix === void 0) throw new Error("TS directive match without prefix");
+		const directiveName = match[2];
+		if (directiveName === void 0) throw new Error("TS directive match without directive name");
+		const directiveStartPos = start + directivePrefix.length + 2;
+		return {
+			startPos: directiveStartPos,
+			endPos: directiveStartPos + directiveName.length + 1
+		};
+	}
+}
+function toBabelLineNumber(range) {
+	if (typeof range === "boolean") return range;
+	return range.map(({ start, end }) => ({
+		start: {
+			column: start.column,
+			line: start.line + 1
+		},
+		end: {
+			column: end.column,
+			line: end.line + 1
+		}
+	}));
+}
+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);
-	for (const { name, mutate, content } of files) {
+	const asts = [];
+	for (const { name, content } of files) {
 		const ast = yield* Effect.tryPromise({
 			try: () => parse(content, name),
 			catch: (cause) => new InstrumentError({
@@ -2274,54 +2298,85 @@ const instrument = Effect.fn("Instrumenter.instrument")(function* (files, option
 				cause
 			})
 		});
-		const warnings = yield* Effect.try({
+		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,
-				mutateDescription: toBabelLineNumber(mutate)
+				options: toTransformerOptions(options),
+				mutateDescription: toBabelLineNumber(file.mutate)
 			}),
 			catch: (cause) => new InstrumentError({
-				message: `Failed to transform ${name}`,
+				message: `Failed to transform ${file.name}`,
 				cause
 			})
 		});
-		for (const warning of warnings) yield* Effect.logWarning(warning);
-		const mutatedContent = yield* Effect.try({
-			try: () => print(ast),
+	}
+	return {
+		files,
+		options,
+		asts,
+		mutants: yield* Effect.try({
+			try: () => collector.map(toApiMutant),
 			catch: (cause) => new InstrumentError({
-				message: `Failed to print ${name}`,
+				message: "Failed to instrument",
 				cause
 			})
-		});
-		outFiles.push({
-			name,
-			mutate,
-			content: mutatedContent
-		});
-		const nrOfMutantsInFile = collector.length - mutantCount;
-		mutantCount = collector.length;
-		yield* Effect.logDebug(`Instrumented ${name} (${nrOfMutantsInFile} mutant(s))`);
-		yield* Effect.annotateCurrentSpan({ "instrumenter.mutants.total": collector.length });
-	}
-	const mutants = collector.map(toApiMutant);
-	yield* Effect.logInfo(`Instrumented ${files.length} source file(s) with ${mutants.length} mutant(s)`);
-	yield* Effect.annotateCurrentSpan({ "instrumenter.mutants.placed": mutants.length });
-	return {
-		files: outFiles,
-		mutants
+		})
 	};
-});
-function toBabelLineNumber(range) {
-	if (typeof range === "boolean") return range;
-	else return range.map(({ start, end }) => ({
-		start: {
-			column: start.column,
-			line: start.line + 1
+})), 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
+			});
 		},
-		end: {
-			column: end.column,
-			line: end.line + 1
-		}
+		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 { angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };