@wevu/compiler 7.1.3 → 7.2.0

package/dist/index.d.mts

@@ -1,10 +1,11 @@
+import { n as StaticRouteValue, t as StaticPageDeclaration } from "./public-DEO6JWFi.mjs";
 import { WevuBindingUpdateMode, WevuBindingUpdateMode as WevuBindingUpdateMode$1, WevuRuntimeBindingManifestV1, WevuRuntimeBindingRecordV1 } from "@weapp-core/constants";
-import { MpPlatform } from "@weapp-core/shared";
-import * as t from "@weapp-vite/ast/babelTypes";
-import { Expression } from "@weapp-vite/ast/babelTypes";
 import { LRUCache } from "lru-cache";
-import { AstEngineName, AstEngineName as AstEngineName$1 } from "@weapp-vite/ast";
 import { SFCBlock, SFCDescriptor, SFCParseResult, SFCStyleBlock } from "vue/compiler-sfc";
+import * as t from "@weapp-vite/ast/babelTypes";
+import { Expression, File } from "@weapp-vite/ast/babelTypes";
+import { MpPlatform } from "@weapp-core/shared";
+import { AstEngineName, AstEngineName as AstEngineName$1 } from "@weapp-vite/ast";
 import "@weapp-vite/ast/babelTraverse";
 //#region src/auto-import-components/builtin.d.ts
 /**
@@ -193,6 +194,1640 @@ export declare const WE_VU_INTERNAL_TEMPLATE_APIS: readonly ["normalizeClass", "
  */
 export declare function resolveWevuInternalImportModuleId(apiName: string): "virtual:weapp-vite/runtime" | "virtual:weapp-vite/runtime/reactivity" | "virtual:weapp-vite/runtime/template";
 //#endregion
