@systemfsoftware/stryker-js-instrumenter 0.1.0 → 1.0.0

package/dist/index.mjs

@@ -1,27 +1,33 @@
-import { PluginKind, commonTokens, declareClassPlugin, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import * as Predicate from "effect/Predicate";
+import { INSTRUMENTER_CONSTANTS, propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js-plugin-api/core";
 import path from "path";
-import { INSTRUMENTER_CONSTANTS as ID } from "@systemfsoftware/stryker-js-plugin-api/core";
+import * as S from "effect/Schema";
 import babel, { File, types } from "@babel/core";
-import { deepFreeze, notEmpty, propertyPath } from "@systemfsoftware/stryker-js-util";
-import { satisfies } from "semver";
-import generator from "@babel/generator";
-import * as weaponRegex from "weapon-regex";
-import "@systemfsoftware/stryker-js-plugin-api/ignore";
-import "@systemfsoftware/stryker-js-plugin-api/logging";
 import { createRequire } from "module";
-//#region src/instrumenter-tokens.ts
-const instrumenterTokens = Object.freeze({
-	createParser: "instrumenterCreateParser",
-	print: "instrumenterPrint",
-	transform: "instrumenterTransform"
-});
-//#endregion
-//#region src/parsers/parse-error.ts
-var ParseError = class extends Error {
-	constructor(message, fileName, location) {
-		super(`Parse error in ${fileName} (${location.line}:${location.column}) ${message}`);
+import * as Option from "effect/Option";
+import "@systemfsoftware/stryker-js-plugin-api/ignore";
+import generator from "@babel/generator";
+import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+import * as Effect from "effect/Effect";
+//#region src/parsers/parse-error.schema.ts
+var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParseFailed")("ParseFailed", {
+	fileName: S.String,
+	message: S.String,
+	location: S.Struct({
+		line: S.Finite,
+		column: S.Finite
+	}),
+	cause: S.Defect()
+}) {
+	get message() {
+		return `Failed to parse ${this.fileName} at ${this.location.line}:${this.location.column}: ${this.message}`;
 	}
 };
+S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParserNotFound")("ParserNotFound", {
+	fileName: S.String,
+	extension: S.String,
+	cause: S.Defect()
+});
 //#endregion
 //#region src/parsers/html-parser.ts
 const TSX_SCRIPT_TYPES = Object.freeze(["tsx", "text/tsx"]);
@@ -53,17 +59,43 @@ async function ngHtmlParser(text, fileName, parserContext) {
 	});
 	if (errors.length !== 0) {
 		const firstError = errors[0];
-		if (firstError === void 0) throw new Error("HTML parser reported errors but first error is missing");
-		throw new ParseError(firstError.msg, fileName, toSourceLocation(firstError.span.start));
+		if (firstError === void 0) throw new ParseFailed({
+			fileName,
+			message: "HTML parser reported errors but first error is missing",
+			location: {
+				line: 0,
+				column: 0
+			},
+			cause: errors
+		});
+		throw new ParseFailed({
+			fileName,
+			message: firstError.msg,
+			location: toSourceLocation(firstError.span.start),
+			cause: firstError
+		});
 	}
 	const scriptsAsPromised = [];
-	ngParser.visitAll(new class extends ngParser.RecursiveVisitor {
-		visitElement(el, context) {
+	const scriptCollector = {
+		visitElement: (el, context) => {
 			const scriptFormat = getScriptType(el);
 			if (scriptFormat) scriptsAsPromised.push(parseScript(el, scriptFormat));
-			super.visitElement(el, context);
-		}
-	}(), rootNodes);
+			ngParser.visitAll(scriptCollector, el.children, context);
+		},
+		visitAttribute: () => void 0,
+		visitText: () => void 0,
+		visitComment: () => void 0,
+		visitDocType: () => void 0,
+		visitExpansion: () => void 0,
+		visitExpansionCase: () => void 0,
+		visitBlock: () => void 0,
+		visitBlockParameter: () => void 0,
+		visitLetDeclaration: () => void 0,
+		visitCdata: () => void 0,
+		visitComponent: () => void 0,
+		visitDirective: () => void 0
+	};
+	ngParser.visitAll(scriptCollector, rootNodes);
 	return { scripts: await Promise.all(scriptsAsPromised) };
 	async function parseScript(el, scriptFormat) {
 		const endSourceSpan = el.endSourceSpan;
@@ -110,7 +142,7 @@ function getScriptType(element) {
 }
 //#endregion
 //#region src/parsers/js-parser.ts
-const { types: types$15, parseAsync: parseAsync$1 } = babel;
+const { types: types$20, parseAsync: parseAsync$1 } = babel;
 function isParserPlugin(value) {
 	return typeof value === "string" || Array.isArray(value);
 }
@@ -157,7 +189,7 @@ function createParser$1({ plugins: pluginsOverride }) {
 			sourceType: "module"
 		});
 		if (ast === null || ast === void 0) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
-		if (types$15.isProgram(ast)) throw new Error(`Expected ${fileName} to contain a babel.types.file, but was a program`);
+		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,
@@ -167,66 +199,50 @@ function createParser$1({ plugins: pluginsOverride }) {
 	};
 }
 //#endregion
