sveast 0.4.0 → 0.6.0

package/index.d.ts

@@ -15,15 +15,6 @@ export declare function isValidType(text: string, options?: {
     inline?: boolean;
 }): boolean;
 
-/**
- * Parses a Svelte component into svelte's modern AST, the same as
- * `parse(source, { modern: true })` from svelte/compiler. From svelte's
- * `Parser` constructor (`phases/1-parse/index.js`).
- *
- * Throws a {@link ParseError} on a syntax error.
- */
-export declare function parse(source: string, options?: ParseOptions): AST.Root;
-
 /**
  * Options for {@link parse}. The defaults give svelte's own output, minus
  * `loc` and `name_loc`.
@@ -41,1149 +32,67 @@ export interface ParseOptions {
      * `comments` are empty and CSS syntax errors aren't reported. Default `true`.
      */
     css?: boolean;
+    /**
+     * Parse each `<script>`'s JavaScript or TypeScript. With `false`, scripts
+     * keep their attributes and bounds, and `content` is a `Program` with its
+     * `start` and `end` but an empty `body`; their comments aren't in
+     * `comments`, and their syntax errors aren't reported. Expressions in the
+     * markup are still parsed. Default `true`.
+     */
+    script?: boolean;
+    /**
+     * Collect JavaScript comments, in scripts, expressions and tags, into
+     * `comments` and attach them to nodes as `leadingComments` and
+     * `trailingComments`. With `false`, `comments` is empty and no node has
+     * either field, including the HTML comment before a `<script>` that
+     * svelte copies into its `content.leadingComments`; HTML comments in the
+     * markup and CSS comments are kept. Default `true`.
+     */
+    comments?: boolean;
 }
 
-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;
-}
-
-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 interface Directive extends BaseNode {
-    type: "ExpressionStatement";
-    expression: Literal;
-    directive: string;
-}
-
-export interface BaseFunction extends BaseNode, TSFunctionFields {
-    params: Array<Pattern | TSParameterProperty>;
-    generator?: boolean | undefined;
-    async?: boolean | undefined;
-    body: BlockStatement | Expression;
-}
-
-export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-
-export type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-
-export interface BaseStatement extends BaseNode {
-}
-
-export interface EmptyStatement extends BaseStatement {
-    type: "EmptyStatement";
-}
-
-export interface BlockStatement extends BaseStatement {
-    type: "BlockStatement";
-    body: Statement[];
-    innerComments?: Comment[] | undefined;
-}
-
-export interface StaticBlock extends Omit<BlockStatement, "type"> {
-    type: "StaticBlock";
-}
-
-export interface ExpressionStatement extends BaseStatement {
-    type: "ExpressionStatement";
-    expression: Expression;
-}
-
-export interface IfStatement extends BaseStatement {
-    type: "IfStatement";
-    test: Expression;
-    consequent: Statement;
-    alternate?: Statement | null | undefined;
-}
-
-export interface LabeledStatement extends BaseStatement {
-    type: "LabeledStatement";
-    label: Identifier;
-    body: Statement;
-}
-
-export interface BreakStatement extends BaseStatement {
-    type: "BreakStatement";
-    label?: Identifier | null | undefined;
-}
-
-export interface ContinueStatement extends BaseStatement {
-    type: "ContinueStatement";
-    label?: Identifier | null | undefined;
-}
-
-export interface WithStatement extends BaseStatement {
-    type: "WithStatement";
-    object: Expression;
-    body: Statement;
-}
-
-export interface SwitchStatement extends BaseStatement {
-    type: "SwitchStatement";
-    discriminant: Expression;
-    cases: SwitchCase[];
-}
-
-export interface ReturnStatement extends BaseStatement {
-    type: "ReturnStatement";
-    argument?: Expression | null | undefined;
-}
-
-export interface ThrowStatement extends BaseStatement {
-    type: "ThrowStatement";
-    argument: Expression;
-}
-
-export interface TryStatement extends BaseStatement {
-    type: "TryStatement";
-    block: BlockStatement;
-    handler?: CatchClause | null | undefined;
-    finalizer?: BlockStatement | null | undefined;
-}
-
-export interface WhileStatement extends BaseStatement {
-    type: "WhileStatement";
-    test: Expression;
-    body: Statement;
-}
-
-export interface DoWhileStatement extends BaseStatement {
-    type: "DoWhileStatement";
-    body: Statement;
-    test: Expression;
-}
-
-export interface ForStatement extends BaseStatement {
-    type: "ForStatement";
-    init?: VariableDeclaration | Expression | null | undefined;
-    test?: Expression | null | undefined;
-    update?: Expression | null | undefined;
-    body: Statement;
-}
-
-export interface BaseForXStatement extends BaseStatement {
-    left: VariableDeclaration | Pattern;
-    right: Expression;
-    body: Statement;
-}
-
-export interface ForInStatement extends BaseForXStatement {
-    type: "ForInStatement";
-}
-
-export interface DebuggerStatement extends BaseStatement {
-    type: "DebuggerStatement";
-}
-
-export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | TSDeclaration;
-
-export interface BaseDeclaration extends BaseStatement {
+/** Options for {@link parseModule}. */
+export interface ParseModuleOptions {
+    /** Parse TypeScript. Default `false`. */
+    typescript?: boolean;
+    /** Add `loc` (line/column) to every node. Default `false`. */
+    loc?: boolean;
+    /**
+     * Attach comments as `leadingComments`/`trailingComments`. With
+     * `false`, no node has either field. Default `true`.
+     */
+    comments?: boolean;
 }
 
-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;
-    /** No `TSParameterProperty`: `private x` only parses in a class constructor, a `FunctionExpression`. */
-    params: Pattern[];
+/** Options for {@link parseImportsExports}. */
+export interface ParseImportsExportsOptions {
+    /**
+     * Parse TypeScript, e.g. `import type`, `export type` and
+     * `import a = require("a")`. Default `false`.
+     */
+    typescript?: boolean;
+    /**
+     * Return the `export` statements that export the module's own bindings,
+     * such as `export let a`, `export function b() {}`, `export { c }` and
+     * `export default d`. With `false`, only imports and the exports that
+     * have a `from`, such as `export * from "e"` and `export { f } from "f"`,
+     * are returned, and the rest is skipped like other code, which is faster
+     * when most statements are exported, as in a component's props.
+     * Default `true`.
+     */
+    localExports?: boolean;
 }
 
-export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-    id: Identifier;
-}
+/**
+ * Parses a Svelte component into svelte's modern AST, the same as
+ * `parse(source, { modern: true })` from svelte/compiler. From svelte's
+ * `Parser` constructor (`phases/1-parse/index.js`).
+ *
+ * Throws a {@link ParseError} on a syntax error.
+ */
+export declare function parse(source: string, options?: ParseOptions): AST.Root;
 
