@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/index.mjs

@@ -0,0 +1,1885 @@
+import { ConfigError, retrieveCause } from "./errors.mjs";
+import { $ as testRunnerPool, A as mutantTestPlanner, B as reporter, F as pluginModulePaths, G as runEventSink, H as reporterPluginModules, I as pluginsByKind, J as sandbox, K as runId, L as process$1, M as mutationTestReportHelper, N as optionsValidator, O as loggingServerAddress, P as pluginCreator, Q as testRunnerFactory, R as progressEnabled, S as incrementalDiffer, U as requireFromCwd, V as reporterOverride, W as resolvedMode, X as testCoverage, Y as temporaryDirectory, Z as testRunnerConcurrencyTokens, _ as clearTextEnabled, a as isWarningEnabled, b as dryRunResult, c as ProjectReader, d as ConfigReader, et as timeOverheadMS, f as FileSystem, g as checkerPool, h as checkerFactory, i as optionsPath, it as workerIdGenerator, j as mutants, k as loggingSink, l as MetaSchemaBuilder, m as checkerConcurrencyTokens, n as OptionsValidator, nt as unexpectedExitRegistry, o as CommandTestRunner, p as PluginCreator, q as runStartedAt, rt as validationSchema, t as PluginLoader, tt as timer, u as FileMatcher, v as concurrencyTokenProvider, x as execa, y as disableTypeChecksHelper, z as project } from "./plugins-Nx86IJQW.mjs";
+import { Timer } from "./timer.mjs";
+import { t as forkCoreSchema } from "./fork-schema-BHuTbRBR.mjs";
+import { a as provideLogging, o as provideLoggingBackend } from "./child-process-proxy-worker-lx1M5Mz3.mjs";
+import { a as ChildProcessCrashedError, c as createTestRunnerPool, i as OutOfMemoryError, l as ConcurrencyTokenProvider, o as ResourceDecorator, r as ChildProcessProxy, s as createCheckerPool, t as createCheckerFactory } from "./checker-C4tGiXtZ.mjs";
+import { n as toRelativeNormalizedFileName, r as TestCoverage, t as IncrementalDiffer } from "./incremental-differ-DY8AA09Q.mjs";
+import { setPendingExitClass } from "./exit-classification.mjs";
+import { n as strykerVersion } from "./stryker-package-CTcsIZ4S.mjs";
+import { o as judgeTestContribution, r as buildVerdictEnvelope } from "./verdict-envelope-BWc61mHm.mjs";
+import { t as ChildProcessTestRunnerWorker } from "./child-process-test-runner-worker-BTWRYb8V.mjs";
+import { PlanKind } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { PluginKind, commonTokens, tokens } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { createInjector, tokens as tokens$1 } from "typed-inject";
+import { ExpirableTask, deepFreeze, errorToString, isErrnoException, normalizeFileName, normalizeWhitespaces, notEmpty, requireResolve, split } from "@stryker-mutator/util";
+import fs from "fs";
+import path from "path";
+import { URL } from "url";
+import { Result, Schema } from "effect";
+import "@systemfsoftware/stryker-js-plugin-api/logging";
+import { EOL } from "os";
+import * as S from "effect/Schema";
+import { EMPTY, bufferTime, concat, from, lastValueFrom, merge, mergeMap, of, partition } from "rxjs";
+import { createInstrumenter, disableTypeChecks, frameworkPluginsFileUrl } from "@stryker-mutator/instrumenter";
+import { DryRunStatus, MutantRunStatus, TestStatus } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+import { execaCommand } from "execa";
+import "@systemfsoftware/stryker-js-plugin-api/report";
+import { calculateMutationTestMetrics } from "mutation-testing-metrics";
+import { CheckStatus } from "@systemfsoftware/stryker-js-plugin-api/check";
+import { npmRunPathEnv } from "npm-run-path";
+import { map, shareReplay, tap as tap$1, toArray } from "rxjs/operators";
+//#region src/reporting/broadcast-reporter.ts
+var BroadcastReporter = class {
+	options;
+	pluginCreator;
+	log;
+	reporterOverride;
+	static inject = tokens$1(commonTokens.options, pluginCreator, commonTokens.logger, reporterOverride, progressEnabled, clearTextEnabled);
+	reporters;
+	/**
+	* The progress bar's gate, resolved by the host once at the edge (U13):
+	* human mode on a non-TTY stdout suppresses the bar so its control
+	* sequences never reach a pipe. Received as data — core no longer probes
+	* the terminal.
+	*/
+	progressEnabled;
+	/**
+	* The clear-text reporter's gate, resolved by the host once at the edge
+	* (U13): machine mode keeps stdout exclusively for the NDJSON stream, so
+	* the prose reporter is dropped before dispatch. Received as data — core
+	* no longer probes the terminal.
+	*/
+	clearTextEnabled;
+	constructor(options, pluginCreator, log, reporterOverride, progressEnabled, clearTextEnabled) {
+		this.options = options;
+		this.pluginCreator = pluginCreator;
+		this.log = log;
+		this.reporterOverride = reporterOverride;
+		this.progressEnabled = progressEnabled;
+		this.clearTextEnabled = clearTextEnabled;
+		this.reporters = {};
+		if (this.reporterOverride) this.reporters["in-memory"] = this.reporterOverride;
+		else this.options.reporters.forEach((reporterName) => this.createReporter(reporterName));
+		this.logAboutReporters();
+	}
+	createReporter(reporterName) {
+		this.reporters[reporterName] = this.pluginCreator.create(PluginKind.Reporter, reporterName);
+	}
+	logAboutReporters() {
+		const reporterNames = Object.keys(this.reporters);
+		if (reporterNames.length) {
+			if (this.log.isDebugEnabled()) this.log.debug(`Broadcasting to reporters ${JSON.stringify(reporterNames)}`);
+		} else this.log.warn("No reporter configured. Please configure one or more reporters in the (for example: reporters: ['progress'])");
+	}
+	broadcast(methodName, call) {
+		return Promise.all(Object.entries(this.reporters).map(async ([reporterName, reporter]) => {
+			if (reporterName === "progress" && !this.progressEnabled || reporterName === "clear-text" && !this.clearTextEnabled) return;
+			try {
+				await call(reporter);
+			} catch (error) {
+				this.handleError(error, methodName, reporterName);
+			}
+		}));
+	}
+	onDryRunCompleted(event) {
+		this.broadcast("onDryRunCompleted", (reporter) => reporter.onDryRunCompleted?.(event));
+	}
+	onMutationTestingPlanReady(event) {
+		this.broadcast("onMutationTestingPlanReady", (reporter) => reporter.onMutationTestingPlanReady?.(event));
+	}
+	onMutantTested(result) {
+		this.broadcast("onMutantTested", (reporter) => reporter.onMutantTested?.(result));
+	}
+	onMutationTestReportReady(report, metrics) {
+		this.broadcast("onMutationTestReportReady", (reporter) => reporter.onMutationTestReportReady?.(report, metrics));
+	}
+	async wrapUp() {
+		await this.broadcast("wrapUp", (reporter) => reporter.wrapUp?.());
+	}
+	handleError(error, methodName, reporterName) {
+		this.log.error(`An error occurred during '${methodName}' on reporter '${reporterName}'.`, error);
+	}
+};
+//#endregion
+//#region src/sandbox/temporary-directory.ts
+var TemporaryDirectory = class {
+	log;
+	options;
+	#temporaryDirectory;
+	removeDuringDisposal;
+	static inject = tokens(commonTokens.logger, commonTokens.options);
+	constructor(log, options) {
+		this.log = log;
+		this.options = options;
+		this.removeDuringDisposal = Boolean(options.cleanTempDir);
+	}
+	async initialize() {
+		const parent = path.resolve(this.options.tempDirName);
+		await fs.promises.mkdir(parent, { recursive: true });
+		this.#temporaryDirectory = await fs.promises.mkdtemp(path.join(parent, this.options.inPlace ? "backup-" : "sandbox-"));
+		this.log.debug("Using temp directory \"%s\"", this.#temporaryDirectory);
+	}
+	get path() {
+		if (!this.#temporaryDirectory) this.#throwNotInitialized();
+		return this.#temporaryDirectory;
+	}
+	#throwNotInitialized() {
+		throw new Error("initialize() was not called!");
+	}
+	/**
+	* Deletes the Stryker-temp directory
+	*/
+	async dispose() {
+		if (this.removeDuringDisposal && this.#temporaryDirectory) {
+			this.log.debug("Deleting stryker temp directory %s", this.#temporaryDirectory);
+			try {
+				await fs.promises.rm(this.#temporaryDirectory, {
+					recursive: true,
+					force: true
+				});
+			} catch {
+				this.log.info(`Failed to delete stryker temp directory ${this.#temporaryDirectory}`);
+			}
+			try {
+				if (!(await fs.promises.readdir(this.options.tempDirName)).length) try {
+					await fs.promises.rmdir(this.options.tempDirName);
+				} catch (e) {
+					this.log.debug(`Failed to clean temp ${path.basename(this.options.tempDirName)}`, e);
+				}
+			} catch {}
+		}
+	}
+};
+//#endregion
+//#region src/unexpected-exit-handler.ts
+/**
+* Runs registered cleanup handlers when the process exits. Signal handling
+* was deliberately removed: SIGINT/SIGTERM are owned by the runMain bootstrap
+* (fiber interruption + `128 + n` at teardown), and a synchronous
+* `process.exit` in a signal handler raced the runtime and killed finalizers.
+* The `exit` event still fires for both `process.exit` and a drained loop.
+*/
+var UnexpectedExitHandler = class {
+	process;
+	unexpectedExitHandlers = [];
+	static inject = [process$1];
+	constructor(process) {
+		this.process = process;
+		process.on("exit", this.handleExit);
+	}
+	handleExit = () => {
+		this.unexpectedExitHandlers.forEach((handler) => handler());
+	};
+	registerHandler(handler) {
+		this.unexpectedExitHandlers.push(handler);
+	}
+	dispose() {
+		this.process.off("exit", this.handleExit);
+	}
+};
+//#endregion
+//#region src/run-stages/1-prepare-executor.ts
+var PrepareExecutor = class {
+	injector;
+	loggingBackend;
+	reporterPluginModules;
+	static inject = tokens(commonTokens.injector, loggingSink, reporterPluginModules);
+	constructor(injector, loggingBackend, reporterPluginModules) {
+		this.injector = injector;
+		this.loggingBackend = loggingBackend;
+		this.reporterPluginModules = reporterPluginModules;
+	}
+	async execute({ cliOptions, targetMutatePatterns }) {
+		const timer$1 = new Timer();
+		this.loggingBackend.configure(cliOptions);
+		const configReaderInjector = this.injector.provideValue(validationSchema, forkCoreSchema).provideClass(optionsValidator, OptionsValidator);
+		const options = await configReaderInjector.injectClass(ConfigReader).readConfig(cliOptions);
+		const pluginLoader = configReaderInjector.injectClass(PluginLoader);
+		const pluginDescriptors = [
+			...options.plugins,
+			frameworkPluginsFileUrl,
+			...this.reporterPluginModules,
+			...options.appendPlugins
+		];
+		const loadedPlugins = await pluginLoader.load(pluginDescriptors);
+		const metaSchema = configReaderInjector.injectClass(MetaSchemaBuilder).buildMetaSchema(loadedPlugins.schemaContributions);
+		const optionsValidatorInjector = configReaderInjector.provideValue(validationSchema, S.decodeUnknownSync(S.Record(S.String, S.Unknown))(metaSchema));
+		optionsValidatorInjector.injectClass(OptionsValidator).validate(options, true);
+		deepFreeze(options);
+		this.loggingBackend.configure(options);
+		const projectFileReaderInjector = optionsValidatorInjector.provideValue(commonTokens.options, options).provideClass(temporaryDirectory, TemporaryDirectory).provideClass("fs", FileSystem).provideValue(pluginsByKind, loadedPlugins.pluginsByKind);
+		const project$2 = await projectFileReaderInjector.injectClass(ProjectReader).read(targetMutatePatterns);
+		if (project$2.isEmpty) throw new ConfigError("No input files found.");
+		else {
+			await projectFileReaderInjector.resolve(temporaryDirectory).initialize();
+			return projectFileReaderInjector.provideValue(project, project$2).provideValue(commonTokens.fileDescriptions, project$2.fileDescriptions).provideClass(pluginCreator, PluginCreator).provideClass(reporter, BroadcastReporter).provideValue(timer, timer$1).provideValue(project, project$2).provideValue(execa, execaCommand).provideValue(process$1, process).provideClass(unexpectedExitRegistry, UnexpectedExitHandler).provideValue(pluginModulePaths, loadedPlugins.pluginModulePaths);
+		}
+	}
+};
+//#endregion
+//#region src/worker-pool/id-generator.ts
+var IdGenerator = class {
+	id = 0;
+	next() {
+		return this.id++;
+	}
+};
+//#endregion
+//#region src/run-stages/map.ts
+/**
+* Calls a defined callback function on each element of a map, and returns an array that contains the results.
+*
+* @param subject The map to act on
+* @param callbackFn The callback fn
+* @returns
+*/
+function map$1(subject, callbackFn) {
+	const results = [];
+	subject.forEach((value, key) => results.push(callbackFn(value, key)));
+	return results;
+}
+//#endregion
+//#region src/sandbox/disable-type-checks-preprocessor.ts
+/**
+* Disabled type checking by inserting `@ts-nocheck` atop TS/JS files and removing other @ts-xxx directives from comments:
+* @see https://github.com/stryker-mutator/stryker-js/issues/2438
+*/
+var DisableTypeChecksPreprocessor = class {
+	log;
+	options;
+	impl;
+	static inject = tokens(commonTokens.logger, commonTokens.options, disableTypeChecksHelper);
+	constructor(log, options, impl) {
+		this.log = log;
+		this.options = options;
+		this.impl = impl;
+	}
+	async preprocess(project) {
+		const matcher = new FileMatcher(this.options.disableTypeChecks);
+		let warningLogged = false;
+		await Promise.all(map$1(project.files, async (file, name) => {
+			if (matcher.matches(path.resolve(name))) try {
+				const { content } = await this.impl(await file.toInstrumenterFile(), { plugins: this.options.mutator.plugins ? [...this.options.mutator.plugins] : null });
+				file.setContent(content);
+			} catch (err) {
+				if (isWarningEnabled("preprocessorErrors", this.options.warnings)) {
+					warningLogged = true;
+					this.log.warn(`Unable to disable type checking for file "${name}". Shouldn't type checking be disabled for this file? Consider configuring a more restrictive "${optionsPath("disableTypeChecks")}" settings (or turn it completely off with \`false\`)`, err);
+				}
+			}
+		}));
+		if (warningLogged) this.log.warn(`(disable "${optionsPath("warnings", "preprocessorErrors")}" to ignore this warning`);
+	}
+};
+//#endregion
+//#region src/sandbox/multi-preprocessor.ts
+var MultiPreprocessor = class {
+	preprocessors;
+	constructor(preprocessors) {
+		this.preprocessors = preprocessors;
+	}
+	async preprocess(project) {
+		for (const preprocessor of this.preprocessors) await preprocessor.preprocess(project);
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@jsr+std__jsonc@1.0.2/node_modules/@jsr/std__jsonc/parse.js
+/**
+* Converts a JSON with Comments (JSONC) string into an object.
+*
+* @example Usage
+* ```ts
+* import { parse } from "@std/jsonc";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(parse('{"foo": "bar"}'), { foo: "bar" });
+* assertEquals(parse('{"foo": "bar", }'), { foo: "bar" });
+* assertEquals(parse('{"foo": "bar", } /* comment *\/'), { foo: "bar" });
+* ```
+*
+* @throws {SyntaxError} If the JSONC string is invalid.
+* @param text A valid JSONC string.
+* @returns The parsed JsonValue from the JSONC string.
+*/ function parse(text) {
+	if (new.target) throw new TypeError("Cannot create an instance: parse is not a constructor");
+	return new JsoncParser(text).parse();
+}
+var JsoncParser = class {
+	#whitespace = /* @__PURE__ */ new Set(" 	\r\n");
+	#numberEndToken = /* @__PURE__ */ new Set([..."[]{}:,/", ...this.#whitespace]);
+	#text;
+	#length;
+	#tokenized;
+	constructor(text) {
+		this.#text = `${text}`;
+		this.#length = this.#text.length;
+		this.#tokenized = this.#tokenize();
+	}
+	parse() {
+		const token = this.#getNext();
+		const res = this.#parseJsonValue(token);
+		const { done, value } = this.#tokenized.next();
+		if (!done) throw new SyntaxError(buildErrorMessage(value));
+		return res;
+	}
+	/** Read the next token. If the token is read to the end, it throws a SyntaxError. */ #getNext() {
+		const { done, value } = this.#tokenized.next();
+		if (done) throw new SyntaxError("Cannot parse JSONC: unexpected end of JSONC input");
+		return value;
+	}
+	/** Split the JSONC string into token units. Whitespace and comments are skipped. */ *#tokenize() {
+		for (let i = 0; i < this.#length; i++) {
+			if (this.#whitespace.has(this.#text[i])) continue;
+			if (this.#text[i] === "/" && this.#text[i + 1] === "*") {
+				i += 2;
+				let hasEndOfComment = false;
+				for (; i < this.#length; i++) if (this.#text[i] === "*" && this.#text[i + 1] === "/") {
+					hasEndOfComment = true;
+					break;
+				}
+				if (!hasEndOfComment) throw new SyntaxError("Cannot parse JSONC: unexpected end of JSONC input");
+				i++;
+				continue;
+			}
+			if (this.#text[i] === "/" && this.#text[i + 1] === "/") {
+				i += 2;
+				for (; i < this.#length; i++) if (this.#text[i] === "\n" || this.#text[i] === "\r") break;
+				continue;
+			}
+			switch (this.#text[i]) {
+				case "{":
+					yield {
+						type: "BeginObject",
+						position: i
+					};
+					break;
+				case "}":
+					yield {
+						type: "EndObject",
+						position: i
+					};
+					break;
+				case "[":
+					yield {
+						type: "BeginArray",
+						position: i
+					};
+					break;
+				case "]":
+					yield {
+						type: "EndArray",
+						position: i
+					};
+					break;
+				case ":":
+					yield {
+						type: "NameSeparator",
+						position: i
+					};
+					break;
+				case ",":
+					yield {
+						type: "ValueSeparator",
+						position: i
+					};
+					break;
+				case "\"": {
+					const startIndex = i;
+					let shouldEscapeNext = false;
+					i++;
+					for (; i < this.#length; i++) {
+						if (this.#text[i] === "\"" && !shouldEscapeNext) break;
+						shouldEscapeNext = this.#text[i] === "\\" && !shouldEscapeNext;
+					}
+					yield {
+						type: "String",
+						sourceText: this.#text.substring(startIndex, i + 1),
+						position: startIndex
+					};
+					break;
+				}
+				default: {
+					const startIndex = i;
+					for (; i < this.#length; i++) if (this.#numberEndToken.has(this.#text[i])) break;
+					i--;
+					yield {
+						type: "NullOrTrueOrFalseOrNumber",
+						sourceText: this.#text.substring(startIndex, i + 1),
+						position: startIndex
+					};
+				}
+			}
+		}
+	}
+	#parseJsonValue(value) {
+		switch (value.type) {
+			case "BeginObject": return this.#parseObject();
+			case "BeginArray": return this.#parseArray();
+			case "NullOrTrueOrFalseOrNumber": return this.#parseNullOrTrueOrFalseOrNumber(value);
+			case "String": return this.#parseString(value);
+			default: throw new SyntaxError(buildErrorMessage(value));
+		}
+	}
+	#parseObject() {
+		const target = {};
+		while (true) {
+			const token1 = this.#getNext();
+			if (token1.type === "EndObject") return target;
+			if (token1.type !== "String") throw new SyntaxError(buildErrorMessage(token1));
+			const key = this.#parseString(token1);
+			const token2 = this.#getNext();
+			if (token2.type !== "NameSeparator") throw new SyntaxError(buildErrorMessage(token2));
+			const token3 = this.#getNext();
+			Object.defineProperty(target, key, {
+				value: this.#parseJsonValue(token3),
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			const token4 = this.#getNext();
+			if (token4.type === "EndObject") return target;
+			if (token4.type !== "ValueSeparator") throw new SyntaxError(buildErrorMessage(token4));
+		}
+	}
+	#parseArray() {
+		const target = [];
+		while (true) {
+			const token1 = this.#getNext();
+			if (token1.type === "EndArray") return target;
+			target.push(this.#parseJsonValue(token1));
+			const token2 = this.#getNext();
+			if (token2.type === "EndArray") return target;
+			if (token2.type !== "ValueSeparator") throw new SyntaxError(buildErrorMessage(token2));
+		}
+	}
+	#parseString(value) {
+		let parsed;
+		try {
+			parsed = JSON.parse(value.sourceText);
+		} catch {
+			throw new SyntaxError(buildErrorMessage(value));
+		}
+		if (typeof parsed !== "string") throw new TypeError(`Parsed value is not a string: ${parsed}`);
+		return parsed;
+	}
+	#parseNullOrTrueOrFalseOrNumber(value) {
+		if (value.sourceText === "null") return null;
+		if (value.sourceText === "true") return true;
+		if (value.sourceText === "false") return false;
+		let parsed;
+		try {
+			parsed = JSON.parse(value.sourceText);
+		} catch {
+			throw new SyntaxError(buildErrorMessage(value));
+		}
+		if (typeof parsed !== "number") throw new TypeError(`Parsed value is not a number: ${parsed}`);
+		return parsed;
+	}
+};
+function buildErrorMessage({ type, sourceText, position }) {
+	let token = "";
+	switch (type) {
+		case "BeginObject":
+			token = "{";
+			break;
+		case "EndObject":
+			token = "}";
+			break;
+		case "BeginArray":
+			token = "[";
+			break;
+		case "EndArray":
+			token = "]";
+			break;
+		case "NameSeparator":
+			token = ":";
+			break;
+		case "ValueSeparator":
+			token = ",";
+			break;
+		case "NullOrTrueOrFalseOrNumber":
+		case "String": token = 30 < sourceText.length ? `${sourceText.slice(0, 30)}...` : sourceText;
+	}
+	return `Cannot parse JSONC: unexpected token "${token}" in JSONC at position ${position}`;
+}
+//#endregion
+//#region src/sandbox/parse-config.schema.ts
+/**
+* Error returned when a tsconfig file fails to parse, or parses to a value that
+* does not match the shape this package consumes.
+*/
+var TsConfigParseError = class extends Schema.TaggedError()("TsConfigParseError", {
+	file: Schema.String,
+	reason: Schema.String
+}) {};
+const JsonRecord = Schema.Record(Schema.String, Schema.Unknown);
+/**
+* The tsconfig shape this package reads and rewrites in the sandbox.
+*
+* The index signature keeps every key the schema does not declare — including
+* `compilerOptions` and `$schema` — so unknown keys survive the write-back untouched.
+* `S.mutableKey` keeps the fields the preprocessor rewrites writable (v4's `mutable`
+* only covers arrays), and `S.mutable` keeps the parsed arrays themselves mutable so
+* `TSConfigPreprocessor` can assign rewritten values back onto the config.
+*/
+const TsConfigSchema = Schema.StructWithRest(Schema.Struct({
+	extends: Schema.mutableKey(Schema.optional(Schema.Union([Schema.String, Schema.Array(Schema.String)]))),
+	references: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.StructWithRest(Schema.Struct({ path: Schema.mutableKey(Schema.String) }), [JsonRecord]))))),
+	files: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.String)))),
+	include: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.String)))),
+	exclude: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.String))))
+}), [JsonRecord]);
+/** A tsconfig `extends` entry list: the array form of `extends`. */
+const ExtendsArraySchema = Schema.Array(Schema.String);
+//#endregion
+//#region src/sandbox/parse-config-helper.ts
+/**
+* Inline replacement for `ts.parseConfigFileTextToJson()` removed in TypeScript 7.
+*
+* No imports from `typescript` — delegates to `@std/jsonc`, which handles comments,
+* trailing commas, and string-aware escaping the way `tsc` does. The parsed value is
+* then shape-checked with an Effect Schema type guard, so consumers receive a config
+* that is already narrowed to the fields this package rewrites.
+*/
+/**
+* Parses a JSONC string into a typed tsconfig.
+*
+* @param fileName — used only for error message context (mirrors upstream behaviour).
+* @param jsonText — the raw tsconfig text, possibly containing comments.
+* @returns `Result.success(config)` when the text parses and matches the shape,
+*          `Result.failure(TsConfigParseError)` on a parse failure or a shape mismatch.
+*/
+function parseTsConfig(fileName, jsonText) {
+	let parsed;
+	try {
+		parsed = parse(jsonText.replace(/^\uFEFF/, ""));
+	} catch (error) {
+		return Result.fail(new TsConfigParseError({
+			file: fileName,
+			reason: errorToString(error)
+		}));
+	}
+	if (Schema.is(TsConfigSchema)(parsed)) return Result.succeed(parsed);
+	return Result.fail(new TsConfigParseError({
+		file: fileName,
+		reason: `parsed to ${JSON.stringify(parsed)}, which does not match the tsconfig shape this package consumes`
+	}));
+}
+//#endregion
+//#region src/sandbox/resolve-reference-helper.ts
+function resolveProjectReferencePath(ref) {
+	return ref.path.endsWith(".json") ? ref.path : `${ref.path}/tsconfig.json`;
+}
+//#endregion
+//#region src/sandbox/ts-config-preprocessor.ts
+/**
+* A helper class that rewrites `references` and `extends` file paths if they end up falling outside of the sandbox.
+* @example
+* {
+*   "extends": "../../tsconfig.settings.json",
+*   "references": {
+*      "path": "../model"
+*   }
+* }
+* becomes:
+* {
+*   "extends": "../../../../tsconfig.settings.json",
+*   "references": {
+*      "path": "../../../model"
+*   }
+* }
+*/
+var TSConfigPreprocessor = class {
+	log;
+	options;
+	touched = /* @__PURE__ */ new Set();
+	static inject = tokens(commonTokens.logger, commonTokens.options);
+	constructor(log, options) {
+		this.log = log;
+		this.options = options;
+	}
+	async preprocess(project) {
+		if (this.options.inPlace) return;
+		else {
+			this.touched.clear();
+			await this.rewriteTSConfigFile(project, path.resolve(this.options.tsconfigFile));
+		}
+	}
+	async rewriteTSConfigFile(project, tsconfigFileName) {
+		if (!this.touched.has(tsconfigFileName)) {
+			this.touched.add(tsconfigFileName);
+			const tsconfigFile = project.files.get(tsconfigFileName);
+			if (tsconfigFile) {
+				this.log.debug("Rewriting file %s", tsconfigFile);
+				const parsed = parseTsConfig(tsconfigFileName, await tsconfigFile.readContent());
+				if (Result.isSuccess(parsed)) {
+					const config = parsed.success;
+					await this.rewriteExtends(project, config, tsconfigFileName);
+					await this.rewriteProjectReferences(project, config, tsconfigFileName);
+					this.rewriteFileArrayProperty(config, tsconfigFileName, "include");
+					this.rewriteFileArrayProperty(config, tsconfigFileName, "exclude");
+					this.rewriteFileArrayProperty(config, tsconfigFileName, "files");
+					tsconfigFile.setContent(JSON.stringify(config, null, 2));
+				} else {
+					const error = parsed.failure;
+					this.log.warn(`Could not rewrite tsconfig file "%s": %s. Its extends, project references, and file array properties were not rewritten for the sandbox, so this file still points at paths outside it.`, tsconfigFileName, error.reason);
+				}
+			}
+		}
+	}
+	async rewriteExtends(project, config, tsconfigFileName) {
+		const extend = config.extends;
+		if (typeof extend === "string") config.extends = await this.rewriteExtendsEntry(project, extend, tsconfigFileName);
+		else if (Schema.is(ExtendsArraySchema)(extend)) {
+			const rewritten = [];
+			for (const entry of extend) rewritten.push(await this.rewriteExtendsEntry(project, entry, tsconfigFileName));
+			config.extends = rewritten;
+		}
+	}
+	async rewriteExtendsEntry(project, extend, tsconfigFileName) {
+		const rewritten = this.tryRewriteReference(extend, tsconfigFileName);
+		if (rewritten) return rewritten;
+		await this.rewriteTSConfigFile(project, path.resolve(path.dirname(tsconfigFileName), extend));
+		return extend;
+	}
+	rewriteFileArrayProperty(config, tsconfigFileName, prop) {
+		const fileArray = config[prop];
+		if (Array.isArray(fileArray)) config[prop] = fileArray.map((pattern) => {
+			const rewritten = this.tryRewriteReference(pattern, tsconfigFileName);
+			if (rewritten) return rewritten;
+			else return pattern;
+		});
+	}
+	async rewriteProjectReferences(project, config, originTSConfigFileName) {
+		if (Array.isArray(config.references)) for (const reference of config.references) {
+			const referencePath = resolveProjectReferencePath(reference);
+			const rewritten = this.tryRewriteReference(referencePath, originTSConfigFileName);
+			if (rewritten) reference.path = rewritten;
+			else await this.rewriteTSConfigFile(project, path.resolve(path.dirname(originTSConfigFileName), referencePath));
+		}
+	}
+	tryRewriteReference(reference, originTSConfigFileName) {
+		const dirName = path.dirname(originTSConfigFileName);
+		const fileName = path.resolve(dirName, reference);
+		if (path.relative(process.cwd(), fileName).startsWith("..")) return this.join("..", "..", reference);
+		return false;
+	}
+	join(...pathSegments) {
+		return pathSegments.map((segment) => segment.replace(/\\/g, "/")).join("/");
+	}
+};
+//#endregion
+//#region src/sandbox/create-preprocessor.ts
+createPreprocessor.inject = tokens(commonTokens.injector);
+function createPreprocessor(injector) {
+	return new MultiPreprocessor([injector.provideValue(disableTypeChecksHelper, disableTypeChecks).injectClass(DisableTypeChecksPreprocessor), injector.injectClass(TSConfigPreprocessor)]);
+}
+//#endregion
+//#region src/sandbox/sandbox.ts
+async function findNodeModulesList(basePath, tempDirName) {
+	const nodeModulesList = [];
+	const dirBfsQueue = ["."];
+	let dir;
+	while (dir = dirBfsQueue.pop()) {
+		if (path.basename(dir) === tempDirName) continue;
+		if (path.basename(dir) === "node_modules") {
+			nodeModulesList.push(dir);
+			continue;
+		}
+		const parentDir = dir;
+		const dirs = (await fs.promises.readdir(path.join(basePath, dir), { withFileTypes: true })).filter((file) => file.isDirectory()).map((childDir) => path.join(parentDir, childDir.name));
+		dirBfsQueue.push(...dirs);
+	}
+	return nodeModulesList;
+}
+async function symlinkJunction(to, from) {
+	await fs.promises.mkdir(path.dirname(from), { recursive: true });
+	return fs.promises.symlink(to, from, "junction");
+}
+/**
+* Recursively walks the from directory and copy the content to the target directory synchronously
+* @param from The source directory to move from
+* @param to The target directory to move to
+*/
+function moveDirectoryRecursiveSync(from, to) {
+	if (!fs.existsSync(from)) return;
+	if (!fs.existsSync(to)) fs.mkdirSync(to);
+	const files = fs.readdirSync(from);
+	for (const file of files) {
+		const fromFileName = path.join(from, file);
+		const toFileName = path.join(to, file);
+		if (fs.lstatSync(fromFileName).isFile()) fs.renameSync(fromFileName, toFileName);
+		else moveDirectoryRecursiveSync(fromFileName, toFileName);
+	}
+	fs.rmdirSync(from);
+}
+var Sandbox = class {
+	options;
+	log;
+	project;
+	execCommand;
+	fileMap = /* @__PURE__ */ new Map();
+	/**
+	* The working directory for this sandbox
+	* Either an actual sandbox directory, or the cwd when running in --inPlace mode
+	*/
+	workingDirectory;
+	/** 11
+	* The backup directory when running in --inPlace mode
+	*/
+	backupDirectory = "";
+	static inject = tokens(commonTokens.options, commonTokens.logger, temporaryDirectory, project, execa, unexpectedExitRegistry);
+	/**
+	* @param temporaryDirectory The sandbox dir or the backup dir when running in `--inPlace` mode
+	*/
+	constructor(options, log, temporaryDirectory, project, execCommand, unexpectedExitHandler) {
+		this.options = options;
+		this.log = log;
+		this.project = project;
+		this.execCommand = execCommand;
+		if (options.inPlace) {
+			this.workingDirectory = process.cwd();
+			this.backupDirectory = temporaryDirectory.path;
+			this.log.info("In place mode is enabled, Stryker will be overriding YOUR files. Find your backup at: %s", path.relative(process.cwd(), this.backupDirectory));
+			unexpectedExitHandler.registerHandler(this.dispose.bind(this, true));
+		} else {
+			this.workingDirectory = temporaryDirectory.path;
+			this.log.debug("Creating a sandbox for files in %s", this.workingDirectory);
+		}
+	}
+	async init() {
+		await this.fillSandbox();
+		await this.runBuildCommand();
+		await this.symlinkNodeModulesIfNeeded();
+	}
+	sandboxFileFor(fileName) {
+		const sandboxFileName = this.fileMap.get(fileName);
+		if (sandboxFileName === void 0) throw new Error(`Cannot find sandbox file for ${fileName}`);
+		return sandboxFileName;
+	}
+	originalFileFor(sandboxFileName) {
+		return path.resolve(sandboxFileName).replace(path.resolve(this.workingDirectory), process.cwd());
+	}
+	async fillSandbox() {
+		await Promise.all(map$1(this.project.files, (file, name) => this.sandboxFile(name, file)));
+	}
+	async runBuildCommand() {
+		if (this.options.buildCommand) {
+			const env = npmRunPathEnv();
+			this.log.info("Running build command \"%s\" in \"%s\".", this.options.buildCommand, this.workingDirectory);
+			this.log.debug("(using PATH: %s)", env["PATH"]);
+			await this.execCommand(this.options.buildCommand, {
+				cwd: this.workingDirectory,
+				env
+			});
+		}
+	}
+	async symlinkNodeModulesIfNeeded() {
+		this.log.debug("Start symlink node_modules");
+		if (this.options.symlinkNodeModules && !this.options.inPlace) {
+			const basePath = process.cwd();
+			const nodeModulesList = await findNodeModulesList(basePath, this.options.tempDirName);
+			if (nodeModulesList.length > 0) for (const nodeModules of nodeModulesList) {
+				this.log.debug(`Create symlink from ${path.resolve(nodeModules)} to ${path.join(this.workingDirectory, nodeModules)}`);
+				await symlinkJunction(path.resolve(nodeModules), path.join(this.workingDirectory, nodeModules)).catch((error) => {
+					if (isErrnoException(error) && error.code === "EEXIST") this.log.warn(normalizeWhitespaces(`Could not symlink "${nodeModules}" in sandbox directory,
+              it is already created in the sandbox. Please remove the node_modules from your sandbox files.
+              Alternatively, set \`symlinkNodeModules\` to \`false\` to disable this warning.`));
+					else this.log.warn(`Unexpected error while trying to symlink "${nodeModules}" in sandbox directory.`, error);
+				});
+			}
+			else this.log.debug(`Could not find a node_modules folder to symlink into the sandbox directory. Search "${basePath}" and its parent directories`);
+		}
+	}
+	/**
+	* Sandboxes a file (writes it to the sandbox). Either in-place, or an actual sandbox directory.
+	* @param name The name of the file
+	* @param file The file reference
+	*/
+	async sandboxFile(name, file) {
+		if (this.options.inPlace) {
+			if (file.hasChanges) {
+				const backupFileName = await file.backupTo(this.backupDirectory);
+				this.log.debug("Stored backup file at %s", backupFileName);
+				await file.writeInPlace();
+			}
+			this.fileMap.set(name, name);
+		} else {
+			const targetFileName = await file.writeToSandbox(this.workingDirectory);
+			this.fileMap.set(name, targetFileName);
+		}
+	}
+	dispose(unexpected = false) {
+		if (this.backupDirectory) {
+			if (unexpected) console.error(`Detecting unexpected exit, recovering original files from ${path.relative(process.cwd(), this.backupDirectory)}`);
+			else this.log.info(`Resetting your original files from ${path.relative(process.cwd(), this.backupDirectory)}.`);
+			moveDirectoryRecursiveSync(this.backupDirectory, this.workingDirectory);
+		}
+	}
+};
+//#endregion
+//#region src/mutants/mutant-test-planner.ts
+/**
+* The factor by which hit count from dry run is multiplied to calculate the hit limit for a mutant.
+* This is intentionally a high value to prevent false positives.
+*
+* For example, a property testing library might execute a failing scenario multiple times to determine the smallest possible counterexample.
+* @see https://jsverify.github.io/#minimal-counterexample
+*/
+const HIT_LIMIT_FACTOR = 100;
+/**
+* Responsible for determining the tests to execute for each mutant, as well as other run option specific details
+*/
+var MutantTestPlanner = class {
+	testCoverage;
+	incrementalDiffer;
+	reporter;
+	sandbox;
+	project;
+	timeOverheadMS;
+	options;
+	logger;
+	static inject = tokens(testCoverage, incrementalDiffer, reporter, sandbox, project, timeOverheadMS, commonTokens.options, commonTokens.logger);
+	timeSpentAllTests;
+	globalTestFilter;
+	constructor(testCoverage, incrementalDiffer, reporter, sandbox, project, timeOverheadMS, options, logger) {
+		this.testCoverage = testCoverage;
+		this.incrementalDiffer = incrementalDiffer;
+		this.reporter = reporter;
+		this.sandbox = sandbox;
+		this.project = project;
+		this.timeOverheadMS = timeOverheadMS;
+		this.options = options;
+		this.logger = logger;
+		this.timeSpentAllTests = calculateTotalTime(this.testCoverage.testsById.values());
+		this.globalTestFilter = this.project.testFiles.length > 0 ? this.project.testFiles.map((file) => this.sandbox.sandboxFileFor(file)) : void 0;
+	}
+	async makePlan(mutants) {
+		const mutantPlans = (await this.incrementalDiff(mutants)).map((mutant) => this.planMutant(mutant));
+		this.reporter.onMutationTestingPlanReady({ mutantPlans });
+		this.warnAboutSlow(mutantPlans);
+		return mutantPlans;
+	}
+	planMutant(mutant) {
+		const isStatic = this.testCoverage.hasStaticCoverage(mutant.id);
+		if (mutant.status) return this.createMutantEarlyResultPlan(mutant, {
+			isStatic,
+			...mutant.coveredBy === void 0 ? {} : { coveredBy: mutant.coveredBy },
+			...mutant.killedBy === void 0 ? {} : { killedBy: mutant.killedBy },
+			status: mutant.status,
+			...mutant.statusReason === void 0 ? {} : { statusReason: mutant.statusReason }
+		});
+		else if (this.testCoverage.hasCoverage) {
+			const tests = this.testCoverage.testsByMutantId.get(mutant.id) ?? [];
+			const coveredBy = toTestIds(tests);
+			if (!isStatic || this.options.ignoreStatic && coveredBy.length) {
+				const netTime = calculateTotalTime(tests);
+				return this.createMutantRunPlan(mutant, {
+					netTime,
+					coveredBy,
+					isStatic,
+					testFilter: coveredBy
+				});
+			} else if (this.options.ignoreStatic) return this.createMutantEarlyResultPlan(mutant, {
+				status: "Ignored",
+				statusReason: "Static mutant (and \"ignoreStatic\" was enabled)",
+				isStatic,
+				coveredBy
+			});
+			else return this.createMutantRunPlan(mutant, {
+				netTime: this.timeSpentAllTests,
+				isStatic,
+				coveredBy,
+				testFilter: this.globalTestFilter
+			});
+		} else return this.createMutantRunPlan(mutant, {
+			netTime: this.timeSpentAllTests,
+			testFilter: this.globalTestFilter
+		});
+	}
+	createMutantEarlyResultPlan(mutant, { isStatic, status, statusReason, coveredBy, killedBy }) {
+		return {
+			plan: PlanKind.EarlyResult,
+			mutant: {
+				...mutant,
+				status,
+				...isStatic === void 0 ? {} : { static: isStatic },
+				...statusReason === void 0 ? {} : { statusReason },
+				...coveredBy === void 0 ? {} : { coveredBy },
+				...killedBy === void 0 ? {} : { killedBy }
+			}
+		};
+	}
+	createMutantRunPlan(mutant, { netTime, testFilter, isStatic, coveredBy }) {
+		const { disableBail, timeoutMS, timeoutFactor } = this.options;
+		const timeout = timeoutFactor * netTime + timeoutMS + this.timeOverheadMS;
+		const hitCount = this.testCoverage.hitsByMutantId.get(mutant.id);
+		const hitLimit = hitCount === void 0 ? void 0 : hitCount * HIT_LIMIT_FACTOR;
+		const canHotSwap = !!testFilter && isStatic === false;
+		return {
+			plan: PlanKind.Run,
+			netTime,
+			mutant: {
+				...mutant,
+				...isStatic === void 0 ? {} : { static: isStatic },
+				...coveredBy === void 0 ? {} : { coveredBy }
+			},
+			runOptions: {
+				activeMutant: {
+					id: mutant.id,
+					fileName: mutant.fileName,
+					location: mutant.location,
+					mutatorName: mutant.mutatorName,
+					replacement: mutant.replacement
+				},
+				mutantActivation: testFilter ? "runtime" : "static",
+				timeout,
+				...testFilter === void 0 ? {} : { testFilter },
+				sandboxFileName: this.sandbox.sandboxFileFor(mutant.fileName),
+				...hitLimit === void 0 ? {} : { hitLimit },
+				disableBail,
+				reloadEnvironment: !canHotSwap
+			}
+		};
+	}
+	warnAboutSlow(mutantPlans) {
+		if (!this.options.ignoreStatic && isWarningEnabled("slow", this.options.warnings)) {
+			const ABSOLUTE_CUT_OFF_PERUNAGE = .4;
+			const RELATIVE_CUT_OFF_FACTOR = 2;
+			const zeroIfNaN = (n) => isNaN(n) ? 0 : n;
+			const totalNetTime = (runPlans) => runPlans.reduce((acc, { netTime }) => acc + netTime, 0);
+			const runPlans = mutantPlans.filter(isRunPlan);
+			const [staticRunPlans, runTimeRunPlans] = split(runPlans, ({ mutant }) => Boolean(mutant.static));
+			const estimatedTimeForStaticMutants = totalNetTime(staticRunPlans);
+			const estimatedTimeForRunTimeMutants = totalNetTime(runTimeRunPlans);
+			const estimatedTotalTime = estimatedTimeForRunTimeMutants + estimatedTimeForStaticMutants;
+			const avgTimeForAStaticMutant = zeroIfNaN(estimatedTimeForStaticMutants / staticRunPlans.length);
+			const avgTimeForARunTimeMutant = zeroIfNaN(estimatedTimeForRunTimeMutants / runTimeRunPlans.length);
+			const relativeTimeForStaticMutants = estimatedTimeForStaticMutants / estimatedTotalTime;
+			const absoluteCondition = relativeTimeForStaticMutants >= ABSOLUTE_CUT_OFF_PERUNAGE;
+			if (avgTimeForAStaticMutant >= RELATIVE_CUT_OFF_FACTOR * avgTimeForARunTimeMutant && absoluteCondition) {
+				const percentage = (perunage) => Math.round(perunage * 100);
+				this.logger.warn(`Detected ${staticRunPlans.length} static mutants (${percentage(staticRunPlans.length / runPlans.length)}% of total) that are estimated to take ${percentage(relativeTimeForStaticMutants)}% of the time running the tests!\n  You might want to enable "ignoreStatic" to ignore these static mutants for your next run. \n  For more information about static mutants visit: https://stryker-mutator.io/docs/mutation-testing-elements/static-mutants\n  (disable "${optionsPath("warnings", "slow")}" to ignore this warning)`);
+			}
+		}
+	}
+	async incrementalDiff(currentMutants) {
+		const { incrementalReport } = this.project;
+		if (incrementalReport) {
+			const currentFiles = await this.readAllOriginalFiles(currentMutants, this.testCoverage.testsById.values(), Object.keys(incrementalReport.files), Object.keys(incrementalReport.testFiles ?? {}));
+			return this.incrementalDiffer.diff(currentMutants, this.testCoverage, incrementalReport, currentFiles);
+		}
+		return currentMutants;
+	}
+	async readAllOriginalFiles(...thingsWithFileNamesOrFileNames) {
+		const uniqueFileNames = [...new Set(thingsWithFileNamesOrFileNames.flatMap((container) => [...container].map((thing) => typeof thing === "string" ? thing : thing.fileName)).filter(notEmpty).map((fileName) => path.resolve(fileName)))];
+		const result = await Promise.all(uniqueFileNames.map(async (fileName) => {
+			const originalContent = await this.project.files.get(fileName)?.readOriginal();
+			if (originalContent) return [toRelativeNormalizedFileName(fileName), originalContent];
+			else return;
+		}));
+		return new Map(result.filter(notEmpty));
+	}
+};
+function calculateTotalTime(testResults) {
+	let total = 0;
+	for (const test of testResults) total += test.timeSpentMs;
+	return total;
+}
+function toTestIds(testResults) {
+	const result = [];
+	for (const test of testResults) result.push(test.id);
+	return result;
+}
+function isEarlyResult(mutantPlan) {
+	return mutantPlan.plan === PlanKind.EarlyResult;
+}
+function isRunPlan(mutantPlan) {
+	return mutantPlan.plan === PlanKind.Run;
+}
+//#endregion
+//#region src/reporting/mutation-test-report-helper.ts
+const STRYKER_FRAMEWORK = Object.freeze({
+	name: "StrykerJS",
+	version: strykerVersion,
+	branding: {
+		homepageUrl: "https://stryker-mutator.io",
+		imageUrl: "data:image/svg+xml;utf8,%3Csvg viewBox='0 0 1458 1458' xmlns='http://www.w3.org/2000/svg' fill-rule='evenodd' clip-rule='evenodd' stroke-linejoin='round' stroke-miterlimit='2'%3E%3Cpath fill='none' d='M0 0h1458v1458H0z'/%3E%3CclipPath id='a'%3E%3Cpath d='M0 0h1458v1458H0z'/%3E%3C/clipPath%3E%3Cg clip-path='url(%23a)'%3E%3Cpath d='M1458 729c0 402.655-326.345 729-729 729S0 1131.655 0 729C0 326.445 326.345 0 729 0s729 326.345 729 729' fill='%23e74c3c' fill-rule='nonzero'/%3E%3Cpath d='M778.349 1456.15L576.6 1254.401l233-105 85-78.668v-64.332l-257-257-44-187-50-208 251.806-82.793L1076.6 389.401l380.14 379.15c-19.681 367.728-311.914 663.049-678.391 687.599z' fill-opacity='.3'/%3E%3Cpath d='M753.4 329.503c41.79 0 74.579 7.83 97.925 25.444 23.571 18.015 41.69 43.956 55.167 77.097l11.662 28.679 165.733-58.183-14.137-32.13c-26.688-60.655-64.896-108.61-114.191-144.011-49.329-35.423-117.458-54.302-204.859-54.302-50.78 0-95.646 7.376-134.767 21.542-40.093 14.671-74.09 34.79-102.239 60.259-28.84 26.207-50.646 57.06-65.496 92.701-14.718 35.052-22.101 72.538-22.101 112.401 0 72.536 20.667 133.294 61.165 182.704 38.624 47.255 98.346 88.037 179.861 121.291 42.257 17.475 78.715 33.125 109.227 46.994 27.193 12.361 49.294 26.124 66.157 41.751 15.309 14.186 26.497 30.584 33.63 49.258 7.721 20.214 11.16 45.69 11.16 76.402 0 28.021-4.251 51.787-13.591 71.219-8.832 18.374-20.171 33.178-34.523 44.219-14.787 11.374-31.193 19.591-49.393 24.466-19.68 5.359-39.14 7.993-58.69 7.993-29.359 0-54.387-3.407-75.182-10.747-20.112-7.013-37.144-16.144-51.259-27.486-13.618-11.009-24.971-23.766-33.744-38.279-9.64-15.8-17.272-31.924-23.032-48.408l-10.965-31.376-161.669 60.585 10.734 30.124c10.191 28.601 24.197 56.228 42.059 82.748 18.208 27.144 41.322 51.369 69.525 72.745 27.695 21.075 60.904 38.218 99.481 51.041 37.777 12.664 82.004 19.159 132.552 19.159 49.998 0 95.818-8.321 137.611-24.622 42.228-16.471 78.436-38.992 108.835-67.291 30.719-28.597 54.631-62.103 71.834-100.642 17.263-38.56 25.923-79.392 25.923-122.248 0-54.339-8.368-100.37-24.208-138.32-16.29-38.759-38.252-71.661-65.948-98.797-26.965-26.418-58.269-48.835-93.858-67.175-33.655-17.241-69.196-33.11-106.593-47.533-35.934-13.429-65.822-26.601-89.948-39.525-22.153-11.868-40.009-24.21-53.547-37.309-11.429-11.13-19.83-23.678-24.718-37.664-5.413-15.49-7.98-33.423-7.98-53.577 0-40.883 11.293-71.522 37.086-90.539 28.443-20.825 64.985-30.658 109.311-30.658z' fill='%23f1c40f' fill-rule='nonzero'/%3E%3Cpath d='M720 0h18v113h-18zM1458 738v-18h-113v18h113zM720 1345h18v113h-18zM113 738v-18H0v18h113z'/%3E%3C/g%3E%3C/svg%3E"
+	}
+});
+/**
+* Converts an internal StrykerJS 0-based location to a schema.Location (1-based).
+* @param location the StrykerJS 0-based location
+* @returns the schema.Location (1-based)
+*/
+function toSchemaLocation(location) {
+	return {
+		end: toSchemaPosition(location.end),
+		start: toSchemaPosition(location.start)
+	};
+}
+/**
+* Converts an internal StrykerJS 0-based position to a schema.Position (1-based).
+* @param pos the StrykerJS 0-based position
+* @returns the schema.Position (1-based)
+*/
+function toSchemaPosition(pos) {
+	return {
+		column: pos.column + 1,
+		line: pos.line + 1
+	};
+}
+/**
+* A helper class to convert and report mutants that survived or get killed
+*/
+var MutationTestReportHelper = class {
+	reporter;
+	options;
+	project;
+	log;
+	testCoverage;
+	fs;
+	requireFromCwd;
+	runEventSink;
+	runId;
+	resolvedMode;
+	static inject = tokens(reporter, commonTokens.options, project, commonTokens.logger, testCoverage, "fs", requireFromCwd, runEventSink, runId, resolvedMode);
+	constructor(reporter, options, project, log, testCoverage, fs, requireFromCwd, runEventSink, runId, resolvedMode) {
+		this.reporter = reporter;
+		this.options = options;
+		this.project = project;
+		this.log = log;
+		this.testCoverage = testCoverage;
+		this.fs = fs;
+		this.requireFromCwd = requireFromCwd;
+		this.runEventSink = runEventSink;
+		this.runId = runId;
+		this.resolvedMode = resolvedMode;
+	}
+	reportCheckFailed(mutant, checkResult) {
+		const location = toSchemaLocation(mutant.location);
+		return this.reportOne({
+			...mutant,
+			status: this.checkStatusToResultStatus(checkResult.status),
+			statusReason: checkResult.reason,
+			location
+		});
+	}
+	reportMutantStatus(mutant, status) {
+		const location = toSchemaLocation(mutant.location);
+		return this.reportOne({
+			...mutant,
+			status,
+			location
+		});
+	}
+	reportMutantRunResult(mutant, result) {
+		const location = toSchemaLocation(mutant.location);
+		switch (result.status) {
+			case MutantRunStatus.Error: return this.reportOne({
+				...mutant,
+				status: "RuntimeError",
+				statusReason: result.errorMessage,
+				location
+			});
+			case MutantRunStatus.Killed: return this.reportOne({
+				...mutant,
+				status: "Killed",
+				testsCompleted: result.nrOfTests,
+				killedBy: result.killedBy,
+				statusReason: result.failureMessage,
+				location
+			});
+			case MutantRunStatus.Timeout: return this.reportOne({
+				...mutant,
+				status: "Timeout",
+				...result.reason === void 0 ? {} : { statusReason: result.reason },
+				location
+			});
+			case MutantRunStatus.Survived: return this.reportOne({
+				...mutant,
+				status: "Survived",
+				testsCompleted: result.nrOfTests,
+				location
+			});
+		}
+	}
+	reportOne(result) {
+		this.reporter.onMutantTested(result);
+		return result;
+	}
+	checkStatusToResultStatus(status) {
+		switch (status) {
+			case CheckStatus.CompileError: return "CompileError";
+		}
+	}
+	async reportAll(results) {
+		const report = await this.mutationTestReport(results);
+		const metrics = calculateMutationTestMetrics(report);
+		this.reporter.onMutationTestReportReady(report, metrics);
+		if (this.options.incremental) {
+			await this.fs.mkdir(path.dirname(this.options.incrementalFile), { recursive: true });
+			await this.fs.writeFile(this.options.incrementalFile, JSON.stringify(report, null, 2), "utf-8");
+		}
+		this.determineExitCode(metrics);
+		this.determineTestContribution(report);
+		this.emitVerdict(report);
+	}
+	/**
+	* Emits the verdict envelope as the terminal `verdict` run event at the
+	* end of a run (U4). Core always pushes; whether the event renders — and
+	* as what — is the host sink's decision, never core's. The run id comes
+	* from the host alongside the sink, so the verdict matches the header and
+	* every stream line of this run — never a fresh id (KTD11/U6).
+	*/
+	emitVerdict(report) {
+		this.runEventSink({
+			kind: "verdict",
+			...buildVerdictEnvelope(report, this.resolvedMode.mode, this.resolvedMode.signal, this.runId)
+		});
+	}
+	determineTestContribution(report) {
+		const verdict = judgeTestContribution(report, this.options["requireTestContribution"], this.options.disableBail);
+		if (verdict === void 0) {
+			this.log.debug("No test contribution required. Won't fail the build for a test file that kills nothing another test file does not also kill. Set `requireTestContribution` to change this behavior.");
+			return;
+		}
+		if (!verdict.failed) {
+			this.log.info(verdict.message);
+			return;
+		}
+		this.log.error(`${verdict.message}\nSetting exit code to 1 (failure).`);
+		this.log.info("(sharpen or delete them, or set `requireTestContribution = null` to prevent this error in the future)");
+		setPendingExitClass(1);
+	}
+	determineExitCode(metrics) {
+		const { mutationScore } = metrics.systemUnderTestMetrics.metrics;
+		const breaking = this.options.thresholds.break;
+		const formattedScore = mutationScore.toFixed(2);
+		if (typeof breaking === "number") {
+			if (mutationScore < breaking) {
+				this.log.error(`Final mutation score ${formattedScore} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`);
+				this.log.info("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)");
+				setPendingExitClass(1);
+			} else this.log.info(`Final mutation score of ${formattedScore} is greater than or equal to break threshold ${String(breaking)}`);
+		} else this.log.debug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.");
+	}
+	async mutationTestReport(results) {
+		const testIdMap = new Map([...this.testCoverage.testsById.values()].map((test, index) => [test.id, index.toString()]));
+		const remapTestId = (id) => testIdMap.get(id) ?? id;
+		const remapTestIds = (ids) => ids?.map(remapTestId);
+		return {
+			files: await this.toFileResults(results, remapTestIds),
+			schemaVersion: "1.0",
+			thresholds: this.options.thresholds,
+			testFiles: await this.toTestFiles(remapTestId),
+			projectRoot: process.cwd(),
+			config: this.options,
+			framework: {
+				...STRYKER_FRAMEWORK,
+				dependencies: this.discoverDependencies()
+			}
+		};
+	}
+	async toFileResults(results, remapTestIds) {
+		const fileResultsByName = new Map(await Promise.all([...new Set(results.map(({ fileName }) => fileName))].map(async (fileName) => [fileName, await this.toFileResult(fileName)])));
+		return results.reduce((acc, mutantResult) => {
+			const reportFileName = normalizeReportFileName(mutantResult.fileName);
+			let fileResult = acc[reportFileName];
+			if (fileResult === void 0) {
+				const prepared = fileResultsByName.get(mutantResult.fileName);
+				if (prepared === void 0) throw new Error(`No file result prepared for ${mutantResult.fileName}`);
+				acc[reportFileName] = prepared;
+				fileResult = prepared;
+			}
+			fileResult.mutants.push(this.toMutantResult(mutantResult, remapTestIds));
+			return acc;
+		}, {});
+	}
+	async toTestFiles(remapTestId) {
+		const testFilesByName = new Map(await Promise.all([...new Set([...this.testCoverage.testsById.values()].map(({ fileName }) => fileName))].map(async (fileName) => [normalizeReportFileName(fileName), await this.toTestFile(fileName)])));
+		return [...this.testCoverage.testsById.values()].reduce((acc, testResult) => {
+			const test = this.toTestDefinition(testResult, remapTestId);
+			const reportFileName = normalizeReportFileName(testResult.fileName);
+			let testFile = acc[reportFileName];
+			if (testFile === void 0) {
+				const prepared = testFilesByName.get(reportFileName);
+				if (prepared === void 0) throw new Error(`No test file prepared for ${reportFileName}`);
+				acc[reportFileName] = prepared;
+				testFile = prepared;
+			}
+			testFile.tests.push(test);
+			return acc;
+		}, {});
+	}
+	async toFileResult(fileName) {
+		const fileResult = {
+			language: this.determineLanguage(fileName),
+			mutants: [],
+			source: ""
+		};
+		const sourceFile = this.project.files.get(fileName);
+		if (sourceFile) fileResult.source = await sourceFile.readOriginal();
+		else this.log.warn(normalizeWhitespaces(`File "${fileName}" not found
+    in input files, but did receive mutant result for it. This shouldn't happen`));
+		return fileResult;
+	}
+	async toTestFile(fileName) {
+		const testFile = { tests: [] };
+		if (fileName) {
+			const file = this.project.files.get(fileName);
+			if (file) testFile.source = await file.readOriginal();
+			else this.log.warn(normalizeWhitespaces(`Test file "${fileName}" not found
+        in input files, but did receive test result for it. This shouldn't happen.`));
+		}
+		return testFile;
+	}
+	toTestDefinition(test, remapTestId) {
+		return {
+			id: remapTestId(test.id),
+			name: test.name,
+			...test.startPosition === void 0 ? {} : { location: { start: toSchemaPosition(test.startPosition) } }
+		};
+	}
+	determineLanguage(name) {
+		switch (path.extname(name).toLowerCase()) {
+			case ".ts":
+			case ".tsx": return "typescript";
+			case ".html":
+			case ".vue": return "html";
+			default: return "javascript";
+		}
+	}
+	toMutantResult(mutantResult, remapTestIds) {
+		const { fileName, location, killedBy, coveredBy, ...apiMutant } = mutantResult;
+		const remappedKilledBy = remapTestIds(killedBy);
+		const remappedCoveredBy = remapTestIds(coveredBy);
+		return {
+			...apiMutant,
+			...remappedKilledBy === void 0 ? {} : { killedBy: remappedKilledBy },
+			...remappedCoveredBy === void 0 ? {} : { coveredBy: remappedCoveredBy },
+			location
+		};
+	}
+	discoverDependencies() {
+		const discover = (specifier) => {
+			try {
+				const version = S.decodeUnknownSync(S.Record(S.String, S.Unknown))(this.requireFromCwd(`${specifier}/package.json`))["version"];
+				return [specifier, typeof version === "string" ? version : JSON.stringify(version) ?? ""];
+			} catch {
+				return;
+			}
+		};
+		return [
+			"@stryker-mutator/mocha-runner",
+			"@stryker-mutator/karma-runner",
+			"@stryker-mutator/jasmine-runner",
+			"@stryker-mutator/jest-runner",
+			"@stryker-mutator/typescript-checker",
+			"karma",
+			"karma-chai",
+			"karma-chrome-launcher",
+			"karma-jasmine",
+			"karma-mocha",
+			"mocha",
+			"jasmine",
+			"jasmine-core",
+			"jest",
+			"react-scripts",
+			"typescript",
+			"@angular/cli",
+			"webpack",
+			"webpack-cli",
+			"ts-jest"
+		].map(discover).reduce((acc, dependency) => {
+			if (dependency) acc[dependency[0]] = dependency[1];
+			return acc;
+		}, {});
+	}
+};
+function normalizeReportFileName(fileName) {
+	if (fileName) return normalizeFileName(path.relative(process.cwd(), fileName));
+	return "";
+}
+//#endregion
+//#region src/test-runner/child-process-test-runner-proxy.ts
+const MAX_WAIT_FOR_DISPOSE = 2e3;
+/**
+* Runs the given test runner in a child process and forwards reports about test results
+*/
+var ChildProcessTestRunnerProxy = class ChildProcessTestRunnerProxy {
+	worker;
+	log;
+	constructor(options, fileDescriptions, sandboxWorkingDirectory, loggingServerAddress, pluginModulePaths, getLogger, idGenerator) {
+		this.log = getLogger(ChildProcessTestRunnerProxy.name);
+		this.worker = ChildProcessProxy.create(new URL("./child-process-test-runner-worker.mjs", import.meta.url).toString(), loggingServerAddress, options, fileDescriptions, pluginModulePaths, sandboxWorkingDirectory, ChildProcessTestRunnerWorker, options.testRunnerNodeArgs, getLogger, idGenerator);
+	}
+	capabilities() {
+		return this.worker.proxy.capabilities();
+	}
+	init() {
+		return this.worker.proxy.init();
+	}
+	dryRun(options) {
+		return this.worker.proxy.dryRun(options);
+	}
+	mutantRun(options) {
+		return this.worker.proxy.mutantRun(options);
+	}
+	async dispose() {
+		await ExpirableTask.timeout(this.worker.proxy.dispose().catch((error) => {
+			if (!(error instanceof ChildProcessCrashedError)) this.log.warn("An unexpected error occurred during test runner disposal. This might be worth looking into. Stryker will ignore this error.", error);
+		}), MAX_WAIT_FOR_DISPOSE);
+		await this.worker.dispose();
+	}
+};
+//#endregion
+//#region src/test-runner/test-runner-decorator.ts
+var TestRunnerDecorator = class extends ResourceDecorator {
+	async capabilities() {
+		return this.innerResource.capabilities();
+	}
+	dryRun(options) {
+		return this.innerResource.dryRun(options);
+	}
+	mutantRun(options) {
+		return this.innerResource.mutantRun(options);
+	}
+};
+//#endregion
+//#region src/test-runner/max-test-runner-reuse-decorator.ts
+/**
+* Wraps a test runner and implements the retry functionality.
+*/
+var MaxTestRunnerReuseDecorator = class extends TestRunnerDecorator {
+	runs = 0;
+	restartAfter;
+	constructor(testRunnerProducer, options) {
+		super(testRunnerProducer);
+		this.restartAfter = options.maxTestRunnerReuse || 0;
+	}
+	async mutantRun(options) {
+		this.runs++;
+		if (this.restartAfter > 0 && this.runs > this.restartAfter) {
+			await this.recover();
+			this.runs = 1;
+		}
+		return super.mutantRun(options);
+	}
+	dispose() {
+		this.runs = 0;
+		return super.dispose();
+	}
+};
+//#endregion
+//#region src/test-runner/reload-environment-decorator.ts
+var ReloadEnvironmentDecorator = class extends TestRunnerDecorator {
+	_capabilities;
+	testEnvironment = 0;
+	async capabilities() {
+		if (!this._capabilities) this._capabilities = await super.capabilities();
+		return this._capabilities;
+	}
+	async dryRun(options) {
+		this.testEnvironment = 1;
+		return super.dryRun(options);
+	}
+	async mutantRun(options) {
+		let newState;
+		if (options.reloadEnvironment) {
+			newState = 2;
+			options.reloadEnvironment = this.testEnvironment !== 0;
+			if (options.reloadEnvironment && !await this.testRunnerIsCapableOfReload()) {
+				await this.recover();
+				options.reloadEnvironment = false;
+			}
+		} else {
+			newState = 1;
+			if (this.testEnvironment === 2) {
+				if (await this.testRunnerIsCapableOfReload()) options.reloadEnvironment = true;
+				else await this.recover();
+			}
+		}
+		const result = await super.mutantRun(options);
+		this.testEnvironment = newState;
+		return result;
+	}
+	async testRunnerIsCapableOfReload() {
+		return (await this.capabilities()).reloadEnvironment;
+	}
+};
+//#endregion
+//#region src/test-runner/retry-rejected-decorator.ts
+const ERROR_MESSAGE = "Test runner crashed. Tried twice to restart it without any luck. Last time the error message was: ";
+/**
+* Implements the retry functionality whenever an internal test runner rejects a promise.
+*/
+var RetryRejectedDecorator = class extends TestRunnerDecorator {
+	log;
+	constructor(log, producer) {
+		super(producer);
+		this.log = log;
+	}
+	async dryRun(options) {
+		const result = await this.run(() => super.dryRun(options));
+		if (typeof result === "string") return {
+			status: DryRunStatus.Error,
+			errorMessage: result
+		};
+		else return result;
+	}
+	async mutantRun(options) {
+		const result = await this.run(() => super.mutantRun(options));
+		if (typeof result === "string") return {
+			status: MutantRunStatus.Error,
+			errorMessage: result
+		};
+		else return result;
+	}
+	async run(actRun, attemptsLeft = 2, lastError) {
+		if (attemptsLeft > 0) try {
+			return await actRun();
+		} catch (error) {
+			if (error instanceof OutOfMemoryError) this.log.info("Test runner process [%s] ran out of memory. You probably have a memory leak in your tests. Don't worry, Stryker will restart the process, but you might want to investigate this later, because this decreases performance.", error.pid);
+			await this.recover();
+			return this.run(actRun, attemptsLeft - 1, error);
+		}
+		else {
+			await this.recover();
+			return `${ERROR_MESSAGE}${errorToString(lastError)}`;
+		}
+	}
+};
+//#endregion
+//#region src/test-runner/timeout-decorator.ts
+/**
+* Wraps a test runner and implements the timeout functionality.
+*/
+var TimeoutDecorator = class extends TestRunnerDecorator {
+	log;
+	constructor(log, producer) {
+		super(producer);
+		this.log = log;
+	}
+	async dryRun(options) {
+		const result = await this.run(options, () => super.dryRun(options));
+		if (result === ExpirableTask.TimeoutExpired) return { status: DryRunStatus.Timeout };
+		else return result;
+	}
+	async mutantRun(options) {
+		const result = await this.run(options, () => super.mutantRun(options));
+		if (result === ExpirableTask.TimeoutExpired) return { status: MutantRunStatus.Timeout };
+		else return result;
+	}
+	async run(options, actRun) {
+		this.log.debug("Starting timeout timer (%s ms) for a test run", options.timeout);
+		const result = await ExpirableTask.timeout(actRun(), options.timeout);
+		if (result === ExpirableTask.TimeoutExpired) {
+			await this.handleTimeout();
+			return result;
+		} else return result;
+	}
+	async handleTimeout() {
+		this.log.debug("Timeout expired, restarting the process and reporting timeout");
+		await this.recover();
+	}
+};
+//#endregion
+//#region src/test-runner/index.ts
+createTestRunnerFactory.inject = tokens(commonTokens.options, commonTokens.fileDescriptions, sandbox, loggingServerAddress, commonTokens.getLogger, pluginModulePaths, workerIdGenerator);
+function createTestRunnerFactory(options, fileDescriptions, sandbox, loggingServerAddress, getLogger, pluginModulePaths, idGenerator) {
+	if (CommandTestRunner.is(options.testRunner)) return () => new RetryRejectedDecorator(getLogger(RetryRejectedDecorator.name), () => new TimeoutDecorator(getLogger(TimeoutDecorator.name), () => new CommandTestRunner(sandbox.workingDirectory, options)));
+	else return () => new RetryRejectedDecorator(getLogger(RetryRejectedDecorator.name), () => new ReloadEnvironmentDecorator(() => new MaxTestRunnerReuseDecorator(() => new TimeoutDecorator(getLogger(TimeoutDecorator.name), () => new ChildProcessTestRunnerProxy(options, fileDescriptions, sandbox.workingDirectory, loggingServerAddress, pluginModulePaths, getLogger, idGenerator)), options)));
+}
+//#endregion
+//#region src/run-stages/4-mutation-test-executor.ts
+const CHECK_BUFFER_MS = 1e4;
+/**
+* Sorting the tests just before running them can yield a significant performance boost,
+* because it can reduce the number of times a test runner process needs to be recreated.
+* However, we need to buffer the results in order to be able to sort them.
+*
+* This value is very low, since it would halt the test execution otherwise.
+* @see https://github.com/stryker-mutator/stryker-js/issues/3462
+*/
+const BUFFER_FOR_SORTING_MS = 0;
+var MutationTestExecutor = class {
+	reporter;
+	testRunnerPool;
+	checkerPool;
+	mutants;
+	planner;
+	mutationTestReportHelper;
+	log;
+	options;
+	timer;
+	concurrencyTokenProvider;
+	dryRunResult;
+	static inject = tokens(reporter, testRunnerPool, checkerPool, mutants, mutantTestPlanner, mutationTestReportHelper, commonTokens.logger, commonTokens.options, timer, concurrencyTokenProvider, dryRunResult);
+	constructor(reporter, testRunnerPool, checkerPool, mutants, planner, mutationTestReportHelper, log, options, timer, concurrencyTokenProvider, dryRunResult) {
+		this.reporter = reporter;
+		this.testRunnerPool = testRunnerPool;
+		this.checkerPool = checkerPool;
+		this.mutants = mutants;
+		this.planner = planner;
+		this.mutationTestReportHelper = mutationTestReportHelper;
+		this.log = log;
+		this.options = options;
+		this.timer = timer;
+		this.concurrencyTokenProvider = concurrencyTokenProvider;
+		this.dryRunResult = dryRunResult;
+	}
+	async execute() {
+		if (this.options.dryRunOnly) {
+			this.log.info("The dry-run has been completed successfully. No mutations have been executed.");
+			return [];
+		}
+		if (this.dryRunResult.tests.length === 0 && this.options.allowEmpty) {
+			this.logDone();
+			return [];
+		}
+		const mutantTestPlans = await this.planner.makePlan(this.mutants);
+		const { earlyResult$, runMutant$ } = this.executeEarlyResult(from(mutantTestPlans));
+		const { passedMutant$, checkResult$ } = this.executeCheck(runMutant$);
+		const { coveredMutant$, noCoverageResult$ } = this.executeNoCoverage(passedMutant$);
+		const testRunnerResult$ = this.executeRunInTestRunner(coveredMutant$);
+		const results = await lastValueFrom(merge(testRunnerResult$, checkResult$, noCoverageResult$, earlyResult$).pipe(toArray()));
+		await this.mutationTestReportHelper.reportAll(results);
+		await this.reporter.wrapUp();
+		this.logDone();
+		return results;
+	}
+	executeEarlyResult(input$) {
+		const [earlyResultMutants$, runMutant$] = partition(input$.pipe(shareReplay()), isEarlyResult);
+		return {
+			earlyResult$: earlyResultMutants$.pipe(map(({ mutant }) => this.mutationTestReportHelper.reportMutantStatus(mutant, mutant.status))),
+			runMutant$
+		};
+	}
+	executeNoCoverage(input$) {
+		const [noCoverageMatchedMutant$, coveredMutant$] = partition(input$.pipe(shareReplay()), ({ runOptions }) => runOptions.testFilter?.length === 0);
+		return {
+			noCoverageResult$: noCoverageMatchedMutant$.pipe(map(({ mutant }) => this.mutationTestReportHelper.reportMutantStatus(mutant, "NoCoverage"))),
+			coveredMutant$
+		};
+	}
+	executeRunInTestRunner(input$) {
+		const sortedPlan$ = input$.pipe(bufferTime(BUFFER_FOR_SORTING_MS), mergeMap((plans) => plans.sort(reloadEnvironmentLast)));
+		return this.testRunnerPool.schedule(sortedPlan$, async (testRunner, { mutant, runOptions }) => {
+			const result = await testRunner.mutantRun(runOptions);
+			return this.mutationTestReportHelper.reportMutantRunResult(mutant, result);
+		});
+	}
+	logDone() {
+		this.log.info("Done in %s.", this.timer.humanReadableElapsed());
+	}
+	/**
+	* Checks mutants against all configured checkers (if any) and returns steams for failed checks and passed checks respectively
+	* @param input$ The mutant run plans to check
+	*/
+	executeCheck(input$) {
+		let checkResult$ = EMPTY;
+		let passedMutant$ = input$;
+		for (const checkerName of this.options.checkers) {
+			const [checkFailedResult$, checkPassedResult$] = partition(this.executeSingleChecker(checkerName, passedMutant$).pipe(shareReplay()), isEarlyResult);
+			passedMutant$ = checkPassedResult$;
+			checkResult$ = concat(checkResult$, checkFailedResult$.pipe(map(({ mutant }) => mutant)));
+		}
+		return {
+			checkResult$,
+			passedMutant$: passedMutant$.pipe(tap$1({ complete: () => {
+				this.checkerPool.dispose().then(() => {
+					this.concurrencyTokenProvider.freeCheckers();
+				}).catch((error) => {
+					this.log.error("An error occurred while disposing checkers: %s", error);
+				});
+			} }))
+		};
+	}
+	/**
+	* Executes the check task for one checker
+	* @param checkerName The name of the checker to execute
+	* @param input$ The mutants tasks to check
+	* @returns An observable stream with early results (check failed) and passed results
+	*/
+	executeSingleChecker(checkerName, input$) {
+		const group$ = this.checkerPool.schedule(input$.pipe(bufferTime(CHECK_BUFFER_MS)), (checker, mutants) => checker.group(checkerName, mutants)).pipe(mergeMap((mutantGroups) => mutantGroups));
+		return this.checkerPool.schedule(group$, (checker, group) => checker.check(checkerName, group)).pipe(mergeMap((mutantGroupResults) => mutantGroupResults), map(([mutantRunPlan, checkResult]) => checkResult.status === CheckStatus.Passed ? mutantRunPlan : {
+			plan: PlanKind.EarlyResult,
+			mutant: this.mutationTestReportHelper.reportCheckFailed(mutantRunPlan.mutant, checkResult)
+		}));
+	}
+};
+/**
+* Sorting function that sorts mutant run plans that reload environments last.
+* This can yield a significant performance boost, because it reduces the times a test runner process needs to restart.
+* @see https://github.com/stryker-mutator/stryker-js/issues/3462
+*/
+function reloadEnvironmentLast(a, b) {
+	if (a.plan === PlanKind.Run && b.plan === PlanKind.Run) {
+		if (a.runOptions.reloadEnvironment && !b.runOptions.reloadEnvironment) return 1;
+		if (!a.runOptions.reloadEnvironment && b.runOptions.reloadEnvironment) return -1;
+		return 0;
+	}
+	return 0;
+}
+//#endregion
+//#region src/run-stages/3-dry-run-executor.ts
+const INITIAL_TEST_RUN_MARKER = "Initial test run";
+function isFailedTest(testResult) {
+	return testResult.status === TestStatus.Failed;
+}
+var DryRunExecutor = class {
+	injector;
+	log;
+	options;
+	timer;
+	concurrencyTokenProvider;
+	sandbox;
+	reporter;
+	static inject = tokens(commonTokens.injector, commonTokens.logger, commonTokens.options, timer, concurrencyTokenProvider, sandbox, reporter);
+	constructor(injector, log, options, timer, concurrencyTokenProvider, sandbox, reporter) {
+		this.injector = injector;
+		this.log = log;
+		this.options = options;
+		this.timer = timer;
+		this.concurrencyTokenProvider = concurrencyTokenProvider;
+		this.sandbox = sandbox;
+		this.reporter = reporter;
+	}
+	async execute() {
+		const testRunnerInjector = this.injector.provideClass(workerIdGenerator, IdGenerator).provideFactory(testRunnerFactory, createTestRunnerFactory).provideValue(testRunnerConcurrencyTokens, this.concurrencyTokenProvider.testRunnerToken$).provideFactory(testRunnerPool, createTestRunnerPool);
+		const testRunnerPool$1 = testRunnerInjector.resolve(testRunnerPool);
+		const { result, timing } = await lastValueFrom(testRunnerPool$1.schedule(of(0), (testRunner) => this.executeDryRun(testRunner)));
+		this.logInitialTestRunSucceeded(result.tests, timing);
+		if (!result.tests.length && !this.options.allowEmpty) throw new ConfigError("No tests were executed. Stryker will exit prematurely. Please check your configuration.");
+		return testRunnerInjector.provideValue(timeOverheadMS, timing.overhead).provideValue(dryRunResult, result).provideValue(requireFromCwd, requireResolve).provideFactory(testCoverage, TestCoverage.from).provideClass(incrementalDiffer, IncrementalDiffer).provideClass(mutantTestPlanner, MutantTestPlanner).provideClass(mutationTestReportHelper, MutationTestReportHelper).provideClass(workerIdGenerator, IdGenerator);
+	}
+	validateResultCompleted(runResult) {
+		switch (runResult.status) {
+			case DryRunStatus.Complete: {
+				const failedTests = runResult.tests.filter(isFailedTest);
+				if (failedTests.length) {
+					this.logFailedTestsInInitialRun(failedTests);
+					throw new ConfigError("There were failed tests in the initial test run.");
+				}
+				return;
+			}
+			case DryRunStatus.Error:
+				this.logErrorsInInitialRun(runResult);
+				break;
+			case DryRunStatus.Timeout: this.logTimeoutInitialRun();
+		}
+		throw new Error("Something went wrong in the initial test run");
+	}
+	async executeDryRun(testRunner) {
+		if (this.options.dryRunOnly) this.log.info("Note: running the dry-run only. No mutations will be tested.");
+		const dryRunTimeout = this.options.dryRunTimeoutMinutes * 1e3 * 60;
+		const project$1 = this.injector.resolve(project);
+		const dryRunFiles = map$1(project$1.filesToMutate, (_, name) => this.sandbox.sandboxFileFor(name));
+		const testFiles = project$1.testFiles.length > 0 ? project$1.testFiles.map((file) => this.sandbox.sandboxFileFor(file)) : void 0;
+		this.options.coverageAnalysis, this.options.disableBail, { ...testFiles ? { testFiles } : {} };
+		this.timer.mark(INITIAL_TEST_RUN_MARKER);
+		this.log.info(`Starting initial test run (${this.options.testRunner} test runner with "${this.options.coverageAnalysis}" coverage analysis). This may take a while.`);
+		this.log.debug(`Using timeout of ${dryRunTimeout} ms.`);
+		const result = await testRunner.dryRun({
+			timeout: dryRunTimeout,
+			coverageAnalysis: this.options.coverageAnalysis,
+			disableBail: this.options.disableBail,
+			files: dryRunFiles,
+			...testFiles ? { testFiles } : {}
+		});
+		const grossTimeMS = this.timer.elapsedMs(INITIAL_TEST_RUN_MARKER);
+		const capabilities = await testRunner.capabilities();
+		this.validateResultCompleted(result);
+		this.remapSandboxFilesToOriginalFiles(result);
+		const dryRunCompleted = {
+			result,
+			timing: this.calculateTiming(grossTimeMS, result.tests),
+			capabilities
+		};
+		this.reporter.onDryRunCompleted(dryRunCompleted);
+		return dryRunCompleted;
+	}
+	/**
+	* Remaps test files to their respective original names outside the sandbox.
+	* @param dryRunResult the completed result
+	*/
+	remapSandboxFilesToOriginalFiles(dryRunResult) {
+		const disableTypeCheckingFileMatcher = new FileMatcher(this.options.disableTypeChecks);
+		dryRunResult.tests.forEach((test) => {
+			if (test.fileName) {
+				test.fileName = this.sandbox.originalFileFor(test.fileName);
+				if (test.startPosition && disableTypeCheckingFileMatcher.matches(test.fileName)) test.startPosition.line--;
+			}
+		});
+	}
+	logInitialTestRunSucceeded(tests, timing) {
+		if (!tests.length) {
+			this.log.info("No tests were found");
+			return;
+		}
+		this.log.info("Initial test run succeeded. Ran %s tests in %s (net %s ms, overhead %s ms).", tests.length, this.timer.humanReadableElapsed(INITIAL_TEST_RUN_MARKER), timing.net, timing.overhead);
+	}
+	/**
+	* Calculates the timing variables for the test run.
+	* grossTime = NetTime + overheadTime
+	*
+	* The overhead time is used to calculate exact timeout values during mutation testing.
+	* See timeoutMS setting in README for more information on this calculation
+	*/
+	calculateTiming(grossTimeMS, tests) {
+		const netTimeMS = tests.reduce((total, test) => total + test.timeSpentMs, 0);
+		const overheadTimeMS = grossTimeMS - netTimeMS;
+		return {
+			net: netTimeMS,
+			overhead: overheadTimeMS < 0 ? 0 : overheadTimeMS
+		};
+	}
+	logFailedTestsInInitialRun(failedTests) {
+		let message = "One or more tests failed in the initial test run:";
+		failedTests.forEach((test) => {
+			message += `${EOL}\t${test.name}`;
+			message += `${EOL}\t\t${test.failureMessage}`;
+		});
+		this.log.error(message);
+	}
+	logErrorsInInitialRun(runResult) {
+		const message = `One or more tests resulted in an error:${EOL}\t${runResult.errorMessage}`;
+		this.log.error(message);
+	}
+	logTimeoutInitialRun() {
+		this.log.error("Initial test run timed out!");
+	}
+};
+//#endregion
+//#region src/run-stages/2-mutant-instrumenter-executor.ts
+var MutantInstrumenterExecutor = class {
+	injector;
+	project;
+	options;
+	pluginCreator;
+	static inject = tokens(commonTokens.injector, project, commonTokens.options, pluginCreator);
+	constructor(injector, project, options, pluginCreator) {
+		this.injector = injector;
+		this.project = project;
+		this.options = options;
+		this.pluginCreator = pluginCreator;
+	}
+	async execute() {
+		const instrumenter = this.injector.injectFunction(createInstrumenter);
+		const instrumenterOptions = {
+			ignorers: this.options.ignorers.map((name) => this.pluginCreator.create(PluginKind.Ignore, name)),
+			...this.options.mutator,
+			plugins: this.options.mutator.plugins === null ? null : [...this.options.mutator.plugins],
+			excludedMutations: [...this.options.mutator.excludedMutations]
+		};
+		const instrumentResult = await instrumenter.instrument(await this.readFilesToMutate(), instrumenterOptions);
+		const preprocess = this.injector.injectFunction(createPreprocessor);
+		this.writeInstrumentedFiles(instrumentResult);
+		await preprocess.preprocess(this.project);
+		const concurrencyTokenProviderProvider = this.injector.provideClass(concurrencyTokenProvider, ConcurrencyTokenProvider);
+		const concurrencyTokenProvider$1 = concurrencyTokenProviderProvider.resolve(concurrencyTokenProvider);
+		const checkerPoolProvider = concurrencyTokenProviderProvider.provideValue(checkerConcurrencyTokens, concurrencyTokenProvider$1.checkerToken$).provideClass(workerIdGenerator, IdGenerator).provideFactory(checkerFactory, createCheckerFactory).provideFactory(checkerPool, createCheckerPool);
+		await checkerPoolProvider.resolve(checkerPool).init();
+		const dryRunProvider = checkerPoolProvider.provideClass(sandbox, Sandbox).provideValue(mutants, instrumentResult.mutants);
+		await dryRunProvider.resolve(sandbox).init();
+		return dryRunProvider;
+	}
+	readFilesToMutate() {
+		return Promise.all([...this.project.filesToMutate.values()].map((file) => file.toInstrumenterFile()));
+	}
+	writeInstrumentedFiles(instrumentResult) {
+		for (const { name, content } of Object.values(instrumentResult.files)) {
+			const file = this.project.files.get(name);
+			if (file === void 0) throw new Error(`Instrumented file "${name}" is missing from the project's file map.`);
+			file.setContent(content);
+		}
+	}
+};
+//#endregion
+//#region src/stryker.ts
+/**
+* The main Stryker class.
+* It provides a single `runMutationTest()` function which runs mutation testing:
+*/
+var Stryker = class Stryker {
+	cliOptions;
+	hostOptions;
+	injectorFactory;
+	/**
+	* @class
+	* @param cliOptions The cli options.
+	* @param hostOptions What the host resolved for this run, see {@link StrykerHostOptions}.
+	* @param injectorFactory The injector factory, for testing purposes only
+	*/
+	constructor(cliOptions, hostOptions, injectorFactory = createInjector) {
+		this.cliOptions = cliOptions;
+		this.hostOptions = hostOptions;
+		this.injectorFactory = injectorFactory;
+	}
+	async runMutationTest() {
+		const rootInjector = this.injectorFactory();
+		try {
+			const prepareInjector = provideLogging(await provideLoggingBackend(rootInjector, this.hostOptions.loggerConsoleOut, this.hostOptions.showColors)).provideValue(reporterOverride, void 0).provideValue(runEventSink, this.hostOptions.runEventSink).provideValue(runId, this.hostOptions.runId).provideValue(resolvedMode, this.hostOptions.resolvedMode).provideValue(progressEnabled, this.hostOptions.progressEnabled).provideValue(clearTextEnabled, this.hostOptions.clearTextEnabled).provideValue(runStartedAt, this.hostOptions.runStartedAt).provideValue(reporterPluginModules, this.hostOptions.reporterPluginModules);
+			return await Stryker.run(prepareInjector, {
+				cliOptions: this.cliOptions,
+				targetMutatePatterns: void 0
+			});
+		} finally {
+			await rootInjector.dispose();
+		}
+	}
+	/**
+	* Does the actual mutation testing.
+	* Note: this is a public static method, so it can be reused from `StrykerServer`
+	* @internal
+	*/
+	static async run(mutationRunInjector, args) {
+		const sink = mutationRunInjector.resolve(runEventSink);
+		const runStartedAt$1 = mutationRunInjector.resolve(runStartedAt);
+		const emitPhase = (phase) => {
+			sink({
+				kind: "phase",
+				phase,
+				elapsedMs: Date.now() - runStartedAt$1
+			});
+		};
+		try {
+			emitPhase("prepare");
+			const mutantInstrumenterInjector = await mutationRunInjector.injectClass(PrepareExecutor).execute(args);
+			try {
+				emitPhase("instrument");
+				const dryRunExecutorInjector = await mutantInstrumenterInjector.injectClass(MutantInstrumenterExecutor).execute();
+				emitPhase("dry-run");
+				const mutationRunExecutorInjector = await dryRunExecutorInjector.injectClass(DryRunExecutor).execute();
+				emitPhase("mutation-test");
+				return await mutationRunExecutorInjector.injectClass(MutationTestExecutor).execute();
+			} catch (error) {
+				const cleanTempDir = mutantInstrumenterInjector.resolve(commonTokens.options).cleanTempDir;
+				if (cleanTempDir === false || cleanTempDir === true) {
+					mutationRunInjector.resolve(commonTokens.getLogger)(Stryker.name).debug("Not removing the temp dir because an error occurred");
+					mutantInstrumenterInjector.resolve(temporaryDirectory).removeDuringDisposal = false;
+				}
+				throw error;
+			}
+		} catch (error) {
+			const log = mutationRunInjector.resolve(commonTokens.getLogger)(Stryker.name);
+			const cause = retrieveCause(error);
+			if (cause instanceof ConfigError) log.error(cause.message);
+			else {
+				log.error("Unexpected error occurred while running Stryker", error);
+				log.info("This might be a known problem with a solution documented in our troubleshooting guide.");
+				log.info("You can find it at https://stryker-mutator.io/docs/stryker-js/troubleshooting/");
+				if (!log.isTraceEnabled()) log.info("Still having trouble figuring out what went wrong? Try `npx stryker run --fileLogLevel trace --logLevel debug` to get some more info.");
+			}
+			throw cause;
+		}
+	}
+};
+//#endregion
+//#region src/index.ts
+var src_default = Stryker;
+//#endregion
+export { Stryker, src_default as default };