-//#region src/util/position-converter.ts
-/**
-* A class that can convert a string offset back to line / column.
-* Grabbed from TypeScript code base
-* @see https://github.com/microsoft/TypeScript/blob/aa9b6953441b53f8b14072c047f0519b611150c4/src/compiler/scanner.ts#L503
-*/
-var PositionConverter = class {
-	text;
-	_lineStarts;
-	get lineStarts() {
-		if (!this._lineStarts) this._lineStarts = this.computeLineStarts(this.text);
-		return this._lineStarts;
-	}
-	constructor(text) {
-		this.text = text;
-	}
-	positionFromOffset(offset) {
-		const lineNumber = this.computeLineOfPosition(offset);
-		const lineStart = this.lineStarts[lineNumber];
-		if (lineStart === void 0) throw new Error("Line start not found for computed line number");
-		return {
-			line: lineNumber,
-			column: offset - lineStart
-		};
-	}
-	computeLineOfPosition(offset) {
-		let lineNumber = binarySearch(this.lineStarts, offset);
-		if (lineNumber < 0) {
-			lineNumber = ~lineNumber - 1;
-			if (lineNumber === -1) throw new Error("position cannot precede the beginning of the file");
-		}
-		return lineNumber;
-	}
-	computeLineStarts(text) {
-		const result = [];
-		let pos = 0;
-		let lineStart = 0;
-		while (pos < text.length) {
-			const ch = text.charCodeAt(pos);
-			pos++;
-			switch (ch) {
-				case 13:
-					if (text.charCodeAt(pos) === 10) pos++;
-					result.push(lineStart);
-					lineStart = pos;
-					break;
-				case 10:
-					result.push(lineStart);
-					lineStart = pos;
-					break;
-				default: if (ch > 127 && isLineBreak(ch)) {
-					result.push(lineStart);
-					lineStart = pos;
-				}
+//#region src/syntax/position-converter.ts
+function computeLineStarts(text) {
+	const result = [];
+	let pos = 0;
+	let lineStart = 0;
+	while (pos < text.length) {
+		const ch = text.charCodeAt(pos);
+		pos++;
+		switch (ch) {
+			case CharacterCodes.carriageReturn:
+				if (text.charCodeAt(pos) === CharacterCodes.lineFeed) pos++;
+				result.push(lineStart);
+				lineStart = pos;
+				break;
+			case CharacterCodes.lineFeed:
+				result.push(lineStart);
+				lineStart = pos;
+				break;
+			default: if (ch > CharacterCodes.maxAsciiCharacter && isLineBreak(ch)) {
+				result.push(lineStart);
+				lineStart = pos;
 			}
 		}
-		result.push(lineStart);
-		return result;
 	}
-};
+	result.push(lineStart);
+	return result;
+}
+function positionFromOffset(lineStarts, offset) {
+	const lineNumber = computeLineOfPosition(lineStarts, offset);
+	const lineStart = lineStarts[lineNumber];
+	if (lineStart === void 0) throw new Error("Line start not found for computed line number");
+	return {
+		line: lineNumber,
+		column: offset - lineStart
+	};
+}
+function computeLineOfPosition(lineStarts, offset) {
+	let lineNumber = binarySearch(lineStarts, offset);
+	if (lineNumber < 0) {
+		lineNumber = ~lineNumber - 1;
+		if (lineNumber === -1) throw new Error("position cannot precede the beginning of the file");
+	}
+	return lineNumber;
+}
 function binarySearch(array, value) {
 	if (!array.length) return -1;
 	let low = 0;
@@ -248,792 +264,643 @@ function binarySearch(array, value) {
 function compare(a, b) {
 	return a < b ? -1 : a > b ? 1 : 0;
 }
+const CharacterCodes = {
+	lineFeed: 10,
+	carriageReturn: 13,
+	maxAsciiCharacter: 127,
+	lineSeparator: 8232,
+	paragraphSeparator: 8233
+};
 function isLineBreak(ch) {
-	return ch === 10 || ch === 13 || ch === 8232 || ch === 8233;
+	return ch === CharacterCodes.lineFeed || ch === CharacterCodes.carriageReturn || ch === CharacterCodes.lineSeparator || ch === CharacterCodes.paragraphSeparator;
 }
 //#endregion
-//#region src/util/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;
-//#endregion
-//#region src/mutant.ts
-const { traverse: traverse$2 } = babel;
-var Mutant$1 = class {
-	id;
-	fileName;
-	original;
-	offset;
-	replacementCode;
-	replacement;
-	mutatorName;
-	ignoreReason;
-	constructor(id, fileName, original, specs, offset = {
-		column: 0,
-		line: 0
-	}) {
-		this.id = id;
-		this.fileName = fileName;
-		this.original = original;
-		this.offset = offset;
-		this.replacement = specs.replacement;
-		this.mutatorName = specs.mutatorName;
-		this.ignoreReason = specs.ignoreReason;
-		this.replacementCode = generate(this.replacement).code;
-	}
-	toApiMutant() {
-		const loc = this.original.loc;
-		if (loc === void 0 || loc === null) throw new Error("Babel node without a source location");
-		return {
-			fileName: this.fileName,
-			id: this.id,
-			location: toApiLocation(loc, this.offset),
-			mutatorName: this.mutatorName,
-			replacement: this.replacementCode,
-			...this.ignoreReason === void 0 ? {} : { statusReason: this.ignoreReason },
-			...this.ignoreReason === void 0 ? {} : { status: "Ignored" }
-		};
+//#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)`;
 	}
-	/**
-	* Applies the mutant in (a copy of) the AST, without changing provided AST.
-	* Can the tree itself (in which case the replacement is returned),
-	* or can be nested in the given tree.
-	*
-	* Returns a plain node rather than the argument's own type: whether the
-	* replacement fits a given position is the placer's claim, and the placer
-	* checks it with a Babel predicate. A generic return would have to assert it
-	* here, where nothing can check it.
-	* @param originalTree The original node, which will be treated as readonly
-	*/
-	applied(originalTree) {
-		if (originalTree === this.original) return this.replacement;
-		else {
-			const mutatedAst = deepCloneNode(originalTree);
-			let applied = false;
-			const { original, replacement } = this;
-			traverse$2(mutatedAst, {
-				noScope: true,
-				enter(path) {
-					if (eqNode(path.node, original)) {
-						path.replaceWith(replacement);
-						path.stop();
-						applied = true;
-					}
-				}
-			});
-			if (!applied) throw new Error(`Could not apply mutant ${JSON.stringify(this.replacement)}.`);
-			return mutatedAst;
-		}
+};
+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}`;
 	}
 };
-function toApiLocation(source, offset) {
+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 {
-		start: toPosition(source.start, offset),
-		end: toPosition(source.end, offset)
+		major,
+		minor
 	};
 }
-function toPosition(source, offset) {
-	return {
-		column: source.column + (source.line === 1 ? offset.column : 0),
-		line: source.line + offset.line - 1
-	};
+function isSupportedSvelteVersion(version) {
+	const parsed = parseVersion(version);
+	if (parsed === void 0) return false;
+	return parsed.major > 3 || parsed.major === 3 && parsed.minor >= 30;
 }
-//#endregion
-//#region src/mutators/arithmetic-operator-mutator.ts
-const arithmeticOperatorReplacements = Object.freeze({
-	"+": "-",
-	"-": "+",
-	"*": "/",
-	"/": "*",
-	"%": "*"
-});
-const arithmeticOperatorMutator = {
-	name: "ArithmeticOperator",
-	*mutate(path) {
-		if (path.isBinaryExpression() && isSupported$3(path.node.operator, path.node)) {
-			const mutatedOperator = arithmeticOperatorReplacements[path.node.operator];
-			const replacement = deepCloneNode(path.node);
-			replacement.operator = mutatedOperator;
-			yield replacement;
-		}
-	}
-};
-function isSupported$3(operator, node) {
-	if (!Object.keys(arithmeticOperatorReplacements).includes(operator)) return false;
-	const stringTypes = ["StringLiteral", "TemplateLiteral"];
-	const leftType = node.left.type === "BinaryExpression" ? node.left.right.type : node.left.type;
-	if (stringTypes.includes(node.right.type) || stringTypes.includes(leftType)) return false;
-	return true;
+function isSvelteV5OrLater(version) {
+	const parsed = parseVersion(version);
+	if (parsed === void 0) return false;
+	return parsed.major >= 5;
 }
-//#endregion
-//#region src/mutators/array-declaration-mutator.ts
-const { types: types$14 } = babel;
-const arrayDeclarationMutator = {
-	name: "ArrayDeclaration",
-	*mutate(path) {
-		if (path.isArrayExpression()) yield path.node.elements.length ? types$14.arrayExpression() : types$14.arrayExpression([types$14.stringLiteral("Stryker was here")]);
-		if ((path.isCallExpression() || path.isNewExpression()) && types$14.isIdentifier(path.node.callee) && path.node.callee.name === "Array") {
-			const mutatedCallArgs = path.node.arguments.length ? [] : [types$14.arrayExpression()];
-			yield types$14.isNewExpression(path.node) ? types$14.newExpression(deepCloneNode(path.node.callee), mutatedCallArgs) : types$14.callExpression(deepCloneNode(path.node.callee), mutatedCallArgs);
-		}
-	}
-};
-//#endregion
-//#region src/mutators/arrow-function-mutator.ts
-const { types: types$13 } = babel;
-const arrowFunctionMutator = {
-	name: "ArrowFunction",
-	*mutate(path) {
-		if (path.isArrowFunctionExpression() && !types$13.isBlockStatement(path.node.body) && !(types$13.isIdentifier(path.node.body) && path.node.body.name === "undefined")) yield types$13.arrowFunctionExpression([], types$13.identifier("undefined"));
-	}
-};
-//#endregion
-//#region src/mutators/assignment-operator-mutator.ts
-const assignmentOperatorReplacements = Object.freeze({
-	"+=": "-=",
-	"-=": "+=",
-	"*=": "/=",
-	"/=": "*=",
-	"%=": "*=",
-	"<<=": ">>=",
-	">>=": "<<=",
-	"&=": "|=",
-	"|=": "&=",
-	"&&=": "||=",
-	"||=": "&&=",
-	"??=": "&&="
-});
-const stringTypes = Object.freeze(["StringLiteral", "TemplateLiteral"]);
-const stringAssignmentTypes = Object.freeze([
-	"&&=",
-	"||=",
-	"??="
-]);
-const assignmentOperatorMutator = {
-	name: "AssignmentOperator",
-	*mutate(path) {
-		if (path.isAssignmentExpression() && isSupportedAssignmentOperator(path.node.operator) && isSupported$2(path.node)) {
-			const mutatedOperator = assignmentOperatorReplacements[path.node.operator];
-			const replacement = deepCloneNode(path.node);
-			replacement.operator = mutatedOperator;
-			yield replacement;
-		}
-	}
-};
-function isSupportedAssignmentOperator(operator) {
-	return Object.keys(assignmentOperatorReplacements).includes(operator);
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null;
 }
-function isSupported$2(node) {
-	if (stringTypes.includes(node.right.type) && !stringAssignmentTypes.includes(node.operator)) return false;
-	return true;
+function isUnknownArray(value) {
+	return Array.isArray(value);
 }
-//#endregion
-//#region src/mutators/block-statement-mutator.ts
-const { types: types$12 } = babel;
-const blockStatementMutator = {
-	name: "BlockStatement",
-	*mutate(path) {
-		if (path.isBlockStatement() && isValid(path)) yield types$12.blockStatement([]);
-	}
-};
-function isValid(path) {
-	return !isEmpty(path) && !isInvalidConstructorBody(path);
+function isRangedProgram(value) {
+	return isPlainRecord(value) && typeof value["start"] === "number" && typeof value["end"] === "number";
 }
-function isEmpty(path) {
-	return !path.node.body.length;
+function isWalkFunction(value) {
+	return typeof value === "function";
 }
-/**
-* Checks to see if a statement is an invalid constructor body
-* @example
-* // Invalid!
-* class Foo extends Bar {
-*   constructor(public baz: string) {
-*     super(42);
-*   }
-* }
-* @example
-* // Invalid!
-* class Foo extends Bar {
-*   public baz = 'string';
-*   constructor() {
-*     super(42);
-*   }
-* }
-* @see https://github.com/stryker-mutator/stryker-js/issues/2314
-* @see https://github.com/stryker-mutator/stryker-js/issues/2474
-*/
-function isInvalidConstructorBody(blockStatement) {
-	return Boolean(blockStatement.parentPath.isClassMethod() && blockStatement.parentPath.node.kind === "constructor" && (containsTSParameterProperties(blockStatement.parentPath) || containsInitializedClassProperties(blockStatement.parentPath)) && hasSuperExpression(blockStatement));
+function isRangedBaseNode(value) {
+	return isPlainRecord(value) && typeof value["type"] === "string" && typeof value["start"] === "number" && typeof value["end"] === "number";
 }
-function containsTSParameterProperties(constructor) {
-	return constructor.node.params.some((param) => types$12.isTSParameterProperty(param));
+function isTemplateExpressionType(type) {
+	return type === "MustacheTag" || type === "RawMustacheTag" || type === "IfBlock" || type === "ConstTag" || type === "EachBlock" || type === "AwaitBlock" || type === "KeyBlock" || type === "EventHandler";
 }
-function containsInitializedClassProperties(constructor) {
-	return constructor.parentPath.isClassBody() && constructor.parentPath.node.body.some((classMember) => types$12.isClassProperty(classMember) && classMember.value);
+function tryGetScriptRangeFromElement(node) {
+	if (!isPlainRecord(node) || node["type"] !== "Element" || node["name"] !== "script") return;
+	const children = node["children"];
+	if (!isUnknownArray(children) || children.length === 0) return;
+	const firstChild = children[0];
+	if (!isPlainRecord(firstChild) || firstChild["type"] !== "Text" || typeof firstChild["start"] !== "number" || typeof firstChild["end"] !== "number") return;
+	return {
+		start: firstChild["start"],
+		end: firstChild["end"],
+		isExpression: false
+	};
 }
-function hasSuperExpression(constructor) {
-	let hasSuper = false;
-	constructor.traverse({ Super(path) {
-		if (path.parentPath.isCallExpression()) {
-			path.stop();
-			hasSuper = true;
+async function parse$1(text, fileName, context) {
+	const { parse: svelteParse, preprocess, VERSION } = await import("svelte/compiler");
+	let walk;
+	if (!isSupportedSvelteVersion(VERSION)) throw new SvelteVersionNotSupported({
+		version: VERSION,
+		fileName,
+		cause: `Expected >=3.30`
+	});
+	if (isSvelteV5OrLater(VERSION)) {
+		const walkerModule = await import(import.meta.resolve("estree-walker", import.meta.resolve("svelte")));
+		if (!isPlainRecord(walkerModule) || !isWalkFunction(walkerModule["walk"])) throw new SvelteWalkerNotFound({
+			fileName,
+			cause: "estree-walker module without walk export"
+		});
+		walk = walkerModule["walk"];
+	} else {
+		const svelteCompilerModule = await import("svelte/compiler");
+		if (!isPlainRecord(svelteCompilerModule) || !isWalkFunction(svelteCompilerModule["walk"])) throw new SvelteWalkerNotFound({
+			fileName,
+			cause: "svelte/compiler module without walk export"
+		});
+		walk = svelteCompilerModule["walk"];
+	}
+	const lineStarts = computeLineStarts(text);
+	const { replacedCode, scriptMap } = await replaceScripts(text);
+	const svelteAst = svelteParse(replacedCode, { filename: fileName });
+	const { remappedModuleScriptRange, remappedScriptRanges } = remapScriptLocations(replacedCode, scriptMap, getModuleScriptRange(svelteAst), getTemplateScriptRanges(svelteAst, walk));
+	const [moduleScript, ...additionalScripts] = await Promise.all([parseTemplateScriptIfDefined(remappedModuleScriptRange), ...remappedScriptRanges.map(parseTemplateScript)]);
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "svelte",
+		root: {
+			...moduleScript === void 0 ? {} : { moduleScript },
+			additionalScripts
 		}
-	} });
-	return hasSuper;
-}
-//#endregion
-//#region src/mutators/boolean-literal-mutator.ts
-const { types: types$11 } = babel;
-const booleanLiteralMutator = {
-	name: "BooleanLiteral",
-	*mutate(path) {
-		if (path.isBooleanLiteral()) yield types$11.booleanLiteral(!path.node.value);
-		if (path.isUnaryExpression() && path.node.operator === "!" && path.node.prefix) yield deepCloneNode(path.node.argument);
+	};
+	/**
+	* Replaces script tags with placeholders.
+	* This is needed, because svelte's `parse` doesn't support `lang="ts"`.
+	*/
+	async function replaceScripts(code) {
+		const map = /* @__PURE__ */ new Map();
+		let scriptIndex = 0;
+		return {
+			replacedCode: (await preprocess(code, { script(script) {
+				const scriptName = `script${scriptIndex++}`;
+				map.set(scriptName, script);
+				return { code: scriptName };
+			} })).code,
+			scriptMap: map
+		};
 	}
-};
-//#endregion
-//#region src/mutators/conditional-expression-mutator.ts
-const booleanOperators = Object.freeze([
-	"!=",
-	"!==",
-	"&&",
-	"<",
-	"<=",
-	"==",
-	"===",
-	">",
-	">=",
-	"||"
-]);
-const { types: types$10 } = babel;
-const conditionalExpressionMutator = {
-	name: "ConditionalExpression",
-	*mutate(path) {
-		if (isTestOfLoop(path)) yield types$10.booleanLiteral(false);
-		else if (isTestOfCondition(path)) {
-			yield types$10.booleanLiteral(true);
-			yield types$10.booleanLiteral(false);
-		} else if (isBooleanExpression(path)) {
-			if (path.parent?.type === "LogicalExpression") {
-				if (path.parent.operator === "||") {
-					yield types$10.booleanLiteral(false);
-					return;
-				}
-				if (path.parent.operator === "&&") {
-					yield types$10.booleanLiteral(true);
-					return;
-				}
+	function getTemplateScriptRanges(ast, walker) {
+		const ranges = [];
+		if (isPlainRecord(ast) && ast["instance"] !== null && ast["instance"] !== void 0) {
+			const instance = ast["instance"];
+			if (isPlainRecord(instance) && "content" in instance) {
+				const content = instance["content"];
+				if (isRangedProgram(content)) ranges.push({
+					start: content.start,
+					end: content.end,
+					isExpression: false
+				});
+				else throw new Error("Svelte instance script without a source range");
 			}
-			yield types$10.booleanLiteral(true);
-			yield types$10.booleanLiteral(false);
-		} else if (path.isForStatement() && !path.node.test) {
-			const replacement = deepCloneNode(path.node);
-			replacement.test = types$10.booleanLiteral(false);
-			yield replacement;
-		} else if (path.isSwitchCase() && path.node.consequent.length > 0) {
-			const replacement = deepCloneNode(path.node);
-			replacement.consequent = [];
-			yield replacement;
 		}
+		if (!isPlainRecord(ast) || !("html" in ast)) throw new Error("Svelte AST without html");
+		const html = ast["html"];
+		walker(html, { enter(node) {
+			const scriptRange = tryGetScriptRangeFromElement(node);
+			if (scriptRange) ranges.push(scriptRange);
+			const templateExpression = collectTemplateExpression(node);
+			if (templateExpression) {
+				const { start, end } = templateExpression;
+				ranges.push({
+					start,
+					end,
+					isExpression: true
+				});
+			}
+		} });
+		return ranges;
 	}
-};
-function isTestOfLoop(path) {
-	const { parentPath } = path;
-	if (!parentPath) return false;
-	return (parentPath.isForStatement() || parentPath.isWhileStatement() || parentPath.isDoWhileStatement()) && parentPath.node.test === path.node;
-}
-function isTestOfCondition(path) {
-	const { parentPath } = path;
-	if (!parentPath) return false;
-	return parentPath.isIfStatement() && parentPath.node.test === path.node;
-}
-function isBooleanExpression(path) {
-	return (path.isBinaryExpression() || path.isLogicalExpression()) && booleanOperators.includes(path.node.operator);
-}
-//#endregion
-//#region src/mutators/equality-operator-mutator.ts
-const { types: t$2 } = babel;
-const operators = {
-	"<": ["<=", ">="],
-	"<=": ["<", ">"],
-	">": [">=", "<="],
-	">=": [">", "<"],
-	"==": ["!="],
-	"!=": ["=="],
-	"===": ["!=="],
-	"!==": ["==="]
-};
-function isEqualityOperator(operator) {
-	return Object.keys(operators).includes(operator);
-}
-const equalityOperatorMutator = {
-	name: "EqualityOperator",
-	*mutate(path) {
-		if (path.isBinaryExpression() && isEqualityOperator(path.node.operator)) for (const mutableOperator of operators[path.node.operator]) {
-			const replacement = t$2.cloneNode(path.node, true);
-			replacement.operator = mutableOperator;
-			yield replacement;
-		}
+	async function parseTemplateScriptIfDefined(range) {
+		if (range) return parseTemplateScript(range);
 	}
-};
-//#endregion
-//#region src/mutators/logical-operator-mutator.ts
-const logicalOperatorReplacements = Object.freeze({
-	"&&": "||",
-	"||": "&&",
-	"??": "&&"
-});
-const logicalOperatorMutator = {
-	name: "LogicalOperator",
-	*mutate(path) {
-		if (path.isLogicalExpression() && isSupported$1(path.node.operator)) {
-			const mutatedOperator = logicalOperatorReplacements[path.node.operator];
-			const replacement = deepCloneNode(path.node);
-			replacement.operator = mutatedOperator;
-			yield replacement;
-		}
+	async function parseTemplateScript({ start, end, isExpression, format }) {
+		const scriptText = text.slice(start, end);
+		return {
+			ast: {
+				...await context.parse(scriptText, fileName, format),
+				offset: positionFromOffset(lineStarts, start)
+			},
+			range: {
+				start,
+				end
+			},
+			isExpression
+		};
 	}
-};
-function isSupported$1(operator) {
-	return Object.keys(logicalOperatorReplacements).includes(operator);
 }
-//#endregion
-//#region src/mutators/method-expression-mutator.ts
-const { types: types$9 } = babel;
-const replacements = /* @__PURE__ */ new Map([
-	["charAt", null],
-	["endsWith", "startsWith"],
-	["every", "some"],
-	["filter", null],
-	["reverse", null],
-	["slice", null],
-	["sort", null],
-	["substr", null],
-	["substring", null],
-	["toLocaleLowerCase", "toLocaleUpperCase"],
-	["toLowerCase", "toUpperCase"],
-	["trim", null],
-	["trimEnd", "trimStart"],
-	["min", "max"],
-	["setDate", "setTime"],
-	["setFullYear", "setMonth"],
-	["setHours", "setMinutes"],
-	["setSeconds", "setMilliseconds"],
-	["setUTCDate", "setTime"],
-	["setUTCFullYear", "setUTCMonth"],
-	["setUTCHours", "setUTCMinutes"],
-	["setUTCSeconds", "setUTCMilliseconds"]
-]);
-const noReverseRemplacements = ["getUTCDate", "setUTCDate"];
-for (const [key, value] of Array.from(replacements)) if (value && !noReverseRemplacements.includes(key)) replacements.set(value, key);
-const methodExpressionMutator = {
-	name: "MethodExpression",
-	*mutate(path) {
-		if (!(path.isCallExpression() || path.isOptionalCallExpression())) return;
-		const { callee } = path.node;
-		if (!(types$9.isMemberExpression(callee) || types$9.isOptionalMemberExpression(callee)) || !types$9.isIdentifier(callee.property)) return;
-		const newName = replacements.get(callee.property.name);
-		if (newName === void 0) return;
-		if (newName === null) {
-			yield deepCloneNode(callee.object);
-			return;
-		}
-		const nodeArguments = path.node.arguments.map((argumentNode) => deepCloneNode(argumentNode));
-		const mutatedCallee = types$9.isMemberExpression(callee) ? types$9.memberExpression(deepCloneNode(callee.object), types$9.identifier(newName), false, callee.optional) : types$9.optionalMemberExpression(deepCloneNode(callee.object), types$9.identifier(newName), false, callee.optional);
-		yield types$9.isCallExpression(path.node) ? types$9.callExpression(mutatedCallee, nodeArguments) : types$9.optionalCallExpression(mutatedCallee, nodeArguments, path.node.optional);
-	}
-};
-//#endregion
-//#region src/mutators/object-literal-mutator.ts
-const { types: types$8 } = babel;
-const objectLiteralMutator = {
-	name: "ObjectLiteral",
-	*mutate(path) {
-		if (path.isObjectExpression() && path.node.properties.length > 0) yield types$8.objectExpression([]);
-	}
-};
-//#endregion
-//#region src/mutators/optional-chaining-mutator.ts
-const { types: t$1 } = babel;
+function getModuleScriptRange(svelteAst) {
+	if (!isPlainRecord(svelteAst) || !("module" in svelteAst) || svelteAst["module"] === null || svelteAst["module"] === void 0) return;
+	const mod = svelteAst["module"];
+	if (!isPlainRecord(mod) || !("content" in mod)) throw new Error("Svelte module script without a source range");
+	const content = mod["content"];
+	if (!isRangedProgram(content)) throw new Error("Svelte module script without a source range");
+	return {
+		start: content.start,
+		end: content.end,
+		isExpression: false
+	};
+}
 /**
-* Mutates optional chaining operators
-* Note that the AST for optional chaining might not be what you expect. Nodes of type `OptionalMemberExpression` can be either optional or not-optional
-*
-* For example: In this expression: `foo?.bar.baz` the `.baz` member expression is of type `OptionalMemberExpression`, because it is part of an optional chain, but is is _not_ optional.
-* Only the `.bar` optional member expression is optional.
-*
-* @example
-* foo?.bar -> foo.bar
-* foo?.[1] -> foo[1]
-* foo?.() -> foo()
+* Remaps script locations back to the original places using the script map
 */
-const optionalChainingMutator = {
-	name: "OptionalChaining",
-	*mutate(path) {
-		if (path.isOptionalMemberExpression() && path.node.optional) yield t$1.optionalMemberExpression(t$1.cloneNode(path.node.object, true), t$1.cloneNode(path.node.property, true), path.node.computed, false);
-		if (path.isOptionalCallExpression() && path.node.optional) yield t$1.optionalCallExpression(t$1.cloneNode(path.node.callee, true), path.node.arguments.map((arg) => t$1.cloneNode(arg, true)), false);
-	}
-};
+function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges) {
+	const scriptRanges = [moduleScriptRange, ...templateRanges].filter(Predicate.isNotNullish).sort((a, b) => a.start - b.start);
+	let offset = 0;
+	let newModuleScriptRange;
+	const newScriptRanges = scriptRanges.map((range) => {
+		const script = code.substring(range.start, range.end);
+		const actualScript = scriptMap.get(script);
+		const start = range.start + offset;
+		if (actualScript) {
+			const scriptRange = {
+				start,
+				end: start + actualScript.content.length,
+				isExpression: range.isExpression,
+				format: actualScript.attributes["lang"] === "ts" ? "ts" : "js"
+			};
+			offset += actualScript.content.length - script.length;
+			if (range === moduleScriptRange) newModuleScriptRange = scriptRange;
+			return scriptRange;
+		} else return {
+			start,
+			end: start + script.length,
+			isExpression: range.isExpression,
+			format: "js"
+		};
+	});
+	return {
+		remappedModuleScriptRange: newModuleScriptRange,
+		remappedScriptRanges: newScriptRanges.filter((range) => range !== newModuleScriptRange)
+	};
+}
+function collectTemplateExpression(node) {
+	if (!isPlainRecord(node) || typeof node["type"] !== "string") return;
+	if (!isTemplateExpressionType(node["type"])) return;
+	if (!("expression" in node)) return;
+	const expression = node["expression"];
+	if (isRangedBaseNode(expression)) return expression;
+}
 //#endregion
-//#region src/mutators/regex-mutator.ts
-const { types: types$7 } = babel;
+//#region src/parsers/ts-parser.ts
+const { types: types$19, parseAsync } = babel;
+const require = createRequire(import.meta.url);
 /**
-* Checks that a string literal is an obvious regex string literal
-* @param path The string literal to checks
-* @example
-* new RegExp("\\d{4}");
+* See https://babeljs.io/docs/en/babel-preset-typescript
+* @param text The text to parse
+* @param fileName The name of the file
 */
-function isObviousRegexString(path) {
-	return path.parentPath.isNewExpression() && types$7.isIdentifier(path.parentPath.node.callee) && path.parentPath.node.callee.name === RegExp.name && path.parentPath.node.arguments[0] === path.node;
-}
-function getFlags(path) {
-	if (types$7.isStringLiteral(path.node.arguments[1])) return path.node.arguments[1].value;
-}
-const weaponRegexOptions = { mutationLevels: [1] };
-const regexMutator = {
-	name: "Regex",
-	*mutate(path) {
-		if (path.isRegExpLiteral()) for (const replacementPattern of mutatePattern(path.node.pattern, path.node.flags)) yield types$7.regExpLiteral(replacementPattern, path.node.flags);
-		else if (path.isStringLiteral() && isObviousRegexString(path)) {
-			const parentPath = path.parentPath;
-			if (parentPath.isNewExpression()) {
-				const flags = getFlags(parentPath);
-				for (const replacementPattern of mutatePattern(path.node.value, flags)) yield types$7.stringLiteral(replacementPattern);
-			}
-		}
-	}
-};
-function mutatePattern(pattern, flags) {
-	if (pattern.length) try {
-		return weaponRegex.mutate(pattern, flags, weaponRegexOptions).map((mutant) => mutant.pattern);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : typeof err === "string" ? err : JSON.stringify(err) ?? "Unknown error";
-		console.error(`[RegexMutator]: The Regex parser of weapon-regex couldn't parse this regex pattern: "${pattern}". Please report this issue at https://github.com/stryker-mutator/weapon-regex/issues. Inner error: ${message}`);
-	}
-	return [];
-}
-//#endregion
-//#region src/mutators/string-literal-mutator.ts
-const { types: types$6 } = babel;
-const stringLiteralMutator = {
-	name: "StringLiteral",
-	*mutate(path) {
-		if (path.isTemplateLiteral()) {
-			const firstQuasi = path.node.quasis[0];
-			if (firstQuasi === void 0) throw new Error("Template literal without quasis");
-			const replacement = path.node.quasis.length === 1 && firstQuasi.value.raw.length === 0 ? "Stryker was here!" : "";
-			yield types$6.templateLiteral([types$6.templateElement({ raw: replacement })], []);
-		}
-		if (path.isStringLiteral() && isValidParent(path)) yield types$6.stringLiteral(path.node.value.length === 0 ? "Stryker was here!" : "");
-	}
-};
-function isValidParent(child) {
-	const { parent } = child;
-	return !isImportExportRelated(parent) && !isJsxOrExpressionRelated(parent) && !isObjectOrClassPropertyKey(parent, child) && !isDisallowedCallExpression(parent);
-}
-function isImportExportRelated(parent) {
-	return types$6.isImportDeclaration(parent) || types$6.isExportDeclaration(parent) || types$6.isImportOrExportDeclaration(parent) || types$6.isTSExternalModuleReference(parent);
-}
-function isJsxOrExpressionRelated(parent) {
-	return types$6.isJSXAttribute(parent) || types$6.isExpressionStatement(parent) || types$6.isTSLiteralType(parent) || types$6.isObjectMethod(parent);
-}
-function isObjectOrClassPropertyKey(parent, child) {
-	return types$6.isObjectProperty(parent) && parent.key === child.node || types$6.isClassProperty(parent) && parent.key === child.node;
-}
-function isDisallowedCallExpression(parent) {
-	return isRequireCall(parent) || isSymbolCall(parent) || isImportCall(parent);
-}
-function isRequireCall(parent) {
-	return types$6.isCallExpression(parent) && types$6.isIdentifier(parent.callee, { name: "require" });
+async function parseTS(text, fileName) {
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "ts",
+		root: await parse(text, fileName, false)
+	};
 }
-function isSymbolCall(parent) {
-	return types$6.isCallExpression(parent) && types$6.isIdentifier(parent.callee, { name: "Symbol" });
+async function parseTsx(text, fileName) {
+	return {
+		root: await parse(text, fileName, true),
+		format: "tsx",
+		originFileName: fileName,
+		rawContent: text
+	};
 }
-function isImportCall(parent) {
-	return types$6.isCallExpression(parent) && types$6.isImport(parent.callee);
+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/mutators/unary-operator-mutator.ts
-const { types: types$5 } = babel;
-var UnaryOperator = /* @__PURE__ */ function(UnaryOperator) {
-	UnaryOperator["+"] = "-";
-	UnaryOperator["-"] = "+";
-	UnaryOperator["~"] = "";
-	return UnaryOperator;
-}(UnaryOperator || {});
-const unaryOperatorMutator = {
-	name: "UnaryOperator",
-	*mutate(path) {
-		if (path.isUnaryExpression() && isSupported(path.node.operator) && path.node.prefix) {
-			const mutatedOperator = UnaryOperator[path.node.operator];
-			yield isPlusOrMinus(mutatedOperator) ? types$5.unaryExpression(mutatedOperator, deepCloneNode(path.node.argument)) : deepCloneNode(path.node.argument);
+//#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}!`);
 		}
-	}
-};
-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$4 } = babel;
-var UpdateOperators = /* @__PURE__ */ function(UpdateOperators) {
-	UpdateOperators["++"] = "--";
-	UpdateOperators["--"] = "++";
-	return UpdateOperators;
-}(UpdateOperators || {});
-//#endregion
-//#region src/mutators/mutate.ts
-const allMutators = [
-	arithmeticOperatorMutator,
-	arrayDeclarationMutator,
-	arrowFunctionMutator,
-	blockStatementMutator,
-	booleanLiteralMutator,
-	conditionalExpressionMutator,
-	equalityOperatorMutator,
-	logicalOperatorMutator,
-	methodExpressionMutator,
-	objectLiteralMutator,
-	stringLiteralMutator,
-	unaryOperatorMutator,
-	{
-		name: "UpdateOperator",
-		*mutate(path) {
-			if (path.isUpdateExpression()) yield types$4.updateExpression(UpdateOperators[path.node.operator], deepCloneNode(path.node.argument), path.node.prefix);
+		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)}`);
 		}
-	},
-	regexMutator,
-	optionalChainingMutator,
-	assignmentOperatorMutator
-];
-//#endregion
-//#region src/transformers/mutant-collector.ts
-var MutantCollector = class {
-	_mutants = [];
-	get mutants() {
-		return this._mutants;
 	}
-	/**
-	* Adds mutants to the internal mutant list.
-	* @param fileName file name that houses the mutant
-	* @param original The node to mutate
-	* @param mutables the named node mutation to be added
-	* @param contextPath the context where these mutants are found and should be placed as close by as possible
-	* @param offset offset of mutant nodes
-	* @returns The mutant (for testability)
-	*/
-	collect(fileName, original, mutable, offset = {
-		line: 0,
-		column: 0
-	}) {
-		const mutant = new Mutant$1(this._mutants.length.toString(), fileName, original, mutable, offset);
-		this._mutants.push(mutant);
-		return mutant;
-	}
-	hasPlacedMutants(fileName) {
-		return this.mutants.some((mutant) => mutant.fileName === fileName && !mutant.ignoreReason);
+	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/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
-* `canPlace` is what established it, so a mismatch here means the placer was
-* handed a mutant it never accepted.
-*/
-function nodeOfKind(mutant, node, isKind, kind) {
-	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
-	return node;
 }
 //#endregion
-//#region src/mutant-placers/expression-mutant-placer.ts
-const { types: types$3 } = babel;
+//#region src/disable-type-checks.ts
+const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
+const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
+const startingCommentRegex = /(^\s*\/\*.*?\*\/)/gs;
 /**
-* Will set the identifier of anonymous function expressions if is located in a variable declaration.
-* Will treat input as readonly. Returns undefined if not needed.
-* @example
-* const a = function() { }
-* becomes
-* const a = function a() {}
+* 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
 */
-function classOrFunctionExpressionNamedIfNeeded(path) {
-	if ((path.isFunctionExpression() || path.isClassExpression()) && !path.node.id) {
-		if (path.parentPath.isVariableDeclarator() && types$3.isIdentifier(path.parentPath.node.id)) {
-			path.node.id = path.parentPath.node.id;
-			return path.node;
-		} else if (path.parentPath.isObjectProperty() && types$3.isIdentifier(path.parentPath.node.key) && path.getStatementParent()?.isVariableDeclaration()) {
-			path.node.id = path.parentPath.node.key;
-			return path.node;
-		}
+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)
+		};
 	}
 }
-/**
-* Will set the identifier of anonymous arrow function expressions if is located in a variable declaration.
-* Will treat input as readonly. Returns undefined if not needed.
-* @example
-* const a = () => { }
-* becomes
-* const a = (() => { const a = () => {}; return a; })()
-*/
-function arrowFunctionExpressionNamedIfNeeded(path) {
-	if (path.isArrowFunctionExpression() && path.parentPath.isVariableDeclarator() && types$3.isIdentifier(path.parentPath.node.id)) return types$3.callExpression(types$3.arrowFunctionExpression([], types$3.blockStatement([types$3.variableDeclaration("const", [types$3.variableDeclarator(path.parentPath.node.id, path.node)]), types$3.returnStatement(path.parentPath.node.id)])), []);
-}
-function nameIfAnonymous(path) {
-	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowFunctionExpressionNamedIfNeeded(path) ?? path.node;
+function isJSFileWithoutTSDirectives(file, format) {
+	return (format === "ts" || format === "js") && !tsDirectiveLikeRegEx.test(file.content);
 }
-function isMemberOrCallOrNonNullExpression(path) {
-	return isCallExpression(path) || isMemberOrNonNullExpression(path);
+function disableTypeCheckingInBabelAst(ast) {
+	return prefixWithNoCheck(removeTSDirectives(ast.rawContent, ast.root.comments));
 }
-function isMemberOrNonNullExpression(path) {
-	return isMemberExpression(path) || path.isTSNonNullExpression();
+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)}`;
+	}
 }
-function isMemberExpression(path) {
-	return path.isMemberExpression() || path.isOptionalMemberExpression();
+function getScriptStart$1(script) {
+	const start = script.root.start;
+	if (start === void 0 || start === null) throw new Error("Script AST root without start");
+	return start;
 }
-function isCallExpression(path) {
-	return path.isCallExpression() || path.isOptionalCallExpression();
+function getScriptEnd$1(script) {
+	const end = script.root.end;
+	if (end === void 0 || end === null) throw new Error("Script AST root without end");
+	return end;
 }
-function isValidExpression(path) {
-	const parent = path.parentPath;
-	return !isObjectPropertyKey() && !isPartOfChain() && !parent.isTaggedTemplateExpression() && !isPartOfDeleteExpression() && !isPartOfAssignmentExpression();
-	/**
-	* Determines if the expression is property of an object.
-	* @example
-	* const a = {
-	*  'foo': 'bar' // 'foo' here is an object property
-	* };
-	*/
-	function isObjectPropertyKey() {
-		return parent.isObjectProperty() && parent.node.key === path.node;
-	}
-	/**
-	* Determines if the expression is part of a call/member chain.
-	* @example
-	* // bar is part of chain, foo is NOT part of the chain:
-	* foo.bar.baz();
-	* foo.bar?.baz()
-	* foo.bar;
-	* foo.bar!;
-	* foo.bar();
-	* foo?.bar();
-	* baz[foo.bar()]
-	* bar?.baz[0]
-	*/
-	function isPartOfChain() {
-		return isMemberOrCallOrNonNullExpression(path) && (isMemberExpression(parent) && !(parent.node.computed && parent.node.property === path.node) || parent.isTSNonNullExpression() || isCallExpression(parent) && parent.node.callee === path.node);
+function disableTypeCheckingInHtml(ast) {
+	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 += "\n";
+		currentIndex = getScriptEnd$1(script);
 	}
-	/**
-	* Determines if the expression is part of a delete expression.
-	* @returns true if the expression is part of a delete expression
-	* @example
-	* delete foo.bar;
-	*/
-	function isPartOfDeleteExpression() {
-		return parent.isUnaryExpression() && parent.node.operator === "delete";
+	html += ast.rawContent.substring(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);
+	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";
+		currentIndex = script.range.end;
 	}
-	/**
-	* Determines if the expression is part of an assignment expression.
-	* @returns true if the expression is part of an assignment expression
-	* @example
-	* foo.bar = 42;
-	* initialNodes.filter((n) => n.id === 'tiptilt')[0].className = tiptiltState;
-	*/
-	function isPartOfAssignmentExpression() {
-		return parent.isAssignmentExpression() && parent.node.left === path.node;
+	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
 /**
-* Places the mutants with a conditional expression: `global.activeMutant === 1? mutatedCode : originalCode`;
+* `@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 expressionMutantPlacer = {
-	name: "expressionMutantPlacer",
-	canPlace(path) {
-		return path.isExpression() && isValidExpression(path);
-	},
-	place(path, appliedMutants) {
-		let expression = nameIfAnonymous(path);
-		expression = mutationCoverageSequenceExpression(appliedMutants.keys(), expression);
-		for (const [mutant, appliedMutant] of appliedMutants) expression = types$3.conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, types$3.isExpression, "an expression"), expression);
-		path.replaceWith(expression);
-	}
-};
+const generate = typeof generator === "function" ? generator : generator.default;
 //#endregion
-//#region src/mutant-placers/statement-mutant-placer.ts
-const { types: t } = babel;
+//#region src/babel/clone.ts
+const { types: types$18 } = babel;
 /**
-* Mutant placer that places mutants in statements that allow it.
-* It uses an `if` statement to do so
+* Helper for `types.cloneNode(node, deep: true, withoutLocations: false);`
 */
-const statementMutantPlacer = {
-	name: "statementMutantPlacer",
-	canPlace(path) {
-		return path.isStatement();
-	},
-	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);
-	}
-};
+function deepCloneNode(node) {
+	return types$18.cloneNode(node, true, false);
+}
 //#endregion
-//#region src/mutant-placers/switch-case-mutant-placer.ts
+//#region src/babel/equality.ts
+function eqPosition(a, b) {
+	return a.line === b.line && a.column === b.column;
+}
+function eqLocation(a, b) {
+	return eqPosition(a.start, b.start) && eqPosition(a.end, b.end);
+}
+function eqNode(a, b) {
+	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
+}
+//#endregion
+//#region src/mutant.ts
+const { traverse: traverse$1 } = babel;
+function createMutant(id, fileName, original, specs, offset = {
+	column: 0,
+	line: 0
+}) {
+	return {
+		id,
+		fileName,
+		original,
+		offset,
+		replacement: specs.replacement,
+		mutatorName: specs.mutatorName,
+		ignoreReason: specs.ignoreReason,
+		replacementCode: generate(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" }
+	};
+}
 /**
-* 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;
-*   }
+* 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
 */
-const switchCaseMutantPlacer = {
-	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);
+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, {
+		noScope: true,
+		enter(path) {
+			if (eqNode(path.node, original)) {
+				path.replaceWith(replacement);
+				path.stop();
+				applied = true;
+			}
 		}
-		path.replaceWith(babel.types.switchCase(path.node.test, [consequence]));
-	}
-};
-//#endregion
-//#region src/mutant-placers/throw-placement-error.ts
-function throwPlacementError(error, nodePath, placer, mutants, fileName) {
-	const location = `${path.relative(process.cwd(), fileName)}:${nodePath.node.loc?.start.line}:${nodePath.node.loc?.start.column}`;
-	const message = `${placer.name} could not place mutants with type(s): "${new Intl.ListFormat("en").format(mutants.map((mutant) => mutant.mutatorName))}"`;
-	const errorMessage = `${location} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using ${propertyPath()("mutator", "excludedMutations")}). Please report this issue at https://github.com/stryker-mutator/stryker-js/issues/new?assignees=&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=${encodeURIComponent(message)}. Original error: ${error.stack}`;
-	let builtError = new Error(errorMessage);
-	try {
-		builtError = nodePath.buildCodeFrameError(errorMessage);
-	} catch {}
-	throw builtError;
+	});
+	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
+	};
 }
 //#endregion
-//#region src/mutant-placers/index.ts
-const allMutantPlacers = Object.freeze([
-	expressionMutantPlacer,
-	statementMutantPlacer,
-	switchCaseMutantPlacer
-]);
+//#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/util/babel-file.ts
+//#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
@@ -1047,327 +914,569 @@ function createBabelFile(filename, code, ast) {
 	});
 }
 //#endregion
-//#region src/transformers/directive-bookkeeper.ts
-const WILDCARD = "all";
-const DEFAULT_REASON = "Ignored using a comment";
-var IgnoreRule = class {
-	mutatorNames;
-	line;
-	ignoreReason;
-	previousRule;
-	constructor(mutatorNames, line, ignoreReason, previousRule) {
-		this.mutatorNames = mutatorNames;
-		this.line = line;
-		this.ignoreReason = ignoreReason;
-		this.previousRule = previousRule;
-	}
-	matches(mutatorName, line) {
-		const lineMatches = () => this.line === void 0 || this.line === line;
-		const mutatorMatches = () => this.mutatorNames.includes(mutatorName) || this.mutatorNames.includes(WILDCARD);
-		return lineMatches() && mutatorMatches();
-	}
-	findIgnoreReason(mutatorName, line) {
-		if (this.matches(mutatorName, line)) return this.ignoreReason;
-		return this.previousRule.findIgnoreReason(mutatorName, line);
+//#region src/mutators/arithmetic-operator-mutator.ts
+const { types: t$3 } = babel;
+const arithmeticOperatorReplacements = Object.freeze({
+	"+": "-",
+	"-": "+",
+	"*": "/",
+	"/": "*",
+	"%": "*"
+});
+const arithmeticOperatorMutator = function* (node, _context) {
+	if (t$3.isBinaryExpression(node) && isSupported$3(node.operator, node)) {
+		const mutatedOperator = arithmeticOperatorReplacements[node.operator];
+		const replacement = deepCloneNode(node);
+		replacement.operator = mutatedOperator;
+		yield replacement;
 	}
 };
-var RestoreRule = class extends IgnoreRule {
-	constructor(mutatorNames, line, previousRule) {
-		super(mutatorNames, line, void 0, previousRule);
+function isSupported$3(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;
+	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);
 	}
 };
-const rootRule = { findIgnoreReason() {} };
-/**
-* Responsible for the bookkeeping of "// Stryker" directives like "disable" and "restore".
-*/
-var DirectiveBookkeeper = class {
-	logger;
-	allMutators;
-	originFileName;
-	strykerCommentDirectiveRegex = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z, ]+)(?::(.+)?)?/;
-	currentIgnoreRule = rootRule;
-	allMutatorNames;
-	constructor(logger, allMutators, originFileName) {
-		this.logger = logger;
-		this.allMutators = allMutators;
-		this.originFileName = originFileName;
-		this.allMutatorNames = this.allMutators.map((x) => x.name.toLowerCase());
-	}
-	processStrykerDirectives({ loc, leadingComments }) {
-		if (!leadingComments) return;
-		for (const comment of leadingComments) {
-			const matchResult = this.strykerCommentDirectiveRegex.exec(comment.value);
-			if (!matchResult) continue;
-			const directiveType = matchResult[1];
-			const scope = matchResult[2];
-			const mutators = matchResult[3];
-			const optionalReason = matchResult[4];
-			if (directiveType === void 0 || mutators === void 0) throw new Error("Stryker directive without directive type or mutators");
-			let mutatorNames = mutators.split(",").map((mutator) => mutator.trim());
-			this.warnAboutUnusedDirective(mutatorNames, directiveType, scope, comment);
-			mutatorNames = mutatorNames.map((mutator) => mutator.toLowerCase());
-			const reason = (optionalReason ?? DEFAULT_REASON).trim();
-			this.applyDirective(directiveType, scope, mutatorNames, reason, loc);
-		}
-	}
-	applyDirective(directiveType, scope, mutatorNames, reason, loc) {
-		switch (directiveType) {
-			case "disable":
-				this.applyDisable(scope, mutatorNames, reason, loc);
-				break;
-			case "restore": this.applyRestore(scope, mutatorNames, loc);
-		}
+//#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"));
+};
+//#endregion
+//#region src/mutators/assignment-operator-mutator.ts
+const { types: types$15 } = babel;
+const assignmentOperatorReplacements = Object.freeze({
+	"+=": "-=",
+	"-=": "+=",
+	"*=": "/=",
+	"/=": "*=",
+	"%=": "*=",
+	"<<=": ">>=",
+	">>=": "<<=",
+	"&=": "|=",
+	"|=": "&=",
+	"&&=": "||=",
+	"||=": "&&=",
+	"??=": "&&="
+});
+const stringTypes = Object.freeze(["StringLiteral", "TemplateLiteral"]);
+const stringAssignmentTypes = Object.freeze([
+	"&&=",
+	"||=",
+	"??="
+]);
+const assignmentOperatorMutator = function* (node, _context) {
+	if (types$15.isAssignmentExpression(node) && isSupportedAssignmentOperator(node.operator) && isSupported$2(node)) {
+		const mutatedOperator = assignmentOperatorReplacements[node.operator];
+		const replacement = deepCloneNode(node);
+		replacement.operator = mutatedOperator;
+		yield replacement;
 	}
-	applyDisable(scope, mutatorNames, reason, loc) {
-		switch (scope) {
-			case "next-line":
-				this.currentIgnoreRule = new IgnoreRule(mutatorNames, this.getLine(loc), reason, this.currentIgnoreRule);
-				break;
-			case void 0:
-			default: this.currentIgnoreRule = new IgnoreRule(mutatorNames, void 0, reason, this.currentIgnoreRule);
-		}
+};
+function isSupportedAssignmentOperator(operator) {
+	return Object.keys(assignmentOperatorReplacements).includes(operator);
+}
+function isSupported$2(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([]);
+};
+function isValid(node, context) {
+	return !isEmpty(node) && !isInvalidConstructorBody(node, context);
+}
+function isEmpty(node) {
+	return node.body.length === 0;
+}
+function isInvalidConstructorBody(node, context) {
+	const parent = context.parent;
+	if (parent === void 0 || !types$14.isClassMethod(parent) || parent.kind !== "constructor") return false;
+	const hasParamProps = parent.params.some((param) => types$14.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);
+}
+function hasSuperExpression(block) {
+	return containsSuperCall(block);
+}
+function isSuperType(node) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "Super";
+}
+function isSuperCallExpression(node) {
+	return Predicate.hasProperty(node, "type") && node["type"] === "CallExpression" && Predicate.hasProperty(node, "callee") && isSuperType(node["callee"]);
+}
+function containsSuperCall(node) {
+	if (typeof node !== "object" || node === null) return false;
+	if (isSuperType(node) || isSuperCallExpression(node)) return true;
+	return hasSuperInChildren(node);
+}
+function hasSuperInChildren(node) {
+	for (const key of Object.keys(node)) {
+		if (!Predicate.hasProperty(node, key)) continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const element of value) if (containsSuperCall(element)) return true;
+		} else if (typeof value === "object" && value !== null && containsSuperCall(value)) return true;
 	}
-	applyRestore(scope, mutatorNames, loc) {
-		switch (scope) {
-			case "next-line":
-				this.currentIgnoreRule = new RestoreRule(mutatorNames, this.getLine(loc), this.currentIgnoreRule);
-				break;
-			case void 0:
-			default: this.currentIgnoreRule = new RestoreRule(mutatorNames, void 0, this.currentIgnoreRule);
+	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);
+};
+//#endregion
+//#region src/mutators/conditional-expression-mutator.ts
+const booleanOperators = Object.freeze([
+	"!=",
+	"!==",
+	"&&",
+	"<",
+	"<=",
+	"==",
+	"===",
+	">",
+	">=",
+	"||"
+]);
+const { types: types$12 } = babel;
+const conditionalExpressionMutator = function* (node, context) {
+	if (isTestOfLoop(node, context)) yield types$12.booleanLiteral(false);
+	else if (isTestOfCondition(node, context)) {
+		yield types$12.booleanLiteral(true);
+		yield types$12.booleanLiteral(false);
+	} else if (isBooleanExpression(node)) {
+		const parent = context.parent;
+		if (parent !== void 0 && types$12.isLogicalExpression(parent)) {
+			if (parent.operator === "||") {
+				yield types$12.booleanLiteral(false);
+				return;
+			}
+			if (parent.operator === "&&") {
+				yield types$12.booleanLiteral(true);
+				return;
+			}
 		}
+		yield types$12.booleanLiteral(true);
+		yield types$12.booleanLiteral(false);
+	} else if (types$12.isForStatement(node) && node.test === null) {
+		const replacement = deepCloneNode(node);
+		replacement.test = types$12.booleanLiteral(false);
+		yield replacement;
+	} else if (types$12.isSwitchCase(node) && node.consequent.length > 0) {
+		const replacement = deepCloneNode(node);
+		replacement.consequent = [];
+		yield replacement;
 	}
-	getLine(loc) {
-		if (loc === void 0 || loc === null || loc.start === null || loc.start === void 0) throw new Error("Babel node without location");
-		return loc.start.line;
-	}
-	findIgnoreReason(line, mutatorName) {
-		mutatorName = mutatorName.toLowerCase();
-		return this.currentIgnoreRule.findIgnoreReason(mutatorName, line);
+};
+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;
+	return false;
+}
+function isTestOfCondition(node, context) {
+	const parent = context.parent;
+	if (parent === void 0) return false;
+	return types$12.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);
+	return false;
+}
+//#endregion
+//#region src/mutators/equality-operator-mutator.ts
+const { types: t$2 } = babel;
+const operators = {
+	"<": ["<=", ">="],
+	"<=": ["<", ">"],
+	">": [">=", "<="],
+	">=": [">", "<"],
+	"==": ["!="],
+	"!=": ["=="],
+	"===": ["!=="],
+	"!==": ["==="]
+};
+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);
+		replacement.operator = mutableOperator;
+		yield replacement;
 	}