-export interface VariableDeclaration extends BaseDeclaration {
-    type: "VariableDeclaration";
-    declarations: VariableDeclarator[];
-    kind: "var" | "let" | "const" | "using" | "await using";
-    declare?: boolean;
-}
-
-export interface VariableDeclarator extends BaseNode {
-    type: "VariableDeclarator";
-    id: Pattern;
-    init?: Expression | null | undefined;
-    definite?: boolean;
-}
-
-export 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;
-}
-
-export type Expression = ExpressionMap[keyof ExpressionMap];
-
-export interface BaseExpression extends BaseNode {
-}
-
-export type ChainElement = SimpleCallExpression | MemberExpression;
-
-export interface ChainExpression extends BaseExpression {
-    type: "ChainExpression";
-    expression: ChainElement;
-}
-
-export interface ThisExpression extends BaseExpression {
-    type: "ThisExpression";
-}
-
-export interface ArrayExpression extends BaseExpression {
-    type: "ArrayExpression";
-    elements: Array<Expression | SpreadElement | null>;
-}
-
-export interface ObjectExpression extends BaseExpression {
-    type: "ObjectExpression";
-    properties: Array<Property | SpreadElement>;
-}
-
-export interface PrivateIdentifier extends BaseNode {
-    type: "PrivateIdentifier";
-    name: string;
-}
-
-export interface Property extends BaseNode {
-    type: "Property";
-    key: Expression;
-    value: Expression | Pattern;
-    kind: "init" | "get" | "set";
-    method: boolean;
-    shorthand: boolean;
-    computed: boolean;
-    decorators?: Decorator[];
-}
-
-export interface PropertyDefinition extends BaseNode, TSClassMemberFields {
-    type: "PropertyDefinition";
-    key: Expression | PrivateIdentifier;
-    value?: Expression | null | undefined;
-    computed: boolean;
-    static: boolean;
-    typeAnnotation?: TSTypeAnnotation;
-    definite?: boolean;
-}
-
-export interface FunctionExpression extends BaseFunction, BaseExpression {
-    id?: Identifier | null | undefined;
-    type: "FunctionExpression";
-    body: BlockStatement;
-    expression: false;
-}
-
-export interface SequenceExpression extends BaseExpression {
-    type: "SequenceExpression";
-    expressions: Expression[];
-}
-
-export interface UnaryExpression extends BaseExpression {
-    type: "UnaryExpression";
-    operator: UnaryOperator;
-    prefix: true;
-    argument: Expression;
-}
-
-export interface BinaryExpression extends BaseExpression {
-    type: "BinaryExpression";
-    operator: BinaryOperator;
-    left: Expression | PrivateIdentifier;
-    right: Expression;
-}
-
-export interface AssignmentExpression extends BaseExpression {
-    type: "AssignmentExpression";
-    operator: AssignmentOperator;
-    left: Pattern | MemberExpression | TSAsExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
-    right: Expression;
-}
-
-export interface UpdateExpression extends BaseExpression {
-    type: "UpdateExpression";
-    operator: UpdateOperator;
-    argument: Expression;
-    prefix: boolean;
-}
-
-export interface LogicalExpression extends BaseExpression {
-    type: "LogicalExpression";
-    operator: LogicalOperator;
-    left: Expression;
-    right: Expression;
-}
-
-export interface ConditionalExpression extends BaseExpression {
-    type: "ConditionalExpression";
-    test: Expression;
-    alternate: Expression;
-    consequent: Expression;
-}
-
-export interface BaseCallExpression extends BaseExpression {
-    callee: Expression | Super;
-    arguments: Array<Expression | SpreadElement>;
-    typeArguments?: TSTypeParameterInstantiation;
-}
-
-export type CallExpression = SimpleCallExpression | NewExpression;
-
-export interface SimpleCallExpression extends BaseCallExpression {
-    type: "CallExpression";
-    /** Absent in a decorator, and on a call with type arguments, as in acorn-typescript. */
-    optional?: boolean;
-}
-
-export interface NewExpression extends BaseCallExpression {
-    type: "NewExpression";
-}
-
-export 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;
-}
-
-export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-
-export interface BasePattern extends BaseNode {
-}
-
-export interface SwitchCase extends BaseNode {
-    type: "SwitchCase";
-    test?: Expression | null | undefined;
-    consequent: Statement[];
-}
-
-export interface CatchClause extends BaseNode {
-    type: "CatchClause";
-    param: Pattern | null;
-    body: BlockStatement;
-}
-
-export interface Identifier extends BaseNode, BaseExpression, BasePattern, TSBindingFields {
-    type: "Identifier";
-    name: string;
-}
-
-export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-
-export interface SimpleLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value: string | boolean | number | null;
-    raw?: string | undefined;
-}
-
-/** A string `Literal`: a module specifier, an import attribute, or a quoted module export name. */
-export interface StringLiteral extends SimpleLiteral {
-    value: string;
-}
-
-export interface RegExpLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: RegExp | null | undefined;
-    regex: {
-        pattern: string;
-        flags: string;
-    };
-    raw?: string | undefined;
-}
-
-export interface BigIntLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: bigint | null | undefined;
-    bigint: string;
-    raw?: string | undefined;
-}
-
-export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-
-export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-
-export type LogicalOperator = "||" | "&&" | "??";
-
-export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-
-export type UpdateOperator = "++" | "--";
-
-export interface ForOfStatement extends BaseForXStatement {
-    type: "ForOfStatement";
-    await: boolean;
-}
-
-export interface Super extends BaseNode {
-    type: "Super";
-}
-
-export interface SpreadElement extends BaseNode {
-    type: "SpreadElement";
-    argument: Expression;
-}
-
-export 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[];
-}
-
-export interface YieldExpression extends BaseExpression {
-    type: "YieldExpression";
-    argument?: Expression | null | undefined;
-    delegate: boolean;
-}
-
-export interface TemplateLiteral extends BaseExpression {
-    type: "TemplateLiteral";
-    quasis: TemplateElement[];
-    expressions: Expression[];
-}
-
-export interface TaggedTemplateExpression extends BaseExpression {
-    type: "TaggedTemplateExpression";
-    tag: Expression;
-    quasi: TemplateLiteral;
-    typeArguments?: TSTypeParameterInstantiation;
-}
-
-export 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;
-    };
-}
-
-export interface AssignmentProperty extends Property {
-    value: Pattern;
-    kind: "init";
-    method: boolean;
-}
-
-export interface ObjectPattern extends BasePattern, TSBindingFields {
-    type: "ObjectPattern";
-    properties: Array<AssignmentProperty | RestElement>;
-}
-
-export interface ArrayPattern extends BasePattern, TSBindingFields {
-    type: "ArrayPattern";
-    elements: Array<Pattern | null>;
-}
-
-export interface RestElement extends BasePattern, TSBindingFields {
-    type: "RestElement";
-    argument: Pattern;
-}
-
-export interface AssignmentPattern extends BasePattern {
-    type: "AssignmentPattern";
-    left: Pattern;
-    right: Expression;
-    decorators?: Decorator[];
-}
-
-export type Class = ClassDeclaration | ClassExpression;
-
-export interface BaseClass extends BaseNode, TSClassFields {
-    superClass?: Expression | null | undefined;
-    body: ClassBody;
-}
-
-export interface ClassBody extends BaseNode {
-    type: "ClassBody";
-    body: Array<MethodDefinition | PropertyDefinition | StaticBlock | TSIndexSignature>;
-}
-
-export interface MethodDefinition extends BaseNode, TSClassMemberFields {
-    type: "MethodDefinition";
-    key: Expression | PrivateIdentifier;
-    value: FunctionExpression | TSDeclareMethod;
-    kind: "constructor" | "method" | "get" | "set";
-    computed: boolean;
-    static: boolean;
-    typeParameters?: TSTypeParameterDeclaration;
-}
-
-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;
-}
-
-export interface ClassDeclaration extends MaybeNamedClassDeclaration {
-    id: Identifier;
-}
-
-export interface ClassExpression extends BaseClass, BaseExpression {
-    type: "ClassExpression";
-    id?: Identifier | null | undefined;
-}
-
-export interface MetaProperty extends BaseExpression {
-    type: "MetaProperty";
-    meta: Identifier;
-    property: Identifier;
-}
-
-export type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration | TSModuleDeclarationStatement;
-
-export interface BaseModuleDeclaration extends BaseNode {
-}
-
-export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-
-export interface BaseModuleSpecifier extends BaseNode {
-    local: Identifier;
-}
-
-export 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";
-}
-
-export interface ImportSpecifier extends BaseModuleSpecifier {
-    type: "ImportSpecifier";
-    imported: Identifier | StringLiteral;
-    importKind?: "type" | "value";
-}
-
-export interface ImportAttribute extends BaseNode {
-    type: "ImportAttribute";
-    key: Identifier | StringLiteral;
-    value: StringLiteral;
-}
-
-export interface ImportExpression extends BaseExpression {
-    type: "ImportExpression";
-    source: Expression;
-    options?: Expression | null | undefined;
-    /** The import attributes, with `typescript: true`; `options` otherwise. */
-    arguments?: Expression[];
-}
-
-export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-    type: "ImportDefaultSpecifier";
-}
-
-export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-    type: "ImportNamespaceSpecifier";
-}
-
-export 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";
-}
-
-export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-    type: "ExportSpecifier";
-    local: Identifier | StringLiteral;
-    exported: Identifier | StringLiteral;
-    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 | StringLiteral | null;
-    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
-    attributes?: ImportAttribute[] | undefined;
-    source: StringLiteral;
-    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: StringLiteral;
-    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 | StringLiteral;
-    initializer?: Expression;
-}
-
-/** `namespace A {}`, `module "a" {}`, `declare global {}`; `namespace A.B {}` nests through `body`. */
-export interface TSModuleDeclaration extends BaseNode {
-    type: "TSModuleDeclaration";
-    id: Identifier | StringLiteral;
-    /** 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: StringLiteral;
-}
-
-/** `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;
-}
-
-/** `f<T>` without a call. */
-export interface TSInstantiationExpression extends BaseNode {
-    type: "TSInstantiationExpression";
-    expression: Expression;
-    typeArguments: TSTypeParameterInstantiation;
-}
-
-type Namespace = "html" | "svg" | "mathml";
+type Namespace = "html" | "svg" | "mathml";
 
 export declare namespace AST {
     export interface BaseNode {
@@ -1509,164 +418,1319 @@ export declare namespace AST {
     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 };
+        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;
+}
+
+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;
+}
+
+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 interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+export interface BaseFunction extends BaseNode, TSFunctionFields {
+    params: Array<Pattern | TSParameterProperty>;
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    body: BlockStatement | Expression;
+}
+
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+export type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+
+export interface BaseStatement extends BaseNode {
+}
+
+export interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+export interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+export interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+export interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+export interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+export interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+export interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | TSDeclaration;
+
+export interface BaseDeclaration extends BaseStatement {
+}
+
+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;
+    /** No `TSParameterProperty`: `private x` only parses in a class constructor, a `FunctionExpression`. */
+    params: Pattern[];
+}
+
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const" | "using" | "await using";
+    declare?: boolean;
+}
+
+export interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+    definite?: boolean;
+}
+
+export 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;
+}
+
+export type Expression = ExpressionMap[keyof ExpressionMap];
+
+export interface BaseExpression extends BaseNode {
+}
+
+export type ChainElement = SimpleCallExpression | MemberExpression;
+
+export interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+export interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+export interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+export interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+export interface Property extends BaseNode {
+    type: "Property";
+    key: Expression;
+    value: Expression | Pattern;
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    decorators?: Decorator[];
+}
+
+export interface PropertyDefinition extends BaseNode, TSClassMemberFields {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+    typeAnnotation?: TSTypeAnnotation;
+    definite?: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+    expression: false;
+}
+
+export interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+export interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression | PrivateIdentifier;
+    right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression | TSAsExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
+    right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+export interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    /** Absent in a decorator, and on a call with type arguments, as in acorn-typescript. */
+    optional?: boolean;
+}
+
+export interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+export 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;
+}
+
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+export interface BasePattern extends BaseNode {
+}
+
+export interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+export interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern, TSBindingFields {
+    type: "Identifier";
+    name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+/** A string `Literal`: a module specifier, an import attribute, or a quoted module export name. */
+export interface StringLiteral extends SimpleLiteral {
+    value: string;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+export interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+
+export type LogicalOperator = "||" | "&&" | "??";
+
+export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+export interface Super extends BaseNode {
+    type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+export 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[];
+}
+
+export interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export 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;
+    };
+}
+
+export interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean;
+}
+
+export interface ObjectPattern extends BasePattern, TSBindingFields {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+export interface ArrayPattern extends BasePattern, TSBindingFields {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+export interface RestElement extends BasePattern, TSBindingFields {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+    decorators?: Decorator[];
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+
+export interface BaseClass extends BaseNode, TSClassFields {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock | TSIndexSignature>;
+}
+
+export interface MethodDefinition extends BaseNode, TSClassMemberFields {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression | TSDeclareMethod;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+    typeParameters?: TSTypeParameterDeclaration;
+}
+
+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;
+}
+
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+export interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+export type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration | TSModuleDeclarationStatement;
+
+export interface BaseModuleDeclaration extends BaseNode {
+}
+
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+
+export interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+export 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";
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | StringLiteral;
+    importKind?: "type" | "value";
+}
+
+export interface ImportAttribute extends BaseNode {
+    type: "ImportAttribute";
+    key: Identifier | StringLiteral;
+    value: StringLiteral;
+}
+
+export interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+    options?: Expression | null | undefined;
+    /** The import attributes, with `typescript: true`; `options` otherwise. */
+    arguments?: Expression[];
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+export 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";
+}
+
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | StringLiteral;
+    exported: Identifier | StringLiteral;
+    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 | StringLiteral | null;
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
+    source: StringLiteral;
+    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: StringLiteral;
+    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 | StringLiteral;
+    initializer?: Expression;
+}
+
+/** `namespace A {}`, `module "a" {}`, `declare global {}`; `namespace A.B {}` nests through `body`. */
+export interface TSModuleDeclaration extends BaseNode {
+    type: "TSModuleDeclaration";
+    id: Identifier | StringLiteral;
+    /** Absent for `declare module "a";`. */
+    body?: TSModuleBlock | TSModuleDeclaration;
+    declare?: boolean;
+    global?: boolean;
 }
 
