@systemfsoftware/stryker-js-instrumenter 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2114 @@
+import { PluginKind, commonTokens, declareClassPlugin, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import path from "path";
+import { INSTRUMENTER_CONSTANTS as ID } from "@systemfsoftware/stryker-js-plugin-api/core";
+import babel, { File, types } from "@babel/core";
+import { deepFreeze, notEmpty, propertyPath } from "@systemfsoftware/stryker-js-util";
+import { satisfies } from "semver";
+import 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}`);
+	}
+};
+//#endregion
+//#region src/parsers/html-parser.ts
+const TSX_SCRIPT_TYPES = Object.freeze(["tsx", "text/tsx"]);
+const TS_SCRIPT_TYPES = Object.freeze([
+	"ts",
+	"text/typescript",
+	"typescript"
+]);
+const JS_SCRIPT_TYPES = Object.freeze([
+	"js",
+	"text/javascript",
+	"javascript",
+	"module"
+]);
+async function parse$2(text, originFileName, context) {
+	return {
+		originFileName,
+		rawContent: text,
+		format: "html",
+		root: await ngHtmlParser(text, originFileName, context)
+	};
+}
+async function ngHtmlParser(text, fileName, parserContext) {
+	const ngParser = await import("angular-html-parser");
+	const { rootNodes, errors } = ngParser.parse(text, {
+		canSelfClose: true,
+		allowHtmComponentClosingTags: true,
+		isTagNameCaseSensitive: true
+	});
+	if (errors.length !== 0) {
+		const firstError = errors[0];
+		if (firstError === void 0) throw new Error("HTML parser reported errors but first error is missing");
+		throw new ParseError(firstError.msg, fileName, toSourceLocation(firstError.span.start));
+	}
+	const scriptsAsPromised = [];
+	ngParser.visitAll(new class extends ngParser.RecursiveVisitor {
+		visitElement(el, context) {
+			const scriptFormat = getScriptType(el);
+			if (scriptFormat) scriptsAsPromised.push(parseScript(el, scriptFormat));
+			super.visitElement(el, context);
+		}
+	}(), rootNodes);
+	return { scripts: await Promise.all(scriptsAsPromised) };
+	async function parseScript(el, scriptFormat) {
+		const endSourceSpan = el.endSourceSpan;
+		if (endSourceSpan === null || endSourceSpan === void 0) throw new Error("HTML element without an end source span");
+		const content = text.substring(el.startSourceSpan.end.offset, endSourceSpan.start.offset);
+		const ast = await parserContext.parse(content, fileName, scriptFormat);
+		if (ast) {
+			const offset = el.startSourceSpan.end;
+			const rootStart = ast.root.start;
+			if (rootStart === null || rootStart === void 0) throw new Error("Babel File node without a start offset");
+			const rootEnd = ast.root.end;
+			if (rootEnd === null || rootEnd === void 0) throw new Error("Babel File node without an end offset");
+			ast.root.start = rootStart + offset.offset;
+			ast.root.end = rootEnd + offset.offset;
+			return {
+				...ast,
+				offset: {
+					column: offset.offset,
+					line: offset.line
+				}
+			};
+		}
+		return ast;
+	}
+}
+function toSourceLocation({ line, col }) {
+	return {
+		line: line + 1,
+		column: col
+	};
+}
+function getScriptType(element) {
+	if (element.name === "script") {
+		if (!element.attrs.some((attr) => attr.name === "src")) {
+			const type = element.attrs.find((attr) => attr.name === "type") ?? element.attrs.find((attr) => attr.name === "lang");
+			if (type) {
+				const typeToLower = type.value.toLowerCase();
+				if (TSX_SCRIPT_TYPES.includes(typeToLower)) return "tsx";
+				if (TS_SCRIPT_TYPES.includes(typeToLower)) return "ts";
+				if (JS_SCRIPT_TYPES.includes(typeToLower)) return "js";
+			} else return "js";
+		}
+	}
+}
+//#endregion
+//#region src/parsers/js-parser.ts
+const { types: types$15, parseAsync: parseAsync$1 } = babel;
+function isParserPlugin(value) {
+	return typeof value === "string" || Array.isArray(value);
+}
+function isParserPluginArray(value) {
+	return value.every(isParserPlugin);
+}
+function getParserPlugins(override) {
+	if (override === null || override === void 0) return defaultPlugins;
+	if (isParserPluginArray(override)) return override;
+	throw new Error("Invalid parser plugins: expected ParserPlugin[]");
+}
+const defaultPlugins = [
+	"doExpressions",
+	"objectRestSpread",
+	"classProperties",
+	"exportDefaultFrom",
+	"exportNamespaceFrom",
+	"asyncGenerators",
+	"functionBind",
+	"functionSent",
+	"dynamicImport",
+	"numericSeparator",
+	"importMeta",
+	"optionalCatchBinding",
+	"optionalChaining",
+	"classPrivateProperties",
+	["pipelineOperator", { proposal: "minimal" }],
+	"nullishCoalescingOperator",
+	"bigInt",
+	"throwExpressions",
+	"logicalAssignment",
+	"classPrivateMethods",
+	"v8intrinsic",
+	"partialApplication",
+	["decorators", { decoratorsBeforeExport: false }],
+	"jsx"
+];
+function createParser$1({ plugins: pluginsOverride }) {
+	return async function parse(text, fileName) {
+		const plugins = getParserPlugins(pluginsOverride);
+		const ast = await parseAsync$1(text, {
+			parserOpts: { plugins: [...plugins] },
+			filename: fileName,
+			sourceType: "module"
+		});
+		if (ast === null || ast === void 0) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
+		if (types$15.isProgram(ast)) throw new Error(`Expected ${fileName} to contain a babel.types.file, but was a program`);
+		return {
+			originFileName: fileName,
+			rawContent: text,
+			format: "js",
+			root: ast
+		};
+	};
+}
+//#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;
+				}
+			}
+		}
+		result.push(lineStart);
+		return result;
+	}
+};
+function binarySearch(array, value) {
+	if (!array.length) return -1;
+	let low = 0;
+	let high = array.length - 1;
+	while (low <= high) {
+		const middle = low + (high - low >> 1);
+		const midValue = array[middle];
+		if (midValue === void 0) throw new Error("Binary search middle value is missing");
+		switch (compare(midValue, value)) {
+			case -1:
+				low = middle + 1;
+				break;
+			case 0: return middle;
+			case 1: high = middle - 1;
+		}
+	}
+	return ~low;
+}
+function compare(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function isLineBreak(ch) {
+	return ch === 10 || ch === 13 || ch === 8232 || ch === 8233;
+}
+//#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" }
+		};
+	}
+	/**
+	* Applies the mutant in (a copy of) the AST, without changing provided AST.
+	* Can the tree itself (in which case the replacement is returned),
+	* or can be nested in the given tree.
+	*
+	* Returns a plain node rather than the argument's own type: whether the
+	* replacement fits a given position is the placer's claim, and the placer
+	* checks it with a Babel predicate. A generic return would have to assert it
+	* here, where nothing can check it.
+	* @param originalTree The original node, which will be treated as readonly
+	*/
+	applied(originalTree) {
+		if (originalTree === this.original) return this.replacement;
+		else {
+			const mutatedAst = deepCloneNode(originalTree);
+			let applied = false;
+			const { original, replacement } = this;
+			traverse$2(mutatedAst, {
+				noScope: true,
+				enter(path) {
+					if (eqNode(path.node, original)) {
+						path.replaceWith(replacement);
+						path.stop();
+						applied = true;
+					}
+				}
+			});
+			if (!applied) throw new Error(`Could not apply mutant ${JSON.stringify(this.replacement)}.`);
+			return mutatedAst;
+		}
+	}
+};
+function toApiLocation(source, offset) {
+	return {
+		start: toPosition(source.start, offset),
+		end: toPosition(source.end, offset)
+	};
+}
+function toPosition(source, offset) {
+	return {
+		column: source.column + (source.line === 1 ? offset.column : 0),
+		line: source.line + offset.line - 1
+	};
+}
+//#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;
+}
+//#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 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$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 isEmpty(path) {
+	return !path.node.body.length;
+}
+/**
+* Checks to see if a statement is an invalid constructor body
+* @example
+* // Invalid!
+* class Foo extends Bar {
+*   constructor(public baz: string) {
+*     super(42);
+*   }
+* }
+* @example
+* // Invalid!
+* class Foo extends Bar {
+*   public baz = 'string';
+*   constructor() {
+*     super(42);
+*   }
+* }
+* @see https://github.com/stryker-mutator/stryker-js/issues/2314
+* @see https://github.com/stryker-mutator/stryker-js/issues/2474
+*/
+function isInvalidConstructorBody(blockStatement) {
+	return Boolean(blockStatement.parentPath.isClassMethod() && blockStatement.parentPath.node.kind === "constructor" && (containsTSParameterProperties(blockStatement.parentPath) || containsInitializedClassProperties(blockStatement.parentPath)) && hasSuperExpression(blockStatement));
+}
+function containsTSParameterProperties(constructor) {
+	return constructor.node.params.some((param) => types$12.isTSParameterProperty(param));
+}
+function containsInitializedClassProperties(constructor) {
+	return constructor.parentPath.isClassBody() && constructor.parentPath.node.body.some((classMember) => types$12.isClassProperty(classMember) && classMember.value);
+}
+function hasSuperExpression(constructor) {
+	let hasSuper = false;
+	constructor.traverse({ Super(path) {
+		if (path.parentPath.isCallExpression()) {
+			path.stop();
+			hasSuper = true;
+		}
+	} });
+	return hasSuper;
+}
+//#endregion
+//#region src/mutators/boolean-literal-mutator.ts
+const { types: types$11 } = babel;
+const booleanLiteralMutator = {
+	name: "BooleanLiteral",
+	*mutate(path) {
+		if (path.isBooleanLiteral()) yield types$11.booleanLiteral(!path.node.value);
+		if (path.isUnaryExpression() && path.node.operator === "!" && path.node.prefix) yield deepCloneNode(path.node.argument);
+	}
+};
+//#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;
+				}
+			}
+			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;
+		}
+	}
+};
+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;
+		}
+	}
+};
+//#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;
+		}
+	}
+};
+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;
+/**
+* Mutates optional chaining operators
+* Note that the AST for optional chaining might not be what you expect. Nodes of type `OptionalMemberExpression` can be either optional or not-optional
+*
+* For example: In this expression: `foo?.bar.baz` the `.baz` member expression is of type `OptionalMemberExpression`, because it is part of an optional chain, but is is _not_ optional.
+* Only the `.bar` optional member expression is optional.
+*
+* @example
+* foo?.bar -> foo.bar
+* foo?.[1] -> foo[1]
+* foo?.() -> foo()
+*/
+const optionalChainingMutator = {
+	name: "OptionalChaining",
+	*mutate(path) {
+		if (path.isOptionalMemberExpression() && path.node.optional) yield t$1.optionalMemberExpression(t$1.cloneNode(path.node.object, true), t$1.cloneNode(path.node.property, true), path.node.computed, false);
+		if (path.isOptionalCallExpression() && path.node.optional) yield t$1.optionalCallExpression(t$1.cloneNode(path.node.callee, true), path.node.arguments.map((arg) => t$1.cloneNode(arg, true)), false);
+	}
+};
+//#endregion
+//#region src/mutators/regex-mutator.ts
+const { types: types$7 } = babel;
+/**
+* Checks that a string literal is an obvious regex string literal
+* @param path The string literal to checks
+* @example
+* new RegExp("\\d{4}");
+*/
+function isObviousRegexString(path) {
+	return path.parentPath.isNewExpression() && types$7.isIdentifier(path.parentPath.node.callee) && path.parentPath.node.callee.name === RegExp.name && path.parentPath.node.arguments[0] === path.node;
+}
+function getFlags(path) {
+	if (types$7.isStringLiteral(path.node.arguments[1])) return path.node.arguments[1].value;
+}
+const weaponRegexOptions = { mutationLevels: [1] };
+const regexMutator = {
+	name: "Regex",
+	*mutate(path) {
+		if (path.isRegExpLiteral()) for (const replacementPattern of mutatePattern(path.node.pattern, path.node.flags)) yield types$7.regExpLiteral(replacementPattern, path.node.flags);
+		else if (path.isStringLiteral() && isObviousRegexString(path)) {
+			const parentPath = path.parentPath;
+			if (parentPath.isNewExpression()) {
+				const flags = getFlags(parentPath);
+				for (const replacementPattern of mutatePattern(path.node.value, flags)) yield types$7.stringLiteral(replacementPattern);
+			}
+		}
+	}
+};
+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" });
+}
+function isSymbolCall(parent) {
+	return types$6.isCallExpression(parent) && types$6.isIdentifier(parent.callee, { name: "Symbol" });
+}
+function isImportCall(parent) {
+	return types$6.isCallExpression(parent) && types$6.isImport(parent.callee);
+}
+//#endregion
+//#region src/mutators/unary-operator-mutator.ts
+const { types: types$5 } = babel;
+var UnaryOperator = /* @__PURE__ */ function(UnaryOperator) {
+	UnaryOperator["+"] = "-";
+	UnaryOperator["-"] = "+";
+	UnaryOperator["~"] = "";
+	return UnaryOperator;
+}(UnaryOperator || {});
+const unaryOperatorMutator = {
+	name: "UnaryOperator",
+	*mutate(path) {
+		if (path.isUnaryExpression() && isSupported(path.node.operator) && path.node.prefix) {
+			const mutatedOperator = UnaryOperator[path.node.operator];
+			yield isPlusOrMinus(mutatedOperator) ? types$5.unaryExpression(mutatedOperator, deepCloneNode(path.node.argument)) : deepCloneNode(path.node.argument);
+		}
+	}
+};
+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);
+		}
+	},
+	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);
+	}
+};
+//#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;
+/**
+* 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$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;
+		}
+	}
+}
+/**
+* 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 isMemberOrCallOrNonNullExpression(path) {
+	return isCallExpression(path) || isMemberOrNonNullExpression(path);
+}
+function isMemberOrNonNullExpression(path) {
+	return isMemberExpression(path) || path.isTSNonNullExpression();
+}
+function isMemberExpression(path) {
+	return path.isMemberExpression() || path.isOptionalMemberExpression();
+}
+function isCallExpression(path) {
+	return path.isCallExpression() || path.isOptionalCallExpression();
+}
+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$3.conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, types$3.isExpression, "an expression"), expression);
+		path.replaceWith(expression);
+	}
+};
+//#endregion
+//#region src/mutant-placers/statement-mutant-placer.ts
+const { types: t } = babel;
+/**
+* Mutant placer that places mutants in statements that allow it.
+* It uses an `if` statement to do so
+*/
+const statementMutantPlacer = {
+	name: "statementMutantPlacer",
+	canPlace(path) {
+		return path.isStatement();
+	},
+	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 https://github.com/stryker-mutator/stryker-js/issues/new?assignees=&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=${encodeURIComponent(message)}. Original error: ${error.stack}`;
+	let builtError = new Error(errorMessage);
+	try {
+		builtError = nodePath.buildCodeFrameError(errorMessage);
+	} catch {}
+	throw builtError;
+}
+//#endregion
+//#region src/mutant-placers/index.ts
+const allMutantPlacers = Object.freeze([
+	expressionMutantPlacer,
+	statementMutantPlacer,
+	switchCaseMutantPlacer
+]);
+//#endregion
+//#region src/util/babel-file.ts
+/**
+* Wraps a parsed AST the way Babel's own pipeline does, so
+* `NodePath#buildCodeFrameError` can render a code frame
+* (https://github.com/babel/babel/issues/11889). Without the wrapper a
+* placement failure reports no source context.
+*/
+function createBabelFile(filename, code, ast) {
+	return new File({ filename }, {
+		code,
+		ast
+	});
+}
+//#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);
+	}
+};
+var RestoreRule = class extends IgnoreRule {
+	constructor(mutatorNames, line, previousRule) {
+		super(mutatorNames, line, void 0, previousRule);
+	}
+};
+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);
+		}
+	}
+	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);
+		}
+	}
+	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);
+		}
+	}
+	getLine(loc) {
+		if (loc === void 0 || loc === null || loc.start === null || loc.start === void 0) throw new Error("Babel node without location");
+		return loc.start.line;
+	}
+	findIgnoreReason(line, mutatorName) {
+		mutatorName = mutatorName.toLowerCase();
+		return this.currentIgnoreRule.findIgnoreReason(mutatorName, line);
+	}
+	warnAboutUnusedDirective(mutators, directiveType, scope, comment) {
+		for (const mutator of mutators) {
+			if (mutator === WILDCARD) continue;
+			if (!this.allMutatorNames.includes(mutator.toLowerCase())) {
+				const commentLoc = comment.loc;
+				if (commentLoc === void 0 || commentLoc === null || commentLoc.start === null || commentLoc.start === void 0) throw new Error("Comment without location");
+				this.logger.warn(`Unused 'Stryker ${scope ? directiveType + " " + scope : directiveType}' directive. Mutator with name '${mutator}' not found. Directive found at: ${this.originFileName}:${commentLoc.start.line}:${commentLoc.start.column}.`);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/transformers/ignorer-bookkeeper.ts
+/**
+* Responsible for keeping track of the active ignore message and node using the configured ignore-plugins.
+*/
+var IgnorerBookkeeper = class {
+	ignorers;
+	activeIgnored;
+	get currentIgnoreMessage() {
+		return this.activeIgnored?.message;
+	}
+	constructor(ignorers) {
+		this.ignorers = ignorers;
+	}
+	enterNode(path) {
+		if (!this.activeIgnored) this.ignorers.forEach((ignorer) => {
+			const message = ignorer.shouldIgnore(path);
+			if (message) this.activeIgnored = {
+				node: path.node,
+				message
+			};
+		});
+	}
+	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)}`);
+					}
+				}
+			}
+		},
+		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
+		});
+	}
+	/**
+	* 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;
+		}
+	}
+};
+function getNodeLocation(node) {
+	const loc = node.loc;
+	if (loc === void 0 || loc === null || loc.start === null || loc.start === void 0 || loc.end === null || loc.end === void 0) throw new Error("Babel node without location");
+	return loc;
+}
+function toError(value) {
+	if (value instanceof Error) return value;
+	return new Error("Unexpected error", { cause: value });
+}
+//#endregion
+//#region src/transformers/html-transformer.ts
+const transformHtml = ({ root }, mutantCollector, context) => {
+	root.scripts.forEach((ast) => {
+		context.transform(ast, mutantCollector, context);
+	});
+};
+//#endregion
+//#region src/transformers/svelte-transformer.ts
+const moduleScript = `<script context="module">
+\n<\/script>\n`;
+const transformSvelte = (svelte, mutantCollector, context) => {
+	const { root, originFileName } = svelte;
+	[root.moduleScript, ...root.additionalScripts].filter(notEmpty).forEach((script) => {
+		context.transform(script.ast, mutantCollector, {
+			...context,
+			options: {
+				...context.options,
+				noHeader: true
+			}
+		});
+	});
+	if (mutantCollector.hasPlacedMutants(originFileName)) {
+		if (!root.moduleScript) {
+			root.moduleScript = {
+				ast: {
+					format: "js",
+					root: types.file(types.program([])),
+					rawContent: "",
+					originFileName
+				},
+				range: {
+					start: 26,
+					end: 26
+				},
+				isExpression: false
+			};
+			svelte.rawContent = `${moduleScript}${svelte.rawContent}`;
+			svelte.root.additionalScripts.forEach((script) => {
+				script.range.start += moduleScript.length;
+				script.range.end += moduleScript.length;
+			});
+		}
+		placeHeader(root.moduleScript.ast.root);
+	}
+};
+//#endregion
+//#region src/transformers/transformer.ts
+/**
+* Transform the AST by generating mutants and placing them in the AST.
+* Supports all AST formats supported by Stryker.
+* @param ast The Abstract Syntax Tree
+* @param mutantCollector the mutant collector that will be used to register and administer mutants
+* @param transformerContext the options used during transforming
+*/
+function transform(ast, mutantCollector, transformerContext) {
+	const context = {
+		...transformerContext,
+		transform
+	};
+	switch (ast.format) {
+		case "html":
+			transformHtml(ast, mutantCollector, context);
+			break;
+		case "js":
+		case "ts":
+		case "tsx":
+			transformBabel(ast, mutantCollector, context);
+			break;
+		case "svelte": transformSvelte(ast, mutantCollector, context);
+	}
+}
+//#endregion
+//#region src/util/syntax-helpers.ts
+const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
+const COVER_MUTANT_HELPER = "stryCov_9fa48";
+const IS_MUTANT_ACTIVE_HELPER = "stryMutAct_9fa48";
+const { types: types$2, traverse } = babel;
+/**
+* Returns syntax for the header if JS/TS files
+*/
+const parsedInstrumentationHeader = babel.parse(`function ${STRYKER_NAMESPACE_HELPER}(){
+  var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
+  var ns = g.${ID.NAMESPACE} || (g.${ID.NAMESPACE} = {});
+  if (ns.${ID.ACTIVE_MUTANT} === undefined && g.process && g.process.env && g.process.env.${ID.ACTIVE_MUTANT_ENV_VARIABLE}) {
+    ns.${ID.ACTIVE_MUTANT} = g.process.env.${ID.ACTIVE_MUTANT_ENV_VARIABLE};
+  }
+  function retrieveNS(){
+    return ns;
+  }
+  ${STRYKER_NAMESPACE_HELPER} = retrieveNS;
+  return retrieveNS();
+}
+${STRYKER_NAMESPACE_HELPER}();
+
+function ${COVER_MUTANT_HELPER}() {
+  var ns = ${STRYKER_NAMESPACE_HELPER}();
+  var cov = ns.${ID.MUTATION_COVERAGE_OBJECT} || (ns.${ID.MUTATION_COVERAGE_OBJECT} = { static: {}, perTest: {} });
+  function cover() {
+    var c = cov.static;
+    if (ns.${ID.CURRENT_TEST_ID}) {
+      c = cov.perTest[ns.${ID.CURRENT_TEST_ID}] = cov.perTest[ns.${ID.CURRENT_TEST_ID}] || {};
+    }
+    var a = arguments;
+    for(var i=0; i < a.length; i++){
+      c[a[i]] = (c[a[i]] || 0) + 1;
+    }
+  }
+  ${COVER_MUTANT_HELPER} = cover;
+  cover.apply(null, arguments);
+}
+function ${IS_MUTANT_ACTIVE_HELPER}(id) {
+  var ns = ${STRYKER_NAMESPACE_HELPER}();
+  function isActive(id) {
+    if (ns.${ID.ACTIVE_MUTANT} === id) {
+      if (ns.${ID.HIT_COUNT} !== void 0 && ++ns.${ID.HIT_COUNT} > ns.${ID.HIT_LIMIT}) {
+        throw new Error('Stryker: Hit count limit reached (' + ns.${ID.HIT_COUNT} + ')');
+      }
+      return true;
+    }
+    return false;
+  }
+  ${IS_MUTANT_ACTIVE_HELPER} = isActive;
+  return isActive(id);
+}`, {
+	configFile: false,
+	browserslistConfigFile: false,
+	env: { targets: {} }
+});
+if (!types$2.isFile(parsedInstrumentationHeader)) throw new Error("Instrumentation header parsed as non-File");
+const instrumentationBabelHeader = parsedInstrumentationHeader.program.body;
+deepFreeze(instrumentationBabelHeader);
+/**
+* returns syntax for `global.activeMutant === $mutantId`
+* @param mutantId The id of the mutant to switch
+*/
+function mutantTestExpression(mutantId) {
+	return types$2.callExpression(types$2.identifier(IS_MUTANT_ACTIVE_HELPER), [types$2.stringLiteral(mutantId)]);
+}
+function eqLocation(a, b) {
+	function eqPosition(start, end) {
+		return start.column === end.column && start.line === end.line;
+	}
+	return eqPosition(a.start, b.start) && eqPosition(a.end, b.end);
+}
+function eqNode(a, b) {
+	return a.type === b.type && !!a.loc && !!b.loc && eqLocation(a.loc, b.loc);
+}
+/**
+* Returns a sequence of mutation coverage counters with an optional last expression.
+*
+* @example (global.__coverMutant__(0, 1), 40 + 2)
+* @param mutants The mutants for which covering syntax needs to be generated
+* @param targetExpression The original expression
+*/
+function mutationCoverageSequenceExpression(mutants, targetExpression) {
+	const mutantIds = [...mutants].map((mutant) => types$2.stringLiteral(mutant.id));
+	const sequence = [types$2.callExpression(types$2.identifier(COVER_MUTANT_HELPER), mutantIds)];
+	if (targetExpression) sequence.push(targetExpression);
+	return types$2.sequenceExpression(sequence);
+}
+function isTypeNode(path) {
+	return path.isTypeAnnotation() || flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path) || isDeclareModule(path);
+}
+/**
+* Determines whether or not it is a declare variable statement node.
+* @example
+* declare const foo: 'foo';
+*/
+function isDeclareVariableStatement(path) {
+	return path.isVariableDeclaration() && path.node.declare === true;
+}
+/**
+* Determines whether or not a node is a string literal that is the name of a module.
+* @example
+* declare module "express" {};
+*/
+function isDeclareModule(path) {
+	return path.isTSModuleDeclaration() && (path.node.declare ?? false);
+}
+const tsTypeAnnotationNodeTypes = Object.freeze([
+	"TSAsExpression",
+	"TSInterfaceDeclaration",
+	"TSTypeAnnotation",
+	"TSTypeAliasDeclaration",
+	"TSEnumDeclaration",
+	"TSDeclareFunction",
+	"TSTypeParameterInstantiation",
+	"TSTypeParameterDeclaration"
+]);
+const flowTypeAnnotationNodeTypes = Object.freeze([
+	"DeclareClass",
+	"DeclareFunction",
+	"DeclareInterface",
+	"DeclareModule",
+	"DeclareModuleExports",
+	"DeclareTypeAlias",
+	"DeclareOpaqueType",
+	"DeclareVariable",
+	"DeclareExportDeclaration",
+	"DeclareExportAllDeclaration",
+	"InterfaceDeclaration",
+	"OpaqueType",
+	"TypeAlias",
+	"InterfaceDeclaration"
+]);
+function isImportDeclaration(path) {
+	return types$2.isTSImportEqualsDeclaration(path.node) || path.isImportDeclaration();
+}
+/**
+* Determines if a location (needle) is included in an other location (haystack)
+* @param haystack The range to look in
+* @param needle the range to search for
+*/
+function locationIncluded(haystack, needle) {
+	const startIncluded = haystack.start.line < needle.start.line || haystack.start.line === needle.start.line && haystack.start.column <= needle.start.column;
+	const endIncluded = haystack.end.line > needle.end.line || haystack.end.line === needle.end.line && haystack.end.column >= needle.end.column;
+	return startIncluded && endIncluded;
+}
+/**
+* Determines if two locations overlap with each other
+*/
+function locationOverlaps(a, b) {
+	const startIncluded = a.start.line < b.end.line || a.start.line === b.end.line && a.start.column <= b.end.column;
+	const endIncluded = a.end.line > b.start.line || a.end.line === b.start.line && a.end.column >= b.start.column;
+	return startIncluded && endIncluded;
+}
+/**
+* Helper for `types.cloneNode(node, deep: true, withoutLocations: false);`
+*/
+function deepCloneNode(node) {
+	return types$2.cloneNode(node, true, false);
+}
+function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
+	if (mutantCollector.hasPlacedMutants(originFileName) && !options.noHeader) placeHeader(root);
+}
+function placeHeader(root) {
+	let header = instrumentationBabelHeader;
+	const leadingComments = root.program.body[0]?.leadingComments;
+	if (Array.isArray(leadingComments)) {
+		const firstHeader = instrumentationBabelHeader[0];
+		if (firstHeader === void 0) throw new Error("Instrumentation header is empty");
+		const cloned = types$2.cloneNode(firstHeader, true, false);
+		cloned.leadingComments = leadingComments;
+		header = [cloned, ...instrumentationBabelHeader.slice(1)];
+	}
+	root.program.body.unshift(...header);
+}
+//#endregion
+//#region src/parsers/svelte-parser.ts
+const MIN_SVELTE_VERSION = ">=3.30";
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function isRangedProgram(value) {
+	return isPlainRecord(value) && typeof value["start"] === "number" && typeof value["end"] === "number";
+}
+function isWalkFunction(value) {
+	return typeof value === "function";
+}
+function isRangedBaseNode(value) {
+	return isPlainRecord(value) && typeof value["type"] === "string" && typeof value["start"] === "number" && typeof value["end"] === "number";
+}
+function isTemplateExpressionType(type) {
+	return type === "MustacheTag" || type === "RawMustacheTag" || type === "IfBlock" || type === "ConstTag" || type === "EachBlock" || type === "AwaitBlock" || type === "KeyBlock" || type === "EventHandler";
+}
+function tryGetScriptRangeFromElement(node) {
+	if (!isPlainRecord(node) || node["type"] !== "Element" || node["name"] !== "script") return;
+	const children = node["children"];
+	if (!isUnknownArray(children) || children.length === 0) return;
+	const firstChild = children[0];
+	if (!isPlainRecord(firstChild) || firstChild["type"] !== "Text" || typeof firstChild["start"] !== "number" || typeof firstChild["end"] !== "number") return;
+	return {
+		start: firstChild["start"],
+		end: firstChild["end"],
+		isExpression: false
+	};
+}
+async function parse$1(text, fileName, context) {
+	const { parse: svelteParse, preprocess, VERSION } = await import("./compiler-Ck-td5Ds.mjs");
+	let walk;
+	if (!satisfies(VERSION, MIN_SVELTE_VERSION)) throw new Error(`Svelte version ${VERSION} not supported. Expected: ${MIN_SVELTE_VERSION} (processing file ${fileName})`);
+	if (satisfies(VERSION, ">=5")) {
+		const walkerModule = await import(import.meta.resolve("estree-walker", import.meta.resolve("svelte")));
+		if (!isPlainRecord(walkerModule) || !isWalkFunction(walkerModule["walk"])) throw new Error("estree-walker module without walk export");
+		walk = walkerModule["walk"];
+	} else {
+		const svelteCompilerModule = await import("./compiler-Ck-td5Ds.mjs");
+		if (!isPlainRecord(svelteCompilerModule) || !isWalkFunction(svelteCompilerModule["walk"])) throw new Error("svelte/compiler module without walk export");
+		walk = svelteCompilerModule["walk"];
+	}
+	const positionConverter = new PositionConverter(text);
+	const { replacedCode, scriptMap } = await replaceScripts(text);
+	const svelteAst = svelteParse(replacedCode, { filename: fileName });
+	const { remappedModuleScriptRange, remappedScriptRanges } = remapScriptLocations(replacedCode, scriptMap, getModuleScriptRange(svelteAst), getTemplateScriptRanges(svelteAst, walk));
+	const [moduleScript, ...additionalScripts] = await Promise.all([parseTemplateScriptIfDefined(remappedModuleScriptRange), ...remappedScriptRanges.map(parseTemplateScript)]);
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "svelte",
+		root: {
+			...moduleScript === void 0 ? {} : { moduleScript },
+			additionalScripts
+		}
+	};
+	/**
+	* Replaces script tags with placeholders.
+	* This is needed, because svelte's `parse` doesn't support `lang="ts"`.
+	*/
+	async function replaceScripts(code) {
+		const map = /* @__PURE__ */ new Map();
+		let scriptIndex = 0;
+		return {
+			replacedCode: (await preprocess(code, { script(script) {
+				const scriptName = `script${scriptIndex++}`;
+				map.set(scriptName, script);
+				return { code: scriptName };
+			} })).code,
+			scriptMap: map
+		};
+	}
+	function getTemplateScriptRanges(ast, walker) {
+		const ranges = [];
+		if (isPlainRecord(ast) && ast["instance"] !== null && ast["instance"] !== void 0) {
+			const instance = ast["instance"];
+			if (isPlainRecord(instance) && "content" in instance) {
+				const content = instance["content"];
+				if (isRangedProgram(content)) ranges.push({
+					start: content.start,
+					end: content.end,
+					isExpression: false
+				});
+				else throw new Error("Svelte instance script without a source range");
+			}
+		}
+		if (!isPlainRecord(ast) || !("html" in ast)) throw new Error("Svelte AST without html");
+		const html = ast["html"];
+		walker(html, { enter(node) {
+			const scriptRange = tryGetScriptRangeFromElement(node);
+			if (scriptRange) ranges.push(scriptRange);
+			const templateExpression = collectTemplateExpression(node);
+			if (templateExpression) {
+				const { start, end } = templateExpression;
+				ranges.push({
+					start,
+					end,
+					isExpression: true
+				});
+			}
+		} });
+		return ranges;
+	}
+	async function parseTemplateScriptIfDefined(range) {
+		if (range) return parseTemplateScript(range);
+	}
+	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 getModuleScriptRange(svelteAst) {
+	if (!isPlainRecord(svelteAst) || !("module" in svelteAst) || svelteAst["module"] === null || svelteAst["module"] === void 0) return;
+	const mod = svelteAst["module"];
+	if (!isPlainRecord(mod) || !("content" in mod)) throw new Error("Svelte module script without a source range");
+	const content = mod["content"];
+	if (!isRangedProgram(content)) throw new Error("Svelte module script without a source range");
+	return {
+		start: content.start,
+		end: content.end,
+		isExpression: false
+	};
+}
+/**
+* Remaps script locations back to the original places using the script map
+*/
+function remapScriptLocations(code, scriptMap, moduleScriptRange, templateRanges) {
+	const scriptRanges = [moduleScriptRange, ...templateRanges].filter(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"
+		};
+	});
+	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/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) {
+	return {
+		originFileName: fileName,
+		rawContent: text,
+		format: "ts",
+		root: await parse(text, fileName, false)
+	};
+}
+async function parseTsx(text, fileName) {
+	return {
+		root: await parse(text, fileName, true),
+		format: "tsx",
+		originFileName: fileName,
+		rawContent: text
+	};
+}
+async function parse(text, fileName, isTSX) {
+	const ast = await parseAsync(text, {
+		filename: fileName,
+		parserOpts: { ranges: true },
+		configFile: false,
+		babelrc: false,
+		presets: [[require.resolve("@babel/preset-typescript"), {
+			isTSX,
+			allExtensions: true
+		}]],
+		plugins: [[require.resolve("@babel/plugin-proposal-decorators"), { legacy: true }], [require.resolve("@babel/plugin-transform-explicit-resource-management")]]
+	});
+	if (ast === null) throw new Error(`Expected ${fileName} to contain a babel.types.file, but it yielded null`);
+	if (types$1.isProgram(ast)) throw new Error(`Expected ${fileName} to contain a babel.types.file, but was a program`);
+	return ast;
+}
+//#endregion
+//#region src/parsers/create-parser.ts
+function createParser(parserOptions) {
+	const jsParse = createParser$1(parserOptions);
+	async function parse(code, fileName, formatOverride) {
+		const format = getFormat(fileName, formatOverride);
+		if (!format) {
+			const ext = path.extname(fileName).toLowerCase();
+			throw new Error(`Unable to parse ${fileName}. No parser registered for ${ext}!`);
+		}
+		switch (format) {
+			case "js": return jsParse(code, fileName);
+			case "tsx": return parseTsx(code, fileName);
+			case "ts": return parseTS(code, fileName);
+			case "html": return parse$2(code, fileName, { parse });
+			case "svelte": return parse$1(code, fileName, { parse });
+			default: throw new Error(`Unsupported format: ${String(format)}`);
+		}
+	}
+	return parse;
+}
+function getFormat(fileName, override) {
+	if (override) return override;
+	else switch (path.extname(fileName).toLowerCase()) {
+		case ".js":
+		case ".jsx":
+		case ".mjs":
+		case ".cjs": return "js";
+		case ".mts":
+		case ".cts":
+		case ".ts": return "ts";
+		case ".tsx": return "tsx";
+		case ".vue":
+		case ".html":
+		case ".htm": return "html";
+		case ".svelte": return "svelte";
+		default: return;
+	}
+}
+//#endregion
+//#region src/printers/html-printer.ts
+function getScriptStart$1(script) {
+	const start = script.root.start;
+	if (start === void 0 || start === null) throw new Error("Script AST root without start");
+	return start;
+}
+function getScriptEnd$1(script) {
+	const end = script.root.end;
+	if (end === void 0 || end === null) throw new Error("Script AST root without end");
+	return end;
+}
+const print$4 = (ast, context) => {
+	const sortedScripts = [...ast.root.scripts].sort((a, b) => getScriptStart$1(a) - getScriptStart$1(b));
+	let currentIndex = 0;
+	let html = "";
+	for (const script of sortedScripts) {
+		html += ast.rawContent.substring(currentIndex, getScriptStart$1(script));
+		html += "\n";
+		html += context.print(script, context);
+		html += "\n";
+		currentIndex = getScriptEnd$1(script);
+	}
+	html += ast.rawContent.substr(currentIndex);
+	return html;
+};
+//#endregion
+//#region src/printers/js-printer.ts
+const print$3 = (file) => {
+	return generate(file.root, { sourceMaps: false }).code;
+};
+//#endregion
+//#region src/printers/svelte-printer.ts
+const print$2 = ({ root, rawContent }, context) => {
+	let currentIndex = 0;
+	let outputText = "";
+	const sortedScripts = [root.moduleScript, ...root.additionalScripts].filter(notEmpty).sort((a, b) => a.range.start - b.range.start);
+	for (const script of sortedScripts) if (script.isExpression) {
+		const codeWithoutSemicolon = context.print(script.ast, context).slice(0, -1);
+		outputText += rawContent.substring(currentIndex, script.range.start) + codeWithoutSemicolon;
+		currentIndex = script.range.end;
+	} else {
+		outputText += rawContent.substring(currentIndex, script.range.start);
+		outputText += "\n";
+		outputText += context.print(script.ast, context);
+		outputText += "\n";
+		currentIndex = script.range.end;
+	}
+	outputText += rawContent.substring(currentIndex);
+	return outputText;
+};
+//#endregion
+//#region src/printers/ts-printer.ts
+const print$1 = (file) => {
+	return generate(file.root, {
+		decoratorsBeforeExport: true,
+		sourceMaps: false
+	}).code;
+};
+//#endregion
+//#region src/printers/index.ts
+function print(file) {
+	const context = { print };
+	switch (file.format) {
+		case "js": return print$3(file, context);
+		case "ts": return print$1(file, context);
+		case "tsx": return print$1(file, context);
+		case "html": return print$4(file, context);
+		case "svelte": return print$2(file, context);
+	}
+}
+//#endregion
+//#region src/create-instrumenter.ts
+createInstrumenter.inject = tokens(commonTokens.injector);
+function createInstrumenter(injector) {
+	return injector.provideValue(instrumenterTokens.print, print).provideValue(instrumenterTokens.createParser, createParser).provideValue(instrumenterTokens.transform, transform).injectClass(Instrumenter);
+}
+//#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, {
+				options,
+				mutateDescription: toBabelLineNumber(mutate),
+				logger: this.logger
+			});
+			const mutatedContent = this._print(ast);
+			outFiles.push({
+				name,
+				mutate,
+				content: mutatedContent
+			});
+			if (this.logger.isDebugEnabled()) {
+				const nrOfMutantsInFile = mutantCollector.mutants.length - mutantCount;
+				mutantCount = mutantCollector.mutants.length;
+				this.logger.debug(`Instrumented ${path.relative(process.cwd(), name)} (${nrOfMutantsInFile} mutant(s))`);
+			}
+		}
+		const mutants = mutantCollector.mutants.map((mutant) => mutant.toApiMutant());
+		this.logger.info("Instrumented %d source file(s) with %d mutant(s)", files.length, mutants.length);
+		return {
+			files: outFiles,
+			mutants
+		};
+	}
+};
+function toBabelLineNumber(range) {
+	if (typeof range === "boolean") return range;
+	else return range.map(({ start, end }) => ({
+		start: {
+			column: start.column,
+			line: start.line + 1
+		},
+		end: {
+			column: end.column,
+			line: end.line + 1
+		}
+	}));
+}
+//#endregion
+export { Instrumenter, createInstrumenter, disableTypeChecks, frameworkPluginsFileUrl, strykerPlugins };