-	warnAboutUnusedDirective(mutators, directiveType, scope, comment) {
-		for (const mutator of mutators) {
-			if (mutator === WILDCARD) continue;
-			if (!this.allMutatorNames.includes(mutator.toLowerCase())) {
-				const commentLoc = comment.loc;
-				if (commentLoc === void 0 || commentLoc === null || commentLoc.start === null || commentLoc.start === void 0) throw new Error("Comment without location");
-				this.logger.warn(`Unused 'Stryker ${scope ? directiveType + " " + scope : directiveType}' directive. Mutator with name '${mutator}' not found. Directive found at: ${this.originFileName}:${commentLoc.start.line}:${commentLoc.start.column}.`);
-			}
-		}
+};
+//#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)) {
+		const mutatedOperator = logicalOperatorReplacements[node.operator];
+		const replacement = deepCloneNode(node);
+		replacement.operator = mutatedOperator;
+		yield replacement;
 	}
 };
+function isSupported$1(operator) {
+	return Object.keys(logicalOperatorReplacements).includes(operator);
+}
 //#endregion
-//#region src/transformers/ignorer-bookkeeper.ts
+//#region src/mutators/method-expression-mutator.ts
+const { types: types$10 } = babel;
+const baseReplacements = {
+	charAt: null,
+	endsWith: "startsWith",
+	every: "some",
+	filter: null,
+	reverse: null,
+	slice: null,
+	sort: null,
+	substr: null,
+	substring: null,
+	toLocaleLowerCase: "toLocaleUpperCase",
+	toLowerCase: "toUpperCase",
+	trim: null,
+	trimEnd: "trimStart",
+	min: "max",
+	setDate: "setTime",
+	setFullYear: "setMonth",
+	setHours: "setMinutes",
+	setSeconds: "setMilliseconds",
+	setUTCDate: "setTime",
+	setUTCFullYear: "setUTCMonth",
+	setUTCHours: "setUTCMinutes",
+	setUTCSeconds: "setUTCMilliseconds"
+};
+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 methodExpressionMutator = function* (node, _context) {
+	if (!(types$10.isCallExpression(node) || types$10.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 (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);
+};
+//#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([]);
+};
+//#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
 /**
-* Responsible for keeping track of the active ignore message and node using the configured ignore-plugins.
+* 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.
 */
-var IgnorerBookkeeper = class {
-	ignorers;
-	activeIgnored;
-	get currentIgnoreMessage() {
-		return this.activeIgnored?.message;
-	}
-	constructor(ignorers) {
-		this.ignorers = ignorers;
-	}
-	enterNode(path) {
-		if (!this.activeIgnored) this.ignorers.forEach((ignorer) => {
-			const message = ignorer.shouldIgnore(path);
-			if (message) this.activeIgnored = {
-				node: path.node,
-				message
-			};
+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")
 		});
-	}
-	leaveNode(path) {
-		if (this.activeIgnored?.node === path.node) this.activeIgnored = void 0;
-	}
-};
-//#endregion
-//#region src/transformers/babel-transformer.ts
-const { traverse: traverse$1 } = babel;
-const transformBabel = ({ root, originFileName, rawContent, offset }, mutantCollector, { options, mutateDescription, logger }, mutators = allMutators, mutantPlacers = allMutantPlacers) => {
-	const file = createBabelFile(originFileName, rawContent, root);
-	const placementMap = /* @__PURE__ */ new Map();
-	const directiveBookkeeper = new DirectiveBookkeeper(logger, mutators, originFileName);
-	const ignorerBookkeeper = new IgnorerBookkeeper(options.ignorers);
-	traverse$1(file.ast, {
-		enter(path) {
-			directiveBookkeeper.processStrykerDirectives(path.node);
-			if (shouldSkip(path)) path.skip();
-			else {
-				ignorerBookkeeper.enterNode(path);
-				addToPlacementMapIfPossible(path);
-				if (shouldMutate(path)) {
-					const mutantsToPlace = collectMutants(path);
-					if (mutantsToPlace.length) {
-						const placementPath = path.find((ancestor) => placementMap.has(ancestor.node));
-						if (placementPath) {
-							const placement = placementMap.get(placementPath.node);
-							if (placement === void 0) throw new Error("Placement not found for node");
-							const { appliedMutants } = placement;
-							mutantsToPlace.forEach((mutant) => appliedMutants.set(mutant, mutant.applied(placementPath.node)));
-						} else throw new Error(`Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${JSON.stringify(mutantsToPlace, null, 2)}`);
-					}
+		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
+				});
 			}
-		},
-		exit(path) {
-			placeMutantsIfNeeded(path);
-			ignorerBookkeeper.leaveNode(path);
-		}
-	});
-	placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
-	/**
-	* If this node can be used to place mutants on, add to the placement map
-	*/
-	function addToPlacementMapIfPossible(path) {
-		const placer = mutantPlacers.find((p) => p.canPlace(path));
-		if (placer) placementMap.set(path.node, {
-			appliedMutants: /* @__PURE__ */ new Map(),
-			placer
 		});
+		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 [];
 	}
-	/**
-	* Don't traverse import declarations, decorators and nodes that don't have overlap with the selected mutation ranges
-	*/
-	function shouldSkip(path) {
-		return isTypeNode(path) || isImportDeclaration(path) || path.isDecorator() || !mutateDescription || Array.isArray(mutateDescription) && mutateDescription.every((range) => !locationOverlaps(range, getNodeLocation(path.node)));
-	}
-	function shouldMutate(path) {
-		return mutateDescription === true || Array.isArray(mutateDescription) && mutateDescription.some((range) => locationIncluded(range, getNodeLocation(path.node)));
-	}
-	/**
-	* Place mutants that are assigned to the current node path (on exit)
-	*/
-	function placeMutantsIfNeeded(path) {
-		const mutantsPlacement = placementMap.get(path.node);
-		if (mutantsPlacement?.appliedMutants.size) try {
-			mutantsPlacement.placer.place(path, mutantsPlacement.appliedMutants);
-			path.skip();
-		} catch (error) {
-			throwPlacementError(toError(error), path, mutantsPlacement.placer, [...mutantsPlacement.appliedMutants.keys()], originFileName);
-		}
-	}
-	/**
-	* Collect the mutants for the current node and return the non-ignored.
-	*/
-	function collectMutants(path) {
-		return [...mutate(path)].map((mutable) => mutantCollector.collect(originFileName, path.node, mutable, offset)).filter((mutant) => !mutant.ignoreReason);
-	}
-	/**
-	* Generate mutants for the current node.
-	* @yields {Mutable} A mutable describing the mutant to be placed
-	*/
-	function* mutate(node) {
-		for (const mutator of mutators) for (const replacement of mutator.mutate(node)) {
-			const ignoreReason = directiveBookkeeper.findIgnoreReason(getNodeLocation(node.node).start.line, mutator.name) ?? findExcludedMutatorIgnoreReason(mutator.name) ?? ignorerBookkeeper.currentIgnoreMessage;
-			yield {
-				replacement,
-				mutatorName: mutator.name,
-				...ignoreReason === void 0 ? {} : { ignoreReason }
-			};
-		}
-		function findExcludedMutatorIgnoreReason(mutatorName) {
-			if (options.excludedMutations.includes(mutatorName)) return `Ignored because of excluded mutation "${mutatorName}"`;
-			else return;
+}
+//#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 getNodeLocation(node) {
-	const loc = node.loc;
-	if (loc === void 0 || loc === null || loc.start === null || loc.start === void 0 || loc.end === null || loc.end === void 0) throw new Error("Babel node without location");
-	return loc;
+function 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 toError(value) {
-	if (value instanceof Error) return value;
-	return new Error("Unexpected error", { cause: value });
+function getFlags(node) {
+	const secondArg = node.arguments[1];
+	if (secondArg !== void 0 && types$8.isStringLiteral(secondArg)) return secondArg.value;
 }
 //#endregion
-//#region src/transformers/html-transformer.ts
-const transformHtml = ({ root }, mutantCollector, context) => {
-	root.scripts.forEach((ast) => {
-		context.transform(ast, mutantCollector, context);
-	});
+//#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/transformers/svelte-transformer.ts
-const moduleScript = `<script context="module">
-\n<\/script>\n`;
-const transformSvelte = (svelte, mutantCollector, context) => {
-	const { root, originFileName } = svelte;
-	[root.moduleScript, ...root.additionalScripts].filter(notEmpty).forEach((script) => {
-		context.transform(script.ast, mutantCollector, {
-			...context,
-			options: {
-				...context.options,
-				noHeader: true
-			}
-		});
-	});
-	if (mutantCollector.hasPlacedMutants(originFileName)) {
-		if (!root.moduleScript) {
-			root.moduleScript = {
-				ast: {
-					format: "js",
-					root: types.file(types.program([])),
-					rawContent: "",
-					originFileName
-				},
-				range: {
-					start: 26,
-					end: 26
-				},
-				isExpression: false
-			};
-			svelte.rawContent = `${moduleScript}${svelte.rawContent}`;
-			svelte.root.additionalScripts.forEach((script) => {
-				script.range.start += moduleScript.length;
-				script.range.end += moduleScript.length;
-			});
-		}
-		placeHeader(root.moduleScript.ast.root);
+//#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/transformers/transformer.ts
+//#region src/mutators/registry.ts
 /**
-* Transform the AST by generating mutants and placing them in the AST.
-* Supports all AST formats supported by Stryker.
-* @param ast The Abstract Syntax Tree
-* @param mutantCollector the mutant collector that will be used to register and administer mutants
-* @param transformerContext the options used during transforming
+* 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.
 */
-function transform(ast, mutantCollector, transformerContext) {
-	const context = {
-		...transformerContext,
-		transform
-	};
-	switch (ast.format) {
-		case "html":
-			transformHtml(ast, mutantCollector, context);
-			break;
-		case "js":
-		case "ts":
-		case "tsx":
-			transformBabel(ast, mutantCollector, context);
-			break;
-		case "svelte": transformSvelte(ast, mutantCollector, context);
-	}
-}
+const allMutators = Object.freeze({
+	ArithmeticOperator: arithmeticOperatorMutator,
+	ArrayDeclaration: arrayDeclarationMutator,
+	ArrowFunction: arrowFunctionMutator,
+	AssignmentOperator: assignmentOperatorMutator,
+	BlockStatement: blockStatementMutator,
+	BooleanLiteral: booleanLiteralMutator,
+	ConditionalExpression: conditionalExpressionMutator,
+	EqualityOperator: equalityOperatorMutator,
+	LogicalOperator: logicalOperatorMutator,
+	MethodExpression: methodExpressionMutator,
+	ObjectLiteral: objectLiteralMutator,
+	OptionalChaining: optionalChainingMutator,
+	Regex: regexMutator,
+	StringLiteral: stringLiteralMutator,
+	UnaryOperator: unaryOperatorMutator,
+	UpdateOperator: updateOperatorMutator
+});
 //#endregion
-//#region src/util/syntax-helpers.ts
+//#region src/babel/instrumentation-header.ts
 const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
-const COVER_MUTANT_HELPER = "stryCov_9fa48";
-const IS_MUTANT_ACTIVE_HELPER = "stryMutAct_9fa48";
-const { types: types$2, traverse } = babel;
+const COVER_MUTANT_HELPER$1 = "stryCov_9fa48";
+const IS_MUTANT_ACTIVE_HELPER$1 = "stryMutAct_9fa48";
+const { types: types$4 } = babel;
 /**
 * Returns syntax for the header if JS/TS files
 */
 const parsedInstrumentationHeader = babel.parse(`function ${STRYKER_NAMESPACE_HELPER}(){
   var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
-  var ns = g.${ID.NAMESPACE} || (g.${ID.NAMESPACE} = {});
-  if (ns.${ID.ACTIVE_MUTANT} === undefined && g.process && g.process.env && g.process.env.${ID.ACTIVE_MUTANT_ENV_VARIABLE}) {
-    ns.${ID.ACTIVE_MUTANT} = g.process.env.${ID.ACTIVE_MUTANT_ENV_VARIABLE};
+  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;
@@ -1377,72 +1486,84 @@ const parsedInstrumentationHeader = babel.parse(`function ${STRYKER_NAMESPACE_HE
 }
 ${STRYKER_NAMESPACE_HELPER}();
 
-function ${COVER_MUTANT_HELPER}() {
+function ${COVER_MUTANT_HELPER$1}() {
   var ns = ${STRYKER_NAMESPACE_HELPER}();
-  var cov = ns.${ID.MUTATION_COVERAGE_OBJECT} || (ns.${ID.MUTATION_COVERAGE_OBJECT} = { static: {}, perTest: {} });
+  var cov = ns.${INSTRUMENTER_CONSTANTS.MUTATION_COVERAGE_OBJECT} || (ns.${INSTRUMENTER_CONSTANTS.MUTATION_COVERAGE_OBJECT} = { static: {}, perTest: {} });
   function cover() {
     var c = cov.static;
-    if (ns.${ID.CURRENT_TEST_ID}) {
-      c = cov.perTest[ns.${ID.CURRENT_TEST_ID}] = cov.perTest[ns.${ID.CURRENT_TEST_ID}] || {};
+    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_MUTANT_HELPER$1} = cover;
   cover.apply(null, arguments);
 }
-function ${IS_MUTANT_ACTIVE_HELPER}(id) {
+function ${IS_MUTANT_ACTIVE_HELPER$1}(id) {
   var ns = ${STRYKER_NAMESPACE_HELPER}();
   function isActive(id) {
-    if (ns.${ID.ACTIVE_MUTANT} === id) {
-      if (ns.${ID.HIT_COUNT} !== void 0 && ++ns.${ID.HIT_COUNT} > ns.${ID.HIT_LIMIT}) {
-        throw new Error('Stryker: Hit count limit reached (' + ns.${ID.HIT_COUNT} + ')');
+    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;
+  ${IS_MUTANT_ACTIVE_HELPER$1} = isActive;
   return isActive(id);
 }`, {
 	configFile: false,
 	browserslistConfigFile: false,
 	env: { targets: {} }
 });
-if (!types$2.isFile(parsedInstrumentationHeader)) throw new Error("Instrumentation header parsed as non-File");
+if (!types$4.isFile(parsedInstrumentationHeader)) throw new Error("Instrumentation header parsed as non-File");
 const instrumentationBabelHeader = parsedInstrumentationHeader.program.body;
 deepFreeze(instrumentationBabelHeader);
-/**
-* returns syntax for `global.activeMutant === $mutantId`
-* @param mutantId The id of the mutant to switch
-*/
-function mutantTestExpression(mutantId) {
-	return types$2.callExpression(types$2.identifier(IS_MUTANT_ACTIVE_HELPER), [types$2.stringLiteral(mutantId)]);
+function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
+	if (hasPlacedMutants(mutantCollector, originFileName) && !options.noHeader) placeHeader(root);
 }
-function eqLocation(a, b) {
-	function eqPosition(start, end) {
-		return start.column === end.column && start.line === end.line;
+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)];
 	}
-	return eqPosition(a.start, b.start) && eqPosition(a.end, b.end);
-}
-function eqNode(a, b) {
-	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
+	root.program.body.unshift(...header);
 }
-/**
-* Returns a sequence of mutation coverage counters with an optional last expression.
-*
-* @example (global.__coverMutant__(0, 1), 40 + 2)
-* @param mutants The mutants for which covering syntax needs to be generated
-* @param targetExpression The original expression
-*/
-function mutationCoverageSequenceExpression(mutants, targetExpression) {
-	const mutantIds = [...mutants].map((mutant) => types$2.stringLiteral(mutant.id));
-	const sequence = [types$2.callExpression(types$2.identifier(COVER_MUTANT_HELPER), mutantIds)];
-	if (targetExpression) sequence.push(targetExpression);
-	return types$2.sequenceExpression(sequence);
+function 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 value;
 }
+//#endregion
+//#region src/babel/type-guards.ts
+const { types: types$3 } = babel;
 function isTypeNode(path) {
 	return path.isTypeAnnotation() || flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path) || isDeclareModule(path);
 }
@@ -1489,326 +1610,604 @@ const flowTypeAnnotationNodeTypes = Object.freeze([
 	"InterfaceDeclaration"
 ]);
 function isImportDeclaration(path) {
-	return types$2.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
+	return types$3.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";
 /**
-* 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
+* returns syntax for `global.activeMutant === $mutantId`
+* @param mutantId The id of the mutant to switch
 */
-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;
+function mutantTestExpression(mutantId) {
+	return types$2.callExpression(types$2.identifier(IS_MUTANT_ACTIVE_HELPER), [types$2.stringLiteral(mutantId)]);
 }
 /**
-* Determines if two locations overlap with each other
+* Returns a sequence of mutation coverage counters with an optional last expression.
+*
+* @example (global.__coverMutant__(0, 1), 40 + 2)
+* @param mutants The mutants for which covering syntax needs to be generated
+* @param targetExpression The original expression
 */
-function locationOverlaps(a, b) {
-	const startIncluded = a.start.line < b.end.line || a.start.line === b.end.line && a.start.column <= b.end.column;
-	const endIncluded = a.end.line > b.start.line || a.end.line === b.start.line && a.end.column >= b.start.column;
-	return startIncluded && endIncluded;
+function mutationCoverageSequenceExpression(mutants, targetExpression) {
+	const mutantIds = [...mutants].map((mutant) => types$2.stringLiteral(mutant.id));
+	const sequence = [types$2.callExpression(types$2.identifier(COVER_MUTANT_HELPER), mutantIds)];
+	if (targetExpression) sequence.push(targetExpression);
+	return types$2.sequenceExpression(sequence);
 }
+//#endregion
+//#region src/mutant-placers/mutant-placer.ts
 /**
-* Helper for `types.cloneNode(node, deep: true, withoutLocations: false);`
+* Narrows an applied mutant to the node kind a placer emits. `applied()` hands
+* back a plain node — whether it fits this position is the placer's claim, and
+* `canPlace` is what established it, so a mismatch here means the placer was
+* handed a mutant it never accepted.
 */
-function deepCloneNode(node) {
-	return types$2.cloneNode(node, true, false);
-}
-function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
-	if (mutantCollector.hasPlacedMutants(originFileName) && !options.noHeader) placeHeader(root);
+function nodeOfKind(mutant, node, isKind, kind) {
+	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
+	return node;
 }
-function placeHeader(root) {
-	let header = instrumentationBabelHeader;
-	const leadingComments = root.program.body[0]?.leadingComments;
-	if (Array.isArray(leadingComments)) {
-		const firstHeader = instrumentationBabelHeader[0];
-		if (firstHeader === void 0) throw new Error("Instrumentation header is empty");
-		const cloned = types$2.cloneNode(firstHeader, true, false);
-		cloned.leadingComments = leadingComments;
-		header = [cloned, ...instrumentationBabelHeader.slice(1)];
+//#endregion
+//#region src/mutant-placers/expression-mutant-placer.ts
+const { types: types$1 } = babel;
+/**
+* Will set the identifier of anonymous function expressions if is located in a variable declaration.
+* Will treat input as readonly. Returns undefined if not needed.
+* @example
+* const a = function() { }
+* becomes
+* const a = function a() {}
+*/
+function classOrFunctionExpressionNamedIfNeeded(path) {
+	if ((path.isFunctionExpression() || path.isClassExpression()) && !path.node.id) {
+		if (path.parentPath.isVariableDeclarator() && types$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;
+		}
 	}
-	root.program.body.unshift(...header);
 }
-//#endregion
-//#region src/parsers/svelte-parser.ts
-const MIN_SVELTE_VERSION = ">=3.30";
-function isPlainRecord(value) {
-	return typeof value === "object" && value !== null;
+/**
+* Will set the identifier of anonymous arrow function expressions if is located in a variable declaration.
+* Will treat input as readonly. Returns undefined if not needed.
+* @example
+* const a = () => { }
+* becomes
+* const a = (() => { const a = () => {}; return a; })()
+*/
+function arrowFunctionExpressionNamedIfNeeded(path) {
+	if (path.isArrowFunctionExpression() && path.parentPath.isVariableDeclarator() && 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)])), []);
 }
-function isUnknownArray(value) {
-	return Array.isArray(value);
+function nameIfAnonymous(path) {
+	return classOrFunctionExpressionNamedIfNeeded(path) ?? arrowFunctionExpressionNamedIfNeeded(path) ?? path.node;
 }
-function isRangedProgram(value) {
-	return isPlainRecord(value) && typeof value["start"] === "number" && typeof value["end"] === "number";
+function isMemberOrCallOrNonNullExpression(path) {
+	return isCallExpression(path) || isMemberOrNonNullExpression(path);
 }
-function isWalkFunction(value) {
-	return typeof value === "function";
+function isMemberOrNonNullExpression(path) {
+	return isMemberExpression(path) || path.isTSNonNullExpression();
 }
-function isRangedBaseNode(value) {
-	return isPlainRecord(value) && typeof value["type"] === "string" && typeof value["start"] === "number" && typeof value["end"] === "number";
+function isMemberExpression(path) {
+	return path.isMemberExpression() || path.isOptionalMemberExpression();
 }
-function isTemplateExpressionType(type) {
-	return type === "MustacheTag" || type === "RawMustacheTag" || type === "IfBlock" || type === "ConstTag" || type === "EachBlock" || type === "AwaitBlock" || type === "KeyBlock" || type === "EventHandler";
+function isCallExpression(path) {
+	return path.isCallExpression() || path.isOptionalCallExpression();
 }
-function tryGetScriptRangeFromElement(node) {
-	if (!isPlainRecord(node) || node["type"] !== "Element" || node["name"] !== "script") return;
-	const children = node["children"];
-	if (!isUnknownArray(children) || children.length === 0) return;
-	const firstChild = children[0];
-	if (!isPlainRecord(firstChild) || firstChild["type"] !== "Text" || typeof firstChild["start"] !== "number" || typeof firstChild["end"] !== "number") return;
-	return {
-		start: firstChild["start"],
-		end: firstChild["end"],
-		isExpression: false
-	};
+function isValidExpression(path) {
+	const parent = path.parentPath;
+	return !isObjectPropertyKey() && !isPartOfChain() && !parent.isTaggedTemplateExpression() && !isPartOfDeleteExpression() && !isPartOfAssignmentExpression();
+	/**
+	* Determines if the expression is property of an object.
+	* @example
+	* const a = {
+	*  'foo': 'bar' // 'foo' here is an object property
+	* };
+	*/
+	function isObjectPropertyKey() {
+		return parent.isObjectProperty() && parent.node.key === path.node;
+	}
+	/**
+	* Determines if the expression is part of a call/member chain.
+	* @example
+	* // bar is part of chain, foo is NOT part of the chain:
+	* foo.bar.baz();
+	* foo.bar?.baz()
+	* foo.bar;
+	* foo.bar!;
+	* foo.bar();
+	* foo?.bar();
+	* baz[foo.bar()]
+	* bar?.baz[0]
+	*/
+	function isPartOfChain() {
+		return isMemberOrCallOrNonNullExpression(path) && (isMemberExpression(parent) && !(parent.node.computed && parent.node.property === path.node) || parent.isTSNonNullExpression() || isCallExpression(parent) && parent.node.callee === path.node);
+	}
+	/**
+	* Determines if the expression is part of a delete expression.
+	* @returns true if the expression is part of a delete expression
+	* @example
+	* delete foo.bar;
+	*/
+	function isPartOfDeleteExpression() {
+		return parent.isUnaryExpression() && parent.node.operator === "delete";
+	}
+	/**
+	* Determines if the expression is part of an assignment expression.
+	* @returns true if the expression is part of an assignment expression
+	* @example
+	* foo.bar = 42;
+	* initialNodes.filter((n) => n.id === 'tiptilt')[0].className = tiptiltState;
+	*/
+	function isPartOfAssignmentExpression() {
+		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();
+	},
+	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();
+	},
+	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]));
+	}
+};
+//#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;
+}
+/**
+* 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;
 }
-async function parse$1(text, fileName, context) {
-	const { parse: svelteParse, preprocess, VERSION } = await import("./compiler-Ck-td5Ds.mjs");
-	let walk;
-	if (!satisfies(VERSION, MIN_SVELTE_VERSION)) throw new Error(`Svelte version ${VERSION} not supported. Expected: ${MIN_SVELTE_VERSION} (processing file ${fileName})`);
-	if (satisfies(VERSION, ">=5")) {
-		const walkerModule = await import(import.meta.resolve("estree-walker", import.meta.resolve("svelte")));
-		if (!isPlainRecord(walkerModule) || !isWalkFunction(walkerModule["walk"])) throw new Error("estree-walker module without walk export");
-		walk = walkerModule["walk"];
-	} else {
-		const svelteCompilerModule = await import("./compiler-Ck-td5Ds.mjs");
-		if (!isPlainRecord(svelteCompilerModule) || !isWalkFunction(svelteCompilerModule["walk"])) throw new Error("svelte/compiler module without walk export");
-		walk = svelteCompilerModule["walk"];
-	}
-	const positionConverter = new PositionConverter(text);
-	const { replacedCode, scriptMap } = await replaceScripts(text);
-	const svelteAst = svelteParse(replacedCode, { filename: fileName });
-	const { remappedModuleScriptRange, remappedScriptRanges } = remapScriptLocations(replacedCode, scriptMap, getModuleScriptRange(svelteAst), getTemplateScriptRanges(svelteAst, walk));
-	const [moduleScript, ...additionalScripts] = await Promise.all([parseTemplateScriptIfDefined(remappedModuleScriptRange), ...remappedScriptRanges.map(parseTemplateScript)]);
-	return {
-		originFileName: fileName,
-		rawContent: text,
-		format: "svelte",
-		root: {
-			...moduleScript === void 0 ? {} : { moduleScript },
-			additionalScripts
+//#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;
 		}
-	};
-	/**
-	* Replaces script tags with placeholders.
-	* This is needed, because svelte's `parse` doesn't support `lang="ts"`.
-	*/
-	async function replaceScripts(code) {
-		const map = /* @__PURE__ */ new Map();
-		let scriptIndex = 0;
-		return {
-			replacedCode: (await preprocess(code, { script(script) {
-				const scriptName = `script${scriptIndex++}`;
-				map.set(scriptName, script);
-				return { code: scriptName };
-			} })).code,
-			scriptMap: map
-		};
 	}
-	function getTemplateScriptRanges(ast, walker) {
-		const ranges = [];
-		if (isPlainRecord(ast) && ast["instance"] !== null && ast["instance"] !== void 0) {
-			const instance = ast["instance"];
-			if (isPlainRecord(instance) && "content" in instance) {
-				const content = instance["content"];
-				if (isRangedProgram(content)) ranges.push({
-					start: content.start,
-					end: content.end,
-					isExpression: false
-				});
-				else throw new Error("Svelte instance script without a source range");
+}
+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}.`);
 			}
 		}
-		if (!isPlainRecord(ast) || !("html" in ast)) throw new Error("Svelte AST without html");
-		const html = ast["html"];
-		walker(html, { enter(node) {
-			const scriptRange = tryGetScriptRangeFromElement(node);
-			if (scriptRange) ranges.push(scriptRange);
-			const templateExpression = collectTemplateExpression(node);
-			if (templateExpression) {
-				const { start, end } = templateExpression;
-				ranges.push({
-					start,
-					end,
-					isExpression: true
-				});
-			}
-		} });
-		return ranges;
+		mutatorNames = mutatorNames.map((mutator) => mutator.toLowerCase());
+		const reason = (optionalReason ?? DEFAULT_REASON).trim();
+		current = applyDirective(current, directiveType, scope, mutatorNames, reason, node.loc);
 	}
-	async function parseTemplateScriptIfDefined(range) {
-		if (range) return parseTemplateScript(range);
+	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
+		};
 	}
-	async function parseTemplateScript({ start, end, isExpression, format }) {
-		const scriptText = text.slice(start, end);
-		return {
-			ast: {
-				...await context.parse(scriptText, fileName, format),
-				offset: positionConverter.positionFromOffset(start)
-			},
-			range: {
-				start,
-				end
-			},
-			isExpression
+}
+function 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 getModuleScriptRange(svelteAst) {
-	if (!isPlainRecord(svelteAst) || !("module" in svelteAst) || svelteAst["module"] === null || svelteAst["module"] === void 0) return;
-	const mod = svelteAst["module"];
-	if (!isPlainRecord(mod) || !("content" in mod)) throw new Error("Svelte module script without a source range");
-	const content = mod["content"];
-	if (!isRangedProgram(content)) throw new Error("Svelte module script without a source range");
+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;
+}
+//#endregion
+//#region src/transformers/ignorer-bookkeeper.ts
+function createIgnorerBookkeeper(ignorers) {
 	return {
-		start: content.start,
-		end: content.end,
-		isExpression: false
+		ignorers,
+		activeIgnored: void 0
 	};
 }
-/**
-* Remaps script locations back to the original places using the script map
-*/
-function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges) {
-	const scriptRanges = [moduleScriptRange, ...templateRanges].filter(notEmpty).sort((a, b) => a.start - b.start);
-	let offset = 0;
-	let newModuleScriptRange;
-	const newScriptRanges = scriptRanges.map((range) => {
-		const script = code.substring(range.start, range.end);
-		const actualScript = scriptMap.get(script);
-		const start = range.start + offset;
-		if (actualScript) {
-			const scriptRange = {
-				start,
-				end: start + actualScript.content.length,
-				isExpression: range.isExpression,
-				format: actualScript.attributes["lang"] === "ts" ? "ts" : "js"
-			};
-			offset += actualScript.content.length - script.length;
-			if (range === moduleScriptRange) newModuleScriptRange = scriptRange;
-			return scriptRange;
-		} else return {
-			start,
-			end: start + script.length,
-			isExpression: range.isExpression,
-			format: "js"
+function 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
+			}
 		};
-	});
-	return {
-		remappedModuleScriptRange: newModuleScriptRange,
-		remappedScriptRanges: newScriptRanges.filter((range) => range !== newModuleScriptRange)
-	};
+	}
+	return bookkeeper;
 }
-function collectTemplateExpression(node) {
-	if (!isPlainRecord(node) || typeof node["type"] !== "string") return;
-	if (!isTemplateExpressionType(node["type"])) return;
-	if (!("expression" in node)) return;
-	const expression = node["expression"];
-	if (isRangedBaseNode(expression)) return expression;
+function leaveNode(bookkeeper, path) {
+	if (bookkeeper.activeIgnored?.node === path.node) return {
+		...bookkeeper,
+		activeIgnored: void 0
+	};
+	return bookkeeper;
 }
-//#endregion
-//#region src/parsers/ts-parser.ts
-const { types: types$1, parseAsync } = babel;
-const require = createRequire(import.meta.url);
-/**
-* 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) {
+function toIgnorerPath(path) {
 	return {
-		originFileName: fileName,
-		rawContent: text,
-		format: "ts",
-		root: await parse(text, fileName, false)
+		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();
+		}
 	};
 }
-async function parseTsx(text, fileName) {
+//#endregion
+//#region src/transformers/babel-transformer.ts
+const { traverse } = 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, {
+		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);
+					if (mutantsToPlace.length > 0) {
+						const placementPath = path.find((ancestor) => placementMap.has(ancestor.node));
+						if (placementPath) {
+							const placement = placementMap.get(placementPath.node);
+							if (placement === void 0) throw new Error("Placement not found for node");
+							const { appliedMutants } = placement;
+							mutantsToPlace.forEach((mutant) => appliedMutants.set(mutant, applyMutant(mutant, placementPath.node)));
+						} else throw new Error(`Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${JSON.stringify(mutantsToPlace, null, 2)}`);
+					}
+				}
+			}
+		},
+		exit(path) {
+			placeMutantsIfNeeded(path);
+			ignorerState = leaveNode(ignorerState, path);
+		}
+	});
+	placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
+	return warnings;
+	function addToPlacementMapIfPossible(path) {
+		const placer = mutantPlacers.find((p) => p.canPlace(path));
+		if (placer !== void 0) placementMap.set(path.node, {
+			appliedMutants: /* @__PURE__ */ new Map(),
+			placer
+		});
+	}
+	function shouldSkip(path) {
+		return isTypeNode(path) || isImportDeclaration(path) || path.isDecorator() || !mutateDescription || Array.isArray(mutateDescription) && mutateDescription.every((range) => !locationOverlaps(range, getNodeLocation(path.node)));
+	}
+	function shouldMutate(path) {
+		return mutateDescription === true || Array.isArray(mutateDescription) && mutateDescription.some((range) => locationIncluded(range, getNodeLocation(path.node)));
+	}
+	function placeMutantsIfNeeded(path) {
+		const mutantsPlacement = placementMap.get(path.node);
+		if (mutantsPlacement !== void 0 && mutantsPlacement.appliedMutants.size > 0) try {
+			mutantsPlacement.placer.place(path, mutantsPlacement.appliedMutants);
+			path.skip();
+		} catch (error) {
+			throwPlacementError(toError(error), path, mutantsPlacement.placer, [...mutantsPlacement.appliedMutants.keys()], originFileName);
+		}
+	}
+	function collectMutants(path) {
+		return [...mutate(path)].map((mutable) => collect(mutantCollector, originFileName, path.node, mutable, offset)).filter((mutant) => !mutant.ignoreReason);
+	}
+	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 {
+				replacement,
+				mutatorName,
+				...ignoreReason === void 0 ? {} : { ignoreReason }
+			};
+		}
+		function findExcludedMutatorIgnoreReason(mutatorName) {
+			if (options.excludedMutations.includes(mutatorName)) return `Ignored because of excluded mutation "${mutatorName}"`;
+			else return;
+		}
+	}
+};
+function toMutatorContext(path) {
+	const ancestors = [];
+	let current = path.parentPath;
+	while (current !== null && current !== void 0) {
+		ancestors.push(current.node);
+		current = current.parentPath;
+	}
 	return {
-		root: await parse(text, fileName, true),
-		format: "tsx",
-		originFileName: fileName,
-		rawContent: text
+		parent: ancestors[0],
+		grandParent: ancestors[1],
+		ancestors
 	};
 }
-async function parse(text, fileName, isTSX) {
-	const ast = await parseAsync(text, {
-		filename: fileName,
-		parserOpts: { ranges: true },
-		configFile: false,
-		babelrc: false,
-		presets: [[require.resolve("@babel/preset-typescript"), {
-			isTSX,
-			allExtensions: true
-		}]],
-		plugins: [[require.resolve("@babel/plugin-proposal-decorators"), { legacy: true }], [require.resolve("@babel/plugin-transform-explicit-resource-management")]]
-	});
-	if (ast === null) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
-	if (types$1.isProgram(ast)) throw new Error(`Expected ${fileName} to contain a babel.types.file, but was a program`);
-	return ast;
+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;
+}
+function toError(value) {
+	if (value instanceof Error) return value;
+	return new Error("Unexpected error", { cause: value });
 }
 //#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)}`);
+//#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
+			}
+		}));
+	});
+	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 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;
+	return warnings;
+};
+//#endregion
+//#region src/transformers/transformer.ts
+function transform(ast, mutantCollector, transformerContext) {
+	const context = {
+		...transformerContext,
+		transform
+	};
+	switch (ast.format) {
+		case "html": return transformHtml(ast, mutantCollector, context);
+		case "js":
+		case "ts":
+		case "tsx": return transformBabel(ast, mutantCollector, context);
+		case "svelte": return transformSvelte(ast, mutantCollector, context);
 	}
 }
 //#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;
