@systemfsoftware/stryker-js-instrumenter 8.1.0 → 9.0.0

package/dist/index.d.mts

@@ -1,236 +1,1763 @@
-import * as Effect from 'effect/Effect';
-import * as S from 'effect/Schema';
-import { YieldableError } from 'effect/Cause';
-
-export declare const causeText: <A = unknown>(cause: A, depth: number) => string | undefined;
-
-export declare interface Coverage {
-    readonly static: CoverageData;
-    readonly perTest: CoveragePerTestId;
-}
-
-export declare type CoverageData = Record<string, number>;
-
-export declare type CoveragePerTestId = Record<string, CoverageData>;
-
-export declare const disableTypeChecks: (file: File_2) => Effect.Effect<File_2, InstrumentError>;
-
-export declare interface EarlyResultPlan {
-    readonly plan: 'EarlyResult';
-    readonly mutant: Mutant;
-}
-
-export declare interface ErrnoException extends Error {
-    code?: string;
-    errno?: number;
-    path?: string;
-    syscall?: string;
-}
-
-export declare const ERROR_CODES: Readonly<{
-    NoSuchFileOrDirectory: 'ENOENT';
-}>;
-
-export declare function errorToString<A = unknown>(error: A): string;
-
-declare interface File_2 extends FileDescription {
-    name: string;
-    content: string;
-}
-export { File_2 as File }
-
-export declare interface FileDescription {
-    readonly mutate: MutateDescription;
-}
-
-export declare type FileDescriptions = Record<string, FileDescription>;
-
-export declare const instrument: (files: readonly File_2[], options: InstrumenterOptions, basePath?: string) => Effect.Effect<InstrumentResult, InstrumentError>;
-
-export declare const INSTRUMENTER_CONSTANTS: Readonly<{
-    NAMESPACE: '__stryker__';
-    MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
-    ACTIVE_MUTANT: 'activeMutant';
-    CURRENT_TEST_ID: 'currentTestId';
-    HIT_COUNT: 'hitCount';
-    HIT_LIMIT: 'hitLimit';
-    ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
-}>;
-
-export declare interface InstrumenterContext {
-    activeMutant?: string;
-    currentTestId?: string;
-    mutantCoverage?: MutantCoverage;
-    hitCount?: number;
-    hitLimit?: number;
-}
-
-export declare type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
-
-export declare const InstrumenterOptionsSchema: S.Struct<{
-    readonly excludedMutations: S.$Array<S.String>;
-    readonly ignorers: S.$Array<S.Unknown>;
-    readonly noHeader: S.optional<S.Boolean>;
-    readonly optInMutations: S.optional<S.$Array<S.String>>;
-}>;
-
-export declare class InstrumentError extends InstrumentError_base {
-    get message(): string;
-}
-
-declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
-    readonly message: S.String;
-    readonly cause: S.Defect;
-}>, YieldableError>;
-
-export declare interface InstrumentResult {
-    files: readonly File_2[];
-    mutants: readonly Mutant[];
-}
-
-export declare function isErrnoException(error: unknown): error is ErrnoException;
-
-export declare const isMutant: (value: unknown) => value is Mutant;
-
-export declare type Location = typeof LocationSchema.Type;
-
-export declare const LocationSchema: S.Struct<{
-    readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>;
-    readonly end: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>;
-}>;
-
-export declare class Mutant extends Mutant_base {}
-
-declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
-    readonly id: S.NonEmptyString;
-    readonly fileName: S.NonEmptyString;
-    readonly mutatorName: S.NonEmptyString;
-    readonly replacement: S.String;
-    readonly location: S.Struct<{
-        readonly start: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-        readonly end: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-    }>;
-    readonly status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
-    readonly statusReason: S.optional<S.String>;
-    readonly coveredBy: S.optional<S.$Array<S.String>>;
-    readonly static: S.optional<S.Boolean>;
-    readonly testsCompleted: S.optional<S.Finite>;
-    readonly description: S.optional<S.String>;
-}>, {}>;
-
-export declare type MutantActivation = typeof MutantActivationSchema.Type;
-
-export declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
-
-export declare interface MutantCoverage {
-    readonly perTest: Record<string, Record<string, number>>;
-    readonly static: Record<string, number>;
-}
-
-export declare type MutantEarlyResultPlan = EarlyResultPlan;
-
-export declare interface MutantRunOptions extends RunOptions {
-    readonly testFilter?: readonly string[];
-    readonly hitLimit?: number;
-    readonly activeMutant: Mutant;
-    readonly sandboxFileName: string;
-    readonly mutantActivation: MutantActivation;
-    readonly reloadEnvironment: boolean;
-}
-
-export declare const MutantRunOptionsSchema: S.Struct<{
-    readonly timeout: S.Finite;
-    readonly disableBail: S.Boolean;
-    readonly activeMutant: typeof Mutant;
-    readonly sandboxFileName: S.String;
-    readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
-    readonly reloadEnvironment: S.Boolean;
-    readonly testFilter: S.optionalKey<S.$Array<S.String>>;
-    readonly hitLimit: S.optionalKey<S.Finite>;
-}>;
-
-export declare type MutantRunPlan = RunPlan;
-
-export declare type MutantStatus = typeof MutantStatusSchema.Type;
-
-export declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-
-export declare type MutantTestCoverage = Mutant & {
-    readonly coveredBy: ReadonlyArray<string> | undefined;
-    readonly static: boolean | undefined;
-};
-
-export declare type MutantTestPlan = TestPlan;
-
-export declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
-
-export declare interface MutationRange {
-    readonly start: Position;
-    readonly end: Position;
-}
-
-export declare function normalizeFileName(fileName: string): string;
-
-export declare type OpenEndLocation = typeof OpenEndLocationSchema.Type;
-
-export declare const OpenEndLocationSchema: S.Struct<{
-    readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>;
-    readonly end: S.optional<S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>>;
-}>;
-
-export declare interface ParserOptions {}
-
-export declare type Position = typeof PositionSchema.Type;
-
-export declare const PositionSchema: S.Struct<{
-    readonly line: S.Finite;
-    readonly column: S.Finite;
-}>;
-
-export declare type RunMutantResult = Mutant & {
-    readonly status: MutantStatus;
-    readonly statusReason?: string | undefined;
-    readonly testsCompleted?: number | undefined;
-    readonly killedBy?: readonly string[] | undefined;
-    readonly coveredBy?: readonly string[] | undefined;
-    readonly static?: boolean | undefined;
-};
-
-export declare interface RunOptions {
-    readonly timeout: number;
-    readonly disableBail: boolean;
-}
-
-export declare const RunOptionsFields: {
-    timeout: S.Finite;
-    disableBail: S.Boolean;
-};
-
-export declare interface RunPlan {
-    readonly plan: 'Run';
-    readonly mutant: Mutant;
-    readonly runOptions: MutantRunOptions;
-    readonly netTime: number;
-}
-
-export declare type TestPlan = EarlyResultPlan | RunPlan;
-
-export { }
+import * as Option from "effect/Option";
+import "effect/Result";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { Workflow } from "@systemfsoftware/effect-cell-types";
+import "effect/Pipeable";
+import { EmbeddedDocument, FormatId, Framework, FrameworkContext } from "@systemfsoftware/stryker-framework-interface";
+import "oxc-parser";
+import "@oxc-project/types";
+//#region src/ErrorText.schema.d.ts
+declare const ErrorText_base: S.Class<ErrorText, S.Struct<{
+  readonly text: S.NonEmptyString;
+}>, {}>;
+declare class ErrorText extends ErrorText_base {
+  static fromCause: <A>(cause: A) => Option.Option<ErrorText>;
+}
+type ErrorTextValue = ErrorText;
+declare const CauseText_base: S.Class<CauseText, S.Struct<{
+  readonly text: S.NonEmptyString;
+}>, {}>;
+declare class CauseText extends CauseText_base {
+  static fromCause: <A>(cause: A) => Option.Option<CauseText>;
+}
+type CauseTextValue = CauseText;
+interface ErrnoException extends Error {
+  code?: string;
+  errno?: number;
+  path?: string;
+  syscall?: string;
+}
+declare namespace mod_d_exports {
+  export { CauseText, CauseTextValue, ErrnoException, ErrorText, ErrorTextValue };
+}
+//#endregion
+//#region ../ignorers/interface/dist/index.d.ts
+declare interface AccessorProperty$1 extends Span$1 {
+  type: AccessorPropertyType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey_2;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value: Expression$1 | null;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  definite?: boolean;
+  accessibility?: TSAccessibility | null;
+  declare?: false;
+  optional?: false;
+  readonly?: false;
+  parent?: Node$1;
+}
+declare type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty";
+declare type Argument$1 = SpreadElement$1 | Expression$1;
+declare interface ArrayAssignmentTarget extends Span$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface ArrayExpression$1 extends Span$1 {
+  type: "ArrayExpression";
+  elements: Array<ArrayExpressionElement>;
+  parent?: Node$1;
+}
+declare type ArrayExpressionElement = SpreadElement$1 | null | Expression$1;
+declare interface ArrayPattern$1 extends Span$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<BindingPattern$1 | BindingRestElement$1 | null>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface ArrowFunctionExpression$1 extends Span$1 {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  async: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType?: TSTypeAnnotation$1 | null;
+  body: FunctionBody | Expression$1;
+  id: null;
+  generator: false;
+  parent?: Node$1;
+}
+declare interface AssignmentExpression$1 extends Span$1 {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: AssignmentTarget;
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+declare interface AssignmentPattern$1 extends Span$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: BindingPattern$1;
+  right: Expression$1;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare type AssignmentTarget = SimpleAssignmentTarget$1 | AssignmentTargetPattern;
+declare type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget;
+declare type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
+declare type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
+declare interface AssignmentTargetPropertyIdentifier extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: IdentifierReference$1;
+  value: IdentifierReference$1 | AssignmentTargetWithDefault;
+  method: false;
+  shorthand: true;
+  computed: false;
+  optional?: false;
+  parent?: Node$1;
+}
+declare interface AssignmentTargetPropertyProperty extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey_2;
+  value: AssignmentTargetMaybeDefault;
+  method: false;
+  shorthand: false;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1;
+}
+declare interface AssignmentTargetRest extends Span$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: AssignmentTarget;
+  optional?: false;
+  typeAnnotation?: null;
+  value?: null;
+  parent?: Node$1;
+}
+declare interface AssignmentTargetWithDefault extends Span$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: AssignmentTarget;
+  right: Expression$1;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface AwaitExpression extends Span$1 {
+  type: "AwaitExpression";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare interface BigIntLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: bigint;
+  raw: string | null;
+  bigint: string;
+  parent?: Node$1;
+}
+declare interface BinaryExpression$1 extends Span$1 {
+  type: "BinaryExpression";
+  left: Expression$1;
+  operator: BinaryOperator;
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
+declare interface BindingIdentifier$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
+declare interface BindingProperty$1 extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey_2;
+  value: BindingPattern$1;
+  method: false;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1;
+}
+declare interface BindingRestElement$1 extends Span$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: BindingPattern$1;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value?: null;
+  parent?: Node$1;
+}
+declare interface BlockStatement$1 extends Span$1 {
+  type: "BlockStatement";
+  body: Array<Statement$1>;
+  parent?: Node$1;
+}
+declare interface BooleanLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: boolean;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface BreakStatement$1 extends Span$1 {
+  type: "BreakStatement";
+  label: LabelIdentifier$1 | null;
+  parent?: Node$1;
+}
+declare type Built<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built<T[number]>> : T) : T extends Span$1 ? { [K in keyof T as K extends keyof Span$1 ? never : K]: Child<T[K]>; } & Partial<Pick<T, keyof Span$1>> : T;
+declare interface CallExpression$1 extends Span$1 {
+  type: "CallExpression";
+  callee: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  arguments: Array<Argument$1>;
+  optional: boolean;
+  parent?: Node$1;
+}
+declare interface CatchClause$1 extends Span$1 {
+  type: "CatchClause";
+  param: BindingPattern$1 | null;
+  body: BlockStatement$1;
+  parent?: Node$1;
+}
+declare type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
+declare interface ChainExpression$1 extends Span$1 {
+  type: "ChainExpression";
+  expression: ChainElement;
+  parent?: Node$1;
+}
+declare type Child<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child<T[number]>> : T) : T extends Span$1 ? Built<T> | T : T;
+declare interface Class$1 extends Span$1 {
+  type: ClassType;
+  decorators: Array<Decorator$1>;
+  id: BindingIdentifier$1 | null;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  superClass: Expression$1 | null;
+  superTypeArguments?: TSTypeParameterInstantiation$1 | null;
+  implements?: Array<TSClassImplements>;
+  body: ClassBody$1;
+  abstract?: boolean;
+  declare?: boolean;
+  parent?: Node$1;
+}
+declare interface ClassBody$1 extends Span$1 {
+  type: "ClassBody";
+  body: Array<ClassElement>;
+  parent?: Node$1;
+}
+declare type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
+declare type ClassType = "ClassDeclaration" | "ClassExpression";
+declare interface ComputedMemberExpression extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: Expression$1;
+  optional: boolean;
+  computed: true;
+  parent?: Node$1;
+}
+declare interface ConditionalExpression$1 extends Span$1 {
+  type: "ConditionalExpression";
+  test: Expression$1;
+  consequent: Expression$1;
+  alternate: Expression$1;
+  parent?: Node$1;
+}
+declare interface ContinueStatement$1 extends Span$1 {
+  type: "ContinueStatement";
+  label: LabelIdentifier$1 | null;
+  parent?: Node$1;
+}
+declare interface DebuggerStatement extends Span$1 {
+  type: "DebuggerStatement";
+  parent?: Node$1;
+}
+declare type Declaration = VariableDeclaration$1 | Function$1 | Class$1 | TSTypeAliasDeclaration$1 | TSInterfaceDeclaration$1 | TSEnumDeclaration$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSImportEqualsDeclaration$1;
+declare interface Decorator$1 extends Span$1 {
+  type: "Decorator";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface Directive extends Span$1 {
+  type: "ExpressionStatement";
+  expression: StringLiteral$1;
+  directive: string;
+  parent?: Node$1;
+}
+declare interface DoWhileStatement$1 extends Span$1 {
+  type: "DoWhileStatement";
+  body: Statement$1;
+  test: Expression$1;
+  parent?: Node$1;
+}
+declare interface EmptyStatement$1 extends Span$1 {
+  type: "EmptyStatement";
+  parent?: Node$1;
+}
+declare interface ExportAllDeclaration$1 extends Span$1 {
+  type: "ExportAllDeclaration";
+  exported: ModuleExportName | null;
+  source: StringLiteral$1;
+  attributes: Array<ImportAttribute$1>;
+  exportKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare interface ExportDefaultDeclaration$1 extends Span$1 {
+  type: "ExportDefaultDeclaration";
+  declaration: ExportDefaultDeclarationKind;
+  exportKind?: "value";
+  parent?: Node$1;
+}
+declare type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
+declare interface ExportNamedDeclaration$1 extends Span$1 {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source: StringLiteral$1 | null;
+  exportKind?: ImportOrExportKind;
+  attributes: Array<ImportAttribute$1>;
+  parent?: Node$1;
+}
+declare interface ExportSpecifier extends Span$1 {
+  type: "ExportSpecifier";
+  local: ModuleExportName;
+  exported: ModuleExportName;
+  exportKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
+declare interface ExpressionStatement$1 extends Span$1 {
+  type: "ExpressionStatement";
+  expression: Expression$1;
+  directive?: string | null;
+  parent?: Node$1;
+}
+declare interface ForInStatement$1 extends Span$1 {
+  type: "ForInStatement";
+  left: ForStatementLeft;
+  right: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare type FormalParameter = {
+  decorators?: Array<Decorator$1>;
+} & BindingPattern$1;
+declare interface FormalParameterRest extends Span$1 {
+  type: "RestElement";
+  argument: BindingPattern$1;
+  decorators?: Array<Decorator$1>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value?: null;
+  parent?: Node$1;
+}
+declare interface ForOfStatement$1 extends Span$1 {
+  type: "ForOfStatement";
+  await: boolean;
+  left: ForStatementLeft;
+  right: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface ForStatement$1 extends Span$1 {
+  type: "ForStatement";
+  init: ForStatementInit | null;
+  test: Expression$1 | null;
+  update: Expression$1 | null;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare type ForStatementInit = VariableDeclaration$1 | Expression$1;
+declare type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
+declare interface Function$1 extends Span$1 {
+  type: FunctionType;
+  id: BindingIdentifier$1 | null;
+  generator: boolean;
+  async: boolean;
+  declare?: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType?: TSTypeAnnotation$1 | null;
+  body: FunctionBody | null;
+  expression: false;
+  parent?: Node$1;
+}
+declare interface FunctionBody extends Span$1 {
+  type: "BlockStatement";
+  body: Array<Directive | Statement$1>;
+  parent?: Node$1;
+}
+declare type FunctionType = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
+declare interface Hashbang extends Span$1 {
+  type: "Hashbang";
+  value: string;
+  parent?: Node$1;
+}
+declare interface IdentifierName$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface IdentifierReference$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface IfStatement$1 extends Span$1 {
+  type: "IfStatement";
+  test: Expression$1;
+  consequent: Statement$1;
+  alternate: Statement$1 | null;
+  parent?: Node$1;
+}
+declare interface Ignorer {
+  readonly name: string;
+  shouldIgnore(node: Node_2, ancestors: readonly Node_2[]): string | undefined;
+}
+declare interface ImportAttribute$1 extends Span$1 {
+  type: "ImportAttribute";
+  key: ImportAttributeKey;
+  value: StringLiteral$1;
+  parent?: Node$1;
+}
+declare type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
+declare interface ImportDeclaration$1 extends Span$1 {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportDeclarationSpecifier>;
+  source: StringLiteral$1;
+  phase: ImportPhase | null;
+  attributes: Array<ImportAttribute$1>;
+  importKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+declare interface ImportDefaultSpecifier extends Span$1 {
+  type: "ImportDefaultSpecifier";
+  local: BindingIdentifier$1;
+  parent?: Node$1;
+}
+declare interface ImportExpression$1 extends Span$1 {
+  type: "ImportExpression";
+  source: Expression$1;
+  options: Expression$1 | null;
+  phase: ImportPhase | null;
+  parent?: Node$1;
+}
+declare interface ImportNamespaceSpecifier extends Span$1 {
+  type: "ImportNamespaceSpecifier";
+  local: BindingIdentifier$1;
+  parent?: Node$1;
+}
+declare type ImportOrExportKind = "value" | "type";
+declare type ImportPhase = "source" | "defer";
+declare interface ImportSpecifier extends Span$1 {
+  type: "ImportSpecifier";
+  imported: ModuleExportName;
+  local: BindingIdentifier$1;
+  importKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare interface JSDocNonNullableType$1 extends Span$1 {
+  type: "TSJSDocNonNullableType";
+  typeAnnotation: TSType$1;
+  postfix: boolean;
+  parent?: Node$1;
+}
+declare interface JSDocNullableType$1 extends Span$1 {
+  type: "TSJSDocNullableType";
+  typeAnnotation: TSType$1;
+  postfix: boolean;
+  parent?: Node$1;
+}
+declare interface JSDocUnknownType extends Span$1 {
+  type: "TSJSDocUnknownType";
+  parent?: Node$1;
+}
+declare interface JSXAttribute$1 extends Span$1 {
+  type: "JSXAttribute";
+  name: JSXAttributeName;
+  value: JSXAttributeValue | null;
+  parent?: Node$1;
+}
+declare type JSXAttributeItem = JSXAttribute$1 | JSXSpreadAttribute$1;
+declare type JSXAttributeName = JSXIdentifier$1 | JSXNamespacedName$1;
+declare type JSXAttributeValue = StringLiteral$1 | JSXExpressionContainer$1 | JSXElement$1 | JSXFragment$1;
+declare type JSXChild = JSXText$1 | JSXElement$1 | JSXFragment$1 | JSXExpressionContainer$1 | JSXSpreadChild$1;
+declare interface JSXClosingElement extends Span$1 {
+  type: "JSXClosingElement";
+  name: JSXElementName;
+  parent?: Node$1;
+}
+declare interface JSXClosingFragment extends Span$1 {
+  type: "JSXClosingFragment";
+  parent?: Node$1;
+}
+declare interface JSXElement$1 extends Span$1 {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement$1;
+  children: Array<JSXChild>;
+  closingElement: JSXClosingElement | null;
+  parent?: Node$1;
+}
+declare type JSXElementName = JSXIdentifier$1 | JSXNamespacedName$1 | JSXMemberExpression$1;
+declare interface JSXEmptyExpression extends Span$1 {
+  type: "JSXEmptyExpression";
+  parent?: Node$1;
+}
+declare type JSXExpression = JSXEmptyExpression | Expression$1;
+declare interface JSXExpressionContainer$1 extends Span$1 {
+  type: "JSXExpressionContainer";
+  expression: JSXExpression;
+  parent?: Node$1;
+}
+declare interface JSXFragment$1 extends Span$1 {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  children: Array<JSXChild>;
+  closingFragment: JSXClosingFragment;
+  parent?: Node$1;
+}
+declare interface JSXIdentifier$1 extends Span$1 {
+  type: "JSXIdentifier";
+  name: string;
+  parent?: Node$1;
+}
+declare interface JSXMemberExpression$1 extends Span$1 {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpressionObject;
+  property: JSXIdentifier$1;
+  parent?: Node$1;
+}
+declare type JSXMemberExpressionObject = JSXIdentifier$1 | JSXMemberExpression$1;
+declare interface JSXNamespacedName$1 extends Span$1 {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier$1;
+  name: JSXIdentifier$1;
+  parent?: Node$1;
+}
+declare interface JSXOpeningElement$1 extends Span$1 {
+  type: "JSXOpeningElement";
+  name: JSXElementName;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  attributes: Array<JSXAttributeItem>;
+  selfClosing: boolean;
+  parent?: Node$1;
+}
+declare interface JSXOpeningFragment extends Span$1 {
+  type: "JSXOpeningFragment";
+  attributes?: [];
+  selfClosing?: false;
+  parent?: Node$1;
+}
+declare interface JSXSpreadAttribute$1 extends Span$1 {
+  type: "JSXSpreadAttribute";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare interface JSXSpreadChild$1 extends Span$1 {
+  type: "JSXSpreadChild";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface JSXText$1 extends Span$1 {
+  type: "JSXText";
+  value: string;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface LabeledStatement$1 extends Span$1 {
+  type: "LabeledStatement";
+  label: LabelIdentifier$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface LabelIdentifier$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface LogicalExpression$1 extends Span$1 {
+  type: "LogicalExpression";
+  left: Expression$1;
+  operator: LogicalOperator;
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare type LogicalOperator = "||" | "&&" | "??";
+declare type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
+declare interface MetaProperty$1 extends Span$1 {
+  type: "MetaProperty";
+  meta: IdentifierName$1;
+  property: IdentifierName$1;
+  parent?: Node$1;
+}
+declare interface MethodDefinition$1 extends Span$1 {
+  type: MethodDefinitionType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey_2;
+  value: Function$1;
+  kind: MethodDefinitionKind;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: TSAccessibility | null;
+  parent?: Node$1;
+}
+declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
+declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
+declare type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
+declare type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
+declare type ModuleKind = "script" | "module" | "commonjs";
+declare interface NewExpression$1 extends Span$1 {
+  type: "NewExpression";
+  callee: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  arguments: Array<Argument$1>;
+  parent?: Node$1;
+}
+declare type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
+declare type Node_2 = Simplify<Built<Node$1>> | Node$1;
+declare interface NullLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: null;
+  raw: "null" | null;
+  parent?: Node$1;
+}
+declare interface NumericLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: number;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface ObjectAssignmentTarget extends Span$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface ObjectExpression$1 extends Span$1 {
+  type: "ObjectExpression";
+  properties: Array<ObjectPropertyKind>;
+  parent?: Node$1;
+}
+declare interface ObjectPattern extends Span$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<BindingProperty$1 | BindingRestElement$1>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface ObjectProperty$1 extends Span$1 {
+  type: "Property";
+  kind: PropertyKind;
+  key: PropertyKey_2;
+  value: Expression$1;
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1;
+}
+declare type ObjectPropertyKind = ObjectProperty$1 | SpreadElement$1;
+declare type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
+declare interface ParenthesizedExpression extends Span$1 {
+  type: "ParenthesizedExpression";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface PrivateFieldExpression extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: PrivateIdentifier$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1;
+}
+declare interface PrivateIdentifier$1 extends Span$1 {
+  type: "PrivateIdentifier";
+  name: string;
+  parent?: Node$1;
+}
+declare interface PrivateInExpression$1 extends Span$1 {
+  type: "BinaryExpression";
+  left: PrivateIdentifier$1;
+  operator: "in";
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare interface Program$1 extends Span$1 {
+  type: "Program";
+  body: Array<Directive | Statement$1>;
+  sourceType: ModuleKind;
+  hashbang: Hashbang | null;
+  parent?: null;
+}
+declare type Program = Simplify<Built<Program$1>>;
+declare interface PropertyDefinition$1 extends Span$1 {
+  type: PropertyDefinitionType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey_2;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value: Expression$1 | null;
+  computed: boolean;
+  static: boolean;
+  declare?: boolean;
+  override?: boolean;
+  optional?: boolean;
+  definite?: boolean;
+  readonly?: boolean;
+  accessibility?: TSAccessibility | null;
+  parent?: Node$1;
+}
+declare type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
+declare type PropertyKey_2 = IdentifierName$1 | PrivateIdentifier$1 | Expression$1;
+declare type PropertyKind = "init" | "get" | "set";
+declare interface RegExpLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: RegExp | null;
+  raw: string | null;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  parent?: Node$1;
+}
+declare interface ReturnStatement$1 extends Span$1 {
+  type: "ReturnStatement";
+  argument: Expression$1 | null;
+  parent?: Node$1;
+}
+declare interface SequenceExpression$1 extends Span$1 {
+  type: "SequenceExpression";
+  expressions: Array<Expression$1>;
+  parent?: Node$1;
+}
+declare type SimpleAssignmentTarget$1 = IdentifierReference$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1 | MemberExpression$1;
+declare type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+declare interface Span$1 {
+  start: number;
+  end: number;
+  range?: [number, number];
+}
+declare interface SpreadElement$1 extends Span$1 {
+  type: "SpreadElement";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare type Statement$1 = BlockStatement$1 | BreakStatement$1 | ContinueStatement$1 | DebuggerStatement | DoWhileStatement$1 | EmptyStatement$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | IfStatement$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | WhileStatement$1 | WithStatement$1 | Declaration | ModuleDeclaration;
+declare interface StaticBlock$1 extends Span$1 {
+  type: "StaticBlock";
+  body: Array<Statement$1>;
+  parent?: Node$1;
+}
+declare interface StaticMemberExpression$1 extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: IdentifierName$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1;
+}
+declare interface StringLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: string;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface Super$1 extends Span$1 {
+  type: "Super";
+  parent?: Node$1;
+}
+declare interface SwitchCase$1 extends Span$1 {
+  type: "SwitchCase";
+  test: Expression$1 | null;
+  consequent: Array<Statement$1>;
+  parent?: Node$1;
+}
+declare interface SwitchStatement$1 extends Span$1 {
+  type: "SwitchStatement";
+  discriminant: Expression$1;
+  cases: Array<SwitchCase$1>;
+  parent?: Node$1;
+}
+declare interface TaggedTemplateExpression$1 extends Span$1 {
+  type: "TaggedTemplateExpression";
+  tag: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  quasi: TemplateLiteral$1;
+  parent?: Node$1;
+}
+declare interface TemplateElement$1 extends Span$1 {
+  type: "TemplateElement";
+  value: TemplateElementValue;
+  tail: boolean;
+  parent?: Node$1;
+}
+declare interface TemplateElementValue {
+  raw: string;
+  cooked: string | null;
+}
+declare interface TemplateLiteral$1 extends Span$1 {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement$1>;
+  expressions: Array<Expression$1>;
+  parent?: Node$1;
+}
+declare interface ThisExpression$1 extends Span$1 {
+  type: "ThisExpression";
+  parent?: Node$1;
+}
+declare interface ThrowStatement$1 extends Span$1 {
+  type: "ThrowStatement";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare interface TryStatement$1 extends Span$1 {
+  type: "TryStatement";
+  block: BlockStatement$1;
+  handler: CatchClause$1 | null;
+  finalizer: BlockStatement$1 | null;
+  parent?: Node$1;
+}
+declare type TSAccessibility = "private" | "protected" | "public";
+declare interface TSAnyKeyword extends Span$1 {
+  type: "TSAnyKeyword";
+  parent?: Node$1;
+}
+declare interface TSArrayType$1 extends Span$1 {
+  type: "TSArrayType";
+  elementType: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSAsExpression$1 extends Span$1 {
+  type: "TSAsExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSBigIntKeyword extends Span$1 {
+  type: "TSBigIntKeyword";
+  parent?: Node$1;
+}
+declare interface TSBooleanKeyword extends Span$1 {
+  type: "TSBooleanKeyword";
+  parent?: Node$1;
+}
+declare interface TSCallSignatureDeclaration$1 extends Span$1 {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSClassImplements extends Span$1 {
+  type: "TSClassImplements";
+  expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSConditionalType$1 extends Span$1 {
+  type: "TSConditionalType";
+  checkType: TSType$1;
+  extendsType: TSType$1;
+  trueType: TSType$1;
+  falseType: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSConstructorType$1 extends Span$1 {
+  type: "TSConstructorType";
+  abstract: boolean;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1;
+  parent?: Node$1;
+}
+declare interface TSConstructSignatureDeclaration$1 extends Span$1 {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSEnumBody extends Span$1 {
+  type: "TSEnumBody";
+  members: Array<TSEnumMember>;
+  parent?: Node$1;
+}
+declare interface TSEnumDeclaration$1 extends Span$1 {
+  type: "TSEnumDeclaration";
+  id: BindingIdentifier$1;
+  body: TSEnumBody;
+  const: boolean;
+  declare: boolean;
+  parent?: Node$1;
+}
+declare interface TSEnumMember extends Span$1 {
+  type: "TSEnumMember";
+  id: TSEnumMemberName;
+  initializer: Expression$1 | null;
+  computed: boolean;
+  parent?: Node$1;
+}
+declare type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
+declare interface TSExportAssignment$1 extends Span$1 {
+  type: "TSExportAssignment";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface TSExternalModuleReference extends Span$1 {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral$1;
+  parent?: Node$1;
+}
+declare interface TSFunctionType$1 extends Span$1 {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1;
+  parent?: Node$1;
+}
+declare interface TSGlobalDeclaration extends Span$1 {
+  type: "TSModuleDeclaration";
+  id: IdentifierName$1;
+  body: TSModuleBlock$1;
+  kind: "global";
+  declare: boolean;
+  global: true;
+  parent?: Node$1;
+}
+declare interface TSImportEqualsDeclaration$1 extends Span$1 {
+  type: "TSImportEqualsDeclaration";
+  id: BindingIdentifier$1;
+  moduleReference: TSModuleReference;
+  importKind: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare interface TSImportType$1 extends Span$1 {
+  type: "TSImportType";
+  source: StringLiteral$1;
+  options: ObjectExpression$1 | null;
+  qualifier: TSImportTypeQualifier | null;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSImportTypeQualifiedName extends Span$1 {
+  type: "TSQualifiedName";
+  left: TSImportTypeQualifier;
+  right: IdentifierName$1;
+  parent?: Node$1;
+}
+declare type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
+declare interface TSIndexedAccessType$1 extends Span$1 {
+  type: "TSIndexedAccessType";
+  objectType: TSType$1;
+  indexType: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSIndexSignature$1 extends Span$1 {
+  type: "TSIndexSignature";
+  parameters: Array<TSIndexSignatureName>;
+  typeAnnotation: TSTypeAnnotation$1;
+  readonly: boolean;
+  static: boolean;
+  accessibility: null;
+  parent?: Node$1;
+}
+declare interface TSIndexSignatureName extends Span$1 {
+  type: "Identifier";
+  decorators: [];
+  name: string;
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1;
+  parent?: Node$1;
+}
+declare interface TSInferType$1 extends Span$1 {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
+  parent?: Node$1;
+}
+declare interface TSInstantiationExpression$1 extends Span$1 {
+  type: "TSInstantiationExpression";
+  expression: Expression$1;
+  typeArguments: TSTypeParameterInstantiation$1;
+  parent?: Node$1;
+}
+declare interface TSInterfaceBody$1 extends Span$1 {
+  type: "TSInterfaceBody";
+  body: Array<TSSignature>;
+  parent?: Node$1;
+}
+declare interface TSInterfaceDeclaration$1 extends Span$1 {
+  type: "TSInterfaceDeclaration";
+  id: BindingIdentifier$1;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  extends: Array<TSInterfaceHeritage>;
+  body: TSInterfaceBody$1;
+  declare: boolean;
+  parent?: Node$1;
+}
+declare interface TSInterfaceHeritage extends Span$1 {
+  type: "TSInterfaceHeritage";
+  expression: Expression$1;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSIntersectionType$1 extends Span$1 {
+  type: "TSIntersectionType";
+  types: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSIntrinsicKeyword extends Span$1 {
+  type: "TSIntrinsicKeyword";
+  parent?: Node$1;
+}
+declare type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
+declare interface TSLiteralType$1 extends Span$1 {
+  type: "TSLiteralType";
+  literal: TSLiteral;
+  parent?: Node$1;
+}
+declare interface TSMappedType$1 extends Span$1 {
+  type: "TSMappedType";
+  key: BindingIdentifier$1;
+  constraint: TSType$1;
+  nameType: TSType$1 | null;
+  typeAnnotation: TSType$1 | null;
+  optional: TSMappedTypeModifierOperator | false;
+  readonly: TSMappedTypeModifierOperator | null;
+  parent?: Node$1;
+}
+declare type TSMappedTypeModifierOperator = true | "+" | "-";
+declare interface TSMethodSignature$1 extends Span$1 {
+  type: "TSMethodSignature";
+  key: PropertyKey_2;
+  computed: boolean;
+  optional: boolean;
+  kind: TSMethodSignatureKind;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  accessibility: null;
+  readonly: false;
+  static: false;
+  parent?: Node$1;
+}
+declare type TSMethodSignatureKind = "method" | "get" | "set";
+declare interface TSModuleBlock$1 extends Span$1 {
+  type: "TSModuleBlock";
+  body: Array<Directive | Statement$1>;
+  parent?: Node$1;
+}
+declare interface TSModuleDeclaration$1 extends Span$1 {
+  type: "TSModuleDeclaration";
+  id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
+  body: TSModuleBlock$1 | null;
+  kind: TSModuleDeclarationKind;
+  declare: boolean;
+  global: false;
+  parent?: Node$1;
+}
+declare type TSModuleDeclarationKind = "module" | "namespace";
+declare type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
+declare interface TSNamedTupleMember$1 extends Span$1 {
+  type: "TSNamedTupleMember";
+  label: IdentifierName$1;
+  elementType: TSTupleElement;
+  optional: boolean;
+  parent?: Node$1;
+}
+declare interface TSNamespaceExportDeclaration$1 extends Span$1 {
+  type: "TSNamespaceExportDeclaration";
+  id: IdentifierName$1;
+  parent?: Node$1;
+}
+declare interface TSNeverKeyword extends Span$1 {
+  type: "TSNeverKeyword";
+  parent?: Node$1;
+}
+declare interface TSNonNullExpression$1 extends Span$1 {
+  type: "TSNonNullExpression";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface TSNullKeyword extends Span$1 {
+  type: "TSNullKeyword";
+  parent?: Node$1;
+}
+declare interface TSNumberKeyword extends Span$1 {
+  type: "TSNumberKeyword";
+  parent?: Node$1;
+}
+declare interface TSObjectKeyword extends Span$1 {
+  type: "TSObjectKeyword";
+  parent?: Node$1;
+}
+declare interface TSOptionalType$1 extends Span$1 {
+  type: "TSOptionalType";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSParameterProperty extends Span$1 {
+  type: "TSParameterProperty";
+  accessibility: TSAccessibility | null;
+  decorators: Array<Decorator$1>;
+  override: boolean;
+  parameter: FormalParameter;
+  readonly: boolean;
+  static: boolean;
+  parent?: Node$1;
+}
+declare interface TSParenthesizedType$1 extends Span$1 {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSPropertySignature$1 extends Span$1 {
+  type: "TSPropertySignature";
+  computed: boolean;
+  optional: boolean;
+  readonly: boolean;
+  key: PropertyKey_2;
+  typeAnnotation: TSTypeAnnotation$1 | null;
+  accessibility: null;
+  static: false;
+  parent?: Node$1;
+}
+declare interface TSQualifiedName$1 extends Span$1 {
+  type: "TSQualifiedName";
+  left: TSTypeName;
+  right: IdentifierName$1;
+  parent?: Node$1;
+}
+declare interface TSRestType$1 extends Span$1 {
+  type: "TSRestType";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSSatisfiesExpression$1 extends Span$1 {
+  type: "TSSatisfiesExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
+declare interface TSStringKeyword extends Span$1 {
+  type: "TSStringKeyword";
+  parent?: Node$1;
+}
+declare interface TSSymbolKeyword extends Span$1 {
+  type: "TSSymbolKeyword";
+  parent?: Node$1;
+}
+declare interface TSTemplateLiteralType$1 extends Span$1 {
+  type: "TSTemplateLiteralType";
+  quasis: Array<TemplateElement$1>;
+  types: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSThisParameter extends Span$1 {
+  type: "Identifier";
+  decorators: [];
+  name: "this";
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSThisType extends Span$1 {
+  type: "TSThisType";
+  parent?: Node$1;
+}
+declare type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
+declare interface TSTupleType$1 extends Span$1 {
+  type: "TSTupleType";
+  elementTypes: Array<TSTupleElement>;
+  parent?: Node$1;
+}
+declare type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
+declare interface TSTypeAliasDeclaration$1 extends Span$1 {
+  type: "TSTypeAliasDeclaration";
+  id: BindingIdentifier$1;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  typeAnnotation: TSType$1;
+  declare: boolean;
+  parent?: Node$1;
+}
+declare interface TSTypeAnnotation$1 extends Span$1 {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSTypeAssertion$1 extends Span$1 {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType$1;
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface TSTypeLiteral extends Span$1 {
+  type: "TSTypeLiteral";
+  members: Array<TSSignature>;
+  parent?: Node$1;
+}
+declare type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
+declare interface TSTypeOperator$1 extends Span$1 {
+  type: "TSTypeOperator";
+  operator: TSTypeOperatorOperator;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
+declare interface TSTypeParameter extends Span$1 {
+  type: "TSTypeParameter";
+  name: BindingIdentifier$1;
+  constraint: TSType$1 | null;
+  default: TSType$1 | null;
+  in: boolean;
+  out: boolean;
+  const: boolean;
+  parent?: Node$1;
+}
+declare interface TSTypeParameterDeclaration$1 extends Span$1 {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter>;
+  parent?: Node$1;
+}
+declare interface TSTypeParameterInstantiation$1 extends Span$1 {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSTypePredicate$1 extends Span$1 {
+  type: "TSTypePredicate";
+  parameterName: TSTypePredicateName;
+  asserts: boolean;
+  typeAnnotation: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare type TSTypePredicateName = IdentifierName$1 | TSThisType;
+declare interface TSTypeQuery$1 extends Span$1 {
+  type: "TSTypeQuery";
+  exprName: TSTypeQueryExprName;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
+declare interface TSTypeReference$1 extends Span$1 {
+  type: "TSTypeReference";
+  typeName: TSTypeName;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSUndefinedKeyword extends Span$1 {
+  type: "TSUndefinedKeyword";
+  parent?: Node$1;
+}
+declare interface TSUnionType$1 extends Span$1 {
+  type: "TSUnionType";
+  types: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSUnknownKeyword extends Span$1 {
+  type: "TSUnknownKeyword";
+  parent?: Node$1;
+}
+declare interface TSVoidKeyword extends Span$1 {
+  type: "TSVoidKeyword";
+  parent?: Node$1;
+}
+declare interface UnaryExpression$1 extends Span$1 {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  argument: Expression$1;
+  prefix: true;
+  parent?: Node$1;
+}
+declare type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
+declare interface UpdateExpression$1 extends Span$1 {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  prefix: boolean;
+  argument: SimpleAssignmentTarget$1;
+  parent?: Node$1;
+}
+declare type UpdateOperator = "++" | "--";
+declare interface V8IntrinsicExpression extends Span$1 {
+  type: "V8IntrinsicExpression";
+  name: IdentifierName$1;
+  arguments: Array<Argument$1>;
+  parent?: Node$1;
+}
+declare interface VariableDeclaration$1 extends Span$1 {
+  type: "VariableDeclaration";
+  kind: VariableDeclarationKind;
+  declarations: Array<VariableDeclarator$1>;
+  declare?: boolean;
+  parent?: Node$1;
+}
+declare type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
+declare interface VariableDeclarator$1 extends Span$1 {
+  type: "VariableDeclarator";
+  id: BindingPattern$1;
+  init: Expression$1 | null;
+  definite?: boolean;
+  parent?: Node$1;
+}
+declare interface WhileStatement$1 extends Span$1 {
+  type: "WhileStatement";
+  test: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface WithStatement$1 extends Span$1 {
+  type: "WithStatement";
+  object: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface YieldExpression$1 extends Span$1 {
+  type: "YieldExpression";
+  delegate: boolean;
+  argument: Expression$1 | null;
+  parent?: Node$1;
+}
+//#endregion
+//#region src/Location.schema.d.ts
+/**
+ * File coordinates in the mutation-testing-report-schema contract: both line
+ * and column are 1-based. The first line of a file is line 1, and the first
+ * character of a line is column 1. Slicing a source line by one of these
+ * positions uses `line - 1` for the line index and `column - 1` for the
+ * character offset.
+ */
+declare const PositionSchema: S.Struct<{
+  readonly line: S.Int;
+  readonly column: S.Int;
+}>;
+type Position = typeof PositionSchema.Type;
+declare const LocationSchema: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+}>;
+type Location = typeof LocationSchema.Type;
+declare const OpenEndLocationSchema: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+  readonly end: S.optional<S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>>;
+}>;
+type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+/**
+ * A mutant's `location` already speaks the report contract (1-based line and
+ * column), so the report's location is that location unchanged.
+ */
+declare const ReportLocationFromMutant: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+}>;
+//#endregion
+//#region src/Syntax.schema.d.ts
+declare const AstFormat: S.Literals<readonly ["js", "ts", "tsx"]>;
+type AstFormat = typeof AstFormat.Type;
+//#endregion
+//#region src/Ast.schema.d.ts
+interface SpannedComment {
+  readonly type: 'Line' | 'Block';
+  readonly value: string;
+  readonly start: number;
+  readonly end: number;
+}
+type ScriptFormat = Extract<AstFormat, 'js' | 'ts' | 'tsx'>;
+interface BaseAst {
+  originFileName: string;
+  rawContent: string;
+  root: Program;
+  offset?: Position;
+}
+interface EmbeddedAst {
+  format: 'embedded';
+  formatId: FormatId;
+  originFileName: string;
+  rawContent: string;
+  document: EmbeddedDocument;
+  readonly context: FrameworkContext;
+  scripts: readonly EmbeddedScript[];
+}
+interface EmbeddedScript {
+  readonly region: number;
+  readonly ast: ScriptAst;
+}
+interface JSAst extends BaseAst {
+  format: 'js';
+  root: Program;
+  comments: readonly SpannedComment[];
+}
+interface TSAst extends BaseAst {
+  format: 'ts';
+  root: Program;
+  comments: readonly SpannedComment[];
+}
+interface TsxAst extends BaseAst {
+  format: 'tsx';
+  root: Program;
+  comments: readonly SpannedComment[];
+}
+type ScriptAst = JSAst | TSAst | TsxAst;
+type Ast = JSAst | TSAst | TsxAst | EmbeddedAst;
+//#endregion
+//#region src/Mutant.schema.d.ts
+declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+type MutantStatus = typeof MutantStatusSchema.Type;
+declare const MutantId: S.brand<S.NonEmptyString, "MutantId">;
+type MutantId = typeof MutantId.Type;
+declare const MutatorName: S.brand<S.NonEmptyString, "MutatorName">;
+type MutatorName = typeof MutatorName.Type;
+declare const CanonicalFileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+type CanonicalFileName = typeof CanonicalFileName.Type;
+declare const Mutant_base: S.Class<Mutant$1, S.TaggedStruct<"Mutant", {
+  readonly id: S.brand<S.NonEmptyString, "MutantId">;
+  readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+  readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
+  readonly replacement: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+  }>;
+  readonly status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+  readonly statusReason: S.optional<S.String>;
+  readonly coveredBy: S.optional<S.$Array<S.String>>;
+  readonly static: S.optional<S.Boolean>;
+  readonly testsCompleted: S.optional<S.Finite>;
+  readonly description: S.optional<S.String>;
+}>, {}>;
+/**
+ * A mutant's file location in the mutation-testing-report-schema contract:
+ * 1-based line and 1-based column, the same base the JSON report and the
+ * machine stream emit. Every producer on the instrument path (node spans,
+ * embedded-region shifts) targets this base; no downstream layer converts.
+ */
+declare class Mutant$1 extends Mutant_base {}
+declare const MutantFromUnknown: S.compose<typeof Mutant$1, S.Unknown>;
+type MutantFromUnknown = typeof MutantFromUnknown.Type;
+declare const RunOptionsFields: {
+  timeout: S.Finite;
+  disableBail: S.Boolean;
+};
+declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+type MutantActivation = typeof MutantActivationSchema.Type;
+declare const MutantRunOptionsSchema: S.Struct<{
+  readonly timeout: S.Finite;
+  readonly disableBail: S.Boolean;
+  readonly activeMutant: typeof Mutant$1;
+  readonly sandboxFileName: S.String;
+  readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
+  readonly reloadEnvironment: S.Boolean;
+  readonly testFilter: S.optionalKey<S.$Array<S.String>>;
+  readonly hitLimit: S.optionalKey<S.Int>;
+}>;
+declare const MutantCoverageSchema: S.Struct<{
+  readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Int>>;
+  readonly static: S.$Record<S.String, S.Int>;
+}>;
+type MutantCoverage = typeof MutantCoverageSchema.Type;
+type CoverageData = Record<string, number>;
+type CoveragePerTestId = Record<string, CoverageData>;
+interface Coverage {
+  readonly static: CoverageData;
+  readonly perTest: CoveragePerTestId;
+}
+interface RunOptions {
+  readonly timeout: number;
+  readonly disableBail: boolean;
+}
+interface MutantRunOptions extends RunOptions {
+  readonly testFilter?: readonly string[];
+  readonly hitLimit?: number;
+  readonly activeMutant: Mutant$1;
+  readonly sandboxFileName: string;
+  readonly mutantActivation: MutantActivation;
+  readonly reloadEnvironment: boolean;
+}
+interface EarlyResultPlan {
+  readonly plan: 'EarlyResult';
+  readonly mutant: Mutant$1;
+}
+interface RunPlan {
+  readonly plan: 'Run';
+  readonly mutant: Mutant$1;
+  readonly runOptions: MutantRunOptions;
+  readonly netTime: number;
+}
+type TestPlan = EarlyResultPlan | RunPlan;
+type MutantTestCoverage = Mutant$1 & {
+  readonly coveredBy: ReadonlyArray<string> | undefined;
+  readonly static: boolean | undefined;
+};
+type RunMutantResult = Mutant$1 & {
+  readonly status: MutantStatus;
+  readonly statusReason?: string | undefined;
+  readonly testsCompleted?: number | undefined;
+  readonly killedBy?: readonly string[] | undefined;
+  readonly coveredBy?: readonly string[] | undefined;
+  readonly static?: boolean | undefined;
+};
+declare const InstrumenterContext_base: S.Class<InstrumenterContext, S.Struct<{
+  readonly activeMutant: S.optional<S.String>;
+  readonly currentTestId: S.optional<S.String>;
+  readonly mutantCoverage: S.optional<S.Struct<{
+    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Int>>;
+    readonly static: S.$Record<S.String, S.Int>;
+  }>>;
+  readonly hitCount: S.optional<S.Finite>;
+  readonly hitLimit: S.optional<S.Finite>;
+}>, {}>;
+declare class InstrumenterContext extends InstrumenterContext_base {
+  static readonly NAMESPACE = "__stryker__";
+  static readonly MUTATION_COVERAGE_OBJECT = "mutantCoverage";
+  static readonly ACTIVE_MUTANT = "activeMutant";
+  static readonly CURRENT_TEST_ID = "currentTestId";
+  static readonly HIT_COUNT = "hitCount";
+  static readonly HIT_LIMIT = "hitLimit";
+  static readonly ACTIVE_MUTANT_ENV_VARIABLE = "__STRYKER_ACTIVE_MUTANT__";
+}
+type MutantRunPlan = RunPlan;
+type MutantEarlyResultPlan = EarlyResultPlan;
+type MutantTestPlan = TestPlan;
+//#endregion
+//#region src/Instrument.schema.d.ts
+declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
+  readonly message: S.String;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class InstrumentError extends InstrumentError_base {
+  get message(): string;
+}
+declare const MutateDescriptionSchema: S.Union<readonly [S.Boolean, S.$Array<S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+}>>]>;
+type MutateDescription = typeof MutateDescriptionSchema.Type;
+interface MutationRange {
+  readonly start: Position;
+  readonly end: Position;
+}
+interface FileDescription {
+  readonly mutate: MutateDescription;
+}
+type FileDescriptions = Record<string, FileDescription>;
+declare const InstrumenterOptionsSchema: S.Struct<{
+  readonly excludedMutations: S.$Array<S.String>;
+  readonly ignorers: S.$Array<S.Unknown>;
+  readonly noHeader: S.optional<S.Boolean>;
+  readonly optInMutations: S.optional<S.$Array<S.String>>;
+}>;
+type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
+declare const InstrumentFileSkip_base: S.Class<InstrumentFileSkip, S.TaggedStruct<"InstrumentFileSkip", {
+  readonly file: S.String;
+  readonly extension: S.String;
+  readonly reason: S.String;
+}>, {}>;
+declare class InstrumentFileSkip extends InstrumentFileSkip_base {}
+declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
+  readonly files: S.$Array<S.Struct<{
+    readonly name: S.String;
+    readonly content: S.String;
+    readonly mutate: S.Union<readonly [S.Boolean, S.$Array<S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+    }>>]>;
+  }>>;
+  readonly mutants: S.$Array<typeof Mutant$1>;
+  readonly skipped: S.$Array<typeof InstrumentFileSkip>;
+}>, {}>;
+declare class InstrumentResult$1 extends InstrumentResult_base {}
+//#endregion
+//#region src/Parser.schema.d.ts
+declare const ParseFailed_base: S.Class<ParseFailed, S.TaggedStruct<"ParseFailed", {
+  readonly fileName: S.String;
+  readonly message: S.String;
+  readonly location: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class ParseFailed extends ParseFailed_base {
+  get message(): string;
+}
+//#endregion
+//#region src/Parser.service.d.ts
+interface ParserOptions {}
+interface ParserContext {
+  parse: (code: string, fileName: string, scriptFormat: ScriptFormat) => Effect.Effect<ScriptAst, ParseFailed>;
+}
+//#endregion
+//#region src/Printer.handle.d.ts
+type Printer<T extends Ast = Ast> = (file: T, context: PrinterContext) => string;
+interface PrinterContext {
+  print: Printer<Ast>;
+}
+//#endregion
+//#region src/Mutator.service.d.ts
+interface Mutable {
+  mutatorName: string;
+  ignoreReason?: string | undefined;
+  replacement: Node_2;
+}
+interface Mutant extends Mutable {
+  readonly id: string;
+  readonly fileName: string;
+  readonly original: Node_2;
+  readonly location: Location;
+  readonly replacementCode: string;
+}
+interface MutatorOptions {
+  excludedMutations: string[];
+  optInMutations: readonly string[];
+  noHeader?: boolean;
+}
+//#endregion
+//#region src/Transformer.service.d.ts
+interface TransformerOptions extends MutatorOptions {
+  ignorers: readonly Ignorer[];
+}
+interface MutantCollector {
+  readonly nextIndex: number;
+  readonly append: (mutants: readonly Mutant[]) => void;
+  readonly map: <A>(transform: (mutant: Mutant) => A) => readonly A[];
+}
+type AstTransformer<T extends Ast = Ast> = (ast: T, mutantCollector: MutantCollector, context: TransformerContext) => Effect.Effect<readonly string[], ParseFailed | InstrumentError>;
+interface TransformerContext {
+  transform: AstTransformer;
+  options: TransformerOptions;
+  mutateDescription: MutateDescription;
+  registry: FormatRegistry;
+  readonly basePath?: string | undefined;
+}
+//#endregion
+//#region src/Format.schema.d.ts
+type FormatKind = 'script' | 'embedded';
+interface FormatClaim<Kind extends FormatKind = FormatKind> {
+  readonly formatId: FormatId;
+  readonly extensions: readonly string[];
+  readonly language: string;
+  readonly kind: Kind;
+}
+interface ScriptHooks {
+  readonly parse: (text: string, fileName: string, context: ParserContext) => Effect.Effect<Ast, ParseFailed | InstrumentError>;
+  readonly transform: AstTransformer;
+  readonly print: (ast: Ast, context: PrinterContext) => string;
+  readonly disableTypeChecks: (ast: Ast) => Effect.Effect<string, InstrumentError>;
+}
+interface FormatHooks extends ScriptHooks {
+  readonly owner: string;
+  readonly ownerVersion: string;
+}
+interface ScriptFormatEntry extends FormatHooks {
+  readonly claim: FormatClaim<'script'>;
+  readonly scriptFormat: ScriptFormat;
+}
+interface EmbeddedFormatEntry extends FormatHooks {
+  readonly claim: FormatClaim<'embedded'>;
+}
+type FormatEntry = ScriptFormatEntry | EmbeddedFormatEntry;
+type EntryForFormat = (formatId: string) => Option.Option<FormatEntry>;
+interface FormatRegistry {
+  readonly entries: readonly FormatEntry[];
+  readonly entryForFormat: EntryForFormat;
+  readonly entryForExtension: (extension: string) => Option.Option<FormatEntry>;
+}
+//#endregion
+//#region src/Format.handle.d.ts
+declare const extensionOf: (fileName: string) => string;
+declare const registerEntries: {
+  (registry: FormatRegistry, additions: readonly FormatEntry[]): FormatRegistry;
+  (additions: readonly FormatEntry[]): (registry: FormatRegistry) => FormatRegistry;
+};
+declare const coreFormatRegistry: FormatRegistry;
+//#endregion
+//#region src/FrameworkEntry.handle.d.ts
+declare const frameworkEntryOf: {
+  (moduleName: string, framework: Framework): EmbeddedFormatEntry;
+  (framework: Framework): (moduleName: string) => EmbeddedFormatEntry;
+};
+declare namespace mod_d_exports$1 {
+  export { EmbeddedFormatEntry, FormatClaim, FormatEntry, FormatHooks, FormatKind, FormatRegistry, ScriptFormatEntry, coreFormatRegistry, extensionOf, frameworkEntryOf, registerEntries };
+}
+//#endregion
+//#region src/Instrument.service.d.ts
+interface File extends FileDescription {
+  name: string;
+  content: string;
+}
+interface InstrumentResult {
+  files: readonly File[];
+  mutants: readonly Mutant$1[];
+  skipped: readonly InstrumentFileSkip[];
+}
+declare const instrument: {
+  (files: readonly File[], options: InstrumenterOptions, registry?: FormatRegistry): Effect.Effect<InstrumentResult$1, InstrumentError>;
+  (options: InstrumenterOptions, registry?: FormatRegistry): (files: readonly File[]) => Effect.Effect<InstrumentResult$1, InstrumentError>;
+};
+declare const disableTypeChecks: {
+  (file: File, registry?: FormatRegistry): Effect.Effect<File, InstrumentError>;
+  (registry?: FormatRegistry): (file: File) => Effect.Effect<File, InstrumentError>;
+};
+declare namespace mod_d_exports$2 {
+  export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterOptions, MutateDescription, MutationRange, ParserOptions, disableTypeChecks, instrument };
+}
+declare namespace mod_d_exports$3 {
+  export { CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, InstrumenterContext, Location, LocationSchema, Mutant$1 as Mutant, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema, MutantEarlyResultPlan, MutantFromUnknown, MutantFromUnknown as MutantFromUnknownValue, MutantId, MutantId as MutantIdValue, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutatorName, MutatorName as MutatorNameValue, OpenEndLocation, OpenEndLocationSchema, Position, PositionSchema, ReportLocationFromMutant, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, TestPlan };
+}
+//#endregion
+export { mod_d_exports as ErrorText, mod_d_exports$1 as Format, mod_d_exports$2 as Instrument, mod_d_exports$3 as Mutant };