sveast 0.0.0 → 0.2.0

package/index.d.ts

@@ -0,0 +1,1686 @@
+/**
+ * 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`.
+ */
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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: Literal;
+    importKind?: "type" | "value";
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | Literal;
+    importKind?: "type" | "value";
+}
+
+export interface ImportAttribute extends BaseNode {
+    type: "ImportAttribute";
+    key: Identifier | Literal;
+    value: Literal;
+}
+
+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?: Literal | null | undefined;
+    exportKind?: "type" | "value";
+}
+
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+    exportKind?: "type" | "value";
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression | TSDeclareFunction | TSInterfaceDeclaration;
+    exportKind?: "type" | "value";
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    /** Absent with `typescript: true` unless there's a `with` clause, as in acorn-typescript. */
+    attributes?: ImportAttribute[] | undefined;
+    source: Literal;
+    exportKind?: "type" | "value";
+}
+
+export interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+
+export type TSNode = Decorator | TSTypeAnnotation | TypeNode | TSTypePredicate | TSNamedTupleMember | TSOptionalType | TSRestType | TemplateLiteralType | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSQualifiedName | TypeElement | TSInterfaceBody | TSExpressionWithTypeArguments | TSEnumMember | TSModuleBlock | TSExternalModuleReference | TSParameterProperty | TSDeclareMethod | TSDeclaration | TSModuleDeclarationStatement | TSExpression;
+
+/** Declarations; in estree's `Declaration` union. */
+export type TSDeclaration = TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration;
+
+/** Module-level statements; in estree's `ModuleDeclaration` union. */
+export type TSModuleDeclarationStatement = TSExportAssignment | TSImportEqualsDeclaration | TSNamespaceExportDeclaration;
+
+/** Expressions; in estree's `Expression` union. */
+export type TSExpression = TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
+
+export type TypeNode = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType | TSConditionalType | TSConstructorType | TSFunctionType | TSImportType | TSIndexedAccessType | TSInferType | TSIntersectionType | TSLiteralType | TSMappedType | TSParenthesizedType | TSThisType | TSTupleType | TSTypeLiteral | TSTypeOperator | TSTypeQuery | TSTypeReference | TSUnionType;
+
+export type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature;
+
+export type EntityName = Identifier | TSQualifiedName;
+
+export type Accessibility = "public" | "private" | "protected";
+
+/** A parameter of a function type, method signature or declared function. */
+export type SignatureParameter = Identifier | ObjectPattern | ArrayPattern | RestElement;
+
+/** Fields the plugin adds to `Identifier`, `ObjectPattern`, `ArrayPattern` and `RestElement`. */
+export interface TSBindingFields {
+    typeAnnotation?: TSTypeAnnotation | undefined;
+    /** `a?` in a parameter list. */
+    optional?: boolean;
+    decorators?: Decorator[];
+}
+
+/** Fields the plugin adds to functions. */
+export interface TSFunctionFields {
+    typeParameters?: TSTypeParameterDeclaration;
+    returnType?: TSTypeAnnotation;
+}
+
+/** Fields the plugin adds to classes. */
+export interface TSClassFields {
+    typeParameters?: TSTypeParameterDeclaration;
+    superTypeParameters?: TSTypeParameterInstantiation;
+    implements?: TSExpressionWithTypeArguments[];
+    abstract?: boolean;
+    declare?: boolean;
+    decorators?: Decorator[];
+}
+
+/** Modifiers the plugin adds to class members. */
+export interface TSClassMemberFields {
+    accessibility?: Accessibility;
+    abstract?: boolean;
+    override?: boolean;
+    readonly?: boolean;
+    declare?: boolean;
+    accessor?: boolean;
+    optional?: boolean;
+    decorators?: Decorator[];
+}
+
+export interface Decorator extends BaseNode {
+    type: "Decorator";
+    expression: Expression;
+}
+
+export interface TSTypeAnnotation extends BaseNode {
+    type: "TSTypeAnnotation";
+    /** A predicate (`x is T`, `asserts x`) only in a return type. */
+    typeAnnotation: TypeNode | TSTypePredicate;
+}
+
+export interface TSTypePredicate extends BaseNode {
+    type: "TSTypePredicate";
+    parameterName: Identifier | TSThisType;
+    asserts: boolean;
+    /** `null` for `asserts x` without `is`. */
+    typeAnnotation: TSTypeAnnotation | null;
+}
+
+export interface TSAnyKeyword extends BaseNode {
+    type: "TSAnyKeyword";
+}
+
+export interface TSBigIntKeyword extends BaseNode {
+    type: "TSBigIntKeyword";
+}
+
+export interface TSBooleanKeyword extends BaseNode {
+    type: "TSBooleanKeyword";
+}
+
+export interface TSNeverKeyword extends BaseNode {
+    type: "TSNeverKeyword";
+}
+
+export interface TSNullKeyword extends BaseNode {
+    type: "TSNullKeyword";
+}
+
+export interface TSNumberKeyword extends BaseNode {
+    type: "TSNumberKeyword";
+}
+
+export interface TSObjectKeyword extends BaseNode {
+    type: "TSObjectKeyword";
+}
+
+export interface TSStringKeyword extends BaseNode {
+    type: "TSStringKeyword";
+}
+
+export interface TSSymbolKeyword extends BaseNode {
+    type: "TSSymbolKeyword";
+}
+
+export interface TSUndefinedKeyword extends BaseNode {
+    type: "TSUndefinedKeyword";
+}
+
+export interface TSUnknownKeyword extends BaseNode {
+    type: "TSUnknownKeyword";
+}
+
+export interface TSVoidKeyword extends BaseNode {
+    type: "TSVoidKeyword";
+}
+
+export interface TSThisType extends BaseNode {
+    type: "TSThisType";
+}
+
+export interface TSArrayType extends BaseNode {
+    type: "TSArrayType";
+    elementType: TypeNode;
+}
+
+export interface TSConditionalType extends BaseNode {
+    type: "TSConditionalType";
+    checkType: TypeNode;
+    extendsType: TypeNode;
+    trueType: TypeNode;
+    falseType: TypeNode;
+}
+
+export interface TSFunctionType extends BaseNode {
+    type: "TSFunctionType";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation: TSTypeAnnotation;
+}
+
+export interface TSConstructorType extends BaseNode {
+    type: "TSConstructorType";
+    abstract: boolean;
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation: TSTypeAnnotation;
+}
+
+export interface TSImportType extends BaseNode {
+    type: "TSImportType";
+    argument: Literal;
+    qualifier?: EntityName;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export interface TSIndexedAccessType extends BaseNode {
+    type: "TSIndexedAccessType";
+    objectType: TypeNode;
+    indexType: TypeNode;
+}
+
+export interface TSInferType extends BaseNode {
+    type: "TSInferType";
+    typeParameter: TSTypeParameter;
+}
+
+export interface TSIntersectionType extends BaseNode {
+    type: "TSIntersectionType";
+    types: TypeNode[];
+}
+
+export interface TSUnionType extends BaseNode {
+    type: "TSUnionType";
+    types: TypeNode[];
+}
+
+export interface TSLiteralType extends BaseNode {
+    type: "TSLiteralType";
+    /** `UnaryExpression` for a negative number, e.g. `-1`. */
+    literal: Literal | UnaryExpression | TemplateLiteralType;
+}
+
+/** A template literal type, `` `prefix-${T}` ``: a `TemplateLiteral` whose expressions are types. */
+export interface TemplateLiteralType extends BaseNode {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: TypeNode[];
+}
+
+export interface TSMappedType extends BaseNode {
+    type: "TSMappedType";
+    readonly?: true | "+" | "-";
+    typeParameter: TSTypeParameter;
+    /** The `as` clause. */
+    nameType: TypeNode | null;
+    optional?: true | "+" | "-";
+    typeAnnotation?: TypeNode;
+}
+
+export interface TSParenthesizedType extends BaseNode {
+    type: "TSParenthesizedType";
+    typeAnnotation: TypeNode;
+}
+
+export interface TSTupleType extends BaseNode {
+    type: "TSTupleType";
+    elementTypes: Array<TypeNode | TSNamedTupleMember | TSOptionalType | TSRestType>;
+}
+
+export interface TSNamedTupleMember extends BaseNode {
+    type: "TSNamedTupleMember";
+    label: Identifier;
+    optional: boolean;
+    elementType: TypeNode;
+}
+
+export interface TSOptionalType extends BaseNode {
+    type: "TSOptionalType";
+    typeAnnotation: TypeNode;
+}
+
+export interface TSRestType extends BaseNode {
+    type: "TSRestType";
+    typeAnnotation: TypeNode | TSNamedTupleMember;
+}
+
+export interface TSTypeLiteral extends BaseNode {
+    type: "TSTypeLiteral";
+    members: TypeElement[];
+}
+
+export interface TSTypeOperator extends BaseNode {
+    type: "TSTypeOperator";
+    operator: "keyof" | "unique" | "readonly";
+    typeAnnotation: TypeNode;
+}
+
+export interface TSTypeQuery extends BaseNode {
+    type: "TSTypeQuery";
+    exprName: EntityName | TSImportType;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export interface TSTypeReference extends BaseNode {
+    type: "TSTypeReference";
+    typeName: EntityName;
+    typeArguments?: TSTypeParameterInstantiation;
+}
+
+export interface TSQualifiedName extends BaseNode {
+    type: "TSQualifiedName";
+    left: EntityName;
+    right: Identifier;
+}
+
+export interface TSTypeParameterDeclaration extends BaseNode {
+    type: "TSTypeParameterDeclaration";
+    params: TSTypeParameter[];
+    /** With a trailing comma, its offset. */
+    extra?: {
+        trailingComma: number;
+    };
+}
+
+export interface TSTypeParameter extends BaseNode {
+    type: "TSTypeParameter";
+    name: string;
+    constraint?: TypeNode;
+    default?: TypeNode;
+    const?: true;
+    in?: true;
+    out?: true;
+}
+
+export interface TSTypeParameterInstantiation extends BaseNode {
+    type: "TSTypeParameterInstantiation";
+    params: TypeNode[];
+}
+
+export interface TSPropertySignature extends BaseNode {
+    type: "TSPropertySignature";
+    key: Expression;
+    computed?: boolean;
+    optional?: boolean;
+    readonly?: boolean;
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+export interface TSMethodSignature extends BaseNode {
+    type: "TSMethodSignature";
+    key: Expression;
+    computed?: boolean;
+    optional?: boolean;
+    kind: "method" | "get" | "set";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    /** The return type. */
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+/** In an interface, a type literal, or a class body (with the class member modifiers). */
+export interface TSIndexSignature extends BaseNode, TSClassMemberFields {
+    type: "TSIndexSignature";
+    parameters: Identifier[];
+    typeAnnotation?: TSTypeAnnotation;
+    static?: boolean;
+}
+
+export interface TSCallSignatureDeclaration extends BaseNode {
+    type: "TSCallSignatureDeclaration";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+export interface TSConstructSignatureDeclaration extends BaseNode {
+    type: "TSConstructSignatureDeclaration";
+    typeParameters?: TSTypeParameterDeclaration;
+    parameters: SignatureParameter[];
+    typeAnnotation?: TSTypeAnnotation;
+}
+
+export interface TSInterfaceDeclaration extends BaseNode {
+    type: "TSInterfaceDeclaration";
+    id: Identifier;
+    typeParameters?: TSTypeParameterDeclaration;
+    extends?: TSExpressionWithTypeArguments[];
+    body: TSInterfaceBody;
+    declare?: boolean;
+}
+
+export interface TSInterfaceBody extends BaseNode {
+    type: "TSInterfaceBody";
+    body: TypeElement[];
+}
+
+/** An interface's `extends` or a class's `implements` entry. */
+export interface TSExpressionWithTypeArguments extends BaseNode {
+    type: "TSExpressionWithTypeArguments";
+    expression: EntityName;
+    /** The type arguments, named `typeParameters` as in acorn-typescript. */
+    typeParameters?: TSTypeParameterInstantiation;
+}
+
+export interface TSTypeAliasDeclaration extends BaseNode {
+    type: "TSTypeAliasDeclaration";
+    id: Identifier;
+    typeParameters?: TSTypeParameterDeclaration;
+    typeAnnotation: TypeNode;
+    declare?: boolean;
+}
+
+export interface TSEnumDeclaration extends BaseNode {
+    type: "TSEnumDeclaration";
+    id: Identifier;
+    members: TSEnumMember[];
+    const?: boolean;
+    declare?: boolean;
+}
+
+export interface TSEnumMember extends BaseNode {
+    type: "TSEnumMember";
+    id: Identifier | Literal;
+    initializer?: Expression;
+}
+
+/** `namespace A {}`, `module "a" {}`, `declare global {}`; `namespace A.B {}` nests through `body`. */
+export interface TSModuleDeclaration extends BaseNode {
+    type: "TSModuleDeclaration";
+    id: Identifier | Literal;
+    /** Absent for `declare module "a";`. */
+    body?: TSModuleBlock | TSModuleDeclaration;
+    declare?: boolean;
+    global?: boolean;
+}
+
+export interface TSModuleBlock extends BaseNode {
+    type: "TSModuleBlock";
+    body: Array<Statement | ModuleDeclaration>;
+}
+
+/** A function declaration without a body: an overload or `declare function`. */
+export interface TSDeclareFunction extends BaseNode, TSFunctionFields {
+    type: "TSDeclareFunction";
+    /** `null` in `export default function (): void;`. */
+    id: Identifier | null;
+    params: Pattern[];
+    expression: boolean;
+    generator: boolean;
+    async: boolean;
+    declare?: boolean;
+}
+
+/** A `MethodDefinition`'s value when the method has no body: an overload or an abstract method. */
+export interface TSDeclareMethod extends BaseNode, TSFunctionFields {
+    type: "TSDeclareMethod";
+    id: null;
+    params: Array<Pattern | TSParameterProperty>;
+    expression: boolean;
+    generator: boolean;
+    async: boolean;
+}
+
+/** `constructor(private a: T)`: a constructor parameter with a modifier. */
+export interface TSParameterProperty extends BaseNode {
+    type: "TSParameterProperty";
+    accessibility?: Accessibility;
+    readonly?: boolean;
+    override?: boolean;
+    parameter: Identifier | AssignmentPattern;
+}
+
+/** `import a = require("a")`, `import a = B.C`, `export import a = B.C`. */
+export interface TSImportEqualsDeclaration extends BaseNode {
+    type: "TSImportEqualsDeclaration";
+    importKind: "type" | "value";
+    isExport: boolean;
+    id: Identifier;
+    moduleReference: EntityName | TSExternalModuleReference;
+}
+
+export interface TSExternalModuleReference extends BaseNode {
+    type: "TSExternalModuleReference";
+    expression: Literal;
+}
+
+/** `export = a`. */
+export interface TSExportAssignment extends BaseNode {
+    type: "TSExportAssignment";
+    expression: Expression;
+}
+
+/** `export as namespace A`. */
+export interface TSNamespaceExportDeclaration extends BaseNode {
+    type: "TSNamespaceExportDeclaration";
+    id: Identifier;
+}
+
+export interface TSAsExpression extends BaseNode {
+    type: "TSAsExpression";
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+
+export interface TSSatisfiesExpression extends BaseNode {
+    type: "TSSatisfiesExpression";
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+
+/** `<T>a`. */
+export interface TSTypeAssertion extends BaseNode {
+    type: "TSTypeAssertion";
+    typeAnnotation: TypeNode;
+    expression: Expression;
+}
+
+export interface TSNonNullExpression extends BaseNode {
+    type: "TSNonNullExpression";
+    expression: Expression;
+}
+
+/** `f<T>` without a call. */
+export interface TSInstantiationExpression extends BaseNode {
+    type: "TSInstantiationExpression";
+    expression: Expression;
+    typeArguments: TSTypeParameterInstantiation;
+}
+
+type Namespace = "html" | "svg" | "mathml";
+
+export declare namespace AST {
+    export interface BaseNode {
+        type: string;
+        start: number;
+        end: number;
+    }
+    export interface Fragment {
+        type: "Fragment";
+        nodes: Array<Text | Tag | ElementLike | Block | Comment>;
+    }
+    export interface Root extends BaseNode {
+        type: "Root";
+        /**
+         * Inline options provided by `<svelte:options>` — these override options passed to `compile(...)`
+         */
+        options: SvelteOptions | null;
+        fragment: Fragment;
+        /** The parsed `<style>` element, if exists */
+        css: AST.CSS.StyleSheet | null;
+        /** The parsed `<script>` element, if exists */
+        instance?: Script;
+        /** The parsed `<script module>` element, if exists */
+        module?: Script;
+        /** Comments found in <script> and {expressions} */
+        comments: JSComment[];
+        /** Always empty, as in svelte. */
+        js: [];
+    }
+    export interface SvelteOptions {
+        start: number;
+        end: number;
+        runes?: boolean;
+        immutable?: boolean;
+        accessors?: boolean;
+        preserveWhitespace?: boolean;
+        namespace?: Namespace;
+        css?: "injected";
+        customElement?: {
+            tag?: string;
+            shadow?: "open" | "none" | ObjectExpression | undefined;
+            props?: Record<string, {
+                attribute?: string;
+                reflect?: boolean;
+                type?: "Array" | "Boolean" | "Number" | "Object" | "String";
+            }>;
+            /**
+             * Is of type
+             * ```ts
+             * (ceClass: new () => HTMLElement) => new () => HTMLElement
+             * ```
+             */
+            extend?: ArrowFunctionExpression | Identifier;
+        };
+        attributes: Attribute[];
+    }
+    /** Static text */
+    export interface Text extends BaseNode {
+        type: "Text";
+        /** Text with decoded HTML entities */
+        data: string;
+        /** The original text, with undecoded HTML entities */
+        raw: string;
+    }
+    /** A (possibly reactive) template expression — `{...}` */
+    export interface ExpressionTag extends BaseNode {
+        type: "ExpressionTag";
+        expression: Expression;
+    }
+    /** A (possibly reactive) HTML template expression — `{@html ...}` */
+    export interface HtmlTag extends BaseNode {
+        type: "HtmlTag";
+        expression: Expression;
+    }
+    /** An HTML comment */
+    export interface Comment extends BaseNode {
+        type: "Comment";
+        /** the contents of the comment */
+        data: string;
+    }
+    /** A `{@const ...}` tag */
+    export interface ConstTag extends BaseNode {
+        type: "ConstTag";
+        declaration: VariableDeclaration & {
+            declarations: [VariableDeclarator & {
+                id: Pattern;
+                init: Expression;
+            }];
+        };
+    }
+    /** A `{let ...}` or `{const ...}` tag */
+    export interface DeclarationTag extends BaseNode {
+        type: "DeclarationTag";
+        declaration: VariableDeclaration;
+    }
+    /** A `{@debug ...}` tag */
+    export interface DebugTag extends BaseNode {
+        type: "DebugTag";
+        identifiers: Identifier[];
+    }
+    /** A `{@render foo(...)} tag */
+    export interface RenderTag extends BaseNode {
+        type: "RenderTag";
+        expression: SimpleCallExpression | (ChainExpression & {
+            expression: SimpleCallExpression;
+        });
+    }
+    /** A `{@attach foo(...)} tag */
+    export interface AttachTag extends BaseNode {
+        type: "AttachTag";
+        expression: Expression;
+    }
+    /** An `animate:` directive */
+    export interface AnimateDirective extends BaseAttribute {
+        type: "AnimateDirective";
+        /** The 'x' in `animate:x` */
+        name: string;
+        /** The y in `animate:x={y}` */
+        expression: null | Expression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** A `bind:` directive */
+    export interface BindDirective extends BaseAttribute {
+        type: "BindDirective";
+        /** The 'x' in `bind:x` */
+        name: string;
+        /** The y in `bind:x={y}` */
+        expression: Identifier | MemberExpression | SequenceExpression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** A `class:` directive */
+    export interface ClassDirective extends BaseAttribute {
+        type: "ClassDirective";
+        /** The 'x' in `class:x` */
+        name: "class";
+        /** The 'y' in `class:x={y}`, or the `x` in `class:x` */
+        expression: Expression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** A `let:` directive */
+    export interface LetDirective extends BaseAttribute {
+        type: "LetDirective";
+        /** The 'x' in `let:x` */
+        name: string;
+        /** The 'y' in `let:x={y}` */
+        expression: null | Identifier | ArrayExpression | ObjectExpression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    /** An `on:` directive */
+    export interface OnDirective extends BaseAttribute {
+        type: "OnDirective";
+        /** The 'x' in `on:x` */
+        name: string;
+        /** The 'y' in `on:x={y}` */
+        expression: null | Expression;
+        modifiers: Array<"capture" | "nonpassive" | "once" | "passive" | "preventDefault" | "self" | "stopImmediatePropagation" | "stopPropagation" | "trusted">;
+    }
+    /** A `style:` directive */
+    export interface StyleDirective extends BaseAttribute {
+        type: "StyleDirective";
+        /** The 'x' in `style:x` */
+        name: string;
+        /** The 'y' in `style:x={y}` */
+        value: true | ExpressionTag | Array<ExpressionTag | Text>;
+        modifiers: Array<"important">;
+    }
+    /** A `transition:`, `in:` or `out:` directive */
+    export interface TransitionDirective extends BaseAttribute {
+        type: "TransitionDirective";
+        /** The 'x' in `transition:x` */
+        name: string;
+        /** The 'y' in `transition:x={y}` */
+        expression: null | Expression;
+        modifiers: Array<"local" | "global">;
+        /** True if this is a `transition:` or `in:` directive */
+        intro: boolean;
+        /** True if this is a `transition:` or `out:` directive */
+        outro: boolean;
+    }
+    /** A `use:` directive */
+    export interface UseDirective extends BaseAttribute {
+        type: "UseDirective";
+        /** The 'x' in `use:x` */
+        name: string;
+        /** The 'y' in `use:x={y}` */
+        expression: null | Expression;
+        /** Parsed for every directive, e.g. `use:x|y`; svelte's types declare it only on some. */
+        modifiers: string[];
+    }
+    export interface BaseElement extends BaseNode {
+        name: string;
+        /** Only with `parse(source, { loc: true })`. */
+        name_loc?: SourceLocation;
+        attributes: Array<Attribute | SpreadAttribute | Directive | AttachTag>;
+        fragment: Fragment;
+    }
+    export interface Component extends BaseElement {
+        type: "Component";
+    }
+    export interface TitleElement extends BaseElement {
+        type: "TitleElement";
+        name: "title";
+    }
+    export interface SlotElement extends BaseElement {
+        type: "SlotElement";
+        name: "slot";
+    }
+    export interface RegularElement extends BaseElement {
+        type: "RegularElement";
+    }
+    export interface SvelteBody extends BaseElement {
+        type: "SvelteBody";
+        name: "svelte:body";
+    }
+    export interface SvelteComponent extends BaseElement {
+        type: "SvelteComponent";
+        name: "svelte:component";
+        expression: Expression;
+    }
+    export interface SvelteDocument extends BaseElement {
+        type: "SvelteDocument";
+        name: "svelte:document";
+    }
+    export interface SvelteElement extends BaseElement {
+        type: "SvelteElement";
+        name: "svelte:element";
+        tag: Expression;
+    }
+    export interface SvelteFragment extends BaseElement {
+        type: "SvelteFragment";
+        name: "svelte:fragment";
+    }
+    export interface SvelteBoundary extends BaseElement {
+        type: "SvelteBoundary";
+        name: "svelte:boundary";
+    }
+    export interface SvelteHead extends BaseElement {
+        type: "SvelteHead";
+        name: "svelte:head";
+    }
+    /** This is only an intermediate representation while parsing, it doesn't exist in the final AST */
+    export interface SvelteOptionsRaw extends BaseElement {
+        type: "SvelteOptions";
+        name: "svelte:options";
+    }
+    export interface SvelteSelf extends BaseElement {
+        type: "SvelteSelf";
+        name: "svelte:self";
+    }
+    export interface SvelteWindow extends BaseElement {
+        type: "SvelteWindow";
+        name: "svelte:window";
+    }
+    /** An `{#each ...}` block */
+    export interface EachBlock extends BaseNode {
+        type: "EachBlock";
+        expression: Expression;
+        /** The `entry` in `{#each item as entry}`. `null` if `as` part is omitted */
+        context: Pattern | null;
+        body: Fragment;
+        fallback?: Fragment;
+        index?: string;
+        key?: Expression;
+    }
+    /** An `{#if ...}` block */
+    export interface IfBlock extends BaseNode {
+        type: "IfBlock";
+        elseif: boolean;
+        test: Expression;
+        consequent: Fragment;
+        alternate: Fragment | null;
+    }
+    /** An `{#await ...}` block */
+    export interface AwaitBlock extends BaseNode {
+        type: "AwaitBlock";
+        expression: Expression;
+        /** The resolved value inside the `then` block */
+        value: Pattern | null;
+        /** The rejection reason inside the `catch` block */
+        error: Pattern | null;
+        pending: Fragment | null;
+        then: Fragment | null;
+        catch: Fragment | null;
+    }
+    export interface KeyBlock extends BaseNode {
+        type: "KeyBlock";
+        expression: Expression;
+        fragment: Fragment;
+    }
+    export interface SnippetBlock extends BaseNode {
+        type: "SnippetBlock";
+        expression: Identifier;
+        parameters: Pattern[];
+        typeParams?: string;
+        body: Fragment;
+    }
+    export interface BaseAttribute extends BaseNode {
+        name: string;
+        /** Only with `parse(source, { loc: true })`. */
+        name_loc?: SourceLocation | null;
+    }
+    export interface Attribute extends BaseAttribute {
+        type: "Attribute";
+        /**
+         * Quoted/string values are represented by an array, even if they contain a single expression like `"{x}"`
+         */
+        value: true | ExpressionTag | Array<Text | ExpressionTag>;
+    }
+    export interface SpreadAttribute extends BaseNode {
+        type: "SpreadAttribute";
+        expression: Expression;
+    }
+    export interface Script extends BaseNode {
+        type: "Script";
+        context: "default" | "module";
+        content: Program;
+        attributes: Attribute[];
+    }
+    export interface JSComment {
+        type: "Line" | "Block";
+        value: string;
+        start: number;
+        end: number;
+        /** Only with `parse(source, { loc: true })`. */
+        loc?: {
+            start: {
+                line: number;
+                column: number;
+            };
+            end: {
+                line: number;
+                column: number;
+            };
+        };
+    }
+    export type AttributeLike = Attribute | SpreadAttribute | Directive;
+    export type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
+    export type Block = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock;
+    export type ElementLike = AST.Component | AST.TitleElement | AST.SlotElement | AST.RegularElement | AST.SvelteBody | AST.SvelteBoundary | AST.SvelteComponent | AST.SvelteDocument | AST.SvelteElement | AST.SvelteFragment | AST.SvelteHead | AST.SvelteOptionsRaw | AST.SvelteSelf | AST.SvelteWindow | AST.SvelteBoundary;
+    export type Tag = AST.AttachTag | AST.ConstTag | AST.DeclarationTag | AST.DebugTag | AST.ExpressionTag | AST.HtmlTag | AST.RenderTag;
+    export type TemplateNode = AST.Root | AST.Text | Tag | ElementLike | AST.Attribute | AST.SpreadAttribute | Directive | AST.AttachTag | AST.Comment | Block;
+    export type SvelteNode = Node | TemplateNode | AST.Fragment | _CSS.Node | Script;
+    export type { _CSS as CSS };
+}
+
+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;
+}
+
+/**
+ * Parses a JavaScript or TypeScript module, e.g. a `.ts` file a component
+ * imports, into the same kind of AST as a component's `<script>`:
+ * estree, TypeScript nodes as in `@sveltejs/acorn-typescript`, and
+ * comments attached as `leadingComments`/`trailingComments`.
+ *
+ * Throws a {@link ParseError} (`js_parse_error`) on a syntax error.
+ */
+export declare function parseModule(source: string, options?: {
+    /** Parse TypeScript. Default `false`. */
+    typescript?: boolean;
+    /** Add `loc` (line/column) to every node. Default `false`. */
+    loc?: boolean;
+}): Program;
+
+type NodeLike = number | {
+    start?: number;
+    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);
+}
+
+interface Location {
+    line: number;
+    column: number;
+    character: number;
+}