-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;
+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: StringLiteral;
+}
+
+/** `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;
+}
+
+/** `f<T>` without a call. */
+export interface TSInstantiationExpression extends BaseNode {
+    type: "TSInstantiationExpression";
+    expression: Expression;
+    typeArguments: TSTypeParameterInstantiation;
 }
 
+/**
+ * Parses only a module's top-level `import` and `export` statements, e.g.
+ * to rewrite or follow its imports, and skips the rest without building
+ * it. Each node is the one {@link parseModule} returns for the statement
+ * with `comments: false`: `ImportDeclaration`, `ExportNamedDeclaration`,
+ * `ExportDefaultDeclaration` and `ExportAllDeclaration`, plus, with
+ * `typescript: true`, `TSImportEqualsDeclaration`, `TSExportAssignment`
+ * and `TSNamespaceExportDeclaration`. `import(...)` and `import.meta`
+ * aren't statements, so they aren't returned.
+ *
+ * Throws a {@link ParseError} (`js_parse_error`) on a syntax error in one
+ * of those statements. Syntax errors in the rest aren't reported.
+ */
+export declare function parseImportsExports(source: string, options?: ParseImportsExportsOptions): ModuleDeclaration[];
+
 /**
  * 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>`:
@@ -1675,12 +1739,7 @@ declare namespace _CSS {
  *
  * 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;
+export declare function parseModule(source: string, options?: ParseModuleOptions): Program;
 
 type NodeLike = number | {
     start?: number;
@@ -1716,3 +1775,271 @@ interface Location {
     column: number;
     character: number;
 }
+
+/**
+ * The fields of each node type that hold child nodes, in source order.
+ * Typed against the AST, so a node type without an entry, or a key that
+ * isn't one of its fields, fails typechecking. `tests/walk.test.ts` checks
+ * the rest against the corpus: no field that holds a node is missing, and
+ * children come in source order.
+ */
+export declare const visitorKeys: {
+    readonly Root: readonly ["module", "instance", "fragment", "css"];
+    readonly Script: readonly ["attributes", "content"];
+    readonly Fragment: readonly ["nodes"];
+    readonly Text: readonly [];
+    readonly Comment: readonly [];
+    readonly ExpressionTag: readonly ["expression"];
+    readonly HtmlTag: readonly ["expression"];
+    readonly ConstTag: readonly ["declaration"];
+    readonly DeclarationTag: readonly ["declaration"];
+    readonly DebugTag: readonly ["identifiers"];
+    readonly RenderTag: readonly ["expression"];
+    readonly AttachTag: readonly ["expression"];
+    readonly Attribute: readonly ["value"];
+    readonly SpreadAttribute: readonly ["expression"];
+    readonly AnimateDirective: readonly ["expression"];
+    readonly BindDirective: readonly ["expression"];
+    readonly ClassDirective: readonly ["expression"];
+    readonly LetDirective: readonly ["expression"];
+    readonly OnDirective: readonly ["expression"];
+    readonly StyleDirective: readonly ["value"];
+    readonly TransitionDirective: readonly ["expression"];
+    readonly UseDirective: readonly ["expression"];
+    readonly Component: readonly ["attributes", "fragment"];
+    readonly TitleElement: readonly ["attributes", "fragment"];
+    readonly SlotElement: readonly ["attributes", "fragment"];
+    readonly RegularElement: readonly ["attributes", "fragment"];
+    readonly SvelteBody: readonly ["attributes", "fragment"];
+    readonly SvelteBoundary: readonly ["attributes", "fragment"];
+    readonly SvelteComponent: readonly ["expression", "attributes", "fragment"];
+    readonly SvelteDocument: readonly ["attributes", "fragment"];
+    readonly SvelteElement: readonly ["tag", "attributes", "fragment"];
+    readonly SvelteFragment: readonly ["attributes", "fragment"];
+    readonly SvelteHead: readonly ["attributes", "fragment"];
+    readonly SvelteOptions: readonly ["attributes", "fragment"];
+    readonly SvelteSelf: readonly ["attributes", "fragment"];
+    readonly SvelteWindow: readonly ["attributes", "fragment"];
+    readonly IfBlock: readonly ["test", "consequent", "alternate"];
+    readonly EachBlock: readonly ["expression", "context", "key", "body", "fallback"];
+    readonly AwaitBlock: readonly ["expression", "pending", "value", "then", "error", "catch"];
+    readonly KeyBlock: readonly ["expression", "fragment"];
+    readonly SnippetBlock: readonly ["expression", "parameters", "body"];
+    readonly StyleSheet: readonly ["attributes", "children"];
+    readonly Rule: readonly ["prelude", "block"];
+    readonly Atrule: readonly ["block"];
+    readonly SelectorList: readonly ["children"];
+    readonly ComplexSelector: readonly ["children"];
+    readonly RelativeSelector: readonly ["combinator", "selectors"];
+    readonly Combinator: readonly [];
+    readonly TypeSelector: readonly [];
+    readonly IdSelector: readonly [];
+    readonly ClassSelector: readonly [];
+    readonly AttributeSelector: readonly [];
+    readonly PseudoElementSelector: readonly ["args"];
+    readonly PseudoClassSelector: readonly ["args"];
+    readonly Percentage: readonly [];
+    readonly Nth: readonly [];
+    readonly NestingSelector: readonly [];
+    readonly Block: readonly ["children"];
+    readonly Declaration: readonly [];
+    readonly Program: readonly ["body"];
+    readonly ExpressionStatement: readonly ["expression"];
+    readonly BlockStatement: readonly ["body"];
+    readonly StaticBlock: readonly ["body"];
+    readonly EmptyStatement: readonly [];
+    readonly DebuggerStatement: readonly [];
+    readonly WithStatement: readonly ["object", "body"];
+    readonly ReturnStatement: readonly ["argument"];
+    readonly LabeledStatement: readonly ["label", "body"];
+    readonly BreakStatement: readonly ["label"];
+    readonly ContinueStatement: readonly ["label"];
+    readonly IfStatement: readonly ["test", "consequent", "alternate"];
+    readonly SwitchStatement: readonly ["discriminant", "cases"];
+    readonly SwitchCase: readonly ["test", "consequent"];
+    readonly ThrowStatement: readonly ["argument"];
+    readonly TryStatement: readonly ["block", "handler", "finalizer"];
+    readonly CatchClause: readonly ["param", "body"];
+    readonly WhileStatement: readonly ["test", "body"];
+    readonly DoWhileStatement: readonly ["body", "test"];
+    readonly ForStatement: readonly ["init", "test", "update", "body"];
+    readonly ForInStatement: readonly ["left", "right", "body"];
+    readonly ForOfStatement: readonly ["left", "right", "body"];
+    readonly FunctionDeclaration: readonly ["id", "typeParameters", "params", "returnType", "body"];
+    readonly FunctionExpression: readonly ["id", "typeParameters", "params", "returnType", "body"];
+    readonly ArrowFunctionExpression: readonly ["typeParameters", "params", "returnType", "body"];
+    readonly VariableDeclaration: readonly ["declarations"];
+    readonly VariableDeclarator: readonly ["id", "init"];
+    readonly ClassDeclaration: readonly ["decorators", "id", "typeParameters", "superClass", "superTypeParameters", "implements", "body"];
+    readonly ClassExpression: readonly ["decorators", "id", "typeParameters", "superClass", "superTypeParameters", "implements", "body"];
+    readonly ClassBody: readonly ["body"];
+    readonly MethodDefinition: readonly ["decorators", "key", "typeParameters", "value"];
+    readonly PropertyDefinition: readonly ["decorators", "key", "typeAnnotation", "value"];
+    readonly Property: readonly ["decorators", "key", "value"];
+    readonly ThisExpression: readonly [];
+    readonly Super: readonly [];
+    readonly Literal: readonly [];
+    readonly Identifier: readonly ["decorators", "typeAnnotation"];
+    readonly PrivateIdentifier: readonly [];
+    readonly ArrayExpression: readonly ["elements"];
+    readonly ObjectExpression: readonly ["properties"];
+    readonly UnaryExpression: readonly ["argument"];
+    readonly UpdateExpression: readonly ["argument"];
+    readonly BinaryExpression: readonly ["left", "right"];
+    readonly LogicalExpression: readonly ["left", "right"];
+    readonly AssignmentExpression: readonly ["left", "right"];
+    readonly MemberExpression: readonly ["object", "property"];
+    readonly ConditionalExpression: readonly ["test", "consequent", "alternate"];
+    readonly CallExpression: readonly ["callee", "typeArguments", "arguments"];
+    readonly NewExpression: readonly ["callee", "typeArguments", "arguments"];
+    readonly SequenceExpression: readonly ["expressions"];
+    readonly TemplateLiteral: readonly ["quasis", "expressions"];
+    readonly TaggedTemplateExpression: readonly ["tag", "typeArguments", "quasi"];
+    readonly TemplateElement: readonly [];
+    readonly SpreadElement: readonly ["argument"];
+    readonly RestElement: readonly ["decorators", "argument", "typeAnnotation"];
+    readonly YieldExpression: readonly ["argument"];
+    readonly AwaitExpression: readonly ["argument"];
+    readonly ImportExpression: readonly ["source", "options", "arguments"];
+    readonly ChainExpression: readonly ["expression"];
+    readonly MetaProperty: readonly ["meta", "property"];
+    readonly ObjectPattern: readonly ["decorators", "properties", "typeAnnotation"];
+    readonly ArrayPattern: readonly ["decorators", "elements", "typeAnnotation"];
+    readonly AssignmentPattern: readonly ["decorators", "left", "right"];
+    readonly ImportDeclaration: readonly ["specifiers", "source", "attributes"];
+    readonly ImportSpecifier: readonly ["imported", "local"];
+    readonly ImportDefaultSpecifier: readonly ["local"];
+    readonly ImportNamespaceSpecifier: readonly ["local"];
+    readonly ImportAttribute: readonly ["key", "value"];
+    readonly ExportNamedDeclaration: readonly ["declaration", "specifiers", "source", "attributes"];
+    readonly ExportSpecifier: readonly ["local", "exported"];
+    readonly ExportDefaultDeclaration: readonly ["declaration"];
+    readonly ExportAllDeclaration: readonly ["exported", "source", "attributes"];
+    readonly Decorator: readonly ["expression"];
+    readonly TSTypeAnnotation: readonly ["typeAnnotation"];
+    readonly TSTypeParameterDeclaration: readonly ["params"];
+    readonly TSTypeParameterInstantiation: readonly ["params"];
+    readonly TSTypeParameter: readonly ["constraint", "default"];
+    readonly TSAnyKeyword: readonly [];
+    readonly TSBigIntKeyword: readonly [];
+    readonly TSBooleanKeyword: readonly [];
+    readonly TSNeverKeyword: readonly [];
+    readonly TSNullKeyword: readonly [];
+    readonly TSNumberKeyword: readonly [];
+    readonly TSObjectKeyword: readonly [];
+    readonly TSStringKeyword: readonly [];
+    readonly TSSymbolKeyword: readonly [];
+    readonly TSUndefinedKeyword: readonly [];
+    readonly TSUnknownKeyword: readonly [];
+    readonly TSVoidKeyword: readonly [];
+    readonly TSThisType: readonly [];
+    readonly TSArrayType: readonly ["elementType"];
+    readonly TSTupleType: readonly ["elementTypes"];
+    readonly TSNamedTupleMember: readonly ["label", "elementType"];
+    readonly TSOptionalType: readonly ["typeAnnotation"];
+    readonly TSRestType: readonly ["typeAnnotation"];
+    readonly TSUnionType: readonly ["types"];
+    readonly TSIntersectionType: readonly ["types"];
+    readonly TSConditionalType: readonly ["checkType", "extendsType", "trueType", "falseType"];
+    readonly TSInferType: readonly ["typeParameter"];
+    readonly TSParenthesizedType: readonly ["typeAnnotation"];
+    readonly TSTypeOperator: readonly ["typeAnnotation"];
+    readonly TSIndexedAccessType: readonly ["objectType", "indexType"];
+    readonly TSMappedType: readonly ["typeParameter", "nameType", "typeAnnotation"];
+    readonly TSLiteralType: readonly ["literal"];
+    readonly TSTypeReference: readonly ["typeName", "typeArguments"];
+    readonly TSQualifiedName: readonly ["left", "right"];
+    readonly TSTypeQuery: readonly ["exprName", "typeArguments"];
+    readonly TSImportType: readonly ["argument", "qualifier", "typeArguments"];
+    readonly TSTypeLiteral: readonly ["members"];
+    readonly TSPropertySignature: readonly ["key", "typeAnnotation"];
+    readonly TSMethodSignature: readonly ["key", "typeParameters", "parameters", "typeAnnotation"];
+    readonly TSCallSignatureDeclaration: readonly ["typeParameters", "parameters", "typeAnnotation"];
+    readonly TSConstructSignatureDeclaration: readonly ["typeParameters", "parameters", "typeAnnotation"];
+    readonly TSFunctionType: readonly ["typeParameters", "parameters", "typeAnnotation"];
+    readonly TSConstructorType: readonly ["typeParameters", "parameters", "typeAnnotation"];
+    readonly TSIndexSignature: readonly ["decorators", "parameters", "typeAnnotation"];
+    readonly TSTypePredicate: readonly ["parameterName", "typeAnnotation"];
+    readonly TSInterfaceDeclaration: readonly ["id", "typeParameters", "extends", "body"];
+    readonly TSInterfaceBody: readonly ["body"];
+    readonly TSExpressionWithTypeArguments: readonly ["expression", "typeParameters"];
+    readonly TSTypeAliasDeclaration: readonly ["id", "typeParameters", "typeAnnotation"];
+    readonly TSEnumDeclaration: readonly ["id", "members"];
+    readonly TSEnumMember: readonly ["id", "initializer"];
+    readonly TSModuleDeclaration: readonly ["id", "body"];
+    readonly TSModuleBlock: readonly ["body"];
+    readonly TSImportEqualsDeclaration: readonly ["id", "moduleReference"];
+    readonly TSExternalModuleReference: readonly ["expression"];
+    readonly TSExportAssignment: readonly ["expression"];
+    readonly TSNamespaceExportDeclaration: readonly ["id"];
+    readonly TSDeclareFunction: readonly ["id", "typeParameters", "params", "returnType"];
+    readonly TSDeclareMethod: readonly ["typeParameters", "params", "returnType"];
+    readonly TSParameterProperty: readonly ["parameter"];
+    readonly TSAsExpression: readonly ["expression", "typeAnnotation"];
+    readonly TSSatisfiesExpression: readonly ["expression", "typeAnnotation"];
+    readonly TSTypeAssertion: readonly ["typeAnnotation", "expression"];
+    readonly TSNonNullExpression: readonly ["expression"];
+    readonly TSInstantiationExpression: readonly ["expression", "typeArguments"];
+};
+
+/**
+ * Return it from `enter` or `leave` to end the walk: no further `enter` or
+ * `leave` calls, including `leave` on the node's ancestors.
+ */
+export declare const STOP: unique symbol;
+
+/**
+ * Return it from `enter` to skip the node's children; `leave` is still
+ * called on the node.
+ */
+export declare const SKIP: unique symbol;
+
+/** The callbacks {@link walk} calls for each node. */
+export interface Visitor {
+    /**
+     * Called before the node's children. Return {@link SKIP} to skip them;
+     * `leave` is still called, so the two stay paired. Return {@link STOP} to
+     * end the walk. Return another node to put it in this one's place: `walk`
+     * writes it to `parent[key]` (or `parent[key][index]`), then calls `enter`
+     * on it and visits its children instead. Any other value, `false`
+     * included, is ignored, so `(node) => node.type === "Component" &&
+     * names.add(node.name)` visits every node.
+     */
+    enter?(node: AST.SvelteNode, parent: AST.SvelteNode | null, key: string | null, index: number | null): unknown;
+    /** Called after the node's children. Return {@link STOP} to end the walk. */
+    leave?(node: AST.SvelteNode, parent: AST.SvelteNode | null, key: string | null, index: number | null): unknown;
+}
+
+/**
+ * Visits `node` and its descendants depth-first, in source order, calling
+ * `visitor.enter` before a node's children and `visitor.leave` after them.
+ * `parent[key]` is the node, or `parent[key][index]` when the field is an
+ * array; all three are `null` for `node` itself.
+ */
+export declare function walk(node: AST.SvelteNode, visitor: Visitor): void;
+
+/**
+ * The `Identifier` nodes a pattern binds, in source order: `a`, `c`, `d`,
+ * `e` and `f` in `{ a, b: [c, ...d], e = 1, ...f }`. Not the property
+ * keys, defaults or type annotations. A member expression, which an
+ * assignment's pattern can hold, as in `[a.b] = c`, binds nothing, so it
+ * yields no identifiers, as in svelte's `extract_identifiers`. Also takes
+ * a function's params as they are, parameter properties included, and an
+ * assignment's `left`, where `a!`, `a as T`, `a satisfies T` and `<T>a`
+ * yield `a`.
+ */
+export declare function extractIdentifiers(pattern: Pattern | TSParameterProperty | AssignmentExpression["left"]): Identifier[];
+
+/**
+ * Whether `node` is an `Identifier` that names a binding in the value
+ * namespace, where it's declared or where it's used, given its `parent`
+ * from `walk`. `false` for a property, method or label name, the
+ * renamed side of an import or export specifier, `import.meta`'s and
+ * `new.target`'s names, an import attribute's key, and every name in a
+ * type. The check svelte's analyzer makes, from the `is-reference` package,
+ * plus TypeScript: an `Identifier` whose parent is a TypeScript node is a
+ * reference only as the expression of `as`, `satisfies`, `<T>x`, `x!`,
+ * `f<T>` or `export =`, an enum member's initializer, a parameter
+ * property, an enum's name, or the name or target of `import a = b`.
+ */
+export declare function isReference(node: AST.SvelteNode, parent: AST.SvelteNode | null): boolean;