@systemfsoftware/stryker-js 13.0.0 → 13.1.0

package/dist/{dist-BscHZmXN.mjs → dist-CQ7r4AaH.mjs}

@@ -1,6 +1,6 @@
 import { Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Boolean$1$1 from "effect/Boolean";
-import * as Match from "effect/Match";
+import * as Match$1 from "effect/Match";
 import * as Option$1 from "effect/Option";
 import * as Predicate$1 from "effect/Predicate";
 import * as Result from "effect/Result";
@@ -2439,7 +2439,7 @@ const nonEmptyText = Option$1.liftPredicate(S.is(S.NonEmptyString));
 const errorTextOf$2 = (cause) => Option$1.flatMap(nonEmptyText(errorTextValueOf(cause)), (text) => ErrorText.makeOption({ text }));
 const causeTextOf = (cause) => Option$1.flatMap(nonEmptyText(causeChainTextOf(cause)), (text) => CauseText.makeOption({ text }));
 function errorTextValueOf(error) {
-	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
+	return Match$1.value(error).pipe(Match$1.when(isEmptyError, () => ""), Match$1.when(Match$1.instanceOf(Error), errorText), Match$1.orElse(() => stringifyNonError(error)));
 }
 function causeChainTextOf(cause) {
 	return causeText(cause, 1) ?? "";
@@ -2450,30 +2450,30 @@ function readFieldOf(record, key) {
 	return record[key];
 }
 const fieldOf = (value, key) => Option$1.getOrUndefined(Option$1.filter(Option$1.some(value), (candidate) => Predicate$1.hasProperty(key)(candidate)).pipe(Option$1.map((record) => readFieldOf(record, key))));
-const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
-const isErrnoException = (error) => Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
-const isEmptyNumber = (value) => Match.value(value).pipe(Match.when(0, () => true), Match.orElse(Number.isNaN));
-const isEmptyError = (error) => Match.value(error).pipe(Match.when(Match.undefined, () => true), Match.when(Match.null, () => true), Match.when(Match.string, (text) => text.length === 0), Match.when(Match.number, isEmptyNumber), Match.when(Match.boolean, (value) => !value), Match.orElse(() => false));
-const formatErrnoException = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
-const formatError = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), Match.orElse(() => `${error.name}: ${error.message}`));
-const isJsonPrimitive = (value) => Match.value(value).pipe(Match.when(Match.number, () => true), Match.when(Match.boolean, () => true), Match.when(Match.bigint, () => true), Match.orElse(() => false));
+const hasStringCode = (error) => Match$1.value(fieldOf(error, "code")).pipe(Match$1.when(Match$1.string, () => true), Match$1.orElse(() => false));
+const isErrnoException = (error) => Match$1.value(error).pipe(Match$1.when(Match$1.instanceOf(Error), hasStringCode), Match$1.orElse(() => false));
+const isEmptyNumber = (value) => Match$1.value(value).pipe(Match$1.when(0, () => true), Match$1.orElse(Number.isNaN));
+const isEmptyError = (error) => Match$1.value(error).pipe(Match$1.when(Match$1.undefined, () => true), Match$1.when(Match$1.null, () => true), Match$1.when(Match$1.string, (text) => text.length === 0), Match$1.when(Match$1.number, isEmptyNumber), Match$1.when(Match$1.boolean, (value) => !value), Match$1.orElse(() => false));
+const formatErrnoException = (error) => Match$1.value(error.stack).pipe(Match$1.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match$1.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
+const formatError = (error) => Match$1.value(error.stack).pipe(Match$1.when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), Match$1.orElse(() => `${error.name}: ${error.message}`));
+const isJsonPrimitive = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.number, () => true), Match$1.when(Match$1.boolean, () => true), Match$1.when(Match$1.bigint, () => true), Match$1.orElse(() => false));
 const jsonText = (error) => Result.getOrElse(Result.try({
 	try: () => textIfNonEmpty(JSON.stringify(error)),
 	catch: () => void 0
 }), () => void 0);
-const isNonPlaceholderText = (text) => Match.value({
+const isNonPlaceholderText = (text) => Match$1.value({
 	hasLength: text.length > 0,
 	isPlaceholder: text === "[object Object]"
-}).pipe(Match.when({
+}).pipe(Match$1.when({
 	hasLength: true,
 	isPlaceholder: false
-}, () => true), Match.orElse(() => false));
-const isUsableText = (value) => Match.value(value).pipe(Match.when(Match.string, isNonPlaceholderText), Match.orElse(() => false));
+}, () => true), Match$1.orElse(() => false));
+const isUsableText = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.string, isNonPlaceholderText), Match$1.orElse(() => false));
 const usableText = (value) => isUsableText(value) ? value : "";
-const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pipe(Match.when(Match.instanceOf(Function), (callable) => Result.getOrElse(Result.try({
+const objectToStringText = (value) => Match$1.value(fieldOf(value, "toString")).pipe(Match$1.when(Match$1.instanceOf(Function), (callable) => Result.getOrElse(Result.try({
 	try: () => usableText(Reflect.apply(callable, value, [])),
 	catch: () => ""
-}), () => "")), Match.orElse(() => ""));
+}), () => "")), Match$1.orElse(() => ""));
 const toStringText = (error) => Predicate$1.isObjectOrArray(error) ? objectToStringText(error) : "";
 const stringifyRest = (error) => Option$1.match(Option$1.filter(Option$1.fromUndefinedOr(jsonText(error)), hasText), {
 	onNone: () => toStringText(error),
@@ -2486,15 +2486,15 @@ const stringifyNonError = (error) => typeof error === "string" ? error : nonStri
 function nonStringTextOf(error) {
 	return primitiveJsonOf(error) ?? stringifyRest(error);
 }
-const errorText = (error) => Match.value(error).pipe(Match.when(isErrnoException, formatErrnoException), Match.orElse(() => formatError(error)));
-const errorNameOf = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), (error) => textIfNonEmpty(error.name)), Match.orElse(() => void 0));
-const tagOf = (value) => Match.value(textIfNonEmpty(fieldOf(value, "_tag"))).pipe(Match.when(hasText, (tag) => tag), Match.orElse(() => errorNameOf(value)));
-const textWithNested = (own, nested) => Match.value(own).pipe(Match.when(hasText, (text) => appendNested(text, nested)), Match.orElse(() => nested));
-const appendNested = (own, nested) => Match.value(nested).pipe(Match.when(hasText, (text) => `${own}: ${text}`), Match.orElse(() => own));
-const errorMessage = (error) => Match.value(error.message.length > 0).pipe(Match.when(true, () => error.message), Match.orElse(() => tagOf(error)));
-const errorMessageOrTag = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), errorMessage), Match.orElse(() => tagOf(value)));
-const messageText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match.when(hasText, (message) => message), Match.orElse(() => errorMessageOrTag(value)));
-const ownCauseText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match.when(hasText, (reason) => reason), Match.orElse(() => messageText(value)));
+const errorText = (error) => Match$1.value(error).pipe(Match$1.when(isErrnoException, formatErrnoException), Match$1.orElse(() => formatError(error)));
+const errorNameOf = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.instanceOf(Error), (error) => textIfNonEmpty(error.name)), Match$1.orElse(() => void 0));
+const tagOf = (value) => Match$1.value(textIfNonEmpty(fieldOf(value, "_tag"))).pipe(Match$1.when(hasText, (tag) => tag), Match$1.orElse(() => errorNameOf(value)));
+const textWithNested = (own, nested) => Match$1.value(own).pipe(Match$1.when(hasText, (text) => appendNested(text, nested)), Match$1.orElse(() => nested));
+const appendNested = (own, nested) => Match$1.value(nested).pipe(Match$1.when(hasText, (text) => `${own}: ${text}`), Match$1.orElse(() => own));
+const errorMessage = (error) => Match$1.value(error.message.length > 0).pipe(Match$1.when(true, () => error.message), Match$1.orElse(() => tagOf(error)));
+const errorMessageOrTag = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.instanceOf(Error), errorMessage), Match$1.orElse(() => tagOf(value)));
+const messageText = (value) => Match$1.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match$1.when(hasText, (message) => message), Match$1.orElse(() => errorMessageOrTag(value)));
+const ownCauseText = (value) => Match$1.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match$1.when(hasText, (reason) => reason), Match$1.orElse(() => messageText(value)));
 const isPastDepth = (depth) => depth > 4;
 const isMissingCause = (cause) => cause === void 0 || cause === null;
 function causeText(cause, depth) {
@@ -2510,7 +2510,7 @@ function missingCauseTextOf(cause, depth) {
 	});
 }
 function causeNodeTextOf(cause, depth) {
-	return Match.value(cause).pipe(Match.when(Match.string, (text) => textIfNonEmpty(text)), Match.orElse((value) => objectCauseTextOf(value, depth)));
+	return Match$1.value(cause).pipe(Match$1.when(Match$1.string, (text) => textIfNonEmpty(text)), Match$1.orElse((value) => objectCauseTextOf(value, depth)));
 }
 function objectCauseTextOf(cause, depth) {
 	return Option$1.getOrUndefined(Option$1.map(Option$1.filter(Option$1.some(cause), Predicate$1.isObjectOrArray), (object) => textWithNested(ownCauseText(object), causeText(fieldOf(object, "cause"), depth + 1))));
@@ -2739,16 +2739,32 @@ var MutantsUnapplied = class extends S.TaggedError()("MutantsUnapplied", {
 	placer: PlacerNameSchema,
 	mutatorNames: S.Array(MutatorNameSchema),
 	cause: S.Defect()
-}) {};
+}) {
+	get message() {
+		return `Failed to apply ${this.mutatorNames.join(", ")} in ${this.fileName}`;
+	}
+};
 var MutantNotApplied = class extends S.TaggedError()("MutantNotApplied", {
 	fileName: S.String,
 	mutatorName: MutatorNameSchema
-}) {};
-var NodeWithoutSpan = class extends S.TaggedError()("NodeWithoutSpan", { fileName: S.String }) {};
+}) {
+	get message() {
+		return `Could not apply the ${this.mutatorName} mutant in ${this.fileName}`;
+	}
+};
+var NodeWithoutSpan = class extends S.TaggedError()("NodeWithoutSpan", { fileName: S.String }) {
+	get message() {
+		return `Node without a span in ${this.fileName}`;
+	}
+};
 var MutantsUnplaced = class extends S.TaggedError()("MutantsUnplaced", {
 	fileName: S.String,
 	detail: S.String
-}) {};
+}) {
+	get message() {
+		return `Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${this.detail}`;
+	}
+};
 var PlacementRefused = class extends S.TaggedError()("PlacementRefused", { message: S.String }) {};
 const LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/g;
 const lineStartsOf = (text) => [0, ...[...text.matchAll(LINE_TERMINATOR)].map((match) => match.index + match[0].length)];
@@ -3213,7 +3229,7 @@ const writeAtKey = (parent, key, index, replacement) => Option$1.match(Option$1.
 	onNone: () => void 0,
 	onSome: (name) => writeAtSlot(parent, name, index, replacement)
 });
-const writeAtSlot = (parent, key, index, replacement) => Match.value(index).pipe(Match.when(Match.null, () => overwrite(parent, key, replacement)), Match.orElse((position) => writeElement(parent[key], position, replacement)));
+const writeAtSlot = (parent, key, index, replacement) => Match$1.value(index).pipe(Match$1.when(Match$1.null, () => overwrite(parent, key, replacement)), Match$1.orElse((position) => writeElement(parent[key], position, replacement)));
 const overwrite = (parent, key, replacement) => {
 	parent[key] = replacement;
 };
@@ -3325,26 +3341,26 @@ const EMPTY_IMPORT_TABLE = Object.freeze({
 const buildImportTable = (program) => Arr.reduce(Arr.flatMap(Arr.filter(program.body, isImportDeclaration$1), importContributions), EMPTY_IMPORT_TABLE, applyContribution);
 const withEntry = (entries, key, value) => new Map([...entries, [key, value]]);
 const withMember = (members, value) => /* @__PURE__ */ new Set([...members, value]);
-const applyContribution = (table, contribution) => Match.value(contribution).pipe(Match.when((candidate) => candidate.kind === "module", (moduleBinding) => ({
+const applyContribution = (table, contribution) => Match$1.value(contribution).pipe(Match$1.when((candidate) => candidate.kind === "module", (moduleBinding) => ({
 	...table,
 	moduleBindings: withEntry(table.moduleBindings, moduleBinding.local, moduleBinding.module)
-})), Match.when((candidate) => candidate.kind === "namespace", (namespaceBinding) => ({
+})), Match$1.when((candidate) => candidate.kind === "namespace", (namespaceBinding) => ({
 	...table,
 	namespaces: withEntry(table.namespaces, namespaceBinding.local, namespaceBinding.binding)
-})), Match.when((candidate) => candidate.kind === "bareFunction", (bareFunction) => ({
+})), Match$1.when((candidate) => candidate.kind === "bareFunction", (bareFunction) => ({
 	...table,
 	bareFunctions: withEntry(table.bareFunctions, bareFunction.local, {
 		module: bareFunction.module,
 		exportName: bareFunction.exportName
 	})
-})), Match.orElse((pipeBinding) => ({
+})), Match$1.orElse((pipeBinding) => ({
 	...table,
 	pipeBindings: withMember(table.pipeBindings, pipeBinding.local)
 })));
 const importContributions = (declaration) => Option$1.toArray(onlyWhen(declaration.importKind !== "type", declaration)).flatMap((imported) => Arr.flatMap(imported.specifiers, (specifier) => Option$1.toArray(specifierContribution(imported.source.value, specifier))));
-const specifierContribution = (source, specifier) => Match.value(specifier).pipe(Match.when(isNamedImportSpecifier, (named) => namedSpecifierContribution(source, named)), Match.when(isNamespaceImportSpecifier, (namespace) => namespaceSpecifierContribution(source, namespace)), Match.orElse(() => Option$1.none()));
+const specifierContribution = (source, specifier) => Match$1.value(specifier).pipe(Match$1.when(isNamedImportSpecifier, (named) => namedSpecifierContribution(source, named)), Match$1.when(isNamespaceImportSpecifier, (namespace) => namespaceSpecifierContribution(source, namespace)), Match$1.orElse(() => Option$1.none()));
 const namedSpecifierContribution = (source, specifier) => onlyWhen(specifier.importKind !== "type", specifier).pipe(Option$1.flatMap((imported) => namedContribution(source, moduleExportName(imported.imported), imported.local.name)));
-const namedContribution = (source, importedName, localName) => Match.value(source).pipe(Match.when((candidate) => candidate === EFFECT_SOURCE, () => effectRootContribution(importedName, localName)), Match.when((candidate) => candidate === FUNCTION_SOURCE, () => pipeContribution(importedName, localName)), Match.orElse(() => Option$1.map(moduleNameFromSource(source), (module) => bareFunctionContribution(localName, module, importedName))));
+const namedContribution = (source, importedName, localName) => Match$1.value(source).pipe(Match$1.when((candidate) => candidate === EFFECT_SOURCE, () => effectRootContribution(importedName, localName)), Match$1.when((candidate) => candidate === FUNCTION_SOURCE, () => pipeContribution(importedName, localName)), Match$1.orElse(() => Option$1.map(moduleNameFromSource(source), (module) => bareFunctionContribution(localName, module, importedName))));
 const effectRootContribution = (importedName, localName) => Option$1.orElse(Option$1.map(moduleNameFromName(importedName), (module) => moduleContribution(localName, module)), () => pipeContribution(importedName, localName));
 const pipeContribution = (importedName, localName) => onlyWhen(importedName === "pipe", pipeContributionOf(localName));
 const namespaceSpecifierContribution = (source, specifier) => Option$1.map(namespaceBindingFor(source), (binding) => ({
@@ -3367,7 +3383,7 @@ const pipeContributionOf = (local) => ({
 	kind: "pipe",
 	local
 });
-const namespaceBindingFor = (source) => Match.value(source).pipe(Match.when((candidate) => candidate === EFFECT_SOURCE, () => Option$1.some({ kind: "root" })), Match.when((candidate) => candidate === FUNCTION_SOURCE, () => Option$1.some({ kind: "functionModule" })), Match.orElse(() => Option$1.map(moduleNameFromSource(source), (module) => ({
+const namespaceBindingFor = (source) => Match$1.value(source).pipe(Match$1.when((candidate) => candidate === EFFECT_SOURCE, () => Option$1.some({ kind: "root" })), Match$1.when((candidate) => candidate === FUNCTION_SOURCE, () => Option$1.some({ kind: "functionModule" })), Match$1.orElse(() => Option$1.map(moduleNameFromSource(source), (module) => ({
 	kind: "module",
 	module
 }))));
@@ -3376,7 +3392,7 @@ const moduleNameFromSource = (source) => Arr.findFirst(MODULE_NAMES, (module) =>
 const resolveEffectCallDataFirst = (node, context) => Option$1.flatMap(programOf(context), (program) => resolveIn(node, context, buildImportTable(program)));
 const resolveEffectCall = dual((args) => args.length >= 2, resolveEffectCallDataFirst);
 const programOf = (context) => Arr.findLast(context.ancestors, isProgram);
-const resolveIn = (node, context, table) => Match.value(node).pipe(Match.when(isCallExpression$1, (call) => resolveCall(call, context, table)), Match.when(isMemberExpression, (member) => resolveReference(member, context, table)), Match.when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), Match.orElse(() => Option$1.none()));
+const resolveIn = (node, context, table) => Match$1.value(node).pipe(Match$1.when(isCallExpression$1, (call) => resolveCall(call, context, table)), Match$1.when(isMemberExpression, (member) => resolveReference(member, context, table)), Match$1.when(isIdentifier$1, (reference) => resolveReference(reference, context, table)), Match$1.orElse(() => Option$1.none()));
 const resolveCall = (call, context, table) => Option$1.flatMap(resolveCallee(call.callee, context, table), (callee) => Option$1.flatMap(spreadFreeArguments$1(call.arguments), (args) => Option$1.flatMap(callForm(callee, args, call, context, table), (form) => Option$1.some({
 	module: callee.module,
 	exportName: callee.exportName,
@@ -3392,8 +3408,8 @@ const resolveReference = (reference, context, table) => Option$1.flatMap(resolve
 	moduleAccess: moduleAccessFunction(callee, context, table)
 })));
 const referenceForm = (reference, context, table) => Option$1.flatMap(parentCall(context), (parent) => Option$1.map(pipePosition(parent, reference, context, table), () => PIPED_REFERENCE));
-const spreadFreeArguments$1 = (args) => Match.value(args.some(isSpreadElement)).pipe(Match.when(true, () => Option$1.none()), Match.orElse(() => Option$1.some(args.filter(isSpreadFree))));
-const resolveCallee = (callee, context, table) => Match.value(callee).pipe(Match.when(isIdentifier$1, (reference) => resolveBareCallee(reference, context, table)), Match.when(isMemberExpression, (member) => resolveMemberCallee(member, context, table)), Match.orElse(() => Option$1.none()));
+const spreadFreeArguments$1 = (args) => Match$1.value(args.some(isSpreadElement)).pipe(Match$1.when(true, () => Option$1.none()), Match$1.orElse(() => Option$1.some(args.filter(isSpreadFree))));
+const resolveCallee = (callee, context, table) => Match$1.value(callee).pipe(Match$1.when(isIdentifier$1, (reference) => resolveBareCallee(reference, context, table)), Match$1.when(isMemberExpression, (member) => resolveMemberCallee(member, context, table)), Match$1.orElse(() => Option$1.none()));
 const resolveBareCallee = (reference, context, table) => Option$1.flatMap(Option$1.fromNullishOr(table.bareFunctions.get(reference.name)), (binding) => Option$1.map(unshadowedName(reference.name, context), () => ({
 	module: binding.module,
 	exportName: binding.exportName,
@@ -3404,7 +3420,7 @@ const resolveMemberCallee = (member, context, table) => Option$1.flatMap(staticM
 	exportName,
 	owner: Option$1.some(owner)
 })));
-const resolveModuleObject = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => identifierModuleObject(reference, context, table)), Match.when(isMemberExpression, (member) => namespacedModuleObject(member, context, table)), Match.orElse(() => Option$1.none()));
+const resolveModuleObject = (expression, context, table) => Match$1.value(expression).pipe(Match$1.when(isIdentifier$1, (reference) => identifierModuleObject(reference, context, table)), Match$1.when(isMemberExpression, (member) => namespacedModuleObject(member, context, table)), Match$1.orElse(() => Option$1.none()));
 const identifierModuleObject = (reference, context, table) => Option$1.orElse(Option$1.flatMap(Option$1.fromNullishOr(table.moduleBindings.get(reference.name)), (module) => Option$1.map(unshadowedName(reference.name, context), () => ({
 	module,
 	access: reference
@@ -3412,20 +3428,20 @@ const identifierModuleObject = (reference, context, table) => Option$1.orElse(Op
 	module,
 	access: reference
 }))));
-const namespacedModuleObject = (member, context, table) => Option$1.flatMap(staticMemberName(member), (moduleName) => Option$1.flatMap(namespaceOf(member.object, context, table), (binding) => Match.value(binding).pipe(Match.when(isRootNamespace, () => Option$1.map(moduleNameFromName(moduleName), (module) => ({
+const namespacedModuleObject = (member, context, table) => Option$1.flatMap(staticMemberName(member), (moduleName) => Option$1.flatMap(namespaceOf(member.object, context, table), (binding) => Match$1.value(binding).pipe(Match$1.when(isRootNamespace, () => Option$1.map(moduleNameFromName(moduleName), (module) => ({
 	module,
 	access: member
-}))), Match.when(isModuleNamespace, (moduleNamespace) => Option$1.map(onlyWhen(moduleNamespace.module === moduleName, member), (access) => ({
+}))), Match$1.when(isModuleNamespace, (moduleNamespace) => Option$1.map(onlyWhen(moduleNamespace.module === moduleName, member), (access) => ({
 	module: moduleNamespace.module,
 	access
-}))), Match.orElse(() => Option$1.none()))));
+}))), Match$1.orElse(() => Option$1.none()))));
 const isRootNamespace = (binding) => binding.kind === "root";
-const moduleOf = (binding) => Match.value(binding).pipe(Match.when(isModuleNamespace, (moduleNamespace) => Option$1.some(moduleNamespace.module)), Match.orElse(() => Option$1.none()));
+const moduleOf = (binding) => Match$1.value(binding).pipe(Match$1.when(isModuleNamespace, (moduleNamespace) => Option$1.some(moduleNamespace.module)), Match$1.orElse(() => Option$1.none()));
 const isModuleNamespace = (binding) => binding.kind === "module";
-const namespaceOf = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => Option$1.flatMap(Option$1.fromNullishOr(table.namespaces.get(reference.name)), (binding) => Option$1.map(unshadowedName(reference.name, context), () => binding))), Match.orElse(() => Option$1.none()));
-const callForm = (callee, args, call, context, table) => Option$1.flatMap(arityOf(callee), (arity) => Match.value(args.length).pipe(Match.when((count) => arity.dataFirst.includes(count), () => Option$1.some(DATA_FIRST)), Match.when((count) => arity.dataLast === count, () => dataLastForm(call, context, table)), Match.orElse(() => Option$1.none())));
+const namespaceOf = (expression, context, table) => Match$1.value(expression).pipe(Match$1.when(isIdentifier$1, (reference) => Option$1.flatMap(Option$1.fromNullishOr(table.namespaces.get(reference.name)), (binding) => Option$1.map(unshadowedName(reference.name, context), () => binding))), Match$1.orElse(() => Option$1.none()));
+const callForm = (callee, args, call, context, table) => Option$1.flatMap(arityOf(callee), (arity) => Match$1.value(args.length).pipe(Match$1.when((count) => arity.dataFirst.includes(count), () => Option$1.some(DATA_FIRST)), Match$1.when((count) => arity.dataLast === count, () => dataLastForm(call, context, table)), Match$1.orElse(() => Option$1.none())));
 const arityOf = (callee) => Option$1.fromNullishOr(ARITIES[`${callee.module}.${callee.exportName}`]);
-const dataLastForm = (call, context, table) => Option$1.flatMap(parentCall(context), (parent) => Match.value(parent.callee === call).pipe(Match.when(true, () => Option$1.some(DATA_LAST_IMMEDIATE)), Match.orElse(() => Option$1.flatMap(pipePosition(parent, call, context, table), formForPosition))));
+const dataLastForm = (call, context, table) => Option$1.flatMap(parentCall(context), (parent) => Match$1.value(parent.callee === call).pipe(Match$1.when(true, () => Option$1.some(DATA_LAST_IMMEDIATE)), Match$1.orElse(() => Option$1.flatMap(pipePosition(parent, call, context, table), formForPosition))));
 const pipePosition = (parent, argument, context, table) => Option$1.flatMap(argumentIndex(parent.arguments, argument), (index) => Option$1.orElse(onlyWhen(isPipeMethodCall(parent), {
 	index,
 	callee: "method"
@@ -3433,16 +3449,16 @@ const pipePosition = (parent, argument, context, table) => Option$1.flatMap(argu
 	index,
 	callee: "effect"
 })));
-const formForPosition = (position) => Match.value(position.callee).pipe(Match.when((callee) => callee === "method", () => Option$1.some(DATA_LAST_PIPE_METHOD)), Match.orElse(() => onlyWhen(position.index >= 1, DATA_LAST_PIPE_ARG)));
+const formForPosition = (position) => Match$1.value(position.callee).pipe(Match$1.when((callee) => callee === "method", () => Option$1.some(DATA_LAST_PIPE_METHOD)), Match$1.orElse(() => onlyWhen(position.index >= 1, DATA_LAST_PIPE_ARG)));
 const argumentIndex = (args, node) => Option$1.flatMap(Option$1.fromNullishOr(args.findIndex((argument) => sameNode(argument, node))), (index) => onlyWhen(index >= 0, index));
-const parentCall = (context) => Option$1.flatMap(Option$1.fromNullishOr(context.parent), (parent) => Match.value(parent).pipe(Match.when(isCallExpression$1, (call) => Option$1.some(call)), Match.orElse(() => Option$1.none())));
-const isPipeMethodCall = (parent) => Match.value(parent.callee).pipe(Match.when(isMemberExpression, (member) => Option$1.exists(staticMemberName(member), (name) => name === "pipe")), Match.orElse(() => false));
-const isEffectPipeCall = (parent, context, table) => Match.value(parent.callee).pipe(Match.when(isIdentifier$1, (reference) => Boolean$1$1.and(isVisible(reference.name, context), table.pipeBindings.has(reference.name))), Match.when(isMemberExpression, (member) => Option$1.exists(staticMemberName(member), (name) => Boolean$1$1.and(name === "pipe", isPipeNamespace(member.object, context, table)))), Match.orElse(() => false));
-const isPipeNamespace = (expression, context, table) => Match.value(expression).pipe(Match.when(isIdentifier$1, (reference) => Option$1.match(namespaceOf(expression, context, table), {
+const parentCall = (context) => Option$1.flatMap(Option$1.fromNullishOr(context.parent), (parent) => Match$1.value(parent).pipe(Match$1.when(isCallExpression$1, (call) => Option$1.some(call)), Match$1.orElse(() => Option$1.none())));
+const isPipeMethodCall = (parent) => Match$1.value(parent.callee).pipe(Match$1.when(isMemberExpression, (member) => Option$1.exists(staticMemberName(member), (name) => name === "pipe")), Match$1.orElse(() => false));
+const isEffectPipeCall = (parent, context, table) => Match$1.value(parent.callee).pipe(Match$1.when(isIdentifier$1, (reference) => Boolean$1$1.and(isVisible(reference.name, context), table.pipeBindings.has(reference.name))), Match$1.when(isMemberExpression, (member) => Option$1.exists(staticMemberName(member), (name) => Boolean$1$1.and(name === "pipe", isPipeNamespace(member.object, context, table)))), Match$1.orElse(() => false));
+const isPipeNamespace = (expression, context, table) => Match$1.value(expression).pipe(Match$1.when(isIdentifier$1, (reference) => Option$1.match(namespaceOf(expression, context, table), {
 	onNone: () => false,
 	onSome: (binding) => Boolean$1$1.and(isPipeNamespaceBinding(binding), isVisible(reference.name, context))
-})), Match.orElse(() => false));
-const isPipeNamespaceBinding = (binding) => Match.value(binding.kind).pipe(Match.when((kind) => kind === "root", () => true), Match.when((kind) => kind === "functionModule", () => true), Match.orElse(() => false));
+})), Match$1.orElse(() => false));
+const isPipeNamespaceBinding = (binding) => Match$1.value(binding.kind).pipe(Match$1.when((kind) => kind === "root", () => true), Match$1.when((kind) => kind === "functionModule", () => true), Match$1.orElse(() => false));
 const moduleAccessFunction = (callee, context, table) => (module) => Arr.findFirst([
 	ownerAccessFor(callee, module),
 	namedModuleAccess(module, context, table),
@@ -3458,17 +3474,17 @@ const YIELD_OR_AWAIT_KINDS = {
 	AwaitExpression: true,
 	YieldExpression: true
 };
-const isDroppableArgument = (node) => Match.value(node).pipe(Match.when(isIdentifier$1, () => true), Match.when(isLiteral, () => true), Match.when(isThisExpression, () => true), Match.when(isFunctionLike, () => true), Match.when(isMemberExpression, (member) => isCallFreeMemberChain(member)), Match.orElse(() => false));
-const isCallFreeMemberChain = (member) => Match.value(member.computed).pipe(Match.when(true, () => false), Match.orElse(() => Match.value(member.object).pipe(Match.when(isIdentifier$1, () => true), Match.when(isThisExpression, () => true), Match.when(isMemberExpression, (inner) => isCallFreeMemberChain(inner)), Match.orElse(() => false))));
+const isDroppableArgument = (node) => Match$1.value(node).pipe(Match$1.when(isIdentifier$1, () => true), Match$1.when(isLiteral, () => true), Match$1.when(isThisExpression, () => true), Match$1.when(isFunctionLike, () => true), Match$1.when(isMemberExpression, (member) => isCallFreeMemberChain(member)), Match$1.orElse(() => false));
+const isCallFreeMemberChain = (member) => Match$1.value(member.computed).pipe(Match$1.when(true, () => false), Match$1.orElse(() => Match$1.value(member.object).pipe(Match$1.when(isIdentifier$1, () => true), Match$1.when(isThisExpression, () => true), Match$1.when(isMemberExpression, (inner) => isCallFreeMemberChain(inner)), Match$1.orElse(() => false))));
 const identifiersIn = (node) => allNodesUnder(node).flatMap((candidate) => Option$1.toArray(identifierText(candidate)));
 const freshIdentifierDataFirst = (base, taken) => freeIdentifier(base, taken, 0);
 const freshIdentifier = dual((args) => args.length >= 2, freshIdentifierDataFirst);
-const freeIdentifier = (base, taken, suffix) => Match.value(taken.has(suffixedName(base, suffix))).pipe(Match.when(false, () => suffixedName(base, suffix)), Match.orElse(() => freeIdentifier(base, taken, suffix + 1)));
-const suffixedName = (base, suffix) => Match.value(suffix).pipe(Match.when(0, () => base), Match.orElse((count) => `${base}${count}`));
+const freeIdentifier = (base, taken, suffix) => Match$1.value(taken.has(suffixedName(base, suffix))).pipe(Match$1.when(false, () => suffixedName(base, suffix)), Match$1.orElse(() => freeIdentifier(base, taken, suffix + 1)));
+const suffixedName = (base, suffix) => Match$1.value(suffix).pipe(Match$1.when(0, () => base), Match$1.orElse((count) => `${base}${count}`));
 const isShadowed = (name, context) => context.ancestors.some((ancestor) => scopeDeclares(ancestor, name));
 const isVisible = (name, context) => isShadowed(name, context) === false;
 const unshadowedName = (name, context) => onlyWhen(isVisible(name, context), name);
-const scopeDeclares = (ancestor, name) => Match.value(ancestor).pipe(Match.when(isProgram, (program) => statementsDeclare(program.body, name)), Match.when(isBlockStatement, (block) => statementsDeclare(block.body, name)), Match.when(isStaticBlock, (block) => statementsDeclare(block.body, name)), Match.when(isTSModuleBlock, (block) => statementsDeclare(block.body, name)), Match.when(isSwitchStatement, (statement) => statement.cases.some((caseClause) => statementsDeclare(caseClause.consequent, name))), Match.when(isFunctionLike, (fn) => functionDeclares(fn, name)), Match.when(isCatchClause, (clause) => patternDeclaresOr(clause.param, name)), Match.when(isForStatement, (statement) => variableDeclarationDeclaresOr(statement.init, name)), Match.when(isForInStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), Match.when(isForOfStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), Match.when(isClassLike, (cls) => declaresIdentifier(cls.id, name)), Match.orElse(() => false));
+const scopeDeclares = (ancestor, name) => Match$1.value(ancestor).pipe(Match$1.when(isProgram, (program) => statementsDeclare(program.body, name)), Match$1.when(isBlockStatement, (block) => statementsDeclare(block.body, name)), Match$1.when(isStaticBlock, (block) => statementsDeclare(block.body, name)), Match$1.when(isTSModuleBlock, (block) => statementsDeclare(block.body, name)), Match$1.when(isSwitchStatement, (statement) => statement.cases.some((caseClause) => statementsDeclare(caseClause.consequent, name))), Match$1.when(isFunctionLike, (fn) => functionDeclares(fn, name)), Match$1.when(isCatchClause, (clause) => patternDeclaresOr(clause.param, name)), Match$1.when(isForStatement, (statement) => variableDeclarationDeclaresOr(statement.init, name)), Match$1.when(isForInStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), Match$1.when(isForOfStatement, (statement) => variableDeclarationDeclaresOr(statement.left, name)), Match$1.when(isClassLike, (cls) => declaresIdentifier(cls.id, name)), Match$1.orElse(() => false));
 const functionDeclares = (fn, name) => holdsAny([
 	fn.params.some((param) => patternDeclaresOr(param, name)),
 	declaresIdentifier(fn.id, name),
@@ -3476,25 +3492,25 @@ const functionDeclares = (fn, name) => holdsAny([
 ]);
 const blockBodyDeclaresHoistedVar = (body, name) => Option$1.match(Option$1.fromNullishOr(body), {
 	onNone: () => false,
-	onSome: (present) => Match.value(present).pipe(Match.when(isBlockStatement, (block) => hoistedVarsDeclare(block, name)), Match.orElse(() => false))
+	onSome: (present) => Match$1.value(present).pipe(Match$1.when(isBlockStatement, (block) => hoistedVarsDeclare(block, name)), Match$1.orElse(() => false))
 });
 const hoistedVarsDeclare = (block, name) => nodesOutsideFunctions(block).some((candidate) => hoistedCandidateDeclares(candidate, name));
-const hoistedCandidateDeclares = (candidate, name) => Match.value(candidate).pipe(Match.when(isVariableDeclaration, (declaration) => Boolean$1$1.and(declaration.kind === "var", statementBindingsDeclare(declaration, name))), Match.orElse(() => false));
+const hoistedCandidateDeclares = (candidate, name) => Match$1.value(candidate).pipe(Match$1.when(isVariableDeclaration, (declaration) => Boolean$1$1.and(declaration.kind === "var", statementBindingsDeclare(declaration, name))), Match$1.orElse(() => false));
 const statementsDeclare = (statements, name) => statements.some((statement) => statementDeclares(statement, name));
-const statementDeclares = (statement, name) => Match.value(statement).pipe(Match.when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), Match.when(isFunctionDeclaration, (declaration) => declaresIdentifier(declaration.id, name)), Match.when(isClassLike, (declaration) => declaresIdentifier(declaration.id, name)), Match.when(isTSEnumDeclaration, (declaration) => declaration.id.name === name), Match.when(isTSModuleDeclaration, (declaration) => moduleDeclarationDeclares(declaration, name)), Match.when(isTSImportEqualsDeclaration, (declaration) => importEqualsDeclares(declaration, name)), Match.when(isExportNamedDeclaration, (declaration) => Option$1.exists(Option$1.fromNullishOr(declaration.declaration), (inner) => statementDeclares(inner, name))), Match.orElse(() => false));
+const statementDeclares = (statement, name) => Match$1.value(statement).pipe(Match$1.when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), Match$1.when(isFunctionDeclaration, (declaration) => declaresIdentifier(declaration.id, name)), Match$1.when(isClassLike, (declaration) => declaresIdentifier(declaration.id, name)), Match$1.when(isTSEnumDeclaration, (declaration) => declaration.id.name === name), Match$1.when(isTSModuleDeclaration, (declaration) => moduleDeclarationDeclares(declaration, name)), Match$1.when(isTSImportEqualsDeclaration, (declaration) => importEqualsDeclares(declaration, name)), Match$1.when(isExportNamedDeclaration, (declaration) => Option$1.exists(Option$1.fromNullishOr(declaration.declaration), (inner) => statementDeclares(inner, name))), Match$1.orElse(() => false));
 const statementBindingsDeclare = (declaration, name) => declaration.declarations.some((declarator) => patternDeclaresOr(declarator.id, name));
 const variableDeclarationDeclaresOr = (node, name) => Option$1.match(Option$1.fromNullishOr(node), {
 	onNone: () => false,
-	onSome: (present) => Match.value(present).pipe(Match.when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), Match.orElse(() => false))
+	onSome: (present) => Match$1.value(present).pipe(Match$1.when(isVariableDeclaration, (declaration) => statementBindingsDeclare(declaration, name)), Match$1.orElse(() => false))
 });
 const moduleDeclarationDeclares = (declaration, name) => Boolean$1$1.and(declaration.body !== null, Option$1.exists(identifierText(declaration.id), (text) => text === name));
 const importEqualsDeclares = (declaration, name) => Boolean$1$1.and(declaration.importKind !== "type", declaration.id.name === name);
 const declaresIdentifier = (id, name) => Option$1.exists(identifierText(id), (text) => text === name);
 const patternDeclaresOr = (pattern, name) => Option$1.match(Option$1.fromNullishOr(pattern), {
 	onNone: () => false,
-	onSome: (present) => Match.value(present).pipe(Match.when(isBindingIdentifierPattern, (binding) => binding.name === name), Match.when(isObjectBindingPattern, (object) => object.properties.some((property) => propertyDeclares(property, name))), Match.when(isArrayBindingPattern, (array) => array.elements.some((element) => patternDeclaresOr(element, name))), Match.when(isAssignmentBindingPattern, (assignment) => patternDeclaresOr(assignment.left, name)), Match.when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), Match.orElse(() => false))
+	onSome: (present) => Match$1.value(present).pipe(Match$1.when(isBindingIdentifierPattern, (binding) => binding.name === name), Match$1.when(isObjectBindingPattern, (object) => object.properties.some((property) => propertyDeclares(property, name))), Match$1.when(isArrayBindingPattern, (array) => array.elements.some((element) => patternDeclaresOr(element, name))), Match$1.when(isAssignmentBindingPattern, (assignment) => patternDeclaresOr(assignment.left, name)), Match$1.when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), Match$1.orElse(() => false))
 });
-const propertyDeclares = (property, name) => Match.value(property).pipe(Match.when(isBindingProperty, (binding) => patternDeclaresOr(binding.value, name)), Match.when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), Match.orElse(() => false));
+const propertyDeclares = (property, name) => Match$1.value(property).pipe(Match$1.when(isBindingProperty, (binding) => patternDeclaresOr(binding.value, name)), Match$1.when(isBindingRestElement, (rest) => patternDeclaresOr(rest.argument, name)), Match$1.orElse(() => false));
 const isBindingIdentifierPattern = (candidate) => nodeType(candidate) === "Identifier";
 const isObjectBindingPattern = (candidate) => nodeType(candidate) === "ObjectPattern";
 const isArrayBindingPattern = (candidate) => nodeType(candidate) === "ArrayPattern";
@@ -3503,11 +3519,11 @@ const isBindingRestElement = (candidate) => nodeType(candidate) === "RestElement
 const isBindingProperty = (candidate) => nodeType(candidate) === "Property";
 const identifierText = (node) => Option$1.match(Option$1.fromNullishOr(node), {
 	onNone: () => Option$1.none(),
-	onSome: (present) => Match.value(present).pipe(Match.when(isNamedIdentifier, (name) => Option$1.some(name.name)), Match.when(isStringLiteral$1, (literal) => literalValueText(literal.value)), Match.orElse(() => Option$1.none()))
+	onSome: (present) => Match$1.value(present).pipe(Match$1.when(isNamedIdentifier, (name) => Option$1.some(name.name)), Match$1.when(isStringLiteral$1, (literal) => literalValueText(literal.value)), Match$1.orElse(() => Option$1.none()))
 });
-const literalValueText = (value) => Match.value(value).pipe(Match.when(Predicate$1.isString, (text) => Option$1.some(text)), Match.orElse(() => Option$1.none()));
+const literalValueText = (value) => Match$1.value(value).pipe(Match$1.when(Predicate$1.isString, (text) => Option$1.some(text)), Match$1.orElse(() => Option$1.none()));
 const moduleExportName = (name) => Option$1.getOrElse(identifierText(name), () => "");
-const staticMemberName = (member) => Match.value(member.computed).pipe(Match.when(false, () => identifierText(member.property)), Match.orElse(() => Option$1.none()));
+const staticMemberName = (member) => Match$1.value(member.computed).pipe(Match$1.when(false, () => identifierText(member.property)), Match$1.orElse(() => Option$1.none()));
 const nodesOutsideFunctions = (root) => {
 	const collected = [];
 	traverse(make(root), { enter(path) {
@@ -3529,7 +3545,7 @@ const pruneAtFunction = (path) => Option$1.match(onlyWhen(isFunctionLike(path.no
 });
 const moduleCallDataFirst = (module, property, args) => callExpression(memberExpression(module, identifier(property), false), args);
 const moduleCall = dual((args) => args.length >= 3, moduleCallDataFirst);
-const onlyWhenDataFirst = (holds, value) => Match.value(holds).pipe(Match.when(true, () => Option$1.some(value)), Match.orElse(() => Option$1.none()));
+const onlyWhenDataFirst = (holds, value) => Match$1.value(holds).pipe(Match$1.when(true, () => Option$1.some(value)), Match$1.orElse(() => Option$1.none()));
 const onlyWhen = dual((args) => args.length >= 2, onlyWhenDataFirst);
 const holdsAny = (conditions) => conditions.some((condition) => condition);
 const sameNode = (first, second) => first === second;
@@ -3587,7 +3603,7 @@ const atomicUpdateSplitMutatorDataFirst = (node, context) => Option$1.match(reso
 });
 const atomicUpdateSplitMutator = dual((args) => args.length >= 2, atomicUpdateSplitMutatorDataFirst);
 const atomicUpdateSplitReplacement = (call) => Option$1.flatMap(splitOperation(call), (operation) => Option$1.some(replacementExpression$1(operation)));
-const splitOperation = (call) => Match.value(call).pipe(Match.when(isAtomicUpdateSplitOperation, (covered) => splitOperationOf(covered)), Match.orElse(() => Option$1.none()));
+const splitOperation = (call) => Match$1.value(call).pipe(Match$1.when(isAtomicUpdateSplitOperation, (covered) => splitOperationOf(covered)), Match$1.orElse(() => Option$1.none()));
 const isAtomicUpdateSplitOperation = (call) => Boolean$1$1.and(included(ATOMIC_UPDATE_SPLIT_MODULES, call.module), included(ATOMIC_UPDATE_SPLIT_OPERATIONS, call.exportName));
 const splitOperationOf = (call) => Option$1.flatMap(moduleBindings(call), (bindings) => Option$1.flatMap(splitArguments$1(call), (args) => Option$1.some({
 	effectModule: bindings.effectModule,
@@ -3597,7 +3613,7 @@ const splitOperationOf = (call) => Option$1.flatMap(moduleBindings(call), (bindi
 	f: args.f,
 	binders: freshBinders$1(takenNames$2(call, bindings, args.f))
 })));
-const splitArguments$1 = (call) => Match.value(call.form).pipe(Match.when((form) => form === "data-first", () => dataFirstArguments$1(call)), Match.when((form) => form === "piped-reference", () => Option$1.none()), Match.orElse(() => dataLastArguments(call)));
+const splitArguments$1 = (call) => Match$1.value(call.form).pipe(Match$1.when((form) => form === "data-first", () => dataFirstArguments$1(call)), Match$1.when((form) => form === "piped-reference", () => Option$1.none()), Match$1.orElse(() => dataLastArguments(call)));
 const dataFirstArguments$1 = (call) => Option$1.flatMap(Arr.get(call.args, 0), (ref) => Option$1.flatMap(Arr.get(call.args, 1), (f) => onlyWhen(Boolean$1$1.and(isMovableArgument(ref), isMovableArgument(f)), {
 	ref: Option$1.some(cloneNode(ref)),
 	f: cloneNode(f)
@@ -3650,8 +3666,8 @@ const replacementExpression = (call, effect, form, split, shape) => {
 	};
 	return placedBody(form, bodyExpression(plan), binders);
 };
-const coveredForm = (call) => Match.value(call.form).pipe(Match.when("data-first", () => Option$1.some("data-first")), Match.when("data-last-pipe-arg", () => Option$1.some("data-last")), Match.when("data-last-pipe-method", () => Option$1.some("data-last")), Match.when("data-last-immediate", () => Option$1.some("data-last")), Match.orElse(() => Option$1.none()));
-const splitArguments = (call, form) => Match.value(form).pipe(Match.when("data-first", () => dataFirstArguments(call)), Match.orElse(() => Option$1.some({
+const coveredForm = (call) => Match$1.value(call.form).pipe(Match$1.when("data-first", () => Option$1.some("data-first")), Match$1.when("data-last-pipe-arg", () => Option$1.some("data-last")), Match$1.when("data-last-pipe-method", () => Option$1.some("data-last")), Match$1.when("data-last-immediate", () => Option$1.some("data-last")), Match$1.orElse(() => Option$1.none()));
+const splitArguments = (call, form) => Match$1.value(form).pipe(Match$1.when("data-first", () => dataFirstArguments(call)), Match$1.orElse(() => Option$1.some({
 	self: Option$1.none(),
 	rest: [...call.args]
 })));
@@ -3660,7 +3676,7 @@ const dataFirstArguments = (call) => Option$1.map(Arr.get(call.args, 0), (self)
 	rest: call.args.slice(1)
 }));
 const selfExpression = (split, binders) => Option$1.getOrElse(split.self, () => identifier(binders.self));
-const shapeOf = (exportName, rest) => Match.value(exportName).pipe(Match.when("ensuring", () => finalizerShape(rest)), Match.when("onExit", () => exitShape(rest)), Match.when("onError", () => handlerShape(rest)), Match.when("onInterrupt", () => droppedHandlerShape(rest)), Match.when("acquireRelease", () => releaseShape(rest)), Match.when("acquireUseRelease", () => useReleaseShape(rest)), Match.orElse(() => Option$1.none()));
+const shapeOf = (exportName, rest) => Match$1.value(exportName).pipe(Match$1.when("ensuring", () => finalizerShape(rest)), Match$1.when("onExit", () => exitShape(rest)), Match$1.when("onError", () => handlerShape(rest)), Match$1.when("onInterrupt", () => droppedHandlerShape(rest)), Match$1.when("acquireRelease", () => releaseShape(rest)), Match$1.when("acquireUseRelease", () => useReleaseShape(rest)), Match$1.orElse(() => Option$1.none()));
 const finalizerShape = (rest) => Option$1.flatMap(Arr.get(rest, 0), (fin) => onlyWhen(isMovableArgument(fin), {
 	kind: "ensuring",
 	fin
@@ -3691,19 +3707,19 @@ const droppableOptionAt = (rest, index) => Option$1.match(Arr.get(rest, index),
 	onNone: () => Option$1.some(true),
 	onSome: (argument) => onlyWhen(isDroppableArgument(argument), true)
 });
-const bodyExpression = (plan) => Match.value(plan.shape).pipe(Match.when({ kind: "ensuring" }, (shape) => moduleCall(plan.effect, "onExitIf", [
+const bodyExpression = (plan) => Match$1.value(plan.shape).pipe(Match$1.when({ kind: "ensuring" }, (shape) => moduleCall(plan.effect, "onExitIf", [
 	plan.self,
 	notInterruptedPredicate(plan.binders),
 	arrowFunctionExpression([], shape.fin)
-])), Match.when({ kind: "onExit" }, (shape) => moduleCall(plan.effect, "onExitIf", [
+])), Match$1.when({ kind: "onExit" }, (shape) => moduleCall(plan.effect, "onExitIf", [
 	plan.self,
 	notInterruptedPredicate(plan.binders),
 	shape.f
-])), Match.when({ kind: "onError" }, (shape) => moduleCall(plan.effect, "onErrorIf", [
+])), Match$1.when({ kind: "onError" }, (shape) => moduleCall(plan.effect, "onErrorIf", [
 	plan.self,
 	noInterruptPredicate(plan.binders),
 	shape.h
-])), Match.when({ kind: "onInterrupt" }, () => plan.self), Match.when({ kind: "acquireRelease" }, (shape) => releaseBody(plan, shape)), Match.when({ kind: "acquireUseRelease" }, (shape) => useReleaseBody(plan, shape)), Match.exhaustive);
+])), Match$1.when({ kind: "onInterrupt" }, () => plan.self), Match$1.when({ kind: "acquireRelease" }, (shape) => releaseBody(plan, shape)), Match$1.when({ kind: "acquireUseRelease" }, (shape) => useReleaseBody(plan, shape)), Match$1.exhaustive);
 const releaseBody = (plan, shape) => moduleCall(plan.effect, "flatMap", [moduleCall(plan.effect, "interruptible", [plan.self]), arrowFunctionExpression([identifier(plan.binders.a)], moduleCall(plan.effect, "acquireRelease", [moduleCall(plan.effect, "succeed", [identifier(plan.binders.a)]), shape.rel]))]);
 const useReleaseBody = (plan, shape) => moduleCall(plan.effect, "acquireUseRelease", [
 	plan.self,
@@ -3711,11 +3727,11 @@ const useReleaseBody = (plan, shape) => moduleCall(plan.effect, "acquireUseRelea
 	arrowFunctionExpression([identifier(plan.binders.a), identifier(plan.binders.exit)], conditionalExpression(notInterruptedTest(plan.binders), appliedRelease(shape.rel, plan.binders, shape.releaseArity), memberExpression(plan.effect, identifier("void"), false)))
 ]);
 const appliedRelease = (rel, binders, releaseArity) => callExpression(rel, Arr.take([identifier(binders.a), identifier(binders.exit)], releaseArity));
-const releaseArityOf = (rel) => Match.value(rel).pipe(Match.when(isInlineFunction, plainParameterArity), Match.orElse(() => Option$1.none()));
+const releaseArityOf = (rel) => Match$1.value(rel).pipe(Match$1.when(isInlineFunction, plainParameterArity), Match$1.orElse(() => Option$1.none()));
 const isInlineFunction = (candidate) => nodeType(candidate) === "ArrowFunctionExpression" || nodeType(candidate) === "FunctionExpression";
 const plainParameterArity = (fn) => onlyWhen(Boolean$1$1.and(fn.params.every(isPlainParameter), fn.params.length <= 2), fn.params.length);
 const isPlainParameter = (param) => nodeType(param) === "Identifier";
-const placedBody = (form, body, binders) => Match.value(form).pipe(Match.when("data-first", () => body), Match.orElse(() => arrowFunctionExpression([identifier(binders.self)], body)));
+const placedBody = (form, body, binders) => Match$1.value(form).pipe(Match$1.when("data-first", () => body), Match$1.orElse(() => arrowFunctionExpression([identifier(binders.self)], body)));
 const notInterruptedPredicate = (binders) => arrowFunctionExpression([identifier(binders.exit)], notInterruptedTest(binders));
 const notInterruptedTest = (binders) => logicalExpression("||", tagCheck(binders.exit, SUCCESS_TAG), unaryExpression("!", interruptionSome(failureReasons(binders.exit), binders.reason)));
 const noInterruptPredicate = (binders) => arrowFunctionExpression([identifier(binders.cause)], unaryExpression("!", interruptionSome(causeReasons(binders.cause), binders.reason)));
@@ -3737,16 +3753,16 @@ const synchronizationRemovalMutatorDataFirst = (node, context) => Option$1.match
 	onSome: (call) => Option$1.toArray(synchronizationRemovalReplacement(call))
 });
 const synchronizationRemovalMutator = dual((args) => args.length >= 2, synchronizationRemovalMutatorDataFirst);
-const synchronizationRemovalReplacement = (call) => Match.value(call).pipe(Match.when(isWithPermits, withPermitsReplacement), Match.when(isWithPermit, withPermitReplacement), Match.when(isUninterruptible, uninterruptibleReplacement), Match.when(isUninterruptibleMask, uninterruptibleMaskReplacement), Match.orElse(() => Option$1.none()));
+const synchronizationRemovalReplacement = (call) => Match$1.value(call).pipe(Match$1.when(isWithPermits, withPermitsReplacement), Match$1.when(isWithPermit, withPermitReplacement), Match$1.when(isUninterruptible, uninterruptibleReplacement), Match$1.when(isUninterruptibleMask, uninterruptibleMaskReplacement), Match$1.orElse(() => Option$1.none()));
 const isWithPermits = (call) => Boolean$1$1.and(call.module === "Semaphore", call.exportName === "withPermits");
 const isWithPermit = (call) => Boolean$1$1.and(call.module === "Semaphore", call.exportName === "withPermit");
 const isUninterruptible = (call) => Boolean$1$1.and(call.module === "Effect", call.exportName === "uninterruptible");
 const isUninterruptibleMask = (call) => Boolean$1$1.and(call.module === "Effect", call.exportName === "uninterruptibleMask");
 const isDataFirst = (form) => form === "data-first";
 const isPipedReference = (form) => form === "piped-reference";
-const withPermitsReplacement = (call) => Match.value(call.form).pipe(Match.when(isDataFirst, () => whenDroppable(call, [0, 1], (guarded) => argumentReplacement(guarded, 2))), Match.orElse(() => whenDroppable(call, [0, 1], identityFunctionOf)));
-const withPermitReplacement = (call) => Match.value(call.form).pipe(Match.when(isDataFirst, () => whenDroppable(call, [0], (guarded) => argumentReplacement(guarded, 1))), Match.orElse(() => whenDroppable(call, [0], identityFunctionOf)));
-const uninterruptibleReplacement = (call) => Match.value(call.form).pipe(Match.when(isPipedReference, () => Option$1.some(identityFunction(call))), Match.orElse(() => argumentReplacement(call, 0)));
+const withPermitsReplacement = (call) => Match$1.value(call.form).pipe(Match$1.when(isDataFirst, () => whenDroppable(call, [0, 1], (guarded) => argumentReplacement(guarded, 2))), Match$1.orElse(() => whenDroppable(call, [0, 1], identityFunctionOf)));
+const withPermitReplacement = (call) => Match$1.value(call.form).pipe(Match$1.when(isDataFirst, () => whenDroppable(call, [0], (guarded) => argumentReplacement(guarded, 1))), Match$1.orElse(() => whenDroppable(call, [0], identityFunctionOf)));
+const uninterruptibleReplacement = (call) => Match$1.value(call.form).pipe(Match$1.when(isPipedReference, () => Option$1.some(identityFunction(call))), Match$1.orElse(() => argumentReplacement(call, 0)));
 const uninterruptibleMaskReplacement = (call) => whenMovable(call, [0], (masked) => Option$1.flatMap(masked.moduleAccess("Effect"), (effectModule) => Option$1.map(Arr.get(masked.args, 0), (f) => maskedReplacement(effectModule, f))));
 const maskedReplacement = (effectModule, f) => moduleCall(effectModule, "suspend", [arrowFunctionExpression([], callExpression(cloneNode(f), [memberExpression(effectModule, identifier("interruptible"), false)]))]);
 const argumentReplacement = (call, index) => Option$1.map(Arr.get(call.args, index), (argument) => cloneNode(argument));
@@ -3808,16 +3824,16 @@ function toApiMutant(mutant) {
 	});
 }
 function applyMutantDataFirst(mutant, originalTree) {
-	return Match.value(originalTree === mutant.original).pipe(Match.when(true, () => Result.succeed(mutant.replacement)), Match.when(false, () => cloneWithReplacement(mutant, originalTree)), Match.exhaustive);
+	return Match$1.value(originalTree === mutant.original).pipe(Match$1.when(true, () => Result.succeed(mutant.replacement)), Match$1.when(false, () => cloneWithReplacement(mutant, originalTree)), Match$1.exhaustive);
 }
 const applyMutant = dual((args) => args.length >= 2, applyMutantDataFirst);
 function cloneWithReplacement(mutant, originalTree) {
 	const mutatedAst = cloneNode(originalTree);
 	const { original, replacement } = mutant;
-	return Match.value(hasReplaced(mutatedAst, original, replacement)).pipe(Match.when(true, () => Result.succeed(mutatedAst)), Match.when(false, () => Result.fail(MutantNotApplied.make({
+	return Match$1.value(hasReplaced(mutatedAst, original, replacement)).pipe(Match$1.when(true, () => Result.succeed(mutatedAst)), Match$1.when(false, () => Result.fail(MutantNotApplied.make({
 		fileName: mutant.fileName,
 		mutatorName: mutant.mutatorName
-	}))), Match.exhaustive);
+	}))), Match$1.exhaustive);
 }
 function hasReplaced(root, original, replacement) {
 	let applied = false;
@@ -3827,7 +3843,7 @@ function hasReplaced(root, original, replacement) {
 	return applied;
 }
 function replaceFirstMatch(path, original, replacement) {
-	return Match.value(eqNode(path.node, original)).pipe(Match.when(false, () => false), Match.orElse(() => {
+	return Match$1.value(eqNode(path.node, original)).pipe(Match$1.when(false, () => false), Match$1.orElse(() => {
 		path.replaceWith(replacement);
 		return true;
 	}));
@@ -3900,7 +3916,7 @@ function collectSplices(pattern, flags) {
 	return groups;
 }
 function collectAssertion(assertion, pattern, groups) {
-	Match.value(assertion).pipe(Match.when(isEdgeAssertion, (edge) => pushAnchor(edge, pattern, groups)), Match.when(isLookaround, (lookaround) => groups.rest.push(lookaroundNegation(lookaround))), Match.orElse(() => void 0));
+	Match$1.value(assertion).pipe(Match$1.when(isEdgeAssertion, (edge) => pushAnchor(edge, pattern, groups)), Match$1.when(isLookaround, (lookaround) => groups.rest.push(lookaroundNegation(lookaround))), Match$1.orElse(() => void 0));
 }
 function isEdgeAssertion(assertion) {
 	return assertion.kind === "start" || assertion.kind === "end";
@@ -3912,10 +3928,10 @@ function pushAnchor(edge, pattern, groups) {
 	pushWhen(anchorGroup(edge, groups), anchorRemoval(edge, pattern));
 }
 function anchorGroup(edge, groups) {
-	return Match.value(edge.kind).pipe(Match.when("start", () => groups.bol), Match.orElse(() => groups.eol));
+	return Match$1.value(edge.kind).pipe(Match$1.when("start", () => groups.bol), Match$1.orElse(() => groups.eol));
 }
 function lookaroundNegation(lookaround) {
-	return Match.value(lookaround.kind).pipe(Match.when("lookahead", () => lookaroundSplice(lookaround, 2)), Match.orElse(() => lookaroundSplice(lookaround, 3)));
+	return Match$1.value(lookaround.kind).pipe(Match$1.when("lookahead", () => lookaroundSplice(lookaround, 2)), Match$1.orElse(() => lookaroundSplice(lookaround, 3)));
 }
 function lookaroundSplice(lookaround, markerWidth) {
 	return {
@@ -3926,16 +3942,16 @@ function lookaroundSplice(lookaround, markerWidth) {
 	};
 }
 function negationMarker(negate) {
-	return Match.value(negate).pipe(Match.when(true, () => "="), Match.orElse(() => "!"));
+	return Match$1.value(negate).pipe(Match$1.when(true, () => "="), Match$1.orElse(() => "!"));
 }
 function collectCharacterClass(characterClass, groups) {
 	const pos = characterClass.start + 1;
-	groups.rest.push(Match.value(characterClass.negate).pipe(Match.when(true, () => ({
+	groups.rest.push(Match$1.value(characterClass.negate).pipe(Match$1.when(true, () => ({
 		start: pos,
 		end: pos + 1,
 		text: "",
 		priority: 1
-	})), Match.orElse(() => ({
+	})), Match$1.orElse(() => ({
 		start: pos,
 		end: pos,
 		text: "^",
@@ -3946,7 +3962,7 @@ function collectCharacterSet(characterSet, groups) {
 	pushWhen(groups.rest, characterSetSplice(characterSet));
 }
 function characterSetSplice(characterSet) {
-	return Match.value(characterSet.kind).pipe(Match.when((kind) => NEGATABLE_CHARACTER_SETS[kind] === true, () => classSplice(characterSet)), Match.orElse(() => void 0));
+	return Match$1.value(characterSet.kind).pipe(Match$1.when((kind) => NEGATABLE_CHARACTER_SETS[kind] === true, () => classSplice(characterSet)), Match$1.orElse(() => void 0));
 }
 const NEGATABLE_CHARACTER_SETS = {
 	digit: true,
@@ -4011,7 +4027,7 @@ function withOperator(node, operator) {
 }
 /** The mutants a condition selects, built only when it holds. */
 function mutantsWhen(holds, build) {
-	return Match.value(holds).pipe(Match.when(true, build), Match.orElse(() => NO_MUTANTS));
+	return Match$1.value(holds).pipe(Match$1.when(true, build), Match$1.orElse(() => NO_MUTANTS));
 }
 const hasPropertyIn = (node, key) => key in node;
 const readPropertyOf = (node, key) => hasPropertyIn(node, key) ? node[key] : void 0;
@@ -4032,7 +4048,7 @@ const arithmeticOperatorReplacements = Object.freeze({
 	"%": "*"
 });
 const ARITHMETIC_OPERATOR_KEYS = Object.keys(arithmeticOperatorReplacements);
-const arithmeticOperatorMutator = (node) => Match.value(node).pipe(Match.when(isArithmeticBinary, (binary) => [withOperator(binary, arithmeticOperatorReplacements[binary.operator])]), Match.orElse(() => NO_MUTANTS));
+const arithmeticOperatorMutator = (node) => Match$1.value(node).pipe(Match$1.when(isArithmeticBinary, (binary) => [withOperator(binary, arithmeticOperatorReplacements[binary.operator])]), Match$1.orElse(() => NO_MUTANTS));
 function isArithmeticBinary(node) {
 	return isBinaryExpression(node) && isSupportedArithmeticOperator(node.operator, node);
 }
@@ -4053,7 +4069,7 @@ function isStringConcatenation(node) {
 function outerLeftOperand(node) {
 	return node.left.type === "BinaryExpression" ? node.left.right : node.left;
 }
-const arrayDeclarationMutator = (node) => Match.value(node).pipe(Match.when(isArrayExpression, (array) => [arrayDeclarationReplacement(array)]), Match.when(isArrayConstructorCall, (construct) => [arrayConstructorReplacement(construct)]), Match.orElse(() => NO_MUTANTS));
+const arrayDeclarationMutator = (node) => Match$1.value(node).pipe(Match$1.when(isArrayExpression, (array) => [arrayDeclarationReplacement(array)]), Match$1.when(isArrayConstructorCall, (construct) => [arrayConstructorReplacement(construct)]), Match$1.orElse(() => NO_MUTANTS));
 function isArrayExpression(node) {
 	return node.type === "ArrayExpression";
 }
@@ -4077,7 +4093,7 @@ function arrayConstructorReplacement(construct) {
 function constructorArguments(args) {
 	return args.length > 0 ? [] : [arrayExpression([])];
 }
-const arrowFunctionMutator = (node) => Match.value(node).pipe(Match.when(isExpressionBodiedArrow, () => [arrowFunctionExpression([], identifier("undefined"))]), Match.orElse(() => NO_MUTANTS));
+const arrowFunctionMutator = (node) => Match$1.value(node).pipe(Match$1.when(isExpressionBodiedArrow, () => [arrowFunctionExpression([], identifier("undefined"))]), Match$1.orElse(() => NO_MUTANTS));
 function isExpressionBodiedArrow(node) {
 	return node.type === "ArrowFunctionExpression" && hasMutableArrowBody(node.body);
 }
@@ -4119,7 +4135,7 @@ const stringAssignmentTypes = Object.freeze([
 	"??="
 ]);
 const ASSIGNMENT_OPERATOR_KEYS = Object.keys(assignmentOperatorReplacements);
-const assignmentOperatorMutator = (node) => Match.value(node).pipe(Match.when(isMutatableAssignment, (assignment) => [withOperator(assignment, assignmentOperatorReplacements[assignment.operator])]), Match.orElse(() => NO_MUTANTS));
+const assignmentOperatorMutator = (node) => Match$1.value(node).pipe(Match$1.when(isMutatableAssignment, (assignment) => [withOperator(assignment, assignmentOperatorReplacements[assignment.operator])]), Match$1.orElse(() => NO_MUTANTS));
 function isMutatableAssignment(node) {
 	return node.type === "AssignmentExpression" && isSupportedAssignment(node);
 }
@@ -4196,7 +4212,7 @@ function hasSuperInChildren(node) {
 function containsSuperInValue(value) {
 	return Array.isArray(value) ? value.some(containsSuperCall) : containsSuperCall(value);
 }
-const booleanLiteralMutator = (node) => Match.value(node).pipe(Match.when(isBooleanLiteral, (literal) => [booleanLiteral(!literal.value)]), Match.when(isNegatedPrefix, (unary) => [cloneNode(unary.argument)]), Match.orElse(() => NO_MUTANTS));
+const booleanLiteralMutator = (node) => Match$1.value(node).pipe(Match$1.when(isBooleanLiteral, (literal) => [booleanLiteral(!literal.value)]), Match$1.when(isNegatedPrefix, (unary) => [cloneNode(unary.argument)]), Match$1.orElse(() => NO_MUTANTS));
 function isBooleanLiteral(node) {
 	return node.type === "Literal" && typeof node.value === "boolean";
 }
@@ -4221,15 +4237,15 @@ const booleanOperators = Object.freeze([
 	">=",
 	"||"
 ]);
-const conditionalExpressionMutator = (node, context) => Match.value(isTestOfLoop(node, context)).pipe(Match.when(true, () => [booleanLiteral(false)]), Match.orElse(() => conditionTestMutants(node, context)));
+const conditionalExpressionMutator = (node, context) => Match$1.value(isTestOfLoop(node, context)).pipe(Match$1.when(true, () => [booleanLiteral(false)]), Match$1.orElse(() => conditionTestMutants(node, context)));
 function conditionTestMutants(node, context) {
-	return Match.value(isTestOfCondition(node, context)).pipe(Match.when(true, () => [booleanLiteral(true), booleanLiteral(false)]), Match.orElse(() => booleanExpressionMutants(node, context)));
+	return Match$1.value(isTestOfCondition(node, context)).pipe(Match$1.when(true, () => [booleanLiteral(true), booleanLiteral(false)]), Match$1.orElse(() => booleanExpressionMutants(node, context)));
 }
 function booleanExpressionMutants(node, context) {
-	return Match.value(isBooleanExpression(node)).pipe(Match.when(true, () => booleanExpressionReplacements(context)), Match.orElse(() => statementMutants(node)));
+	return Match$1.value(isBooleanExpression(node)).pipe(Match$1.when(true, () => booleanExpressionReplacements(context)), Match$1.orElse(() => statementMutants(node)));
 }
 function statementMutants(node) {
-	return Match.value(node).pipe(Match.when(isEmptyTestForStatement, (loop) => [withEmptyTest(loop)]), Match.when(isNonEmptySwitchCase, (switchCase) => [withEmptyConsequent(switchCase)]), Match.orElse(() => NO_MUTANTS));
+	return Match$1.value(node).pipe(Match$1.when(isEmptyTestForStatement, (loop) => [withEmptyTest(loop)]), Match$1.when(isNonEmptySwitchCase, (switchCase) => [withEmptyConsequent(switchCase)]), Match$1.orElse(() => NO_MUTANTS));
 }
 function withEmptyTest(loop) {
 	const replacement = cloneNode(loop);
@@ -4249,10 +4265,10 @@ function isNonEmptySwitchCase(node) {
 }
 /** A `true` test only matters in `a && b` and a `false` one in `a || b`; any other parent takes both. */
 function booleanExpressionReplacements(context) {
-	return Match.value(logicalParentOperator(context.parent)).pipe(Match.when("&&", () => [booleanLiteral(true)]), Match.when("||", () => [booleanLiteral(false)]), Match.orElse(() => [booleanLiteral(true), booleanLiteral(false)]));
+	return Match$1.value(logicalParentOperator(context.parent)).pipe(Match$1.when("&&", () => [booleanLiteral(true)]), Match$1.when("||", () => [booleanLiteral(false)]), Match$1.orElse(() => [booleanLiteral(true), booleanLiteral(false)]));
 }
 function logicalParentOperator(parent) {
-	return Match.value(parent).pipe(Match.when(isLogicalExpression, (logical) => logical.operator), Match.orElse(() => void 0));
+	return Match$1.value(parent).pipe(Match$1.when(isLogicalExpression, (logical) => logical.operator), Match$1.orElse(() => void 0));
 }
 function isLogicalExpression(node) {
 	return node?.type === "LogicalExpression";
@@ -4284,7 +4300,7 @@ function isTestBearingStatement(node) {
 	return node !== void 0 && TEST_BEARING_KINDS[node.type] === true;
 }
 function testOfStatement(node) {
-	return Match.value(node).pipe(Match.when(isTestBearingStatement, (statement) => statement.test ?? void 0), Match.orElse(() => void 0));
+	return Match$1.value(node).pipe(Match$1.when(isTestBearingStatement, (statement) => statement.test ?? void 0), Match$1.orElse(() => void 0));
 }
 function isBooleanExpression(node) {
 	return isOperatorExpression(node) && booleanOperators.includes(node.operator);
@@ -4303,7 +4319,7 @@ const operators = {
 	"!==": ["==="]
 };
 const EQUALITY_OPERATOR_KEYS = Object.keys(operators);
-const equalityOperatorMutator = (node) => Match.value(node).pipe(Match.when(isEqualityBinary, (binary) => mutatedEqualityOperators(binary)), Match.orElse(() => NO_MUTANTS));
+const equalityOperatorMutator = (node) => Match$1.value(node).pipe(Match$1.when(isEqualityBinary, (binary) => mutatedEqualityOperators(binary)), Match$1.orElse(() => NO_MUTANTS));
 function isEqualityBinary(node) {
 	return node.type === "BinaryExpression" && EQUALITY_OPERATOR_KEYS.includes(node.operator);
 }
@@ -4316,7 +4332,7 @@ const logicalOperatorReplacements = Object.freeze({
 	"??": "&&"
 });
 const LOGICAL_OPERATOR_KEYS = Object.keys(logicalOperatorReplacements);
-const logicalOperatorMutator = (node) => Match.value(node).pipe(Match.when(isSupportedLogicalOperator, (binary) => [withOperator(binary, logicalOperatorReplacements[binary.operator])]), Match.orElse(() => NO_MUTANTS));
+const logicalOperatorMutator = (node) => Match$1.value(node).pipe(Match$1.when(isSupportedLogicalOperator, (binary) => [withOperator(binary, logicalOperatorReplacements[binary.operator])]), Match$1.orElse(() => NO_MUTANTS));
 function isSupportedLogicalOperator(node) {
 	return node.type === "LogicalExpression" && LOGICAL_OPERATOR_KEYS.includes(node.operator);
 }
@@ -4351,9 +4367,9 @@ const replacements = {
 	...baseReplacements,
 	...reverseReplacements
 };
-const methodExpressionMutator = (node) => Match.value(node).pipe(Match.when(isCallExpression, (call) => methodCallMutants(call)), Match.orElse(() => NO_MUTANTS));
+const methodExpressionMutator = (node) => Match$1.value(node).pipe(Match$1.when(isCallExpression, (call) => methodCallMutants(call)), Match$1.orElse(() => NO_MUTANTS));
 function methodCallMutants(call) {
-	return Match.value(methodMutation(call)).pipe(Match.when(isMethodMutation, (mutation) => [methodExpressionReplacement(mutation)]), Match.orElse(() => NO_MUTANTS));
+	return Match$1.value(methodMutation(call)).pipe(Match$1.when(isMethodMutation, (mutation) => [methodExpressionReplacement(mutation)]), Match$1.orElse(() => NO_MUTANTS));
 }
 function isMethodMutation(mutation) {
 	return mutation !== void 0;
@@ -4361,19 +4377,19 @@ function isMethodMutation(mutation) {
 /** The method this call replaces, or `undefined` when the call is not one this operator knows. */
 function methodMutation(call) {
 	const callee = namedMethodCallee(call);
-	return Match.value(callee).pipe(Match.when(void 0, () => void 0), Match.orElse((member) => mutationFor(call, member)));
+	return Match$1.value(callee).pipe(Match$1.when(void 0, () => void 0), Match$1.orElse((member) => mutationFor(call, member)));
 }
 function mutationFor(call, callee) {
 	const methodName = callee.property.name;
 	const replacement = Object.hasOwn(replacements, methodName) ? replacements[methodName] : void 0;
-	return Match.value(replacement).pipe(Match.when(void 0, () => void 0), Match.orElse((newName) => ({
+	return Match$1.value(replacement).pipe(Match$1.when(void 0, () => void 0), Match$1.orElse((newName) => ({
 		call,
 		callee,
 		newName
 	})));
 }
 function namedMethodCallee(call) {
-	return Match.value(call.callee).pipe(Match.when(isNamedMember, (member) => member), Match.orElse(() => void 0));
+	return Match$1.value(call.callee).pipe(Match$1.when(isNamedMember, (member) => member), Match$1.orElse(() => void 0));
 }
 function isNamedMember(node) {
 	return isMemberProperty(node) && isNotSuperMember(node);
@@ -4385,7 +4401,7 @@ function isNotSuperMember(member) {
 	return !isSuperType(member.object);
 }
 function methodExpressionReplacement(mutation) {
-	return Match.value(mutation.newName).pipe(Match.when(null, () => callExpression(cloneNode(mutation.callee.object), [], mutation.callee.optional === true)), Match.orElse((newName) => renamedMethodCall(mutation, newName)));
+	return Match$1.value(mutation.newName).pipe(Match$1.when(null, () => callExpression(cloneNode(mutation.callee.object), [], mutation.callee.optional === true)), Match$1.orElse((newName) => renamedMethodCall(mutation, newName)));
 }
 function renamedMethodCall(mutation, newName) {
 	const mutatedCallee = memberExpression(cloneNode(mutation.callee.object), identifier(newName), mutation.callee.optional === true);
@@ -4397,14 +4413,14 @@ function spreadFreeArguments(args) {
 function isNotSpreadElement(node) {
 	return node.type !== "SpreadElement";
 }
-const objectLiteralMutator = (node) => Match.value(node).pipe(Match.when(isNonEmptyObjectLiteral, () => [{
+const objectLiteralMutator = (node) => Match$1.value(node).pipe(Match$1.when(isNonEmptyObjectLiteral, () => [{
 	type: "ObjectExpression",
 	properties: []
-}]), Match.orElse(() => NO_MUTANTS));
+}]), Match$1.orElse(() => NO_MUTANTS));
 function isNonEmptyObjectLiteral(node) {
 	return node.type === "ObjectExpression" && node.properties.length > 0;
 }
-const optionalChainingMutator = (node) => Match.value(node).pipe(Match.when(isOptionalMember, (member) => [withoutOptional(member)]), Match.when(isOptionalCall, (call) => [withoutOptional(call)]), Match.orElse(() => NO_MUTANTS));
+const optionalChainingMutator = (node) => Match$1.value(node).pipe(Match$1.when(isOptionalMember, (member) => [withoutOptional(member)]), Match$1.when(isOptionalCall, (call) => [withoutOptional(call)]), Match$1.orElse(() => NO_MUTANTS));
 function isOptionalMember(node) {
 	return node.type === "MemberExpression" && node.optional === true;
 }
@@ -4416,7 +4432,7 @@ function withoutOptional(node) {
 	replacement.optional = false;
 	return replacement;
 }
-const regexMutator = (node, context) => Match.value(node).pipe(Match.when(isRegexLiteral, (literal) => regexLiteralMutants(literal)), Match.when(isStringLiteral, (literal) => mutantsWhen(isObviousRegexString(literal, context), () => regexConstructorMutants(literal, context))), Match.orElse(() => NO_MUTANTS));
+const regexMutator = (node, context) => Match$1.value(node).pipe(Match$1.when(isRegexLiteral, (literal) => regexLiteralMutants(literal)), Match$1.when(isStringLiteral, (literal) => mutantsWhen(isObviousRegexString(literal, context), () => regexConstructorMutants(literal, context))), Match$1.orElse(() => NO_MUTANTS));
 function isRegexLiteral(node) {
 	return nodeType(node) === "Literal" && Predicate$1.isNotNullish(propertyOf(node, "regex"));
 }
@@ -4440,13 +4456,13 @@ function isRegExpIdentifier(node) {
 	return node.type === "Identifier" && node.name === RegExp.name;
 }
 function newExpressionArgument(parent, index) {
-	return Match.value(parent).pipe(Match.when(isNewExpression, (call) => call.arguments[index]), Match.orElse(() => void 0));
+	return Match$1.value(parent).pipe(Match$1.when(isNewExpression, (call) => call.arguments[index]), Match$1.orElse(() => void 0));
 }
 function regexFlags(parent) {
-	return Match.value(newExpressionArgument(parent, 1)).pipe(Match.when(isStringLiteral, (literal) => literal.value), Match.orElse(() => void 0));
+	return Match$1.value(newExpressionArgument(parent, 1)).pipe(Match$1.when(isStringLiteral, (literal) => literal.value), Match$1.orElse(() => void 0));
 }
 const PLACEHOLDER = "Stryker was here!";
-const stringLiteralMutator = (node, context) => Match.value(node).pipe(Match.when(isTemplateLiteral, (template) => templateMutants(template)), Match.when(isStringLiteral, (literal) => mutantsWhen(isValidParent(literal, context), () => [stringLiteral(replacementText(literal.value.length === 0))])), Match.orElse(() => NO_MUTANTS));
+const stringLiteralMutator = (node, context) => Match$1.value(node).pipe(Match$1.when(isTemplateLiteral, (template) => templateMutants(template)), Match$1.when(isStringLiteral, (literal) => mutantsWhen(isValidParent(literal, context), () => [stringLiteral(replacementText(literal.value.length === 0))])), Match$1.orElse(() => NO_MUTANTS));
 function templateMutants(template) {
 	const first = template.quasis[0];
 	return Option$1.match(Option$1.fromNullishOr(first), {
@@ -4512,7 +4528,7 @@ function isDisallowedCallExpression(parent) {
 	return isCallExpression(parent) && DISALLOWED_CALLEES[calleeName(parent)] === true;
 }
 function calleeName(parent) {
-	return Match.value(parent.callee).pipe(Match.when(isIdentifier, (identifier) => identifier.name), Match.when(isImportCallee, () => "import"), Match.orElse(() => ""));
+	return Match$1.value(parent.callee).pipe(Match$1.when(isIdentifier, (identifier) => identifier.name), Match$1.when(isImportCallee, () => "import"), Match$1.orElse(() => ""));
 }
 function isImportCallee(callee) {
 	return nodeType(callee) === "Import";
@@ -4523,7 +4539,7 @@ const UnaryOperator = {
 	"~": ""
 };
 const UNARY_OPERATOR_KEYS = Object.keys(UnaryOperator);
-const unaryOperatorMutator = (node) => Match.value(node).pipe(Match.when(isSupportedUnaryExpression, (unary) => [unaryOperatorReplacement(unary)]), Match.orElse(() => NO_MUTANTS));
+const unaryOperatorMutator = (node) => Match$1.value(node).pipe(Match$1.when(isSupportedUnaryExpression, (unary) => [unaryOperatorReplacement(unary)]), Match$1.orElse(() => NO_MUTANTS));
 function isSupportedUnaryExpression(node) {
 	return isPrefixUnaryExpression(node) && isSupportedUnaryOperator(node.operator);
 }
@@ -4533,7 +4549,7 @@ function isPrefixUnaryExpression(node) {
 /** The sign-flipping unary becomes a flipped unary; `~x` loses its operator entirely. */
 function unaryOperatorReplacement(unary) {
 	const mutatedOperator = UnaryOperator[unary.operator];
-	return Match.value(mutatedOperator).pipe(Match.when(isPlusOrMinus, (operator) => unaryExpression(operator, cloneNode(unary.argument))), Match.orElse(() => cloneNode(unary.argument)));
+	return Match$1.value(mutatedOperator).pipe(Match$1.when(isPlusOrMinus, (operator) => unaryExpression(operator, cloneNode(unary.argument))), Match$1.orElse(() => cloneNode(unary.argument)));
 }
 function isSupportedUnaryOperator(operator) {
 	return UNARY_OPERATOR_KEYS.includes(operator);
@@ -4545,7 +4561,7 @@ const UpdateOperators = {
 	"++": "--",
 	"--": "++"
 };
-const updateOperatorMutator = (node) => Match.value(node).pipe(Match.when(isUpdateExpression, (update) => [updateExpression(UpdateOperators[update.operator], cloneNode(update.argument), update.prefix)]), Match.orElse(() => NO_MUTANTS));
+const updateOperatorMutator = (node) => Match$1.value(node).pipe(Match$1.when(isUpdateExpression, (update) => [updateExpression(UpdateOperators[update.operator], cloneNode(update.argument), update.prefix)]), Match$1.orElse(() => NO_MUTANTS));
 function isUpdateExpression(node) {
 	return node.type === "UpdateExpression";
 }
@@ -4647,7 +4663,7 @@ const oxcParseFailure = (errors, fileName, lineStarts) => Option$1.match(Option$
 	})
 });
 const oxcErrorLabelStart = (error) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(error.labels.at(0)), (label) => label.start), () => 0);
-const createParser = () => ({ parse: (code, fileName, scriptFormat) => Match.value(scriptFormat).pipe(Match.when("js", () => parseJS(code, fileName)), Match.when("ts", () => parseTS(code, fileName)), Match.when("tsx", () => parseTsx(code, fileName)), Match.exhaustive) });
+const createParser = () => ({ parse: (code, fileName, scriptFormat) => Match$1.value(scriptFormat).pipe(Match$1.when("js", () => parseJS(code, fileName)), Match$1.when("ts", () => parseTS(code, fileName)), Match$1.when("tsx", () => parseTsx(code, fileName)), Match$1.exhaustive) });
 const parseJSDataFirst = Effect$1.fn("stryker.instrument.parser.parseJS")(function* (text, fileName) {
 	const parsed = yield* parseWithOxc(text, fileName, "js");
 	return {
@@ -4775,7 +4791,7 @@ const jumpStatementText = (keyword, label) => Option$1.match(Option$1.fromNullis
 	onSome: (value) => `${keyword} ${value.name};`,
 	onNone: () => `${keyword};`
 });
-const emitComment = (comment) => Match.value(comment.type).pipe(Match.when("Line", () => `//${comment.value}\n`), Match.orElse(() => `/*${comment.value}*/\n`));
+const emitComment = (comment) => Match$1.value(comment.type).pipe(Match$1.when("Line", () => `//${comment.value}\n`), Match$1.orElse(() => `/*${comment.value}*/\n`));
 const hashbangPrefix = (hashbang) => Option$1.match(Option$1.fromNullishOr(hashbang), {
 	onNone: () => "",
 	onSome: (value) => `#!${value.value}\n`
@@ -4808,7 +4824,7 @@ const printNodePrec = (ctx, node, prec) => Option$1.match(Option$1.fromNullishOr
 	onSome: (value) => dispatchNode(ctx, value, prec)
 });
 const unknownNodeText = (type) => `/* unknown:${type} */`;
-const nodeText = Match.type().pipe(Match.withReturnType(), Match.discriminatorsExhaustive("type")({
+const nodeText = Match$1.type().pipe(Match$1.withReturnType(), Match$1.discriminatorsExhaustive("type")({
 	Literal: (n) => () => literalText(n),
 	Identifier: (n) => () => n.name,
 	PrivateIdentifier: (n) => () => `#${n.name}`,
@@ -4977,7 +4993,7 @@ const nodeText = Match.type().pipe(Match.withReturnType(), Match.discriminatorsE
 	TSQualifiedName: (n) => () => unknownNodeText(n.type)
 }));
 const dispatchNode = (ctx, node, prec) => nodeText(node)(ctx, prec);
-const tsTypeText = Match.type().pipe(Match.withReturnType(), Match.discriminatorsExhaustive("type")({
+const tsTypeText = Match$1.type().pipe(Match$1.withReturnType(), Match$1.discriminatorsExhaustive("type")({
 	TSAnyKeyword: () => () => "any",
 	TSStringKeyword: () => () => "string",
 	TSBooleanKeyword: () => () => "boolean",
@@ -5021,7 +5037,7 @@ const typeTextOf = (ctx, node) => Option$1.match(Option$1.filter(Option$1.some(n
 	onSome: (typed) => printTSTypeToString(ctx, typed),
 	onNone: () => unknownNodeText(node.type)
 });
-const statementKindText = (ctx, node) => Match.value(node).pipe(Match.withReturnType(), Match.when(isFunctionNode, (n) => functionText(ctx, n)), Match.when(isClassNode, (n) => classText(ctx, n)), Match.discriminatorsExhaustive("type")({
+const statementKindText = (ctx, node) => Match$1.value(node).pipe(Match$1.withReturnType(), Match$1.when(isFunctionNode, (n) => functionText(ctx, n)), Match$1.when(isClassNode, (n) => classText(ctx, n)), Match$1.discriminatorsExhaustive("type")({
 	BlockStatement: (n) => blockStatementText(ctx, n),
 	VariableDeclaration: (n) => `${variableDeclarationText(ctx, n)};`,
 	ExpressionStatement: (n) => expressionStatementText(ctx, n),
@@ -5062,10 +5078,10 @@ const literalWithoutRegex = (node) => Option$1.match(Option$1.fromNullishOr(node
 	onSome: (bigint) => bigint,
 	onNone: () => valueLiteralText(node.value)
 });
-const valueLiteralText = (value) => Match.value(value).pipe(Match.when(Match.string, (v) => JSON.stringify(v)), Match.orElse(nonStringLiteralText));
-const nonStringLiteralText = (value) => Match.value(value).pipe(Match.when(Match.number, (v) => String(v)), Match.orElse(booleanOrBigintText));
-const booleanOrBigintText = (value) => Match.value(value).pipe(Match.when(Match.boolean, (v) => String(v)), Match.orElse(bigintText));
-const bigintText = (value) => Match.value(value).pipe(Match.when((candidate) => typeof candidate === "bigint", (v) => `${String(v)}n`), Match.orElse(() => "null"));
+const valueLiteralText = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.string, (v) => JSON.stringify(v)), Match$1.orElse(nonStringLiteralText));
+const nonStringLiteralText = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.number, (v) => String(v)), Match$1.orElse(booleanOrBigintText));
+const booleanOrBigintText = (value) => Match$1.value(value).pipe(Match$1.when(Match$1.boolean, (v) => String(v)), Match$1.orElse(bigintText));
+const bigintText = (value) => Match$1.value(value).pipe(Match$1.when((candidate) => typeof candidate === "bigint", (v) => `${String(v)}n`), Match$1.orElse(() => "null"));
 const flagText = (present, text) => Boolean$1$1.match(Predicate$1.isTruthy(present), {
 	onTrue: () => text,
 	onFalse: () => ""
@@ -5079,18 +5095,18 @@ const objectExpressionText = (ctx, node) => Boolean$1$1.match(node.properties.le
 	onTrue: () => "{}",
 	onFalse: () => `{ ${nodeListText(ctx, node.properties, PREC.Sequence)} }`
 });
-const propertyText = (ctx, node) => Match.value(propertyFormOf(node)).pipe(Match.when("accessor", () => `${node.kind} ${propertyKeyText(ctx, node.key, node.computed === true, PREC.Assignment)}${functionValueTailText(ctx, node.value)}`), Match.when("method", () => `${propertyKeyText(ctx, node.key, node.computed === true, PREC.Assignment)}${functionValueTailText(ctx, node.value)}`), Match.when("shorthand", () => identifierNameText(node.key)), Match.when("shorthandDefault", () => shorthandDefaultPropertyText(ctx, node)), Match.orElse(() => `${propertyKeyText(ctx, node.key, node.computed === true, PREC.Assignment)}: ${printNodePrec(ctx, node.value, PREC.Assignment)}`));
-const functionValueTailText = (ctx, value) => Match.value(value).pipe(Match.when(isFunctionNode, (fn) => functionTailText(ctx, fn)), Match.orElse(() => ""));
-const shorthandDefaultPropertyText = (ctx, node) => Match.value(node.value).pipe(Match.when(isAssignmentPattern, (value) => `${identifierNameText(node.key)} = ${printNodePrec(ctx, value.right, PREC.Assignment)}`), Match.orElse(() => ""));
+const propertyText = (ctx, node) => Match$1.value(propertyFormOf(node)).pipe(Match$1.when("accessor", () => `${node.kind} ${propertyKeyText(ctx, node.key, node.computed === true, PREC.Assignment)}${functionValueTailText(ctx, node.value)}`), Match$1.when("method", () => `${propertyKeyText(ctx, node.key, node.computed === true, PREC.Assignment)}${functionValueTailText(ctx, node.value)}`), Match$1.when("shorthand", () => identifierNameText(node.key)), Match$1.when("shorthandDefault", () => shorthandDefaultPropertyText(ctx, node)), Match$1.orElse(() => `${propertyKeyText(ctx, node.key, node.computed === true, PREC.Assignment)}: ${printNodePrec(ctx, node.value, PREC.Assignment)}`));
+const functionValueTailText = (ctx, value) => Match$1.value(value).pipe(Match$1.when(isFunctionNode, (fn) => functionTailText(ctx, fn)), Match$1.orElse(() => ""));
+const shorthandDefaultPropertyText = (ctx, node) => Match$1.value(node.value).pipe(Match$1.when(isAssignmentPattern, (value) => `${identifierNameText(node.key)} = ${printNodePrec(ctx, value.right, PREC.Assignment)}`), Match$1.orElse(() => ""));
 const propertyKeyText = (ctx, key, computed, computedPrec) => Boolean$1$1.match(computed, {
 	onTrue: () => `[${dispatchNode(ctx, key, computedPrec)}]`,
 	onFalse: () => plainPropertyKeyText(ctx, key)
 });
-const plainPropertyKeyText = (ctx, key) => Match.value(key).pipe(Match.discriminators("type")({
+const plainPropertyKeyText = (ctx, key) => Match$1.value(key).pipe(Match$1.discriminators("type")({
 	Identifier: (n) => identifierNameText(n),
 	PrivateIdentifier: (n) => privateIdentifierText(n),
 	Literal: (n) => literalText(n)
-}), Match.orElse((n) => dispatchNode(ctx, n, PREC.Assignment)));
+}), Match$1.orElse((n) => dispatchNode(ctx, n, PREC.Assignment)));
 const functionTailText = (ctx, fn) => `${typeParametersText(ctx, fn.typeParameters)}(${paramsText(ctx, fn.params)})${typeAnnotationText(ctx, fn.returnType)}${functionBodyText(ctx, fn)}`;
 const functionBodyText = (ctx, fn) => Option$1.match(Option$1.fromNullishOr(fn.body), {
 	onSome: (body) => ` ${blockStatementText(ctx, body)}`,
@@ -5120,10 +5136,10 @@ const memberSelectorText = (ctx, access) => Boolean$1$1.match(access.computed, {
 	onTrue: () => `[${sequenceNodeText(ctx, access.property)}]`,
 	onFalse: () => `${flagText(!access.optional, ".")}${memberPropertyText(ctx, access.property)}`
 });
-const memberPropertyText = (ctx, property) => Match.value(property).pipe(Match.discriminators("type")({
+const memberPropertyText = (ctx, property) => Match$1.value(property).pipe(Match$1.discriminators("type")({
 	Identifier: (n) => identifierNameText(n),
 	PrivateIdentifier: (n) => privateIdentifierText(n)
-}), Match.orElse((n) => sequenceNodeText(ctx, n)));
+}), Match$1.orElse((n) => sequenceNodeText(ctx, n)));
 const callExpressionText = (ctx, node) => `${wrappedExpressionText(ctx, node.callee, PREC.Member, CALLEE_WRAPPED_KINDS)}${flagText(node.optional, "?.")}${typeArgumentsText(ctx, node.typeArguments)}(${nodeListText(ctx, node.arguments, PREC.Assignment)})`;
 const newExpressionText = (ctx, node) => `new ${dispatchNode(ctx, node.callee, PREC.Member)}${typeArgumentsText(ctx, node.typeArguments)}(${nodeListText(ctx, node.arguments, PREC.Assignment)})`;
 const metaPropertyText = (node) => `${node.meta.name}.${node.property.name}`;
@@ -5181,7 +5197,7 @@ const arrowParamsText = (ctx, node) => {
 		onFalse: () => bareParam
 	});
 };
-const arrowBodyText = (ctx, node) => Match.value(node.body).pipe(Match.discriminators("type")({ BlockStatement: (body) => blockStatementText(ctx, body) }), Match.orElse((body) => assignmentNodeText(ctx, body)));
+const arrowBodyText = (ctx, node) => Match$1.value(node.body).pipe(Match$1.discriminators("type")({ BlockStatement: (body) => blockStatementText(ctx, body) }), Match$1.orElse((body) => assignmentNodeText(ctx, body)));
 const functionText = (ctx, node) => `${functionHeaderText(node)}${functionTailText(ctx, node)}`;
 const classText = (ctx, node) => `${decoratorsText(ctx, node.decorators)}${flagText(node.declare, "declare ")}${flagText(node.abstract, "abstract ")}class${namedDeclarationText(node)}${typeParametersText(ctx, node.typeParameters)}${classHeritageText(ctx, node)}${classImplementsText(ctx, node)} ${classBodyText(ctx, node.body)}`;
 const classHeritageText = (ctx, node) => Option$1.match(Option$1.fromNullishOr(node.superClass), {
@@ -5208,30 +5224,30 @@ const jsxOpeningElementText = (ctx, node) => `<${jsxElementNameText(ctx, node.na
 	onTrue: () => " />",
 	onFalse: () => ">"
 })}`;
-const jsxElementNameText = (ctx, name) => Match.value(name).pipe(Match.discriminators("type")({
+const jsxElementNameText = (ctx, name) => Match$1.value(name).pipe(Match$1.discriminators("type")({
 	JSXIdentifier: (n) => n.name,
 	JSXNamespacedName: (n) => `${n.namespace.name}:${n.name.name}`,
 	JSXMemberExpression: (n) => jsxMemberExpressionText(n)
-}), Match.orElse(() => ""));
-const jsxMemberExpressionText = (node) => Match.value(node.object).pipe(Match.discriminators("type")({ JSXIdentifier: (obj) => `${obj.name}.${node.property.name}` }), Match.orElse((obj) => `${jsxMemberExpressionText(obj)}.${node.property.name}`));
+}), Match$1.orElse(() => ""));
+const jsxMemberExpressionText = (node) => Match$1.value(node.object).pipe(Match$1.discriminators("type")({ JSXIdentifier: (obj) => `${obj.name}.${node.property.name}` }), Match$1.orElse((obj) => `${jsxMemberExpressionText(obj)}.${node.property.name}`));
 const jsxAttributeText = (ctx, node) => `${jsxAttributeNameText(node.name)}${jsxAttributeValueClauseText(ctx, node.value)}`;
 const jsxAttributeValueClauseText = (ctx, value) => Option$1.match(Option$1.fromNullishOr(value), {
 	onSome: (nonNull) => `=${jsxAttributeValueText(ctx, nonNull)}`,
 	onNone: () => ""
 });
-const jsxAttributeValueText = (ctx, value) => Match.value(value).pipe(Match.discriminators("type")({
+const jsxAttributeValueText = (ctx, value) => Match$1.value(value).pipe(Match$1.discriminators("type")({
 	Literal: (n) => literalText(n),
 	JSXExpressionContainer: (n) => `{${sequenceNodeText(ctx, n.expression)}}`,
 	JSXElement: (n) => sequenceNodeText(ctx, n),
 	JSXFragment: (n) => sequenceNodeText(ctx, n)
-}), Match.orElse(() => ""));
-const jsxChildText = (ctx, child) => Match.value(child).pipe(Match.discriminators("type")({
+}), Match$1.orElse(() => ""));
+const jsxChildText = (ctx, child) => Match$1.value(child).pipe(Match$1.discriminators("type")({
 	JSXText: (n) => n.value,
 	JSXElement: (n) => jsxElementText(ctx, n),
 	JSXFragment: (n) => jsxFragmentText(ctx, n),
 	JSXExpressionContainer: (n) => `{${printNodePrec(ctx, n.expression, PREC.Sequence)}}`,
 	JSXSpreadChild: (n) => `{...${printNodePrec(ctx, n.expression, PREC.Assignment)}}`
-}), Match.orElse(() => ""));
+}), Match$1.orElse(() => ""));
 const tsAsExpressionText = (ctx, node, prec) => {
 	const myPrec = PREC.Relational;
 	return parenthesizedIf(myPrec < prec, `${dispatchNode(ctx, node.expression, myPrec)} as ${printTSTypeToString(ctx, node.typeAnnotation)}`);
@@ -5255,16 +5271,16 @@ const ifStatementText = (ctx, node) => `if (${printNodePrec(ctx, node.test, PREC
 	onSome: (alternate) => ` else ${statementOrBlockText(ctx, alternate)}`,
 	onNone: () => ""
 })}`;
-const statementOrBlockText = (ctx, node) => Match.value(node).pipe(Match.discriminators("type")({ BlockStatement: (n) => blockStatementText(ctx, n) }), Match.orElse((n) => statementText(ctx, n)));
+const statementOrBlockText = (ctx, node) => Match$1.value(node).pipe(Match$1.discriminators("type")({ BlockStatement: (n) => blockStatementText(ctx, n) }), Match$1.orElse((n) => statementText(ctx, n)));
 const whileStatementText = (ctx, node) => `while (${printNodePrec(ctx, node.test, PREC.Sequence)}) ${statementOrBlockText(ctx, node.body)}`;
 const doWhileStatementText = (ctx, node) => `do ${statementOrBlockText(ctx, node.body)} while (${printNodePrec(ctx, node.test, PREC.Sequence)});`;
 const forStatementText = (ctx, node) => `for (${declarationOrExpressionText(ctx, node.init)}; ${optionalSequenceText(ctx, node.test)}; ${optionalSequenceText(ctx, node.update)}) ${statementOrBlockText(ctx, node.body)}`;
 const declarationOrExpressionText = (ctx, node) => Option$1.match(Option$1.fromNullishOr(node), {
 	onNone: () => "",
-	onSome: (value) => Match.value(value).pipe(Match.discriminators("type")({ VariableDeclaration: (n) => variableDeclarationText(ctx, n) }), Match.orElse((n) => printNodePrec(ctx, n, PREC.Sequence)))
+	onSome: (value) => Match$1.value(value).pipe(Match$1.discriminators("type")({ VariableDeclaration: (n) => variableDeclarationText(ctx, n) }), Match$1.orElse((n) => printNodePrec(ctx, n, PREC.Sequence)))
 });
 const optionalSequenceText = (ctx, node) => sequenceNodeText(ctx, node);
-const forInStatementText = (ctx, node) => `for (${Match.value(node.left).pipe(Match.discriminators("type")({ VariableDeclaration: (n) => variableDeclarationText(ctx, n) }), Match.orElse((n) => printNodePrec(ctx, n, PREC.Sequence)))} in ${printNodePrec(ctx, node.right, PREC.Sequence)}) ${statementOrBlockText(ctx, node.body)}`;
+const forInStatementText = (ctx, node) => `for (${Match$1.value(node.left).pipe(Match$1.discriminators("type")({ VariableDeclaration: (n) => variableDeclarationText(ctx, n) }), Match$1.orElse((n) => printNodePrec(ctx, n, PREC.Sequence)))} in ${printNodePrec(ctx, node.right, PREC.Sequence)}) ${statementOrBlockText(ctx, node.body)}`;
 const forOfStatementText = (ctx, node) => `${Boolean$1$1.match(node.await, {
 	onTrue: () => "for await (",
 	onFalse: () => "for ("
@@ -5293,28 +5309,28 @@ const catchParamText = (ctx, param) => Option$1.match(Option$1.fromNullishOr(par
 	onSome: (value) => ` (${catchParamBodyText(ctx, value)})`,
 	onNone: () => ""
 });
-const catchParamBodyText = (ctx, param) => Match.value(param).pipe(Match.discriminators("type")({ Identifier: (n) => identifierWithOptionalText(ctx, n) }), Match.orElse((n) => sequenceNodeText(ctx, n)));
+const catchParamBodyText = (ctx, param) => Match$1.value(param).pipe(Match$1.discriminators("type")({ Identifier: (n) => identifierWithOptionalText(ctx, n) }), Match$1.orElse((n) => sequenceNodeText(ctx, n)));
 const finallyClauseText = (ctx, finalizer) => Option$1.match(Option$1.fromNullishOr(finalizer), {
 	onSome: (value) => ` finally ${blockStatementText(ctx, value)}`,
 	onNone: () => ""
 });
 const variableDeclarationText = (ctx, node) => `${flagText(node.declare, "declare ")}${node.kind} ${node.declarations.map((declaration) => variableDeclaratorText(ctx, declaration)).join(", ")}`;
 const variableDeclaratorText = (ctx, node) => `${bindingTargetText(ctx, node.id)}${flagText(node.definite, "!")}${typeAnnotationText(ctx, bindingTypeAnnotation(node.id))}${initializerText(ctx, node.init)}`;
-const bindingTargetText = (ctx, id) => Match.value(id).pipe(Match.discriminators("type")({ Identifier: (n) => `${bindingNameText(n)}${flagText(n.optional, "?")}` }), Match.orElse((n) => sequenceNodeText(ctx, n)));
+const bindingTargetText = (ctx, id) => Match$1.value(id).pipe(Match$1.discriminators("type")({ Identifier: (n) => `${bindingNameText(n)}${flagText(n.optional, "?")}` }), Match$1.orElse((n) => sequenceNodeText(ctx, n)));
 const identifierWithOptionalText = (ctx, node) => `${bindingNameText(node)}${flagText(node.optional, "?")}${typeAnnotationText(ctx, node.typeAnnotation)}`;
-const paramText = (ctx, param) => Match.value(param).pipe(Match.discriminators("type")({
+const paramText = (ctx, param) => Match$1.value(param).pipe(Match$1.discriminators("type")({
 	RestElement: (n) => restParamText(ctx, n),
 	TSParameterProperty: (n) => parameterPropertyText(ctx, n),
 	Identifier: (n) => formalParameterText(ctx, n),
 	ObjectPattern: (n) => formalParameterText(ctx, n),
 	ArrayPattern: (n) => formalParameterText(ctx, n),
 	AssignmentPattern: (n) => formalParameterText(ctx, n)
-}), Match.orElse(() => ""));
+}), Match$1.orElse(() => ""));
 const restParamText = (ctx, param) => `...${assignmentNodeText(ctx, param.argument)}${typeAnnotationText(ctx, param.typeAnnotation)}`;
 const parameterPropertyText = (ctx, param) => `${decoratorsText(ctx, param.decorators)}${parameterPropertyModifiers(param)}${parameterPropertyTargetText(ctx, param.parameter)}`;
-const parameterPropertyTargetText = (ctx, parameter) => Match.value(parameter).pipe(Match.discriminators("type")({ Identifier: (n) => identifierWithOptionalText(ctx, n) }), Match.orElse((n) => sequenceNodeText(ctx, n)));
+const parameterPropertyTargetText = (ctx, parameter) => Match$1.value(parameter).pipe(Match$1.discriminators("type")({ Identifier: (n) => identifierWithOptionalText(ctx, n) }), Match$1.orElse((n) => sequenceNodeText(ctx, n)));
 const formalParameterText = (ctx, param) => `${decoratorsText(ctx, param.decorators)}${formalParameterBodyText(ctx, param)}`;
-const formalParameterBodyText = (ctx, param) => Match.value(param).pipe(Match.discriminators("type")({ Identifier: (n) => identifierWithOptionalText(ctx, n) }), Match.orElse((n) => `${assignmentNodeText(ctx, n)}${typeAnnotationText(ctx, bindingTypeAnnotation(n))}`));
+const formalParameterBodyText = (ctx, param) => Match$1.value(param).pipe(Match$1.discriminators("type")({ Identifier: (n) => identifierWithOptionalText(ctx, n) }), Match$1.orElse((n) => `${assignmentNodeText(ctx, n)}${typeAnnotationText(ctx, bindingTypeAnnotation(n))}`));
 const classBodyText = (ctx, node) => Boolean$1$1.match(node.body.length === 0, {
 	onTrue: () => "{}",
 	onFalse: () => `{\n${indentedBodyText(ctx, node.body, (inner, element) => printNodePrec(inner, element, PREC.Sequence))}${indent(ctx)}}`
@@ -5348,7 +5364,7 @@ const exportSourceClauseText = (node) => Option$1.match(Option$1.fromNullishOr(n
 	onSome: (source) => ` from ${JSON.stringify(source.value)}${importAttributesText(node.attributes)}`,
 	onNone: () => ""
 });
-const exportDefaultDeclarationText = (ctx, node) => `export default ${Match.value(node.declaration).pipe(Match.when(isBareDefaultExport, (declaration) => statementText(ctx, declaration)), Match.orElse((declaration) => `${printNodePrec(ctx, declaration, PREC.Assignment)};`))}`;
+const exportDefaultDeclarationText = (ctx, node) => `export default ${Match$1.value(node.declaration).pipe(Match$1.when(isBareDefaultExport, (declaration) => statementText(ctx, declaration)), Match$1.orElse((declaration) => `${printNodePrec(ctx, declaration, PREC.Assignment)};`))}`;
 const exportAllDeclarationText = (ctx, node) => `export ${flagText(node.exportKind === "type", "type ")}*${exportedNameClauseText(node.exported)} from ${JSON.stringify(node.source.value)}${importAttributesText(node.attributes)};`;
 const tsTypeAliasDeclarationText = (ctx, node) => `${flagText(node.declare, "declare ")}type ${node.id.name}${typeParametersText(ctx, node.typeParameters)} = ${printTSTypeToString(ctx, node.typeAnnotation)};`;
 const tsInterfaceDeclarationText = (ctx, node) => `${flagText(node.declare, "declare ")}interface ${node.id.name}${typeParametersText(ctx, node.typeParameters)}${interfaceExtendsText(ctx, node.extends)} ${tsInterfaceBodyText(ctx, node.body)}`;
@@ -5360,13 +5376,13 @@ const tsInterfaceBodyText = (ctx, node) => Boolean$1$1.match(node.body.length ==
 	onTrue: () => "{}",
 	onFalse: () => `{\n${indentedBodyText(ctx, node.body, printTSSignatureText)}${indent(ctx)}}`
 });
-const printTSSignatureText = (ctx, sig) => Match.value(sig).pipe(Match.discriminators("type")({
+const printTSSignatureText = (ctx, sig) => Match$1.value(sig).pipe(Match$1.discriminators("type")({
 	TSPropertySignature: (n) => printTSPropertySignatureText(ctx, n),
 	TSIndexSignature: (n) => printTSIndexSignatureText(ctx, n),
 	TSCallSignatureDeclaration: (n) => printTSCallSignatureText(ctx, n),
 	TSConstructSignatureDeclaration: (n) => printTSConstructSignatureText(ctx, n),
 	TSMethodSignature: (n) => printTSMethodSignatureText(ctx, n)
-}), Match.orElse(() => ""));
+}), Match$1.orElse(() => ""));
 const printTSPropertySignatureText = (ctx, node) => `${flagText(node.readonly, "readonly ")}${propertyKeyText(ctx, node.key, node.computed === true, PREC.Sequence)}${flagText(node.optional, "?")}${typeAnnotationText(ctx, node.typeAnnotation)};`;
 const printTSIndexSignatureText = (ctx, node) => {
 	const parameters = node.parameters.map((parameter) => indexParameterText(ctx, parameter)).join(", ");
@@ -5378,10 +5394,10 @@ const printTSConstructSignatureText = (ctx, node) => `new ${typeParametersText(c
 const printTSMethodSignatureText = (ctx, node) => `${methodKindText(node.kind)}${propertyKeyText(ctx, node.key, node.computed === true, PREC.Sequence)}${flagText(node.optional, "?")}${typeParametersText(ctx, node.typeParameters)}(${paramsText(ctx, node.params)})${typeAnnotationText(ctx, node.returnType)};`;
 const tsEnumDeclarationText = (ctx, node) => `${flagText(node.declare, "declare ")}${flagText(node.const, "const ")}enum ${node.id.name} {\n${indentedBodyText(ctx, node.body.members, printEnumMemberText)}${indent(ctx)}}`;
 const printEnumMemberText = (ctx, member) => `${identifierOrLiteralNameText(ctx, member.id)}${initializerText(ctx, member.initializer)},`;
-const identifierOrLiteralNameText = (ctx, id) => Match.value(id).pipe(Match.discriminators("type")({
+const identifierOrLiteralNameText = (ctx, id) => Match$1.value(id).pipe(Match$1.discriminators("type")({
 	Identifier: (n) => identifierNameText(n),
 	Literal: (n) => literalText(n)
-}), Match.orElse((n) => sequenceNodeText(ctx, n)));
+}), Match$1.orElse((n) => sequenceNodeText(ctx, n)));
 const tsModuleDeclarationText = (ctx, node) => `${flagText(node.declare, "declare ")}${moduleHeaderText(ctx, node)}${moduleBodyText(ctx, node)}`;
 const moduleHeaderText = (ctx, node) => Boolean$1$1.match(node.global === true, {
 	onTrue: () => "global ",
@@ -5393,7 +5409,7 @@ const moduleBodyText = (ctx, node) => Option$1.match(Option$1.fromNullishOr(node
 });
 const tsModuleBlockText = (ctx, node) => `{\n${indentedBodyText(ctx, node.body, statementText)}${indent(ctx)}}`;
 const tsImportEqualsDeclarationText = (ctx, node) => `import ${flagText(node.importKind === "type", "type ")}${node.id.name} = ${moduleReferenceText(ctx, node.moduleReference)};`;
-const moduleReferenceText = (ctx, reference) => Match.value(reference).pipe(Match.discriminators("type")({ TSExternalModuleReference: (n) => `require(${externalModuleArgumentText(n.expression.value)})` }), Match.orElse((n) => sequenceNodeText(ctx, n)));
+const moduleReferenceText = (ctx, reference) => Match$1.value(reference).pipe(Match$1.discriminators("type")({ TSExternalModuleReference: (n) => `require(${externalModuleArgumentText(n.expression.value)})` }), Match$1.orElse((n) => sequenceNodeText(ctx, n)));
 const tsTypeListText = (ctx, types, separator) => types.map((type) => printTSTypeToString(ctx, type)).join(separator);
 const arrayElementTypeText = (ctx, type) => parenthesizedIf(ARRAY_ELEMENT_WRAPPED_KINDS[type.type] === true, printTSTypeToString(ctx, type));
 const printTSTypeLiteral = (ctx, members) => Boolean$1$1.match(members.length === 0, {
@@ -5408,18 +5424,18 @@ const signatureText = (ctx, member) => {
 	});
 };
 const printTupleType = (ctx, elements) => `[${elements.map((element) => printTupleElement(ctx, element)).join(", ")}]`;
-const printTupleElement = (ctx, element) => Match.value(element).pipe(Match.discriminators("type")({
+const printTupleElement = (ctx, element) => Match$1.value(element).pipe(Match$1.discriminators("type")({
 	TSRestType: (n) => `...${printTSTypeToString(ctx, n.typeAnnotation)}`,
 	TSOptionalType: (n) => `${printTSTypeToString(ctx, n.typeAnnotation)}?`,
 	TSNamedTupleMember: (n) => printNamedTupleMember(ctx, n)
-}), Match.when(isTSType, (n) => printTSTypeToString(ctx, n)), Match.orElse(() => ""));
+}), Match$1.when(isTSType, (n) => printTSTypeToString(ctx, n)), Match$1.orElse(() => ""));
 const printNamedTupleMember = (ctx, member) => `${member.label.name}${flagText(member.optional, "?")}: ${printTupleElement(ctx, member.elementType)}`;
 const printTypeClause = (ctx, keyword, type) => Option$1.match(Option$1.fromNullishOr(type), {
 	onSome: (value) => `${keyword}${printTSTypeToString(ctx, value)}`,
 	onNone: () => ""
 });
-const printTypeQueryName = (ctx, node) => Match.value(node.exprName).pipe(Match.discriminators("type")({ TSImportType: (n) => printTSTypeToString(ctx, n) }), Match.orElse((n) => printTSTypeName(n)));
-const printTSTypeName = (name) => Match.value(name).pipe(Match.withReturnType(), Match.discriminatorsExhaustive("type")({
+const printTypeQueryName = (ctx, node) => Match$1.value(node.exprName).pipe(Match$1.discriminators("type")({ TSImportType: (n) => printTSTypeToString(ctx, n) }), Match$1.orElse((n) => printTSTypeName(n)));
+const printTSTypeName = (name) => Match$1.value(name).pipe(Match$1.withReturnType(), Match$1.discriminatorsExhaustive("type")({
 	TSQualifiedName: (n) => `${printTSTypeName(n.left)}.${n.right.name}`,
 	Identifier: (n) => n.name,
 	ThisExpression: () => "this"
@@ -5428,13 +5444,13 @@ const printTSImportTypeQualifier = (ctx, qualifier) => Option$1.match(Option$1.f
 	onSome: (value) => printTSImportTypeQualifierNode(ctx, value),
 	onNone: () => ""
 });
-const printTSImportTypeQualifierNode = (ctx, qualifier) => Match.value(qualifier).pipe(Match.discriminators("type")({ Identifier: (n) => n.name }), Match.orElse((n) => `${printTSImportTypeQualifier(ctx, n.left)}.${n.right.name}`));
+const printTSImportTypeQualifierNode = (ctx, qualifier) => Match$1.value(qualifier).pipe(Match$1.discriminators("type")({ Identifier: (n) => n.name }), Match$1.orElse((n) => `${printTSImportTypeQualifier(ctx, n.left)}.${n.right.name}`));
 const printTSImportType = (ctx, node) => `import(${JSON.stringify(node.source.value)}${flagText(node.options, `, ${assignmentNodeText(ctx, node.options)}`)})${Option$1.match(Option$1.fromNullishOr(node.qualifier), {
 	onSome: (qualifier) => `.${printTSImportTypeQualifierNode(ctx, qualifier)}`,
 	onNone: () => ""
 })}${typeArgumentsText(ctx, node.typeArguments)}`;
 const printMappedType = (ctx, node) => `{ ${printMappedTypeModifier(node.readonly, "readonly ")}[${node.key.name} in ${printTSTypeToString(ctx, node.constraint)}${printTypeClause(ctx, " as ", node.nameType)}]${printMappedTypeModifier(node.optional, "?")}${printTypeClause(ctx, ": ", node.typeAnnotation)} }`;
-const printMappedTypeModifier = (modifier, rendered) => Match.value(modifier).pipe(Match.when(true, () => rendered), Match.when("+", () => `+${rendered}`), Match.when("-", () => `-${rendered}`), Match.orElse(() => ""));
+const printMappedTypeModifier = (modifier, rendered) => Match$1.value(modifier).pipe(Match$1.when(true, () => rendered), Match$1.when("+", () => `+${rendered}`), Match$1.when("-", () => `-${rendered}`), Match$1.orElse(() => ""));
 const printTSTemplateLiteral = (ctx, node) => {
 	const tail = Arr.last(node.quasis);
 	const segments = Arr.zipWith(Arr.dropRight(node.quasis, 1), node.types, (quasi, type) => `${quasi.value.raw}\${${printTSTypeToString(ctx, type)}}`);
@@ -5448,11 +5464,11 @@ const printPredicateAnnotation = (ctx, node) => Option$1.match(Option$1.fromNull
 	onSome: (annotation) => printTypeClause(ctx, " is ", annotation.typeAnnotation),
 	onNone: () => ""
 });
-const printTSLiteralType = (ctx, literal) => Match.value(literal).pipe(Match.discriminators("type")({
+const printTSLiteralType = (ctx, literal) => Match$1.value(literal).pipe(Match$1.discriminators("type")({
 	Literal: (n) => literalText(n),
 	TemplateLiteral: (n) => templateLiteralText(ctx, n),
-	UnaryExpression: (n) => `${n.operator}${Match.value(n.argument).pipe(Match.discriminators("type")({ Literal: (argument) => literalText(argument) }), Match.orElse(() => ""))}`
-}), Match.orElse(() => ""));
+	UnaryExpression: (n) => `${n.operator}${Match$1.value(n.argument).pipe(Match$1.discriminators("type")({ Literal: (argument) => literalText(argument) }), Match$1.orElse(() => ""))}`
+}), Match$1.orElse(() => ""));
 const printJSDocPostfixModifier = (ctx, node, marker) => Boolean$1$1.match(node.postfix, {
 	onTrue: () => `${printTSTypeToString(ctx, node.typeAnnotation)}${marker}`,
 	onFalse: () => `${marker}${printTSTypeToString(ctx, node.typeAnnotation)}`
@@ -5519,9 +5535,9 @@ const identifierName = (node) => Option$1.getOrUndefined(Option$1.map(Option$1.f
 const identifierNameText = (node) => identifierName(node) ?? "";
 const privateIdentifierText = (node) => Option$1.match(Option$1.fromNullishOr(node), {
 	onNone: () => "",
-	onSome: (value) => Match.value(value).pipe(Match.discriminators("type")({ PrivateIdentifier: (n) => `#${n.name}` }), Match.orElse(() => ""))
+	onSome: (value) => Match$1.value(value).pipe(Match$1.discriminators("type")({ PrivateIdentifier: (n) => `#${n.name}` }), Match$1.orElse(() => ""))
 });
-const precOf = Match.type().pipe(Match.discriminators("type")({
+const precOf = Match$1.type().pipe(Match$1.discriminators("type")({
 	SequenceExpression: () => PREC.Sequence,
 	AssignmentExpression: () => PREC.Assignment,
 	ConditionalExpression: () => PREC.Conditional,
@@ -5537,7 +5553,7 @@ const precOf = Match.type().pipe(Match.discriminators("type")({
 	ImportExpression: () => PREC.Call,
 	MemberExpression: () => PREC.Member,
 	ChainExpression: () => PREC.Member
-}), Match.orElse(() => PREC.Primary));
+}), Match$1.orElse(() => PREC.Primary));
 const MEMBER_OBJECT_WRAPPED_KINDS = {
 	SequenceExpression: true,
 	AssignmentExpression: true,
@@ -5568,8 +5584,8 @@ const ARRAY_ELEMENT_WRAPPED_KINDS = {
 	TSUnionType: true,
 	TSIntersectionType: true
 };
-const jsxAttributeNameText = (name) => Match.value(name).pipe(Match.discriminators("type")({ JSXIdentifier: (n) => n.name }), Match.orElse((n) => `${n.namespace.name}:${n.name.name}`));
-const propertyFormOf = (fields) => Match.value(fields).pipe(Match.withReturnType(), Match.when(isAccessorKind, () => "accessor"), Match.when(isMethodKind, () => "method"), Match.when(isShorthandMatch, () => "shorthand"), Match.when(isShorthandDefaultMatch, () => "shorthandDefault"), Match.orElse(() => "verbose"));
+const jsxAttributeNameText = (name) => Match$1.value(name).pipe(Match$1.discriminators("type")({ JSXIdentifier: (n) => n.name }), Match$1.orElse((n) => `${n.namespace.name}:${n.name.name}`));
+const propertyFormOf = (fields) => Match$1.value(fields).pipe(Match$1.withReturnType(), Match$1.when(isAccessorKind, () => "accessor"), Match$1.when(isMethodKind, () => "method"), Match$1.when(isShorthandMatch, () => "shorthand"), Match$1.when(isShorthandDefaultMatch, () => "shorthandDefault"), Match$1.orElse(() => "verbose"));
 const isAccessorKind = (fields) => fields.kind === "get" || fields.kind === "set";
 const isMethodKind = (fields) => fields.method === true;
 const isShorthandMatch = (fields) => fields.shorthand === true && namesMatch(identifierName(fields.key), identifierName(fields.value));
@@ -5616,7 +5632,7 @@ const importedNameText = (imported) => Option$1.match(Option$1.fromUndefinedOr(i
 	onSome: (value) => importedNameOf(value),
 	onNone: () => ""
 });
-const importedNameOf = (imported) => Match.value(imported.type).pipe(Match.when("Identifier", () => imported.name ?? ""), Match.orElse(() => imported.value ?? ""));
+const importedNameOf = (imported) => Match$1.value(imported.type).pipe(Match$1.when("Identifier", () => imported.name ?? ""), Match$1.orElse(() => imported.value ?? ""));
 const exportAliasText = (localName, exportedName) => Boolean$1$1.match(localName === exportedName, {
 	onTrue: () => localName,
 	onFalse: () => `${localName} as ${exportedName}`
@@ -5631,12 +5647,12 @@ const importAttributesText = (attrs) => {
 	return flagText(rendered, ` with { ${rendered} }`);
 };
 const importAttributeText = (attribute) => `${importAttrKeyText(attribute.key)}: ${JSON.stringify(attribute.value.value)}`;
-const importAttrKeyText = (key) => Match.value(key).pipe(Match.discriminators("type")({ Identifier: (n) => n.name }), Match.orElse((n) => JSON.stringify(n.value)));
+const importAttrKeyText = (key) => Match$1.value(key).pipe(Match$1.discriminators("type")({ Identifier: (n) => n.name }), Match$1.orElse((n) => JSON.stringify(n.value)));
 const bareArrowParamName = (node) => {
 	const name = singleParamName(node);
 	return flagText(name.length > 0 && node.returnType == null, name);
 };
-const singleParamName = (node) => Match.value(node.params.length).pipe(Match.when(1, () => bareParameterName(Arr.head(node.params))), Match.orElse(() => ""));
+const singleParamName = (node) => Match$1.value(node.params.length).pipe(Match$1.when(1, () => bareParameterName(Arr.head(node.params))), Match$1.orElse(() => ""));
 const bareParameterName = (param) => Option$1.match(param, {
 	onSome: (value) => bareParameterNameOf(value),
 	onNone: () => ""
@@ -5649,9 +5665,9 @@ const namedDeclarationText = (node) => Option$1.match(Option$1.fromNullishOr(nod
 	onNone: () => ""
 });
 const parameterPropertyModifiers = (param) => `${flagText(param.accessibility, `${param.accessibility} `)}${flagText(param.readonly, "readonly ")}${flagText(param.override, "override ")}${flagText(param.static, "static ")}`;
-const commentText = (comment) => Match.value(comment.type).pipe(Match.when("Block", () => `/*${comment.value}*/`), Match.orElse(() => `//${comment.value}`));
+const commentText = (comment) => Match$1.value(comment.type).pipe(Match$1.when("Block", () => `/*${comment.value}*/`), Match$1.orElse(() => `//${comment.value}`));
 const methodDefinitionPrefix = (node, fn) => `${flagText(node.accessibility, `${node.accessibility} `)}${flagText(node.static, "static ")}${flagText(node.override, "override ")}${flagText(fn.async, "async ")}${flagText(fn.generator, "*")}${methodKindText(node.kind)}`;
-const methodKindText = (kind) => Match.value(kind).pipe(Match.when("get", () => "get "), Match.when("set", () => "set "), Match.orElse(() => ""));
+const methodKindText = (kind) => Match$1.value(kind).pipe(Match$1.when("get", () => "get "), Match$1.when("set", () => "set "), Match$1.orElse(() => ""));
 const propertyDefinitionModifiers = (node) => `${flagText(node.declare, "declare ")}${flagText(node.accessibility, `${node.accessibility} `)}${flagText(node.static, "static ")}${flagText(node.readonly, "readonly ")}${flagText(node.override, "override ")}`;
 const BARE_DEFAULT_EXPORT_KINDS = {
 	FunctionDeclaration: true,
@@ -5660,7 +5676,7 @@ const BARE_DEFAULT_EXPORT_KINDS = {
 };
 const isBareDefaultExport = (node) => BARE_DEFAULT_EXPORT_KINDS[node.type] === true;
 const typeParameterModifiersText = (node) => `${flagText(node.in, "in ")}${flagText(node.out, "out ")}${flagText(node.const, "const ")}`;
-const typePredicateParameterText = (parameterName) => Match.value(parameterName).pipe(Match.discriminators("type")({ TSThisType: () => "this" }), Match.orElse((n) => identifierNameText(n)));
+const typePredicateParameterText = (parameterName) => Match$1.value(parameterName).pipe(Match$1.discriminators("type")({ TSThisType: () => "this" }), Match$1.orElse((n) => identifierNameText(n)));
 const externalModuleArgumentText = (value) => Boolean$1$1.match(Predicate$1.isTruthy(value), {
 	onTrue: () => JSON.stringify(value),
 	onFalse: () => "\"\""
@@ -5720,9 +5736,13 @@ var FormatOverrideUnclaimed = class extends S.TaggedError()("FormatOverrideUncla
 	fileName: S.String,
 	formatId: S.String,
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return `Cannot instrument ${this.fileName}: ${this.reason}`;
+	}
+};
 const pinOf = (command) => Option$1.fromUndefinedOr(command.formatId);
-const matchesCommand = (claim, command) => Match.value(pinOf(command)).pipe(Match.when(Option$1.isSome, (pin) => claim.formatId === pin.value), Match.orElse(() => claim.extensions.includes(command.extension)));
+const matchesCommand = (claim, command) => Match$1.value(pinOf(command)).pipe(Match$1.when(Option$1.isSome, (pin) => claim.formatId === pin.value), Match$1.orElse(() => claim.extensions.includes(command.extension)));
 const claimFor = (command) => command.claims.find((claim) => matchesCommand(claim, command));
 const assignedFrom = (claim, command) => FormatAssigned.make({
 	fileName: command.fileName,
@@ -5759,7 +5779,7 @@ const resolveFormat = Workflow.make({
 	command: FormatResolutionCommand,
 	decision: S.Union([FormatAssigned, FormatSkipped]),
 	error: FormatOverrideUnclaimed,
-	decide: (command) => Match.value(selectionFor(command)).pipe(Match.tag("ClaimSelected", ({ claim }) => Result.succeed(assignedFrom(claim, command))), Match.tag("PinUnclaimed", ({ formatId }) => Result.fail(overrideUnclaimedFrom(command, formatId))), Match.tag("ExtensionUnclaimed", () => Result.succeed(skippedFrom(command))), Match.exhaustive)
+	decide: (command) => Match$1.value(selectionFor(command)).pipe(Match$1.tag("ClaimSelected", ({ claim }) => Result.succeed(assignedFrom(claim, command))), Match$1.tag("PinUnclaimed", ({ formatId }) => Result.fail(overrideUnclaimedFrom(command, formatId))), Match$1.tag("ExtensionUnclaimed", () => Result.succeed(skippedFrom(command))), Match$1.exhaustive)
 });
 const DIRECTIVE_PATTERN = /^\s?Stryker (disable|restore)(?: (next-line))? ([a-zA-Z, ]+)(?::(.+)?)?/;
 const DEFAULT_REASON = "Ignored using a comment";
@@ -5774,7 +5794,7 @@ var DirectiveDecoded = class extends S.TaggedClass()("DirectiveDecoded", { direc
 var DirectiveMalformed = class extends S.TaggedClass()("DirectiveMalformed", { commentText: S.String }) {
 	[DirectiveDecisionTypeId] = DirectiveDecisionTypeId;
 };
-const actionOf = (action) => Match.value(action).pipe(Match.when("restore", () => "restore"), Match.orElse(() => "disable"));
+const actionOf = (action) => Match$1.value(action).pipe(Match$1.when("restore", () => "restore"), Match$1.orElse(() => "disable"));
 const scopeOf = (nextLine) => Option$1.match(nextLine, {
 	onNone: () => "block",
 	onSome: () => NEXT_LINE$1
@@ -5791,7 +5811,7 @@ const decodeDirective = Workflow.make({
 	command: DecodeDirectiveCommand,
 	decision: S.Union([DirectiveDecoded, DirectiveMalformed]),
 	error: S.Never,
-	decide: (command) => Match.value(Option$1.flatMap(Option$1.fromNullishOr(DIRECTIVE_PATTERN.exec(command.commentText)), decodedDirective)).pipe(Match.when(Option$1.isSome, (decoded) => Result.succeed(DirectiveDecoded.make({ directive: decoded.value }))), Match.when(Option$1.isNone, () => Result.succeed(DirectiveMalformed.make({ commentText: command.commentText }))), Match.exhaustive)
+	decide: (command) => Match$1.value(Option$1.flatMap(Option$1.fromNullishOr(DIRECTIVE_PATTERN.exec(command.commentText)), decodedDirective)).pipe(Match$1.when(Option$1.isSome, (decoded) => Result.succeed(DirectiveDecoded.make({ directive: decoded.value }))), Match$1.when(Option$1.isNone, () => Result.succeed(DirectiveMalformed.make({ commentText: command.commentText }))), Match$1.exhaustive)
 });
 var FoldRuleCommand = class extends S.TaggedClass()("FoldRuleCommand", {
 	rule: S.Array(LocatedDirectiveSchema),
@@ -5810,7 +5830,7 @@ const foldRule = Workflow.make({
 	command: FoldRuleCommand,
 	decision: S.Union([DisableFolded, RestoreFolded]),
 	error: S.Never,
-	decide: (command) => Match.value(command.directive.directive.action).pipe(Match.when("restore", () => Result.succeed(RestoreFolded.make({ rule: [...command.rule, command.directive] }))), Match.when("disable", () => Result.succeed(DisableFolded.make({ rule: [...command.rule, command.directive] }))), Match.exhaustive)
+	decide: (command) => Match$1.value(command.directive.directive.action).pipe(Match$1.when("restore", () => Result.succeed(RestoreFolded.make({ rule: [...command.rule, command.directive] }))), Match$1.when("disable", () => Result.succeed(DisableFolded.make({ rule: [...command.rule, command.directive] }))), Match$1.exhaustive)
 });
 const hasLeadingComments$1 = (value) => Predicate$1.hasProperty(value, "leadingComments") && Array.isArray(value.leadingComments);
 const STRYKER_NAMESPACE_HELPER = "stryNS_9fa48";
@@ -5949,15 +5969,23 @@ var MutantKindMismatch = class extends S.TaggedError()("MutantKindMismatch", {
 	mutantId: MutantId,
 	mutatorName: MutatorNameSchema,
 	expected: ExpectedKindSchema
-}) {};
-var NoPlacerClaimsNode = class extends S.TaggedError()("NoPlacerClaimsNode", { fileName: S.String }) {};
-const claimingPlacer = (facts) => Match.value(facts).pipe(Match.when({
+}) {
+	get message() {
+		return `Expected ${this.expected} for mutant ${this.mutantId} (${this.mutatorName}) in ${this.fileName}`;
+	}
+};
+var NoPlacerClaimsNode = class extends S.TaggedError()("NoPlacerClaimsNode", { fileName: S.String }) {
+	get message() {
+		return `No placer claims the node in ${this.fileName}`;
+	}
+};
+const claimingPlacer = (facts) => Match$1.value(facts).pipe(Match$1.when({
 	isExpression: true,
 	expressionIsValid: true
-}, () => Option$1.some("expression")), Match.when({ isStatement: true }, () => Option$1.some("statement")), Match.when({ isSwitchCase: true }, () => Option$1.some("switch-case")), Match.orElse(() => Option$1.none()));
-const placerOf = (command) => Match.value(claimingPlacer(command.facts)).pipe(Match.when(Option$1.isSome, (chosen) => Result.succeed(chosen.value)), Match.when(Option$1.isNone, () => Result.fail(NoPlacerClaimsNode.make({ fileName: command.fileName }))), Match.exhaustive);
-const expectedKindOf = (placer) => Match.value(placer).pipe(Match.when("expression", () => "an expression"), Match.when("statement", () => "a statement"), Match.when("switch-case", () => "a switch case"), Match.exhaustive);
-const matchesPlacer = (placer, replacement) => Match.value(placer).pipe(Match.when("expression", () => replacement.isExpression), Match.when("statement", () => replacement.isStatement), Match.when("switch-case", () => replacement.isSwitchCase), Match.exhaustive);
+}, () => Option$1.some("expression")), Match$1.when({ isStatement: true }, () => Option$1.some("statement")), Match$1.when({ isSwitchCase: true }, () => Option$1.some("switch-case")), Match$1.orElse(() => Option$1.none()));
+const placerOf = (command) => Match$1.value(claimingPlacer(command.facts)).pipe(Match$1.when(Option$1.isSome, (chosen) => Result.succeed(chosen.value)), Match$1.when(Option$1.isNone, () => Result.fail(NoPlacerClaimsNode.make({ fileName: command.fileName }))), Match$1.exhaustive);
+const expectedKindOf = (placer) => Match$1.value(placer).pipe(Match$1.when("expression", () => "an expression"), Match$1.when("statement", () => "a statement"), Match$1.when("switch-case", () => "a switch case"), Match$1.exhaustive);
+const matchesPlacer = (placer, replacement) => Match$1.value(placer).pipe(Match$1.when("expression", () => replacement.isExpression), Match$1.when("statement", () => replacement.isStatement), Match$1.when("switch-case", () => replacement.isSwitchCase), Match$1.exhaustive);
 const firstMismatch = (command, placer) => Option$1.map(Option$1.fromNullishOr(command.mutants.find((mutant) => !matchesPlacer(placer, mutant.replacement))), (mutant) => MutantKindMismatch.make({
 	fileName: command.fileName,
 	placer,
@@ -5965,19 +5993,19 @@ const firstMismatch = (command, placer) => Option$1.map(Option$1.fromNullishOr(c
 	mutatorName: mutant.mutatorName,
 	expected: expectedKindOf(placer)
 }));
-const placementRefusal = (command, placer) => Match.value(firstMismatch(command, placer)).pipe(Match.when(Option$1.isSome, (mismatch) => Result.fail(mismatch.value)), Match.when(Option$1.isNone, () => Result.succeed(void 0)), Match.exhaustive);
+const placementRefusal = (command, placer) => Match$1.value(firstMismatch(command, placer)).pipe(Match$1.when(Option$1.isSome, (mismatch) => Result.fail(mismatch.value)), Match$1.when(Option$1.isNone, () => Result.succeed(void 0)), Match$1.exhaustive);
 const siteOf = (command, placer) => {
 	const mutantIds = command.mutants.map((mutant) => mutant.id);
-	return Match.value(placer).pipe(Match.when("expression", () => ExpressionSite.make({
+	return Match$1.value(placer).pipe(Match$1.when("expression", () => ExpressionSite.make({
 		fileName: command.fileName,
 		mutantIds
-	})), Match.when("statement", () => StatementSite.make({
+	})), Match$1.when("statement", () => StatementSite.make({
 		fileName: command.fileName,
 		mutantIds
-	})), Match.when("switch-case", () => SwitchCaseSite.make({
+	})), Match$1.when("switch-case", () => SwitchCaseSite.make({
 		fileName: command.fileName,
 		mutantIds
-	})), Match.exhaustive);
+	})), Match$1.exhaustive);
 };
 const placeMutants = Workflow.make({
 	command: PlaceMutantsCommand,
@@ -6050,12 +6078,16 @@ var MutantsFullyIgnored = class extends S.TaggedClass()("MutantsFullyIgnored", {
 var MutantWithoutLocation = class extends S.TaggedError()("MutantWithoutLocation", {
 	fileName: S.String,
 	mutatorName: MutatorNameSchema
-}) {};
-const reachedLine = (located, line) => Match.value(located.directive.scope).pipe(Match.when(NEXT_LINE, () => located.governedLine === line), Match.when("block", () => true), Match.exhaustive);
+}) {
+	get message() {
+		return `Mutant without a source location: ${this.mutatorName} in ${this.fileName}`;
+	}
+};
+const reachedLine = (located, line) => Match$1.value(located.directive.scope).pipe(Match$1.when(NEXT_LINE, () => located.governedLine === line), Match$1.when("block", () => true), Match$1.exhaustive);
 const namesMutator = (located, lowerMutatorName) => located.directive.mutatorNames.some((name) => [name === WILDCARD, name.toLowerCase() === lowerMutatorName].some(Boolean));
 const lastReachingDirective = (rule, lowerMutatorName, line) => Option$1.fromNullishOr(rule.findLast((located) => [reachedLine(located, line), namesMutator(located, lowerMutatorName)].every(Boolean)));
-const directiveReason = (rule, mutatorName, line) => Option$1.flatMap(lastReachingDirective(rule, mutatorName.toLowerCase(), line), (located) => Match.value(located.directive.action).pipe(Match.when("disable", () => Option$1.some(located.directive.reason)), Match.when("restore", () => Option$1.none()), Match.exhaustive));
-const exclusionReason = (excludedMutations, mutatorName) => Match.value(excludedMutations.includes(mutatorName)).pipe(Match.when(true, () => Option$1.some(`Ignored because of excluded mutation "${mutatorName}"`)), Match.when(false, () => Option$1.none()), Match.exhaustive);
+const directiveReason = (rule, mutatorName, line) => Option$1.flatMap(lastReachingDirective(rule, mutatorName.toLowerCase(), line), (located) => Match$1.value(located.directive.action).pipe(Match$1.when("disable", () => Option$1.some(located.directive.reason)), Match$1.when("restore", () => Option$1.none()), Match$1.exhaustive));
+const exclusionReason = (excludedMutations, mutatorName) => Match$1.value(excludedMutations.includes(mutatorName)).pipe(Match$1.when(true, () => Option$1.some(`Ignored because of excluded mutation "${mutatorName}"`)), Match$1.when(false, () => Option$1.none()), Match$1.exhaustive);
 const ignoreReasonOf = (command, candidate) => Option$1.getOrUndefined(Option$1.orElse(Option$1.orElse(directiveReason(command.rule, candidate.mutatorName, command.line), () => exclusionReason(command.excludedMutations, candidate.mutatorName)), () => Option$1.fromNullishOr(candidate.ignorerReason)));
 const unusedDirectives = (directives, mutatorNames) => directives.flatMap((located) => located.directive.mutatorNames.filter((mutatorName) => mutatorName !== WILDCARD).filter((mutatorName) => !mutatorNames.includes(mutatorName.toLowerCase())).map((mutatorName) => ({
 	directive: located.directive,
@@ -6063,7 +6095,7 @@ const unusedDirectives = (directives, mutatorNames) => directives.flatMap((locat
 	mutatorName
 })));
 const unusedDirectiveWarning = (unused, fileName) => {
-	return `Unused 'Stryker ${Match.value(unused.directive.scope).pipe(Match.when(NEXT_LINE, () => `${unused.directive.action} ${NEXT_LINE}`), Match.when("block", () => unused.directive.action), Match.exhaustive)}' directive. Mutator with name '${unused.mutatorName}' not found. Directive found at: ${fileName}:${unused.at.line}:${unused.at.column}.`;
+	return `Unused 'Stryker ${Match$1.value(unused.directive.scope).pipe(Match$1.when(NEXT_LINE, () => `${unused.directive.action} ${NEXT_LINE}`), Match$1.when("block", () => unused.directive.action), Match$1.exhaustive)}' directive. Mutator with name '${unused.mutatorName}' not found. Directive found at: ${fileName}:${unused.at.line}:${unused.at.column}.`;
 };
 const warningsOf = (command) => unusedDirectives(command.directives, command.mutatorNames).map((unused) => unusedDirectiveWarning(unused, command.fileName));
 /**
@@ -6073,7 +6105,7 @@ const warningsOf = (command) => unusedDirectives(command.directives, command.mut
 * column 1, so the shift adds `offset.line - 1` lines and — only when the node
 * sits on the region's first line — `offset.columnShift`.
 */
-const columnOffsetOf = (source, offset) => Match.value(source.line === 1).pipe(Match.when(true, () => offset.columnShift), Match.when(false, () => 0), Match.exhaustive);
+const columnOffsetOf = (source, offset) => Match$1.value(source.line === 1).pipe(Match$1.when(true, () => offset.columnShift), Match$1.when(false, () => 0), Match$1.exhaustive);
 const shiftedPosition = (source, offset) => ({
 	column: source.column + columnOffsetOf(source, offset),
 	line: source.line + offset.line - 1
@@ -6097,16 +6129,16 @@ const plannedMutant = (command, candidate, index) => Option$1.match(Option$1.fro
 });
 const plannedMutants = (command) => command.candidates.reduce((accumulated, candidate, index) => Result.flatMap(accumulated, (mutants) => Result.map(plannedMutant(command, candidate, index), (mutant) => [...mutants, mutant])), Result.succeed([]));
 const withoutReason = (mutant) => mutant.ignoreReason === void 0;
-const planOf = (command, mutants) => Match.value(mutants.some(withoutReason)).pipe(Match.when(true, () => MutantsPlanned.make({
+const planOf = (command, mutants) => Match$1.value(mutants.some(withoutReason)).pipe(Match$1.when(true, () => MutantsPlanned.make({
 	mutants: [...mutants],
 	placeable: mutants.filter(withoutReason),
 	warnings: warningsOf(command),
 	nextIndex: command.firstIndex + mutants.length
-})), Match.when(false, () => MutantsFullyIgnored.make({
+})), Match$1.when(false, () => MutantsFullyIgnored.make({
 	mutants: [...mutants],
 	warnings: warningsOf(command),
 	nextIndex: command.firstIndex + mutants.length
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const planMutants = Workflow.make({
 	command: PlanMutantsCommand,
 	decision: S.Union([MutantsPlanned, MutantsFullyIgnored]),
@@ -6143,17 +6175,17 @@ const createMutantCollector = () => {
 		map: (transform) => mutants.map(transform)
 	};
 };
-const decidedDirective = (commentText) => Match.value(decodeDirective(DecodeDirectiveCommand.make({ commentText }))).pipe(Match.when(Result.isSuccess, (decoded) => Match.value(decoded.success).pipe(Match.tag("DirectiveDecoded", (decision) => Option$1.some(decision.directive)), Match.orElse(() => Option$1.none()))), Match.orElse(() => Option$1.none()));
+const decidedDirective = (commentText) => Match$1.value(decodeDirective(DecodeDirectiveCommand.make({ commentText }))).pipe(Match$1.when(Result.isSuccess, (decoded) => Match$1.value(decoded.success).pipe(Match$1.tag("DirectiveDecoded", (decision) => Option$1.some(decision.directive)), Match$1.orElse(() => Option$1.none()))), Match$1.orElse(() => Option$1.none()));
 const locatedDirective = (comment, governedLine) => Option$1.flatMap(Option$1.fromNullishOr(comment.loc), (loc) => Option$1.map(decidedDirective(comment.value), (directive) => ({
 	directive,
 	at: loc.start,
 	governedLine
 })));
 const directivesOf = (node, governedLine) => attachedComments(node).flatMap((comment) => Option$1.toArray(locatedDirective(comment, governedLine)));
-const foldInto = (rule, directive) => Match.value(foldRule(FoldRuleCommand.make({
+const foldInto = (rule, directive) => Match$1.value(foldRule(FoldRuleCommand.make({
 	rule,
 	directive
-}))).pipe(Match.when(Result.isSuccess, (folded) => folded.success.rule), Match.orElse(() => rule));
+}))).pipe(Match$1.when(Result.isSuccess, (folded) => folded.success.rule), Match$1.orElse(() => rule));
 const NO_COMMENTS = [];
 const attachedComments = (node) => hasLeadingComments(node) ? node.leadingComments : NO_COMMENTS;
 const hasLeadingComments = (value) => Predicate$1.hasProperty(value, "leadingComments") && Array.isArray(value.leadingComments);
@@ -6209,8 +6241,8 @@ function mutationCoverageSequenceExpression(mutants, targetExpression) {
 	const sequence = [callExpression(identifier(COVER_MUTANT_HELPER), mutantIds)];
 	return sequenceExpression(targetExpression === void 0 ? sequence : [...sequence, targetExpression]);
 }
-const refusalPlacer = (refusal) => Match.value(refusal).pipe(Match.tag("MutantKindMismatch", (mismatch) => mismatch.placer), Match.tag("MutantsUnapplied", (unapplied) => unapplied.placer), Match.tag("NoPlacerClaimsNode", () => "no placer"), Match.tag("MutantNotApplied", () => "no placer"), Match.exhaustive);
-const refusalDetail = (refusal) => Match.value(refusal).pipe(Match.tag("MutantKindMismatch", (mismatch) => `Expected ${mismatch.expected} for mutant ${mismatch.mutantId}`), Match.tag("MutantsUnapplied", (unapplied) => `Failed to apply ${unapplied.mutatorNames.join(", ")}`), Match.tag("NoPlacerClaimsNode", () => "No placer claims the node"), Match.tag("MutantNotApplied", (unapplied) => `Could not apply the ${unapplied.mutatorName} mutant`), Match.exhaustive);
+const refusalPlacer = (refusal) => Match$1.value(refusal).pipe(Match$1.tag("MutantKindMismatch", (mismatch) => mismatch.placer), Match$1.tag("MutantsUnapplied", (unapplied) => unapplied.placer), Match$1.tag("NoPlacerClaimsNode", () => "no placer"), Match$1.tag("MutantNotApplied", () => "no placer"), Match$1.exhaustive);
+const refusalDetail = (refusal) => Match$1.value(refusal).pipe(Match$1.tag("MutantKindMismatch", (mismatch) => `Expected ${mismatch.expected} for mutant ${mismatch.mutantId}`), Match$1.tag("MutantsUnapplied", (unapplied) => `Failed to apply ${unapplied.mutatorNames.join(", ")}`), Match$1.tag("NoPlacerClaimsNode", () => "No placer claims the node"), Match$1.tag("MutantNotApplied", (unapplied) => `Could not apply the ${unapplied.mutatorName} mutant`), Match$1.exhaustive);
 const placementFailureMessage = (refusal, node, mutants, fileName, lineStarts, basePath) => {
 	const message = `${refusalPlacer(refusal)} could not place mutants with type(s): "${placementListFormat.format(mutants.map((mutant) => mutant.mutatorName))}"`;
 	return `${placementLocation(node, fileName, lineStarts, basePath)} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using \`mutator.excludedMutations\`). Original error: ${refusalDetail(refusal)}`;
@@ -6254,14 +6286,14 @@ function classOrFunctionExpressionNamedIfNeeded(path) {
 	return Option$1.flatMap(Option$1.filter(Option$1.some(path.node), isAnonymousFunctionOrClass), (node) => nameFromParent(path, node));
 }
 function nameFromParent(path, node) {
-	return Match.value(path.parentPath?.node).pipe(Match.when(isVariableDeclarator, (declarator) => adoptDeclaredName(node, declarator)), Match.when({
+	return Match$1.value(path.parentPath?.node).pipe(Match$1.when(isVariableDeclarator, (declarator) => adoptDeclaredName(node, declarator)), Match$1.when({
 		type: "Property",
 		key: { type: "Identifier" }
-	}, () => namedPropertyValue(path, node)), Match.orElse(() => Option$1.none()));
+	}, () => namedPropertyValue(path, node)), Match$1.orElse(() => Option$1.none()));
 }
 /** A property value only survives by name when the declaration above it carries one. */
 function namedPropertyValue(path, node) {
-	return Match.value(path.getStatementParent()?.node.type).pipe(Match.when("VariableDeclaration", () => Option$1.some(node)), Match.orElse(() => Option$1.none()));
+	return Match$1.value(path.getStatementParent()?.node.type).pipe(Match$1.when("VariableDeclaration", () => Option$1.some(node)), Match$1.orElse(() => Option$1.none()));
 }
 function adoptIdentifier(node, identifier) {
 	node.id = identifier;
@@ -6274,7 +6306,7 @@ function isFunctionOrClassExpression(node) {
 	return node.type === "FunctionExpression" || node.type === "ClassExpression";
 }
 function arrowFunctionExpressionNamedIfNeeded(path) {
-	return Match.value(path.node).pipe(Match.when({ type: "ArrowFunctionExpression" }, (node) => arrowNamedByDeclarator(node, path.parentPath)), Match.orElse(() => Option$1.none()));
+	return Match$1.value(path.node).pipe(Match$1.when({ type: "ArrowFunctionExpression" }, (node) => arrowNamedByDeclarator(node, path.parentPath)), Match$1.orElse(() => Option$1.none()));
 }
 /** An arrow bound to a named declaration is re-emitted as a named function. */
 function arrowNamedByDeclarator(node, parentPath) {
@@ -6285,7 +6317,7 @@ function namedArrowExpression(node, identifier) {
 	return callExpression(arrowFunctionExpression([], blockStatement([declaration, returnStatement(identifier)])), []);
 }
 function declaratorIdentifier(parentPath) {
-	return Option$1.flatMap(Option$1.fromNullishOr(parentPath), (parent) => Match.value(parent.node).pipe(Match.when(isVariableDeclarator, (declarator) => declaredName(declarator)), Match.orElse(() => Option$1.none())));
+	return Option$1.flatMap(Option$1.fromNullishOr(parentPath), (parent) => Match$1.value(parent.node).pipe(Match$1.when(isVariableDeclarator, (declarator) => declaredName(declarator)), Match$1.orElse(() => Option$1.none())));
 }
 function isVariableDeclarator(node) {
 	return nodeType(node) === "VariableDeclarator";
@@ -6294,7 +6326,7 @@ function adoptDeclaredName(node, declarator) {
 	return Option$1.map(declaredName(declarator), (identifier) => adoptIdentifier(node, identifier));
 }
 function declaredName(declarator) {
-	return Match.value(declarator.id).pipe(Match.when(isIdentifierReference, (identifier) => Option$1.some(identifier)), Match.orElse(() => Option$1.none()));
+	return Match$1.value(declarator.id).pipe(Match$1.when(isIdentifierReference, (identifier) => Option$1.some(identifier)), Match$1.orElse(() => Option$1.none()));
 }
 function isIdentifierReference(node) {
 	return nodeType(node) === "Identifier";
@@ -6403,7 +6435,7 @@ function guardedStatement(statement, entry) {
 	return Result.map(nodeOfKind(entry[0], entry[1], isStatementKind, "a statement"), (narrowed) => ifStatement(mutantTestExpression(entry[0].id), blockStatement([narrowed]), statement));
 }
 function wrappedStatement(path, statement) {
-	return Match.value(nodeType(path.node)).pipe(Match.when("BlockStatement", () => blockStatement([statement])), Match.orElse(() => statement));
+	return Match$1.value(nodeType(path.node)).pipe(Match$1.when("BlockStatement", () => blockStatement([statement])), Match$1.orElse(() => statement));
 }
 const placerBuilders = Object.freeze({
 	expression: expressionMutantPlacer,
@@ -6425,7 +6457,7 @@ const transformDataFirst = (ast, mutantCollector, transformerContext) => {
 		transform
 	};
 	const formatKey = formatKeyOf(ast);
-	return Match.value(transformerContext.registry.entryForFormat(formatKey)).pipe(Match.when(Option$1.isSome, (entry) => entry.value.transform(ast, mutantCollector, context)), Match.orElse(() => Effect$1.fail(InstrumentError.make({
+	return Match$1.value(transformerContext.registry.entryForFormat(formatKey)).pipe(Match$1.when(Option$1.isSome, (entry) => entry.value.transform(ast, mutantCollector, context)), Match$1.orElse(() => Effect$1.fail(InstrumentError.make({
 		message: `No registered format transforms the "${formatKey}" AST`,
 		cause: /* @__PURE__ */ new Error(`Missing format entry for "${formatKey}"`)
 	}))));
@@ -6463,7 +6495,7 @@ const placementFactsOf = (frame) => ({
 	isSwitchCase: nodeType(frame.node) === "SwitchCase",
 	expressionIsValid: isValidExpression(frame.node, parentNodeOf(frame))
 });
-const placerNameOf = (site) => Match.value(site).pipe(Match.tag("ExpressionSite", () => "expression"), Match.tag("StatementSite", () => "statement"), Match.tag("SwitchCaseSite", () => "switch-case"), Match.exhaustive);
+const placerNameOf = (site) => Match$1.value(site).pipe(Match$1.tag("ExpressionSite", () => "expression"), Match$1.tag("StatementSite", () => "statement"), Match$1.tag("SwitchCaseSite", () => "switch-case"), Match$1.exhaustive);
 const replacementRecord = (mutant, applied) => {
 	const replacement = unwrapParenthesizedExpression(applied);
 	return {
@@ -6529,13 +6561,13 @@ const applyToClaim = (mutants, target, state, context) => {
 		} : claim)
 	}));
 };
-const attachPlaceable = (mutants, frame, state, context) => Match.value(mutants.length > 0).pipe(Match.when(false, () => Result.succeed(state)), Match.when(true, () => Option$1.match(Option$1.fromNullishOr(framesUpward(frame).find((candidate) => state.claims.some((claim) => claim.node === candidate.node))), {
+const attachPlaceable = (mutants, frame, state, context) => Match$1.value(mutants.length > 0).pipe(Match$1.when(false, () => Result.succeed(state)), Match$1.when(true, () => Option$1.match(Option$1.fromNullishOr(framesUpward(frame).find((candidate) => state.claims.some((claim) => claim.node === candidate.node))), {
 	onNone: () => Result.fail(MutantsUnplaced.make({
 		fileName: context.fileName,
 		detail: JSON.stringify(mutants, null, 2)
 	})),
 	onSome: (target) => applyToClaim(mutants, target, state, context)
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const collectPlan = (frame, candidates, plan, state, context) => {
 	const collected = plannedWithNodes(candidates, plan.mutants, context.fileName);
 	const nextState = {
@@ -6544,10 +6576,10 @@ const collectPlan = (frame, candidates, plan, state, context) => {
 		warnings: [...state.warnings, ...plan.warnings],
 		nextIndex: plan.nextIndex
 	};
-	return Match.value(plan).pipe(Match.tag("MutantsPlanned", (planned) => attachPlaceable(plannedWithNodes(candidates, planned.placeable, context.fileName), frame, {
+	return Match$1.value(plan).pipe(Match$1.tag("MutantsPlanned", (planned) => attachPlaceable(plannedWithNodes(candidates, planned.placeable, context.fileName), frame, {
 		...nextState,
 		hasLiveMutants: true
-	}, context)), Match.orElse(() => Result.succeed(nextState)));
+	}, context)), Match$1.orElse(() => Result.succeed(nextState)));
 };
 const planMutantsAt = (frame, candidates, directives, location, state, context) => {
 	const plan = planMutants(PlanMutantsCommand.make({
@@ -6561,13 +6593,13 @@ const planMutantsAt = (frame, candidates, directives, location, state, context)
 		directives: [...directives],
 		candidates: candidates.map((candidate) => candidate.data)
 	}));
-	return Match.value(plan).pipe(Match.when(Result.isFailure, (failed) => Result.fail(failed.failure)), Match.orElse((succeeded) => collectPlan(frame, candidates, succeeded.success, state, context)));
+	return Match$1.value(plan).pipe(Match$1.when(Result.isFailure, (failed) => Result.fail(failed.failure)), Match$1.orElse((succeeded) => collectPlan(frame, candidates, succeeded.success, state, context)));
 };
-const candidatesFor = (frame, location, context) => Match.value(shouldMutateAt(location, context.mutateDescription)).pipe(Match.when(true, () => mutablesFor(frame, location, context)), Match.orElse(() => []));
+const candidatesFor = (frame, location, context) => Match$1.value(shouldMutateAt(location, context.mutateDescription)).pipe(Match$1.when(true, () => mutablesFor(frame, location, context)), Match$1.orElse(() => []));
 const needsPlan = (candidates, directives) => [candidates.length > 0, directives.length > 0].some(Boolean);
 const planAtNode = (frame, directives, location, state, context) => {
 	const candidates = candidatesFor(frame, location, context);
-	return Match.value(needsPlan(candidates, directives)).pipe(Match.when(false, () => Result.succeed(state)), Match.when(true, () => planMutantsAt(frame, candidates, directives, location, state, context)), Match.exhaustive);
+	return Match$1.value(needsPlan(candidates, directives)).pipe(Match$1.when(false, () => Result.succeed(state)), Match$1.when(true, () => planMutantsAt(frame, candidates, directives, location, state, context)), Match$1.exhaustive);
 };
 const claimSelf = (frame, facts, claims, context) => {
 	const claimed = placeMutants(PlaceMutantsCommand.make({
@@ -6575,11 +6607,11 @@ const claimSelf = (frame, facts, claims, context) => {
 		facts,
 		mutants: []
 	}));
-	return Match.value(claimed.pipe(Result.isSuccess)).pipe(Match.when(true, () => [...claims, {
+	return Match$1.value(claimed.pipe(Result.isSuccess)).pipe(Match$1.when(true, () => [...claims, {
 		node: frame.node,
 		facts,
 		applied: []
-	}]), Match.orElse(() => claims));
+	}]), Match$1.orElse(() => claims));
 };
 const siteOfClaim = (claim, context) => {
 	const mutants = claim.applied.map(([mutant]) => mutant);
@@ -6588,16 +6620,16 @@ const siteOfClaim = (claim, context) => {
 		facts: claim.facts,
 		mutants: claim.applied.map(([mutant, applied]) => replacementRecord(mutant, applied))
 	}));
-	return Match.value(decision).pipe(Match.when(Result.isFailure, (refused) => Result.fail(refusedPlacement(refused.failure, claim.node, mutants, context))), Match.orElse((decided) => Result.succeed(decided.success)));
+	return Match$1.value(decision).pipe(Match$1.when(Result.isFailure, (refused) => Result.fail(refusedPlacement(refused.failure, claim.node, mutants, context))), Match$1.orElse((decided) => Result.succeed(decided.success)));
 };
-const emitClaim = (claim, state, context) => Match.value(claim.applied.length > 0).pipe(Match.when(false, () => Result.succeed(state)), Match.when(true, () => Result.map(siteOfClaim(claim, context), (site) => ({
+const emitClaim = (claim, state, context) => Match$1.value(claim.applied.length > 0).pipe(Match$1.when(false, () => Result.succeed(state)), Match$1.when(true, () => Result.map(siteOfClaim(claim, context), (site) => ({
 	...state,
 	placements: [...state.placements, {
 		node: claim.node,
 		placer: placerNameOf(site),
 		applied: claim.applied
 	}]
-}))), Match.exhaustive);
+}))), Match$1.exhaustive);
 const emitPlacement = (frame, state, context) => Option$1.match(Option$1.fromNullishOr(state.claims.find((claim) => claim.node === frame.node)), {
 	onNone: () => Result.succeed(state),
 	onSome: (claim) => emitClaim(claim, state, context)
@@ -6620,7 +6652,7 @@ const foldPlacements = (frame, state, context) => Result.flatMap(locationOfNode(
 		...state,
 		directiveRule: directives.reduce(foldInto, state.directiveRule)
 	};
-	return Match.value(shouldSkipNode(frame, location, context.mutateDescription)).pipe(Match.when(true, () => Result.succeed(ruled)), Match.when(false, () => visitFrame(frame, directives, location, ruled, context)), Match.exhaustive);
+	return Match$1.value(shouldSkipNode(frame, location, context.mutateDescription)).pipe(Match$1.when(true, () => Result.succeed(ruled)), Match$1.when(false, () => visitFrame(frame, directives, location, ruled, context)), Match$1.exhaustive);
 });
 const planInstrumentation = (root, firstIndex, context) => Result.map(foldPlacements({
 	node: root,
@@ -6665,19 +6697,19 @@ const applyPlan = (root, plan, context) => {
 		}))
 	});
 };
-const refusalError = (refusal) => Match.value(refusal).pipe(Match.tag("NodeWithoutSpan", () => InstrumentError.make({
+const refusalError = (refusal) => Match$1.value(refusal).pipe(Match$1.tag("NodeWithoutSpan", () => InstrumentError.make({
 	message: "Node without a span",
 	cause: void 0
-})), Match.tag("MutantsUnplaced", (unplaced) => InstrumentError.make({
+})), Match$1.tag("MutantsUnplaced", (unplaced) => InstrumentError.make({
 	message: `Mutants cannot be placed. This shouldn't happen! Unplaced mutants: ${unplaced.detail}`,
 	cause: void 0
-})), Match.tag("PlacementRefused", (refused) => InstrumentError.make({
+})), Match$1.tag("PlacementRefused", (refused) => InstrumentError.make({
 	message: refused.message,
 	cause: new Error(refused.message)
-})), Match.tag("MutantWithoutLocation", (failed) => InstrumentError.make({
+})), Match$1.tag("MutantWithoutLocation", (failed) => InstrumentError.make({
 	message: `Mutant without a source location: ${failed.mutatorName} in ${failed.fileName}`,
 	cause: void 0
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const transformScriptDataFirst = Effect$1.fn("stryker.instrument.transform.script")(function* ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription, basePath }) {
 	const lineStarts = lineStartsOf(rawContent);
 	attachComments(make(root), comments, lineStarts);
@@ -6697,10 +6729,10 @@ const transformScriptDataFirst = Effect$1.fn("stryker.instrument.transform.scrip
 		try: () => planInstrumentation(root, mutantCollector.nextIndex, context),
 		catch: traversalFailure
 	});
-	const plan = yield* Match.value(planned).pipe(Match.when(Result.isFailure, (refused) => {
+	const plan = yield* Match$1.value(planned).pipe(Match$1.when(Result.isFailure, (refused) => {
 		const error = refusalError(refused.failure);
 		return Effect$1.fail(error);
-	}), Match.orElse((succeeded) => Effect$1.succeed(succeeded.success)));
+	}), Match$1.orElse((succeeded) => Effect$1.succeed(succeeded.success)));
 	mutantCollector.append(plan.mutants);
 	yield* applyPlan(root, plan, context);
 	yield* placeHeaderIfNeeded(plan.hasLiveMutants, options, root);
@@ -6769,7 +6801,7 @@ const scriptAstError = (ast) => InstrumentError.make({
 	message: `Expected a script AST, received the "${ast.format}" format`,
 	cause: void 0
 });
-const scriptAstOf = (ast) => Match.value(ast).pipe(Match.when({ format: "embedded" }, () => Option$1.none()), Match.orElse((script) => Option$1.some(script)));
+const scriptAstOf = (ast) => Match$1.value(ast).pipe(Match$1.when({ format: "embedded" }, () => Option$1.none()), Match$1.orElse((script) => Option$1.some(script)));
 const extensionOf = (fileName) => {
 	const dot = fileName.lastIndexOf(".");
 	return dot > Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\")) ? fileName.slice(dot).toLowerCase() : "";
@@ -6811,8 +6843,8 @@ const scriptHooks = (scriptFormat) => ({
 		onSome: (script) => Effect$1.succeed(disableTypeCheckingInScript(script))
 	})
 });
-const parseScriptFormat = (scriptFormat, text, fileName) => Match.value(scriptFormat).pipe(Match.when("js", () => parseJS(text, fileName)), Match.when("ts", () => parseTS(text, fileName)), Match.when("tsx", () => parseTsx(text, fileName)), Match.exhaustive);
-const printScriptAst = (ast, context) => Match.value(ast).pipe(Match.when({ format: "js" }, (js) => jsPrint(js, context)), Match.when({ format: "ts" }, (ts) => tsPrint(ts, context)), Match.when({ format: "tsx" }, (tsx) => tsPrint(tsx, context)), Match.orElse(printNothingForEmbeddedAst));
+const parseScriptFormat = (scriptFormat, text, fileName) => Match$1.value(scriptFormat).pipe(Match$1.when("js", () => parseJS(text, fileName)), Match$1.when("ts", () => parseTS(text, fileName)), Match$1.when("tsx", () => parseTsx(text, fileName)), Match$1.exhaustive);
+const printScriptAst = (ast, context) => Match$1.value(ast).pipe(Match$1.when({ format: "js" }, (js) => jsPrint(js, context)), Match$1.when({ format: "ts" }, (ts) => tsPrint(ts, context)), Match$1.when({ format: "tsx" }, (tsx) => tsPrint(tsx, context)), Match$1.orElse(printNothingForEmbeddedAst));
 const printNothingForEmbeddedAst = () => "";
 const coreFormatRegistry = formatRegistry([
 	{
@@ -6898,8 +6930,8 @@ const unclaimedOverrideError = (file) => InstrumentError.make({
 	message: `No installed format owns ${file.name}`,
 	cause: /* @__PURE__ */ new Error(`Unresolvable format pin for ${file.name}`)
 });
-const outcomeFor = (registry, file, decision) => Match.value(decision).pipe(Match.when(S.is(FormatAssigned), (assigned) => parsedOutcomeFor(registry, file, assigned)), Match.when(S.is(FormatSkipped), (skipped) => Effect$1.succeed(skippedOutcomeFor(file, skipped))), Match.exhaustive);
-const fileOutcome = (request) => Match.value(resolveFile(request.registry, request.file.name)).pipe(Match.when(Result.isSuccess, (resolved) => outcomeFor(request.registry, request.file, resolved.success)), Match.orElse(() => Effect$1.fail(unclaimedOverrideError(request.file))));
+const outcomeFor = (registry, file, decision) => Match$1.value(decision).pipe(Match$1.when(S.is(FormatAssigned), (assigned) => parsedOutcomeFor(registry, file, assigned)), Match$1.when(S.is(FormatSkipped), (skipped) => Effect$1.succeed(skippedOutcomeFor(file, skipped))), Match$1.exhaustive);
+const fileOutcome = (request) => Match$1.value(resolveFile(request.registry, request.file.name)).pipe(Match$1.when(Result.isSuccess, (resolved) => outcomeFor(request.registry, request.file, resolved.success)), Match$1.orElse(() => Effect$1.fail(unclaimedOverrideError(request.file))));
 const isParsedOutcome = (outcome) => outcome.kind === "parsed";
 const skipsOf = (outcome) => outcome.kind === "skipped" ? [outcome.record] : [];
 const transformInto = (request) => transform(request.ast, request.collector, {
@@ -6917,7 +6949,7 @@ const collectMutants = (collector) => Effect$1.flatMap(Effect$1.sync(() => Resul
 const isScriptEntry = (entry) => entry.claim.kind === "script";
 const lacksTsDirective = (file) => !tsDirectiveLikeRegEx.test(file.content);
 const prefixesScriptWithoutParsing = (file, entry) => entry.scriptFormat !== "tsx" && lacksTsDirective(file);
-const prefixesWithoutParsing = (file, entry) => Match.value(entry).pipe(Match.when(isScriptEntry, (scriptEntry) => prefixesScriptWithoutParsing(file, scriptEntry)), Match.orElse(() => false));
+const prefixesWithoutParsing = (file, entry) => Match$1.value(entry).pipe(Match$1.when(isScriptEntry, (scriptEntry) => prefixesScriptWithoutParsing(file, scriptEntry)), Match$1.orElse(() => false));
 const disabledFile = (file, entry, ast) => Effect$1.map(entry.disableTypeChecks(ast), (content) => ({
 	...file,
 	content
@@ -6979,7 +7011,7 @@ const embeddedAstError = (ast) => InstrumentError.make({
 	message: `Expected an embedded document AST, received the "${ast.format}" format`,
 	cause: void 0
 });
-const embeddedOf = (ast) => Match.value(ast).pipe(Match.when({ format: "embedded" }, (embedded) => Option$1.some(embedded)), Match.orElse(() => Option$1.none()));
+const embeddedOf = (ast) => Match$1.value(ast).pipe(Match$1.when({ format: "embedded" }, (embedded) => Option$1.some(embedded)), Match$1.orElse(() => Option$1.none()));
 const printNothingForNonEmbeddedAst = () => "";
 const frameworkFailure = (moduleName, fileName, detail) => InstrumentError.make({
 	message: `The framework "${moduleName}" could not parse ${fileName}: ${detail}`,
@@ -7084,10 +7116,10 @@ const admitInstrumentFiles = Workflow.make({
 	command: InstrumentFilesCommand,
 	decision: S.Union([InstrumentFilesAdmitted, InstrumentFilesSkippedOnly]),
 	error: S.Never,
-	decide: (command) => Match.value(isZero(command.claimedCount)).pipe(Match.when(true, () => Result.succeed(InstrumentFilesSkippedOnly.make({ skipped: command.skipped }))), Match.when(false, () => Result.succeed(InstrumentFilesAdmitted.make({
+	decide: (command) => Match$1.value(isZero(command.claimedCount)).pipe(Match$1.when(true, () => Result.succeed(InstrumentFilesSkippedOnly.make({ skipped: command.skipped }))), Match$1.when(false, () => Result.succeed(InstrumentFilesAdmitted.make({
 		fileCount: command.fileCount,
 		skipped: command.skipped
-	}))), Match.exhaustive)
+	}))), Match$1.exhaustive)
 });
 const printedFile = (raw, { file, ast }) => Result.map(print(ast, raw.registry.entryForFormat), (content) => ({
 	name: file.name,
@@ -7241,7 +7273,12 @@ var CheckerFailed = class extends S.TaggedError()("CheckerFailed", {
 	cause: S.String,
 	checkerName: S.String,
 	mutantIds: S.Array(Mutant_exports.MutantId)
-}) {};
+}) {
+	get message() {
+		const mutants = this.mutantIds.length === 0 ? "" : ` for mutants ${this.mutantIds.join(", ")}`;
+		return `Checker "${this.checkerName}" failed${mutants}: ${this.cause}`;
+	}
+};
 var Checker = class extends Context.Service()("@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker") {};
 var Checker_exports = /* @__PURE__ */ __exportAll({
 	CheckResultSchema: () => CheckResultSchema,
@@ -7420,7 +7457,11 @@ var TestRunnerFailed = class extends S.TaggedError()("TestRunnerFailed", {
 		"mutantRun"
 	]),
 	runnerName: S.String
-}) {};
+}) {
+	get message() {
+		return `Test runner "${this.runnerName}" failed during ${this.phase}: ${this.cause}`;
+	}
+};
 const MutantResultSchema = S.Struct({
 	id: Mutant_exports.MutantId,
 	mutatorName: S.String,
@@ -7794,7 +7835,11 @@ var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
 	cause: S.String,
 	event: ReporterEventKind,
 	reporterName: S.String
-}) {};
+}) {
+	get message() {
+		return `Reporter "${this.reporterName}" failed while handling ${this.event}: ${this.cause}`;
+	}
+};
 const TraceparentHeader = S.Literal("traceparent");
 const TracestateHeader = S.Literal("tracestate");
 const VERSION = S.String.pipe(S.check(S.isPattern(/^([0-9a-e][0-9a-f]|[0-9a-f][0-9a-e])$/)));
@@ -7891,12 +7936,20 @@ var BoundaryPayloadRejected = class extends S.TaggedError()("BoundaryPayloadReje
 	pluginName: S.String,
 	method: S.String,
 	cause: S.String
-}) {};
+}) {
+	get message() {
+		return `Plugin "${this.pluginName}" rejected the payload for ${this.method}: ${this.cause}`;
+	}
+};
 var BoundaryUnrecognizedSignal = class extends S.TaggedError()("BoundaryUnrecognizedSignal", {
 	pluginName: S.String,
 	method: S.String,
 	signal: S.String
-}) {};
+}) {
+	get message() {
+		return `Plugin "${this.pluginName}" sent an unrecognized signal "${this.signal}" for ${this.method}`;
+	}
+};
 const BoundaryErrorSchema = S.Union([
 	BoundaryPayloadRejected,
 	BoundaryUnrecognizedSignal,