+	}
+};
+//#endregion
 //#region src/printers/html-printer.ts
-function getScriptStart$1(script) {
+function getScriptStart(script) {
 	const start = script.root.start;
 	if (start === void 0 || start === null) throw new Error("Script AST root without start");
 	return start;
 }
-function getScriptEnd$1(script) {
+function getScriptEnd(script) {
 	const end = script.root.end;
 	if (end === void 0 || end === null) throw new Error("Script AST root without end");
 	return end;
 }
 const print$4 = (ast, context) => {
-	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart$1(a) - getScriptStart$1(b));
+	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$1(script));
+		html += ast.rawContent.substring(currentIndex, getScriptStart(script));
 		html += "\n";
 		html += context.print(script, context);
 		html += "\n";
-		currentIndex = getScriptEnd$1(script);
+		currentIndex = getScriptEnd(script);
 	}
 	html += ast.rawContent.substr(currentIndex);
 	return html;
@@ -1823,7 +2222,7 @@ const print$3 = (file) => {
 const print$2 = ({ root, rawContent }, context) => {
 	let currentIndex = 0;
 	let outputText = "";
-	const sortedScripts = [root.moduleScript, ...root.additionalScripts].filter(notEmpty).sort((a, b) => a.range.start - b.range.start);
+	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;
@@ -1859,244 +2258,58 @@ function print(file) {
 	}
 }
 //#endregion
-//#region src/create-instrumenter.ts
-createInstrumenter.inject = tokens(commonTokens.injector);
-function createInstrumenter(injector) {
-	return injector.provideValue(instrumenterTokens.print, print).provideValue(instrumenterTokens.createParser, createParser).provideValue(instrumenterTokens.transform, transform).injectClass(Instrumenter);
-}
-//#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)}`;
-	}
-}
-function getScriptStart(script) {
-	const start = script.root.start;
-	if (start === void 0 || start === null) throw new Error("Script AST root without start");
-	return start;
-}
-function getScriptEnd(script) {
-	const end = script.root.end;
-	if (end === void 0 || end === null) throw new Error("Script AST root without end");
-	return end;
-}
-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 += prefixWithNoCheck(removeTSDirectives(script.rawContent, script.root.comments));
-		html += "\n";
-		currentIndex = getScriptEnd(script);
-	}
-	html += ast.rawContent.substring(currentIndex);
-	return html;
-}
-function disableTypeCheckingInSvelte(ast) {
-	const sortedScripts = [ast.root.moduleScript, ...ast.root.additionalScripts].filter(notEmpty).sort((a, b) => a.range.start - b.range.start);
-	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";
-		currentIndex = script.range.end;
-	}
-	html += ast.rawContent.substring(currentIndex);
-	return html;
-}
-function removeTSDirectives(text, comments) {
-	const directiveRanges = comments?.map(tryParseTSDirective).filter(notEmpty).sort((a, b) => a.startPos - b.startPos);
-	if (directiveRanges) {
-		let currentIndex = 0;
-		let pruned = "";
-		for (const directiveRange of directiveRanges) {
-			pruned += text.substring(currentIndex, directiveRange.startPos);
-			currentIndex = directiveRange.endPos;
-		}
-		pruned += text.substring(currentIndex);
-		return pruned;
-	} else return text;
-}
-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.";
-var AngularIgnorer = class {
-	shouldIgnore(path) {
-		if (this.isInputModelOrOutputConfigurationObject(path)) return INPUT_MODEL_OUTPUT_CONFIG_MSG;
-		if (this.isSignalQueryOptionsObject(path)) return SIGNAL_QUERY_OPTIONS_MSG;
-	}
-	#isClassFieldLike(path) {
-		return path.isClassProperty() || path.isClassPrivateProperty() || path.isClassAccessorProperty();
-	}
-	/**
-	* Determines if the given path is a configuration object for an Angular input, model or output function.
-	* This solves the "Argument needs to be statically analyzable." error
-	*/
-	isInputModelOrOutputConfigurationObject(path) {
-		if (!path.isObjectExpression() || !path.parentPath.isCallExpression() || !path.parentPath.parentPath.isClassProperty()) return false;
-		const callExpression = path.parentPath;
-		const objectExpression = path;
-		const isRequiredSignalIOFunction = callExpression.node.callee.type === "MemberExpression" && callExpression.node.callee.object.type === "Identifier" && ANGULAR_SIGNAL_IO_FUNCTIONS.includes(callExpression.node.callee.object.name) && callExpression.node.callee.property.type === "Identifier" && callExpression.node.callee.property.name === "required";
-		const isSignalIOFunction = callExpression.node.callee.type === "Identifier" && ANGULAR_SIGNAL_IO_FUNCTIONS.includes(callExpression.node.callee.name);
-		const isOutput = callExpression.node.callee.type === "Identifier" && callExpression.node.callee.name === "output";
-		if (isRequiredSignalIOFunction || isOutput) return callExpression.node.arguments.length >= 1 && callExpression.node.arguments[0] === objectExpression.node;
-		if (isSignalIOFunction) return callExpression.node.arguments.length >= 2 && callExpression.node.arguments[1] === objectExpression.node;
-		return false;
-	}
-	/**
-	* Determines if the given path is a configuration object for an Angular signal query function.
-	* This solves the "Argument needs to be statically analyzable." error
-	*/
-	isSignalQueryOptionsObject(path) {
-		if (!path.isObjectExpression() || !path.parentPath.isCallExpression() || !this.#isClassFieldLike(path.parentPath.parentPath)) return false;
-		const callExpression = path.parentPath;
-		const objectExpression = path;
-		const callee = callExpression.node.callee;
-		const isQueryFn = callee.type === "Identifier" && ANGULAR_SIGNAL_QUERY_FUNCTIONS.includes(callee.name);
-		const isRequiredQueryFn = callee.type === "MemberExpression" && callee.object.type === "Identifier" && ANGULAR_SIGNAL_QUERY_FUNCTIONS.includes(callee.object.name) && callee.property.type === "Identifier" && callee.property.name === "required";
-		if (!isQueryFn && !isRequiredQueryFn) return false;
-		return callExpression.node.arguments.length >= 2 && callExpression.node.arguments[1] === objectExpression.node;
-	}
-};
-//#endregion
-//#region src/frameworks/index.ts
-const strykerPlugins = [declareClassPlugin(PluginKind.Ignore, "angular", AngularIgnorer)];
-const frameworkPluginsFileUrl = import.meta.url;
-//#endregion
 //#region src/instrumenter.ts
