sveast 0.9.3 → 0.9.4

package/scope.d.ts

@@ -0,0 +1,1792 @@
+/** How a {@link Binding} is declared. */
+export type BindingKind = "import" | "var" | "let" | "const" | "using" | "function" | "class" | "enum" | "enum-member" | "namespace" | "param" | "catch" | "reactive" | "each" | "each-index" | "let-directive" | "snippet" | "snippet-param" | "const-tag" | "await-value" | "await-error";
+
+/** A name declared in a {@link Scope}. */
+export interface Binding {
+    readonly name: string;
+    /**
+     * What declares it: `"import"`, `"var"`, `"let"`, `"const"` (`{let}`
+     * and `{const}` tags included), `"using"`, `"function"`, `"class"`,
+     * `"enum"`, `"enum-member"`, `"namespace"`, `"param"`, `"catch"`,
+     * `"reactive"` (`x` in `$: x = ...` without a declaration of `x`),
+     * `"each"` and `"each-index"` (`item` and `i` in `{#each items as item,
+     * i}`), `"let-directive"`, `"snippet"` (its name), `"snippet-param"`,
+     * `"const-tag"` (`{@const}`), `"await-value"` and `"await-error"` (`{:then
+     * value}` and `{:catch error}`).
+     */
+    readonly kind: BindingKind;
+    /**
+     * The `Identifier` that declares it; `null` for an each block's index
+     * and `let:x` without a value, whose names are strings.
+     */
+    readonly node: Identifier | null;
+    /**
+     * The node that declares it: the import specifier, the
+     * `VariableDeclarator`, the function or class, the function a
+     * parameter belongs to, the `CatchClause`, the `LabeledStatement` of
+     * `$:`, the `EachBlock`, `LetDirective`, `SnippetBlock` or `AwaitBlock`,
+     * the enum, enum member or namespace, or `import a = b`.
+     */
+    readonly declaration: AST.SvelteNode;
+    /**
+     * What it starts as, as svelte's analyzer has it: a variable's
+     * initializer, the function or class, the `ImportDeclaration`, the
+     * `SnippetBlock` for a snippet's name, the `EachBlock` for an index,
+     * the right side of `$: x = ...`, an enum member's initializer. For a
+     * prop destructured from `$props()`, its default, without `$bindable`:
+     * `"md"` in `let { size = "md" } = $props()` or in `let { size =
+     * $bindable("md") } = $props()`. `null` otherwise.
+     */
+    readonly initial: AST.SvelteNode | null;
+    readonly scope: Scope;
+    /**
+     * Every use of it, in source order: reads, writes, and `$name`
+     * subscriptions if it's a store. Not the identifiers that declare it,
+     * but for `x` in `$: x = ...`, which declares `x` and writes it each
+     * time the statement runs.
+     */
+    readonly references: readonly Reference[];
+    /**
+     * The rune its declarator's initializer calls, such as `"$state"`,
+     * `"$state.raw"`, `"$derived"`, `"$derived.by"` or `"$props"`, unless
+     * a binding or a store shadows it; `null` otherwise.
+     */
+    readonly rune: string | null;
+    /**
+     * The name a parent passes it as, for a prop: `"class"` for `klass` in
+     * `let { class: klass } = $props()` and in `export { klass as class }`,
+     * `"size"` in `export let size`. `null` otherwise, including for `rest`
+     * in `let { a, ...rest } = $props()`.
+     */
+    readonly prop: string | null;
+}
+
+/** A use of a name. */
+export interface Reference {
+    /**
+     * The `Identifier`. For a name the AST holds only as a string, such as
+     * `Foo` in `<Foo.Bar>`, `a` in `use:a`, `transition:a`, `in:a`,
+     * `out:a` and `animate:a`, and `color` in `style:color`, a new
+     * `Identifier` with the name's `start` and `end`.
+     */
+    readonly node: Identifier;
+    /** The node that holds it. */
+    readonly parent: AST.SvelteNode;
+    /** The scope it's in. */
+    readonly scope: Scope;
+    /** What it refers to; `null` for a global, such as `window` or a rune. */
+    readonly binding: Binding | null;
+    /**
+     * Whether it reads the value: all but the target of a plain `=`, and
+     * every store subscription.
+     */
+    readonly reads: boolean;
+    /**
+     * Whether it assigns a new value: the target of `=`, `+=` and the like,
+     * `++` and `--`, `bind:`, or `for (a of b)`.
+     */
+    readonly writes: boolean;
+    /**
+     * Whether it changes a property of the value: `a` in `a.b = c`,
+     * `a.b++` and `bind:value={a.b}`.
+     */
+    readonly mutates: boolean;
+    /**
+     * Whether it's a store subscription: `$count` refers to `count`, and
+     * `$count = 1` mutates it.
+     */
+    readonly store: boolean;
+}
+
+/**
+ * The names a function, block, element or other node declares, and the
+ * scopes around it.
+ */
+export interface Scope {
+    /**
+     * The node that makes it, or `null` for a component's `<script>` or
+     * `<script module>` that isn't there.
+     */
+    readonly node: AST.SvelteNode | null;
+    readonly parent: Scope | null;
+    /** Its own bindings, by name, in the order they're declared. */
+    readonly declarations: ReadonlyMap<string, Binding>;
+    /**
+     * The binding `name` refers to here, declared in this scope or one
+     * around it; `null` if none does.
+     */
+    get(name: string): Binding | null;
+}
+
+/** What {@link analyzeScopes} found. */
+export interface Scopes {
+    /** The `<script module>`'s scope, or a module's. */
+    readonly module: Scope;
+    /** The `<script>`'s scope, inside `module`; a module's, for a module. */
+    readonly instance: Scope;
+    /**
+     * The scope `node` is in: for a function, the scope around it, while
+     * its parameters are in its own. `null` for a node in a type, in the
+     * `<style>` or outside the AST.
+     */
+    scopeOf(node: AST.SvelteNode): Scope | null;
+    /**
+     * The binding an `Identifier` declares or refers to; `null` for a
+     * global, and for a name that isn't a reference, such as a property
+     * key or a name in a type.
+     */
+    bindingOf(node: Identifier): Binding | null;
+    /**
+     * The use an `Identifier` is, with whether it reads, writes or
+     * mutates its binding or subscribes to it as a store; `null` for an
+     * `Identifier` that declares a binding or isn't a reference. A global's
+     * use has no binding.
+     */
+    referenceOf(node: Identifier): Reference | null;
+    /**
+     * The bindings of the scope `node` makes, by name; empty if it makes
+     * none. A function's are its parameters, and a function expression's
+     * name; its body's declarations are its body's.
+     */
+    declaredIn(node: AST.SvelteNode): ReadonlyMap<string, Binding>;
+}
+
+/**
+ * Finds every scope, binding and reference in a component, its scripts
+ * and its markup together, or in a module, as svelte's analyzer does:
+ * which declaration each name refers to, and where each binding is read,
+ * written or subscribed to.
+ *
+ * Besides JavaScript's scopes, it knows the markup's: `{#each items as
+ * item, i (key)}` declares `item` and `i` for the key and the body, a
+ * snippet its parameters, `{:then value}` and `{:catch error}` their
+ * names, `{@const}` a name for its whole fragment, and `let:` a name for
+ * the element, or for a component's default or named slot (`let:a={b}`
+ * declares `b`). Store subscriptions such as `$count` are uses of
+ * `count`, unless they're runes. `bind:` writes its target, and
+ * `$: x = ...` declares `x` if nothing else does. A binding records the
+ * rune that initializes it, such as `$state` or `$props`, and the name a
+ * prop is passed as.
+ *
+ * Names in TypeScript types aren't references, and types aren't
+ * declarations: `interface` and `type` declare nothing. A top-level
+ * snippet is declared in the markup's scope, as in svelte's analyzer, so
+ * a `<script>` that uses it refers to a global.
+ *
+ * ```ts
+ * import { parse } from "sveast";
+ * import { analyzeScopes } from "sveast/scope";
+ *
+ * const ast = parse(source);
+ * const scopes = analyzeScopes(ast);
+ * const size = scopes.instance.get("size");
+ * size?.prop; // "size", for `let { size } = $props()`
+ * size?.references.some((reference) => reference.writes || reference.mutates);
+ * ```
+ *
+ * It reads the AST but doesn't change it.
+ */
+export declare function analyzeScopes(ast: AST.Root | Program): Scopes;
+
+interface BaseNodeWithoutComments {
+    type: string;
+    start: number;
+    end: number;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+    ImportAttribute: ImportAttribute;
+    TSNode: TSNode;
+}
+
+type Node = NodeMap[keyof NodeMap];
+
+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 Program extends Omit<BaseNode, "leadingComments"> {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+    /** In a component's `<script>`, an HTML comment right before the tag becomes `{ type: "Line", value }`, without offsets, as in svelte. */
+    leadingComments?: Array<Comment | {
+        type: "Line";
+        value: string;
+    }> | undefined;
+}
+
+interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+interface BaseFunction extends BaseNode, TSFunctionFields {
+    params: Array<Pattern | TSParameterProperty>;
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    body: BlockStatement | Expression;
+}
+
+type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+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 | TSDeclaration;
+
+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;
+    expression: false;
+    /** No `TSParameterProperty`: `private x` only parses in a class constructor, a `FunctionExpression`. */
+    params: Pattern[];
+}
+
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const" | "using" | "await using";
+    declare?: boolean;
+}
+
+interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+    definite?: boolean;
+}
+
+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;
+    TSExpression: TSExpression;
+}
+
+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;
+    value: Expression | Pattern;
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    decorators?: Decorator[];
+}
+
+interface PropertyDefinition extends BaseNode, TSClassMemberFields {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+    typeAnnotation?: TSTypeAnnotation;
+    definite?: boolean;
+}
+
+interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+    expression: false;
+}
+
+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 | TSAsExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
+    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>;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+type CallExpression = SimpleCallExpression | NewExpression;
+
+interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    /** Absent in a decorator, and on a call with type arguments, as in acorn-typescript. */
+    optional?: boolean;
+}
+
+interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    /** Absent in a decorator, and on a call with type arguments, as in acorn-typescript. */
+    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, TSBindingFields {
+    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 StringLiteral extends SimpleLiteral {
+    value: string;
+}
+
+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;
+    id: null;
+    /** No `TSParameterProperty`: `private x` only parses in a class constructor, a `FunctionExpression`. */
+    params: Pattern[];
+}
+
+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;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+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;
+}
+
+interface ObjectPattern extends BasePattern, TSBindingFields {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+interface ArrayPattern extends BasePattern, TSBindingFields {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+interface RestElement extends BasePattern, TSBindingFields {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+    decorators?: Decorator[];
+}
+
+type Class = ClassDeclaration | ClassExpression;
+
+interface BaseClass extends BaseNode, TSClassFields {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock | TSIndexSignature>;
+}
+
+interface MethodDefinition extends BaseNode, TSClassMemberFields {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression | TSDeclareMethod;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+    typeParameters?: TSTypeParameterDeclaration;
+}
+
+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;
+}
+
+type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration | TSModuleDeclarationStatement;
+
+interface BaseModuleDeclaration extends BaseNode {
+}
+
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+
+interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
+    source: StringLiteral;
+    importKind?: "type" | "value";
+}
+
+interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | StringLiteral;
+    importKind?: "type" | "value";
+}
+
+interface ImportAttribute extends BaseNode {
+    type: "ImportAttribute";
+    key: Identifier | StringLiteral;
+    value: StringLiteral;
+}
+
+interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+    options?: Expression | null | undefined;
+    /** The import attributes, with `typescript: true`; `options` otherwise. */
+    arguments?: Expression[];
+}
+
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
+    source?: StringLiteral | null | undefined;
+    exportKind?: "type" | "value";
+}
+
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | StringLiteral;
+    exported: Identifier | StringLiteral;
+    exportKind?: "type" | "value";
+}
+
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression | TSDeclareFunction | TSInterfaceDeclaration;
+    exportKind?: "type" | "value";
+}
+
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | StringLiteral | null;
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
+    source: StringLiteral;
+    exportKind?: "type" | "value";
+}
+
+interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+
+type TSNode = Decorator | TSTypeAnnotation | TypeNode | TSTypePredicate | TSNamedTupleMember | TSOptionalType | TSRestType | TemplateLiteralType | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSQualifiedName | TypeElement | TSInterfaceBody | TSExpressionWithTypeArguments | TSEnumMember | TSModuleBlock | TSExternalModuleReference | TSParameterProperty | TSDeclareMethod | TSDeclaration | TSModuleDeclarationStatement | TSExpression;
+
+type TSDeclaration = TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration;
+
+type TSModuleDeclarationStatement = TSExportAssignment | TSImportEqualsDeclaration | TSNamespaceExportDeclaration;
+
+type TSExpression = TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
+
+type TypeNode = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType | TSConditionalType | TSConstructorType | TSFunctionType | TSImportType | TSIndexedAccessType | TSInferType | TSIntersectionType | TSLiteralType | TSMappedType | TSParenthesizedType | TSThisType | TSTupleType | TSTypeLiteral | TSTypeOperator | TSTypeQuery | TSTypeReference | TSUnionType;
+
+type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature;
+
+type EntityName = Identifier | TSQualifiedName;
+
+type Accessibility = "public" | "private" | "protected";
+
+type SignatureParameter = Identifier | ObjectPattern | ArrayPattern | RestElement;
+
+interface TSBindingFields {
+    typeAnnotation?: TSTypeAnnotation | undefined;
+    /** `a?` in a parameter list. */
+    optional?: boolean;
+    decorators?: Decorator[];
+}
+
+interface TSFunctionFields {
+    typeParameters?: TSTypeParameterDeclaration;
+    returnType?: TSTypeAnnotation;
+}
+
+interface TSClassFields {
+    typeParameters?: TSTypeParameterDeclaration;
+    superTypeParameters?: TSTypeParameterInstantiation;
+    implements?: TSExpressionWithTypeArguments[];
+    abstract?: boolean;
+    declare?: boolean;
+    decorators?: Decorator[];
+}
+
+interface TSClassMemberFields {
+    accessibility?: Accessibility;
+    abstract?: boolean;
+    override?: boolean;
+    readonly?: boolean;
+    declare?: boolean;
+    accessor?: boolean;
+    optional?: boolean;
+    decorators?: Decorator[];
+}
+
+interface Decorator extends BaseNode {
+    type: "Decorator";
+    expression: Expression;
+}
+
+interface TSTypeAnnotation extends BaseNode {
+    type: "TSTypeAnnotation";
+    /** A predicate (`x is T`, `asserts x`) only in a return type. */
+    typeAnnotation: TypeNode | TSTypePredicate;
+}
+
+interface TSTypePredicate extends BaseNode {
+    type: "TSTypePredicate";
+    parameterName: Identifier | TSThisType;
+    asserts: boolean;
+    /** `null` for `asserts x` without `is`. */
+    typeAnnotation: TSTypeAnnotation | null;
+}
+
+interface TSAnyKeyword extends BaseNode {
+    type: "TSAnyKeyword";
+}
+
+interface TSBigIntKeyword extends BaseNode {
+    type: "TSBigIntKeyword";
+}
+
+interface TSBooleanKeyword extends BaseNode {
+    type: "TSBooleanKeyword";
+}
+
+interface TSNeverKeyword extends BaseNode {
+    type: "TSNeverKeyword";
+}
+
+interface TSNullKeyword extends BaseNode {
+    type: "TSNullKeyword";
+}
+
+interface TSNumberKeyword extends BaseNode {
+    type: "TSNumberKeyword";
+}
+
+interface TSObjectKeyword extends BaseNode {
+    type: "TSObjectKeyword";
+}
+
+interface TSStringKeyword extends BaseNode {
+    type: "TSStringKeyword";
+}
+
+interface TSSymbolKeyword extends BaseNode {
+    type: "TSSymbolKeyword";
+}
+
+interface TSUndefinedKeyword extends BaseNode {
+    type: "TSUndefinedKeyword";
+}
+
+interface TSUnknownKeyword extends BaseNode {
+    type: "TSUnknownKeyword";
+}
+
+interface TSVoidKeyword extends BaseNode {
+    type: "TSVoidKeyword";
+}
+
+interface TSThisType extends BaseNode {
+    type: "TSThisType";
+}
+
+interface TSArrayType extends BaseNode {
+    type: "TSArrayType";
+    elementType: TypeNode;
+}
+
+interface TSConditionalType extends BaseNode {
+    type: "TSConditionalType";
+    checkType: TypeNode;
+    extendsType: TypeNode;
+    trueType: TypeNode;
+    falseType: TypeNode;
+}
+
+interface TSFunctionType extends BaseNode {
+    type: "TSFunctionType";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation: TSTypeAnnotation;
+}
+
+interface TSConstructorType extends BaseNode {
+    type: "TSConstructorType";
+    abstract: boolean;
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation: TSTypeAnnotation;
+}
+
+interface TSImportType extends BaseNode {
+    type: "TSImportType";
+    argument: StringLiteral;
+    qualifier?: EntityName;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+interface TSIndexedAccessType extends BaseNode {
+    type: "TSIndexedAccessType";
+    objectType: TypeNode;
+    indexType: TypeNode;
+}
+
+interface TSInferType extends BaseNode {
+    type: "TSInferType";
+    typeParameter: TSTypeParameter;
+}
+
+interface TSIntersectionType extends BaseNode {
+    type: "TSIntersectionType";
+    types: TypeNode[];
+}
+
+interface TSUnionType extends BaseNode {
+    type: "TSUnionType";
+    types: TypeNode[];
+}
+
+interface TSLiteralType extends BaseNode {
+    type: "TSLiteralType";
+    /** `UnaryExpression` for a negative number, e.g. `-1`. */
+    literal: Literal | UnaryExpression | TemplateLiteralType;
+}
+
+interface TemplateLiteralType extends BaseNode {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: TypeNode[];
+}
+
+interface TSMappedType extends BaseNode {
+    type: "TSMappedType";
+    readonly?: true | "+" | "-";
+    typeParameter: TSTypeParameter;
+    /** The `as` clause. */
+    nameType: TypeNode | null;
+    optional?: true | "+" | "-";
+    typeAnnotation?: TypeNode;
+}
+
+interface TSParenthesizedType extends BaseNode {
+    type: "TSParenthesizedType";
+    typeAnnotation: TypeNode;
+}
+
+interface TSTupleType extends BaseNode {
+    type: "TSTupleType";
+    elementTypes: Array<TypeNode | TSNamedTupleMember | TSOptionalType | TSRestType>;
+}
+
+interface TSNamedTupleMember extends BaseNode {
+    type: "TSNamedTupleMember";
+    label: Identifier;
+    optional: boolean;
+    elementType: TypeNode;
+}
+
+interface TSOptionalType extends BaseNode {
+    type: "TSOptionalType";
+    typeAnnotation: TypeNode;
+}
+
+interface TSRestType extends BaseNode {
+    type: "TSRestType";
+    typeAnnotation: TypeNode | TSNamedTupleMember;
+}
+
+interface TSTypeLiteral extends BaseNode {
+    type: "TSTypeLiteral";
+    members: TypeElement[];
+}
+
+interface TSTypeOperator extends BaseNode {
+    type: "TSTypeOperator";
+    operator: "keyof" | "unique" | "readonly";
+    typeAnnotation: TypeNode;
+}
+
+interface TSTypeQuery extends BaseNode {
+    type: "TSTypeQuery";
+    exprName: EntityName | TSImportType;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+interface TSTypeReference extends BaseNode {
+    type: "TSTypeReference";
+    typeName: EntityName;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+interface TSQualifiedName extends BaseNode {
+    type: "TSQualifiedName";
+    left: EntityName;
+    right: Identifier;
+}
+
+interface TSTypeParameterDeclaration extends BaseNode {
+    type: "TSTypeParameterDeclaration";
+    params: TSTypeParameter[];
+    /** With a trailing comma, its offset. */
+    extra?: {
+        trailingComma: number;
+    };
+}
+
+interface TSTypeParameter extends BaseNode {
+    type: "TSTypeParameter";
+    name: string;
+    constraint?: TypeNode;
+    default?: TypeNode;
+    const?: true;
+    in?: true;
+    out?: true;
+}
+
+interface TSTypeParameterInstantiation extends BaseNode {
+    type: "TSTypeParameterInstantiation";
+    params: TypeNode[];
+}
+
+interface TSPropertySignature extends BaseNode {
+    type: "TSPropertySignature";
+    key: Expression;
+    computed?: boolean;
+    optional?: boolean;
+    readonly?: boolean;
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+interface TSMethodSignature extends BaseNode {
+    type: "TSMethodSignature";
+    key: Expression;
+    computed?: boolean;
+    optional?: boolean;
+    kind: "method" | "get" | "set";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    /** The return type. */
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+interface TSIndexSignature extends BaseNode, TSClassMemberFields {
+    type: "TSIndexSignature";
+    parameters: Identifier[];
+    typeAnnotation?: TSTypeAnnotation;
+    static?: boolean;
+}
+
+interface TSCallSignatureDeclaration extends BaseNode {
+    type: "TSCallSignatureDeclaration";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+interface TSConstructSignatureDeclaration extends BaseNode {
+    type: "TSConstructSignatureDeclaration";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+interface TSInterfaceDeclaration extends BaseNode {
+    type: "TSInterfaceDeclaration";
+    id: Identifier;
+    typeParameters?: TSTypeParameterDeclaration;
+    extends?: TSExpressionWithTypeArguments[];
+    body: TSInterfaceBody;
+    declare?: boolean;
+}
+
+interface TSInterfaceBody extends BaseNode {
+    type: "TSInterfaceBody";
+    body: TypeElement[];
+}
+
+interface TSExpressionWithTypeArguments extends BaseNode {
+    type: "TSExpressionWithTypeArguments";
+    expression: EntityName;
+    /** The type arguments, named `typeParameters` as in acorn-typescript. */
+    typeParameters?: TSTypeParameterInstantiation;
+}
+
+interface TSTypeAliasDeclaration extends BaseNode {
+    type: "TSTypeAliasDeclaration";
+    id: Identifier;
+    typeParameters?: TSTypeParameterDeclaration;
+    typeAnnotation: TypeNode;
+    declare?: boolean;
+}
+
+interface TSEnumDeclaration extends BaseNode {
+    type: "TSEnumDeclaration";
+    id: Identifier;
+    members: TSEnumMember[];
+    const?: boolean;
+    declare?: boolean;
+}
+
+interface TSEnumMember extends BaseNode {
+    type: "TSEnumMember";
+    id: Identifier | StringLiteral;
+    initializer?: Expression;
+}
+
+interface TSModuleDeclaration extends BaseNode {
+    type: "TSModuleDeclaration";
+    id: Identifier | StringLiteral;
+    /** Absent for `declare module "a";`. */
+    body?: TSModuleBlock | TSModuleDeclaration;
+    declare?: boolean;
+    global?: boolean;
+}
+
+interface TSModuleBlock extends BaseNode {
+    type: "TSModuleBlock";
+    body: Array<Statement | ModuleDeclaration>;
+}
+
+interface TSDeclareFunction extends BaseNode, TSFunctionFields {
+    type: "TSDeclareFunction";
+    /** `null` in `export default function (): void;`. */
+    id: Identifier | null;
+    params: Pattern[];
+    expression: boolean;
+    generator: boolean;
+    async: boolean;
+    declare?: boolean;
+}
+
+interface TSDeclareMethod extends BaseNode, TSFunctionFields {
+    type: "TSDeclareMethod";
+    id: null;
+    params: Array<Pattern | TSParameterProperty>;
+    expression: boolean;
+    generator: boolean;
+    async: boolean;
+}
+
+interface TSParameterProperty extends BaseNode {
+    type: "TSParameterProperty";
+    accessibility?: Accessibility;
+    readonly?: boolean;
+    override?: boolean;
+    parameter: Identifier | AssignmentPattern;
+}
+
+interface TSImportEqualsDeclaration extends BaseNode {
+    type: "TSImportEqualsDeclaration";
+    importKind: "type" | "value";
+    isExport: boolean;
+    id: Identifier;
+    moduleReference: EntityName | TSExternalModuleReference;
+}
+
+interface TSExternalModuleReference extends BaseNode {
+    type: "TSExternalModuleReference";
+    expression: StringLiteral;
+}
+
+interface TSExportAssignment extends BaseNode {
+    type: "TSExportAssignment";
+    expression: Expression;
+}
+
+interface TSNamespaceExportDeclaration extends BaseNode {
+    type: "TSNamespaceExportDeclaration";
+    id: Identifier;
+}
+
+interface TSAsExpression extends BaseNode {
+    type: "TSAsExpression";
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+
+interface TSSatisfiesExpression extends BaseNode {
+    type: "TSSatisfiesExpression";
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+
+interface TSTypeAssertion extends BaseNode {
+    type: "TSTypeAssertion";
+    typeAnnotation: TypeNode;
+    expression: Expression;
+}
+
+interface TSNonNullExpression extends BaseNode {
+    type: "TSNonNullExpression";
+    expression: Expression;
+}
+
+interface TSInstantiationExpression extends BaseNode {
+    type: "TSInstantiationExpression";
+    expression: Expression;
+    typeArguments: TSTypeParameterInstantiation;
+}
+
+type Namespace = "html" | "svg" | "mathml";
+
+declare namespace AST {
+    export interface BaseNode {
+        type: string;
+        start: number;
+        end: number;
+    }
+    export interface Fragment {
+        type: "Fragment";
+        nodes: Array<Text | Tag | ElementLike | Block | Comment>;
+    }
+    export interface Root extends BaseNode {
+        type: "Root";
+        /**
+         * Inline options provided by `<svelte:options>` — these override options passed to `compile(...)`
+         */
+        options: SvelteOptions | null;
+        fragment: Fragment;
+        /** The parsed `<style>` element, if exists */
+        css: AST.CSS.StyleSheet | null;
+        /** The parsed `<script>` element, if exists */
+        instance?: Script;
+        /** The parsed `<script module>` element, if exists */
+        module?: Script;
+        /** Comments found in <script> and {expressions} */
+        comments: JSComment[];
+        /** Always empty, as in svelte. */
+        js: [];
+    }
+    export interface SvelteOptions {
+        start: number;
+        end: number;
+        runes?: boolean;
+        immutable?: boolean;
+        accessors?: boolean;
+        preserveWhitespace?: boolean;
+        namespace?: Namespace;
+        css?: "injected";
+        customElement?: {
+            tag?: string;
+            shadow?: "open" | "none" | ObjectExpression | undefined;
+            props?: Record<string, {
+                attribute?: string;
+                reflect?: boolean;
+                type?: "Array" | "Boolean" | "Number" | "Object" | "String";
+            }>;
+            /**
+             * Is of type
+             * ```ts
+             * (ceClass: new () => HTMLElement) => new () => HTMLElement
+             * ```
+             */
+            extend?: ArrowFunctionExpression | Identifier;
+        };
+        attributes: Attribute[];
+    }
+    /** Static text */
+    export interface Text extends BaseNode {
+        type: "Text";
+        /** Text with decoded HTML entities */
+        data: string;
+        /** The original text, with undecoded HTML entities */
+        raw: string;
+    }
+    /** A (possibly reactive) template expression — `{...}` */
+    export interface ExpressionTag extends BaseNode {
+        type: "ExpressionTag";
+        expression: Expression;
+    }
+    /** A (possibly reactive) HTML template expression — `{@html ...}` */
+    export interface HtmlTag extends BaseNode {
+        type: "HtmlTag";
+        expression: Expression;
+    }
+    /** An HTML comment */
+    export interface Comment extends BaseNode {
+        type: "Comment";
+        /** the contents of the comment */
+        data: string;
+    }
+    /** A `{@const ...}` tag */
+    export interface ConstTag extends BaseNode {
+        type: "ConstTag";
+        declaration: VariableDeclaration & {
+            declarations: [VariableDeclarator & {
+                id: Pattern;
+                init: Expression;
+            }];
+        };
+    }
+    /** A `{let ...}` or `{const ...}` tag */
+    export interface DeclarationTag extends BaseNode {
+        type: "DeclarationTag";
+        declaration: VariableDeclaration;
+    }
+    /** A `{@debug ...}` tag */
+    export interface DebugTag extends BaseNode {
+        type: "DebugTag";
+        identifiers: Identifier[];
+    }
+    /** A `{@render foo(...)} tag */
+    export interface RenderTag extends BaseNode {
+        type: "RenderTag";
+        expression: SimpleCallExpression | (ChainExpression & {
+            expression: SimpleCallExpression;
+        });
+    }
+    /** A `{@attach foo(...)} tag */
+    export interface AttachTag extends BaseNode {
+        type: "AttachTag";
+        expression: Expression;
+    }
+    /** An `animate:` directive */
+    export interface AnimateDirective extends BaseAttribute {
+        type: "AnimateDirective";
+        /** The 'x' in `animate:x` */
+        name: string;
+        /** The y in `animate:x={y}` */
+        expression: null | Expression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** A `bind:` directive */
+    export interface BindDirective extends BaseAttribute {
+        type: "BindDirective";
+        /** The 'x' in `bind:x` */
+        name: string;
+        /** The y in `bind:x={y}` */
+        expression: Identifier | MemberExpression | SequenceExpression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** A `class:` directive */
+    export interface ClassDirective extends BaseAttribute {
+        type: "ClassDirective";
+        /** The 'x' in `class:x` */
+        name: "class";
+        /** The 'y' in `class:x={y}`, or the `x` in `class:x` */
+        expression: Expression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** A `let:` directive */
+    export interface LetDirective extends BaseAttribute {
+        type: "LetDirective";
+        /** The 'x' in `let:x` */
+        name: string;
+        /** The 'y' in `let:x={y}` */
+        expression: null | Identifier | ArrayExpression | ObjectExpression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** An `on:` directive */
+    export interface OnDirective extends BaseAttribute {
+        type: "OnDirective";
+        /** The 'x' in `on:x` */
+        name: string;
+        /** The 'y' in `on:x={y}` */
+        expression: null | Expression;
+        modifiers: Array<"capture" | "nonpassive" | "once" | "passive" | "preventDefault" | "self" | "stopImmediatePropagation" | "stopPropagation" | "trusted">;
+    }
+    /** A `style:` directive */
+    export interface StyleDirective extends BaseAttribute {
+        type: "StyleDirective";
+        /** The 'x' in `style:x` */
+        name: string;
+        /** The 'y' in `style:x={y}` */
+        value: true | ExpressionTag | Array<ExpressionTag | Text>;
+        modifiers: Array<"important">;
+    }
+    /** A `transition:`, `in:` or `out:` directive */
+    export interface TransitionDirective extends BaseAttribute {
+        type: "TransitionDirective";
+        /** The 'x' in `transition:x` */
+        name: string;
+        /** The 'y' in `transition:x={y}` */
+        expression: null | Expression;
+        modifiers: Array<"local" | "global">;
+        /** True if this is a `transition:` or `in:` directive */
+        intro: boolean;
+        /** True if this is a `transition:` or `out:` directive */
+        outro: boolean;
+    }
+    /** A `use:` directive */
+    export interface UseDirective extends BaseAttribute {
+        type: "UseDirective";
+        /** The 'x' in `use:x` */
+        name: string;
+        /** The 'y' in `use:x={y}` */
+        expression: null | Expression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    export interface BaseElement extends BaseNode {
+        name: string;
+        /** Only with `parse(source, { loc: true })`. */
+        name_loc?: SourceLocation;
+        attributes: Array<Attribute | SpreadAttribute | Directive | AttachTag>;
+        fragment: Fragment;
+    }
+    export interface Component extends BaseElement {
+        type: "Component";
+    }
+    export interface TitleElement extends BaseElement {
+        type: "TitleElement";
+        name: "title";
+    }
+    export interface SlotElement extends BaseElement {
+        type: "SlotElement";
+        name: "slot";
+    }
+    export interface RegularElement extends BaseElement {
+        type: "RegularElement";
+    }
+    export interface SvelteBody extends BaseElement {
+        type: "SvelteBody";
+        name: "svelte:body";
+    }
+    export interface SvelteComponent extends BaseElement {
+        type: "SvelteComponent";
+        name: "svelte:component";
+        expression: Expression;
+    }
+    export interface SvelteDocument extends BaseElement {
+        type: "SvelteDocument";
+        name: "svelte:document";
+    }
+    export interface SvelteElement extends BaseElement {
+        type: "SvelteElement";
+        name: "svelte:element";
+        tag: Expression;
+    }
+    export interface SvelteFragment extends BaseElement {
+        type: "SvelteFragment";
+        name: "svelte:fragment";
+    }
+    export interface SvelteBoundary extends BaseElement {
+        type: "SvelteBoundary";
+        name: "svelte:boundary";
+    }
+    export interface SvelteHead extends BaseElement {
+        type: "SvelteHead";
+        name: "svelte:head";
+    }
+    /** This is only an intermediate representation while parsing, it doesn't exist in the final AST */
+    export interface SvelteOptionsRaw extends BaseElement {
+        type: "SvelteOptions";
+        name: "svelte:options";
+    }
+    export interface SvelteSelf extends BaseElement {
+        type: "SvelteSelf";
+        name: "svelte:self";
+    }
+    export interface SvelteWindow extends BaseElement {
+        type: "SvelteWindow";
+        name: "svelte:window";
+    }
+    /** An `{#each ...}` block */
+    export interface EachBlock extends BaseNode {
+        type: "EachBlock";
+        expression: Expression;
+        /** The `entry` in `{#each item as entry}`. `null` if `as` part is omitted */
+        context: Pattern | null;
+        body: Fragment;
+        fallback?: Fragment;
+        index?: string;
+        key?: Expression;
+    }
+    /** An `{#if ...}` block */
+    export interface IfBlock extends BaseNode {
+        type: "IfBlock";
+        elseif: boolean;
+        test: Expression;
+        consequent: Fragment;
+        alternate: Fragment | null;
+    }
+    /** An `{#await ...}` block */
+    export interface AwaitBlock extends BaseNode {
+        type: "AwaitBlock";
+        expression: Expression;
+        /** The resolved value inside the `then` block */
+        value: Pattern | null;
+        /** The rejection reason inside the `catch` block */
+        error: Pattern | null;
+        pending: Fragment | null;
+        then: Fragment | null;
+        catch: Fragment | null;
+    }
+    export interface KeyBlock extends BaseNode {
+        type: "KeyBlock";
+        expression: Expression;
+        fragment: Fragment;
+    }
+    export interface SnippetBlock extends BaseNode {
+        type: "SnippetBlock";
+        expression: Identifier;
+        parameters: Pattern[];
+        typeParams?: string;
+        body: Fragment;
+    }
+    export interface BaseAttribute extends BaseNode {
+        name: string;
+        /** Only with `parse(source, { loc: true })`. */
+        name_loc?: SourceLocation | null;
+    }
+    export interface Attribute extends BaseAttribute {
+        type: "Attribute";
+        /**
+         * Quoted/string values are represented by an array, even if they contain a single expression like `"{x}"`
+         */
+        value: true | ExpressionTag | Array<Text | ExpressionTag>;
+    }
+    export interface SpreadAttribute extends BaseNode {
+        type: "SpreadAttribute";
+        expression: Expression;
+    }
+    export interface Script extends BaseNode {
+        type: "Script";
+        context: "default" | "module";
+        content: Program;
+        attributes: Attribute[];
+    }
+    export interface JSComment {
+        type: "Line" | "Block";
+        value: string;
+        start: number;
+        end: number;
+        /** Only with `parse(source, { loc: true })`. */
+        loc?: {
+            start: {
+                line: number;
+                column: number;
+            };
+            end: {
+                line: number;
+                column: number;
+            };
+        };
+    }
+    export type AttributeLike = Attribute | SpreadAttribute | Directive;
+    export type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
+    export type Block = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock;
+    export type ElementLike = AST.Component | AST.TitleElement | AST.SlotElement | AST.RegularElement | AST.SvelteBody | AST.SvelteBoundary | AST.SvelteComponent | AST.SvelteDocument | AST.SvelteElement | AST.SvelteFragment | AST.SvelteHead | AST.SvelteOptionsRaw | AST.SvelteSelf | AST.SvelteWindow | AST.SvelteBoundary;
+    export type Tag = AST.AttachTag | AST.ConstTag | AST.DeclarationTag | AST.DebugTag | AST.ExpressionTag | AST.HtmlTag | AST.RenderTag;
+    export type TemplateNode = AST.Root | AST.Text | Tag | ElementLike | AST.Attribute | AST.SpreadAttribute | Directive | AST.AttachTag | AST.Comment | Block;
+    export type SvelteNode = Node | TemplateNode | AST.Fragment | _CSS.Node | Script;
+    export type { _CSS as CSS };
+}
+
+declare namespace _CSS {
+    interface BaseNode {
+        start: number;
+        end: number;
+    }
+    interface StyleSheetBase extends BaseNode {
+        children: Array<Atrule | Rule>;
+        /** CSS comments in source order */
+        comments: CSSComment[];
+    }
+    interface CSSComment extends BaseNode {
+        type: "CSSComment";
+        value: string;
+        /** Character offset in a containing declaration value or at-rule prelude */
+        position?: number;
+    }
+    interface StyleSheetFile extends StyleSheetBase {
+        type: "StyleSheetFile";
+    }
+    interface StyleSheet extends StyleSheetBase {
+        type: "StyleSheet";
+        attributes: any[];
+        content: {
+            start: number;
+            end: number;
+            styles: string;
+            /** Possible comment atop the style tag */
+            comment: AST.Comment | null;
+        };
+    }
+    interface Atrule extends BaseNode {
+        type: "Atrule";
+        name: string;
+        prelude: string;
+        block: Block | null;
+    }
+    interface Rule extends BaseNode {
+        type: "Rule";
+        prelude: SelectorList;
+        block: Block;
+    }
+    /**
+     * A list of selectors, e.g. `a, b, c {}`
+     */
+    interface SelectorList extends BaseNode {
+        type: "SelectorList";
+        /**
+         * The `a`, `b` and `c` in `a, b, c {}`
+         */
+        children: ComplexSelector[];
+    }
+    /**
+     * A complex selector, e.g. `a b c {}`
+     */
+    interface ComplexSelector extends BaseNode {
+        type: "ComplexSelector";
+        /**
+         * The `a`, `b` and `c` in `a b c {}`
+         */
+        children: RelativeSelector[];
+    }
+    /**
+     * A relative selector, e.g the `a` and `> b` in `a > b {}`
+     */
+    interface RelativeSelector extends BaseNode {
+        type: "RelativeSelector";
+        /**
+         * In `a > b`, `> b` forms one relative selector, and `>` is the combinator. `null` for the first selector.
+         */
+        combinator: null | Combinator;
+        /**
+         * The `b:is(...)` in `> b:is(...)`
+         */
+        selectors: SimpleSelector[];
+    }
+    interface TypeSelector extends BaseNode {
+        type: "TypeSelector";
+        name: string;
+        namespace?: string;
+    }
+    interface IdSelector extends BaseNode {
+        type: "IdSelector";
+        name: string;
+    }
+    interface ClassSelector extends BaseNode {
+        type: "ClassSelector";
+        name: string;
+    }
+    interface AttributeSelector extends BaseNode {
+        type: "AttributeSelector";
+        name: string;
+        matcher: string | null;
+        value: string | null;
+        flags: string | null;
+    }
+    interface PseudoElementSelector extends BaseNode {
+        type: "PseudoElementSelector";
+        name: string;
+        args?: SelectorList;
+    }
+    interface PseudoClassSelector extends BaseNode {
+        type: "PseudoClassSelector";
+        name: string;
+        args: SelectorList | null;
+    }
+    interface Percentage extends BaseNode {
+        type: "Percentage";
+        value: string;
+    }
+    interface NestingSelector extends BaseNode {
+        type: "NestingSelector";
+        name: "&";
+    }
+    interface Nth extends BaseNode {
+        type: "Nth";
+        value: string;
+    }
+    type SimpleSelector = TypeSelector | IdSelector | ClassSelector | AttributeSelector | PseudoElementSelector | PseudoClassSelector | Percentage | Nth | NestingSelector;
+    interface Combinator extends BaseNode {
+        type: "Combinator";
+        name: string;
+    }
+    interface Block extends BaseNode {
+        type: "Block";
+        children: Array<Declaration | Rule | Atrule>;
+    }
+    interface Declaration extends BaseNode {
+        type: "Declaration";
+        property: string;
+        value: string;
+    }
+    type Node = StyleSheet | Rule | Atrule | SelectorList | Block | ComplexSelector | RelativeSelector | Combinator | SimpleSelector | Declaration;
+}