+//#region src/plugins/utils/vueSfcBlockSrc.d.ts
+/**
+ * 解析 SFC block `src` 的配置。
+ */
+interface ResolveSfcBlockSrcOptions {
+  resolveId?: (source: string, importer?: string) => Promise<string | undefined>;
+  readFile?: (id: string, options?: {
+    checkMtime?: boolean;
+  }) => Promise<string>;
+  checkMtime?: boolean;
+}
+/**
+ * 解析 SFC 中带 `src` 的 block，并返回依赖列表。
+ */
+export declare function resolveSfcBlockSrc(descriptor: SFCDescriptor, filename: string, options?: ResolveSfcBlockSrcOptions): Promise<{
+  descriptor: SFCDescriptor;
+  deps: string[];
+  scriptResolvedId?: string;
+  scriptSetupResolvedId?: string;
+  templateResolvedId?: string;
+}>;
+//#endregion
+//#region src/plugins/utils/vueSfc.d.ts
+/**
+ * 读取并解析 SFC 的配置。
+ */
+interface ReadAndParseSfcOptions {
+  /**
+   * 直接传入源码以跳过文件读取。
+   */
+  source?: string;
+  /**
+   * 已完成其他 parser 预处理的源码。
+   */
+  preprocessedSource?: string;
+  /**
+   * 是否忽略空 SFC block。
+   */
+  ignoreEmpty?: boolean;
+  /**
+   * 是否按 mtime+size 检查文件变更（dev 推荐开启）。
+   */
+  checkMtime?: boolean;
+  /**
+   * 解析 <template>/<script>/<style> 的 src 引用。
+   */
+  resolveSrc?: ResolveSfcBlockSrcOptions;
+}
+/**
+ * 预处理 `<script setup src>`，避免编译器丢失 src。
+ */
+export declare function preprocessScriptSetupSrc(source: string): string;
+/**
+ * 预处理普通 `<script src>`，避免编译器丢失 src。
+ */
+export declare function preprocessScriptSrc(source: string): string;
+/**
+ * 将预处理的 `<script setup src>` 恢复为真实 src。
+ */
+export declare function restoreScriptSetupSrc(descriptor: SFCDescriptor): void;
+/**
+ * 将预处理的 `<script src>` 恢复为真实 src。
+ */
+export declare function restoreScriptSrc(descriptor: SFCDescriptor): void;
+/**
+ * 读取并解析 SFC，支持缓存与 src 解析。
+ */
+export declare function readAndParseSfc(filename: string, options?: ReadAndParseSfcOptions): Promise<{
+  source: string;
+  descriptor: SFCDescriptor;
+  errors: SFCParseResult['errors'];
+}>;
+/**
+ * 获取 SFC 读取时是否检查 mtime 的策略。
+ */
+export declare function getSfcCheckMtime(config?: {
+  isDev?: boolean;
+}): boolean;
+//#endregion
+//#region src/utils/sourcemap.d.ts
+interface EncodedSourceMapLike {
+  version: number | string;
+  file?: string;
+  names: string[];
+  sourceRoot?: string;
+  sources: string[];
+  sourcesContent?: Array<string | null>;
+  mappings: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@babel+types@8.0.6/node_modules/@babel/types/lib/index.d.ts
+interface BaseComment {
+  value: string;
+  start?: number;
+  end?: number;
+  loc?: SourceLocation;
+  ignore?: boolean;
+  type: "CommentBlock" | "CommentLine";
+}
+interface Position {
+  line: number;
+  column: number;
+  index: number;
+}
+interface CommentBlock extends BaseComment {
+  type: "CommentBlock";
+}
+interface CommentLine extends BaseComment {
+  type: "CommentLine";
+}
+type Comment = CommentBlock | CommentLine;
+interface SourceLocation {
+  start: Position;
+  end: Position;
+  filename: string | undefined;
+  identifierName: string | undefined | null;
+}
+interface BaseNode {
+  leadingComments?: Comment[] | null;
+  innerComments?: Comment[] | null;
+  trailingComments?: Comment[] | null;
+  start?: number | null;
+  end?: number | null;
+  loc?: SourceLocation | null;
+  range?: [number, number];
+  extra?: Record<string, unknown>;
+}
+interface ArrayExpression extends BaseNode {
+  type: "ArrayExpression";
+  elements: (null | Expression$1 | SpreadElement)[];
+}
+interface AssignmentExpression extends BaseNode {
+  type: "AssignmentExpression";
+  operator: "=" | "+=" | "-=" | "/=" | "%=" | "*=" | "**=" | "&=" | "|=" | ">>=" | ">>>=" | "<<=" | "^=" | "||=" | "&&=" | "??=";
+  left: Identifier | MemberExpression | OptionalMemberExpression | ArrayPattern | ObjectPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+  right: Expression$1;
+}
+interface BinaryExpressionIn extends BaseNode {
+  type: "BinaryExpression";
+  right: Expression$1;
+  operator: "in";
+  left: Expression$1 | PrivateName;
+}
+interface BinaryExpressionNotIn extends BaseNode {
+  type: "BinaryExpression";
+  right: Expression$1;
+  operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>";
+  left: Expression$1;
+}
+type BinaryExpression = BinaryExpressionIn | BinaryExpressionNotIn;
+interface InterpreterDirective extends BaseNode {
+  type: "InterpreterDirective";
+  value: string;
+}
+interface Directive extends BaseNode {
+  type: "Directive";
+  value: DirectiveLiteral;
+}
+interface DirectiveLiteral extends BaseNode {
+  type: "DirectiveLiteral";
+  value: string;
+}
+interface BlockStatement extends BaseNode {
+  type: "BlockStatement";
+  body: Statement[];
+  directives: Directive[];
+}
+interface BreakStatement extends BaseNode {
+  type: "BreakStatement";
+  label?: Identifier | null;
+}
+interface CallExpression extends BaseNode {
+  type: "CallExpression";
+  callee: Expression$1 | Super | Import | V8IntrinsicIdentifier;
+  arguments: (Expression$1 | SpreadElement | ArgumentPlaceholder)[];
+  typeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param?: Identifier | ArrayPattern | ObjectPattern | null;
+  body: BlockStatement;
+}
+interface ConditionalExpression extends BaseNode {
+  type: "ConditionalExpression";
+  test: Expression$1;
+  consequent: Expression$1;
+  alternate: Expression$1;
+}
+interface ContinueStatement extends BaseNode {
+  type: "ContinueStatement";
+  label?: Identifier | null;
+}
+interface DebuggerStatement extends BaseNode {
+  type: "DebuggerStatement";
+}
+interface DoWhileStatement extends BaseNode {
+  type: "DoWhileStatement";
+  test: Expression$1;
+  body: Statement;
+}
+interface EmptyStatement extends BaseNode {
+  type: "EmptyStatement";
+}
+interface ExpressionStatement extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Expression$1;
+}
+interface ForInStatement extends BaseNode {
+  type: "ForInStatement";
+  left: VariableDeclaration | Identifier | MemberExpression | ArrayPattern | ObjectPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+  right: Expression$1;
+  body: Statement;
+}
+interface ForStatement extends BaseNode {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression$1 | null;
+  test?: Expression$1 | null;
+  update?: Expression$1 | null;
+  body: Statement;
+}
+interface FunctionDeclaration extends BaseNode {
+  type: "FunctionDeclaration";
+  id?: Identifier | null;
+  params: FunctionParameter[];
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  declare?: boolean | null;
+  predicate?: FlowPredicate | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+}
+interface FunctionExpression extends BaseNode {
+  type: "FunctionExpression";
+  id?: Identifier | null;
+  params: FunctionParameter[];
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  predicate?: FlowPredicate | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+}
+interface Identifier extends BaseNode {
+  type: "Identifier";
+  name: string;
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+}
+interface IfStatement extends BaseNode {
+  type: "IfStatement";
+  test: Expression$1;
+  consequent: Statement;
+  alternate?: Statement | null;
+}
+interface LabeledStatement extends BaseNode {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface StringLiteral extends BaseNode {
+  type: "StringLiteral";
+  value: string;
+}
+interface NumericLiteral extends BaseNode {
+  type: "NumericLiteral";
+  value: number;
+}
+interface NullLiteral extends BaseNode {
+  type: "NullLiteral";
+}
+interface BooleanLiteral extends BaseNode {
+  type: "BooleanLiteral";
+  value: boolean;
+}
+interface RegExpLiteral extends BaseNode {
+  type: "RegExpLiteral";
+  pattern: string;
+  flags: string;
+}
+interface LogicalExpression extends BaseNode {
+  type: "LogicalExpression";
+  operator: "||" | "&&" | "??";
+  left: Expression$1;
+  right: Expression$1;
+}
+interface MemberExpressionComputed extends BaseNode {
+  type: "MemberExpression";
+  object: Expression$1 | Super;
+  computed: true;
+  property: Expression$1;
+}
+interface MemberExpressionNonComputed extends BaseNode {
+  type: "MemberExpression";
+  object: Expression$1 | Super;
+  computed: false;
+  property: Identifier | PrivateName;
+}
+type MemberExpression = MemberExpressionComputed | MemberExpressionNonComputed;
+interface NewExpression extends BaseNode {
+  type: "NewExpression";
+  callee: Expression$1 | V8IntrinsicIdentifier;
+  arguments: (Expression$1 | SpreadElement | ArgumentPlaceholder)[];
+  typeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+interface Program extends BaseNode {
+  type: "Program";
+  body: Statement[];
+  directives: Directive[];
+  sourceType: "script" | "module";
+  interpreter?: InterpreterDirective | null;
+}
+interface ObjectExpression extends BaseNode {
+  type: "ObjectExpression";
+  properties: (ObjectMethod | ObjectProperty | SpreadElement)[];
+}
+interface ObjectMethodComputed extends BaseNode {
+  type: "ObjectMethod";
+  kind: "method" | "get" | "set";
+  params: FunctionParameter[];
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  decorators?: Decorator[] | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+  computed: true;
+  key: Expression$1;
+}
+interface ObjectMethodNonComputed extends BaseNode {
+  type: "ObjectMethod";
+  kind: "method" | "get" | "set";
+  params: FunctionParameter[];
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  decorators?: Decorator[] | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+  computed: false;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+}
+type ObjectMethod = ObjectMethodComputed | ObjectMethodNonComputed;
+interface ObjectPropertyComputed extends BaseNode {
+  type: "ObjectProperty";
+  value: Expression$1 | PatternLike;
+  shorthand: boolean;
+  decorators?: Decorator[] | null;
+  computed: true;
+  key: Expression$1;
+}
+interface ObjectPropertyNonComputed extends BaseNode {
+  type: "ObjectProperty";
+  value: Expression$1 | PatternLike;
+  shorthand: boolean;
+  decorators?: Decorator[] | null;
+  computed: false;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | PrivateName;
+}
+type ObjectProperty = ObjectPropertyComputed | ObjectPropertyNonComputed;
+interface RestElement extends BaseNode {
+  type: "RestElement";
+  argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+}
+interface ReturnStatement extends BaseNode {
+  type: "ReturnStatement";
+  argument?: Expression$1 | null;
+}
+interface SequenceExpression extends BaseNode {
+  type: "SequenceExpression";
+  expressions: Expression$1[];
+}
+interface ParenthesizedExpression extends BaseNode {
+  type: "ParenthesizedExpression";
+  expression: Expression$1;
+}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression$1 | null;
+  consequent: Statement[];
+}
+interface SwitchStatement extends BaseNode {
+  type: "SwitchStatement";
+  discriminant: Expression$1;
+  cases: SwitchCase[];
+}
+interface ThisExpression extends BaseNode {
+  type: "ThisExpression";
+}
+interface ThrowStatement extends BaseNode {
+  type: "ThrowStatement";
+  argument: Expression$1;
+}
+interface TryStatement extends BaseNode {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null;
+  finalizer?: BlockStatement | null;
+}
+interface UnaryExpression extends BaseNode {
+  type: "UnaryExpression";
+  operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
+  argument: Expression$1;
+  prefix: boolean;
+}
+interface UpdateExpression extends BaseNode {
+  type: "UpdateExpression";
+  operator: "++" | "--";
+  argument: Identifier | MemberExpression;
+  prefix: boolean;
+}
+interface VariableDeclaration extends BaseNode {
+  type: "VariableDeclaration";
+  kind: "var" | "let" | "const" | "using" | "await using";
+  declarations: VariableDeclarator[];
+  declare?: boolean | null;
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Identifier | ArrayPattern | ObjectPattern | VoidPattern;
+  init?: Expression$1 | null;
+  definite?: boolean | null;
+}
+interface WhileStatement extends BaseNode {
+  type: "WhileStatement";
+  test: Expression$1;
+  body: Statement;
+}
+interface WithStatement extends BaseNode {
+  type: "WithStatement";
+  object: Expression$1;
+  body: Statement;
+}
+interface AssignmentPattern extends BaseNode {
+  type: "AssignmentPattern";
+  left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+  right: Expression$1;
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+}
+interface ArrayPattern extends BaseNode {
+  type: "ArrayPattern";
+  elements: (null | PatternLike)[];
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+}
+interface ArrowFunctionExpression extends BaseNode {
+  type: "ArrowFunctionExpression";
+  params: FunctionParameter[];
+  body: BlockStatement | Expression$1;
+  async: boolean;
+  expression?: boolean | null;
+  generator?: boolean | null;
+  predicate?: FlowPredicate | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[];
+}
+interface ClassExpression extends BaseNode {
+  type: "ClassExpression";
+  id?: Identifier | null;
+  superClass?: Expression$1 | null;
+  body: ClassBody;
+  decorators?: Decorator[] | null;
+  implements?: (TSClassImplements | ClassImplements)[] | null;
+  mixins?: InterfaceExtends | null;
+  superTypeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+}
+interface ClassDeclaration extends BaseNode {
+  type: "ClassDeclaration";
+  id?: Identifier | null;
+  superClass?: Expression$1 | null;
+  body: ClassBody;
+  decorators?: Decorator[] | null;
+  abstract?: boolean | null;
+  declare?: boolean | null;
+  implements?: (TSClassImplements | ClassImplements)[] | null;
+  mixins?: InterfaceExtends | null;
+  superTypeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+}
+interface ExportAllDeclaration extends BaseNode {
+  type: "ExportAllDeclaration";
+  source: StringLiteral;
+  attributes?: ImportAttribute[] | null;
+  exportKind?: "type" | "value" | null;
+}
+interface ExportDefaultDeclaration extends BaseNode {
+  type: "ExportDefaultDeclaration";
+  declaration: FunctionDeclaration | ClassDeclaration | Expression$1 | TSDeclareFunction | TSInterfaceDeclaration | EnumDeclaration;
+  exportKind?: "value" | null;
+}
+interface ExportNamedDeclaration extends BaseNode {
+  type: "ExportNamedDeclaration";
+  declaration?: VariableDeclaration | FunctionDeclaration | ClassDeclaration | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | EnumDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | null;
+  specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[];
+  source?: StringLiteral | null;
+  attributes?: ImportAttribute[] | null;
+  exportKind?: "type" | "value" | null;
+}
+interface ExportSpecifier extends BaseNode {
+  type: "ExportSpecifier";
+  local: Identifier | StringLiteral;
+  exported: Identifier | StringLiteral;
+  exportKind?: "type" | "value" | null;
+}
+interface ForOfStatement extends BaseNode {
+  type: "ForOfStatement";
+  left: VariableDeclaration | Identifier | MemberExpression | ArrayPattern | ObjectPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+  right: Expression$1;
+  body: Statement;
+  await: boolean;
+}
+interface ImportDeclaration extends BaseNode {
+  type: "ImportDeclaration";
+  specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[];
+  source: StringLiteral;
+  attributes?: ImportAttribute[] | null;
+  importKind?: "type" | "typeof" | "value" | null;
+  module?: boolean | null;
+  phase?: "source" | "defer" | null;
+}
+interface ImportDefaultSpecifier extends BaseNode {
+  type: "ImportDefaultSpecifier";
+  local: Identifier;
+}
+interface ImportNamespaceSpecifier extends BaseNode {
+  type: "ImportNamespaceSpecifier";
+  local: Identifier;
+}
+interface ImportSpecifier extends BaseNode {
+  type: "ImportSpecifier";
+  local: Identifier;
+  imported: Identifier | StringLiteral;
+  importKind?: "type" | "typeof" | "value" | null;
+}
+interface MetaProperty extends BaseNode {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+interface ClassMethodComputed extends BaseNode {
+  type: "ClassMethod";
+  kind: "get" | "set" | "method" | "constructor";
+  params: (FunctionParameter | TSParameterProperty)[];
+  body: BlockStatement;
+  static: boolean;
+  generator: boolean;
+  async: boolean;
+  abstract?: boolean | null;
+  access?: "public" | "private" | "protected" | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  override?: boolean | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+  computed: true;
+  key: Expression$1;
+}
+interface ClassMethodNonComputed extends BaseNode {
+  type: "ClassMethod";
+  kind: "get" | "set" | "method" | "constructor";
+  params: (FunctionParameter | TSParameterProperty)[];
+  body: BlockStatement;
+  static: boolean;
+  generator: boolean;
+  async: boolean;
+  abstract?: boolean | null;
+  access?: "public" | "private" | "protected" | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  override?: boolean | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+  computed: false;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+}
+type ClassMethod = ClassMethodComputed | ClassMethodNonComputed;
+interface ObjectPattern extends BaseNode {
+  type: "ObjectPattern";
+  properties: (RestElement | ObjectProperty)[];
+  decorators?: Decorator[] | null;
+  optional?: boolean | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression$1;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface TaggedTemplateExpression extends BaseNode {
+  type: "TaggedTemplateExpression";
+  tag: Expression$1;
+  quasi: TemplateLiteral;
+  typeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  value: {
+    raw: string;
+    cooked?: string | null;
+  };
+  tail: boolean;
+}
+interface TemplateLiteral extends BaseNode {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: (Expression$1 | TSType)[];
+}
+interface YieldExpression extends BaseNode {
+  type: "YieldExpression";
+  argument?: Expression$1 | null;
+  delegate: boolean;
+}
+interface AwaitExpression extends BaseNode {
+  type: "AwaitExpression";
+  argument: Expression$1;
+}
+interface ImportExpression extends BaseNode {
+  type: "ImportExpression";
+  source: Expression$1;
+  options?: Expression$1 | null;
+  phase?: "source" | "defer" | null;
+}
+interface Import extends BaseNode {
+  type: "Import";
+}
+interface BigIntLiteral extends BaseNode {
+  type: "BigIntLiteral";
+  value: bigint;
+}
+interface ExportNamespaceSpecifier extends BaseNode {
+  type: "ExportNamespaceSpecifier";
+  exported: Identifier | StringLiteral;
+}
+interface OptionalMemberExpressionComputed extends BaseNode {
+  type: "OptionalMemberExpression";
+  object: Expression$1;
+  optional: boolean;
+  computed: true;
+  property: Expression$1;
+}
+interface OptionalMemberExpressionNonComputed extends BaseNode {
+  type: "OptionalMemberExpression";
+  object: Expression$1;
+  optional: boolean;
+  computed: false;
+  property: Identifier | PrivateName;
+}
+type OptionalMemberExpression = OptionalMemberExpressionComputed | OptionalMemberExpressionNonComputed;
+interface OptionalCallExpression extends BaseNode {
+  type: "OptionalCallExpression";
+  callee: Expression$1;
+  arguments: (Expression$1 | SpreadElement | ArgumentPlaceholder)[];
+  optional: boolean;
+  typeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+interface ClassPropertyComputed extends BaseNode {
+  type: "ClassProperty";
+  value?: Expression$1 | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+  decorators?: Decorator[] | null;
+  static: boolean;
+  abstract?: boolean | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  declare?: boolean | null;
+  definite?: boolean | null;
+  optional?: boolean | null;
+  override?: boolean | null;
+  readonly?: boolean | null;
+  variance?: Variance | null;
+  computed: true;
+  key: Expression$1;
+}
+interface ClassPropertyNonComputed extends BaseNode {
+  type: "ClassProperty";
+  value?: Expression$1 | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+  decorators?: Decorator[] | null;
+  static: boolean;
+  abstract?: boolean | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  declare?: boolean | null;
+  definite?: boolean | null;
+  optional?: boolean | null;
+  override?: boolean | null;
+  readonly?: boolean | null;
+  variance?: Variance | null;
+  computed: false;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+}
+type ClassProperty = ClassPropertyComputed | ClassPropertyNonComputed;
+interface ClassPrivateProperty extends BaseNode {
+  type: "ClassPrivateProperty";
+  key: PrivateName;
+  value?: Expression$1 | null;
+  decorators?: Decorator[] | null;
+  static: boolean;
+  definite?: boolean | null;
+  optional?: boolean | null;
+  readonly?: boolean | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+  variance?: Variance | null;
+}
+interface ClassPrivateMethod extends BaseNode {
+  type: "ClassPrivateMethod";
+  kind: "get" | "set" | "method";
+  key: PrivateName;
+  params: (FunctionParameter | TSParameterProperty)[];
+  body: BlockStatement;
+  static: boolean;
+  abstract?: boolean | null;
+  access?: "public" | "private" | "protected" | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  async: boolean;
+  computed: boolean;
+  decorators?: Decorator[] | null;
+  generator: boolean;
+  optional?: boolean | null;
+  override?: boolean | null;
+  returnType?: TypeAnnotation | TSTypeAnnotation | null;
+  typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | null;
+}
+interface PrivateName extends BaseNode {
+  type: "PrivateName";
+  id: Identifier;
+}
+interface StaticBlock extends BaseNode {
+  type: "StaticBlock";
+  body: Statement[];
+}
+interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: Identifier | StringLiteral;
+  value: StringLiteral;
+}
+interface AnyTypeAnnotation extends BaseNode {
+  type: "AnyTypeAnnotation";
+}
+interface ArrayTypeAnnotation extends BaseNode {
+  type: "ArrayTypeAnnotation";
+  elementType: FlowType;
+}
+interface BooleanTypeAnnotation extends BaseNode {
+  type: "BooleanTypeAnnotation";
+}
+interface BooleanLiteralTypeAnnotation extends BaseNode {
+  type: "BooleanLiteralTypeAnnotation";
+  value: boolean;
+}
+interface NullLiteralTypeAnnotation extends BaseNode {
+  type: "NullLiteralTypeAnnotation";
+}
+interface ClassImplements extends BaseNode {
+  type: "ClassImplements";
+  id: Identifier;
+  typeParameters?: TypeParameterInstantiation | null;
+}
+interface DeclareClass extends BaseNode {
+  type: "DeclareClass";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  extends?: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+  implements?: ClassImplements[] | null;
+  mixins?: InterfaceExtends[] | null;
+}
+interface DeclareFunction extends BaseNode {
+  type: "DeclareFunction";
+  id: Identifier;
+  predicate?: FlowPredicate | null;
+}
+interface DeclareInterface extends BaseNode {
+  type: "DeclareInterface";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  extends?: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+}
+interface DeclareModule extends BaseNode {
+  type: "DeclareModule";
+  id: Identifier | StringLiteral;
+  body: BlockStatement;
+  kind?: "CommonJS" | "ES" | null;
+}
+interface DeclareModuleExports extends BaseNode {
+  type: "DeclareModuleExports";
+  typeAnnotation: TypeAnnotation;
+}
+interface DeclareTypeAlias extends BaseNode {
+  type: "DeclareTypeAlias";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  right: FlowType;
+}
+interface DeclareOpaqueType extends BaseNode {
+  type: "DeclareOpaqueType";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  supertype?: FlowType | null;
+  impltype?: FlowType | null;
+}
+interface DeclareVariable extends BaseNode {
+  type: "DeclareVariable";
+  id: Identifier;
+}
+interface DeclareExportDeclaration extends BaseNode {
+  type: "DeclareExportDeclaration";
+  declaration?: Flow | null;
+  specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null;
+  source?: StringLiteral | null;
+  attributes?: ImportAttribute[] | null;
+  default?: boolean | null;
+}
+interface DeclareExportAllDeclaration extends BaseNode {
+  type: "DeclareExportAllDeclaration";
+  source: StringLiteral;
+  attributes?: ImportAttribute[] | null;
+  exportKind?: "type" | "value" | null;
+}
+interface DeclaredPredicate extends BaseNode {
+  type: "DeclaredPredicate";
+  value: Expression$1;
+}
+interface ExistsTypeAnnotation extends BaseNode {
+  type: "ExistsTypeAnnotation";
+}
+interface FunctionTypeAnnotation extends BaseNode {
+  type: "FunctionTypeAnnotation";
+  typeParameters?: TypeParameterDeclaration | null;
+  params: FunctionTypeParam[];
+  rest?: FunctionTypeParam | null;
+  returnType: FlowType;
+  this?: FunctionTypeParam | null;
+}
+interface FunctionTypeParam extends BaseNode {
+  type: "FunctionTypeParam";
+  name?: Identifier | null;
+  typeAnnotation: FlowType;
+  optional?: boolean | null;
+}
+interface GenericTypeAnnotation extends BaseNode {
+  type: "GenericTypeAnnotation";
+  id: Identifier | QualifiedTypeIdentifier;
+  typeParameters?: TypeParameterInstantiation | null;
+}
+interface InferredPredicate extends BaseNode {
+  type: "InferredPredicate";
+}
+interface InterfaceExtends extends BaseNode {
+  type: "InterfaceExtends";
+  id: Identifier | QualifiedTypeIdentifier;
+  typeParameters?: TypeParameterInstantiation | null;
+}
+interface InterfaceDeclaration extends BaseNode {
+  type: "InterfaceDeclaration";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  extends?: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+}
+interface InterfaceTypeAnnotation extends BaseNode {
+  type: "InterfaceTypeAnnotation";
+  extends?: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+}
+interface IntersectionTypeAnnotation extends BaseNode {
+  type: "IntersectionTypeAnnotation";
+  types: FlowType[];
+}
+interface MixedTypeAnnotation extends BaseNode {
+  type: "MixedTypeAnnotation";
+}
+interface EmptyTypeAnnotation extends BaseNode {
+  type: "EmptyTypeAnnotation";
+}
+interface NullableTypeAnnotation extends BaseNode {
+  type: "NullableTypeAnnotation";
+  typeAnnotation: FlowType;
+}
+interface NumberLiteralTypeAnnotation extends BaseNode {
+  type: "NumberLiteralTypeAnnotation";
+  value: number;
+}
+interface BigIntLiteralTypeAnnotation extends BaseNode {
+  type: "BigIntLiteralTypeAnnotation";
+  value: bigint;
+}
+interface NumberTypeAnnotation extends BaseNode {
+  type: "NumberTypeAnnotation";
+}
+interface ObjectTypeAnnotation extends BaseNode {
+  type: "ObjectTypeAnnotation";
+  properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[];
+  indexers: ObjectTypeIndexer[];
+  callProperties: ObjectTypeCallProperty[];
+  internalSlots: ObjectTypeInternalSlot[];
+  exact: boolean;
+  inexact?: boolean | null;
+}
+interface ObjectTypeInternalSlot extends BaseNode {
+  type: "ObjectTypeInternalSlot";
+  id: Identifier;
+  value: FlowType;
+  optional: boolean;
+  static: boolean;
+  method: boolean;
+}
+interface ObjectTypeCallProperty extends BaseNode {
+  type: "ObjectTypeCallProperty";
+  value: FlowType;
+  static: boolean;
+}
+interface ObjectTypeIndexer extends BaseNode {
+  type: "ObjectTypeIndexer";
+  id?: Identifier | null;
+  key: FlowType;
+  value: FlowType;
+  variance?: Variance | null;
+  static: boolean;
+}
+interface ObjectTypeProperty extends BaseNode {
+  type: "ObjectTypeProperty";
+  key: Identifier | StringLiteral | NumericLiteral;
+  value: FlowType;
+  variance?: Variance | null;
+  kind: "init" | "get" | "set";
+  method: boolean;
+  optional: boolean;
+  proto: boolean;
+  static: boolean;
+}
+interface ObjectTypeSpreadProperty extends BaseNode {
+  type: "ObjectTypeSpreadProperty";
+  argument: FlowType;
+}
+interface OpaqueType extends BaseNode {
+  type: "OpaqueType";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  supertype?: FlowType | null;
+  impltype: FlowType;
+}
+interface QualifiedTypeIdentifier extends BaseNode {
+  type: "QualifiedTypeIdentifier";
+  id: Identifier;
+  qualification: Identifier | QualifiedTypeIdentifier;
+}
+interface StringLiteralTypeAnnotation extends BaseNode {
+  type: "StringLiteralTypeAnnotation";
+  value: string;
+}
+interface StringTypeAnnotation extends BaseNode {
+  type: "StringTypeAnnotation";
+}
+interface SymbolTypeAnnotation extends BaseNode {
+  type: "SymbolTypeAnnotation";
+}
+interface ThisTypeAnnotation extends BaseNode {
+  type: "ThisTypeAnnotation";
+}
+interface TupleTypeAnnotation extends BaseNode {
+  type: "TupleTypeAnnotation";
+  types: FlowType[];
+}
+interface TypeofTypeAnnotation extends BaseNode {
+  type: "TypeofTypeAnnotation";
+  argument: FlowType | Identifier;
+}
+interface TypeAlias extends BaseNode {
+  type: "TypeAlias";
+  id: Identifier;
+  typeParameters?: TypeParameterDeclaration | null;
+  right: FlowType;
+}
+interface TypeAnnotation extends BaseNode {
+  type: "TypeAnnotation";
+  typeAnnotation: FlowType | Identifier;
+}
+interface TypeCastExpression extends BaseNode {
+  type: "TypeCastExpression";
+  expression: Expression$1;
+  typeAnnotation: TypeAnnotation;
+}
+interface TypeParameter extends BaseNode {
+  type: "TypeParameter";
+  name: string;
+  bound?: TypeAnnotation | null;
+  default?: FlowType | null;
+  variance?: Variance | null;
+}
+interface TypeParameterDeclaration extends BaseNode {
+  type: "TypeParameterDeclaration";
+  params: TypeParameter[];
+}
+interface TypeParameterInstantiation extends BaseNode {
+  type: "TypeParameterInstantiation";
+  params: FlowType[];
+}
+interface UnionTypeAnnotation extends BaseNode {
+  type: "UnionTypeAnnotation";
+  types: FlowType[];
+}
+interface Variance extends BaseNode {
+  type: "Variance";
+  kind: "minus" | "plus";
+}
+interface VoidTypeAnnotation extends BaseNode {
+  type: "VoidTypeAnnotation";
+}
+interface EnumDeclaration extends BaseNode {
+  type: "EnumDeclaration";
+  id: Identifier;
+  body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody;
+}
+interface EnumBooleanBody extends BaseNode {
+  type: "EnumBooleanBody";
+  members: EnumBooleanMember[];
+  explicitType: boolean;
+  hasUnknownMembers: boolean;
+}
+interface EnumNumberBody extends BaseNode {
+  type: "EnumNumberBody";
+  members: EnumNumberMember[];
+  explicitType: boolean;
+  hasUnknownMembers: boolean;
+}
+interface EnumStringBody extends BaseNode {
+  type: "EnumStringBody";
+  members: (EnumStringMember | EnumDefaultedMember)[];
+  explicitType: boolean;
+  hasUnknownMembers: boolean;
+}
+interface EnumSymbolBody extends BaseNode {
+  type: "EnumSymbolBody";
+  members: EnumDefaultedMember[];
+  hasUnknownMembers: boolean;
+}
+interface EnumBooleanMember extends BaseNode {
+  type: "EnumBooleanMember";
+  id: Identifier;
+  init: BooleanLiteral;
+}
+interface EnumNumberMember extends BaseNode {
+  type: "EnumNumberMember";
+  id: Identifier;
+  init: NumericLiteral;
+}
+interface EnumStringMember extends BaseNode {
+  type: "EnumStringMember";
+  id: Identifier;
+  init: StringLiteral;
+}
+interface EnumDefaultedMember extends BaseNode {
+  type: "EnumDefaultedMember";
+  id: Identifier;
+}
+interface IndexedAccessType extends BaseNode {
+  type: "IndexedAccessType";
+  objectType: FlowType;
+  indexType: FlowType;
+}
+interface OptionalIndexedAccessType extends BaseNode {
+  type: "OptionalIndexedAccessType";
+  objectType: FlowType;
+  indexType: FlowType;
+  optional: boolean;
+}
+interface JSXAttribute extends BaseNode {
+  type: "JSXAttribute";
+  name: JSXIdentifier | JSXNamespacedName;
+  value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null;
+}
+interface JSXClosingElement extends BaseNode {
+  type: "JSXClosingElement";
+  name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+}
+interface JSXElement extends BaseNode {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement;
+  closingElement?: JSXClosingElement | null;
+  children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
+}
+interface JSXEmptyExpression extends BaseNode {
+  type: "JSXEmptyExpression";
+}
+interface JSXExpressionContainer extends BaseNode {
+  type: "JSXExpressionContainer";
+  expression: Expression$1 | JSXEmptyExpression;
+}
+interface JSXSpreadChild extends BaseNode {
+  type: "JSXSpreadChild";
+  expression: Expression$1;
+}
+interface JSXIdentifier extends BaseNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+interface JSXMemberExpression extends BaseNode {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpression | JSXIdentifier;
+  property: JSXIdentifier;
+}
+interface JSXNamespacedName extends BaseNode {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier;
+  name: JSXIdentifier;
+}
+interface JSXOpeningElement extends BaseNode {
+  type: "JSXOpeningElement";
+  name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+  attributes: (JSXAttribute | JSXSpreadAttribute)[];
+  selfClosing: boolean;
+  typeArguments?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+interface JSXSpreadAttribute extends BaseNode {
+  type: "JSXSpreadAttribute";
+  argument: Expression$1;
+}
+interface JSXText extends BaseNode {
+  type: "JSXText";
+  value: string;
+}
+interface JSXFragment extends BaseNode {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  closingFragment: JSXClosingFragment;
+  children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
+}
+interface JSXOpeningFragment extends BaseNode {
+  type: "JSXOpeningFragment";
+}
+interface JSXClosingFragment extends BaseNode {
+  type: "JSXClosingFragment";
+}
+interface V8IntrinsicIdentifier extends BaseNode {
+  type: "V8IntrinsicIdentifier";
+  name: string;
+}
+interface ArgumentPlaceholder extends BaseNode {
+  type: "ArgumentPlaceholder";
+}
+interface BindExpression extends BaseNode {
+  type: "BindExpression";
+  object: null | Expression$1;
+  callee: Expression$1;
+}
+interface ClassAccessorPropertyComputed extends BaseNode {
+  type: "ClassAccessorProperty";
+  value?: Expression$1 | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+  decorators?: Decorator[] | null;
+  static: boolean;
+  abstract?: boolean | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  declare?: boolean | null;
+  definite?: boolean | null;
+  optional?: boolean | null;
+  override?: boolean | null;
+  readonly?: boolean | null;
+  variance?: Variance | null;
+  computed: true;
+  key: Expression$1;
+}
+interface ClassAccessorPropertyNonComputed extends BaseNode {
+  type: "ClassAccessorProperty";
+  value?: Expression$1 | null;
+  typeAnnotation?: TypeAnnotation | TSTypeAnnotation | null;
+  decorators?: Decorator[] | null;
+  static: boolean;
+  abstract?: boolean | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  declare?: boolean | null;
+  definite?: boolean | null;
+  optional?: boolean | null;
+  override?: boolean | null;
+  readonly?: boolean | null;
+  variance?: Variance | null;
+  computed: false;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | PrivateName;
+}
+type ClassAccessorProperty = ClassAccessorPropertyComputed | ClassAccessorPropertyNonComputed;
+interface Decorator extends BaseNode {
+  type: "Decorator";
+  expression: Expression$1;
+}
+interface DoExpression extends BaseNode {
+  type: "DoExpression";
+  body: BlockStatement;
+  async: boolean;
+}
+interface ExportDefaultSpecifier extends BaseNode {
+  type: "ExportDefaultSpecifier";
+  exported: Identifier;
+}
+interface ModuleExpression extends BaseNode {
+  type: "ModuleExpression";
+  body: Program;
+}
+interface TopicReference extends BaseNode {
+  type: "TopicReference";
+}
+interface VoidPattern extends BaseNode {
+  type: "VoidPattern";
+}
+interface TSParameterProperty extends BaseNode {
+  type: "TSParameterProperty";
+  parameter: Identifier | AssignmentPattern;
+  accessibility?: "public" | "private" | "protected" | null;
+  decorators?: Decorator[] | null;
+  override?: boolean | null;
+  readonly?: boolean | null;
+}
+interface TSDeclareFunction extends BaseNode {
+  type: "TSDeclareFunction";
+  id?: Identifier | null;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FunctionParameter[];
+  returnType?: TSTypeAnnotation | null;
+  async: boolean;
+  declare?: boolean | null;
+  generator: boolean;
+}
+interface TSDeclareMethodComputed extends BaseNode {
+  type: "TSDeclareMethod";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (FunctionParameter | TSParameterProperty)[];
+  returnType?: TSTypeAnnotation | null;
+  abstract?: boolean | null;
+  access?: "public" | "private" | "protected" | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  async: boolean;
+  generator: boolean;
+  kind: "get" | "set" | "method" | "constructor";
+  optional?: boolean | null;
+  override?: boolean | null;
+  static: boolean;
+  computed: true;
+  key: Expression$1;
+}
+interface TSDeclareMethodNonComputed extends BaseNode {
+  type: "TSDeclareMethod";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (FunctionParameter | TSParameterProperty)[];
+  returnType?: TSTypeAnnotation | null;
+  abstract?: boolean | null;
+  access?: "public" | "private" | "protected" | null;
+  accessibility?: "public" | "private" | "protected" | null;
+  async: boolean;
+  generator: boolean;
+  kind: "get" | "set" | "method" | "constructor";
+  optional?: boolean | null;
+  override?: boolean | null;
+  static: boolean;
+  computed: false;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | PrivateName;
+}
+type TSDeclareMethod = TSDeclareMethodComputed | TSDeclareMethodNonComputed;
+interface TSQualifiedName extends BaseNode {
+  type: "TSQualifiedName";
+  left: TSEntityName;
+  right: Identifier;
+}
+interface TSCallSignatureDeclaration extends BaseNode {
+  type: "TSCallSignatureDeclaration";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  returnType?: TSTypeAnnotation | null;
+}
+interface TSConstructSignatureDeclaration extends BaseNode {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  returnType?: TSTypeAnnotation | null;
+}
+interface TSPropertySignature extends BaseNode {
+  type: "TSPropertySignature";
+  key: Expression$1;
+  typeAnnotation?: TSTypeAnnotation | null;
+  computed: boolean;
+  kind?: "get" | "set" | null;
+  optional?: boolean | null;
+  readonly?: boolean | null;
+}
+interface TSMethodSignature extends BaseNode {
+  type: "TSMethodSignature";
+  key: Expression$1;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  returnType?: TSTypeAnnotation | null;
+  computed: boolean;
+  kind: "method" | "get" | "set";
+  optional?: boolean | null;
+}
+interface TSIndexSignature extends BaseNode {
+  type: "TSIndexSignature";
+  parameters: Identifier[];
+  typeAnnotation?: TSTypeAnnotation | null;
+  readonly?: boolean | null;
+  static?: boolean | null;
+}
+interface TSAnyKeyword extends BaseNode {
+  type: "TSAnyKeyword";
+}
+interface TSBooleanKeyword extends BaseNode {
+  type: "TSBooleanKeyword";
+}
+interface TSBigIntKeyword extends BaseNode {
+  type: "TSBigIntKeyword";
+}
+interface TSIntrinsicKeyword extends BaseNode {
+  type: "TSIntrinsicKeyword";
+}
+interface TSNeverKeyword extends BaseNode {
+  type: "TSNeverKeyword";
+}
+interface TSNullKeyword extends BaseNode {
+  type: "TSNullKeyword";
+}
+interface TSNumberKeyword extends BaseNode {
+  type: "TSNumberKeyword";
+}
+interface TSObjectKeyword extends BaseNode {
+  type: "TSObjectKeyword";
+}
+interface TSStringKeyword extends BaseNode {
+  type: "TSStringKeyword";
+}
+interface TSSymbolKeyword extends BaseNode {
+  type: "TSSymbolKeyword";
+}
+interface TSUndefinedKeyword extends BaseNode {
+  type: "TSUndefinedKeyword";
+}
+interface TSUnknownKeyword extends BaseNode {
+  type: "TSUnknownKeyword";
+}
+interface TSVoidKeyword extends BaseNode {
+  type: "TSVoidKeyword";
+}
+interface TSThisType extends BaseNode {
+  type: "TSThisType";
+}
+interface TSFunctionType extends BaseNode {
+  type: "TSFunctionType";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  returnType?: TSTypeAnnotation | null;
+}
+interface TSConstructorType extends BaseNode {
+  type: "TSConstructorType";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  returnType?: TSTypeAnnotation | null;
+  abstract?: boolean | null;
+}
+interface TSTypeReference extends BaseNode {
+  type: "TSTypeReference";
+  typeName: TSEntityName;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+interface TSTypePredicate extends BaseNode {
+  type: "TSTypePredicate";
+  parameterName: Identifier | TSThisType;
+  typeAnnotation?: TSTypeAnnotation | null;
+  asserts?: boolean | null;
+}
+interface TSTypeQuery extends BaseNode {
+  type: "TSTypeQuery";
+  exprName: TSEntityName | TSImportType;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+interface TSTypeLiteral extends BaseNode {
+  type: "TSTypeLiteral";
+  members: TSTypeElement[];
+}
+interface TSArrayType extends BaseNode {
+  type: "TSArrayType";
+  elementType: TSType;
+}
+interface TSTupleType extends BaseNode {
+  type: "TSTupleType";
+  elementTypes: (TSType | TSNamedTupleMember)[];
+}
+interface TSOptionalType extends BaseNode {
+  type: "TSOptionalType";
+  typeAnnotation: TSType;
+}
+interface TSRestType extends BaseNode {
+  type: "TSRestType";
+  typeAnnotation: TSType;
+}
+interface TSNamedTupleMember extends BaseNode {
+  type: "TSNamedTupleMember";
+  label: Identifier;
+  elementType: TSType;
+  optional: boolean;
+}
+interface TSUnionType extends BaseNode {
+  type: "TSUnionType";
+  types: TSType[];
+}
+interface TSIntersectionType extends BaseNode {
+  type: "TSIntersectionType";
+  types: TSType[];
+}
+interface TSConditionalType extends BaseNode {
+  type: "TSConditionalType";
+  checkType: TSType;
+  extendsType: TSType;
+  trueType: TSType;
+  falseType: TSType;
+}
+interface TSInferType extends BaseNode {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
+}
+interface TSParenthesizedType extends BaseNode {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType;
+}
+interface TSTypeOperator extends BaseNode {
+  type: "TSTypeOperator";
+  typeAnnotation: TSType;
+  operator: "keyof" | "readonly" | "unique";
+}
+interface TSIndexedAccessType extends BaseNode {
+  type: "TSIndexedAccessType";
+  objectType: TSType;
+  indexType: TSType;
+}
+interface TSMappedType extends BaseNode {
+  type: "TSMappedType";
+  key: Identifier;
+  constraint: TSType;
+  nameType?: TSType | null;
+  typeAnnotation?: TSType | null;
+  optional?: true | false | "+" | "-" | null;
+  readonly?: true | false | "+" | "-" | null;
+}
+interface TSTemplateLiteralType extends BaseNode {
+  type: "TSTemplateLiteralType";
+  quasis: TemplateElement[];
+  types: TSType[];
+}
+interface TSLiteralType extends BaseNode {
+  type: "TSLiteralType";
+  literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression;
+}
+interface TSClassImplements extends BaseNode {
+  type: "TSClassImplements";
+  expression: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+interface TSInterfaceHeritage extends BaseNode {
+  type: "TSInterfaceHeritage";
+  expression: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+interface TSInterfaceDeclaration extends BaseNode {
+  type: "TSInterfaceDeclaration";
+  id: Identifier;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  extends?: TSInterfaceHeritage[] | null;
+  body: TSInterfaceBody;
+  declare?: boolean | null;
+}
+interface TSInterfaceBody extends BaseNode {
+  type: "TSInterfaceBody";
+  body: TSTypeElement[];
+}
+interface TSTypeAliasDeclaration extends BaseNode {
+  type: "TSTypeAliasDeclaration";
+  id: Identifier;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSType;
+  declare?: boolean | null;
+}
+interface TSInstantiationExpression extends BaseNode {
+  type: "TSInstantiationExpression";
+  expression: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+interface TSAsExpression extends BaseNode {
+  type: "TSAsExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType;
+}
+interface TSSatisfiesExpression extends BaseNode {
+  type: "TSSatisfiesExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType;
+}
+interface TSTypeAssertion extends BaseNode {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType;
+  expression: Expression$1;
+}
+interface TSEnumBody extends BaseNode {
+  type: "TSEnumBody";
+  members: TSEnumMember[];
+}
+interface TSEnumDeclaration extends BaseNode {
+  type: "TSEnumDeclaration";
+  id: Identifier;
+  body: TSEnumBody;
+  const?: boolean | null;
+  declare?: boolean | null;
+}
+interface TSEnumMember extends BaseNode {
+  type: "TSEnumMember";
+  id: Identifier | StringLiteral;
+  initializer?: Expression$1 | null;
+}
+interface TSModuleDeclaration extends BaseNode {
+  type: "TSModuleDeclaration";
+  id: TSEntityName | StringLiteral;
+  body: TSModuleBlock;
+  declare?: boolean | null;
+  kind: "global" | "namespace" | "module";
+}
+interface TSModuleBlock extends BaseNode {
+  type: "TSModuleBlock";
+  body: Statement[];
+}
+interface TSImportType extends BaseNode {
+  type: "TSImportType";
+  source: StringLiteral;
+  qualifier?: TSEntityName | null;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  options?: ObjectExpression | null;
+}
+interface TSImportEqualsDeclaration extends BaseNode {
+  type: "TSImportEqualsDeclaration";
+  id: Identifier;
+  moduleReference: TSEntityName | TSExternalModuleReference;
+  importKind?: "type" | "value" | null;
+}
+interface TSExternalModuleReference extends BaseNode {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral;
+}
+interface TSNonNullExpression extends BaseNode {
+  type: "TSNonNullExpression";
+  expression: Expression$1;
+}
+interface TSExportAssignment extends BaseNode {
+  type: "TSExportAssignment";
+  expression: Expression$1;
+}
+interface TSNamespaceExportDeclaration extends BaseNode {
+  type: "TSNamespaceExportDeclaration";
+  id: Identifier;
+}
+interface TSTypeAnnotation extends BaseNode {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType;
+}
+interface TSTypeParameterInstantiation extends BaseNode {
+  type: "TSTypeParameterInstantiation";
+  params: TSType[];
+}
+interface TSTypeParameterDeclaration extends BaseNode {
+  type: "TSTypeParameterDeclaration";
+  params: TSTypeParameter[];
+}
+interface TSTypeParameter extends BaseNode {
+  type: "TSTypeParameter";
+  constraint?: TSType | null;
+  default?: TSType | null;
+  name: Identifier;
+  const?: boolean | null;
+  in?: boolean | null;
+  out?: boolean | null;
+}
+type Expression$1 = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | SequenceExpression | ParenthesizedExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression | ClassExpression | MetaProperty | TaggedTemplateExpression | TemplateLiteral | YieldExpression | AwaitExpression | ImportExpression | BigIntLiteral | OptionalMemberExpression | OptionalCallExpression | TypeCastExpression | JSXElement | JSXFragment | BindExpression | DoExpression | ModuleExpression | TopicReference | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration | TSExportAssignment | TSNamespaceExportDeclaration;
+type FunctionParameter = Identifier | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern;
+type PatternLike = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+type TSEntityName = Identifier | ThisExpression | TSQualifiedName;
+type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ClassImplements | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | DeclaredPredicate | ExistsTypeAnnotation | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | InferredPredicate | InterfaceExtends | InterfaceDeclaration | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | BigIntLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | QualifiedTypeIdentifier | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | UnionTypeAnnotation | Variance | VoidTypeAnnotation | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | IndexedAccessType | OptionalIndexedAccessType;
+type FlowType = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ExistsTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | BigIntLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType;
+type FlowPredicate = DeclaredPredicate | InferredPredicate;
+type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature;
+type TSType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSNamedTupleMember | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSClassImplements | TSInterfaceHeritage | TSImportType;
+//#endregion
+//#region src/pageDeclaration/analyze.d.ts
+/**
+ * 共享普通脚本与 setup 的模块绑定，收集指向全局宏或规范导入的页面元信息调用。
+ */
+export declare function collectPageMetaCallsFromPrograms(programs: {
+  script?: File;
+  scriptSetup?: File;
+}): CallExpression[];
+//#endregion
+//#region src/pageDeclaration/index.d.ts
+interface StripPageDeclarationResult {
+  code: string;
+  map?: EncodedSourceMapLike;
+}
+interface ExtractPageDeclarationWithDependenciesResult {
+  declaration?: StaticPageDeclaration;
+  declarationSourceFile?: string;
+  dependencies: string[];
+}
+/**
+ * 源码是否可能包含页面路由声明宏。
+ */
+export declare function mayContainPageDeclaration(source: string): boolean;
+/**
+ * 源码是否可能包含页面元信息宏。
+ */
+export declare function mayContainPageMeta(source: string): boolean;
+/**
+ * 解析页面声明，并返回由现有 SFC `src` 规则解析出的脚本依赖。
+ */
+export declare function extractPageDeclarationWithDependencies(source: string, filename: string, options?: ResolveSfcBlockSrcOptions): Promise<ExtractPageDeclarationWithDependenciesResult>;
+export declare function extractPageDeclaration(source: string, filename: string): StaticPageDeclaration | undefined;
+export declare function stripPageDeclaration(source: string, filename: string): StripPageDeclarationResult | undefined;
+//#endregion
 //#region src/runtimeCapabilities.d.ts
 /**
  * wevu 编译器内部使用的运行时能力规范顺序。
@@ -320,94 +1955,6 @@ interface WevuDefaults {
   component?: Record<string, any>;
 }
 //#endregion
-//#region src/utils/sourcemap.d.ts
-interface EncodedSourceMapLike {
-  version: number | string;
-  file?: string;
-  names: string[];
-  sourceRoot?: string;
-  sources: string[];
-  sourcesContent?: Array<string | null>;
-  mappings: string;
-}
-//#endregion
-//#region src/plugins/utils/vueSfcBlockSrc.d.ts
-/**
- * 解析 SFC block `src` 的配置。
- */
-interface ResolveSfcBlockSrcOptions {
-  resolveId?: (source: string, importer?: string) => Promise<string | undefined>;
-  readFile?: (id: string, options?: {
-    checkMtime?: boolean;
-  }) => Promise<string>;
-  checkMtime?: boolean;
-}
-/**
- * 解析 SFC 中带 `src` 的 block，并返回依赖列表。
- */
-export declare function resolveSfcBlockSrc(descriptor: SFCDescriptor, filename: string, options?: ResolveSfcBlockSrcOptions): Promise<{
-  descriptor: SFCDescriptor;
-  deps: string[];
-  templateResolvedId?: string;
-}>;
-//#endregion
-//#region src/plugins/utils/vueSfc.d.ts
-/**
- * 读取并解析 SFC 的配置。
- */
-interface ReadAndParseSfcOptions {
-  /**
-   * 直接传入源码以跳过文件读取。
-   */
-  source?: string;
-  /**
-   * 已完成 `<script src>` 预处理的源码。
-   */
-  preprocessedSource?: string;
-  /**
-   * 是否忽略空 SFC block。
-   */
-  ignoreEmpty?: boolean;
-  /**
-   * 是否按 mtime+size 检查文件变更（dev 推荐开启）。
-   */
-  checkMtime?: boolean;
-  /**
-   * 解析 <template>/<script>/<style> 的 src 引用。
-   */
-  resolveSrc?: ResolveSfcBlockSrcOptions;
-}
-/**
- * 预处理 `<script setup src>`，避免编译器丢失 src。
- */
-export declare function preprocessScriptSetupSrc(source: string): string;
-/**
- * 预处理普通 `<script src>`，避免编译器丢失 src。
- */
-export declare function preprocessScriptSrc(source: string): string;
-/**
- * 将预处理的 `<script setup src>` 恢复为真实 src。
- */
-export declare function restoreScriptSetupSrc(descriptor: SFCDescriptor): void;
-/**
- * 将预处理的 `<script src>` 恢复为真实 src。
- */
-export declare function restoreScriptSrc(descriptor: SFCDescriptor): void;
-/**
- * 读取并解析 SFC，支持缓存与 src 解析。
- */
-export declare function readAndParseSfc(filename: string, options?: ReadAndParseSfcOptions): Promise<{
-  source: string;
-  descriptor: SFCDescriptor;
-  errors: SFCParseResult['errors'];
-}>;
-/**
- * 获取 SFC 读取时是否检查 mtime 的策略。
- */
-export declare function getSfcCheckMtime(config?: {
-  isDev?: boolean;
-}): boolean;
-//#endregion
 //#region src/plugins/vue/compiler/template/platform.d.ts
 interface MiniProgramDirectiveAttrs {
   ifAttr: string;
@@ -831,6 +2378,12 @@ interface CompileVueFileOptions {
    * 是否根据绑定清单自动合并 setData.pick。
    */
   autoSetDataPick?: boolean;
+  /**
+   * 在开发期保持 CSS 变量运行时依赖与导出形状稳定。
+   *
+   * @internal
+   */
+  stabilizeCssVarsRuntime?: boolean;
   /**
    * 绑定清单中记录的源码文件名；默认使用当前编译文件名。
    */
@@ -1241,6 +2794,12 @@ interface TransformScriptOptions {
    * 当前 SFC 的 CSS Modules 映射。
    */
   cssModules?: Record<string, Record<string, string>>;
+  /**
+   * 注入空 CSS 变量注册，保持开发期运行时模块图稳定。
+   *
+   * @internal
+   */
+  stabilizeCssVarsRuntime?: boolean;
 }
 //#endregion
 //#region src/plugins/vue/transform/transformScript/index.d.ts
@@ -1419,4 +2978,4 @@ interface CollectVueTemplateTagsOptions {
  */
 export declare function collectVueTemplateTags(template: string, options: CollectVueTemplateTagsOptions): Set<string>;
 //#endregion
-export { type AstEngineName, type AutoImportTagsOptions, type AutoUsingComponentsOptions, type BindingCondition, type ClassStyleBinding, type ClassStyleRuntime, type CollectVueTemplateTagsOptions, type CompileVueFileOptions, type CompilerAppShell, type CompilerDiagnostic, type CompilerDiagnosticCode, type CompilerDiagnosticSeverity, type CompilerDiagnosticSource, type CompilerLayoutPropValue, type CompilerPageLayout, type CompilerPageLayoutPlan, type ComponentStyleOptions, type ComponentStylePrimitive, type ForParseResult, type InlineExpressionAsset, type JsLikeLang, type JsonConfig, type JsonMergeContext, type JsonMergeStage, type JsonMergeStrategy, type MiniProgramPlatform, type ModuleResolver, type MpPlatform, type ReadAndParseSfcOptions, type ResolveSfcBlockSrcOptions, type ResolvedUsingComponentInfo, type ResolvedUsingComponentPath, type ScopedSlotComponentAsset, type SlotFallbackWrapperComponentAsset, type SlotFallbackWrapperStrategy, type SourcePosition, type SourceSpan, type StaticComponentStyleOption, type StyleCompileOptions, type StyleCompileResult, type TemplateCompileOptions, type TemplateCompileResult, type TemplateRefBinding, type TransformResult, type TransformScriptOptions, type TransformUniAppSourceOptions, type UniAppCompatibilityTarget, type VueSfcBlockChanges, type VueSfcBlockSignatures, type VueSfcBlockType, type VueSfcHmrSignatures, type VueTransformResult, type WevuBindingDependencyV1, type WevuBindingKind, type WevuBindingManifestFeaturesV1, type WevuBindingManifestV1, type WevuBindingRecordV1, type WevuBindingScopeV1, type WevuBindingUpdateMode, type WevuDefaults, type WevuRuntimeBindingManifestMode, type WevuRuntimeBindingManifestV1, type WevuRuntimeBindingRecordV1, compileVueFile as compileSfc, compileVueStyleToWxss as compileStyle, compileVueTemplateToWxml as compileTemplate, transformScript as transformSfcScript };
+export { type AstEngineName, type AutoImportTagsOptions, type AutoUsingComponentsOptions, type BindingCondition, type ClassStyleBinding, type ClassStyleRuntime, type CollectVueTemplateTagsOptions, type CompileVueFileOptions, type CompilerAppShell, type CompilerDiagnostic, type CompilerDiagnosticCode, type CompilerDiagnosticSeverity, type CompilerDiagnosticSource, type CompilerLayoutPropValue, type CompilerPageLayout, type CompilerPageLayoutPlan, type ComponentStyleOptions, type ComponentStylePrimitive, type ExtractPageDeclarationWithDependenciesResult, type ForParseResult, type InlineExpressionAsset, type JsLikeLang, type JsonConfig, type JsonMergeContext, type JsonMergeStage, type JsonMergeStrategy, type MiniProgramPlatform, type ModuleResolver, type MpPlatform, type ReadAndParseSfcOptions, type ResolveSfcBlockSrcOptions, type ResolvedUsingComponentInfo, type ResolvedUsingComponentPath, type ScopedSlotComponentAsset, type SlotFallbackWrapperComponentAsset, type SlotFallbackWrapperStrategy, type SourcePosition, type SourceSpan, type StaticComponentStyleOption, type StaticPageDeclaration, type StaticRouteValue, type StyleCompileOptions, type StyleCompileResult, type TemplateCompileOptions, type TemplateCompileResult, type TemplateRefBinding, type TransformResult, type TransformScriptOptions, type TransformUniAppSourceOptions, type UniAppCompatibilityTarget, type VueSfcBlockChanges, type VueSfcBlockSignatures, type VueSfcBlockType, type VueSfcHmrSignatures, type VueTransformResult, type WevuBindingDependencyV1, type WevuBindingKind, type WevuBindingManifestFeaturesV1, type WevuBindingManifestV1, type WevuBindingRecordV1, type WevuBindingScopeV1, type WevuBindingUpdateMode, type WevuDefaults, type WevuRuntimeBindingManifestMode, type WevuRuntimeBindingManifestV1, type WevuRuntimeBindingRecordV1, compileVueFile as compileSfc, compileVueStyleToWxss as compileStyle, compileVueTemplateToWxml as compileTemplate, transformScript as transformSfcScript };