-/**
-* The instrumenter is responsible for
-* * Generating mutants based on source files
-* * Instrumenting the source code with the mutants placed in `mutant switches`.
-* * Adding mutant coverage expressions in the source code.
-* @see https://github.com/stryker-mutator/stryker-js/issues/1514
-*/
-var Instrumenter = class {
-	logger;
-	_createParser;
-	_print;
-	_transform;
-	static inject = tokens(commonTokens.logger, instrumenterTokens.createParser, instrumenterTokens.print, instrumenterTokens.transform);
-	constructor(logger, _createParser = createParser, _print = print, _transform = transform) {
-		this.logger = logger;
-		this._createParser = _createParser;
-		this._print = _print;
-		this._transform = _transform;
-	}
-	async instrument(files, options) {
-		this.logger.debug("Instrumenting %d source files with mutants", files.length);
-		const mutantCollector = new MutantCollector();
-		const outFiles = [];
-		let mutantCount = 0;
-		const parse = this._createParser(options);
-		for (const { name, mutate, content } of files) {
-			const ast = await parse(content, name);
-			this._transform(ast, mutantCollector, {
+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;
+	const parse = createParser(options);
+	for (const { name, mutate, content } of files) {
+		const ast = yield* Effect.tryPromise({
+			try: () => parse(content, name),
+			catch: (cause) => new InstrumentError({
+				message: `Failed to parse ${name}`,
+				cause
+			})
+		});
+		const warnings = yield* Effect.try({
+			try: () => transform(ast, collector, {
 				options,
-				mutateDescription: toBabelLineNumber(mutate),
-				logger: this.logger
-			});
-			const mutatedContent = this._print(ast);
-			outFiles.push({
-				name,
-				mutate,
-				content: mutatedContent
-			});
-			if (this.logger.isDebugEnabled()) {
-				const nrOfMutantsInFile = mutantCollector.mutants.length - mutantCount;
-				mutantCount = mutantCollector.mutants.length;
-				this.logger.debug(`Instrumented ${path.relative(process.cwd(), name)} (${nrOfMutantsInFile} mutant(s))`);
-			}
-		}
-		const mutants = mutantCollector.mutants.map((mutant) => mutant.toApiMutant());
-		this.logger.info("Instrumented %d source file(s) with %d mutant(s)", files.length, mutants.length);
-		return {
-			files: outFiles,
-			mutants
-		};
-	}
-};
+				mutateDescription: toBabelLineNumber(mutate)
+			}),
+			catch: (cause) => new InstrumentError({
+				message: `Failed to transform ${name}`,
+				cause
+			})
+		});
+		for (const warning of warnings) yield* Effect.logWarning(warning);
+		const mutatedContent = yield* Effect.try({
+			try: () => print(ast),
+			catch: (cause) => new InstrumentError({
+				message: `Failed to print ${name}`,
+				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 }) => ({
@@ -2111,4 +2324,4 @@ function toBabelLineNumber(range) {
 	}));
 }
 //#endregion
-export { Instrumenter, createInstrumenter, disableTypeChecks, frameworkPluginsFileUrl, strykerPlugins };
+export { angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };