@systemfsoftware/stryker-js 10.1.2 → 11.0.0

package/dist/index-CMCCQdTd.d.mts

@@ -0,0 +1,4087 @@
+import { Workflow } from "@systemfsoftware/effect-cell-types";
+import * as Option$1 from "effect/Option";
+import "effect/Result";
+import * as S from "effect/Schema";
+import * as Effect$1 from "effect/Effect";
+import "effect/Pipeable";
+import * as Context from "effect/Context";
+import { Schema } from "effect";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
+import * as HashMap from "effect/HashMap";
+import { StandardSchemaV1 } from "effect/StandardSchema";
+//#region ../ignorers/interface/dist/index.d.ts
+declare interface AccessorProperty$1$1 extends Span$1$1 {
+  type: AccessorPropertyType$1;
+  decorators: Array<Decorator$1$1>;
+  key: PropertyKey_2$1;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  value: Expression$1$1 | null;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  definite?: boolean;
+  accessibility?: TSAccessibility$1 | null;
+  declare?: false;
+  optional?: false;
+  readonly?: false;
+  parent?: Node$1$1;
+}
+declare type AccessorPropertyType$1 = "AccessorProperty" | "TSAbstractAccessorProperty";
+declare type Argument$1$1 = SpreadElement$1$1 | Expression$1$1;
+declare interface ArrayAssignmentTarget$1 extends Span$1$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<AssignmentTargetMaybeDefault$1 | AssignmentTargetRest$1 | null>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare interface ArrayExpression$1$1 extends Span$1$1 {
+  type: "ArrayExpression";
+  elements: Array<ArrayExpressionElement$1>;
+  parent?: Node$1$1;
+}
+declare type ArrayExpressionElement$1 = SpreadElement$1$1 | null | Expression$1$1;
+declare interface ArrayPattern$1$1 extends Span$1$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<BindingPattern$1$1 | BindingRestElement$1$1 | null>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface ArrowFunctionExpression$1$1 extends Span$1$1 {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  async: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType?: TSTypeAnnotation$1$1 | null;
+  body: FunctionBody$1 | Expression$1$1;
+  id: null;
+  generator: false;
+  parent?: Node$1$1;
+}
+declare interface AssignmentExpression$1$1 extends Span$1$1 {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator$1;
+  left: AssignmentTarget$1;
+  right: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare type AssignmentOperator$1 = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+declare interface AssignmentPattern$1$1 extends Span$1$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: BindingPattern$1$1;
+  right: Expression$1$1;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare type AssignmentTarget$1 = SimpleAssignmentTarget$1$1 | AssignmentTargetPattern$1;
+declare type AssignmentTargetMaybeDefault$1 = AssignmentTargetWithDefault$1 | AssignmentTarget$1;
+declare type AssignmentTargetPattern$1 = ArrayAssignmentTarget$1 | ObjectAssignmentTarget$1;
+declare type AssignmentTargetProperty$1 = AssignmentTargetPropertyIdentifier$1 | AssignmentTargetPropertyProperty$1;
+declare interface AssignmentTargetPropertyIdentifier$1 extends Span$1$1 {
+  type: "Property";
+  kind: "init";
+  key: IdentifierReference$1$1;
+  value: IdentifierReference$1$1 | AssignmentTargetWithDefault$1;
+  method: false;
+  shorthand: true;
+  computed: false;
+  optional?: false;
+  parent?: Node$1$1;
+}
+declare interface AssignmentTargetPropertyProperty$1 extends Span$1$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey_2$1;
+  value: AssignmentTargetMaybeDefault$1;
+  method: false;
+  shorthand: false;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1$1;
+}
+declare interface AssignmentTargetRest$1 extends Span$1$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: AssignmentTarget$1;
+  optional?: false;
+  typeAnnotation?: null;
+  value?: null;
+  parent?: Node$1$1;
+}
+declare interface AssignmentTargetWithDefault$1 extends Span$1$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: AssignmentTarget$1;
+  right: Expression$1$1;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare interface AwaitExpression$1 extends Span$1$1 {
+  type: "AwaitExpression";
+  argument: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface BigIntLiteral$1$1 extends Span$1$1 {
+  type: "Literal";
+  value: bigint;
+  raw: string | null;
+  bigint: string;
+  parent?: Node$1$1;
+}
+declare interface BinaryExpression$1$1 extends Span$1$1 {
+  type: "BinaryExpression";
+  left: Expression$1$1;
+  operator: BinaryOperator$1;
+  right: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare type BinaryOperator$1 = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
+declare interface BindingIdentifier$1$1 extends Span$1$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare type BindingPattern$1$1 = BindingIdentifier$1$1 | ObjectPattern$1 | ArrayPattern$1$1 | AssignmentPattern$1$1;
+declare interface BindingProperty$1$1 extends Span$1$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey_2$1;
+  value: BindingPattern$1$1;
+  method: false;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1$1;
+}
+declare interface BindingRestElement$1$1 extends Span$1$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: BindingPattern$1$1;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  value?: null;
+  parent?: Node$1$1;
+}
+declare interface BlockStatement$1$1 extends Span$1$1 {
+  type: "BlockStatement";
+  body: Array<Statement$1$1>;
+  parent?: Node$1$1;
+}
+declare interface BooleanLiteral$1$1 extends Span$1$1 {
+  type: "Literal";
+  value: boolean;
+  raw: string | null;
+  parent?: Node$1$1;
+}
+declare interface BreakStatement$1$1 extends Span$1$1 {
+  type: "BreakStatement";
+  label: LabelIdentifier$1$1 | null;
+  parent?: Node$1$1;
+}
+declare type Built$1<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built$1<T[number]>> : T) : T extends Span$1$1 ? { [K in keyof T as K extends keyof Span$1$1 ? never : K]: Child$1<T[K]>; } & Partial<Pick<T, keyof Span$1$1>> : T;
+declare interface CallExpression$1$1 extends Span$1$1 {
+  type: "CallExpression";
+  callee: Expression$1$1;
+  typeArguments?: TSTypeParameterInstantiation$1$1 | null;
+  arguments: Array<Argument$1$1>;
+  optional: boolean;
+  parent?: Node$1$1;
+}
+declare interface CatchClause$1$1 extends Span$1$1 {
+  type: "CatchClause";
+  param: BindingPattern$1$1 | null;
+  body: BlockStatement$1$1;
+  parent?: Node$1$1;
+}
+declare type ChainElement$1 = CallExpression$1$1 | TSNonNullExpression$1$1 | MemberExpression$1$1;
+declare interface ChainExpression$1$1 extends Span$1$1 {
+  type: "ChainExpression";
+  expression: ChainElement$1;
+  parent?: Node$1$1;
+}
+declare type Child$1<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child$1<T[number]>> : T) : T extends Span$1$1 ? Built$1<T> | T : T;
+declare interface Class$1$1 extends Span$1$1 {
+  type: ClassType$1;
+  decorators: Array<Decorator$1$1>;
+  id: BindingIdentifier$1$1 | null;
+  typeParameters?: TSTypeParameterDeclaration$1$1 | null;
+  superClass: Expression$1$1 | null;
+  superTypeArguments?: TSTypeParameterInstantiation$1$1 | null;
+  implements?: Array<TSClassImplements$1>;
+  body: ClassBody$1$1;
+  abstract?: boolean;
+  declare?: boolean;
+  parent?: Node$1$1;
+}
+declare interface ClassBody$1$1 extends Span$1$1 {
+  type: "ClassBody";
+  body: Array<ClassElement$1>;
+  parent?: Node$1$1;
+}
+declare type ClassElement$1 = StaticBlock$1$1 | MethodDefinition$1$1 | PropertyDefinition$1$1 | AccessorProperty$1$1 | TSIndexSignature$1$1;
+declare type ClassType$1 = "ClassDeclaration" | "ClassExpression";
+declare interface ComputedMemberExpression$1 extends Span$1$1 {
+  type: "MemberExpression";
+  object: Expression$1$1;
+  property: Expression$1$1;
+  optional: boolean;
+  computed: true;
+  parent?: Node$1$1;
+}
+declare interface ConditionalExpression$1$1 extends Span$1$1 {
+  type: "ConditionalExpression";
+  test: Expression$1$1;
+  consequent: Expression$1$1;
+  alternate: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface ContinueStatement$1$1 extends Span$1$1 {
+  type: "ContinueStatement";
+  label: LabelIdentifier$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface DebuggerStatement$1 extends Span$1$1 {
+  type: "DebuggerStatement";
+  parent?: Node$1$1;
+}
+declare type Declaration$1 = VariableDeclaration$1$1 | Function$1$1 | Class$1$1 | TSTypeAliasDeclaration$1$1 | TSInterfaceDeclaration$1$1 | TSEnumDeclaration$1$1 | TSModuleDeclaration$1$1 | TSGlobalDeclaration$1 | TSImportEqualsDeclaration$1$1;
+declare interface Decorator$1$1 extends Span$1$1 {
+  type: "Decorator";
+  expression: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface Directive$1 extends Span$1$1 {
+  type: "ExpressionStatement";
+  expression: StringLiteral$1$1;
+  directive: string;
+  parent?: Node$1$1;
+}
+declare interface DoWhileStatement$1$1 extends Span$1$1 {
+  type: "DoWhileStatement";
+  body: Statement$1$1;
+  test: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface EmptyStatement$1$1 extends Span$1$1 {
+  type: "EmptyStatement";
+  parent?: Node$1$1;
+}
+declare interface ExportAllDeclaration$1$1 extends Span$1$1 {
+  type: "ExportAllDeclaration";
+  exported: ModuleExportName$1 | null;
+  source: StringLiteral$1$1;
+  attributes: Array<ImportAttribute$1$1>;
+  exportKind?: ImportOrExportKind$1;
+  parent?: Node$1$1;
+}
+declare interface ExportDefaultDeclaration$1$1 extends Span$1$1 {
+  type: "ExportDefaultDeclaration";
+  declaration: ExportDefaultDeclarationKind$1;
+  exportKind?: "value";
+  parent?: Node$1$1;
+}
+declare type ExportDefaultDeclarationKind$1 = Function$1$1 | Class$1$1 | TSInterfaceDeclaration$1$1 | Expression$1$1;
+declare interface ExportNamedDeclaration$1$1 extends Span$1$1 {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration$1 | null;
+  specifiers: Array<ExportSpecifier$1>;
+  source: StringLiteral$1$1 | null;
+  exportKind?: ImportOrExportKind$1;
+  attributes: Array<ImportAttribute$1$1>;
+  parent?: Node$1$1;
+}
+declare interface ExportSpecifier$1 extends Span$1$1 {
+  type: "ExportSpecifier";
+  local: ModuleExportName$1;
+  exported: ModuleExportName$1;
+  exportKind?: ImportOrExportKind$1;
+  parent?: Node$1$1;
+}
+declare type Expression$1$1 = BooleanLiteral$1$1 | NullLiteral$1$1 | NumericLiteral$1$1 | BigIntLiteral$1$1 | RegExpLiteral$1$1 | StringLiteral$1$1 | TemplateLiteral$1$1 | IdentifierReference$1$1 | Super$1$1 | ArrayExpression$1$1 | ArrowFunctionExpression$1$1 | AssignmentExpression$1$1 | AwaitExpression$1 | BinaryExpression$1$1 | CallExpression$1$1 | ChainExpression$1$1 | Class$1$1 | ConditionalExpression$1$1 | Function$1$1 | ImportExpression$1$1 | LogicalExpression$1$1 | NewExpression$1$1 | ObjectExpression$1$1 | ParenthesizedExpression$1 | SequenceExpression$1$1 | TaggedTemplateExpression$1$1 | ThisExpression$1$1 | UnaryExpression$1$1 | UpdateExpression$1$1 | YieldExpression$1$1 | PrivateInExpression$1$1 | MetaProperty$1$1 | JSXElement$1$1 | JSXFragment$1$1 | TSAsExpression$1$1 | TSSatisfiesExpression$1$1 | TSTypeAssertion$1$1 | TSNonNullExpression$1$1 | TSInstantiationExpression$1$1 | V8IntrinsicExpression$1 | MemberExpression$1$1;
+declare interface ExpressionStatement$1$1 extends Span$1$1 {
+  type: "ExpressionStatement";
+  expression: Expression$1$1;
+  directive?: string | null;
+  parent?: Node$1$1;
+}
+declare interface ForInStatement$1$1 extends Span$1$1 {
+  type: "ForInStatement";
+  left: ForStatementLeft$1;
+  right: Expression$1$1;
+  body: Statement$1$1;
+  parent?: Node$1$1;
+}
+declare type FormalParameter$1 = {
+  decorators?: Array<Decorator$1$1>;
+} & BindingPattern$1$1;
+declare interface FormalParameterRest$1 extends Span$1$1 {
+  type: "RestElement";
+  argument: BindingPattern$1$1;
+  decorators?: Array<Decorator$1$1>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  value?: null;
+  parent?: Node$1$1;
+}
+declare interface ForOfStatement$1$1 extends Span$1$1 {
+  type: "ForOfStatement";
+  await: boolean;
+  left: ForStatementLeft$1;
+  right: Expression$1$1;
+  body: Statement$1$1;
+  parent?: Node$1$1;
+}
+declare interface ForStatement$1$1 extends Span$1$1 {
+  type: "ForStatement";
+  init: ForStatementInit$1 | null;
+  test: Expression$1$1 | null;
+  update: Expression$1$1 | null;
+  body: Statement$1$1;
+  parent?: Node$1$1;
+}
+declare type ForStatementInit$1 = VariableDeclaration$1$1 | Expression$1$1;
+declare type ForStatementLeft$1 = VariableDeclaration$1$1 | AssignmentTarget$1;
+declare interface Function$1$1 extends Span$1$1 {
+  type: FunctionType$1;
+  id: BindingIdentifier$1$1 | null;
+  generator: boolean;
+  async: boolean;
+  declare?: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType?: TSTypeAnnotation$1$1 | null;
+  body: FunctionBody$1 | null;
+  expression: false;
+  parent?: Node$1$1;
+}
+declare interface FunctionBody$1 extends Span$1$1 {
+  type: "BlockStatement";
+  body: Array<Directive$1 | Statement$1$1>;
+  parent?: Node$1$1;
+}
+declare type FunctionType$1 = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
+declare interface Hashbang$1 extends Span$1$1 {
+  type: "Hashbang";
+  value: string;
+  parent?: Node$1$1;
+}
+declare interface IdentifierName$1$1 extends Span$1$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare interface IdentifierReference$1$1 extends Span$1$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare interface IfStatement$1$1 extends Span$1$1 {
+  type: "IfStatement";
+  test: Expression$1$1;
+  consequent: Statement$1$1;
+  alternate: Statement$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface Ignorer$1 {
+  readonly name: string;
+  shouldIgnore(node: Node_2$1, ancestors: readonly Node_2$1[]): string | undefined;
+}
+declare interface ImportAttribute$1$1 extends Span$1$1 {
+  type: "ImportAttribute";
+  key: ImportAttributeKey$1;
+  value: StringLiteral$1$1;
+  parent?: Node$1$1;
+}
+declare type ImportAttributeKey$1 = IdentifierName$1$1 | StringLiteral$1$1;
+declare interface ImportDeclaration$1$1 extends Span$1$1 {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportDeclarationSpecifier$1>;
+  source: StringLiteral$1$1;
+  phase: ImportPhase$1 | null;
+  attributes: Array<ImportAttribute$1$1>;
+  importKind?: ImportOrExportKind$1;
+  parent?: Node$1$1;
+}
+declare type ImportDeclarationSpecifier$1 = ImportSpecifier$1 | ImportDefaultSpecifier$1 | ImportNamespaceSpecifier$1;
+declare interface ImportDefaultSpecifier$1 extends Span$1$1 {
+  type: "ImportDefaultSpecifier";
+  local: BindingIdentifier$1$1;
+  parent?: Node$1$1;
+}
+declare interface ImportExpression$1$1 extends Span$1$1 {
+  type: "ImportExpression";
+  source: Expression$1$1;
+  options: Expression$1$1 | null;
+  phase: ImportPhase$1 | null;
+  parent?: Node$1$1;
+}
+declare interface ImportNamespaceSpecifier$1 extends Span$1$1 {
+  type: "ImportNamespaceSpecifier";
+  local: BindingIdentifier$1$1;
+  parent?: Node$1$1;
+}
+declare type ImportOrExportKind$1 = "value" | "type";
+declare type ImportPhase$1 = "source" | "defer";
+declare interface ImportSpecifier$1 extends Span$1$1 {
+  type: "ImportSpecifier";
+  imported: ModuleExportName$1;
+  local: BindingIdentifier$1$1;
+  importKind?: ImportOrExportKind$1;
+  parent?: Node$1$1;
+}
+declare interface JSDocNonNullableType$1$1 extends Span$1$1 {
+  type: "TSJSDocNonNullableType";
+  typeAnnotation: TSType$1$1;
+  postfix: boolean;
+  parent?: Node$1$1;
+}
+declare interface JSDocNullableType$1$1 extends Span$1$1 {
+  type: "TSJSDocNullableType";
+  typeAnnotation: TSType$1$1;
+  postfix: boolean;
+  parent?: Node$1$1;
+}
+declare interface JSDocUnknownType$1 extends Span$1$1 {
+  type: "TSJSDocUnknownType";
+  parent?: Node$1$1;
+}
+declare interface JSXAttribute$1$1 extends Span$1$1 {
+  type: "JSXAttribute";
+  name: JSXAttributeName$1;
+  value: JSXAttributeValue$1 | null;
+  parent?: Node$1$1;
+}
+declare type JSXAttributeItem$1 = JSXAttribute$1$1 | JSXSpreadAttribute$1$1;
+declare type JSXAttributeName$1 = JSXIdentifier$1$1 | JSXNamespacedName$1$1;
+declare type JSXAttributeValue$1 = StringLiteral$1$1 | JSXExpressionContainer$1$1 | JSXElement$1$1 | JSXFragment$1$1;
+declare type JSXChild$1 = JSXText$1$1 | JSXElement$1$1 | JSXFragment$1$1 | JSXExpressionContainer$1$1 | JSXSpreadChild$1$1;
+declare interface JSXClosingElement$1 extends Span$1$1 {
+  type: "JSXClosingElement";
+  name: JSXElementName$1;
+  parent?: Node$1$1;
+}
+declare interface JSXClosingFragment$1 extends Span$1$1 {
+  type: "JSXClosingFragment";
+  parent?: Node$1$1;
+}
+declare interface JSXElement$1$1 extends Span$1$1 {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement$1$1;
+  children: Array<JSXChild$1>;
+  closingElement: JSXClosingElement$1 | null;
+  parent?: Node$1$1;
+}
+declare type JSXElementName$1 = JSXIdentifier$1$1 | JSXNamespacedName$1$1 | JSXMemberExpression$1$1;
+declare interface JSXEmptyExpression$1 extends Span$1$1 {
+  type: "JSXEmptyExpression";
+  parent?: Node$1$1;
+}
+declare type JSXExpression$1 = JSXEmptyExpression$1 | Expression$1$1;
+declare interface JSXExpressionContainer$1$1 extends Span$1$1 {
+  type: "JSXExpressionContainer";
+  expression: JSXExpression$1;
+  parent?: Node$1$1;
+}
+declare interface JSXFragment$1$1 extends Span$1$1 {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment$1;
+  children: Array<JSXChild$1>;
+  closingFragment: JSXClosingFragment$1;
+  parent?: Node$1$1;
+}
+declare interface JSXIdentifier$1$1 extends Span$1$1 {
+  type: "JSXIdentifier";
+  name: string;
+  parent?: Node$1$1;
+}
+declare interface JSXMemberExpression$1$1 extends Span$1$1 {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpressionObject$1;
+  property: JSXIdentifier$1$1;
+  parent?: Node$1$1;
+}
+declare type JSXMemberExpressionObject$1 = JSXIdentifier$1$1 | JSXMemberExpression$1$1;
+declare interface JSXNamespacedName$1$1 extends Span$1$1 {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier$1$1;
+  name: JSXIdentifier$1$1;
+  parent?: Node$1$1;
+}
+declare interface JSXOpeningElement$1$1 extends Span$1$1 {
+  type: "JSXOpeningElement";
+  name: JSXElementName$1;
+  typeArguments?: TSTypeParameterInstantiation$1$1 | null;
+  attributes: Array<JSXAttributeItem$1>;
+  selfClosing: boolean;
+  parent?: Node$1$1;
+}
+declare interface JSXOpeningFragment$1 extends Span$1$1 {
+  type: "JSXOpeningFragment";
+  attributes?: [];
+  selfClosing?: false;
+  parent?: Node$1$1;
+}
+declare interface JSXSpreadAttribute$1$1 extends Span$1$1 {
+  type: "JSXSpreadAttribute";
+  argument: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface JSXSpreadChild$1$1 extends Span$1$1 {
+  type: "JSXSpreadChild";
+  expression: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface JSXText$1$1 extends Span$1$1 {
+  type: "JSXText";
+  value: string;
+  raw: string | null;
+  parent?: Node$1$1;
+}
+declare interface LabeledStatement$1$1 extends Span$1$1 {
+  type: "LabeledStatement";
+  label: LabelIdentifier$1$1;
+  body: Statement$1$1;
+  parent?: Node$1$1;
+}
+declare interface LabelIdentifier$1$1 extends Span$1$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare interface LogicalExpression$1$1 extends Span$1$1 {
+  type: "LogicalExpression";
+  left: Expression$1$1;
+  operator: LogicalOperator$1;
+  right: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare type LogicalOperator$1 = "||" | "&&" | "??";
+declare type MemberExpression$1$1 = ComputedMemberExpression$1 | StaticMemberExpression$1$1 | PrivateFieldExpression$1;
+declare interface MetaProperty$1$1 extends Span$1$1 {
+  type: "MetaProperty";
+  meta: IdentifierName$1$1;
+  property: IdentifierName$1$1;
+  parent?: Node$1$1;
+}
+declare interface MethodDefinition$1$1 extends Span$1$1 {
+  type: MethodDefinitionType$1;
+  decorators: Array<Decorator$1$1>;
+  key: PropertyKey_2$1;
+  value: Function$1$1;
+  kind: MethodDefinitionKind$1;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: TSAccessibility$1 | null;
+  parent?: Node$1$1;
+}
+declare type MethodDefinitionKind$1 = "constructor" | "method" | "get" | "set";
+declare type MethodDefinitionType$1 = "MethodDefinition" | "TSAbstractMethodDefinition";
+declare type ModuleDeclaration$1 = ImportDeclaration$1$1 | ExportAllDeclaration$1$1 | ExportDefaultDeclaration$1$1 | ExportNamedDeclaration$1$1 | TSExportAssignment$1$1 | TSNamespaceExportDeclaration$1$1;
+declare type ModuleExportName$1 = IdentifierName$1$1 | IdentifierReference$1$1 | StringLiteral$1$1;
+declare type ModuleKind$1 = "script" | "module" | "commonjs";
+declare interface NewExpression$1$1 extends Span$1$1 {
+  type: "NewExpression";
+  callee: Expression$1$1;
+  typeArguments?: TSTypeParameterInstantiation$1$1 | null;
+  arguments: Array<Argument$1$1>;
+  parent?: Node$1$1;
+}
+declare type Node$1$1 = Program$1$1 | IdentifierName$1$1 | IdentifierReference$1$1 | BindingIdentifier$1$1 | LabelIdentifier$1$1 | ThisExpression$1$1 | ArrayExpression$1$1 | ObjectExpression$1$1 | ObjectProperty$1$1 | TemplateLiteral$1$1 | TaggedTemplateExpression$1$1 | TemplateElement$1$1 | ComputedMemberExpression$1 | StaticMemberExpression$1$1 | PrivateFieldExpression$1 | CallExpression$1$1 | NewExpression$1$1 | MetaProperty$1$1 | SpreadElement$1$1 | UpdateExpression$1$1 | UnaryExpression$1$1 | BinaryExpression$1$1 | PrivateInExpression$1$1 | LogicalExpression$1$1 | ConditionalExpression$1$1 | AssignmentExpression$1$1 | ArrayAssignmentTarget$1 | ObjectAssignmentTarget$1 | AssignmentTargetRest$1 | AssignmentTargetWithDefault$1 | AssignmentTargetPropertyIdentifier$1 | AssignmentTargetPropertyProperty$1 | SequenceExpression$1$1 | Super$1$1 | AwaitExpression$1 | ChainExpression$1$1 | ParenthesizedExpression$1 | Directive$1 | Hashbang$1 | BlockStatement$1$1 | VariableDeclaration$1$1 | VariableDeclarator$1$1 | EmptyStatement$1$1 | ExpressionStatement$1$1 | IfStatement$1$1 | DoWhileStatement$1$1 | WhileStatement$1$1 | ForStatement$1$1 | ForInStatement$1$1 | ForOfStatement$1$1 | ContinueStatement$1$1 | BreakStatement$1$1 | ReturnStatement$1$1 | WithStatement$1$1 | SwitchStatement$1$1 | SwitchCase$1$1 | LabeledStatement$1$1 | ThrowStatement$1$1 | TryStatement$1$1 | CatchClause$1$1 | DebuggerStatement$1 | AssignmentPattern$1$1 | ObjectPattern$1 | BindingProperty$1$1 | ArrayPattern$1$1 | BindingRestElement$1$1 | Function$1$1 | FunctionBody$1 | ArrowFunctionExpression$1$1 | YieldExpression$1$1 | Class$1$1 | ClassBody$1$1 | MethodDefinition$1$1 | PropertyDefinition$1$1 | PrivateIdentifier$1$1 | StaticBlock$1$1 | AccessorProperty$1$1 | ImportExpression$1$1 | ImportDeclaration$1$1 | ImportSpecifier$1 | ImportDefaultSpecifier$1 | ImportNamespaceSpecifier$1 | ImportAttribute$1$1 | ExportNamedDeclaration$1$1 | ExportDefaultDeclaration$1$1 | ExportAllDeclaration$1$1 | ExportSpecifier$1 | V8IntrinsicExpression$1 | BooleanLiteral$1$1 | NullLiteral$1$1 | NumericLiteral$1$1 | StringLiteral$1$1 | BigIntLiteral$1$1 | RegExpLiteral$1$1 | JSXElement$1$1 | JSXOpeningElement$1$1 | JSXClosingElement$1 | JSXFragment$1$1 | JSXOpeningFragment$1 | JSXClosingFragment$1 | JSXNamespacedName$1$1 | JSXMemberExpression$1$1 | JSXExpressionContainer$1$1 | JSXEmptyExpression$1 | JSXAttribute$1$1 | JSXSpreadAttribute$1$1 | JSXIdentifier$1$1 | JSXSpreadChild$1$1 | JSXText$1$1 | TSThisParameter$1 | TSEnumDeclaration$1$1 | TSEnumBody$1 | TSEnumMember$1 | TSTypeAnnotation$1$1 | TSLiteralType$1$1 | TSConditionalType$1$1 | TSUnionType$1$1 | TSIntersectionType$1$1 | TSParenthesizedType$1$1 | TSTypeOperator$1$1 | TSArrayType$1$1 | TSIndexedAccessType$1$1 | TSTupleType$1$1 | TSNamedTupleMember$1$1 | TSOptionalType$1$1 | TSRestType$1$1 | TSAnyKeyword$1 | TSStringKeyword$1 | TSBooleanKeyword$1 | TSNumberKeyword$1 | TSNeverKeyword$1 | TSIntrinsicKeyword$1 | TSUnknownKeyword$1 | TSNullKeyword$1 | TSUndefinedKeyword$1 | TSVoidKeyword$1 | TSSymbolKeyword$1 | TSThisType$1 | TSObjectKeyword$1 | TSBigIntKeyword$1 | TSTypeReference$1$1 | TSQualifiedName$1$1 | TSTypeParameterInstantiation$1$1 | TSTypeParameter$1 | TSTypeParameterDeclaration$1$1 | TSTypeAliasDeclaration$1$1 | TSClassImplements$1 | TSInterfaceDeclaration$1$1 | TSInterfaceBody$1$1 | TSPropertySignature$1$1 | TSIndexSignature$1$1 | TSCallSignatureDeclaration$1$1 | TSMethodSignature$1$1 | TSConstructSignatureDeclaration$1$1 | TSIndexSignatureName$1 | TSInterfaceHeritage$1 | TSTypePredicate$1$1 | TSModuleDeclaration$1$1 | TSGlobalDeclaration$1 | TSModuleBlock$1$1 | TSTypeLiteral$1 | TSInferType$1$1 | TSTypeQuery$1$1 | TSImportType$1$1 | TSImportTypeQualifiedName$1 | TSFunctionType$1$1 | TSConstructorType$1$1 | TSMappedType$1$1 | TSTemplateLiteralType$1$1 | TSAsExpression$1$1 | TSSatisfiesExpression$1$1 | TSTypeAssertion$1$1 | TSImportEqualsDeclaration$1$1 | TSExternalModuleReference$1 | TSNonNullExpression$1$1 | Decorator$1$1 | TSExportAssignment$1$1 | TSNamespaceExportDeclaration$1$1 | TSInstantiationExpression$1$1 | JSDocNullableType$1$1 | JSDocNonNullableType$1$1 | JSDocUnknownType$1 | ParamPattern$1$1;
+declare type Node_2$1 = Simplify$1<Built$1<Node$1$1>> | Node$1$1;
+declare interface NullLiteral$1$1 extends Span$1$1 {
+  type: "Literal";
+  value: null;
+  raw: "null" | null;
+  parent?: Node$1$1;
+}
+declare interface NumericLiteral$1$1 extends Span$1$1 {
+  type: "Literal";
+  value: number;
+  raw: string | null;
+  parent?: Node$1$1;
+}
+declare interface ObjectAssignmentTarget$1 extends Span$1$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<AssignmentTargetProperty$1 | AssignmentTargetRest$1>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1$1;
+}
+declare interface ObjectExpression$1$1 extends Span$1$1 {
+  type: "ObjectExpression";
+  properties: Array<ObjectPropertyKind$1>;
+  parent?: Node$1$1;
+}
+declare interface ObjectPattern$1 extends Span$1$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<BindingProperty$1$1 | BindingRestElement$1$1>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface ObjectProperty$1$1 extends Span$1$1 {
+  type: "Property";
+  kind: PropertyKind$1;
+  key: PropertyKey_2$1;
+  value: Expression$1$1;
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1$1;
+}
+declare type ObjectPropertyKind$1 = ObjectProperty$1$1 | SpreadElement$1$1;
+declare type ParamPattern$1$1 = FormalParameter$1 | TSParameterProperty$1 | FormalParameterRest$1;
+declare interface ParenthesizedExpression$1 extends Span$1$1 {
+  type: "ParenthesizedExpression";
+  expression: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface PrivateFieldExpression$1 extends Span$1$1 {
+  type: "MemberExpression";
+  object: Expression$1$1;
+  property: PrivateIdentifier$1$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1$1;
+}
+declare interface PrivateIdentifier$1$1 extends Span$1$1 {
+  type: "PrivateIdentifier";
+  name: string;
+  parent?: Node$1$1;
+}
+declare interface PrivateInExpression$1$1 extends Span$1$1 {
+  type: "BinaryExpression";
+  left: PrivateIdentifier$1$1;
+  operator: "in";
+  right: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface Program$1$1 extends Span$1$1 {
+  type: "Program";
+  body: Array<Directive$1 | Statement$1$1>;
+  sourceType: ModuleKind$1;
+  hashbang: Hashbang$1 | null;
+  parent?: null;
+}
+declare type Program$2 = Simplify$1<Built$1<Program$1$1>>;
+declare interface PropertyDefinition$1$1 extends Span$1$1 {
+  type: PropertyDefinitionType$1;
+  decorators: Array<Decorator$1$1>;
+  key: PropertyKey_2$1;
+  typeAnnotation?: TSTypeAnnotation$1$1 | null;
+  value: Expression$1$1 | null;
+  computed: boolean;
+  static: boolean;
+  declare?: boolean;
+  override?: boolean;
+  optional?: boolean;
+  definite?: boolean;
+  readonly?: boolean;
+  accessibility?: TSAccessibility$1 | null;
+  parent?: Node$1$1;
+}
+declare type PropertyDefinitionType$1 = "PropertyDefinition" | "TSAbstractPropertyDefinition";
+declare type PropertyKey_2$1 = IdentifierName$1$1 | PrivateIdentifier$1$1 | Expression$1$1;
+declare type PropertyKind$1 = "init" | "get" | "set";
+declare interface RegExpLiteral$1$1 extends Span$1$1 {
+  type: "Literal";
+  value: RegExp | null;
+  raw: string | null;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  parent?: Node$1$1;
+}
+declare interface ReturnStatement$1$1 extends Span$1$1 {
+  type: "ReturnStatement";
+  argument: Expression$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface SequenceExpression$1$1 extends Span$1$1 {
+  type: "SequenceExpression";
+  expressions: Array<Expression$1$1>;
+  parent?: Node$1$1;
+}
+declare type SimpleAssignmentTarget$1$1 = IdentifierReference$1$1 | TSAsExpression$1$1 | TSSatisfiesExpression$1$1 | TSNonNullExpression$1$1 | TSTypeAssertion$1$1 | MemberExpression$1$1;
+declare type Simplify$1<T> = { [K in keyof T]: T[K]; } & {};
+declare interface Span$1$1 {
+  start: number;
+  end: number;
+  range?: [number, number];
+}
+declare interface SpreadElement$1$1 extends Span$1$1 {
+  type: "SpreadElement";
+  argument: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare type Statement$1$1 = BlockStatement$1$1 | BreakStatement$1$1 | ContinueStatement$1$1 | DebuggerStatement$1 | DoWhileStatement$1$1 | EmptyStatement$1$1 | ExpressionStatement$1$1 | ForInStatement$1$1 | ForOfStatement$1$1 | ForStatement$1$1 | IfStatement$1$1 | LabeledStatement$1$1 | ReturnStatement$1$1 | SwitchStatement$1$1 | ThrowStatement$1$1 | TryStatement$1$1 | WhileStatement$1$1 | WithStatement$1$1 | Declaration$1 | ModuleDeclaration$1;
+declare type Statement = Simplify$1<Built$1<Statement$1$1>> | Statement$1$1;
+declare interface StaticBlock$1$1 extends Span$1$1 {
+  type: "StaticBlock";
+  body: Array<Statement$1$1>;
+  parent?: Node$1$1;
+}
+declare interface StaticMemberExpression$1$1 extends Span$1$1 {
+  type: "MemberExpression";
+  object: Expression$1$1;
+  property: IdentifierName$1$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1$1;
+}
+declare interface StringLiteral$1$1 extends Span$1$1 {
+  type: "Literal";
+  value: string;
+  raw: string | null;
+  parent?: Node$1$1;
+}
+declare interface Super$1$1 extends Span$1$1 {
+  type: "Super";
+  parent?: Node$1$1;
+}
+declare interface SwitchCase$1$1 extends Span$1$1 {
+  type: "SwitchCase";
+  test: Expression$1$1 | null;
+  consequent: Array<Statement$1$1>;
+  parent?: Node$1$1;
+}
+declare interface SwitchStatement$1$1 extends Span$1$1 {
+  type: "SwitchStatement";
+  discriminant: Expression$1$1;
+  cases: Array<SwitchCase$1$1>;
+  parent?: Node$1$1;
+}
+declare interface TaggedTemplateExpression$1$1 extends Span$1$1 {
+  type: "TaggedTemplateExpression";
+  tag: Expression$1$1;
+  typeArguments?: TSTypeParameterInstantiation$1$1 | null;
+  quasi: TemplateLiteral$1$1;
+  parent?: Node$1$1;
+}
+declare interface TemplateElement$1$1 extends Span$1$1 {
+  type: "TemplateElement";
+  value: TemplateElementValue$1;
+  tail: boolean;
+  parent?: Node$1$1;
+}
+declare interface TemplateElementValue$1 {
+  raw: string;
+  cooked: string | null;
+}
+declare interface TemplateLiteral$1$1 extends Span$1$1 {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement$1$1>;
+  expressions: Array<Expression$1$1>;
+  parent?: Node$1$1;
+}
+declare interface ThisExpression$1$1 extends Span$1$1 {
+  type: "ThisExpression";
+  parent?: Node$1$1;
+}
+declare interface ThrowStatement$1$1 extends Span$1$1 {
+  type: "ThrowStatement";
+  argument: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface TryStatement$1$1 extends Span$1$1 {
+  type: "TryStatement";
+  block: BlockStatement$1$1;
+  handler: CatchClause$1$1 | null;
+  finalizer: BlockStatement$1$1 | null;
+  parent?: Node$1$1;
+}
+declare type TSAccessibility$1 = "private" | "protected" | "public";
+declare interface TSAnyKeyword$1 extends Span$1$1 {
+  type: "TSAnyKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSArrayType$1$1 extends Span$1$1 {
+  type: "TSArrayType";
+  elementType: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSAsExpression$1$1 extends Span$1$1 {
+  type: "TSAsExpression";
+  expression: Expression$1$1;
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSBigIntKeyword$1 extends Span$1$1 {
+  type: "TSBigIntKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSBooleanKeyword$1 extends Span$1$1 {
+  type: "TSBooleanKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSCallSignatureDeclaration$1$1 extends Span$1$1 {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSClassImplements$1 extends Span$1$1 {
+  type: "TSClassImplements";
+  expression: IdentifierReference$1$1 | ThisExpression$1$1 | MemberExpression$1$1;
+  typeArguments: TSTypeParameterInstantiation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSConditionalType$1$1 extends Span$1$1 {
+  type: "TSConditionalType";
+  checkType: TSType$1$1;
+  extendsType: TSType$1$1;
+  trueType: TSType$1$1;
+  falseType: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSConstructorType$1$1 extends Span$1$1 {
+  type: "TSConstructorType";
+  abstract: boolean;
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType: TSTypeAnnotation$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSConstructSignatureDeclaration$1$1 extends Span$1$1 {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSEnumBody$1 extends Span$1$1 {
+  type: "TSEnumBody";
+  members: Array<TSEnumMember$1>;
+  parent?: Node$1$1;
+}
+declare interface TSEnumDeclaration$1$1 extends Span$1$1 {
+  type: "TSEnumDeclaration";
+  id: BindingIdentifier$1$1;
+  body: TSEnumBody$1;
+  const: boolean;
+  declare: boolean;
+  parent?: Node$1$1;
+}
+declare interface TSEnumMember$1 extends Span$1$1 {
+  type: "TSEnumMember";
+  id: TSEnumMemberName$1;
+  initializer: Expression$1$1 | null;
+  computed: boolean;
+  parent?: Node$1$1;
+}
+declare type TSEnumMemberName$1 = IdentifierName$1$1 | StringLiteral$1$1 | TemplateLiteral$1$1;
+declare interface TSExportAssignment$1$1 extends Span$1$1 {
+  type: "TSExportAssignment";
+  expression: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSExternalModuleReference$1 extends Span$1$1 {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSFunctionType$1$1 extends Span$1$1 {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType: TSTypeAnnotation$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSGlobalDeclaration$1 extends Span$1$1 {
+  type: "TSModuleDeclaration";
+  id: IdentifierName$1$1;
+  body: TSModuleBlock$1$1;
+  kind: "global";
+  declare: boolean;
+  global: true;
+  parent?: Node$1$1;
+}
+declare interface TSImportEqualsDeclaration$1$1 extends Span$1$1 {
+  type: "TSImportEqualsDeclaration";
+  id: BindingIdentifier$1$1;
+  moduleReference: TSModuleReference$1;
+  importKind: ImportOrExportKind$1;
+  parent?: Node$1$1;
+}
+declare interface TSImportType$1$1 extends Span$1$1 {
+  type: "TSImportType";
+  source: StringLiteral$1$1;
+  options: ObjectExpression$1$1 | null;
+  qualifier: TSImportTypeQualifier$1 | null;
+  typeArguments: TSTypeParameterInstantiation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSImportTypeQualifiedName$1 extends Span$1$1 {
+  type: "TSQualifiedName";
+  left: TSImportTypeQualifier$1;
+  right: IdentifierName$1$1;
+  parent?: Node$1$1;
+}
+declare type TSImportTypeQualifier$1 = IdentifierName$1$1 | TSImportTypeQualifiedName$1;
+declare interface TSIndexedAccessType$1$1 extends Span$1$1 {
+  type: "TSIndexedAccessType";
+  objectType: TSType$1$1;
+  indexType: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSIndexSignature$1$1 extends Span$1$1 {
+  type: "TSIndexSignature";
+  parameters: Array<TSIndexSignatureName$1>;
+  typeAnnotation: TSTypeAnnotation$1$1;
+  readonly: boolean;
+  static: boolean;
+  accessibility: null;
+  parent?: Node$1$1;
+}
+declare interface TSIndexSignatureName$1 extends Span$1$1 {
+  type: "Identifier";
+  decorators: [];
+  name: string;
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSInferType$1$1 extends Span$1$1 {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter$1;
+  parent?: Node$1$1;
+}
+declare interface TSInstantiationExpression$1$1 extends Span$1$1 {
+  type: "TSInstantiationExpression";
+  expression: Expression$1$1;
+  typeArguments: TSTypeParameterInstantiation$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSInterfaceBody$1$1 extends Span$1$1 {
+  type: "TSInterfaceBody";
+  body: Array<TSSignature$1>;
+  parent?: Node$1$1;
+}
+declare interface TSInterfaceDeclaration$1$1 extends Span$1$1 {
+  type: "TSInterfaceDeclaration";
+  id: BindingIdentifier$1$1;
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  extends: Array<TSInterfaceHeritage$1>;
+  body: TSInterfaceBody$1$1;
+  declare: boolean;
+  parent?: Node$1$1;
+}
+declare interface TSInterfaceHeritage$1 extends Span$1$1 {
+  type: "TSInterfaceHeritage";
+  expression: Expression$1$1;
+  typeArguments: TSTypeParameterInstantiation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSIntersectionType$1$1 extends Span$1$1 {
+  type: "TSIntersectionType";
+  types: Array<TSType$1$1>;
+  parent?: Node$1$1;
+}
+declare interface TSIntrinsicKeyword$1 extends Span$1$1 {
+  type: "TSIntrinsicKeyword";
+  parent?: Node$1$1;
+}
+declare type TSLiteral$1 = BooleanLiteral$1$1 | NumericLiteral$1$1 | BigIntLiteral$1$1 | StringLiteral$1$1 | TemplateLiteral$1$1 | UnaryExpression$1$1;
+declare interface TSLiteralType$1$1 extends Span$1$1 {
+  type: "TSLiteralType";
+  literal: TSLiteral$1;
+  parent?: Node$1$1;
+}
+declare interface TSMappedType$1$1 extends Span$1$1 {
+  type: "TSMappedType";
+  key: BindingIdentifier$1$1;
+  constraint: TSType$1$1;
+  nameType: TSType$1$1 | null;
+  typeAnnotation: TSType$1$1 | null;
+  optional: TSMappedTypeModifierOperator$1 | false;
+  readonly: TSMappedTypeModifierOperator$1 | null;
+  parent?: Node$1$1;
+}
+declare type TSMappedTypeModifierOperator$1 = true | "+" | "-";
+declare interface TSMethodSignature$1$1 extends Span$1$1 {
+  type: "TSMethodSignature";
+  key: PropertyKey_2$1;
+  computed: boolean;
+  optional: boolean;
+  kind: TSMethodSignatureKind$1;
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  params: ParamPattern$1$1[];
+  returnType: TSTypeAnnotation$1$1 | null;
+  accessibility: null;
+  readonly: false;
+  static: false;
+  parent?: Node$1$1;
+}
+declare type TSMethodSignatureKind$1 = "method" | "get" | "set";
+declare interface TSModuleBlock$1$1 extends Span$1$1 {
+  type: "TSModuleBlock";
+  body: Array<Directive$1 | Statement$1$1>;
+  parent?: Node$1$1;
+}
+declare interface TSModuleDeclaration$1$1 extends Span$1$1 {
+  type: "TSModuleDeclaration";
+  id: BindingIdentifier$1$1 | StringLiteral$1$1 | TSQualifiedName$1$1;
+  body: TSModuleBlock$1$1 | null;
+  kind: TSModuleDeclarationKind$1;
+  declare: boolean;
+  global: false;
+  parent?: Node$1$1;
+}
+declare type TSModuleDeclarationKind$1 = "module" | "namespace";
+declare type TSModuleReference$1 = TSExternalModuleReference$1 | IdentifierReference$1$1 | TSQualifiedName$1$1;
+declare interface TSNamedTupleMember$1$1 extends Span$1$1 {
+  type: "TSNamedTupleMember";
+  label: IdentifierName$1$1;
+  elementType: TSTupleElement$1;
+  optional: boolean;
+  parent?: Node$1$1;
+}
+declare interface TSNamespaceExportDeclaration$1$1 extends Span$1$1 {
+  type: "TSNamespaceExportDeclaration";
+  id: IdentifierName$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSNeverKeyword$1 extends Span$1$1 {
+  type: "TSNeverKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSNonNullExpression$1$1 extends Span$1$1 {
+  type: "TSNonNullExpression";
+  expression: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSNullKeyword$1 extends Span$1$1 {
+  type: "TSNullKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSNumberKeyword$1 extends Span$1$1 {
+  type: "TSNumberKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSObjectKeyword$1 extends Span$1$1 {
+  type: "TSObjectKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSOptionalType$1$1 extends Span$1$1 {
+  type: "TSOptionalType";
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSParameterProperty$1 extends Span$1$1 {
+  type: "TSParameterProperty";
+  accessibility: TSAccessibility$1 | null;
+  decorators: Array<Decorator$1$1>;
+  override: boolean;
+  parameter: FormalParameter$1;
+  readonly: boolean;
+  static: boolean;
+  parent?: Node$1$1;
+}
+declare interface TSParenthesizedType$1$1 extends Span$1$1 {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSPropertySignature$1$1 extends Span$1$1 {
+  type: "TSPropertySignature";
+  computed: boolean;
+  optional: boolean;
+  readonly: boolean;
+  key: PropertyKey_2$1;
+  typeAnnotation: TSTypeAnnotation$1$1 | null;
+  accessibility: null;
+  static: false;
+  parent?: Node$1$1;
+}
+declare interface TSQualifiedName$1$1 extends Span$1$1 {
+  type: "TSQualifiedName";
+  left: TSTypeName$1;
+  right: IdentifierName$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSRestType$1$1 extends Span$1$1 {
+  type: "TSRestType";
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSSatisfiesExpression$1$1 extends Span$1$1 {
+  type: "TSSatisfiesExpression";
+  expression: Expression$1$1;
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare type TSSignature$1 = TSIndexSignature$1$1 | TSPropertySignature$1$1 | TSCallSignatureDeclaration$1$1 | TSConstructSignatureDeclaration$1$1 | TSMethodSignature$1$1;
+declare interface TSStringKeyword$1 extends Span$1$1 {
+  type: "TSStringKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSSymbolKeyword$1 extends Span$1$1 {
+  type: "TSSymbolKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSTemplateLiteralType$1$1 extends Span$1$1 {
+  type: "TSTemplateLiteralType";
+  quasis: Array<TemplateElement$1$1>;
+  types: Array<TSType$1$1>;
+  parent?: Node$1$1;
+}
+declare interface TSThisParameter$1 extends Span$1$1 {
+  type: "Identifier";
+  decorators: [];
+  name: "this";
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSThisType$1 extends Span$1$1 {
+  type: "TSThisType";
+  parent?: Node$1$1;
+}
+declare type TSTupleElement$1 = TSOptionalType$1$1 | TSRestType$1$1 | TSType$1$1;
+declare interface TSTupleType$1$1 extends Span$1$1 {
+  type: "TSTupleType";
+  elementTypes: Array<TSTupleElement$1>;
+  parent?: Node$1$1;
+}
+declare type TSType$1$1 = TSAnyKeyword$1 | TSBigIntKeyword$1 | TSBooleanKeyword$1 | TSIntrinsicKeyword$1 | TSNeverKeyword$1 | TSNullKeyword$1 | TSNumberKeyword$1 | TSObjectKeyword$1 | TSStringKeyword$1 | TSSymbolKeyword$1 | TSUndefinedKeyword$1 | TSUnknownKeyword$1 | TSVoidKeyword$1 | TSArrayType$1$1 | TSConditionalType$1$1 | TSConstructorType$1$1 | TSFunctionType$1$1 | TSImportType$1$1 | TSIndexedAccessType$1$1 | TSInferType$1$1 | TSIntersectionType$1$1 | TSLiteralType$1$1 | TSMappedType$1$1 | TSNamedTupleMember$1$1 | TSTemplateLiteralType$1$1 | TSThisType$1 | TSTupleType$1$1 | TSTypeLiteral$1 | TSTypeOperator$1$1 | TSTypePredicate$1$1 | TSTypeQuery$1$1 | TSTypeReference$1$1 | TSUnionType$1$1 | TSParenthesizedType$1$1 | JSDocNullableType$1$1 | JSDocNonNullableType$1$1 | JSDocUnknownType$1;
+declare interface TSTypeAliasDeclaration$1$1 extends Span$1$1 {
+  type: "TSTypeAliasDeclaration";
+  id: BindingIdentifier$1$1;
+  typeParameters: TSTypeParameterDeclaration$1$1 | null;
+  typeAnnotation: TSType$1$1;
+  declare: boolean;
+  parent?: Node$1$1;
+}
+declare interface TSTypeAnnotation$1$1 extends Span$1$1 {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSTypeAssertion$1$1 extends Span$1$1 {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType$1$1;
+  expression: Expression$1$1;
+  parent?: Node$1$1;
+}
+declare interface TSTypeLiteral$1 extends Span$1$1 {
+  type: "TSTypeLiteral";
+  members: Array<TSSignature$1>;
+  parent?: Node$1$1;
+}
+declare type TSTypeName$1 = IdentifierReference$1$1 | TSQualifiedName$1$1 | ThisExpression$1$1;
+declare interface TSTypeOperator$1$1 extends Span$1$1 {
+  type: "TSTypeOperator";
+  operator: TSTypeOperatorOperator$1;
+  typeAnnotation: TSType$1$1;
+  parent?: Node$1$1;
+}
+declare type TSTypeOperatorOperator$1 = "keyof" | "unique" | "readonly";
+declare interface TSTypeParameter$1 extends Span$1$1 {
+  type: "TSTypeParameter";
+  name: BindingIdentifier$1$1;
+  constraint: TSType$1$1 | null;
+  default: TSType$1$1 | null;
+  in: boolean;
+  out: boolean;
+  const: boolean;
+  parent?: Node$1$1;
+}
+declare interface TSTypeParameterDeclaration$1$1 extends Span$1$1 {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter$1>;
+  parent?: Node$1$1;
+}
+declare interface TSTypeParameterInstantiation$1$1 extends Span$1$1 {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType$1$1>;
+  parent?: Node$1$1;
+}
+declare interface TSTypePredicate$1$1 extends Span$1$1 {
+  type: "TSTypePredicate";
+  parameterName: TSTypePredicateName$1;
+  asserts: boolean;
+  typeAnnotation: TSTypeAnnotation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare type TSTypePredicateName$1 = IdentifierName$1$1 | TSThisType$1;
+declare interface TSTypeQuery$1$1 extends Span$1$1 {
+  type: "TSTypeQuery";
+  exprName: TSTypeQueryExprName$1;
+  typeArguments: TSTypeParameterInstantiation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare type TSTypeQueryExprName$1 = TSImportType$1$1 | TSTypeName$1;
+declare interface TSTypeReference$1$1 extends Span$1$1 {
+  type: "TSTypeReference";
+  typeName: TSTypeName$1;
+  typeArguments: TSTypeParameterInstantiation$1$1 | null;
+  parent?: Node$1$1;
+}
+declare interface TSUndefinedKeyword$1 extends Span$1$1 {
+  type: "TSUndefinedKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSUnionType$1$1 extends Span$1$1 {
+  type: "TSUnionType";
+  types: Array<TSType$1$1>;
+  parent?: Node$1$1;
+}
+declare interface TSUnknownKeyword$1 extends Span$1$1 {
+  type: "TSUnknownKeyword";
+  parent?: Node$1$1;
+}
+declare interface TSVoidKeyword$1 extends Span$1$1 {
+  type: "TSVoidKeyword";
+  parent?: Node$1$1;
+}
+declare interface UnaryExpression$1$1 extends Span$1$1 {
+  type: "UnaryExpression";
+  operator: UnaryOperator$1;
+  argument: Expression$1$1;
+  prefix: true;
+  parent?: Node$1$1;
+}
+declare type UnaryOperator$1 = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
+declare interface UpdateExpression$1$1 extends Span$1$1 {
+  type: "UpdateExpression";
+  operator: UpdateOperator$1;
+  prefix: boolean;
+  argument: SimpleAssignmentTarget$1$1;
+  parent?: Node$1$1;
+}
+declare type UpdateOperator$1 = "++" | "--";
+declare interface V8IntrinsicExpression$1 extends Span$1$1 {
+  type: "V8IntrinsicExpression";
+  name: IdentifierName$1$1;
+  arguments: Array<Argument$1$1>;
+  parent?: Node$1$1;
+}
+declare interface VariableDeclaration$1$1 extends Span$1$1 {
+  type: "VariableDeclaration";
+  kind: VariableDeclarationKind$1;
+  declarations: Array<VariableDeclarator$1$1>;
+  declare?: boolean;
+  parent?: Node$1$1;
+}
+declare type VariableDeclarationKind$1 = "var" | "let" | "const" | "using" | "await using";
+declare interface VariableDeclarator$1$1 extends Span$1$1 {
+  type: "VariableDeclarator";
+  id: BindingPattern$1$1;
+  init: Expression$1$1 | null;
+  definite?: boolean;
+  parent?: Node$1$1;
+}
+declare interface WhileStatement$1$1 extends Span$1$1 {
+  type: "WhileStatement";
+  test: Expression$1$1;
+  body: Statement$1$1;
+  parent?: Node$1$1;
+}
+declare interface WithStatement$1$1 extends Span$1$1 {
+  type: "WithStatement";
+  object: Expression$1$1;
+  body: Statement$1$1;
+  parent?: Node$1$1;
+}
+declare interface YieldExpression$1$1 extends Span$1$1 {
+  type: "YieldExpression";
+  delegate: boolean;
+  argument: Expression$1$1 | null;
+  parent?: Node$1$1;
+}
+//#endregion
+//#region ../frameworks/interface/dist/index.d.ts
+declare interface EmbeddedDocument {
+  readonly formatId: FormatId;
+  readonly rawContent: string;
+  readonly regions: readonly ScriptRegion[];
+}
+declare type FormatId = string;
+declare interface Framework {
+  readonly kind: 'Framework';
+  readonly name: string;
+  readonly claim: FrameworkClaim;
+  readonly parse: (rawContent: string, context: FrameworkContext) => FrameworkParseResult<EmbeddedDocument>;
+  readonly transform: (document: EmbeddedDocument, context: FrameworkContext) => EmbeddedDocument;
+  readonly print: (document: EmbeddedDocument, context: FrameworkContext) => string;
+  readonly disableTypeChecks: (rawContent: string) => FrameworkParseResult<string>;
+}
+declare interface FrameworkClaim {
+  readonly formatId: FormatId;
+  readonly extensions: readonly string[];
+  readonly language: string;
+  readonly ownerVersion: string;
+  readonly contractVersion: FrameworkContractVersion;
+}
+declare interface FrameworkContext {
+  readonly parseScript: (source: string, scriptFormat: ScriptFormat$1) => Program$2;
+  readonly printScript: (script: Program$2) => string;
+  readonly instrumentationHeader: () => readonly Statement[];
+}
+declare type FrameworkContractVersion = '1';
+declare type FrameworkParseResult<A> = {
+  readonly kind: 'Parsed';
+  readonly value: A;
+} | {
+  readonly kind: 'ParseFailed';
+  readonly message: string;
+};
+declare type ScriptFormat$1 = 'js' | 'ts' | 'tsx';
+declare interface ScriptRegion {
+  readonly start: number;
+  readonly end: number;
+  readonly isExpression: boolean;
+  readonly scriptAst: Program$2;
+}
+//#endregion
+//#region ../stryker-js-instrumenter/dist/index.d.mts
+//#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$1: 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$1.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$1.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$1.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$1.Effect<Ast, ParseFailed | InstrumentError>;
+  readonly transform: AstTransformer;
+  readonly print: (ast: Ast, context: PrinterContext) => string;
+  readonly disableTypeChecks: (ast: Ast) => Effect$1.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$1.Option<FormatEntry>;
+interface FormatRegistry {
+  readonly entries: readonly FormatEntry[];
+  readonly entryForFormat: EntryForFormat;
+  readonly entryForExtension: (extension: string) => Option$1.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$1.Effect<InstrumentResult$1, InstrumentError>;
+  (options: InstrumenterOptions, registry?: FormatRegistry): (files: readonly File[]) => Effect$1.Effect<InstrumentResult$1, InstrumentError>;
+};
+declare const disableTypeChecks: {
+  (file: File, registry?: FormatRegistry): Effect$1.Effect<File, InstrumentError>;
+  (registry?: FormatRegistry): (file: File) => Effect$1.Effect<File, InstrumentError>;
+};
+declare namespace mod_d_exports$2$1 {
+  export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterOptions, MutateDescription, MutationRange, ParserOptions, disableTypeChecks, instrument };
+}
+declare namespace mod_d_exports$3$1 {
+  export { CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, InstrumenterContext, Location, LocationSchema, Mutant$1 as Mutant, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema$1 as 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
+//#region ../stryker-js-plugin-interface/dist/index.d.mts
+//#region src/Checker.schema.d.ts
+declare const CheckerMutantWire: S.Struct<{
+  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;
+    }>;
+  }>;
+}>;
+type CheckerMutantWire = typeof CheckerMutantWire.Type;
+declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
+type CheckStatus = typeof CheckStatus.Type;
+declare const CheckResultSchema: S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"passed">;
+}>, S.Struct<{
+  readonly status: S.Literal<"compileError">;
+  readonly reason: S.String;
+}>]>;
+declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
+  readonly cause: S.String;
+  readonly checkerName: S.String;
+  readonly mutantIds: S.$Array<S.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class CheckerFailed extends CheckerFailed_base {}
+interface FailedCheckResult {
+  readonly reason: string;
+  readonly status: 'compileError';
+}
+interface PassedCheckResult {
+  readonly status: 'passed';
+}
+type CheckResult = FailedCheckResult | PassedCheckResult;
+//#endregion
+//#region src/Checker.service.d.ts
+interface CheckerService {
+  readonly init: Effect$1.Effect<void, CheckerFailed>;
+  readonly check: (mutants: readonly CheckerMutantWire[]) => Effect$1.Effect<HashMap.HashMap<string, CheckResult>, CheckerFailed>;
+  readonly group: (mutants: readonly CheckerMutantWire[]) => Effect$1.Effect<readonly (readonly string[])[], CheckerFailed>;
+}
+declare const Checker_base: Context.ServiceClass<Checker, "@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker", CheckerService>;
+declare class Checker extends Checker_base {}
+declare namespace mod_d_exports {
+  export { CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerMutantWire, CheckerService, FailedCheckResult, PassedCheckResult };
+}
+declare const MutantResultSchema: S.Struct<{
+  readonly id: S.String;
+  readonly mutatorName: S.String;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  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 replacement: S.optional<S.String>;
+  readonly description: S.optional<S.String>;
+  readonly statusReason: S.optional<S.String>;
+  readonly static: S.optional<S.Boolean>;
+  readonly coveredBy: S.optional<S.$Array<S.String>>;
+  readonly killedBy: S.optional<S.$Array<S.String>>;
+  readonly testsCompleted: S.optional<S.Int>;
+  readonly duration: S.optional<S.Finite>;
+}>;
+type MutantResult = typeof MutantResultSchema.Type;
+declare const FileResultSchema: S.Struct<{
+  readonly language: S.String;
+  readonly source: S.String;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly mutatorName: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    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 replacement: S.optional<S.String>;
+    readonly description: S.optional<S.String>;
+    readonly statusReason: S.optional<S.String>;
+    readonly static: S.optional<S.Boolean>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly killedBy: S.optional<S.$Array<S.String>>;
+    readonly testsCompleted: S.optional<S.Int>;
+    readonly duration: S.optional<S.Finite>;
+  }>>;
+}>;
+type FileResult = typeof FileResultSchema.Type;
+declare const FileResultDictionarySchema: S.$Record<S.String, S.Struct<{
+  readonly language: S.String;
+  readonly source: S.String;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly mutatorName: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    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 replacement: S.optional<S.String>;
+    readonly description: S.optional<S.String>;
+    readonly statusReason: S.optional<S.String>;
+    readonly static: S.optional<S.Boolean>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly killedBy: S.optional<S.$Array<S.String>>;
+    readonly testsCompleted: S.optional<S.Int>;
+    readonly duration: S.optional<S.Finite>;
+  }>>;
+}>>;
+type FileResultDictionary = typeof FileResultDictionarySchema.Type;
+declare const TestDefinitionSchema: S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly location: S.optional<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 TestDefinition = typeof TestDefinitionSchema.Type;
+declare const TestFileSchema: S.Struct<{
+  readonly source: S.optional<S.String>;
+  readonly tests: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly location: S.optional<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 TestFile = typeof TestFileSchema.Type;
+declare const TestFileDefinitionDictionarySchema: S.$Record<S.String, S.Struct<{
+  readonly source: S.optional<S.String>;
+  readonly tests: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly location: S.optional<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 TestFileDefinitionDictionary = typeof TestFileDefinitionDictionarySchema.Type;
+declare const ThresholdsSchema: S.decodeTo<S.declare<{
+  readonly high: number;
+  readonly low: number;
+}, {
+  readonly high: number;
+  readonly low: number;
+}>, S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+}>, never, never>;
+type Thresholds = typeof ThresholdsSchema.Type;
+declare const BrandingInformationSchema: S.Struct<{
+  readonly homepageUrl: S.String;
+  readonly imageUrl: S.optional<S.String>;
+}>;
+type BrandingInformation = typeof BrandingInformationSchema.Type;
+declare const DependenciesSchema: S.$Record<S.String, S.String>;
+type Dependencies = typeof DependenciesSchema.Type;
+declare const FrameworkInformationSchema: S.Struct<{
+  readonly name: S.String;
+  readonly version: S.optional<S.String>;
+  readonly branding: S.optional<S.Struct<{
+    readonly homepageUrl: S.String;
+    readonly imageUrl: S.optional<S.String>;
+  }>>;
+  readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+}>;
+type FrameworkInformation = typeof FrameworkInformationSchema.Type;
+declare const MutationTestResultSchema: S.Struct<{
+  readonly schemaVersion: S.String;
+  readonly files: S.$Record<S.String, S.Struct<{
+    readonly language: S.String;
+    readonly source: S.String;
+    readonly mutants: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly mutatorName: S.String;
+      readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      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 replacement: S.optional<S.String>;
+      readonly description: S.optional<S.String>;
+      readonly statusReason: S.optional<S.String>;
+      readonly static: S.optional<S.Boolean>;
+      readonly coveredBy: S.optional<S.$Array<S.String>>;
+      readonly killedBy: S.optional<S.$Array<S.String>>;
+      readonly testsCompleted: S.optional<S.Int>;
+      readonly duration: S.optional<S.Finite>;
+    }>>;
+  }>>;
+  readonly thresholds: S.decodeTo<S.declare<{
+    readonly high: number;
+    readonly low: number;
+  }, {
+    readonly high: number;
+    readonly low: number;
+  }>, S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+  }>, never, never>;
+  readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
+  readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+    readonly source: S.optional<S.String>;
+    readonly tests: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly name: S.String;
+      readonly location: S.optional<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;
+        }>>;
+      }>>;
+    }>>;
+  }>>>;
+  readonly projectRoot: S.optional<S.String>;
+  readonly framework: S.optional<S.Struct<{
+    readonly name: S.String;
+    readonly version: S.optional<S.String>;
+    readonly branding: S.optional<S.Struct<{
+      readonly homepageUrl: S.String;
+      readonly imageUrl: S.optional<S.String>;
+    }>>;
+    readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+  }>>;
+}>;
+type MutationTestResult = typeof MutationTestResultSchema.Type;
+//#endregion
+//#region src/ExitClass.schema.d.ts
+declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
+type ExitClass = typeof ExitClass.Type;
+declare const ExitCodeFromClass: S.decodeTo<S.Literals<readonly [1, 2, 3, 4]>, S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>, never, never>;
+//#endregion
+//#region src/stryker-options.schema.d.ts
+declare const StrykerCoverageAnalysis: S.Literal<"perTest">;
+declare const StrykerFileLogLevel: S.Literal<"off">;
+declare const StrykerLogLevel: S.Literal<"info">;
+declare const StrykerTempDirName: S.Literal<".stryker-tmp">;
+declare const LogLevel: S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>;
+declare const CoverageAnalysisMode: S.Literals<readonly ["off", "all", "perTest"]>;
+declare const ReportType: S.Literals<readonly ["full", "mutationScore"]>;
+declare const PackageManager: S.Literals<readonly ["npm", "yarn", "pnpm"]>;
+/** The generated module exported these as TypeScript types; consumers still name them that way. */
+type LogLevel = typeof LogLevel.Type;
+type CoverageAnalysisMode = typeof CoverageAnalysisMode.Type;
+type ReportType = typeof ReportType.Type;
+type PackageManager = typeof PackageManager.Type;
+declare const CommandRunnerOptionsSchema: S.StructWithRest<S.Struct<{
+  readonly command: S.withDecodingDefaultKey<S.String, never>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+type CommandRunnerOptions = S.Schema.Type<typeof CommandRunnerOptionsSchema>;
+declare const MutationScoreThresholdsSchema: S.decodeTo<S.declare<{
+  readonly high: number;
+  readonly low: number;
+  readonly break: number | null;
+}, {
+  readonly high: number;
+  readonly low: number;
+  readonly break: number | null;
+}>, S.Struct<{
+  readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+}>, never, never>;
+type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
+declare const PluginFileUrl: S.declare<string, string>;
+declare const TestRunnerCustomConfigSchema: S.Struct<{
+  readonly plugin: S.declare<string, string>;
+  readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+  readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+}>;
+type TestRunnerCustomConfig = typeof TestRunnerCustomConfigSchema.Type;
+declare const TestRunnerConfigSchema: S.Union<readonly [S.String, S.Struct<{
+  readonly plugin: S.declare<string, string>;
+  readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+  readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+}>]>;
+type TestRunnerConfig = typeof TestRunnerConfigSchema.Type;
+declare const isCustomTestRunner: <I>(input: I) => input is I & {
+  readonly plugin: string;
+  readonly nodeArgs?: readonly string[] | undefined;
+  readonly options?: {
+    readonly [x: string]: unknown;
+  } | undefined;
+};
+declare const CheckerCustomConfigSchema: S.Struct<{
+  readonly plugin: S.declare<string, string>;
+  readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+  readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+}>;
+type CheckerCustomConfig = typeof CheckerCustomConfigSchema.Type;
+declare const CheckerEntryConfigSchema: S.Struct<{
+  readonly plugin: S.declare<string, string>;
+  readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+  readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+}>;
+type CheckerEntryConfig = typeof CheckerEntryConfigSchema.Type;
+declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
+  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly buildCommand: S.optionalKey<S.String>;
+  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+    readonly plugin: S.declare<string, string>;
+    readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+    readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+  }>>, never>;
+  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly concurrency: S.optionalKey<S.Union<readonly [S.Finite, S.String]>>;
+  readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+    readonly command: S.withDecodingDefaultKey<S.String, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+  readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
+  readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+    readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+  readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+  readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly mutator: S.withDecodingDefaultKey<S.Struct<{
+    readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  }>, never>;
+  readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+  readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
+  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
+  readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
+  readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
+  readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
+  readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
+  readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
+  readonly testRunner: S.withDecodingDefaultKey<S.Union<readonly [S.String, S.Struct<{
+    readonly plugin: S.declare<string, string>;
+    readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+    readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+  }>]>, never>;
+  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  }, {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  }>, S.Struct<{
+    readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+  }>, never, never>, never>;
+  readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
+    readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
+  readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
+  readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+/** The decoded type: every defaulted option is present. */
+type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;
+/**
+ * The deep-partial input type: when configuring Stryker, every option is
+ * optional, including deep properties like `dashboard.project`.
+ */
+type PartialStrykerOptions = DeepOptional<StrykerOptions>;
+/**
+ * Every option optional, all the way down, and mutable: this is the type a
+ * caller CONSTRUCTS by assignment, so `readonly` is stripped. The decoded
+ * `StrykerOptions` keeps it - that side is read, never built.
+ */
+type DeepOptional<T, V = unknown> = { -readonly [P in keyof T]?: T[P] extends Record<string, V> ? DeepOptional<T[P], V> | undefined : T[P]; };
+declare namespace mod_d_exports$2 {
+  export { CheckerCustomConfig, CheckerCustomConfigSchema, CheckerEntryConfig, CheckerEntryConfigSchema, CommandRunnerOptions, CommandRunnerOptionsSchema, CoverageAnalysisMode, CoverageAnalysisMode as CoverageAnalysisModeType, DeepOptional, LogLevel, LogLevel as LogLevelType, MutationScoreThresholds, MutationScoreThresholdsSchema, PackageManager, PackageManager as PackageManagerType, PartialStrykerOptions, PluginFileUrl, ReportType, ReportType as ReportTypeType, StrykerCoverageAnalysis, StrykerFileLogLevel, StrykerLogLevel, StrykerOptions, StrykerOptionsSchema, StrykerTempDirName, TestRunnerConfig, TestRunnerConfigSchema, TestRunnerCustomConfig, TestRunnerCustomConfigSchema, isCustomTestRunner };
+}
+//#endregion
+//#region src/Metrics.schema.d.ts
+declare const DetectedStatus: S.Union<readonly [S.Literal<"Killed">, S.Literal<"Timeout">]>;
+declare const UndetectedStatus: S.Union<readonly [S.Literal<"Survived">, S.Literal<"NoCoverage">]>;
+declare const InvalidStatus: S.Union<readonly [S.Literal<"CompileError">, S.Literal<"RuntimeError">]>;
+declare const UntestedStatus: S.Union<readonly [S.Literal<"Ignored">, S.Literal<"Pending">]>;
+declare const NonNegativeInt: S.Int;
+declare const NonNegativeFinite: S.Finite;
+declare const Percentage: S.Finite;
+declare const Metrics_base: S.Class<Metrics, S.Struct<{
+  readonly pending: S.Int;
+  readonly killed: S.Int;
+  readonly timeout: S.Int;
+  readonly survived: S.Int;
+  readonly noCoverage: S.Int;
+  readonly runtimeErrors: S.Int;
+  readonly compileErrors: S.Int;
+  readonly ignored: S.Int;
+}>, {}>;
+declare class Metrics extends Metrics_base {
+  get totalDetected(): number;
+  get totalUndetected(): number;
+  get totalCovered(): number;
+  get totalValid(): number;
+  get totalInvalid(): number;
+  get totalMutants(): number;
+  get mutationScore(): number;
+  get mutationScoreBasedOnCoveredCode(): number;
+  static fromMutants(mutants: readonly {
+    readonly status: string;
+  }[]): Metrics;
+}
+declare const MetricsSchema: typeof Metrics;
+interface MetricsResult {
+  readonly name: string;
+  readonly metrics: Metrics;
+  readonly childResults: readonly MetricsResult[];
+}
+interface MetricsResultEncoded {
+  readonly name: string;
+  readonly metrics: typeof Metrics.Encoded;
+  readonly childResults: readonly MetricsResultEncoded[];
+}
+declare const MetricsResultSchema: S.Codec<MetricsResult, MetricsResultEncoded>;
+//#endregion
+//#region src/ReporterEvent.schema.d.ts
+declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+type ReporterEventKind = typeof ReporterEventKind.Type;
+declare const RunTimingSchema: S.Struct<{
+  readonly net: S.Finite;
+  readonly overhead: S.Finite;
+}>;
+type RunTiming = typeof RunTimingSchema.Type;
+declare const ReporterPlanKind: S.Literals<readonly ["EarlyResult", "Run"]>;
+declare const ReporterPlanDescriptorSchema: S.Struct<{
+  readonly mutantId: S.String;
+  readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
+  readonly netTime: S.Finite;
+  readonly reloadEnvironment: S.Boolean;
+}>;
+type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
+declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dryRunCompleted", {
+  readonly timing: S.Struct<{
+    readonly net: S.Finite;
+    readonly overhead: S.Finite;
+  }>;
+  readonly capabilities: S.Struct<{
+    readonly reloadEnvironment: S.Boolean;
+  }>;
+  readonly testCount: S.Int;
+  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"failed">;
+    readonly failureMessage: S.String;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"skipped">;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"success">;
+  }>]>>;
+}>, {}>;
+declare class DryRunCompleted extends DryRunCompleted_base {}
+declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
+  readonly total: S.Int;
+  readonly plans: S.$Array<S.Struct<{
+    readonly mutantId: S.String;
+    readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
+    readonly netTime: S.Finite;
+    readonly reloadEnvironment: S.Boolean;
+  }>>;
+}>, {}>;
+declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
+declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
+  readonly id: S.String;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly file: 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 mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Int;
+  readonly total: S.Int;
+}>, {}>;
+declare class MutantTested extends MutantTested_base {}
+declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.TaggedStruct<"mutationTestReportReady", {
+  readonly report: S.Struct<{
+    readonly schemaVersion: S.String;
+    readonly files: S.$Record<S.String, S.Struct<{
+      readonly language: S.String;
+      readonly source: S.String;
+      readonly mutants: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly mutatorName: S.String;
+        readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+        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 replacement: S.optional<S.String>;
+        readonly description: S.optional<S.String>;
+        readonly statusReason: S.optional<S.String>;
+        readonly static: S.optional<S.Boolean>;
+        readonly coveredBy: S.optional<S.$Array<S.String>>;
+        readonly killedBy: S.optional<S.$Array<S.String>>;
+        readonly testsCompleted: S.optional<S.Int>;
+        readonly duration: S.optional<S.Finite>;
+      }>>;
+    }>>;
+    readonly thresholds: S.decodeTo<S.declare<{
+      readonly high: number;
+      readonly low: number;
+    }, {
+      readonly high: number;
+      readonly low: number;
+    }>, S.Struct<{
+      readonly high: S.Finite;
+      readonly low: S.Finite;
+    }>, never, never>;
+    readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
+    readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+      readonly source: S.optional<S.String>;
+      readonly tests: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly name: S.String;
+        readonly location: S.optional<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;
+          }>>;
+        }>>;
+      }>>;
+    }>>>;
+    readonly projectRoot: S.optional<S.String>;
+    readonly framework: S.optional<S.Struct<{
+      readonly name: S.String;
+      readonly version: S.optional<S.String>;
+      readonly branding: S.optional<S.Struct<{
+        readonly homepageUrl: S.String;
+        readonly imageUrl: S.optional<S.String>;
+      }>>;
+      readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+    }>>;
+  }>;
+  readonly metrics: S.Codec<MetricsResult, MetricsResultEncoded, never, never>;
+}>, {}>;
+declare class MutationTestReportReady extends MutationTestReportReady_base {}
+declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
+type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
+declare const ReporterEventSchema: StandardSchemaV1<typeof ReporterEventUnion['Encoded'], ReporterEvent>;
+interface ReporterInit {
+  readonly traceparent?: string | undefined;
+  readonly tracestate?: string | undefined;
+}
+type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Effect$1.Effect<void, ReporterFailed>;
+declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
+  readonly cause: S.String;
+  readonly event: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+  readonly reporterName: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ReporterFailed extends ReporterFailed_base {}
+//#endregion
+//#region src/TestRunner.schema.d.ts
+declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
+type DryRunStatus = typeof DryRunStatus.Type;
+declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
+type TestStatus = typeof TestStatus.Type;
+declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
+type MutantRunStatus = typeof MutantRunStatus.Type;
+declare const TestResultSchema: S.Union<readonly [S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly timeSpentMs: S.Finite;
+  readonly fileName: S.optionalKey<S.String>;
+  readonly startPosition: S.optionalKey<S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>>;
+  readonly status: S.Literal<"failed">;
+  readonly failureMessage: S.String;
+}>, S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly timeSpentMs: S.Finite;
+  readonly fileName: S.optionalKey<S.String>;
+  readonly startPosition: S.optionalKey<S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>>;
+  readonly status: S.Literal<"skipped">;
+}>, S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly timeSpentMs: S.Finite;
+  readonly fileName: S.optionalKey<S.String>;
+  readonly startPosition: S.optionalKey<S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>>;
+  readonly status: S.Literal<"success">;
+}>]>;
+declare const MutantCoverageSchema: S.Struct<{
+  readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
+  readonly static: S.$Record<S.String, S.Finite>;
+}>;
+declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"complete">;
+  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"failed">;
+    readonly failureMessage: S.String;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"skipped">;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"success">;
+  }>]>>;
+  readonly mutantCoverage: S.optionalKey<S.Struct<{
+    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
+    readonly static: S.$Record<S.String, S.Finite>;
+  }>>;
+}>, S.Struct<{
+  readonly status: S.Literal<"timeout">;
+  readonly reason: S.optionalKey<S.String>;
+}>, S.Struct<{
+  readonly status: S.Literal<"error">;
+  readonly errorMessage: S.String;
+}>]>;
+declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"killed">;
+  readonly killedBy: S.$Array<S.String>;
+  readonly failureMessage: S.String;
+  readonly nrOfTests: S.Finite;
+}>, S.Struct<{
+  readonly status: S.Literal<"survived">;
+  readonly nrOfTests: S.Finite;
+}>, S.Struct<{
+  readonly status: S.Literal<"timeout">;
+  readonly reason: S.optionalKey<S.String>;
+}>, S.Struct<{
+  readonly status: S.Literal<"error">;
+  readonly errorMessage: S.String;
+}>]>;
+declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTest"]>;
+declare const DryRunOptionsSchema: S.Struct<{
+  readonly timeout: S.Finite;
+  readonly disableBail: S.Boolean;
+  readonly coverageAnalysis: S.Literals<readonly ["off", "all", "perTest"]>;
+  readonly files: S.optionalKey<S.$Array<S.String>>;
+  readonly testFiles: S.optionalKey<S.$Array<S.String>>;
+}>;
+declare const TestRunnerCapabilitiesSchema: S.Struct<{
+  readonly reloadEnvironment: S.Boolean;
+}>;
+declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"TestRunnerFailed", {
+  readonly cause: S.String;
+  readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
+  readonly runnerName: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class TestRunnerFailed extends TestRunnerFailed_base {}
+interface BaseTestResult {
+  readonly id: string;
+  readonly name: string;
+  readonly timeSpentMs: number;
+  readonly fileName?: string;
+  readonly startPosition?: mod_d_exports$3$1.Position;
+}
+interface FailedTestResult extends BaseTestResult {
+  readonly status: 'failed';
+  readonly failureMessage: string;
+}
+interface SkippedTestResult extends BaseTestResult {
+  readonly status: 'skipped';
+}
+interface SuccessTestResult extends BaseTestResult {
+  readonly status: 'success';
+}
+type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
+interface CompleteDryRunResult {
+  readonly tests: readonly TestResult[];
+  readonly mutantCoverage?: mod_d_exports$3$1.MutantCoverage;
+  readonly status: 'complete';
+}
+interface TimeoutDryRunResult {
+  readonly status: 'timeout';
+  readonly reason?: string;
+}
+interface ErrorDryRunResult {
+  readonly status: 'error';
+  readonly errorMessage: string;
+}
+type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
+interface TimeoutMutantRunResult {
+  readonly status: 'timeout';
+  readonly reason?: string;
+}
+interface KilledMutantRunResult {
+  readonly status: 'killed';
+  readonly killedBy: readonly string[];
+  readonly failureMessage: string;
+  readonly nrOfTests: number;
+}
+interface SurvivedMutantRunResult {
+  readonly status: 'survived';
+  readonly nrOfTests: number;
+}
+interface ErrorMutantRunResult {
+  readonly status: 'error';
+  readonly errorMessage: string;
+}
+type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
+type CoverageAnalysis = 'off' | 'all' | 'perTest';
+interface DryRunOptions extends mod_d_exports$3$1.RunOptions {
+  readonly coverageAnalysis: CoverageAnalysis;
+  readonly files?: readonly string[];
+  readonly testFiles?: readonly string[];
+}
+interface TestRunnerCapabilities {
+  readonly reloadEnvironment: boolean;
+}
+//#endregion
+//#region src/Plugin.schema.d.ts
+declare const WorkerPluginKind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
+type WorkerPluginKind = typeof WorkerPluginKind.Type;
+declare const TestRunnerDryRunRequest: S.Struct<{
+  readonly options: S.Struct<{
+    readonly timeout: S.Finite;
+    readonly disableBail: S.Boolean;
+    readonly coverageAnalysis: S.Literals<readonly ["off", "all", "perTest"]>;
+    readonly files: S.optionalKey<S.$Array<S.String>>;
+    readonly testFiles: S.optionalKey<S.$Array<S.String>>;
+  }>;
+}>;
+type TestRunnerDryRunRequest = typeof TestRunnerDryRunRequest.Type;
+declare const TestRunnerMutantRunRequest: S.Struct<{
+  readonly options: S.Struct<{
+    readonly timeout: S.Finite;
+    readonly disableBail: S.Boolean;
+    readonly activeMutant: typeof mod_d_exports$3$1.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.Int>;
+  }>;
+}>;
+type TestRunnerMutantRunRequest = typeof TestRunnerMutantRunRequest.Type;
+declare const CheckerRequest: S.Struct<{
+  readonly checkerName: S.String;
+  readonly mutants: S.$Array<S.Struct<{
+    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;
+      }>;
+    }>;
+  }>>;
+}>;
+type CheckerRequest = typeof CheckerRequest.Type;
+declare const CheckerCheckResult: S.$Record<S.String, S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"passed">;
+}>, S.Struct<{
+  readonly status: S.Literal<"compileError">;
+  readonly reason: S.String;
+}>]>>;
+declare const CheckerGroupResult: S.$Array<S.$Array<S.String>>;
+declare const ReporterInitOptions: S.Struct<{
+  readonly traceparent: S.optionalKey<S.String>;
+  readonly tracestate: S.optionalKey<S.String>;
+}>;
+type ReporterInitOptions = typeof ReporterInitOptions.Type;
+declare const ReporterEventBatch: S.$Array<S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>>;
+type ReporterEventBatch = typeof ReporterEventBatch.Type;
+declare const ReporterAck: S.Void;
+declare const ReporterDrained: S.Void;
+declare const BoundaryPayloadRejected_base: S.Class<BoundaryPayloadRejected, S.TaggedStruct<"BoundaryPayloadRejected", {
+  readonly pluginName: S.String;
+  readonly method: S.String;
+  readonly cause: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class BoundaryPayloadRejected extends BoundaryPayloadRejected_base {}
+declare const BoundaryUnrecognizedSignal_base: S.Class<BoundaryUnrecognizedSignal, S.TaggedStruct<"BoundaryUnrecognizedSignal", {
+  readonly pluginName: S.String;
+  readonly method: S.String;
+  readonly signal: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class BoundaryUnrecognizedSignal extends BoundaryUnrecognizedSignal_base {}
+declare const BoundaryErrorSchema: S.Union<readonly [typeof BoundaryPayloadRejected, typeof BoundaryUnrecognizedSignal, typeof TestRunnerFailed, typeof CheckerFailed, typeof ReporterFailed]>;
+type BoundaryError = typeof BoundaryErrorSchema.Type;
+declare const WorkerEntryUrl: S.String;
+type WorkerEntryUrl = typeof WorkerEntryUrl.Type;
+declare const WorkerPluginSpawnSchema: S.Struct<{
+  readonly kind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
+  readonly entrypoint: S.String;
+}>;
+type WorkerPluginSpawn = typeof WorkerPluginSpawnSchema.Type;
+//#endregion
+//#region src/TraceContextRpc.service.d.ts
+declare const PropagatedTrace_base: Context.ServiceClass<PropagatedTrace, "@systemfsoftware/stryker-js-plugin-interface/TraceContextRpc.service/PropagatedTrace", Option$1.Option<{
+  readonly version: string;
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly traceFlags: number;
+  readonly traceState?: string | undefined;
+}>>;
+declare class PropagatedTrace extends PropagatedTrace_base {}
+declare const TraceContextMiddleware_base: RpcMiddleware.ServiceClass<TraceContextMiddleware, "@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", typeof PropagatedTrace, Schema.Never, never, never, true>;
+declare class TraceContextMiddleware extends TraceContextMiddleware_base {}
+type TracedRpc<Tag extends string, Payload extends Schema.Top = Schema.Void, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> = Rpc.Rpc<Tag, Payload, Success, Error, typeof TraceContextMiddleware, RpcMiddleware.ApplyServices<typeof TraceContextMiddleware['Identifier'], never>>;
+//#endregion
+//#region src/PluginRpcs.service.d.ts
+declare const TestRunnerRpcs: RpcGroup.RpcGroup<TracedRpc<'capabilities', Schema.Void, typeof TestRunnerCapabilitiesSchema, typeof TestRunnerFailed> | TracedRpc<'dryRun', typeof TestRunnerDryRunRequest, typeof DryRunResultSchema, typeof TestRunnerFailed> | TracedRpc<'mutantRun', typeof TestRunnerMutantRunRequest, typeof MutantRunResultSchema, typeof TestRunnerFailed>>;
+declare const CheckerRpcs: RpcGroup.RpcGroup<TracedRpc<'check', typeof CheckerRequest, typeof CheckerCheckResult, typeof CheckerFailed> | TracedRpc<'group', typeof CheckerRequest, typeof CheckerGroupResult, typeof CheckerFailed>>;
+declare const ReporterRpcs: RpcGroup.RpcGroup<TracedRpc<'init', typeof ReporterInitOptions, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'onEventBatch', typeof ReporterEventBatch, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'flush', Schema.Void, typeof ReporterDrained, typeof ReporterFailed>>;
+declare namespace mod_d_exports$3 {
+  export { BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, CheckerCheckResult, CheckerGroupResult, CheckerRequest, CheckerRpcs, ExitClass, ExitCodeFromClass, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, TestRunnerDryRunRequest, TestRunnerMutantRunRequest, TestRunnerRpcs, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema };
+}
+declare namespace mod_d_exports$4 {
+  export { BrandingInformation, BrandingInformationSchema, Dependencies, DependenciesSchema, DetectedStatus, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, InvalidStatus, Metrics, MetricsResult, MetricsResultEncoded, MetricsResultSchema, MetricsSchema, MutantResult, MutantResultSchema, MutationTestResult, MutationTestResultSchema, NonNegativeFinite, NonNegativeInt, Percentage, TestDefinition, TestDefinitionSchema, TestFile, TestFileDefinitionDictionary, TestFileDefinitionDictionarySchema, TestFileSchema, Thresholds, ThresholdsSchema, UndetectedStatus, UntestedStatus };
+}
+declare namespace mod_d_exports$5 {
+  export { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFactory, ReporterFailed, ReporterInit, ReporterPlanDescriptor, ReporterPlanDescriptorSchema, ReporterPlanKind, RunTiming, RunTimingSchema };
+}
+//#endregion
+//#region src/mutant-timeout-reason.schema.d.ts
+declare const HitLimitReasonPrefix: S.Literal<"Hit limit reached">;
+declare const WallClockTimeoutReason: S.Literal<"wall-clock-timeout">;
+declare const HitLimitReasonText: S.String;
+declare const HitLimitReason: S.decodeTo<S.Struct<{
+  readonly count: S.Natural;
+  readonly limit: S.Natural;
+}>, S.String, never, never>;
+//#endregion
+//#region src/TestRunner.service.d.ts
+interface TestRunnerService {
+  readonly capabilities: Effect$1.Effect<TestRunnerCapabilities, TestRunnerFailed>;
+  readonly init: Effect$1.Effect<void, TestRunnerFailed>;
+  readonly dryRun: (options: DryRunOptions) => Effect$1.Effect<DryRunResult, TestRunnerFailed>;
+  readonly mutantRun: (options: mod_d_exports$3$1.MutantRunOptions) => Effect$1.Effect<MutantRunResult, TestRunnerFailed>;
+  readonly dispose: Effect$1.Effect<void, TestRunnerFailed>;
+}
+declare const TestRunner_base: Context.ServiceClass<TestRunner, "@systemfsoftware/stryker-js-plugin-interface/TestRunner.service/TestRunner", TestRunnerService>;
+declare class TestRunner extends TestRunner_base {}
+declare namespace mod_d_exports$6 {
+  export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, FailedTestResult, HitLimitReason, HitLimitReasonPrefix, HitLimitReasonText, KilledMutantRunResult, MutantCoverageSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, WallClockTimeoutReason };
+}
+//#endregion
+export { mod_d_exports$5 as a, mod_d_exports$2$1 as c, Ignorer$1 as d, Node_2$1 as f, mod_d_exports$4 as i, mod_d_exports$3$1 as l, mod_d_exports$2 as n, mod_d_exports$6 as o, mod_d_exports$3 as r, mod_d_exports$1 as s, mod_d_exports as t, Framework as u };