sveast 0.1.0 → 0.2.0

package/index.d.ts

@@ -7,19 +7,6 @@
  */
 export declare function parse(source: string, options?: ParseOptions): AST.Root;
 
-interface SourceLocation {
-    start: Location;
-    end: Location;
-}
-
-interface Identifier {
-    type: "Identifier";
-    name: string;
-    start: number;
-    end: number;
-    loc?: SourceLocation;
-}
-
 /**
  * Options for {@link parse}. The defaults give svelte's own output, minus
  * `loc` and `name_loc`.
@@ -39,638 +26,182 @@ export interface ParseOptions {
     css?: boolean;
 }
 
-interface Location {
+export interface BaseNodeWithoutComments {
+    type: string;
+    start: number;
+    end: number;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+export interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+export 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;
+}
+
+export type Node = NodeMap[keyof NodeMap];
+
+export interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+
+export interface Position {
+    /** >= 1 */
     line: number;
+    /** >= 0 */
     column: number;
-    character: number;
 }
 
-type Namespace = "html" | "svg" | "mathml";
+export 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;
+}
 
-export 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 | null;
-        /** The parsed `<script module>` element, if exists */
-        module?: Script | null;
-        /** Comments found in <script> and {expressions} */
-        comments: JSComment[];
-    }
-    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;
-    }
-    /** 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;
-    }
-    /** 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;
-    }
-    /** 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;
-    }
-    /** 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;
-    }
-    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;
-}
-
-interface BaseNodeWithoutComments {
-    type: string;
-    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;
-}
-
-type Node = NodeMap[keyof NodeMap];
-
-interface Comment extends BaseNodeWithoutComments {
-    type: "Line" | "Block";
-    value: string;
-}
-
-interface Program extends BaseNode {
-    type: "Program";
-    sourceType: "script" | "module";
-    body: Array<Directive | Statement | ModuleDeclaration>;
-    comments?: Comment[] | undefined;
-}
-
-interface Directive extends BaseNode {
+export interface Directive extends BaseNode {
     type: "ExpressionStatement";
     expression: Literal;
     directive: string;
 }
 
-interface BaseFunction extends BaseNode {
-    params: Pattern[];
+export interface BaseFunction extends BaseNode, TSFunctionFields {
+    params: Array<Pattern | TSParameterProperty>;
     generator?: boolean | undefined;
     async?: boolean | undefined;
     body: BlockStatement | Expression;
 }
 
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+export 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;
+export 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 {
+export interface BaseStatement extends BaseNode {
 }
 
-interface EmptyStatement extends BaseStatement {
+export interface EmptyStatement extends BaseStatement {
     type: "EmptyStatement";
 }
 
-interface BlockStatement extends BaseStatement {
+export interface BlockStatement extends BaseStatement {
     type: "BlockStatement";
     body: Statement[];
     innerComments?: Comment[] | undefined;
 }
 
-interface StaticBlock extends Omit<BlockStatement, "type"> {
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
     type: "StaticBlock";
 }
 
-interface ExpressionStatement extends BaseStatement {
+export interface ExpressionStatement extends BaseStatement {
     type: "ExpressionStatement";
     expression: Expression;
 }
 
-interface IfStatement extends BaseStatement {
+export interface IfStatement extends BaseStatement {
     type: "IfStatement";
     test: Expression;
     consequent: Statement;
     alternate?: Statement | null | undefined;
 }
 
-interface LabeledStatement extends BaseStatement {
+export interface LabeledStatement extends BaseStatement {
     type: "LabeledStatement";
     label: Identifier;
     body: Statement;
 }
 
-interface BreakStatement extends BaseStatement {
+export interface BreakStatement extends BaseStatement {
     type: "BreakStatement";
     label?: Identifier | null | undefined;
 }
 
-interface ContinueStatement extends BaseStatement {
+export interface ContinueStatement extends BaseStatement {
     type: "ContinueStatement";
     label?: Identifier | null | undefined;
 }
 
-interface WithStatement extends BaseStatement {
+export interface WithStatement extends BaseStatement {
     type: "WithStatement";
     object: Expression;
     body: Statement;
 }
 
-interface SwitchStatement extends BaseStatement {
+export interface SwitchStatement extends BaseStatement {
     type: "SwitchStatement";
     discriminant: Expression;
     cases: SwitchCase[];
 }
 
-interface ReturnStatement extends BaseStatement {
+export interface ReturnStatement extends BaseStatement {
     type: "ReturnStatement";
     argument?: Expression | null | undefined;
 }
 
-interface ThrowStatement extends BaseStatement {
+export interface ThrowStatement extends BaseStatement {
     type: "ThrowStatement";
     argument: Expression;
 }
 
-interface TryStatement extends BaseStatement {
+export interface TryStatement extends BaseStatement {
     type: "TryStatement";
     block: BlockStatement;
     handler?: CatchClause | null | undefined;
     finalizer?: BlockStatement | null | undefined;
 }
 
-interface WhileStatement extends BaseStatement {
+export interface WhileStatement extends BaseStatement {
     type: "WhileStatement";
     test: Expression;
     body: Statement;
 }
 
-interface DoWhileStatement extends BaseStatement {
+export interface DoWhileStatement extends BaseStatement {
     type: "DoWhileStatement";
     body: Statement;
     test: Expression;
 }
 
-interface ForStatement extends BaseStatement {
+export interface ForStatement extends BaseStatement {
     type: "ForStatement";
     init?: VariableDeclaration | Expression | null | undefined;
     test?: Expression | null | undefined;
@@ -678,49 +209,52 @@ interface ForStatement extends BaseStatement {
     body: Statement;
 }
 
-interface BaseForXStatement extends BaseStatement {
+export interface BaseForXStatement extends BaseStatement {
     left: VariableDeclaration | Pattern;
     right: Expression;
     body: Statement;
 }
 
-interface ForInStatement extends BaseForXStatement {
+export interface ForInStatement extends BaseForXStatement {
     type: "ForInStatement";
 }
 
-interface DebuggerStatement extends BaseStatement {
+export interface DebuggerStatement extends BaseStatement {
     type: "DebuggerStatement";
 }
 
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | TSDeclaration;
 
-interface BaseDeclaration extends BaseStatement {
+export interface BaseDeclaration extends BaseStatement {
 }
 
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+export 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;
 }
 
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
     id: Identifier;
 }
 
-interface VariableDeclaration extends BaseDeclaration {
+export interface VariableDeclaration extends BaseDeclaration {
     type: "VariableDeclaration";
     declarations: VariableDeclarator[];
     kind: "var" | "let" | "const" | "using" | "await using";
+    declare?: boolean;
 }
 
-interface VariableDeclarator extends BaseNode {
+export interface VariableDeclarator extends BaseNode {
     type: "VariableDeclarator";
     id: Pattern;
     init?: Expression | null | undefined;
+    definite?: boolean;
 }
 
-interface ExpressionMap {
+export interface ExpressionMap {
     ArrayExpression: ArrayExpression;
     ArrowFunctionExpression: ArrowFunctionExpression;
     AssignmentExpression: AssignmentExpression;
@@ -746,40 +280,41 @@ interface ExpressionMap {
     UnaryExpression: UnaryExpression;
     UpdateExpression: UpdateExpression;
     YieldExpression: YieldExpression;
+    TSExpression: TSExpression;
 }
 
-type Expression = ExpressionMap[keyof ExpressionMap];
+export type Expression = ExpressionMap[keyof ExpressionMap];
 
-interface BaseExpression extends BaseNode {
+export interface BaseExpression extends BaseNode {
 }
 
-type ChainElement = SimpleCallExpression | MemberExpression;
+export type ChainElement = SimpleCallExpression | MemberExpression;
 
-interface ChainExpression extends BaseExpression {
+export interface ChainExpression extends BaseExpression {
     type: "ChainExpression";
     expression: ChainElement;
 }
 
-interface ThisExpression extends BaseExpression {
+export interface ThisExpression extends BaseExpression {
     type: "ThisExpression";
 }
 
-interface ArrayExpression extends BaseExpression {
+export interface ArrayExpression extends BaseExpression {
     type: "ArrayExpression";
     elements: Array<Expression | SpreadElement | null>;
 }
 
-interface ObjectExpression extends BaseExpression {
+export interface ObjectExpression extends BaseExpression {
     type: "ObjectExpression";
     properties: Array<Property | SpreadElement>;
 }
 
-interface PrivateIdentifier extends BaseNode {
+export interface PrivateIdentifier extends BaseNode {
     type: "PrivateIdentifier";
     name: string;
 }
 
-interface Property extends BaseNode {
+export interface Property extends BaseNode {
     type: "Property";
     key: Expression;
     value: Expression | Pattern;
@@ -787,119 +322,131 @@ interface Property extends BaseNode {
     method: boolean;
     shorthand: boolean;
     computed: boolean;
+    decorators?: Decorator[];
 }
 
-interface PropertyDefinition extends BaseNode {
+export 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 {
+export interface FunctionExpression extends BaseFunction, BaseExpression {
     id?: Identifier | null | undefined;
     type: "FunctionExpression";
     body: BlockStatement;
+    expression: false;
 }
 
-interface SequenceExpression extends BaseExpression {
+export interface SequenceExpression extends BaseExpression {
     type: "SequenceExpression";
     expressions: Expression[];
 }
 
-interface UnaryExpression extends BaseExpression {
+export interface UnaryExpression extends BaseExpression {
     type: "UnaryExpression";
     operator: UnaryOperator;
     prefix: true;
     argument: Expression;
 }
 
-interface BinaryExpression extends BaseExpression {
+export interface BinaryExpression extends BaseExpression {
     type: "BinaryExpression";
     operator: BinaryOperator;
     left: Expression | PrivateIdentifier;
     right: Expression;
 }
 
-interface AssignmentExpression extends BaseExpression {
+export interface AssignmentExpression extends BaseExpression {
     type: "AssignmentExpression";
     operator: AssignmentOperator;
-    left: Pattern | MemberExpression;
+    left: Pattern | MemberExpression | TSAsExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
     right: Expression;
 }
 
-interface UpdateExpression extends BaseExpression {
+export interface UpdateExpression extends BaseExpression {
     type: "UpdateExpression";
     operator: UpdateOperator;
     argument: Expression;
     prefix: boolean;
 }
 
-interface LogicalExpression extends BaseExpression {
+export interface LogicalExpression extends BaseExpression {
     type: "LogicalExpression";
     operator: LogicalOperator;
     left: Expression;
     right: Expression;
 }
 
-interface ConditionalExpression extends BaseExpression {
+export interface ConditionalExpression extends BaseExpression {
     type: "ConditionalExpression";
     test: Expression;
     alternate: Expression;
     consequent: Expression;
 }
 
-interface BaseCallExpression extends BaseExpression {
+export interface BaseCallExpression extends BaseExpression {
     callee: Expression | Super;
     arguments: Array<Expression | SpreadElement>;
+    typeArguments?: TSTypeParameterInstantiation;
 }
 
-type CallExpression = SimpleCallExpression | NewExpression;
+export type CallExpression = SimpleCallExpression | NewExpression;
 
-interface SimpleCallExpression extends BaseCallExpression {
+export interface SimpleCallExpression extends BaseCallExpression {
     type: "CallExpression";
-    optional: boolean;
+    /** Absent in a decorator, and on a call with type arguments, as in acorn-typescript. */
+    optional?: boolean;
 }
 
