likec4 1.20.1 → 1.20.3

package/dist/index.d.ts

@@ -101,7 +101,7 @@ type LSPObject = object;
  *
  * @since 3.17.0 - support for negotiated position encoding.
  */
-interface Position$2 {
+interface Position$1 {
     /**
      * Line position in a document (zero-based).
      *
@@ -124,17 +124,17 @@ interface Position$2 {
  * The Position namespace provides helper functions to work with
  * {@link Position} literals.
  */
-declare namespace Position$2 {
+declare namespace Position$1 {
     /**
      * Creates a new Position literal from the given line and character.
      * @param line The position's line.
      * @param character The position's character.
      */
-    function create(line: uinteger, character: uinteger): Position$2;
+    function create(line: uinteger, character: uinteger): Position$1;
     /**
      * Checks whether the given literal conforms to the {@link Position} interface.
      */
-    function is(value: any): value is Position$2;
+    function is(value: any): value is Position$1;
 }
 /**
  * A range in a text document expressed as (zero-based) start and end positions.
@@ -153,11 +153,11 @@ interface Range$1 {
     /**
      * The range's start position.
      */
-    start: Position$2;
+    start: Position$1;
     /**
      * The range's end position.
      */
-    end: Position$2;
+    end: Position$1;
 }
 /**
  * The Range namespace provides helper functions to work with
@@ -169,7 +169,7 @@ declare namespace Range$1 {
      * @param start The range's start position.
      * @param end The range's end position.
      */
-    function create(start: Position$2, end: Position$2): Range$1;
+    function create(start: Position$1, end: Position$1): Range$1;
     /**
      * Create a new Range literal.
      * @param startLine The start line number.
@@ -648,7 +648,7 @@ declare namespace TextEdit$1 {
      * @param position The position to insert the text at.
      * @param newText The text to be inserted.
      */
-    function insert(position: Position$2, newText: string): TextEdit$1;
+    function insert(position: Position$1, newText: string): TextEdit$1;
     /**
      * Creates a delete text edit.
      * @param range The range of text to be deleted.
@@ -716,7 +716,7 @@ declare namespace AnnotatedTextEdit {
      * @param newText The text to be inserted.
      * @param annotation The annotation.
      */
-    function insert(position: Position$2, newText: string, annotation: ChangeAnnotationIdentifier): AnnotatedTextEdit;
+    function insert(position: Position$1, newText: string, annotation: ChangeAnnotationIdentifier): AnnotatedTextEdit;
     /**
      * Creates an annotated delete text edit.
      *
@@ -1679,7 +1679,7 @@ type DefinitionLink = LocationLink;
 /**
  * The declaration of a symbol representation as one or many {@link Location locations}.
  */
-type Declaration$1 = Location | Location[];
+type Declaration = Location | Location[];
 /**
  * Information about where a symbol is declared.
  *
@@ -2728,7 +2728,7 @@ type InlayHint = {
     /**
      * The position of this hint.
      */
-    position: Position$2;
+    position: Position$1;
     /**
      * The label of this hint. A human readable string or an array of
      * InlayHintLabelPart label parts.
@@ -2776,7 +2776,7 @@ type InlayHint = {
     data?: LSPAny;
 };
 declare namespace InlayHint {
-    function create(position: Position$2, label: string | InlayHintLabelPart[], kind?: InlayHintKind): InlayHint;
+    function create(position: Position$1, label: string | InlayHintLabelPart[], kind?: InlayHintKind): InlayHint;
     function is(value: any): value is InlayHint;
 }
 /**
@@ -4962,7 +4962,7 @@ type DocumentUri = string;
  * Positions are line end character agnostic. So you can not specify a position that
  * denotes `\r|\n` or `\n|` where `|` represents the character offset.
  */
-interface Position$1 {
+interface Position {
     /**
      * Line position in a document (zero-based).
      *
@@ -5001,11 +5001,11 @@ interface Range {
     /**
      * The range's start position.
      */
-    start: Position$1;
+    start: Position;
     /**
      * The range's end position.
      */
-    end: Position$1;
+    end: Position;
 }
 /**
  * A text edit applicable to a text document.
@@ -5100,7 +5100,7 @@ interface TextDocument {
      * * position { line: 1, character: 0 } for `offset` 3.
      * * position { line: 1, character: 1 } for `offset` 4.
      */
-    positionAt(offset: number): Position$1;
+    positionAt(offset: number): Position;
     /**
      * Converts the position to a zero-based offset.
      * Invalid positions are adjusted as described in {@link Position.line}
@@ -5109,7 +5109,7 @@ interface TextDocument {
      * @param position A position.
      * @return A valid zero-based offset.
      */
-    offsetAt(position: Position$1): number;
+    offsetAt(position: Position): number;
     /**
      * The number of lines in this document.
      *
@@ -5504,7 +5504,7 @@ interface BaseParser$1 {
      * Requires a unique index within the rule for a specific sub rule.
      * Arguments can be supplied to the rule invocation for semantic predicates
      */
-    subrule(idx: number, rule: RuleResult, feature: AbstractElement, args: Args): void;
+    subrule(idx: number, rule: RuleResult, fragment: boolean, feature: AbstractElement, args: Args): void;
     /**
      * Executes a grammar action that modifies the currently active AST node
      */
@@ -5542,7 +5542,7 @@ declare abstract class AbstractLangiumParser implements BaseParser$1 {
     atLeastOne(idx: number, callback: DSLMethodOpts<unknown>): void;
     abstract rule(rule: ParserRule, impl: RuleImpl): RuleResult;
     abstract consume(idx: number, tokenType: TokenType, feature: AbstractElement): void;
-    abstract subrule(idx: number, rule: RuleResult, feature: AbstractElement, args: Args): void;
+    abstract subrule(idx: number, rule: RuleResult, fragment: boolean, feature: AbstractElement, args: Args): void;
     abstract action($type: string, action: Action): void;
     abstract construct(): unknown;
     getRule(name: string): RuleResult | undefined;
@@ -5559,6 +5559,7 @@ declare class LangiumParser extends AbstractLangiumParser {
     private readonly converter;
     private readonly astReflection;
     private readonly nodeBuilder;
+    private lexerResult?;
     private stack;
     private assignmentMap;
     private get current();
@@ -5567,6 +5568,7 @@ declare class LangiumParser extends AbstractLangiumParser {
     private computeRuleType;
     parse<T extends AstNode = AstNode>(input: string, options?: ParserOptions): ParseResult<T>;
     private startImplementation;
+    private extractHiddenTokens;
     consume(idx: number, tokenType: TokenType, feature: AbstractElement): void;
     /**
      * Most consumed parser tokens are valid. However there are two cases in which they are not valid:
@@ -5575,7 +5577,7 @@ declare class LangiumParser extends AbstractLangiumParser {
      * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.
      */
     private isValidToken;
-    subrule(idx: number, rule: RuleResult, feature: AbstractElement, args: Args): void;
+    subrule(idx: number, rule: RuleResult, fragment: boolean, feature: AbstractElement, args: Args): void;
     private performSubruleAssignment;
     action($type: string, action: Action): void;
     construct(): unknown;
@@ -5610,7 +5612,7 @@ declare class LangiumCompletionParser extends AbstractLangiumParser {
     keepStackSize(): number;
     resetStackSize(size: number): void;
     consume(idx: number, tokenType: TokenType, feature: AbstractElement): void;
-    subrule(idx: number, rule: RuleResult, feature: AbstractElement, args: Args): void;
+    subrule(idx: number, rule: RuleResult, fragment: boolean, feature: AbstractElement, args: Args): void;
     before(element: AbstractElement): void;
     after(element: AbstractElement): void;
     get currIdx(): number;
@@ -6121,9 +6123,9 @@ interface CstNode extends DocumentSegment {
     /** The root CST node */
     readonly root: RootCstNode;
     /** The grammar element from which this node was parsed */
-    readonly grammarSource: AbstractElement;
+    readonly grammarSource?: AbstractElement;
     /** @deprecated use `grammarSource` instead. */
-    readonly feature: AbstractElement;
+    readonly feature?: AbstractElement;
     /** The AST node created from this CST node */
     readonly astNode: AstNode;
     /** @deprecated use `astNode` instead. */
@@ -7515,7 +7517,7 @@ interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultPara
     /**
      * The positions inside the text document.
      */
-    positions: Position$2[];
+    positions: Position$1[];
 }
 
 /**
@@ -9175,7 +9177,7 @@ interface TextDocumentPositionParams {
     /**
      * The position inside the text document.
      */
-    position: Position$2;
+    position: Position$1;
 }
 /**
  * The kind of resource operations supported by the client.
@@ -11266,7 +11268,7 @@ interface DocumentOnTypeFormattingParams {
      * This is not necessarily the exact position where the character denoted
      * by the property `ch` got typed.
      */
-    position: Position$2;
+    position: Position$1;
     /**
      * The character that has been typed that triggered the formatting
      * on type request. That is not necessarily the last character that
@@ -11343,7 +11345,7 @@ interface RenameParams extends WorkDoneProgressParams {
     /**
      * The position at which this request was sent.
      */
-    position: Position$2;
+    position: Position$1;
     /**
      * The new name of the symbol. If the given name is not valid the
      * request must return a {@link ResponseError} with an
@@ -12688,7 +12690,7 @@ interface _Connection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PW
      *
      * @param handler The corresponding handler.
      */
-    onDeclaration(handler: ServerRequestHandler<DeclarationParams, Declaration$1 | DeclarationLink[] | undefined | null, Location[] | DeclarationLink[], void>): Disposable$1;
+    onDeclaration(handler: ServerRequestHandler<DeclarationParams, Declaration | DeclarationLink[] | undefined | null, Location[] | DeclarationLink[], void>): Disposable$1;
     /**
      * Installs a handler for the `Definition` request.
      *
@@ -13760,7 +13762,7 @@ interface CompletionContext {
      * Index of the requested completed position.
      */
     offset: number;
-    position: Position$2;
+    position: Position$1;
 }
 interface CompletionProviderOptions$1 {
     /**
@@ -13833,7 +13835,7 @@ declare class DefaultCompletionProvider implements CompletionProvider {
      */
     protected deduplicateItems(items: CompletionItem[]): CompletionItem[];
     protected findFeaturesAt(document: TextDocument, offset: number): NextFeature[];
-    protected buildContexts(document: LangiumDocument, position: Position$2): IterableIterator<CompletionContext>;
+    protected buildContexts(document: LangiumDocument, position: Position$1): IterableIterator<CompletionContext>;
     protected performNextTokenCompletion(document: LangiumDocument, text: string, _offset: number, _end: number): boolean;
     protected findDataTypeRuleStart(cst: CstNode, offset: number): [number, number] | undefined;
     /**
@@ -13921,6 +13923,7 @@ declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
  ******************************************************************************/
 
 type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
+type Boolean = boolean;
 type BorderStyleValue = 'none' | LineOptions;
 type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
 type CustomColorValue = string;
@@ -13975,7 +13978,7 @@ type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
 declare const RelationshipStyleProperty = "RelationshipStyleProperty";
 type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
 declare const StringProperty = "StringProperty";
-type StyleProperty = BorderProperty | ColorProperty | IconProperty | OpacityProperty | ShapeProperty;
+type StyleProperty = BorderProperty | ColorProperty | IconProperty | MultipleProperty | OpacityProperty | ShapeProperty;
 declare const StyleProperty = "StyleProperty";
 type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
 type Uri = string;
@@ -14523,6 +14526,13 @@ interface ModelViews extends AstNode {
     views: Array<LikeC4View>;
 }
 declare const ModelViews = "ModelViews";
+interface MultipleProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $type: 'MultipleProperty';
+    key: 'multiple';
+    value: Boolean;
+}
+declare const MultipleProperty = "MultipleProperty";
 interface NavigateToProperty extends AstNode {
     readonly $container: CustomElementProperties;
     readonly $type: 'NavigateToProperty';
@@ -14931,6 +14941,7 @@ type LikeC4AstType = {
     Model: Model;
     ModelDeployments: ModelDeployments;
     ModelViews: ModelViews;
+    MultipleProperty: MultipleProperty;
     NavigateToProperty: NavigateToProperty;
     NotationProperty: NotationProperty;
     NotesProperty: NotesProperty;
@@ -15001,7 +15012,7 @@ type LikeC4AstType = {
 
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is DeployedInstance | DeploymentNode | DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleGlobalStyle | ViewRuleStyle | ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression | ElementPredicateWhere | ElementPredicateWith | ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataBody | FqnRefExpr | DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr | RelationPredicateWhereV2 | Element | ExtendElement | DeploymentView | DynamicView | ElementView | DirectedRelationExpression | InOutRelationExpression | IncomingRelationExpression | OutgoingRelationExpression | RelationPredicateWhere | RelationPredicateWith | RelationStringProperty | ArrowProperty | ColorProperty | LineProperty | MetadataAttribute | NotationProperty | NotesProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty | BorderProperty | OpacityProperty | ShapeProperty | ViewRuleGlobalPredicateRef | ViewRuleGroup | ExcludePredicate | IncludePredicate | SpecificationRelationshipKind | GlobalStyle | SpecificationColor | NavigateToProperty | DynamicViewStep | Tags | DeploymentRelation | SpecificationDeploymentNodeKind | DynamicViewParallelSteps | GlobalDynamicPredicateGroup | DynamicViewPredicateIterator | Relation | SpecificationElementKind | GlobalPredicateGroup | Globals | GlobalStyleGroup | SpecificationRule | SpecificationTag;
+declare const isValidatableAstNode: (n: AstNode) => n is DeployedInstance | DeploymentNode | DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleGlobalStyle | ViewRuleStyle | ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression | ElementPredicateWhere | ElementPredicateWith | ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataBody | FqnRefExpr | DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr | RelationPredicateWhereV2 | Element | ExtendElement | DeploymentView | DynamicView | ElementView | DirectedRelationExpression | InOutRelationExpression | IncomingRelationExpression | OutgoingRelationExpression | RelationPredicateWhere | RelationPredicateWith | RelationStringProperty | ArrowProperty | ColorProperty | LineProperty | MetadataAttribute | NotationProperty | NotesProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty | BorderProperty | MultipleProperty | OpacityProperty | ShapeProperty | ViewRuleGlobalPredicateRef | ViewRuleGroup | ExcludePredicate | IncludePredicate | SpecificationRelationshipKind | GlobalStyle | SpecificationColor | NavigateToProperty | DynamicViewStep | Tags | DeploymentRelation | SpecificationDeploymentNodeKind | DynamicViewParallelSteps | GlobalDynamicPredicateGroup | DynamicViewPredicateIterator | Relation | SpecificationElementKind | GlobalPredicateGroup | Globals | GlobalStyleGroup | SpecificationRule | SpecificationTag;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;
@@ -15037,6 +15048,7 @@ type ParsedElementStyle = {
     color?: c4.Color;
     border?: c4.BorderStyle;
     opacity?: number;
+    multiple?: boolean;
 };
 interface ParsedAstSpecification {
     tags: Set<c4.Tag>;
@@ -15208,6 +15220,7 @@ declare class DeploymentsIndex {
     private services;
     protected Names: LikeC4NameProvider;
     protected langiumDocuments: LangiumDocuments;
+    protected documentCache: DocumentCache<string, DocumentDeploymentsIndex>;
     constructor(services: LikeC4Services);
     private documents;
     get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
@@ -15259,7 +15272,15 @@ declare class DocumentDeploymentsIndex {
     unique(): readonly DeploymentAstNodeDescription[];
 }
 
-declare class FqnIndex {
+declare abstract class ADisposable implements Disposable {
+    protected toDispose: Disposable[];
+    protected isDisposed: boolean;
+    onDispose(...disposable: Disposable[]): void;
+    dispose(): void;
+    protected throwIfDisposed(): void;
+}
+
+declare class FqnIndex extends ADisposable {
     private services;
     protected langiumDocuments: LangiumDocuments;
     constructor(services: LikeC4Services);
@@ -15275,7 +15296,7 @@ declare class FqnIndex {
 }
 
 type ModelParsedListener = (docs: URI[]) => void;
-declare class LikeC4ModelBuilder {
+declare class LikeC4ModelBuilder extends ADisposable {
     private services;
     private langiumDocuments;
     private listeners;
@@ -15687,12 +15708,10 @@ declare class LikeC4ModelChanges {
     };
 }
 
-declare class Rpc implements Disposable {
+declare class Rpc extends ADisposable {
     private services;
-    private disposables;
     constructor(services: LikeC4Services);
     init(): void;
-    dispose(): void;
 }
 
 declare class NodeKindProvider implements NodeKindProvider$1 {
@@ -15796,614 +15815,6 @@ interface LikeC4AddedServices {
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
 
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-
-interface BaseNodeWithoutComments {
-    // Every leaf interface that extends BaseNode must specify a type property.
-    // The type property should be a string literal. For example, Identifier
-    // has: `type: "Identifier"`
-    type: string;
-    loc?: SourceLocation | null | undefined;
-    range?: [number, number] | undefined;
-}
-
-interface BaseNode extends BaseNodeWithoutComments {
-    leadingComments?: Comment[] | undefined;
-    trailingComments?: Comment[] | undefined;
-}
-
-interface Comment extends BaseNodeWithoutComments {
-    type: "Line" | "Block";
-    value: string;
-}
-
-interface SourceLocation {
-    source?: string | null | undefined;
-    start: Position;
-    end: Position;
-}
-
-interface Position {
-    /** >= 1 */
-    line: number;
-    /** >= 0 */
-    column: number;
-}
-
-interface BaseFunction extends BaseNode {
-    params: Pattern[];
-    generator?: boolean | undefined;
-    async?: boolean | undefined;
-    // The body is either BlockStatement or Expression because arrow functions
-    // can have a body that's either. FunctionDeclarations and
-    // FunctionExpressions have only BlockStatement bodies.
-    body: BlockStatement | Expression;
-}
-
-type Statement =
-    | ExpressionStatement
-    | BlockStatement
-    | StaticBlock
-    | EmptyStatement
-    | DebuggerStatement
-    | WithStatement
-    | ReturnStatement
-    | LabeledStatement
-    | BreakStatement
-    | ContinueStatement
-    | IfStatement
-    | SwitchStatement
-    | ThrowStatement
-    | TryStatement
-    | WhileStatement
-    | DoWhileStatement
-    | ForStatement
-    | ForInStatement
-    | ForOfStatement
-    | Declaration;
-
-interface BaseStatement extends BaseNode {}
-
-interface EmptyStatement extends BaseStatement {
-    type: "EmptyStatement";
-}
-
-interface BlockStatement extends BaseStatement {
-    type: "BlockStatement";
-    body: Statement[];
-    innerComments?: Comment[] | undefined;
-}
-
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-    type: "StaticBlock";
-}
-
-interface ExpressionStatement extends BaseStatement {
-    type: "ExpressionStatement";
-    expression: Expression;
-}
-
-interface IfStatement extends BaseStatement {
-    type: "IfStatement";
-    test: Expression;
-    consequent: Statement;
-    alternate?: Statement | null | undefined;
-}
-
-interface LabeledStatement extends BaseStatement {
-    type: "LabeledStatement";
-    label: Identifier;
-    body: Statement;
-}
-
-interface BreakStatement extends BaseStatement {
-    type: "BreakStatement";
-    label?: Identifier | null | undefined;
-}
-
-interface ContinueStatement extends BaseStatement {
-    type: "ContinueStatement";
-    label?: Identifier | null | undefined;
-}
-
-interface WithStatement extends BaseStatement {
-    type: "WithStatement";
-    object: Expression;
-    body: Statement;
-}
-
-interface SwitchStatement extends BaseStatement {
-    type: "SwitchStatement";
-    discriminant: Expression;
-    cases: SwitchCase[];
-}
-
-interface ReturnStatement extends BaseStatement {
-    type: "ReturnStatement";
-    argument?: Expression | null | undefined;
-}
-
-interface ThrowStatement extends BaseStatement {
-    type: "ThrowStatement";
-    argument: Expression;
-}
-
-interface TryStatement extends BaseStatement {
-    type: "TryStatement";
-    block: BlockStatement;
-    handler?: CatchClause | null | undefined;
-    finalizer?: BlockStatement | null | undefined;
-}
-
-interface WhileStatement extends BaseStatement {
-    type: "WhileStatement";
-    test: Expression;
-    body: Statement;
-}
-
-interface DoWhileStatement extends BaseStatement {
-    type: "DoWhileStatement";
-    body: Statement;
-    test: Expression;
-}
-
-interface ForStatement extends BaseStatement {
-    type: "ForStatement";
-    init?: VariableDeclaration | Expression | null | undefined;
-    test?: Expression | null | undefined;
-    update?: Expression | null | undefined;
-    body: Statement;
-}
-
-interface BaseForXStatement extends BaseStatement {
-    left: VariableDeclaration | Pattern;
-    right: Expression;
-    body: Statement;
-}
-
-interface ForInStatement extends BaseForXStatement {
-    type: "ForInStatement";
-}
-
-interface DebuggerStatement extends BaseStatement {
-    type: "DebuggerStatement";
-}
-
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-
-interface BaseDeclaration extends BaseStatement {}
-
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-    type: "FunctionDeclaration";
-    /** It is null when a function declaration is a part of the `export default function` statement */
-    id: Identifier | null;
-    body: BlockStatement;
-}
-
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-    id: Identifier;
-}
-
-interface VariableDeclaration extends BaseDeclaration {
-    type: "VariableDeclaration";
-    declarations: VariableDeclarator[];
-    kind: "var" | "let" | "const";
-}
-
-interface VariableDeclarator extends BaseNode {
-    type: "VariableDeclarator";
-    id: Pattern;
-    init?: Expression | null | undefined;
-}
-
-interface ExpressionMap {
-    ArrayExpression: ArrayExpression;
-    ArrowFunctionExpression: ArrowFunctionExpression;
-    AssignmentExpression: AssignmentExpression;
-    AwaitExpression: AwaitExpression;
-    BinaryExpression: BinaryExpression;
-    CallExpression: CallExpression;
-    ChainExpression: ChainExpression;
-    ClassExpression: ClassExpression;
-    ConditionalExpression: ConditionalExpression;
-    FunctionExpression: FunctionExpression;
-    Identifier: Identifier;
-    ImportExpression: ImportExpression;
-    Literal: Literal;
-    LogicalExpression: LogicalExpression;
-    MemberExpression: MemberExpression;
-    MetaProperty: MetaProperty;
-    NewExpression: NewExpression;
-    ObjectExpression: ObjectExpression;
-    SequenceExpression: SequenceExpression;
-    TaggedTemplateExpression: TaggedTemplateExpression;
-    TemplateLiteral: TemplateLiteral;
-    ThisExpression: ThisExpression;
-    UnaryExpression: UnaryExpression;
-    UpdateExpression: UpdateExpression;
-    YieldExpression: YieldExpression;
-}
-
-type Expression = ExpressionMap[keyof ExpressionMap];
-
-interface BaseExpression extends BaseNode {}
-
-type ChainElement = SimpleCallExpression | MemberExpression;
-
-interface ChainExpression extends BaseExpression {
-    type: "ChainExpression";
-    expression: ChainElement;
-}
-
-interface ThisExpression extends BaseExpression {
-    type: "ThisExpression";
-}
-
-interface ArrayExpression extends BaseExpression {
-    type: "ArrayExpression";
-    elements: Array<Expression | SpreadElement | null>;
-}
-
-interface ObjectExpression extends BaseExpression {
-    type: "ObjectExpression";
-    properties: Array<Property | SpreadElement>;
-}
-
-interface PrivateIdentifier extends BaseNode {
-    type: "PrivateIdentifier";
-    name: string;
-}
-
-interface Property extends BaseNode {
-    type: "Property";
-    key: Expression | PrivateIdentifier;
-    value: Expression | Pattern; // Could be an AssignmentProperty
-    kind: "init" | "get" | "set";
-    method: boolean;
-    shorthand: boolean;
-    computed: boolean;
-}
-
-interface PropertyDefinition extends BaseNode {
-    type: "PropertyDefinition";
-    key: Expression | PrivateIdentifier;
-    value?: Expression | null | undefined;
-    computed: boolean;
-    static: boolean;
-}
-
-interface FunctionExpression extends BaseFunction, BaseExpression {
-    id?: Identifier | null | undefined;
-    type: "FunctionExpression";
-    body: BlockStatement;
-}
-
-interface SequenceExpression extends BaseExpression {
-    type: "SequenceExpression";
-    expressions: Expression[];
-}
-
-interface UnaryExpression extends BaseExpression {
-    type: "UnaryExpression";
-    operator: UnaryOperator;
-    prefix: true;
-    argument: Expression;
-}
-
-interface BinaryExpression extends BaseExpression {
-    type: "BinaryExpression";
-    operator: BinaryOperator;
-    left: Expression | PrivateIdentifier;
-    right: Expression;
-}
-
-interface AssignmentExpression extends BaseExpression {
-    type: "AssignmentExpression";
-    operator: AssignmentOperator;
-    left: Pattern | MemberExpression;
-    right: Expression;
-}
-
-interface UpdateExpression extends BaseExpression {
-    type: "UpdateExpression";
-    operator: UpdateOperator;
-    argument: Expression;
-    prefix: boolean;
-}
-
-interface LogicalExpression extends BaseExpression {
-    type: "LogicalExpression";
-    operator: LogicalOperator;
-    left: Expression;
-    right: Expression;
-}
-
-interface ConditionalExpression extends BaseExpression {
-    type: "ConditionalExpression";
-    test: Expression;
-    alternate: Expression;
-    consequent: Expression;
-}
-
-interface BaseCallExpression extends BaseExpression {
-    callee: Expression | Super;
-    arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-
-interface SimpleCallExpression extends BaseCallExpression {
-    type: "CallExpression";
-    optional: boolean;
-}
-
-interface NewExpression extends BaseCallExpression {
-    type: "NewExpression";
-}
-
-interface MemberExpression extends BaseExpression, BasePattern {
-    type: "MemberExpression";
-    object: Expression | Super;
-    property: Expression | PrivateIdentifier;
-    computed: boolean;
-    optional: boolean;
-}
-
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-
-interface BasePattern extends BaseNode {}
-
-interface SwitchCase extends BaseNode {
-    type: "SwitchCase";
-    test?: Expression | null | undefined;
-    consequent: Statement[];
-}
-
-interface CatchClause extends BaseNode {
-    type: "CatchClause";
-    param: Pattern | null;
-    body: BlockStatement;
-}
-
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-    type: "Identifier";
-    name: string;
-}
-
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-
-interface SimpleLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value: string | boolean | number | null;
-    raw?: string | undefined;
-}
-
-interface RegExpLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: RegExp | null | undefined;
-    regex: {
-        pattern: string;
-        flags: string;
-    };
-    raw?: string | undefined;
-}
-
-interface BigIntLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: bigint | null | undefined;
-    bigint: string;
-    raw?: string | undefined;
-}
-
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-
-type BinaryOperator =
-    | "=="
-    | "!="
-    | "==="
-    | "!=="
-    | "<"
-    | "<="
-    | ">"
-    | ">="
-    | "<<"
-    | ">>"
-    | ">>>"
-    | "+"
-    | "-"
-    | "*"
-    | "/"
-    | "%"
-    | "**"
-    | "|"
-    | "^"
-    | "&"
-    | "in"
-    | "instanceof";
-
-type LogicalOperator = "||" | "&&" | "??";
-
-type AssignmentOperator =
-    | "="
-    | "+="
-    | "-="
-    | "*="
-    | "/="
-    | "%="
-    | "**="
-    | "<<="
-    | ">>="
-    | ">>>="
-    | "|="
-    | "^="
-    | "&="
-    | "||="
-    | "&&="
-    | "??=";
-
-type UpdateOperator = "++" | "--";
-
-interface ForOfStatement extends BaseForXStatement {
-    type: "ForOfStatement";
-    await: boolean;
-}
-
-interface Super extends BaseNode {
-    type: "Super";
-}
-
-interface SpreadElement extends BaseNode {
-    type: "SpreadElement";
-    argument: Expression;
-}
-
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-    type: "ArrowFunctionExpression";
-    expression: boolean;
-    body: BlockStatement | Expression;
-}
-
-interface YieldExpression extends BaseExpression {
-    type: "YieldExpression";
-    argument?: Expression | null | undefined;
-    delegate: boolean;
-}
-
-interface TemplateLiteral extends BaseExpression {
-    type: "TemplateLiteral";
-    quasis: TemplateElement[];
-    expressions: Expression[];
-}
-
-interface TaggedTemplateExpression extends BaseExpression {
-    type: "TaggedTemplateExpression";
-    tag: Expression;
-    quasi: TemplateLiteral;
-}
-
-interface TemplateElement extends BaseNode {
-    type: "TemplateElement";
-    tail: boolean;
-    value: {
-        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
-        cooked?: string | null | undefined;
-        raw: string;
-    };
-}
-
-interface AssignmentProperty extends Property {
-    value: Pattern;
-    kind: "init";
-    method: boolean; // false
-}
-
-interface ObjectPattern extends BasePattern {
-    type: "ObjectPattern";
-    properties: Array<AssignmentProperty | RestElement>;
-}
-
-interface ArrayPattern extends BasePattern {
-    type: "ArrayPattern";
-    elements: Array<Pattern | null>;
-}
-
-interface RestElement extends BasePattern {
-    type: "RestElement";
-    argument: Pattern;
-}
-
-interface AssignmentPattern extends BasePattern {
-    type: "AssignmentPattern";
-    left: Pattern;
-    right: Expression;
-}
-interface BaseClass extends BaseNode {
-    superClass?: Expression | null | undefined;
-    body: ClassBody;
-}
-
-interface ClassBody extends BaseNode {
-    type: "ClassBody";
-    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-
-interface MethodDefinition extends BaseNode {
-    type: "MethodDefinition";
-    key: Expression | PrivateIdentifier;
-    value: FunctionExpression;
-    kind: "constructor" | "method" | "get" | "set";
-    computed: boolean;
-    static: boolean;
-}
-
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-    type: "ClassDeclaration";
-    /** It is null when a class declaration is a part of the `export default class` statement */
-    id: Identifier | null;
-}
-
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-    id: Identifier;
-}
-
-interface ClassExpression extends BaseClass, BaseExpression {
-    type: "ClassExpression";
-    id?: Identifier | null | undefined;
-}
-
-interface MetaProperty extends BaseExpression {
-    type: "MetaProperty";
-    meta: Identifier;
-    property: Identifier;
-}
-
-interface ImportExpression extends BaseExpression {
-    type: "ImportExpression";
-    source: Expression;
-}
-
-interface AwaitExpression extends BaseExpression {
-    type: "AwaitExpression";
-    argument: Expression;
-}
-
-declare module 'estree' {
-	export interface Decorator extends BaseNode {
-		type: 'Decorator';
-		expression: Expression;
-	}
-	interface PropertyDefinition {
-		decorators: undefined[];
-	}
-	interface MethodDefinition {
-		decorators: undefined[];
-	}
-	interface BaseClass {
-		decorators: undefined[];
-	}
-}
-
-// declare AbortSignal here for environments without DOM lib or @types/node
-declare global {
-	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-	interface AbortSignal {}
-}
-
 type Logger = {
     info(msg: string): void;
     warn(msg: unknown): void;