@systemfsoftware/stryker-js 6.0.0 → 7.0.0

package/dist/builtin-reporters-BqePgAN0.mjs

@@ -1,671 +0,0 @@
-import { B as errorToString, a as MetricsResultSchema, g as ReporterFailed, u as MutationTestResultSchema } from "./dist-CWbipfGB.mjs";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import "effect/Stdio";
-import * as Predicate from "effect/Predicate";
-import * as S from "effect/Schema";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import "effect/Sink";
-//#region src/reporter-output.ts
-const sinksOf = (stdio) => ({
-	stdout: () => stdio.stdout({ endOnDone: false }),
-	stderr: () => stdio.stderr({ endOnDone: false })
-});
-const sinkFor = (stdio, channel) => sinksOf(stdio)[channel]();
-const write = (stdio, channel, chunks) => Stream.run(Stream.fromIterable(chunks), sinkFor(stdio, channel));
-/**
-* The one Effect→Promise bridge for the sync-loop progress bar (the only reporter
-* that cannot compose Effects — its writes fire inside a synchronous for-await).
-* Write errors are ignored like a broken pipe on a stream handle.
-*
-* Note: effect 4.0.0-rc.112 exports the runner as `Effect.runPromise`; there is no
-* `Runtime.runPromise` in this version (verified against the installed source) —
-* do not invent that import.
-*/
-const writeAsync = (stdio, channel, chunks) => Effect.runPromise(Effect.ignore(write(stdio, channel, chunks)));
-//#endregion
-//#region src/Reporter.ansi.ts
-const codes = {
-	red: "\x1B[31m",
-	green: "\x1B[32m",
-	yellow: "\x1B[33m",
-	grey: "\x1B[90m",
-	cyan: "\x1B[36m",
-	greenBright: "\x1B[92m",
-	redBright: "\x1B[91m",
-	blueBright: "\x1B[94m"
-};
-const reset = "\x1B[39m";
-function wrap(color, text) {
-	return `${codes[color]}${text}${reset}`;
-}
-const ansi = {
-	wrap,
-	red: (text) => wrap("red", text),
-	green: (text) => wrap("green", text),
-	yellow: (text) => wrap("yellow", text),
-	grey: (text) => wrap("grey", text),
-	cyan: (text) => wrap("cyan", text),
-	greenBright: (text) => wrap("greenBright", text),
-	redBright: (text) => wrap("redBright", text),
-	blueBright: (text) => wrap("blueBright", text)
-};
-//#endregion
-//#region src/mutation-score-table.ts
-const KNOWN_EMOJI = {
-	"✅": true,
-	"🙈": true,
-	"🤥": true,
-	"👽": true,
-	"⏰": true,
-	"⌛": true,
-	"💥": true
-};
-const charWidth = (char) => Match.value(char).pipe(Match.when((candidate) => KNOWN_EMOJI[candidate] === true, () => 2), Match.when((candidate) => (candidate.codePointAt(0) ?? 0) > 65535, () => 2), Match.orElse(() => 1));
-function stringWidth(input) {
-	return Array.from(input).reduce((width, char) => width + charWidth(char), 0);
-}
-const FILES_ROOT_NAME = "All files";
-const repeat = (char, nTimes) => {
-	if (nTimes > -1) return char.repeat(nTimes);
-	return char.repeat(0);
-};
-const spaces = (n) => repeat(" ", n);
-const statusHeader = (allowEmojis, emoji, label) => {
-	if (allowEmojis) return `${emoji} ${label}`;
-	return `# ${label}`;
-};
-const maxOf = (values) => values.reduce((acc, cur) => {
-	if (cur > acc) return cur;
-	return acc;
-}, Number.NEGATIVE_INFINITY);
-const widthOrZero = (width) => Match.value(width === Number.NEGATIVE_INFINITY).pipe(Match.when(true, () => 0), Match.when(false, () => width), Match.exhaustive);
-const determineContentWidth = (row, valueFactory, ancestorCount = 0) => {
-	const head = valueFactory(row, ancestorCount).length;
-	const childWidths = row.childResults.map((child) => determineContentWidth(child, valueFactory, ancestorCount + 1));
-	return widthOrZero(maxOf([head, ...childWidths]));
-};
-const columnWidth = (column) => {
-	if (column.isFirstColumn) return column.netWidth + 1;
-	return column.netWidth + 2;
-};
-const padColumn = (column, input) => Match.value(column.kind === "file").pipe(Match.when(true, () => `${input}${spaces(columnWidth(column) - stringWidth(input))}`), Match.when(false, () => Match.value(column.isFirstColumn).pipe(Match.when(true, () => `${spaces(column.netWidth - stringWidth(input))}${input} `), Match.when(false, () => `${spaces(column.netWidth - stringWidth(input))} ${input} `), Match.exhaustive)), Match.exhaustive);
-const drawLine = (column) => repeat("-", columnWidth(column));
-const drawHeader = (column) => padColumn(column, column.header);
-const mutationScoreOf = (scoreType, metrics) => Match.value(scoreType).pipe(Match.when("total", () => metrics.mutationScore), Match.when("covered", () => metrics.mutationScoreBasedOnCoveredCode), Match.exhaustive);
-const thresholdColor = (thresholds, value) => Match.value(value).pipe(Match.when((present) => Number.isNaN(present), () => ansi.grey), Match.when((present) => present >= thresholds.high, () => ansi.green), Match.when((present) => present >= thresholds.low, () => ansi.yellow), Match.orElse(() => ansi.red));
-const scoreColor = (column, score) => Match.value(column.allowColor).pipe(Match.when(true, () => thresholdColor(column.thresholds, mutationScoreOf(column.scoreType, score.metrics))), Match.when(false, () => (input) => input), Match.exhaustive);
-const colorFor = (column, score) => Match.value(column).pipe(Match.discriminator("kind")("mutationScore", (scored) => scoreColor(scored, score)), Match.orElse(() => (input) => input));
-const drawTableCell = (column, score, ancestorCount) => {
-	switch (column.kind) {
-		case "group": return column.columns.map((c) => drawTableCell(c, score, ancestorCount)).join("|");
-		case "single":
-		case "file":
-		case "mutationScore": {
-			const raw = column.valueFactory(score, ancestorCount);
-			const padded = padColumn(column, raw);
-			return colorFor(column, score)(padded);
-		}
-	}
-};
-const drawColumnHeaders = (column) => {
-	if (column.kind !== "group") return drawHeader(column);
-	return column.columns.map((c) => drawHeader(c)).join("|");
-};
-const drawColumnLines = (column) => {
-	if (column.kind !== "group") return drawLine(column);
-	return column.columns.map((c) => drawLine(c)).join("|");
-};
-const makeSingleColumn = (header, isFirstColumn, valueFactory, rows) => {
-	const maxContentSize = determineContentWidth(rows, valueFactory);
-	const netWidth = maxOf([maxContentSize, stringWidth(header)]);
-	return {
-		kind: "single",
-		header,
-		isFirstColumn,
-		netWidth: widthOrZero(netWidth),
-		valueFactory,
-		rows
-	};
-};
-const makeFileColumn = (rows) => {
-	const valueFactory = (row, ancestorCount) => {
-		if (ancestorCount === 0) return spaces(ancestorCount) + FILES_ROOT_NAME;
-		return spaces(ancestorCount) + row.name;
-	};
-	const netWidth = maxOf([determineContentWidth(rows, valueFactory), stringWidth("File")]);
-	return {
-		kind: "file",
-		header: "File",
-		isFirstColumn: true,
-		netWidth: widthOrZero(netWidth),
-		valueFactory,
-		rows
-	};
-};
-const makeMutationScoreColumn = (rows, thresholds, scoreType, allowColor) => {
-	const valueFactory = (row) => Match.value(mutationScoreOf(scoreType, row.metrics)).pipe(Match.when((present) => Number.isNaN(present), () => "n/a"), Match.orElse((present) => present.toFixed(2)));
-	const netWidth = maxOf([determineContentWidth(rows, valueFactory), stringWidth(scoreType)]);
-	return {
-		kind: "mutationScore",
-		header: scoreType,
-		isFirstColumn: false,
-		netWidth: widthOrZero(netWidth),
-		valueFactory,
-		rows,
-		thresholds,
-		scoreType,
-		allowColor
-	};
-};
-const paddingWidth = (isFirstColumn) => Match.value(isFirstColumn).pipe(Match.when(true, () => 1), Match.when(false, () => 2), Match.exhaustive);
-const widthAdjustedColumns = (columns, first, columnsWidth, netWidth) => Match.value(netWidth > columnsWidth + 1).pipe(Match.when(true, () => [{
-	...first,
-	netWidth: first.netWidth + (netWidth - columnsWidth - 1)
-}, ...columns.slice(1)]), Match.when(false, () => columns), Match.exhaustive);
-const makeGroupColumn = (groupName, ...columns) => {
-	const [first, ...rest] = columns;
-	if (first === void 0) throw new Error("a group column needs at least one column");
-	const columnsWidth = rest.reduce((acc, cur) => acc + columnWidth(cur), columnWidth(first)) - paddingWidth(first.isFirstColumn);
-	const netWidth = widthOrZero(maxOf([stringWidth(groupName), columnsWidth]));
-	return {
-		kind: "group",
-		header: groupName,
-		isFirstColumn: first.isFirstColumn,
-		netWidth,
-		columns: widthAdjustedColumns(columns, first, columnsWidth, netWidth)
-	};
-};
-const createColumns = (metricsResult, options) => {
-	const allowColor = options.clearTextReporter.allowColor;
-	const allowEmojis = options.clearTextReporter.allowEmojis;
-	return [
-		makeGroupColumn("", makeFileColumn(metricsResult)),
-		makeGroupColumn("% Mutation score", makeMutationScoreColumn(metricsResult, options.thresholds, "total", allowColor), makeMutationScoreColumn(metricsResult, options.thresholds, "covered", allowColor)),
-		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "✅", "killed"), false, (row) => row.metrics.killed.toString(), metricsResult)),
-		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "⌛️", "timeout"), false, (row) => row.metrics.timeout.toString(), metricsResult)),
-		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "👽", "survived"), false, (row) => row.metrics.survived.toString(), metricsResult)),
-		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "🙈", "no cov"), false, (row) => row.metrics.noCoverage.toString(), metricsResult)),
-		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "💥", "errors"), false, (row) => (row.metrics.runtimeErrors + row.metrics.compileErrors).toString(), metricsResult))
-	];
-};
-const drawRow = (columns, toDraw) => `${columns.map(toDraw).join("|")}|`;
-const drawGroupHeader = (columns) => drawRow(columns, (c) => drawHeader(c));
-const drawGroupLine = (columns) => drawRow(columns, (c) => drawLine(c));
-const drawLineRow = (columns) => drawRow(columns, (c) => drawColumnLines(c));
-const drawColumnHeader = (columns) => drawRow(columns, (c) => drawColumnHeaders(c));
-const drawTableBody = (columns, options, current, ancestorCount) => {
-	const ownRow = Match.value(options.clearTextReporter.skipFull === false || current.metrics.mutationScore !== 100).pipe(Match.when(true, () => [drawRow(columns, (column) => drawTableCell(column, current, ancestorCount))]), Match.when(false, () => []), Match.exhaustive);
-	const childRows = current.childResults.flatMap((child) => drawTableBody(columns, options, child, ancestorCount + 1));
-	return [...ownRow, ...childRows];
-};
-const EOL = "\n";
-const drawMutationScoreTable = (metricsResult, options) => {
-	const columns = createColumns(metricsResult, options);
-	return [
-		drawGroupLine(columns),
-		drawGroupHeader(columns),
-		drawColumnHeader(columns),
-		drawLineRow(columns),
-		drawTableBody(columns, options, metricsResult, 0).join(EOL),
-		drawLineRow(columns)
-	].join(EOL);
-};
-//#endregion
-//#region src/Reporter.schema.ts
-var ClearTextReportCommand = class extends S.TaggedClass()("ClearTextReportCommand", {
-	report: MutationTestResultSchema,
-	metrics: MetricsResultSchema
-}) {};
-//#endregion
-//#region src/clear-text-report.ts
-function plural(items) {
-	if (items > 1) return "s";
-	else return "";
-}
-function getEmojiForStatus(status) {
-	switch (status) {
-		case "Killed": return "✅";
-		case "NoCoverage": return "🙈";
-		case "Ignored": return "🤥";
-		case "Survived": return "👽";
-		case "Timeout": return "⏰";
-		case "Pending": return "⌛";
-		case "RuntimeError":
-		case "CompileError": return "💥";
-	}
-}
-function sourceLocation(fileName, position, allowColor) {
-	return [
-		(() => {
-			if (allowColor) return ansi.cyan(fileName);
-			return fileName;
-		})(),
-		(() => {
-			if (allowColor) return ansi.yellow(String(position.line));
-			return String(position.line);
-		})(),
-		(() => {
-			if (allowColor) return ansi.yellow(String(position.column));
-			return String(position.column);
-		})()
-	].join(":");
-}
-function mutantLabel(status, allowEmojis) {
-	if (allowEmojis) return `${getEmojiForStatus(status)} ${status}`;
-	return status;
-}
-/**
-* Where a mutant's block is written: the diagnostics channel for mutants that
-* failed to run, the report for the ones that inform, and nowhere for the rest.
-*/
-const REPORT_CHANNEL = {
-	Killed: "debug",
-	Timeout: "debug",
-	RuntimeError: "debug",
-	CompileError: "debug",
-	Survived: "stdout",
-	NoCoverage: "stdout",
-	Ignored: "none",
-	Pending: "none"
-};
-function extractReportMutants(report) {
-	if (!Predicate.hasProperty(report, "files")) return [];
-	return Object.entries(report.files).flatMap(([fileName, file]) => file.mutants.map((mutant) => ({
-		fileName,
-		mutant: {
-			...mutant,
-			fileName
-		},
-		source: file.source
-	})));
-}
-function sourceLine(source, position) {
-	const raw = source.split("\n")[position.line - 1];
-	if (raw === void 0) return "";
-	return raw;
-}
-function tailFromColumn(raw, column) {
-	if (raw.length === 0) return [];
-	return [raw.slice(column)];
-}
-function sliceSource(source, position) {
-	if (source === void 0) return [];
-	return tailFromColumn(sourceLine(source, position), position.column);
-}
-function originalLines(source, position, allowColor) {
-	return sliceSource(source, position).map((l) => {
-		if (allowColor) return ansi.red(`-   ${l}`);
-		return `-   ${l}`;
-	});
-}
-function replacementLines(replacement, allowColor) {
-	if (replacement === void 0) return [];
-	return replacement.split("\n").filter(Boolean).map((l) => {
-		if (allowColor) return ansi.green(`+   ${l}`);
-		return `+   ${l}`;
-	});
-}
-const logsCoveredTests = (mutant, options) => {
-	if (!options.clearTextReporter.logTests) return false;
-	return mutant.coveredBy !== void 0;
-};
-const coveredTestsTail = (mutant, options) => {
-	if (!logsCoveredTests(mutant, options)) return [];
-	return formatCoveredTests(mutant.coveredBy, options);
-};
-const survivorTail = (mutant, options) => {
-	if (mutant.static === true) return ["Ran all tests for this mutant."];
-	return coveredTestsTail(mutant, options);
-};
-const killedByLine = (killer) => {
-	if (killer === void 0) return [];
-	return [`Killed by: ${killer}`];
-};
-const killerTail = (mutant) => {
-	const killedBy = mutant.killedBy;
-	if (killedBy === void 0) return [];
-	return killedByLine(killedBy[0]);
-};
-const statusReasonTail = (mutant) => {
-	if (mutant.statusReason === void 0) return [];
-	return [`Error message: ${mutant.statusReason}`];
-};
-/**
-* The lines below a mutant block: one tail per status, chosen by the status the
-* mutant settled at.
-*/
-const statusTail = (mutant, options) => Match.value(mutant.status).pipe(Match.when("Survived", () => survivorTail(mutant, options)), Match.when("Killed", () => killerTail(mutant)), Match.whenOr("RuntimeError", "CompileError", () => statusReasonTail(mutant)), Match.orElse(() => []));
-const overflowNotice = (hidden) => {
-	if (hidden <= 0) return [];
-	return [`  and ${hidden} more test${plural(hidden)}!`];
-};
-function formatCoveredTests(tests, options) {
-	const maxLog = options.clearTextReporter.maxTestsToLog;
-	const logged = Math.min(maxLog, tests.length);
-	if (logged <= 0) return [];
-	return [
-		"Tests ran:",
-		...tests.slice(0, logged).map((test) => `    ${test}`),
-		...overflowNotice(tests.length - maxLog),
-		""
-	];
-}
-function mutantBlock(fileName, mutant, source, options) {
-	const allowColor = options.clearTextReporter.allowColor;
-	const allowEmojis = options.clearTextReporter.allowEmojis;
-	const out = [];
-	out.push(`[${mutantLabel(mutant.status, allowEmojis)}] ${mutant.mutatorName}`);
-	out.push(sourceLocation(fileName, mutant.location.start, allowColor));
-	out.push(...originalLines(source, mutant.location.start, allowColor));
-	out.push(...replacementLines(mutant.replacement, allowColor));
-	out.push(...statusTail(mutant, options));
-	out.push("");
-	return out;
-}
-const linesForChannel = (entries, channel, options) => {
-	return entries.filter((entry) => REPORT_CHANNEL[entry.mutant.status] === channel).flatMap((entry) => mutantBlock(entry.fileName, entry.mutant, entry.source, options));
-};
-function collectMutants(report, options) {
-	const entries = extractReportMutants(report);
-	return {
-		stdout: linesForChannel(entries, "stdout", options),
-		debug: linesForChannel(entries, "debug", options),
-		totalTests: entries.reduce((total, entry) => total + (entry.mutant.testsCompleted ?? 0), 0)
-	};
-}
-const partialScoresVisible = (metrics, options) => {
-	if (!options.clearTextReporter.skipFull) return true;
-	return metrics.childResults.some((child) => child.metrics.mutationScore !== 100);
-};
-const drawsScoreTable = (metrics, options) => {
-	if (!options.clearTextReporter.reportScoreTable) return false;
-	return partialScoresVisible(metrics, options);
-};
-function scoreTable(metrics, options) {
-	if (!drawsScoreTable(metrics, options)) return void 0;
-	return drawMutationScoreTable(metrics, options);
-}
-const EMPTY_REPORT_LINES = {
-	stdout: [],
-	debug: []
-};
-const testsPerMutant = (metrics, totalTests) => {
-	const total = metrics.metrics.totalMutants;
-	if (total === 0) return "0.00";
-	return (totalTests / total).toFixed(2);
-};
-const lineIfPresent = (line) => {
-	if (line === void 0) return [];
-	return [line];
-};
-const mutantReportSection = (report, metrics, options) => {
-	if (!options.clearTextReporter.reportMutants) return EMPTY_REPORT_LINES;
-	const blocks = collectMutants(report, options);
-	return {
-		stdout: [
-			"",
-			...blocks.stdout,
-			`Ran ${testsPerMutant(metrics, blocks.totalTests)} tests per mutant on average.`
-		],
-		debug: blocks.debug
-	};
-};
-function renderClearText(report, metrics, options) {
-	const section = mutantReportSection(report, metrics, options);
-	return {
-		stdout: [
-			"",
-			...section.stdout,
-			...lineIfPresent(scoreTable(metrics, options))
-		],
-		debug: [...section.debug]
-	};
-}
-const rememberTerminalReport = (seen, event) => {
-	Match.value(event).pipe(Match.tag("mutationTestReportReady", (ready) => {
-		seen.terminal = {
-			report: ready.report,
-			metrics: ready.metrics
-		};
-	}), Match.orElse(() => void 0));
-};
-const decodeClearTextReport = (terminal) => S.decodeUnknownEffect(ClearTextReportCommand)({
-	_tag: "ClearTextReportCommand",
-	report: terminal.report,
-	metrics: terminal.metrics
-}).pipe(Effect.mapError((cause) => ReporterFailed.make({
-	reporterName: "clear-text",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-})));
-const streamErrorOf$1 = (cause) => ReporterFailed.make({
-	reporterName: "clear-text",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-});
-const failAsClearText = (cause) => ReporterFailed.make({
-	reporterName: "clear-text",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-});
-const writeRendered = (services, rendered, options) => {
-	const stdoutEffect = write(services.stdio, "stdout", rendered.stdout.map((line) => `${line}\n`)).pipe(Effect.mapError(failAsClearText), Effect.asVoid);
-	return Match.value(options.logLevel === "debug").pipe(Match.when(true, () => Effect.andThen(stdoutEffect, write(services.stdio, "stderr", rendered.debug.map((line) => `${line}\n`)).pipe(Effect.mapError(failAsClearText)))), Match.orElse(() => stdoutEffect));
-};
-const makeClearTextReporter = (services) => (options) => (events) => {
-	const seen = {};
-	return Stream.runForEach(Stream.fromAsyncIterable(events, streamErrorOf$1), (event) => Effect.sync(() => rememberTerminalReport(seen, event))).pipe(Effect.andThen(Effect.sync(() => seen.terminal)), Effect.flatMap((terminal) => Option.match(Option.fromUndefinedOr(terminal), {
-		onNone: () => Effect.void,
-		onSome: (ready) => decodeClearTextReport(ready).pipe(Effect.flatMap((command) => writeRendered(services, renderClearText(command.report, command.metrics, options), options)))
-	})));
-};
-//#endregion
-//#region src/json-reporter.ts
-const failAsJsonReporter = (cause) => ReporterFailed.make({
-	reporterName: "json",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-});
-const writeReport = (services, options, report) => Effect.gen(function* () {
-	const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown, { space: 0 }))(report).pipe(Effect.orDie);
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const fileName = path.resolve(options.jsonReporter.fileName);
-	if (options.logLevel === "debug") yield* Effect.ignore(write(services.stdio, "stderr", [`Using relative path ${path.normalize(options.jsonReporter.fileName)}\n`]));
-	yield* fs.makeDirectory(path.dirname(fileName), { recursive: true }).pipe(Effect.mapError(failAsJsonReporter));
-	yield* fs.writeFileString(fileName, json).pipe(Effect.mapError(failAsJsonReporter));
-	const url = yield* path.toFileUrl(fileName).pipe(Effect.mapError(failAsJsonReporter));
-	yield* Effect.ignore(write(services.stdio, "stdout", [`Your report can be found at: ${url.href}\n`]));
-}).pipe(Effect.provideService(FileSystem.FileSystem, services.fileSystem), Effect.provideService(Path.Path, services.path));
-const rememberReport = (seen, event) => {
-	Match.value(event).pipe(Match.tag("mutationTestReportReady", (ready) => {
-		seen.report = ready.report;
-	}), Match.orElse(() => void 0));
-};
-const streamErrorOf = (cause) => ReporterFailed.make({
-	reporterName: "json",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-});
-const makeJsonReporter = (services) => (options) => (events) => {
-	const seen = {};
-	return Stream.runForEach(Stream.fromAsyncIterable(events, streamErrorOf), (event) => Effect.sync(() => rememberReport(seen, event))).pipe(Effect.andThen(Effect.sync(() => seen.report)), Effect.flatMap((report) => Option.match(Option.fromUndefinedOr(report), {
-		onNone: () => Effect.void,
-		onSome: (ready) => writeReport(services, options, ready)
-	})));
-};
-//#endregion
-//#region src/progress-reporter.ts
-const makeProgressBarState = (format, options) => ({
-	format,
-	total: options.total,
-	curr: 0,
-	width: options.width,
-	complete: options.complete,
-	incomplete: options.incomplete
-});
-const tickProgressBar = (state, ticks) => ({
-	...state,
-	curr: state.curr + ticks
-});
-const renderProgressBar = (state, data) => formatBar(state.format, state.curr, state.total, data, {
-	width: state.width,
-	complete: state.complete,
-	incomplete: state.incomplete
-});
-const isComplete = (state) => state.curr >= state.total;
-function formatBar(format, curr, total, data, options) {
-	const ratio = Match.value(total === 0).pipe(Match.when(true, () => 0), Match.when(false, () => Math.min(curr / total, 1)), Match.exhaustive);
-	const filled = Math.floor(ratio * options.width);
-	const bar = options.complete.repeat(filled) + options.incomplete.repeat(options.width - filled);
-	const percent = `${Math.floor(ratio * 100).toString().padStart(3, " ")}%`;
-	const printed = format.replace(":bar", bar).replace(":percent", percent);
-	return Object.entries(data).reduce((out, [key, value]) => out.replaceAll(`:${key}`, String(value)), printed);
-}
-const emptyTally = (startedAt) => ({
-	survived: 0,
-	timedOut: 0,
-	tested: 0,
-	mutants: 0,
-	total: 0,
-	ticks: 0,
-	ticksByMutantId: {},
-	timing: {
-		net: 0,
-		overhead: 0
-	},
-	capabilities: { reloadEnvironment: false },
-	startedAt
-});
-const getElapsedTime = (tally, now) => {
-	return formatTime(Math.floor((now - tally.startedAt) / 1e3));
-};
-const getEtc = (tally, now) => {
-	const elapsed = Math.floor((now - tally.startedAt) / 1e3);
-	const remaining = Math.floor(elapsed / tally.ticks * (tally.total - tally.ticks));
-	return Match.value(Number.isFinite(remaining) && remaining > 0).pipe(Match.when(true, () => formatTime(remaining)), Match.when(false, () => "n/a"), Match.exhaustive);
-};
-function formatTime(timeInSeconds) {
-	const hours = Math.floor(timeInSeconds / 3600);
-	const minutes = Math.floor(timeInSeconds % 3600 / 60);
-	return Match.value(hours > 0).pipe(Match.when(true, () => `~${hours}h ${minutes}m`), Match.when(false, () => Match.value(minutes > 0).pipe(Match.when(true, () => `~${minutes}m`), Match.when(false, () => "<1m"), Match.exhaustive)), Match.exhaustive);
-}
-const ticksFor = (plan, tally) => Match.value(tally.capabilities.reloadEnvironment === false && plan.reloadEnvironment).pipe(Match.when(true, () => plan.netTime + tally.timing.overhead), Match.when(false, () => plan.netTime), Match.exhaustive);
-const progressData = (tally, now) => ({
-	survived: tally.survived,
-	timedOut: tally.timedOut,
-	tested: tally.tested,
-	mutants: tally.mutants,
-	total: tally.total,
-	ticks: tally.ticks,
-	et: getElapsedTime(tally, now),
-	etc: getEtc(tally, now)
-});
-const tallyAfterTest = (tally, tested, ticks) => {
-	const counted = Match.value(tested.status).pipe(Match.when("Survived", () => ({
-		survived: 1,
-		timedOut: 0
-	})), Match.when("Timeout", () => ({
-		survived: 0,
-		timedOut: 1
-	})), Match.orElse(() => ({
-		survived: 0,
-		timedOut: 0
-	})));
-	return {
-		...tally,
-		tested: tested.completed,
-		ticks: tally.ticks + ticks,
-		survived: tally.survived + counted.survived,
-		timedOut: tally.timedOut + counted.timedOut
-	};
-};
-const PROGRESS_BAR_FORMAT = "Mutation testing  [:bar] :percent (elapsed: :et, remaining: :etc) :tested/:mutants Mutants tested (:survived survived, :timedOut timed out)";
-const PROGRESS_BAR_OPTIONS = {
-	complete: "=",
-	incomplete: " ",
-	width: 50
-};
-const progressStreamErrorOf = (cause) => ReporterFailed.make({
-	reporterName: "progress",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-});
-const makeProgressBarReporter = (services) => () => (events) => {
-	const progress = {
-		tally: emptyTally(0),
-		bar: void 0
-	};
-	let pending = Promise.resolve();
-	const enqueue = (text) => {
-		pending = pending.then(() => writeAsync(services.stdio, "stdout", [text])).catch(() => void 0);
-	};
-	const render = (now) => Option.match(Option.fromUndefinedOr(progress.bar), {
-		onNone: () => void 0,
-		onSome: (bar) => {
-			const line = renderProgressBar(bar, progressData(progress.tally, now));
-			const newline = Match.value(isComplete(bar)).pipe(Match.when(true, () => "\n"), Match.when(false, () => ""), Match.exhaustive);
-			enqueue(`\r${line}${newline}`);
-		}
-	});
-	return Stream.runForEach(Stream.fromAsyncIterable(events, progressStreamErrorOf), (event) => Effect.sync(() => applyProgressEvent(progress, render, event))).pipe(Effect.ensuring(Effect.ignore(Effect.promise(() => {
-		finishProgressBar(progress, enqueue);
-		return pending;
-	}))));
-};
-const makeProgressStreamReporter = () => (events) => Stream.runDrain(Stream.fromAsyncIterable(events, progressStreamErrorOf));
-const applyProgressEvent = (progress, render, event) => {
-	Match.value(event).pipe(Match.tag("dryRunCompleted", (dryRun) => {
-		progress.tally = {
-			...progress.tally,
-			timing: dryRun.timing,
-			capabilities: { reloadEnvironment: dryRun.capabilities.reloadEnvironment }
-		};
-	}), Match.tag("mutationTestingPlanReady", (planReady) => {
-		const ticksByMutantId = Object.fromEntries(planReady.plans.flatMap((plan) => {
-			if (plan.plan !== "Run") return [];
-			return [[plan.mutantId, ticksFor(plan, progress.tally)]];
-		}));
-		const total = Object.values(ticksByMutantId).reduce((sum, ticks) => sum + ticks, 0);
-		progress.tally = {
-			...progress.tally,
-			startedAt: performance.now(),
-			ticksByMutantId,
-			mutants: Object.keys(ticksByMutantId).length,
-			total
-		};
-		progress.bar = makeProgressBarState(PROGRESS_BAR_FORMAT, {
-			...PROGRESS_BAR_OPTIONS,
-			total
-		});
-	}), Match.tag("mutantTested", (tested) => {
-		Option.match(Option.fromUndefinedOr(progress.tally.ticksByMutantId[tested.id]), {
-			onNone: () => void 0,
-			onSome: (ticks) => {
-				progress.tally = tallyAfterTest(progress.tally, tested, ticks);
-				progress.bar = Option.getOrUndefined(Option.map(Option.fromUndefinedOr(progress.bar), (bar) => tickProgressBar(bar, ticks)));
-				render(performance.now());
-			}
-		});
-	}), Match.orElse(() => void 0));
-};
-const finishProgressBar = (progress, enqueue) => {
-	Option.match(Option.fromUndefinedOr(progress.bar), {
-		onNone: () => void 0,
-		onSome: (bar) => Match.value(isComplete(bar)).pipe(Match.when(true, () => void 0), Match.when(false, () => enqueue("\n")), Match.exhaustive)
-	});
-};
-//#endregion
-//#region src/builtin-reporters.ts
-const makeBuiltinReporterFactories = (services) => ({
-	"json": makeJsonReporter(services),
-	"clear-text": makeClearTextReporter(services),
-	"progress": makeProgressBarReporter(services),
-	"progress-stream": makeProgressStreamReporter
-});
-//#endregion
-export { ansi as n, makeBuiltinReporterFactories as t };