-interface NewExpression extends BaseCallExpression {
+export interface NewExpression extends BaseCallExpression {
     type: "NewExpression";
 }
 
-interface MemberExpression extends BaseExpression, BasePattern {
+export interface MemberExpression extends BaseExpression, BasePattern {
     type: "MemberExpression";
     object: Expression | Super;
     property: Expression | PrivateIdentifier;
     computed: boolean;
-    optional: 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;
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
 
-interface BasePattern extends BaseNode {
+export interface BasePattern extends BaseNode {
 }
 
-interface SwitchCase extends BaseNode {
+export interface SwitchCase extends BaseNode {
     type: "SwitchCase";
     test?: Expression | null | undefined;
     consequent: Statement[];
 }
 
-interface CatchClause extends BaseNode {
+export interface CatchClause extends BaseNode {
     type: "CatchClause";
     param: Pattern | null;
     body: BlockStatement;
 }
 
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+export interface Identifier extends BaseNode, BaseExpression, BasePattern, TSBindingFields {
+    type: "Identifier";
+    name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
 
-interface SimpleLiteral extends BaseNode, BaseExpression {
+export interface SimpleLiteral extends BaseNode, BaseExpression {
     type: "Literal";
     value: string | boolean | number | null;
     raw?: string | undefined;
 }
 
-interface RegExpLiteral extends BaseNode, BaseExpression {
+export interface RegExpLiteral extends BaseNode, BaseExpression {
     type: "Literal";
     value?: RegExp | null | undefined;
     regex: {
@@ -909,62 +456,64 @@ interface RegExpLiteral extends BaseNode, BaseExpression {
     raw?: string | undefined;
 }
 
-interface BigIntLiteral extends BaseNode, BaseExpression {
+export interface BigIntLiteral extends BaseNode, BaseExpression {
     type: "Literal";
     value?: bigint | null | undefined;
     bigint: string;
     raw?: string | undefined;
 }
 
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
 
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
 
-type LogicalOperator = "||" | "&&" | "??";
+export type LogicalOperator = "||" | "&&" | "??";
 
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
 
-type UpdateOperator = "++" | "--";
+export type UpdateOperator = "++" | "--";
 
-interface ForOfStatement extends BaseForXStatement {
+export interface ForOfStatement extends BaseForXStatement {
     type: "ForOfStatement";
     await: boolean;
 }
 
-interface Super extends BaseNode {
+export interface Super extends BaseNode {
     type: "Super";
 }
 
-interface SpreadElement extends BaseNode {
+export interface SpreadElement extends BaseNode {
     type: "SpreadElement";
     argument: Expression;
 }
 
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
     type: "ArrowFunctionExpression";
     expression: boolean;
     body: BlockStatement | Expression;
+    id: null;
 }
 
-interface YieldExpression extends BaseExpression {
+export interface YieldExpression extends BaseExpression {
     type: "YieldExpression";
     argument?: Expression | null | undefined;
     delegate: boolean;
 }
 
-interface TemplateLiteral extends BaseExpression {
+export interface TemplateLiteral extends BaseExpression {
     type: "TemplateLiteral";
     quasis: TemplateElement[];
     expressions: Expression[];
 }
 
-interface TaggedTemplateExpression extends BaseExpression {
+export interface TaggedTemplateExpression extends BaseExpression {
     type: "TaggedTemplateExpression";
     tag: Expression;
     quasi: TemplateLiteral;
+    typeArguments?: TSTypeParameterInstantiation;
 }
 
-interface TemplateElement extends BaseNode {
+export interface TemplateElement extends BaseNode {
     type: "TemplateElement";
     tail: boolean;
     value: {
@@ -974,148 +523,1138 @@ interface TemplateElement extends BaseNode {
     };
 }
 
-interface AssignmentProperty extends Property {
+export interface AssignmentProperty extends Property {
     value: Pattern;
     kind: "init";
     method: boolean;
 }
 
-interface ObjectPattern extends BasePattern {
+export interface ObjectPattern extends BasePattern, TSBindingFields {
     type: "ObjectPattern";
     properties: Array<AssignmentProperty | RestElement>;
 }
 
-interface ArrayPattern extends BasePattern {
+export interface ArrayPattern extends BasePattern, TSBindingFields {
     type: "ArrayPattern";
     elements: Array<Pattern | null>;
 }
 
-interface RestElement extends BasePattern {
+export interface RestElement extends BasePattern, TSBindingFields {
     type: "RestElement";
     argument: Pattern;
 }
 
-interface AssignmentPattern extends BasePattern {
+export interface AssignmentPattern extends BasePattern {
     type: "AssignmentPattern";
     left: Pattern;
     right: Expression;
+    decorators?: Decorator[];
 }
 
-type Class = ClassDeclaration | ClassExpression;
+export type Class = ClassDeclaration | ClassExpression;
 
-interface BaseClass extends BaseNode {
+export interface BaseClass extends BaseNode, TSClassFields {
     superClass?: Expression | null | undefined;
     body: ClassBody;
 }
 
-interface ClassBody extends BaseNode {
+export interface ClassBody extends BaseNode {
     type: "ClassBody";
-    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock | TSIndexSignature>;
 }
 
-interface MethodDefinition extends BaseNode {
+export interface MethodDefinition extends BaseNode, TSClassMemberFields {
     type: "MethodDefinition";
     key: Expression | PrivateIdentifier;
-    value: FunctionExpression;
+    value: FunctionExpression | TSDeclareMethod;
     kind: "constructor" | "method" | "get" | "set";
     computed: boolean;
     static: boolean;
+    typeParameters?: TSTypeParameterDeclaration;
 }
 
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+export 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 {
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
     id: Identifier;
 }
 
-interface ClassExpression extends BaseClass, BaseExpression {
+export interface ClassExpression extends BaseClass, BaseExpression {
     type: "ClassExpression";
     id?: Identifier | null | undefined;
 }
 
-interface MetaProperty extends BaseExpression {
+export interface MetaProperty extends BaseExpression {
     type: "MetaProperty";
     meta: Identifier;
     property: Identifier;
 }
 
-type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+export type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration | TSModuleDeclarationStatement;
 
-interface BaseModuleDeclaration extends BaseNode {
+export interface BaseModuleDeclaration extends BaseNode {
 }
 
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
 
-interface BaseModuleSpecifier extends BaseNode {
+export interface BaseModuleSpecifier extends BaseNode {
     local: Identifier;
 }
 
-interface ImportDeclaration extends BaseModuleDeclaration {
+export interface ImportDeclaration extends BaseModuleDeclaration {
     type: "ImportDeclaration";
     specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-    attributes: ImportAttribute[];
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
     source: Literal;
+    importKind?: "type" | "value";
 }
 
-interface ImportSpecifier extends BaseModuleSpecifier {
+export interface ImportSpecifier extends BaseModuleSpecifier {
     type: "ImportSpecifier";
     imported: Identifier | Literal;
+    importKind?: "type" | "value";
 }
 
-interface ImportAttribute extends BaseNode {
+export interface ImportAttribute extends BaseNode {
     type: "ImportAttribute";
     key: Identifier | Literal;
     value: Literal;
 }
 
-interface ImportExpression extends BaseExpression {
+export 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 {
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
     type: "ImportDefaultSpecifier";
 }
 
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
     type: "ImportNamespaceSpecifier";
 }
 
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
     type: "ExportNamedDeclaration";
     declaration?: Declaration | null | undefined;
     specifiers: ExportSpecifier[];
-    attributes: ImportAttribute[];
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
     source?: Literal | null | undefined;
+    exportKind?: "type" | "value";
+}
+
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+    exportKind?: "type" | "value";
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression | TSDeclareFunction | TSInterfaceDeclaration;
+    exportKind?: "type" | "value";
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
+    source: Literal;
+    exportKind?: "type" | "value";
+}
+
+export interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+
+export 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;
+
+/** Declarations; in estree's `Declaration` union. */
+export type TSDeclaration = TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration;
+
+/** Module-level statements; in estree's `ModuleDeclaration` union. */
+export type TSModuleDeclarationStatement = TSExportAssignment | TSImportEqualsDeclaration | TSNamespaceExportDeclaration;
+
+/** Expressions; in estree's `Expression` union. */
+export type TSExpression = TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
+
+export 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;
+
+export type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature;
+
+export type EntityName = Identifier | TSQualifiedName;
+
+export type Accessibility = "public" | "private" | "protected";
+
+/** A parameter of a function type, method signature or declared function. */
+export type SignatureParameter = Identifier | ObjectPattern | ArrayPattern | RestElement;
+
+/** Fields the plugin adds to `Identifier`, `ObjectPattern`, `ArrayPattern` and `RestElement`. */
+export interface TSBindingFields {
+    typeAnnotation?: TSTypeAnnotation | undefined;
+    /** `a?` in a parameter list. */
+    optional?: boolean;
+    decorators?: Decorator[];
+}
+
+/** Fields the plugin adds to functions. */
+export interface TSFunctionFields {
+    typeParameters?: TSTypeParameterDeclaration;
+    returnType?: TSTypeAnnotation;
+}
+
+/** Fields the plugin adds to classes. */
+export interface TSClassFields {
+    typeParameters?: TSTypeParameterDeclaration;
+    superTypeParameters?: TSTypeParameterInstantiation;
+    implements?: TSExpressionWithTypeArguments[];
+    abstract?: boolean;
+    declare?: boolean;
+    decorators?: Decorator[];
+}
+
+/** Modifiers the plugin adds to class members. */
+export interface TSClassMemberFields {
+    accessibility?: Accessibility;
+    abstract?: boolean;
+    override?: boolean;
+    readonly?: boolean;
+    declare?: boolean;
+    accessor?: boolean;
+    optional?: boolean;
+    decorators?: Decorator[];
+}
+
+export interface Decorator extends BaseNode {
+    type: "Decorator";
+    expression: Expression;
+}
+
+export interface TSTypeAnnotation extends BaseNode {
+    type: "TSTypeAnnotation";
+    /** A predicate (`x is T`, `asserts x`) only in a return type. */
+    typeAnnotation: TypeNode | TSTypePredicate;
+}
+
+export interface TSTypePredicate extends BaseNode {
+    type: "TSTypePredicate";
+    parameterName: Identifier | TSThisType;
+    asserts: boolean;
+    /** `null` for `asserts x` without `is`. */
+    typeAnnotation: TSTypeAnnotation | null;
+}
+
+export interface TSAnyKeyword extends BaseNode {
+    type: "TSAnyKeyword";
+}
+
+export interface TSBigIntKeyword extends BaseNode {
+    type: "TSBigIntKeyword";
+}
+
+export interface TSBooleanKeyword extends BaseNode {
+    type: "TSBooleanKeyword";
+}
+
+export interface TSNeverKeyword extends BaseNode {
+    type: "TSNeverKeyword";
+}
+
+export interface TSNullKeyword extends BaseNode {
+    type: "TSNullKeyword";
+}
+
+export interface TSNumberKeyword extends BaseNode {
+    type: "TSNumberKeyword";
+}
+
+export interface TSObjectKeyword extends BaseNode {
+    type: "TSObjectKeyword";
+}
+
+export interface TSStringKeyword extends BaseNode {
+    type: "TSStringKeyword";
+}
+
+export interface TSSymbolKeyword extends BaseNode {
+    type: "TSSymbolKeyword";
+}
+
+export interface TSUndefinedKeyword extends BaseNode {
+    type: "TSUndefinedKeyword";
+}
+
+export interface TSUnknownKeyword extends BaseNode {
+    type: "TSUnknownKeyword";
+}
+
+export interface TSVoidKeyword extends BaseNode {
+    type: "TSVoidKeyword";
+}
+
+export interface TSThisType extends BaseNode {
+    type: "TSThisType";
+}
+
+export interface TSArrayType extends BaseNode {
+    type: "TSArrayType";
+    elementType: TypeNode;
+}
+
+export interface TSConditionalType extends BaseNode {
+    type: "TSConditionalType";
+    checkType: TypeNode;
+    extendsType: TypeNode;
+    trueType: TypeNode;
+    falseType: TypeNode;
+}
+
+export interface TSFunctionType extends BaseNode {
+    type: "TSFunctionType";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation: TSTypeAnnotation;
+}
+
+export interface TSConstructorType extends BaseNode {
+    type: "TSConstructorType";
+    abstract: boolean;
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation: TSTypeAnnotation;
+}
+
+export interface TSImportType extends BaseNode {
+    type: "TSImportType";
+    argument: Literal;
+    qualifier?: EntityName;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export interface TSIndexedAccessType extends BaseNode {
+    type: "TSIndexedAccessType";
+    objectType: TypeNode;
+    indexType: TypeNode;
+}
+
+export interface TSInferType extends BaseNode {
+    type: "TSInferType";
+    typeParameter: TSTypeParameter;
+}
+
+export interface TSIntersectionType extends BaseNode {
+    type: "TSIntersectionType";
+    types: TypeNode[];
+}
+
+export interface TSUnionType extends BaseNode {
+    type: "TSUnionType";
+    types: TypeNode[];
+}
+
+export interface TSLiteralType extends BaseNode {
+    type: "TSLiteralType";
+    /** `UnaryExpression` for a negative number, e.g. `-1`. */
+    literal: Literal | UnaryExpression | TemplateLiteralType;
+}
+
+/** A template literal type, `` `prefix-${T}` ``: a `TemplateLiteral` whose expressions are types. */
+export interface TemplateLiteralType extends BaseNode {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: TypeNode[];
+}
+
+export interface TSMappedType extends BaseNode {
+    type: "TSMappedType";
+    readonly?: true | "+" | "-";
+    typeParameter: TSTypeParameter;
+    /** The `as` clause. */
+    nameType: TypeNode | null;
+    optional?: true | "+" | "-";
+    typeAnnotation?: TypeNode;
+}
+
+export interface TSParenthesizedType extends BaseNode {
+    type: "TSParenthesizedType";
+    typeAnnotation: TypeNode;
+}
+
+export interface TSTupleType extends BaseNode {
+    type: "TSTupleType";
+    elementTypes: Array<TypeNode | TSNamedTupleMember | TSOptionalType | TSRestType>;
+}
+
+export interface TSNamedTupleMember extends BaseNode {
+    type: "TSNamedTupleMember";
+    label: Identifier;
+    optional: boolean;
+    elementType: TypeNode;
+}
+
+export interface TSOptionalType extends BaseNode {
+    type: "TSOptionalType";
+    typeAnnotation: TypeNode;
+}
+
+export interface TSRestType extends BaseNode {
+    type: "TSRestType";
+    typeAnnotation: TypeNode | TSNamedTupleMember;
+}
+
+export interface TSTypeLiteral extends BaseNode {
+    type: "TSTypeLiteral";
+    members: TypeElement[];
+}
+
+export interface TSTypeOperator extends BaseNode {
+    type: "TSTypeOperator";
+    operator: "keyof" | "unique" | "readonly";
+    typeAnnotation: TypeNode;
+}
+
+export interface TSTypeQuery extends BaseNode {
+    type: "TSTypeQuery";
+    exprName: EntityName | TSImportType;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export interface TSTypeReference extends BaseNode {
+    type: "TSTypeReference";
+    typeName: EntityName;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export interface TSQualifiedName extends BaseNode {
+    type: "TSQualifiedName";
+    left: EntityName;
+    right: Identifier;
+}
+
+export interface TSTypeParameterDeclaration extends BaseNode {
+    type: "TSTypeParameterDeclaration";
+    params: TSTypeParameter[];
+    /** With a trailing comma, its offset. */
+    extra?: {
+        trailingComma: number;
+    };
+}
+
+export interface TSTypeParameter extends BaseNode {
+    type: "TSTypeParameter";
+    name: string;
+    constraint?: TypeNode;
+    default?: TypeNode;
+    const?: true;
+    in?: true;
+    out?: true;
+}
+
+export interface TSTypeParameterInstantiation extends BaseNode {
+    type: "TSTypeParameterInstantiation";
+    params: TypeNode[];
+}
+
+export interface TSPropertySignature extends BaseNode {
+    type: "TSPropertySignature";
+    key: Expression;
+    computed?: boolean;
+    optional?: boolean;
+    readonly?: boolean;
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+export 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;
+}
+
+/** In an interface, a type literal, or a class body (with the class member modifiers). */
+export interface TSIndexSignature extends BaseNode, TSClassMemberFields {
+    type: "TSIndexSignature";
+    parameters: Identifier[];
+    typeAnnotation?: TSTypeAnnotation;
+    static?: boolean;
+}
+
+export interface TSCallSignatureDeclaration extends BaseNode {
+    type: "TSCallSignatureDeclaration";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+export interface TSConstructSignatureDeclaration extends BaseNode {
+    type: "TSConstructSignatureDeclaration";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+export interface TSInterfaceDeclaration extends BaseNode {
+    type: "TSInterfaceDeclaration";
+    id: Identifier;
+    typeParameters?: TSTypeParameterDeclaration;
+    extends?: TSExpressionWithTypeArguments[];
+    body: TSInterfaceBody;
+    declare?: boolean;
+}
+
+export interface TSInterfaceBody extends BaseNode {
+    type: "TSInterfaceBody";
+    body: TypeElement[];
+}
+
+/** An interface's `extends` or a class's `implements` entry. */
+export interface TSExpressionWithTypeArguments extends BaseNode {
+    type: "TSExpressionWithTypeArguments";
+    expression: EntityName;
+    /** The type arguments, named `typeParameters` as in acorn-typescript. */
+    typeParameters?: TSTypeParameterInstantiation;
+}
+
+export interface TSTypeAliasDeclaration extends BaseNode {
+    type: "TSTypeAliasDeclaration";
+    id: Identifier;
+    typeParameters?: TSTypeParameterDeclaration;
+    typeAnnotation: TypeNode;
+    declare?: boolean;
+}
+
+export interface TSEnumDeclaration extends BaseNode {
+    type: "TSEnumDeclaration";
+    id: Identifier;
+    members: TSEnumMember[];
+    const?: boolean;
+    declare?: boolean;
+}
+
+export interface TSEnumMember extends BaseNode {
+    type: "TSEnumMember";
+    id: Identifier | Literal;
+    initializer?: Expression;
+}
+
+/** `namespace A {}`, `module "a" {}`, `declare global {}`; `namespace A.B {}` nests through `body`. */
+export interface TSModuleDeclaration extends BaseNode {
+    type: "TSModuleDeclaration";
+    id: Identifier | Literal;
+    /** Absent for `declare module "a";`. */
+    body?: TSModuleBlock | TSModuleDeclaration;
+    declare?: boolean;
+    global?: boolean;
+}
+
+export interface TSModuleBlock extends BaseNode {
+    type: "TSModuleBlock";
+    body: Array<Statement | ModuleDeclaration>;
+}
+
+/** A function declaration without a body: an overload or `declare function`. */
+export 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;
+}
+
+/** A `MethodDefinition`'s value when the method has no body: an overload or an abstract method. */
+export interface TSDeclareMethod extends BaseNode, TSFunctionFields {
+    type: "TSDeclareMethod";
+    id: null;
+    params: Array<Pattern | TSParameterProperty>;
+    expression: boolean;
+    generator: boolean;
+    async: boolean;
+}
+
+/** `constructor(private a: T)`: a constructor parameter with a modifier. */
+export interface TSParameterProperty extends BaseNode {
+    type: "TSParameterProperty";
+    accessibility?: Accessibility;
+    readonly?: boolean;
+    override?: boolean;
+    parameter: Identifier | AssignmentPattern;
+}
+
+/** `import a = require("a")`, `import a = B.C`, `export import a = B.C`. */
+export interface TSImportEqualsDeclaration extends BaseNode {
+    type: "TSImportEqualsDeclaration";
+    importKind: "type" | "value";
+    isExport: boolean;
+    id: Identifier;
+    moduleReference: EntityName | TSExternalModuleReference;
+}
+
+export interface TSExternalModuleReference extends BaseNode {
+    type: "TSExternalModuleReference";
+    expression: Literal;
+}
+
+/** `export = a`. */
+export interface TSExportAssignment extends BaseNode {
+    type: "TSExportAssignment";
+    expression: Expression;
+}
+
+/** `export as namespace A`. */
+export interface TSNamespaceExportDeclaration extends BaseNode {
+    type: "TSNamespaceExportDeclaration";
+    id: Identifier;
+}
+
+export interface TSAsExpression extends BaseNode {
+    type: "TSAsExpression";
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+
+export interface TSSatisfiesExpression extends BaseNode {
+    type: "TSSatisfiesExpression";
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+
+/** `<T>a`. */
+export interface TSTypeAssertion extends BaseNode {
+    type: "TSTypeAssertion";
+    typeAnnotation: TypeNode;
+    expression: Expression;
+}
+
+export interface TSNonNullExpression extends BaseNode {
+    type: "TSNonNullExpression";
+    expression: Expression;
 }
 
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-    type: "ExportSpecifier";
-    local: Identifier | Literal;
-    exported: Identifier | Literal;
+/** `f<T>` without a call. */
+export interface TSInstantiationExpression extends BaseNode {
+    type: "TSInstantiationExpression";
+    expression: Expression;
+    typeArguments: TSTypeParameterInstantiation;
 }
 
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-    type: "ExportDefaultDeclaration";
-    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+type Namespace = "html" | "svg" | "mathml";
+
+export 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 };
 }
 
-interface ExportAllDeclaration extends BaseModuleDeclaration {
-    type: "ExportAllDeclaration";
-    exported: Identifier | Literal | null;
-    attributes: ImportAttribute[];
-    source: Literal;
+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;
 }
 
-interface AwaitExpression extends BaseExpression {
-    type: "AwaitExpression";
-    argument: Expression;
-}
+/**
+ * Parses a JavaScript or TypeScript module, e.g. a `.ts` file a component
+ * imports, into the same kind of AST as a component's `<script>`:
+ * estree, TypeScript nodes as in `@sveltejs/acorn-typescript`, and
+ * comments attached as `leadingComments`/`trailingComments`.
+ *
+ * Throws a {@link ParseError} (`js_parse_error`) on a syntax error.
+ */
+export declare function parseModule(source: string, options?: {
+    /** Parse TypeScript. Default `false`. */
+    typescript?: boolean;
+    /** Add `loc` (line/column) to every node. Default `false`. */
+    loc?: boolean;
+}): Program;
 
 type NodeLike = number | {
     start?: number;
@@ -1140,17 +1679,8 @@ export declare class ParseError extends Error {
     constructor(node: NodeLike, code: string, message: string);
 }
 
-/**
- * Parses a JavaScript or TypeScript module, e.g. a `.ts` file a component
- * imports, into the same kind of AST as a component's `<script>`:
- * estree, TypeScript nodes as in `@sveltejs/acorn-typescript`, and
- * comments attached as `leadingComments`/`trailingComments`.
- *
- * Throws a {@link ParseError} (`js_parse_error`) on a syntax error.
- */
-export declare function parseModule(source: string, options?: {
-    /** Parse TypeScript. Default `false`. */
-    typescript?: boolean;
-    /** Add `loc` (line/column) to every node. Default `false`. */
-    loc?: boolean;
-}): Program;
+interface Location {
+    line: number;
+    column: number;
+    character: number;
+}