@rspack/core 1.2.2 → 1.2.4

package/compiled/@swc/types/index.d.ts

@@ -1,8 +1,99 @@
-import { Assumptions } from "./assumptions";
-export interface Plugin {
+interface Assumptions {
+    /**
+     * https://babeljs.io/docs/en/assumptions#arraylikeisiterable
+     */
+    arrayLikeIsIterable?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#constantreexports
+     */
+    constantReexports?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#constantsuper
+     */
+    constantSuper?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#enumerablemodulemeta
+     */
+    enumerableModuleMeta?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#ignorefunctionlength
+     */
+    ignoreFunctionLength?: boolean;
+    ignoreFunctionName?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#ignoretoprimitivehint
+     */
+    ignoreToPrimitiveHint?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#iterableisarray
+     */
+    iterableIsArray?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#mutabletemplateobject
+     */
+    mutableTemplateObject?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#noclasscalls
+     */
+    noClassCalls?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#nodocumentall
+     */
+    noDocumentAll?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#noincompletensimportdetection
+     */
+    noIncompleteNsImportDetection?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#nonewarrows
+     */
+    noNewArrows?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#objectrestnosymbols
+     */
+    objectRestNoSymbols?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#privatefieldsasproperties
+     */
+    privateFieldsAsProperties?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#puregetters
+     */
+    pureGetters?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#setclassmethods
+     */
+    setClassMethods?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#setcomputedproperties
+     */
+    setComputedProperties?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#setpublicclassfields
+     */
+    setPublicClassFields?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#setspreadproperties
+     */
+    setSpreadProperties?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#skipforofiteratorclosing
+     */
+    skipForOfIteratorClosing?: boolean;
+    /**
+     * https://babeljs.io/docs/en/assumptions#superiscallableconstructor
+     */
+    superIsCallableConstructor?: boolean;
+    /**
+     * @deprecated This value will be always true
+     */
+    tsEnumIsReadonly?: boolean;
+}
+
+interface Plugin {
     (module: Program): Program;
 }
-export type ParseOptions = ParserConfig & {
+type ParseOptions = ParserConfig & {
     comments?: boolean;
     script?: boolean;
     /**
@@ -10,8 +101,8 @@ export type ParseOptions = ParserConfig & {
      */
     target?: JscTarget;
 };
-export type TerserEcmaVersion = 5 | 2015 | 2016 | string | number;
-export interface JsMinifyOptions {
+type TerserEcmaVersion = 5 | 2015 | 2016 | string | number;
+interface JsMinifyOptions {
     compress?: TerserCompressOptions | boolean;
     format?: JsFormatOptions & ToSnakeCaseProperties<JsFormatOptions>;
     mangle?: TerserMangleOptions | boolean;
@@ -40,7 +131,7 @@ type ToSnakeCaseProperties<T> = {
  * but it exists to support passing terser config to swc minify
  * without modification.
  */
-export interface JsFormatOptions {
+interface JsFormatOptions {
     /**
      * Currently noop.
      * @default false
@@ -145,7 +236,7 @@ export interface JsFormatOptions {
      */
     wrapFuncArgs?: boolean;
 }
-export interface TerserCompressOptions {
+interface TerserCompressOptions {
     arguments?: boolean;
     arrows?: boolean;
     booleans?: boolean;
@@ -203,7 +294,7 @@ export interface TerserCompressOptions {
     const_to_let?: boolean;
     module?: boolean;
 }
-export interface TerserMangleOptions {
+interface TerserMangleOptions {
     props?: TerserManglePropertiesOptions;
     /**
      * Pass `true` to mangle names declared in the top level scope.
@@ -241,12 +332,12 @@ export interface TerserMangleOptions {
     safari10?: boolean;
     reserved?: string[];
 }
-export interface TerserManglePropertiesOptions {
+interface TerserManglePropertiesOptions {
 }
 /**
  * Programmatic options.
  */
-export interface Options extends Config {
+interface Options extends Config {
     /**
      * If true, a file is parsed as a script instead of module.
      */
@@ -400,15 +491,15 @@ export interface Options extends Config {
      */
     outputPath?: string;
 }
-export interface CallerOptions {
+interface CallerOptions {
     name: string;
     [key: string]: any;
 }
-export type Swcrc = Config | Config[];
+type Swcrc = Config | Config[];
 /**
  * .swcrc
  */
-export interface Config {
+interface Config {
     /**
      * Note: The type is string because it follows rust's regex syntax.
      */
@@ -438,7 +529,7 @@ export interface Config {
 /**
  * Configuration ported from babel-preset-env
  */
-export interface EnvConfig {
+interface EnvConfig {
     mode?: "usage" | "entry";
     debug?: boolean;
     dynamicImport?: boolean;
@@ -465,7 +556,7 @@ export interface EnvConfig {
      */
     forceAllTransforms?: boolean;
 }
-export interface JscConfig {
+interface JscConfig {
     assumptions?: Assumptions;
     loose?: boolean;
     /**
@@ -545,9 +636,9 @@ export interface JscConfig {
     minify?: JsMinifyOptions;
     preserveAllComments?: boolean;
 }
-export type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "esnext";
-export type ParserConfig = TsParserConfig | EsParserConfig;
-export interface TsParserConfig {
+type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "esnext";
+type ParserConfig = TsParserConfig | EsParserConfig;
+interface TsParserConfig {
     syntax: "typescript";
     /**
      * Defaults to `false`.
@@ -562,7 +653,7 @@ export interface TsParserConfig {
      */
     dynamicImport?: boolean;
 }
-export interface EsParserConfig {
+interface EsParserConfig {
     syntax: "ecmascript";
     /**
      * Defaults to false.
@@ -652,7 +743,7 @@ export interface EsParserConfig {
 /**
  * Options for transform.
  */
-export interface TransformConfig {
+interface TransformConfig {
     /**
      * Effective only if `syntax` supports ƒ.
      */
@@ -677,7 +768,7 @@ export interface TransformConfig {
     treatConstEnumAsEnum?: boolean;
     useDefineForClassFields?: boolean;
 }
-export interface ReactConfig {
+interface ReactConfig {
     /**
      * Replace the function used when compiling JSX expressions.
      *
@@ -731,14 +822,14 @@ export interface ReactConfig {
  *
  * See: https://github.com/swc-project/swc/issues/18#issuecomment-466272558
  */
-export interface ConstModulesConfig {
+interface ConstModulesConfig {
     globals?: {
         [module: string]: {
             [name: string]: string;
         };
     };
 }
-export interface OptimizerConfig {
+interface OptimizerConfig {
     simplify?: boolean;
     globals?: GlobalPassOption;
     jsonify?: {
@@ -748,7 +839,7 @@ export interface OptimizerConfig {
 /**
  * Options for inline-global pass.
  */
-export interface GlobalPassOption {
+interface GlobalPassOption {
     /**
      * Global variables that should be inlined with passed value.
      *
@@ -768,8 +859,8 @@ export interface GlobalPassOption {
      */
     typeofs?: Record<string, string>;
 }
-export type ModuleConfig = Es6Config | CommonJsConfig | UmdConfig | AmdConfig | NodeNextConfig | SystemjsConfig;
-export interface BaseModuleConfig {
+type ModuleConfig = Es6Config | CommonJsConfig | UmdConfig | AmdConfig | NodeNextConfig | SystemjsConfig;
+interface BaseModuleConfig {
     /**
      * By default, when using exports with babel a non-enumerable `__esModule`
      * property is exported. In some cases this property is used to determine
@@ -937,30 +1028,30 @@ export interface BaseModuleConfig {
     allowTopLevelThis?: boolean;
     preserveImportMeta?: boolean;
 }
-export interface Es6Config extends BaseModuleConfig {
+interface Es6Config extends BaseModuleConfig {
     type: "es6";
 }
-export interface NodeNextConfig extends BaseModuleConfig {
+interface NodeNextConfig extends BaseModuleConfig {
     type: "nodenext";
 }
-export interface CommonJsConfig extends BaseModuleConfig {
+interface CommonJsConfig extends BaseModuleConfig {
     type: "commonjs";
 }
-export interface UmdConfig extends BaseModuleConfig {
+interface UmdConfig extends BaseModuleConfig {
     type: "umd";
     globals?: {
         [key: string]: string;
     };
 }
-export interface AmdConfig extends BaseModuleConfig {
+interface AmdConfig extends BaseModuleConfig {
     type: "amd";
     moduleId?: string;
 }
-export interface SystemjsConfig {
+interface SystemjsConfig {
     type: "systemjs";
     allowTopLevelThis?: boolean;
 }
-export interface Output {
+interface Output {
     /**
      * Transformed code
      */
@@ -970,23 +1061,23 @@ export interface Output {
      */
     map?: string;
 }
-export interface MatchPattern {
+interface MatchPattern {
 }
-export interface Span {
+interface Span {
     start: number;
     end: number;
     ctxt: number;
 }
-export interface Node {
+interface Node {
     type: string;
 }
-export interface HasSpan {
+interface HasSpan {
     span: Span;
 }
-export interface HasDecorator {
+interface HasDecorator {
     decorators?: Decorator[];
 }
-export interface Class extends HasSpan, HasDecorator {
+interface Class extends HasSpan, HasDecorator {
     body: ClassMember[];
     superClass?: Expression;
     isAbstract: boolean;
@@ -994,8 +1085,8 @@ export interface Class extends HasSpan, HasDecorator {
     superTypeParams?: TsTypeParameterInstantiation;
     implements: TsExpressionWithTypeArguments[];
 }
-export type ClassMember = Constructor | ClassMethod | PrivateMethod | ClassProperty | PrivateProperty | TsIndexSignature | EmptyStatement | StaticBlock;
-export interface ClassPropertyBase extends Node, HasSpan, HasDecorator {
+type ClassMember = Constructor | ClassMethod | PrivateMethod | ClassProperty | PrivateProperty | TsIndexSignature | EmptyStatement | StaticBlock;
+interface ClassPropertyBase extends Node, HasSpan, HasDecorator {
     value?: Expression;
     typeAnnotation?: TsTypeAnnotation;
     isStatic: boolean;
@@ -1005,21 +1096,21 @@ export interface ClassPropertyBase extends Node, HasSpan, HasDecorator {
     readonly: boolean;
     definite: boolean;
 }
-export interface ClassProperty extends ClassPropertyBase {
+interface ClassProperty extends ClassPropertyBase {
     type: "ClassProperty";
     key: PropertyName;
     isAbstract: boolean;
     declare: boolean;
 }
-export interface PrivateProperty extends ClassPropertyBase {
+interface PrivateProperty extends ClassPropertyBase {
     type: "PrivateProperty";
     key: PrivateName;
 }
-export interface Param extends Node, HasSpan, HasDecorator {
+interface Param extends Node, HasSpan, HasDecorator {
     type: "Parameter";
     pat: Pattern;
 }
-export interface Constructor extends Node, HasSpan {
+interface Constructor extends Node, HasSpan {
     type: "Constructor";
     key: PropertyName;
     params: (TsParameterProperty | Param)[];
@@ -1027,7 +1118,7 @@ export interface Constructor extends Node, HasSpan {
     accessibility?: Accessibility;
     isOptional: boolean;
 }
-export interface ClassMethodBase extends Node, HasSpan {
+interface ClassMethodBase extends Node, HasSpan {
     function: Fn;
     kind: MethodKind;
     isStatic: boolean;
@@ -1036,56 +1127,56 @@ export interface ClassMethodBase extends Node, HasSpan {
     isOptional: boolean;
     isOverride: boolean;
 }
-export interface ClassMethod extends ClassMethodBase {
+interface ClassMethod extends ClassMethodBase {
     type: "ClassMethod";
     key: PropertyName;
 }
-export interface PrivateMethod extends ClassMethodBase {
+interface PrivateMethod extends ClassMethodBase {
     type: "PrivateMethod";
     key: PrivateName;
 }
-export interface StaticBlock extends Node, HasSpan {
+interface StaticBlock extends Node, HasSpan {
     type: "StaticBlock";
     body: BlockStatement;
 }
-export interface Decorator extends Node, HasSpan {
+interface Decorator extends Node, HasSpan {
     type: "Decorator";
     expression: Expression;
 }
-export type MethodKind = "method" | "getter" | "setter";
-export type Declaration = ClassDeclaration | FunctionDeclaration | VariableDeclaration | TsInterfaceDeclaration | TsTypeAliasDeclaration | TsEnumDeclaration | TsModuleDeclaration;
-export interface FunctionDeclaration extends Fn {
+type MethodKind = "method" | "getter" | "setter";
+type Declaration = ClassDeclaration | FunctionDeclaration | VariableDeclaration | TsInterfaceDeclaration | TsTypeAliasDeclaration | TsEnumDeclaration | TsModuleDeclaration;
+interface FunctionDeclaration extends Fn {
     type: "FunctionDeclaration";
     identifier: Identifier;
     declare: boolean;
 }
-export interface ClassDeclaration extends Class, Node {
+interface ClassDeclaration extends Class, Node {
     type: "ClassDeclaration";
     identifier: Identifier;
     declare: boolean;
 }
-export interface VariableDeclaration extends Node, HasSpan {
+interface VariableDeclaration extends Node, HasSpan {
     type: "VariableDeclaration";
     kind: VariableDeclarationKind;
     declare: boolean;
     declarations: VariableDeclarator[];
 }
-export type VariableDeclarationKind = "var" | "let" | "const";
-export interface VariableDeclarator extends Node, HasSpan {
+type VariableDeclarationKind = "var" | "let" | "const";
+interface VariableDeclarator extends Node, HasSpan {
     type: "VariableDeclarator";
     id: Pattern;
     init?: Expression;
     definite: boolean;
 }
-export type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | MemberExpression | SuperPropExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier | Literal | TemplateLiteral | TaggedTemplateExpression | ArrowFunctionExpression | ClassExpression | YieldExpression | MetaProperty | AwaitExpression | ParenthesisExpression | JSXMemberExpression | JSXNamespacedName | JSXEmptyExpression | JSXElement | JSXFragment | TsTypeAssertion | TsConstAssertion | TsNonNullExpression | TsAsExpression | TsSatisfiesExpression | TsInstantiation | PrivateName | OptionalChainingExpression | Invalid;
+type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | MemberExpression | SuperPropExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier | Literal | TemplateLiteral | TaggedTemplateExpression | ArrowFunctionExpression | ClassExpression | YieldExpression | MetaProperty | AwaitExpression | ParenthesisExpression | JSXMemberExpression | JSXNamespacedName | JSXEmptyExpression | JSXElement | JSXFragment | TsTypeAssertion | TsConstAssertion | TsNonNullExpression | TsAsExpression | TsSatisfiesExpression | TsInstantiation | PrivateName | OptionalChainingExpression | Invalid;
 interface ExpressionBase extends Node, HasSpan {
 }
-export interface Identifier extends ExpressionBase {
+interface Identifier extends ExpressionBase {
     type: "Identifier";
     value: string;
     optional: boolean;
 }
-export interface OptionalChainingExpression extends ExpressionBase {
+interface OptionalChainingExpression extends ExpressionBase {
     type: "OptionalChainingExpression";
     questionDotToken: Span;
     /**
@@ -1093,106 +1184,106 @@ export interface OptionalChainingExpression extends ExpressionBase {
      */
     base: MemberExpression | OptionalChainingCall;
 }
-export interface OptionalChainingCall extends ExpressionBase {
+interface OptionalChainingCall extends ExpressionBase {
     type: "CallExpression";
     callee: Expression;
     arguments: ExprOrSpread[];
     typeArguments?: TsTypeParameterInstantiation;
 }
-export interface ThisExpression extends ExpressionBase {
+interface ThisExpression extends ExpressionBase {
     type: "ThisExpression";
 }
-export interface ArrayExpression extends ExpressionBase {
+interface ArrayExpression extends ExpressionBase {
     type: "ArrayExpression";
     elements: (ExprOrSpread | undefined)[];
 }
-export interface ExprOrSpread {
+interface ExprOrSpread {
     spread?: Span;
     expression: Expression;
 }
-export interface ObjectExpression extends ExpressionBase {
+interface ObjectExpression extends ExpressionBase {
     type: "ObjectExpression";
     properties: (SpreadElement | Property)[];
 }
-export interface Argument {
+interface Argument {
     spread?: Span;
     expression: Expression;
 }
-export interface SpreadElement extends Node {
+interface SpreadElement extends Node {
     type: "SpreadElement";
     spread: Span;
     arguments: Expression;
 }
-export interface UnaryExpression extends ExpressionBase {
+interface UnaryExpression extends ExpressionBase {
     type: "UnaryExpression";
     operator: UnaryOperator;
     argument: Expression;
 }
-export interface UpdateExpression extends ExpressionBase {
+interface UpdateExpression extends ExpressionBase {
     type: "UpdateExpression";
     operator: UpdateOperator;
     prefix: boolean;
     argument: Expression;
 }
-export interface BinaryExpression extends ExpressionBase {
+interface BinaryExpression extends ExpressionBase {
     type: "BinaryExpression";
     operator: BinaryOperator;
     left: Expression;
     right: Expression;
 }
-export interface FunctionExpression extends Fn, ExpressionBase {
+interface FunctionExpression extends Fn, ExpressionBase {
     type: "FunctionExpression";
     identifier?: Identifier;
 }
-export interface ClassExpression extends Class, ExpressionBase {
+interface ClassExpression extends Class, ExpressionBase {
     type: "ClassExpression";
     identifier?: Identifier;
 }
-export interface AssignmentExpression extends ExpressionBase {
+interface AssignmentExpression extends ExpressionBase {
     type: "AssignmentExpression";
     operator: AssignmentOperator;
     left: Expression | Pattern;
     right: Expression;
 }
-export interface MemberExpression extends ExpressionBase {
+interface MemberExpression extends ExpressionBase {
     type: "MemberExpression";
     object: Expression;
     property: Identifier | PrivateName | ComputedPropName;
 }
-export interface SuperPropExpression extends ExpressionBase {
+interface SuperPropExpression extends ExpressionBase {
     type: "SuperPropExpression";
     obj: Super;
     property: Identifier | ComputedPropName;
 }
-export interface ConditionalExpression extends ExpressionBase {
+interface ConditionalExpression extends ExpressionBase {
     type: "ConditionalExpression";
     test: Expression;
     consequent: Expression;
     alternate: Expression;
 }
-export interface Super extends Node, HasSpan {
+interface Super extends Node, HasSpan {
     type: "Super";
 }
-export interface Import extends Node, HasSpan {
+interface Import extends Node, HasSpan {
     type: "Import";
 }
-export interface CallExpression extends ExpressionBase {
+interface CallExpression extends ExpressionBase {
     type: "CallExpression";
     callee: Super | Import | Expression;
     arguments: Argument[];
     typeArguments?: TsTypeParameterInstantiation;
 }
-export interface NewExpression extends ExpressionBase {
+interface NewExpression extends ExpressionBase {
     type: "NewExpression";
     callee: Expression;
     arguments?: Argument[];
     typeArguments?: TsTypeParameterInstantiation;
 }
-export interface SequenceExpression extends ExpressionBase {
+interface SequenceExpression extends ExpressionBase {
     type: "SequenceExpression";
     expressions: Expression[];
 }
-export interface ArrowFunctionExpression extends ExpressionBase {
+interface ArrowFunctionExpression extends ExpressionBase {
     type: "ArrowFunctionExpression";
     params: Pattern[];
     body: BlockStatement | Expression;
@@ -1201,41 +1292,41 @@ export interface ArrowFunctionExpression extends ExpressionBase {
     typeParameters?: TsTypeParameterDeclaration;
     returnType?: TsTypeAnnotation;
 }
-export interface YieldExpression extends ExpressionBase {
+interface YieldExpression extends ExpressionBase {
     type: "YieldExpression";
     argument?: Expression;
     delegate: boolean;
 }
-export interface MetaProperty extends Node, HasSpan {
+interface MetaProperty extends Node, HasSpan {
     type: "MetaProperty";
     kind: "new.target" | "import.meta";
 }
-export interface AwaitExpression extends ExpressionBase {
+interface AwaitExpression extends ExpressionBase {
     type: "AwaitExpression";
     argument: Expression;
 }
-export interface TemplateLiteral extends ExpressionBase {
+interface TemplateLiteral extends ExpressionBase {
     type: "TemplateLiteral";
     expressions: Expression[];
     quasis: TemplateElement[];
 }
-export interface TaggedTemplateExpression extends ExpressionBase {
+interface TaggedTemplateExpression extends ExpressionBase {
     type: "TaggedTemplateExpression";
     tag: Expression;
     typeParameters?: TsTypeParameterInstantiation;
     template: TemplateLiteral;
 }
-export interface TemplateElement extends ExpressionBase {
+interface TemplateElement extends ExpressionBase {
     type: "TemplateElement";
     tail: boolean;
     cooked?: string;
     raw: string;
 }
-export interface ParenthesisExpression extends ExpressionBase {
+interface ParenthesisExpression extends ExpressionBase {
     type: "ParenthesisExpression";
     expression: Expression;
 }
-export interface Fn extends HasSpan, HasDecorator {
+interface Fn extends HasSpan, HasDecorator {
     params: Param[];
     body?: BlockStatement;
     generator: boolean;
@@ -1246,12 +1337,12 @@ export interface Fn extends HasSpan, HasDecorator {
 interface PatternBase extends Node, HasSpan {
     typeAnnotation?: TsTypeAnnotation;
 }
-export interface PrivateName extends ExpressionBase {
+interface PrivateName extends ExpressionBase {
     type: "PrivateName";
     id: Identifier;
 }
-export type JSXObject = JSXMemberExpression | Identifier;
-export interface JSXMemberExpression extends Node {
+type JSXObject = JSXMemberExpression | Identifier;
+interface JSXMemberExpression extends Node {
     type: "JSXMemberExpression";
     object: JSXObject;
     property: Identifier;
@@ -1259,112 +1350,112 @@ export interface JSXMemberExpression extends Node {
 /**
  * XML-based namespace syntax:
  */
-export interface JSXNamespacedName extends Node {
+interface JSXNamespacedName extends Node {
     type: "JSXNamespacedName";
     namespace: Identifier;
     name: Identifier;
 }
-export interface JSXEmptyExpression extends Node, HasSpan {
+interface JSXEmptyExpression extends Node, HasSpan {
     type: "JSXEmptyExpression";
 }
-export interface JSXExpressionContainer extends Node, HasSpan {
+interface JSXExpressionContainer extends Node, HasSpan {
     type: "JSXExpressionContainer";
     expression: JSXExpression;
 }
-export type JSXExpression = JSXEmptyExpression | Expression;
-export interface JSXSpreadChild extends Node, HasSpan {
+type JSXExpression = JSXEmptyExpression | Expression;
+interface JSXSpreadChild extends Node, HasSpan {
     type: "JSXSpreadChild";
     expression: Expression;
 }
-export type JSXElementName = Identifier | JSXMemberExpression | JSXNamespacedName;
-export interface JSXOpeningElement extends Node, HasSpan {
+type JSXElementName = Identifier | JSXMemberExpression | JSXNamespacedName;
+interface JSXOpeningElement extends Node, HasSpan {
     type: "JSXOpeningElement";
     name: JSXElementName;
     attributes: JSXAttributeOrSpread[];
     selfClosing: boolean;
     typeArguments?: TsTypeParameterInstantiation;
 }
-export type JSXAttributeOrSpread = JSXAttribute | SpreadElement;
-export interface JSXClosingElement extends Node, HasSpan {
+type JSXAttributeOrSpread = JSXAttribute | SpreadElement;
+interface JSXClosingElement extends Node, HasSpan {
     type: "JSXClosingElement";
     name: JSXElementName;
 }
-export interface JSXAttribute extends Node, HasSpan {
+interface JSXAttribute extends Node, HasSpan {
     type: "JSXAttribute";
     name: JSXAttributeName;
     value?: JSXAttrValue;
 }
-export type JSXAttributeName = Identifier | JSXNamespacedName;
-export type JSXAttrValue = Literal | JSXExpressionContainer | JSXElement | JSXFragment;
-export interface JSXText extends Node, HasSpan {
+type JSXAttributeName = Identifier | JSXNamespacedName;
+type JSXAttrValue = Literal | JSXExpressionContainer | JSXElement | JSXFragment;
+interface JSXText extends Node, HasSpan {
     type: "JSXText";
     value: string;
     raw: string;
 }
-export interface JSXElement extends Node, HasSpan {
+interface JSXElement extends Node, HasSpan {
     type: "JSXElement";
     opening: JSXOpeningElement;
     children: JSXElementChild[];
     closing?: JSXClosingElement;
 }
-export type JSXElementChild = JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment;
-export interface JSXFragment extends Node, HasSpan {
+type JSXElementChild = JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment;
+interface JSXFragment extends Node, HasSpan {
     type: "JSXFragment";
     opening: JSXOpeningFragment;
     children: JSXElementChild[];
     closing: JSXClosingFragment;
 }
-export interface JSXOpeningFragment extends Node, HasSpan {
+interface JSXOpeningFragment extends Node, HasSpan {
     type: "JSXOpeningFragment";
 }
-export interface JSXClosingFragment extends Node, HasSpan {
+interface JSXClosingFragment extends Node, HasSpan {
     type: "JSXClosingFragment";
 }
-export type Literal = StringLiteral | BooleanLiteral | NullLiteral | NumericLiteral | BigIntLiteral | RegExpLiteral | JSXText;
-export interface StringLiteral extends Node, HasSpan {
+type Literal = StringLiteral | BooleanLiteral | NullLiteral | NumericLiteral | BigIntLiteral | RegExpLiteral | JSXText;
+interface StringLiteral extends Node, HasSpan {
     type: "StringLiteral";
     value: string;
     raw?: string;
 }
-export interface BooleanLiteral extends Node, HasSpan {
+interface BooleanLiteral extends Node, HasSpan {
     type: "BooleanLiteral";
     value: boolean;
 }
-export interface NullLiteral extends Node, HasSpan {
+interface NullLiteral extends Node, HasSpan {
     type: "NullLiteral";
 }
-export interface RegExpLiteral extends Node, HasSpan {
+interface RegExpLiteral extends Node, HasSpan {
     type: "RegExpLiteral";
     pattern: string;
     flags: string;
 }
-export interface NumericLiteral extends Node, HasSpan {
+interface NumericLiteral extends Node, HasSpan {
     type: "NumericLiteral";
     value: number;
     raw?: string;
 }
-export interface BigIntLiteral extends Node, HasSpan {
+interface BigIntLiteral extends Node, HasSpan {
     type: "BigIntLiteral";
     value: bigint;
     raw?: string;
 }
-export type ModuleDeclaration = ImportDeclaration | ExportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportDefaultExpression | ExportAllDeclaration | TsImportEqualsDeclaration | TsExportAssignment | TsNamespaceExportDeclaration;
-export interface ExportDefaultExpression extends Node, HasSpan {
+type ModuleDeclaration = ImportDeclaration | ExportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportDefaultExpression | ExportAllDeclaration | TsImportEqualsDeclaration | TsExportAssignment | TsNamespaceExportDeclaration;
+interface ExportDefaultExpression extends Node, HasSpan {
     type: "ExportDefaultExpression";
     expression: Expression;
 }
-export interface ExportDeclaration extends Node, HasSpan {
+interface ExportDeclaration extends Node, HasSpan {
     type: "ExportDeclaration";
     declaration: Declaration;
 }
-export interface ImportDeclaration extends Node, HasSpan {
+interface ImportDeclaration extends Node, HasSpan {
     type: "ImportDeclaration";
     specifiers: ImportSpecifier[];
     source: StringLiteral;
     typeOnly: boolean;
     asserts?: ObjectExpression;
 }
-export interface ExportAllDeclaration extends Node, HasSpan {
+interface ExportAllDeclaration extends Node, HasSpan {
     type: "ExportAllDeclaration";
     source: StringLiteral;
     asserts?: ObjectExpression;
@@ -1373,30 +1464,30 @@ export interface ExportAllDeclaration extends Node, HasSpan {
  * - `export { foo } from 'mod'`
  * - `export { foo as bar } from 'mod'`
  */
-export interface ExportNamedDeclaration extends Node, HasSpan {
+interface ExportNamedDeclaration extends Node, HasSpan {
     type: "ExportNamedDeclaration";
     specifiers: ExportSpecifier[];
     source?: StringLiteral;
     typeOnly: boolean;
     asserts?: ObjectExpression;
 }
-export interface ExportDefaultDeclaration extends Node, HasSpan {
+interface ExportDefaultDeclaration extends Node, HasSpan {
     type: "ExportDefaultDeclaration";
     decl: DefaultDecl;
 }
-export type DefaultDecl = ClassExpression | FunctionExpression | TsInterfaceDeclaration;
-export type ImportSpecifier = NamedImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+type DefaultDecl = ClassExpression | FunctionExpression | TsInterfaceDeclaration;
+type ImportSpecifier = NamedImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
 /**
  * e.g. `import foo from 'mod.js'`
  */
-export interface ImportDefaultSpecifier extends Node, HasSpan {
+interface ImportDefaultSpecifier extends Node, HasSpan {
     type: "ImportDefaultSpecifier";
     local: Identifier;
 }
 /**
  * e.g. `import * as foo from 'mod.js'`.
  */
-export interface ImportNamespaceSpecifier extends Node, HasSpan {
+interface ImportNamespaceSpecifier extends Node, HasSpan {
     type: "ImportNamespaceSpecifier";
     local: Identifier;
 }
@@ -1409,26 +1500,26 @@ export interface ImportNamespaceSpecifier extends Node, HasSpan {
  *
  * local = bar, imported = Some(foo) for
  */
-export interface NamedImportSpecifier extends Node, HasSpan {
+interface NamedImportSpecifier extends Node, HasSpan {
     type: "ImportSpecifier";
     local: Identifier;
     imported?: ModuleExportName;
     isTypeOnly: boolean;
 }
-export type ModuleExportName = Identifier | StringLiteral;
-export type ExportSpecifier = ExportNamespaceSpecifier | ExportDefaultSpecifier | NamedExportSpecifier;
+type ModuleExportName = Identifier | StringLiteral;
+type ExportSpecifier = ExportNamespaceSpecifier | ExportDefaultSpecifier | NamedExportSpecifier;
 /**
  * `export * as foo from 'src';`
  */
-export interface ExportNamespaceSpecifier extends Node, HasSpan {
+interface ExportNamespaceSpecifier extends Node, HasSpan {
     type: "ExportNamespaceSpecifier";
     name: ModuleExportName;
 }
-export interface ExportDefaultSpecifier extends Node, HasSpan {
+interface ExportDefaultSpecifier extends Node, HasSpan {
     type: "ExportDefaultSpecifier";
     exported: Identifier;
 }
-export interface NamedExportSpecifier extends Node, HasSpan {
+interface NamedExportSpecifier extends Node, HasSpan {
     type: "ExportSpecifier";
     orig: ModuleExportName;
     /**
@@ -1443,51 +1534,51 @@ interface HasInterpreter {
      */
     interpreter: string;
 }
-export type Program = Module | Script;
-export interface Module extends Node, HasSpan, HasInterpreter {
+type Program = Module | Script;
+interface Module extends Node, HasSpan, HasInterpreter {
     type: "Module";
     body: ModuleItem[];
 }
-export interface Script extends Node, HasSpan, HasInterpreter {
+interface Script extends Node, HasSpan, HasInterpreter {
     type: "Script";
     body: Statement[];
 }
-export type ModuleItem = ModuleDeclaration | Statement;
-export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "||" | "&&" | "in" | "instanceof" | "**" | "??";
-export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "&&=" | "||=" | "??=";
-export type UpdateOperator = "++" | "--";
-export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-export type Pattern = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern | AssignmentPattern | Invalid | Expression;
-export interface BindingIdentifier extends PatternBase {
+type ModuleItem = ModuleDeclaration | Statement;
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "||" | "&&" | "in" | "instanceof" | "**" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "&&=" | "||=" | "??=";
+type UpdateOperator = "++" | "--";
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type Pattern = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern | AssignmentPattern | Invalid | Expression;
+interface BindingIdentifier extends PatternBase {
     type: "Identifier";
     value: string;
     optional: boolean;
 }
-export interface ArrayPattern extends PatternBase {
+interface ArrayPattern extends PatternBase {
     type: "ArrayPattern";
     elements: (Pattern | undefined)[];
     optional: boolean;
 }
-export interface ObjectPattern extends PatternBase {
+interface ObjectPattern extends PatternBase {
     type: "ObjectPattern";
     properties: ObjectPatternProperty[];
     optional: boolean;
 }
-export interface AssignmentPattern extends PatternBase {
+interface AssignmentPattern extends PatternBase {
     type: "AssignmentPattern";
     left: Pattern;
     right: Expression;
 }
-export interface RestElement extends PatternBase {
+interface RestElement extends PatternBase {
     type: "RestElement";
     rest: Span;
     argument: Pattern;
 }
-export type ObjectPatternProperty = KeyValuePatternProperty | AssignmentPatternProperty | RestElement;
+type ObjectPatternProperty = KeyValuePatternProperty | AssignmentPatternProperty | RestElement;
 /**
  * `{key: value}`
  */
-export interface KeyValuePatternProperty extends Node {
+interface KeyValuePatternProperty extends Node {
     type: "KeyValuePatternProperty";
     key: PropertyName;
     value: Pattern;
@@ -1495,125 +1586,125 @@ export interface KeyValuePatternProperty extends Node {
 /**
  * `{key}` or `{key = value}`
  */
-export interface AssignmentPatternProperty extends Node, HasSpan {
+interface AssignmentPatternProperty extends Node, HasSpan {
     type: "AssignmentPatternProperty";
     key: Identifier;
     value?: Expression;
 }
 /** Identifier is `a` in `{ a, }` */
-export type Property = Identifier | KeyValueProperty | AssignmentProperty | GetterProperty | SetterProperty | MethodProperty;
+type Property = Identifier | KeyValueProperty | AssignmentProperty | GetterProperty | SetterProperty | MethodProperty;
 interface PropBase extends Node {
     key: PropertyName;
 }
-export interface KeyValueProperty extends PropBase {
+interface KeyValueProperty extends PropBase {
     type: "KeyValueProperty";
     value: Expression;
 }
-export interface AssignmentProperty extends Node {
+interface AssignmentProperty extends Node {
     type: "AssignmentProperty";
     key: Identifier;
     value: Expression;
 }
-export interface GetterProperty extends PropBase, HasSpan {
+interface GetterProperty extends PropBase, HasSpan {
     type: "GetterProperty";
     typeAnnotation?: TsTypeAnnotation;
     body?: BlockStatement;
 }
-export interface SetterProperty extends PropBase, HasSpan {
+interface SetterProperty extends PropBase, HasSpan {
     type: "SetterProperty";
     param: Pattern;
     body?: BlockStatement;
 }
-export interface MethodProperty extends PropBase, Fn {
+interface MethodProperty extends PropBase, Fn {
     type: "MethodProperty";
 }
-export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropName | BigIntLiteral;
-export interface ComputedPropName extends Node, HasSpan {
+type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropName | BigIntLiteral;
+interface ComputedPropName extends Node, HasSpan {
     type: "Computed";
     expression: Expression;
 }
-export interface BlockStatement extends Node, HasSpan {
+interface BlockStatement extends Node, HasSpan {
     type: "BlockStatement";
     stmts: Statement[];
 }
-export interface ExpressionStatement extends Node, HasSpan {
+interface ExpressionStatement extends Node, HasSpan {
     type: "ExpressionStatement";
     expression: Expression;
 }
-export type Statement = BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration | ExpressionStatement;
-export interface EmptyStatement extends Node, HasSpan {
+type Statement = BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration | ExpressionStatement;
+interface EmptyStatement extends Node, HasSpan {
     type: "EmptyStatement";
 }
-export interface DebuggerStatement extends Node, HasSpan {
+interface DebuggerStatement extends Node, HasSpan {
     type: "DebuggerStatement";
 }
-export interface WithStatement extends Node, HasSpan {
+interface WithStatement extends Node, HasSpan {
     type: "WithStatement";
     object: Expression;
     body: Statement;
 }
-export interface ReturnStatement extends Node, HasSpan {
+interface ReturnStatement extends Node, HasSpan {
     type: "ReturnStatement";
     argument?: Expression;
 }
-export interface LabeledStatement extends Node, HasSpan {
+interface LabeledStatement extends Node, HasSpan {
     type: "LabeledStatement";
     label: Identifier;
     body: Statement;
 }
-export interface BreakStatement extends Node, HasSpan {
+interface BreakStatement extends Node, HasSpan {
     type: "BreakStatement";
     label?: Identifier;
 }
-export interface ContinueStatement extends Node, HasSpan {
+interface ContinueStatement extends Node, HasSpan {
     type: "ContinueStatement";
     label?: Identifier;
 }
-export interface IfStatement extends Node, HasSpan {
+interface IfStatement extends Node, HasSpan {
     type: "IfStatement";
     test: Expression;
     consequent: Statement;
     alternate?: Statement;
 }
-export interface SwitchStatement extends Node, HasSpan {
+interface SwitchStatement extends Node, HasSpan {
     type: "SwitchStatement";
     discriminant: Expression;
     cases: SwitchCase[];
 }
-export interface ThrowStatement extends Node, HasSpan {
+interface ThrowStatement extends Node, HasSpan {
     type: "ThrowStatement";
     argument: Expression;
 }
-export interface TryStatement extends Node, HasSpan {
+interface TryStatement extends Node, HasSpan {
     type: "TryStatement";
     block: BlockStatement;
     handler?: CatchClause;
     finalizer?: BlockStatement;
 }
-export interface WhileStatement extends Node, HasSpan {
+interface WhileStatement extends Node, HasSpan {
     type: "WhileStatement";
     test: Expression;
     body: Statement;
 }
-export interface DoWhileStatement extends Node, HasSpan {
+interface DoWhileStatement extends Node, HasSpan {
     type: "DoWhileStatement";
     test: Expression;
     body: Statement;
 }
-export interface ForStatement extends Node, HasSpan {
+interface ForStatement extends Node, HasSpan {
     type: "ForStatement";
     init?: VariableDeclaration | Expression;
     test?: Expression;
     update?: Expression;
     body: Statement;
 }
-export interface ForInStatement extends Node, HasSpan {
+interface ForInStatement extends Node, HasSpan {
     type: "ForInStatement";
     left: VariableDeclaration | Pattern;
     right: Expression;
     body: Statement;
 }
-export interface ForOfStatement extends Node, HasSpan {
+interface ForOfStatement extends Node, HasSpan {
     type: "ForOfStatement";
     /**
      *  Span of the await token.
@@ -1625,7 +1716,7 @@ export interface ForOfStatement extends Node, HasSpan {
     right: Expression;
     body: Statement;
 }
-export interface SwitchCase extends Node, HasSpan {
+interface SwitchCase extends Node, HasSpan {
     type: "SwitchCase";
     /**
      * Undefined for default case
@@ -1633,7 +1724,7 @@ export interface SwitchCase extends Node, HasSpan {
     test?: Expression;
     consequent: Statement[];
 }
-export interface CatchClause extends Node, HasSpan {
+interface CatchClause extends Node, HasSpan {
     type: "CatchClause";
     /**
      * The param is `undefined` if the catch binding is omitted. E.g., `try { foo() } catch {}`
@@ -1641,15 +1732,15 @@ export interface CatchClause extends Node, HasSpan {
     param?: Pattern;
     body: BlockStatement;
 }
-export interface TsTypeAnnotation extends Node, HasSpan {
+interface TsTypeAnnotation extends Node, HasSpan {
     type: "TsTypeAnnotation";
     typeAnnotation: TsType;
 }
-export interface TsTypeParameterDeclaration extends Node, HasSpan {
+interface TsTypeParameterDeclaration extends Node, HasSpan {
     type: "TsTypeParameterDeclaration";
     parameters: TsTypeParameter[];
 }
-export interface TsTypeParameter extends Node, HasSpan {
+interface TsTypeParameter extends Node, HasSpan {
     type: "TsTypeParameter";
     name: Identifier;
     in: boolean;
@@ -1657,38 +1748,38 @@ export interface TsTypeParameter extends Node, HasSpan {
     constraint?: TsType;
     default?: TsType;
 }
-export interface TsTypeParameterInstantiation extends Node, HasSpan {
+interface TsTypeParameterInstantiation extends Node, HasSpan {
     type: "TsTypeParameterInstantiation";
     params: TsType[];
 }
-export interface TsParameterProperty extends Node, HasSpan, HasDecorator {
+interface TsParameterProperty extends Node, HasSpan, HasDecorator {
     type: "TsParameterProperty";
     accessibility?: Accessibility;
     override: boolean;
     readonly: boolean;
     param: TsParameterPropertyParameter;
 }
-export type TsParameterPropertyParameter = BindingIdentifier | AssignmentPattern;
-export interface TsQualifiedName extends Node {
+type TsParameterPropertyParameter = BindingIdentifier | AssignmentPattern;
+interface TsQualifiedName extends Node {
     type: "TsQualifiedName";
     left: TsEntityName;
     right: Identifier;
 }
-export type TsEntityName = TsQualifiedName | Identifier;
-export type TsTypeElement = TsCallSignatureDeclaration | TsConstructSignatureDeclaration | TsPropertySignature | TsGetterSignature | TsSetterSignature | TsMethodSignature | TsIndexSignature;
-export interface TsCallSignatureDeclaration extends Node, HasSpan {
+type TsEntityName = TsQualifiedName | Identifier;
+type TsTypeElement = TsCallSignatureDeclaration | TsConstructSignatureDeclaration | TsPropertySignature | TsGetterSignature | TsSetterSignature | TsMethodSignature | TsIndexSignature;
+interface TsCallSignatureDeclaration extends Node, HasSpan {
     type: "TsCallSignatureDeclaration";
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
     typeParams?: TsTypeParameterDeclaration;
 }
-export interface TsConstructSignatureDeclaration extends Node, HasSpan {
+interface TsConstructSignatureDeclaration extends Node, HasSpan {
     type: "TsConstructSignatureDeclaration";
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
     typeParams?: TsTypeParameterDeclaration;
 }
-export interface TsPropertySignature extends Node, HasSpan {
+interface TsPropertySignature extends Node, HasSpan {
     type: "TsPropertySignature";
     readonly: boolean;
     key: Expression;
@@ -1696,7 +1787,7 @@ export interface TsPropertySignature extends Node, HasSpan {
     optional: boolean;
     typeAnnotation?: TsTypeAnnotation;
 }
-export interface TsGetterSignature extends Node, HasSpan {
+interface TsGetterSignature extends Node, HasSpan {
     type: "TsGetterSignature";
     readonly: boolean;
     key: Expression;
@@ -1704,7 +1795,7 @@ export interface TsGetterSignature extends Node, HasSpan {
     optional: boolean;
     typeAnnotation?: TsTypeAnnotation;
 }
-export interface TsSetterSignature extends Node, HasSpan {
+interface TsSetterSignature extends Node, HasSpan {
     type: "TsSetterSignature";
     readonly: boolean;
     key: Expression;
@@ -1712,7 +1803,7 @@ export interface TsSetterSignature extends Node, HasSpan {
     optional: boolean;
     param: TsFnParameter;
 }
-export interface TsMethodSignature extends Node, HasSpan {
+interface TsMethodSignature extends Node, HasSpan {
     type: "TsMethodSignature";
     readonly: boolean;
     key: Expression;
@@ -1722,50 +1813,50 @@ export interface TsMethodSignature extends Node, HasSpan {
     typeAnn?: TsTypeAnnotation;
     typeParams?: TsTypeParameterDeclaration;
 }
-export interface TsIndexSignature extends Node, HasSpan {
+interface TsIndexSignature extends Node, HasSpan {
     type: "TsIndexSignature";
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
     readonly: boolean;
     static: boolean;
 }
-export type TsType = TsKeywordType | TsThisType | TsFnOrConstructorType | TsTypeReference | TsTypeQuery | TsTypeLiteral | TsArrayType | TsTupleType | TsOptionalType | TsRestType | TsUnionOrIntersectionType | TsConditionalType | TsInferType | TsParenthesizedType | TsTypeOperator | TsIndexedAccessType | TsMappedType | TsLiteralType | TsTypePredicate | TsImportType;
-export type TsFnOrConstructorType = TsFunctionType | TsConstructorType;
-export interface TsKeywordType extends Node, HasSpan {
+type TsType = TsKeywordType | TsThisType | TsFnOrConstructorType | TsTypeReference | TsTypeQuery | TsTypeLiteral | TsArrayType | TsTupleType | TsOptionalType | TsRestType | TsUnionOrIntersectionType | TsConditionalType | TsInferType | TsParenthesizedType | TsTypeOperator | TsIndexedAccessType | TsMappedType | TsLiteralType | TsTypePredicate | TsImportType;
+type TsFnOrConstructorType = TsFunctionType | TsConstructorType;
+interface TsKeywordType extends Node, HasSpan {
     type: "TsKeywordType";
     kind: TsKeywordTypeKind;
 }
-export type TsKeywordTypeKind = "any" | "unknown" | "number" | "object" | "boolean" | "bigint" | "string" | "symbol" | "void" | "undefined" | "null" | "never" | "intrinsic";
-export interface TsThisType extends Node, HasSpan {
+type TsKeywordTypeKind = "any" | "unknown" | "number" | "object" | "boolean" | "bigint" | "string" | "symbol" | "void" | "undefined" | "null" | "never" | "intrinsic";
+interface TsThisType extends Node, HasSpan {
     type: "TsThisType";
 }
-export type TsFnParameter = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern;
-export interface TsFunctionType extends Node, HasSpan {
+type TsFnParameter = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern;
+interface TsFunctionType extends Node, HasSpan {
     type: "TsFunctionType";
     params: TsFnParameter[];
     typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsTypeAnnotation;
 }
-export interface TsConstructorType extends Node, HasSpan {
+interface TsConstructorType extends Node, HasSpan {
     type: "TsConstructorType";
     params: TsFnParameter[];
     typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsTypeAnnotation;
     isAbstract: boolean;
 }
-export interface TsTypeReference extends Node, HasSpan {
+interface TsTypeReference extends Node, HasSpan {
     type: "TsTypeReference";
     typeName: TsEntityName;
     typeParams?: TsTypeParameterInstantiation;
 }
-export interface TsTypePredicate extends Node, HasSpan {
+interface TsTypePredicate extends Node, HasSpan {
     type: "TsTypePredicate";
     asserts: boolean;
     paramName: TsThisTypeOrIdent;
     typeAnnotation?: TsTypeAnnotation;
 }
-export type TsThisTypeOrIdent = TsThisType | Identifier;
-export interface TsImportType extends Node, HasSpan {
+type TsThisTypeOrIdent = TsThisType | Identifier;
+interface TsImportType extends Node, HasSpan {
     type: "TsImportType";
     argument: StringLiteral;
     qualifier?: TsEntityName;
@@ -1774,75 +1865,75 @@ export interface TsImportType extends Node, HasSpan {
 /**
  * `typeof` operator
  */
-export interface TsTypeQuery extends Node, HasSpan {
+interface TsTypeQuery extends Node, HasSpan {
     type: "TsTypeQuery";
     exprName: TsTypeQueryExpr;
     typeArguments?: TsTypeParameterInstantiation;
 }
-export type TsTypeQueryExpr = TsEntityName | TsImportType;
-export interface TsTypeLiteral extends Node, HasSpan {
+type TsTypeQueryExpr = TsEntityName | TsImportType;
+interface TsTypeLiteral extends Node, HasSpan {
     type: "TsTypeLiteral";
     members: TsTypeElement[];
 }
-export interface TsArrayType extends Node, HasSpan {
+interface TsArrayType extends Node, HasSpan {
     type: "TsArrayType";
     elemType: TsType;
 }
-export interface TsTupleType extends Node, HasSpan {
+interface TsTupleType extends Node, HasSpan {
     type: "TsTupleType";
     elemTypes: TsTupleElement[];
 }
-export interface TsTupleElement extends Node, HasSpan {
+interface TsTupleElement extends Node, HasSpan {
     type: "TsTupleElement";
     label?: Pattern;
     ty: TsType;
 }
-export interface TsOptionalType extends Node, HasSpan {
+interface TsOptionalType extends Node, HasSpan {
     type: "TsOptionalType";
     typeAnnotation: TsType;
 }
-export interface TsRestType extends Node, HasSpan {
+interface TsRestType extends Node, HasSpan {
     type: "TsRestType";
     typeAnnotation: TsType;
 }
-export type TsUnionOrIntersectionType = TsUnionType | TsIntersectionType;
-export interface TsUnionType extends Node, HasSpan {
+type TsUnionOrIntersectionType = TsUnionType | TsIntersectionType;
+interface TsUnionType extends Node, HasSpan {
     type: "TsUnionType";
     types: TsType[];
 }
-export interface TsIntersectionType extends Node, HasSpan {
+interface TsIntersectionType extends Node, HasSpan {
     type: "TsIntersectionType";
     types: TsType[];
 }
-export interface TsConditionalType extends Node, HasSpan {
+interface TsConditionalType extends Node, HasSpan {
     type: "TsConditionalType";
     checkType: TsType;
     extendsType: TsType;
     trueType: TsType;
     falseType: TsType;
 }
-export interface TsInferType extends Node, HasSpan {
+interface TsInferType extends Node, HasSpan {
     type: "TsInferType";
     typeParam: TsTypeParameter;
 }
-export interface TsParenthesizedType extends Node, HasSpan {
+interface TsParenthesizedType extends Node, HasSpan {
     type: "TsParenthesizedType";
     typeAnnotation: TsType;
 }
-export interface TsTypeOperator extends Node, HasSpan {
+interface TsTypeOperator extends Node, HasSpan {
     type: "TsTypeOperator";
     op: TsTypeOperatorOp;
     typeAnnotation: TsType;
 }
-export type TsTypeOperatorOp = "keyof" | "unique" | "readonly";
-export interface TsIndexedAccessType extends Node, HasSpan {
+type TsTypeOperatorOp = "keyof" | "unique" | "readonly";
+interface TsIndexedAccessType extends Node, HasSpan {
     type: "TsIndexedAccessType";
     readonly: boolean;
     objectType: TsType;
     indexType: TsType;
 }
-export type TruePlusMinus = true | "+" | "-";
-export interface TsMappedType extends Node, HasSpan {
+type TruePlusMinus = true | "+" | "-";
+interface TsMappedType extends Node, HasSpan {
     type: "TsMappedType";
     readonly?: TruePlusMinus;
     typeParam: TsTypeParameter;
@@ -1850,17 +1941,17 @@ export interface TsMappedType extends Node, HasSpan {
     optional?: TruePlusMinus;
     typeAnnotation?: TsType;
 }
-export interface TsLiteralType extends Node, HasSpan {
+interface TsLiteralType extends Node, HasSpan {
     type: "TsLiteralType";
     literal: TsLiteral;
 }
-export type TsLiteral = NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TsTemplateLiteralType;
-export interface TsTemplateLiteralType extends Node, HasSpan {
+type TsLiteral = NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TsTemplateLiteralType;
+interface TsTemplateLiteralType extends Node, HasSpan {
     type: "TemplateLiteral";
     types: TsType[];
     quasis: TemplateElement[];
 }
-export interface TsInterfaceDeclaration extends Node, HasSpan {
+interface TsInterfaceDeclaration extends Node, HasSpan {
     type: "TsInterfaceDeclaration";
     id: Identifier;
     declare: boolean;
@@ -1868,36 +1959,36 @@ export interface TsInterfaceDeclaration extends Node, HasSpan {
     extends: TsExpressionWithTypeArguments[];
     body: TsInterfaceBody;
 }
-export interface TsInterfaceBody extends Node, HasSpan {
+interface TsInterfaceBody extends Node, HasSpan {
     type: "TsInterfaceBody";
     body: TsTypeElement[];
 }
-export interface TsExpressionWithTypeArguments extends Node, HasSpan {
+interface TsExpressionWithTypeArguments extends Node, HasSpan {
     type: "TsExpressionWithTypeArguments";
     expression: Expression;
     typeArguments?: TsTypeParameterInstantiation;
 }
-export interface TsTypeAliasDeclaration extends Node, HasSpan {
+interface TsTypeAliasDeclaration extends Node, HasSpan {
     type: "TsTypeAliasDeclaration";
     declare: boolean;
     id: Identifier;
     typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsType;
 }
-export interface TsEnumDeclaration extends Node, HasSpan {
+interface TsEnumDeclaration extends Node, HasSpan {
     type: "TsEnumDeclaration";
     declare: boolean;
     isConst: boolean;
     id: Identifier;
     members: TsEnumMember[];
 }
-export interface TsEnumMember extends Node, HasSpan {
+interface TsEnumMember extends Node, HasSpan {
     type: "TsEnumMember";
     id: TsEnumMemberId;
     init?: Expression;
 }
-export type TsEnumMemberId = Identifier | StringLiteral;
-export interface TsModuleDeclaration extends Node, HasSpan {
+type TsEnumMemberId = Identifier | StringLiteral;
+interface TsModuleDeclaration extends Node, HasSpan {
     type: "TsModuleDeclaration";
     declare: boolean;
     global: boolean;
@@ -1907,20 +1998,20 @@ export interface TsModuleDeclaration extends Node, HasSpan {
 /**
  * `namespace A.B { }` is a namespace named `A` with another TsNamespaceDecl as its body.
  */
-export type TsNamespaceBody = TsModuleBlock | TsNamespaceDeclaration;
-export interface TsModuleBlock extends Node, HasSpan {
+type TsNamespaceBody = TsModuleBlock | TsNamespaceDeclaration;
+interface TsModuleBlock extends Node, HasSpan {
     type: "TsModuleBlock";
     body: ModuleItem[];
 }
-export interface TsNamespaceDeclaration extends Node, HasSpan {
+interface TsNamespaceDeclaration extends Node, HasSpan {
     type: "TsNamespaceDeclaration";
     declare: boolean;
     global: boolean;
     id: Identifier;
     body: TsNamespaceBody;
 }
-export type TsModuleName = Identifier | StringLiteral;
-export interface TsImportEqualsDeclaration extends Node, HasSpan {
+type TsModuleName = Identifier | StringLiteral;
+interface TsImportEqualsDeclaration extends Node, HasSpan {
     type: "TsImportEqualsDeclaration";
     declare: boolean;
     isExport: boolean;
@@ -1928,50 +2019,50 @@ export interface TsImportEqualsDeclaration extends Node, HasSpan {
     id: Identifier;
     moduleRef: TsModuleReference;
 }
-export type TsModuleReference = TsEntityName | TsExternalModuleReference;
-export interface TsExternalModuleReference extends Node, HasSpan {
+type TsModuleReference = TsEntityName | TsExternalModuleReference;
+interface TsExternalModuleReference extends Node, HasSpan {
     type: "TsExternalModuleReference";
     expression: StringLiteral;
 }
-export interface TsExportAssignment extends Node, HasSpan {
+interface TsExportAssignment extends Node, HasSpan {
     type: "TsExportAssignment";
     expression: Expression;
 }
-export interface TsNamespaceExportDeclaration extends Node, HasSpan {
+interface TsNamespaceExportDeclaration extends Node, HasSpan {
     type: "TsNamespaceExportDeclaration";
     id: Identifier;
 }
-export interface TsAsExpression extends ExpressionBase {
+interface TsAsExpression extends ExpressionBase {
     type: "TsAsExpression";
     expression: Expression;
     typeAnnotation: TsType;
 }
-export interface TsSatisfiesExpression extends ExpressionBase {
+interface TsSatisfiesExpression extends ExpressionBase {
     type: "TsSatisfiesExpression";
     expression: Expression;
     typeAnnotation: TsType;
 }
-export interface TsInstantiation extends Node, HasSpan {
+interface TsInstantiation extends Node, HasSpan {
     type: "TsInstantiation";
     expression: Expression;
     typeArguments: TsTypeParameterInstantiation;
 }
-export interface TsTypeAssertion extends ExpressionBase {
+interface TsTypeAssertion extends ExpressionBase {
     type: "TsTypeAssertion";
     expression: Expression;
     typeAnnotation: TsType;
 }
-export interface TsConstAssertion extends ExpressionBase {
+interface TsConstAssertion extends ExpressionBase {
     type: "TsConstAssertion";
     expression: Expression;
 }
-export interface TsNonNullExpression extends ExpressionBase {
+interface TsNonNullExpression extends ExpressionBase {
     type: "TsNonNullExpression";
     expression: Expression;
 }
-export type Accessibility = "public" | "protected" | "private";
-export interface Invalid extends Node, HasSpan {
+type Accessibility = "public" | "protected" | "private";
+interface Invalid extends Node, HasSpan {
     type: "Invalid";
 }
-export {};
-//# sourceMappingURL=index.d.ts.map
+
+export type { Accessibility, AmdConfig, Argument, ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentOperator, AssignmentPattern, AssignmentPatternProperty, AssignmentProperty, AwaitExpression, BaseModuleConfig, BigIntLiteral, BinaryExpression, BinaryOperator, BindingIdentifier, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CallerOptions, CatchClause, Class, ClassDeclaration, ClassExpression, ClassMember, ClassMethod, ClassMethodBase, ClassProperty, ClassPropertyBase, CommonJsConfig, ComputedPropName, ConditionalExpression, Config, ConstModulesConfig, Constructor, ContinueStatement, DebuggerStatement, Declaration, Decorator, DefaultDecl, DoWhileStatement, EmptyStatement, EnvConfig, Es6Config, EsParserConfig, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultExpression, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, ExprOrSpread, Expression, ExpressionStatement, Fn, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetterProperty, GlobalPassOption, HasDecorator, HasSpan, Identifier, IfStatement, Import, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, Invalid, JSXAttrValue, JSXAttribute, JSXAttributeName, JSXAttributeOrSpread, JSXClosingElement, JSXClosingFragment, JSXElement, JSXElementChild, JSXElementName, JSXEmptyExpression, JSXExpression, JSXExpressionContainer, JSXFragment, JSXMemberExpression, JSXNamespacedName, JSXObject, JSXOpeningElement, JSXOpeningFragment, JSXSpreadChild, JSXText, JsFormatOptions, JsMinifyOptions, JscConfig, JscTarget, KeyValuePatternProperty, KeyValueProperty, LabeledStatement, Literal, MatchPattern, MemberExpression, MetaProperty, MethodKind, MethodProperty, Module, ModuleConfig, ModuleDeclaration, ModuleExportName, ModuleItem, NamedExportSpecifier, NamedImportSpecifier, NewExpression, Node, NodeNextConfig, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ObjectPatternProperty, OptimizerConfig, OptionalChainingCall, OptionalChainingExpression, Options, Output, Param, ParenthesisExpression, ParseOptions, ParserConfig, Pattern, Plugin, PrivateMethod, PrivateName, PrivateProperty, Program, Property, PropertyName, ReactConfig, RegExpLiteral, RestElement, ReturnStatement, Script, SequenceExpression, SetterProperty, Span, SpreadElement, Statement, StaticBlock, StringLiteral, Super, SuperPropExpression, Swcrc, SwitchCase, SwitchStatement, SystemjsConfig, TaggedTemplateExpression, TemplateElement, TemplateLiteral, TerserCompressOptions, TerserEcmaVersion, TerserMangleOptions, TerserManglePropertiesOptions, ThisExpression, ThrowStatement, TransformConfig, TruePlusMinus, TryStatement, TsArrayType, TsAsExpression, TsCallSignatureDeclaration, TsConditionalType, TsConstAssertion, TsConstructSignatureDeclaration, TsConstructorType, TsEntityName, TsEnumDeclaration, TsEnumMember, TsEnumMemberId, TsExportAssignment, TsExpressionWithTypeArguments, TsExternalModuleReference, TsFnOrConstructorType, TsFnParameter, TsFunctionType, TsGetterSignature, TsImportEqualsDeclaration, TsImportType, TsIndexSignature, TsIndexedAccessType, TsInferType, TsInstantiation, TsInterfaceBody, TsInterfaceDeclaration, TsIntersectionType, TsKeywordType, TsKeywordTypeKind, TsLiteral, TsLiteralType, TsMappedType, TsMethodSignature, TsModuleBlock, TsModuleDeclaration, TsModuleName, TsModuleReference, TsNamespaceBody, TsNamespaceDeclaration, TsNamespaceExportDeclaration, TsNonNullExpression, TsOptionalType, TsParameterProperty, TsParameterPropertyParameter, TsParenthesizedType, TsParserConfig, TsPropertySignature, TsQualifiedName, TsRestType, TsSatisfiesExpression, TsSetterSignature, TsTemplateLiteralType, TsThisType, TsThisTypeOrIdent, TsTupleElement, TsTupleType, TsType, TsTypeAliasDeclaration, TsTypeAnnotation, TsTypeAssertion, TsTypeElement, TsTypeLiteral, TsTypeOperator, TsTypeOperatorOp, TsTypeParameter, TsTypeParameterDeclaration, TsTypeParameterInstantiation, TsTypePredicate, TsTypeQuery, TsTypeQueryExpr, TsTypeReference, TsUnionOrIntersectionType, TsUnionType, UmdConfig, UnaryExpression, UnaryOperator, UpdateExpression, UpdateOperator, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WhileStatement, WithStatement, YieldExpression };