sveast 0.0.0 → 0.1.0

package/index.d.ts

@@ -0,0 +1,1156 @@
+/**
+ * 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;
+
+interface SourceLocation {
+    start: Location;
+    end: Location;
+}
+
+interface Identifier {
+    type: "Identifier";
+    name: string;
+    start: number;
+    end: number;
+    loc?: SourceLocation;
+}
+
+/**
+ * Options for {@link parse}. The defaults give svelte's own output, minus
+ * `loc` and `name_loc`.
+ */
+export interface ParseOptions {
+    /**
+     * Add `loc` (line/column) to script and expression nodes, and `name_loc`
+     * to elements, attributes and directives, as svelte does. Off by default:
+     * it makes parsing slower and the AST larger.
+     */
+    loc?: boolean;
+    /**
+     * Parse `<style>` into rules and selectors (`css.children`). With `false`,
+     * `css` still has its `start`, `end` and `content`, but `children` and
+     * `comments` are empty and CSS syntax errors aren't reported. Default `true`.
+     */
+    css?: boolean;
+}
+
+interface Location {
+    line: number;
+    column: number;
+    character: number;
+}
+
+type Namespace = "html" | "svg" | "mathml";
+
+export declare namespace AST {
+    export interface BaseNode {
+        type: string;
+        start: number;
+        end: number;
+    }
+    export interface Fragment {
+        type: "Fragment";
+        nodes: Array<Text | Tag | ElementLike | Block | Comment>;
+    }
+    export interface Root extends BaseNode {
+        type: "Root";
+        /**
+         * Inline options provided by `<svelte:options>` — these override options passed to `compile(...)`
+         */
+        options: SvelteOptions | null;
+        fragment: Fragment;
+        /** The parsed `<style>` element, if exists */
+        css: AST.CSS.StyleSheet | null;
+        /** The parsed `<script>` element, if exists */
+        instance?: Script | null;
+        /** The parsed `<script module>` element, if exists */
+        module?: Script | null;
+        /** Comments found in <script> and {expressions} */
+        comments: JSComment[];
+    }
+    export interface SvelteOptions {
+        start: number;
+        end: number;
+        runes?: boolean;
+        immutable?: boolean;
+        accessors?: boolean;
+        preserveWhitespace?: boolean;
+        namespace?: Namespace;
+        css?: "injected";
+        customElement?: {
+            tag?: string;
+            shadow?: "open" | "none" | ObjectExpression | undefined;
+            props?: Record<string, {
+                attribute?: string;
+                reflect?: boolean;
+                type?: "Array" | "Boolean" | "Number" | "Object" | "String";
+            }>;
+            /**
+             * Is of type
+             * ```ts
+             * (ceClass: new () => HTMLElement) => new () => HTMLElement
+             * ```
+             */
+            extend?: ArrowFunctionExpression | Identifier;
+        };
+        attributes: Attribute[];
+    }
+    /** Static text */
+    export interface Text extends BaseNode {
+        type: "Text";
+        /** Text with decoded HTML entities */
+        data: string;
+        /** The original text, with undecoded HTML entities */
+        raw: string;
+    }
+    /** A (possibly reactive) template expression — `{...}` */
+    export interface ExpressionTag extends BaseNode {
+        type: "ExpressionTag";
+        expression: Expression;
+    }
+    /** A (possibly reactive) HTML template expression — `{@html ...}` */
+    export interface HtmlTag extends BaseNode {
+        type: "HtmlTag";
+        expression: Expression;
+    }
+    /** An HTML comment */
+    export interface Comment extends BaseNode {
+        type: "Comment";
+        /** the contents of the comment */
+        data: string;
+    }
+    /** A `{@const ...}` tag */
+    export interface ConstTag extends BaseNode {
+        type: "ConstTag";
+        declaration: VariableDeclaration & {
+            declarations: [VariableDeclarator & {
+                id: Pattern;
+                init: Expression;
+            }];
+        };
+    }
+    /** A `{let ...}` or `{const ...}` tag */
+    export interface DeclarationTag extends BaseNode {
+        type: "DeclarationTag";
+        declaration: VariableDeclaration;
+    }
+    /** A `{@debug ...}` tag */
+    export interface DebugTag extends BaseNode {
+        type: "DebugTag";
+        identifiers: Identifier[];
+    }
+    /** A `{@render foo(...)} tag */
+    export interface RenderTag extends BaseNode {
+        type: "RenderTag";
+        expression: SimpleCallExpression | (ChainExpression & {
+            expression: SimpleCallExpression;
+        });
+    }
+    /** A `{@attach foo(...)} tag */
+    export interface AttachTag extends BaseNode {
+        type: "AttachTag";
+        expression: Expression;
+    }
+    /** An `animate:` directive */
+    export interface AnimateDirective extends BaseAttribute {
+        type: "AnimateDirective";
+        /** The 'x' in `animate:x` */
+        name: string;
+        /** The y in `animate:x={y}` */
+        expression: null | Expression;
+    }
+    /** A `bind:` directive */
+    export interface BindDirective extends BaseAttribute {
+        type: "BindDirective";
+        /** The 'x' in `bind:x` */
+        name: string;
+        /** The y in `bind:x={y}` */
+        expression: Identifier | MemberExpression | SequenceExpression;
+    }
+    /** A `class:` directive */
+    export interface ClassDirective extends BaseAttribute {
+        type: "ClassDirective";
+        /** The 'x' in `class:x` */
+        name: "class";
+        /** The 'y' in `class:x={y}`, or the `x` in `class:x` */
+        expression: Expression;
+    }
+    /** A `let:` directive */
+    export interface LetDirective extends BaseAttribute {
+        type: "LetDirective";
+        /** The 'x' in `let:x` */
+        name: string;
+        /** The 'y' in `let:x={y}` */
+        expression: null | Identifier | ArrayExpression | ObjectExpression;
+    }
+    /** An `on:` directive */
+    export interface OnDirective extends BaseAttribute {
+        type: "OnDirective";
+        /** The 'x' in `on:x` */
+        name: string;
+        /** The 'y' in `on:x={y}` */
+        expression: null | Expression;
+        modifiers: Array<"capture" | "nonpassive" | "once" | "passive" | "preventDefault" | "self" | "stopImmediatePropagation" | "stopPropagation" | "trusted">;
+    }
+    /** A `style:` directive */
+    export interface StyleDirective extends BaseAttribute {
+        type: "StyleDirective";
+        /** The 'x' in `style:x` */
+        name: string;
+        /** The 'y' in `style:x={y}` */
+        value: true | ExpressionTag | Array<ExpressionTag | Text>;
+        modifiers: Array<"important">;
+    }
+    /** A `transition:`, `in:` or `out:` directive */
+    export interface TransitionDirective extends BaseAttribute {
+        type: "TransitionDirective";
+        /** The 'x' in `transition:x` */
+        name: string;
+        /** The 'y' in `transition:x={y}` */
+        expression: null | Expression;
+        modifiers: Array<"local" | "global">;
+        /** True if this is a `transition:` or `in:` directive */
+        intro: boolean;
+        /** True if this is a `transition:` or `out:` directive */
+        outro: boolean;
+    }
+    /** A `use:` directive */
+    export interface UseDirective extends BaseAttribute {
+        type: "UseDirective";
+        /** The 'x' in `use:x` */
+        name: string;
+        /** The 'y' in `use:x={y}` */
+        expression: null | Expression;
+    }
+    export interface BaseElement extends BaseNode {
+        name: string;
+        /** Only with `parse(source, { loc: true })`. */
+        name_loc?: SourceLocation;
+        attributes: Array<Attribute | SpreadAttribute | Directive | AttachTag>;
+        fragment: Fragment;
+    }
+    export interface Component extends BaseElement {
+        type: "Component";
+    }
+    export interface TitleElement extends BaseElement {
+        type: "TitleElement";
+        name: "title";
+    }
+    export interface SlotElement extends BaseElement {
+        type: "SlotElement";
+        name: "slot";
+    }
+    export interface RegularElement extends BaseElement {
+        type: "RegularElement";
+    }
+    export interface SvelteBody extends BaseElement {
+        type: "SvelteBody";
+        name: "svelte:body";
+    }
+    export interface SvelteComponent extends BaseElement {
+        type: "SvelteComponent";
+        name: "svelte:component";
+        expression: Expression;
+    }
+    export interface SvelteDocument extends BaseElement {
+        type: "SvelteDocument";
+        name: "svelte:document";
+    }
+    export interface SvelteElement extends BaseElement {
+        type: "SvelteElement";
+        name: "svelte:element";
+        tag: Expression;
+    }
+    export interface SvelteFragment extends BaseElement {
+        type: "SvelteFragment";
+        name: "svelte:fragment";
+    }
+    export interface SvelteBoundary extends BaseElement {
+        type: "SvelteBoundary";
+        name: "svelte:boundary";
+    }
+    export interface SvelteHead extends BaseElement {
+        type: "SvelteHead";
+        name: "svelte:head";
+    }
+    /** This is only an intermediate representation while parsing, it doesn't exist in the final AST */
+    export interface SvelteOptionsRaw extends BaseElement {
+        type: "SvelteOptions";
+        name: "svelte:options";
+    }
+    export interface SvelteSelf extends BaseElement {
+        type: "SvelteSelf";
+        name: "svelte:self";
+    }
+    export interface SvelteWindow extends BaseElement {
+        type: "SvelteWindow";
+        name: "svelte:window";
+    }
+    /** An `{#each ...}` block */
+    export interface EachBlock extends BaseNode {
+        type: "EachBlock";
+        expression: Expression;
+        /** The `entry` in `{#each item as entry}`. `null` if `as` part is omitted */
+        context: Pattern | null;
+        body: Fragment;
+        fallback?: Fragment;
+        index?: string;
+        key?: Expression;
+    }
+    /** An `{#if ...}` block */
+    export interface IfBlock extends BaseNode {
+        type: "IfBlock";
+        elseif: boolean;
+        test: Expression;
+        consequent: Fragment;
+        alternate: Fragment | null;
+    }
+    /** An `{#await ...}` block */
+    export interface AwaitBlock extends BaseNode {
+        type: "AwaitBlock";
+        expression: Expression;
+        /** The resolved value inside the `then` block */
+        value: Pattern | null;
+        /** The rejection reason inside the `catch` block */
+        error: Pattern | null;
+        pending: Fragment | null;
+        then: Fragment | null;
+        catch: Fragment | null;
+    }
+    export interface KeyBlock extends BaseNode {
+        type: "KeyBlock";
+        expression: Expression;
+        fragment: Fragment;
+    }
+    export interface SnippetBlock extends BaseNode {
+        type: "SnippetBlock";
+        expression: Identifier;
+        parameters: Pattern[];
+        typeParams?: string;
+        body: Fragment;
+    }
+    export interface BaseAttribute extends BaseNode {
+        name: string;
+        /** Only with `parse(source, { loc: true })`. */
+        name_loc?: SourceLocation | null;
+    }
+    export interface Attribute extends BaseAttribute {
+        type: "Attribute";
+        /**
+         * Quoted/string values are represented by an array, even if they contain a single expression like `"{x}"`
+         */
+        value: true | ExpressionTag | Array<Text | ExpressionTag>;
+    }
+    export interface SpreadAttribute extends BaseNode {
+        type: "SpreadAttribute";
+        expression: Expression;
+    }
+    export interface Script extends BaseNode {
+        type: "Script";
+        context: "default" | "module";
+        content: Program;
+        attributes: Attribute[];
+    }
+    export interface JSComment {
+        type: "Line" | "Block";
+        value: string;
+        start: number;
+        end: number;
+        /** Only with `parse(source, { loc: true })`. */
+        loc?: {
+            start: {
+                line: number;
+                column: number;
+            };
+            end: {
+                line: number;
+                column: number;
+            };
+        };
+    }
+    export type AttributeLike = Attribute | SpreadAttribute | Directive;
+    export type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
+    export type Block = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock;
+    export type ElementLike = AST.Component | AST.TitleElement | AST.SlotElement | AST.RegularElement | AST.SvelteBody | AST.SvelteBoundary | AST.SvelteComponent | AST.SvelteDocument | AST.SvelteElement | AST.SvelteFragment | AST.SvelteHead | AST.SvelteOptionsRaw | AST.SvelteSelf | AST.SvelteWindow | AST.SvelteBoundary;
+    export type Tag = AST.AttachTag | AST.ConstTag | AST.DeclarationTag | AST.DebugTag | AST.ExpressionTag | AST.HtmlTag | AST.RenderTag;
+    export type TemplateNode = AST.Root | AST.Text | Tag | ElementLike | AST.Attribute | AST.SpreadAttribute | Directive | AST.AttachTag | AST.Comment | Block;
+    export type SvelteNode = Node | TemplateNode | AST.Fragment | _CSS.Node | Script;
+    export type { _CSS as CSS };
+}
+
+declare namespace _CSS {
+    interface BaseNode {
+        start: number;
+        end: number;
+    }
+    interface StyleSheetBase extends BaseNode {
+        children: Array<Atrule | Rule>;
+        /** CSS comments in source order */
+        comments: CSSComment[];
+    }
+    interface CSSComment extends BaseNode {
+        type: "CSSComment";
+        value: string;
+        /** Character offset in a containing declaration value or at-rule prelude */
+        position?: number;
+    }
+    interface StyleSheetFile extends StyleSheetBase {
+        type: "StyleSheetFile";
+    }
+    interface StyleSheet extends StyleSheetBase {
+        type: "StyleSheet";
+        attributes: any[];
+        content: {
+            start: number;
+            end: number;
+            styles: string;
+            /** Possible comment atop the style tag */
+            comment: AST.Comment | null;
+        };
+    }
+    interface Atrule extends BaseNode {
+        type: "Atrule";
+        name: string;
+        prelude: string;
+        block: Block | null;
+    }
+    interface Rule extends BaseNode {
+        type: "Rule";
+        prelude: SelectorList;
+        block: Block;
+    }
+    /**
+     * A list of selectors, e.g. `a, b, c {}`
+     */
+    interface SelectorList extends BaseNode {
+        type: "SelectorList";
+        /**
+         * The `a`, `b` and `c` in `a, b, c {}`
+         */
+        children: ComplexSelector[];
+    }
+    /**
+     * A complex selector, e.g. `a b c {}`
+     */
+    interface ComplexSelector extends BaseNode {
+        type: "ComplexSelector";
+        /**
+         * The `a`, `b` and `c` in `a b c {}`
+         */
+        children: RelativeSelector[];
+    }
+    /**
+     * A relative selector, e.g the `a` and `> b` in `a > b {}`
+     */
+    interface RelativeSelector extends BaseNode {
+        type: "RelativeSelector";
+        /**
+         * In `a > b`, `> b` forms one relative selector, and `>` is the combinator. `null` for the first selector.
+         */
+        combinator: null | Combinator;
+        /**
+         * The `b:is(...)` in `> b:is(...)`
+         */
+        selectors: SimpleSelector[];
+    }
+    interface TypeSelector extends BaseNode {
+        type: "TypeSelector";
+        name: string;
+        namespace?: string;
+    }
+    interface IdSelector extends BaseNode {
+        type: "IdSelector";
+        name: string;
+    }
+    interface ClassSelector extends BaseNode {
+        type: "ClassSelector";
+        name: string;
+    }
+    interface AttributeSelector extends BaseNode {
+        type: "AttributeSelector";
+        name: string;
+        matcher: string | null;
+        value: string | null;
+        flags: string | null;
+    }
+    interface PseudoElementSelector extends BaseNode {
+        type: "PseudoElementSelector";
+        name: string;
+        args?: SelectorList;
+    }
+    interface PseudoClassSelector extends BaseNode {
+        type: "PseudoClassSelector";
+        name: string;
+        args: SelectorList | null;
+    }
+    interface Percentage extends BaseNode {
+        type: "Percentage";
+        value: string;
+    }
+    interface NestingSelector extends BaseNode {
+        type: "NestingSelector";
+        name: "&";
+    }
+    interface Nth extends BaseNode {
+        type: "Nth";
+        value: string;
+    }
+    type SimpleSelector = TypeSelector | IdSelector | ClassSelector | AttributeSelector | PseudoElementSelector | PseudoClassSelector | Percentage | Nth | NestingSelector;
+    interface Combinator extends BaseNode {
+        type: "Combinator";
+        name: string;
+    }
+    interface Block extends BaseNode {
+        type: "Block";
+        children: Array<Declaration | Rule | Atrule>;
+    }
+    interface Declaration extends BaseNode {
+        type: "Declaration";
+        property: string;
+        value: string;
+    }
+    type Node = StyleSheet | Rule | Atrule | SelectorList | Block | ComplexSelector | RelativeSelector | Combinator | SimpleSelector | Declaration;
+}
+
+interface BaseNodeWithoutComments {
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+}
+
+type Node = NodeMap[keyof NodeMap];
+
+interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+
+interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    body: BlockStatement | Expression;
+}
+
+type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+
+interface BaseStatement extends BaseNode {
+}
+
+interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+interface BaseDeclaration extends BaseStatement {
+}
+
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
+}
+
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const" | "using" | "await using";
+}
+
+interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+
+interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
+}
+
+type Expression = ExpressionMap[keyof ExpressionMap];
+
+interface BaseExpression extends BaseNode {
+}
+
+type ChainElement = SimpleCallExpression | MemberExpression;
+
+interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+interface Property extends BaseNode {
+    type: "Property";
+    key: Expression;
+    value: Expression | Pattern;
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+}
+
+interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+}
+
+interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+
+interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression | PrivateIdentifier;
+    right: Expression;
+}
+
+interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+
+interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+}
+
+type CallExpression = SimpleCallExpression | NewExpression;
+
+interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional: boolean;
+}
+
+interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
+}
+
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+interface BasePattern extends BaseNode {
+}
+
+interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+
+type LogicalOperator = "||" | "&&" | "??";
+
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+
+type UpdateOperator = "++" | "--";
+
+interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+interface Super extends BaseNode {
+    type: "Super";
+}
+
+interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+
+interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+
+interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+
+interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean;
+}
+
+interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+
+type Class = ClassDeclaration | ClassExpression;
+
+interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+
+interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+}
+
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+    type: "ClassDeclaration";
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
+}
+
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+
+interface BaseModuleDeclaration extends BaseNode {
+}
+
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+
+interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    attributes: ImportAttribute[];
+    source: Literal;
+}
+
+interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | Literal;
+}
+
+interface ImportAttribute extends BaseNode {
+    type: "ImportAttribute";
+    key: Identifier | Literal;
+    value: Literal;
+}
+
+interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+    options?: Expression | null | undefined;
+}
+
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    attributes: ImportAttribute[];
+    source?: Literal | null | undefined;
+}
+
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+}
+
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    attributes: ImportAttribute[];
+    source: Literal;
+}
+
+interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+
+type NodeLike = number | {
+    start?: number;
+    end?: number;
+} | null;
+
+/**
+ * Thrown for a syntax error. `code`, `message`, `position`, `start`, `end`
+ * and `frame` are what svelte/compiler's `CompileError` has for the same
+ * input.
+ */
+export declare class ParseError extends Error {
+    name: string;
+    /** svelte's error code, e.g. `"expected_token"` or `"block_unclosed"`. */
+    code: string;
+    /** `[start, end]` offsets into the source. */
+    position?: [number, number];
+    start?: Location;
+    end?: Location;
+    /** A few lines of source around the error, with a `^` under it. */
+    frame?: string;
+    constructor(node: NodeLike, code: string, message: string);
+}
+
+/**
+ * Parses a JavaScript or TypeScript module, e.g. a `.ts` file a component
+ * imports, into the same kind of AST as a component's `<script>`:
+ * estree, TypeScript nodes as in `@sveltejs/acorn-typescript`, and
+ * comments attached as `leadingComments`/`trailingComments`.
+ *
+ * Throws a {@link ParseError} (`js_parse_error`) on a syntax error.
+ */
+export declare function parseModule(source: string, options?: {
+    /** Parse TypeScript. Default `false`. */
+    typescript?: boolean;
+    /** Add `loc` (line/column) to every node. Default `false`. */
+    loc?: boolean;
+}): Program;