@aussieljk/forkbook 0.0.1-4 → 0.0.1-6

package/dist/babel/index.d.ts

@@ -1,10 +1,10 @@
-import { $ as DeclareModuleExports, $i as TSTypeAnnotation, $n as NumberLiteralTypeAnnotation, $r as TSAsExpression, $t as Identifier, A as ClassBody, Aa as TypeParameterInstantiation, Ai as TSModuleBlock, An as JSXSpreadAttribute, Ar as QualifiedTypeIdentifier, At as ExportSpecifier, B as CompletionStatement, Ba as VariableDeclarator, Bi as TSParameterProperty, Bn as Method, Br as SpreadProperty$1, Bt as For, C as BooleanLiteralTypeAnnotation, Ca as TupleExpression, Ci as TSInterfaceBody, Cn as JSXExpressionContainer, Cr as PipelineTopicExpression, Ct as ExistsTypeAnnotation, D as CatchClause, Da as TypeCastExpression, Di as TSLiteralType, Dn as JSXNamespacedName, Dr as Program, Dt as ExportDefaultSpecifier, E as CallExpression, Ea as TypeAnnotation, Ei as TSIntrinsicKeyword, En as JSXMemberExpression, Er as PrivateName, Et as ExportDefaultDeclaration, F as ClassPrivateMethod, Fa as UnionTypeAnnotation, Fi as TSNonNullExpression, Fn as Literal, Fr as RestProperty$1, Ft as Flow, G as DecimalLiteral, Ga as WhileStatement, Gi as TSSatisfiesExpression, Gn as ModuleSpecifier, Gr as StringLiteralTypeAnnotation, Gt as Function, H as ConditionalExpression, Ha as VoidPattern, Hi as TSPropertySignature, Hn as MixedTypeAnnotation, Hr as Statement, Ht as ForOfStatement, I as ClassPrivateProperty, Ia as UpdateExpression, Ii as TSNullKeyword, In as LogicalExpression, Ir as ReturnStatement, It as FlowBaseAnnotation, J as DeclareExportAllDeclaration, Ja as index_d_exports$1, Ji as TSTemplateLiteralType, Jn as Noop, Jr as SwitchCase, Jt as FunctionParameter, K as Declaration, Ka as WithStatement, Ki as TSStringKeyword, Kn as NewExpression, Kr as StringTypeAnnotation, Kt as FunctionDeclaration, L as ClassProperty, La as UserWhitespacable, Li as TSNumberKeyword, Ln as Loop, Lr as Scopable, Lt as FlowDeclaration, M as ClassExpression, Ma as TypeofTypeAnnotation, Mi as TSNamedTupleMember, Mn as JSXText, Mr as RegExpLiteral, Mt as ExpressionStatement, N as ClassImplements, Na as UnaryExpression, Ni as TSNamespaceExportDeclaration, Nn as LVal, Nr as RegexLiteral$1, Nt as ExpressionWrapper, O as Class, Oa as TypeParameter, Oi as TSMappedType, On as JSXOpeningElement, Or as Property, Ot as ExportNamedDeclaration, P as ClassMethod, Pa as UnaryLike, Pi as TSNeverKeyword, Pn as LabeledStatement, Pr as RestElement, Pt as File, Q as DeclareModule, Qi as TSTypeAliasDeclaration, Qn as NumberLiteral$1, Qr as TSArrayType, Qt as GenericTypeAnnotation, R as Comment, Ra as V8IntrinsicIdentifier, Ri as TSObjectKeyword, Rn as MemberExpression, Rr as SequenceExpression, Rt as FlowPredicate, S as BooleanLiteral, Sa as TryStatement, Si as TSInstantiationExpression, Sn as JSXEmptyExpression, Sr as PipelinePrimaryTopicReference, St as EnumSymbolBody, T as BreakStatement, Ta as TypeAlias, Ti as TSIntersectionType, Tn as JSXIdentifier, Tr as Private, Tt as ExportDeclaration, U as ContinueStatement, Ua as VoidTypeAnnotation, Ui as TSQualifiedName, Un as ModuleDeclaration, Ur as StaticBlock, Ut as ForStatement, V as Conditional, Va as Variance, Vi as TSParenthesizedType, Vn as Miscellaneous, Vr as Standardized, Vt as ForInStatement, W as DebuggerStatement, Wa as While, Wi as TSRestType, Wn as ModuleExpression, Wr as StringLiteral, Wt as ForXStatement, X as DeclareFunction, Xi as TSTupleType, Xn as NullLiteralTypeAnnotation, Xr as SymbolTypeAnnotation, Xt as FunctionTypeAnnotation, Y as DeclareExportDeclaration, Yi as TSThisType, Yn as NullLiteral, Yr as SwitchStatement, Yt as FunctionParent, Z as DeclareInterface, Zi as TSType, Zn as NullableTypeAnnotation, Zr as TSAnyKeyword, Zt as FunctionTypeParam, _ as BinaryExpression, _a as Terminatorless, _i as TSImportEqualsDeclaration, _n as JSX, _r as Options$1, _t as EnumMember, a as Aliases, aa as TSTypeParameterDeclaration, ai as TSConstructSignatureDeclaration, an as ImportDefaultSpecifier, ar as ObjectPattern, at as DeprecatedAliases, b as BlockParent, ba as ThrowStatement, bi as TSIndexedAccessType, bn as JSXClosingFragment, br as PatternLike, bt as EnumStringBody, c as ArrayExpression, ca as TSTypeQuery, ci as TSDeclareMethod, cn as ImportOrExportDeclaration, cr as ObjectTypeCallProperty, ct as DoExpression, d as ArrowFunctionExpression, da as TSUnionType, di as TSEnumDeclaration, dn as InferredPredicate, dr as ObjectTypeProperty, dt as EmptyTypeAnnotation, ea as TSTypeAssertion, ei as TSBaseType, en as IfStatement, er as NumberTypeAnnotation, et as DeclareOpaqueType, f as AssignmentExpression, fa as TSUnknownKeyword, fi as TSEnumMember, fn as InterfaceDeclaration, fr as ObjectTypeSpreadProperty, ft as EnumBody, g as Binary, ga as TemplateLiteral, gi as TSFunctionType, gn as IntersectionTypeAnnotation, gr as OptionalMemberExpression, gt as EnumDefaultedMember, h as BigIntLiteral, ha as TemplateElement, hi as TSExternalModuleReference, hn as InterpreterDirective, hr as OptionalIndexedAccessType, ht as EnumDeclaration, i as Accessor, ia as TSTypeParameter, ii as TSConditionalType, in as ImportDeclaration, ir as ObjectMethod, it as Decorator, j as ClassDeclaration, ja as TypeScript, ji as TSModuleDeclaration, jn as JSXSpreadChild, jr as RecordExpression, jt as Expression, k as ClassAccessorProperty, ka as TypeParameterDeclaration, ki as TSMethodSignature, kn as JSXOpeningFragment, kr as Pureish, kt as ExportNamespaceSpecifier, l as ArrayPattern, la as TSTypeReference, li as TSEntityName, ln as ImportSpecifier, lr as ObjectTypeIndexer, lt as DoWhileStatement, m as AwaitExpression, ma as TaggedTemplateExpression, mi as TSExpressionWithTypeArguments, mn as InterfaceTypeAnnotation, mr as OptionalCallExpression, mt as EnumBooleanMember, na as TSTypeLiteral, ni as TSBooleanKeyword, nn as Import, nr as ObjectExpression, nt as DeclareVariable, o as AnyTypeAnnotation, oa as TSTypeParameterInstantiation, oi as TSConstructorType, on as ImportExpression, or as ObjectProperty, ot as Directive, p as AssignmentPattern, pa as TSVoidKeyword, pi as TSExportAssignment, pn as InterfaceExtends, pr as OpaqueType, pt as EnumBooleanBody, q as DeclareClass, qa as YieldExpression, qi as TSSymbolKeyword, qn as Node$1, qr as Super, qt as FunctionExpression, r as generate$1, ra as TSTypeOperator, ri as TSCallSignatureDeclaration, rn as ImportAttribute, rr as ObjectMember, rt as DeclaredPredicate, s as ArgumentPlaceholder, sa as TSTypePredicate, si as TSDeclareFunction, sn as ImportNamespaceSpecifier, sr as ObjectTypeAnnotation, st as DirectiveLiteral, t as GeneratorOptions, ta as TSTypeElement, ti as TSBigIntKeyword, tn as Immutable, tr as NumericLiteral, tt as DeclareTypeAlias, u as ArrayTypeAnnotation, ua as TSUndefinedKeyword, ui as TSEnumBody, un as IndexedAccessType, ur as ObjectTypeInternalSlot, ut as EmptyStatement, v as BindExpression, va as ThisExpression, vi as TSImportType, vn as JSXAttribute, vr as ParenthesizedExpression, vt as EnumNumberBody, w as BooleanTypeAnnotation, wa as TupleTypeAnnotation, wi as TSInterfaceDeclaration, wn as JSXFragment, wr as Placeholder, wt as ExportAllDeclaration, x as BlockStatement, xa as TopicReference, xi as TSInferType, xn as JSXElement, xr as PipelineBareFunction, xt as EnumStringMember, y as Block, ya as ThisTypeAnnotation, yi as TSIndexSignature, yn as JSXClosingElement, yr as Pattern, yt as EnumNumberMember, z as CommentTypeShorthand, za as VariableDeclaration, zi as TSOptionalType, zn as MetaProperty, zr as SpreadElement, zt as FlowType } from "../chunk-D7DwV41f.js";
+import { $ as DeclareModuleExports, $i as TSTypeAnnotation, $n as NumberLiteralTypeAnnotation, $r as TSAsExpression, $t as Identifier, A as ClassBody, Aa as TypeParameterInstantiation, Ai as TSModuleBlock, An as JSXSpreadAttribute, Ar as QualifiedTypeIdentifier, At as ExportSpecifier, B as CompletionStatement, Ba as VariableDeclarator, Bi as TSParameterProperty, Bn as Method, Br as SpreadProperty$1, Bt as For, C as BooleanLiteralTypeAnnotation, Ca as TupleExpression, Ci as TSInterfaceBody, Cn as JSXExpressionContainer, Cr as PipelineTopicExpression, Ct as ExistsTypeAnnotation, D as CatchClause, Da as TypeCastExpression, Di as TSLiteralType, Dn as JSXNamespacedName, Dr as Program, Dt as ExportDefaultSpecifier, E as CallExpression, Ea as TypeAnnotation, Ei as TSIntrinsicKeyword, En as JSXMemberExpression, Er as PrivateName, Et as ExportDefaultDeclaration, F as ClassPrivateMethod, Fa as UnionTypeAnnotation, Fi as TSNonNullExpression, Fn as Literal, Fr as RestProperty$1, Ft as Flow, G as DecimalLiteral, Ga as WhileStatement, Gi as TSSatisfiesExpression, Gn as ModuleSpecifier, Gr as StringLiteralTypeAnnotation, Gt as Function, H as ConditionalExpression, Ha as VoidPattern, Hi as TSPropertySignature, Hn as MixedTypeAnnotation, Hr as Statement, Ht as ForOfStatement, I as ClassPrivateProperty, Ia as UpdateExpression, Ii as TSNullKeyword, In as LogicalExpression, Ir as ReturnStatement, It as FlowBaseAnnotation, J as DeclareExportAllDeclaration, Ja as index_d_exports, Ji as TSTemplateLiteralType, Jn as Noop, Jr as SwitchCase, Jt as FunctionParameter, K as Declaration, Ka as WithStatement, Ki as TSStringKeyword, Kn as NewExpression, Kr as StringTypeAnnotation, Kt as FunctionDeclaration, L as ClassProperty, La as UserWhitespacable, Li as TSNumberKeyword, Ln as Loop, Lr as Scopable, Lt as FlowDeclaration, M as ClassExpression, Ma as TypeofTypeAnnotation, Mi as TSNamedTupleMember, Mn as JSXText, Mr as RegExpLiteral, Mt as ExpressionStatement, N as ClassImplements, Na as UnaryExpression, Ni as TSNamespaceExportDeclaration, Nn as LVal, Nr as RegexLiteral$1, Nt as ExpressionWrapper, O as Class, Oa as TypeParameter, Oi as TSMappedType, On as JSXOpeningElement, Or as Property, Ot as ExportNamedDeclaration, P as ClassMethod, Pa as UnaryLike, Pi as TSNeverKeyword, Pn as LabeledStatement, Pr as RestElement, Pt as File, Q as DeclareModule, Qi as TSTypeAliasDeclaration, Qn as NumberLiteral$1, Qr as TSArrayType, Qt as GenericTypeAnnotation, R as Comment, Ra as V8IntrinsicIdentifier, Ri as TSObjectKeyword, Rn as MemberExpression, Rr as SequenceExpression, Rt as FlowPredicate, S as BooleanLiteral, Sa as TryStatement, Si as TSInstantiationExpression, Sn as JSXEmptyExpression, Sr as PipelinePrimaryTopicReference, St as EnumSymbolBody, T as BreakStatement, Ta as TypeAlias, Ti as TSIntersectionType, Tn as JSXIdentifier, Tr as Private, Tt as ExportDeclaration, U as ContinueStatement, Ua as VoidTypeAnnotation, Ui as TSQualifiedName, Un as ModuleDeclaration, Ur as StaticBlock, Ut as ForStatement, V as Conditional, Va as Variance, Vi as TSParenthesizedType, Vn as Miscellaneous, Vr as Standardized, Vt as ForInStatement, W as DebuggerStatement, Wa as While, Wi as TSRestType, Wn as ModuleExpression, Wr as StringLiteral, Wt as ForXStatement, X as DeclareFunction, Xi as TSTupleType, Xn as NullLiteralTypeAnnotation, Xr as SymbolTypeAnnotation, Xt as FunctionTypeAnnotation, Y as DeclareExportDeclaration, Yi as TSThisType, Yn as NullLiteral, Yr as SwitchStatement, Yt as FunctionParent, Z as DeclareInterface, Zi as TSType, Zn as NullableTypeAnnotation, Zr as TSAnyKeyword, Zt as FunctionTypeParam, _ as BinaryExpression, _a as Terminatorless, _i as TSImportEqualsDeclaration, _n as JSX, _r as Options$1, _t as EnumMember, a as Aliases, aa as TSTypeParameterDeclaration, ai as TSConstructSignatureDeclaration, an as ImportDefaultSpecifier, ar as ObjectPattern, at as DeprecatedAliases, b as BlockParent, ba as ThrowStatement, bi as TSIndexedAccessType, bn as JSXClosingFragment, br as PatternLike, bt as EnumStringBody, c as ArrayExpression, ca as TSTypeQuery, ci as TSDeclareMethod, cn as ImportOrExportDeclaration, cr as ObjectTypeCallProperty, ct as DoExpression, d as ArrowFunctionExpression, da as TSUnionType, di as TSEnumDeclaration, dn as InferredPredicate, dr as ObjectTypeProperty, dt as EmptyTypeAnnotation, ea as TSTypeAssertion, ei as TSBaseType, en as IfStatement, er as NumberTypeAnnotation, et as DeclareOpaqueType, f as AssignmentExpression, fa as TSUnknownKeyword, fi as TSEnumMember, fn as InterfaceDeclaration, fr as ObjectTypeSpreadProperty, ft as EnumBody, g as Binary, ga as TemplateLiteral, gi as TSFunctionType, gn as IntersectionTypeAnnotation, gr as OptionalMemberExpression, gt as EnumDefaultedMember, h as BigIntLiteral, ha as TemplateElement, hi as TSExternalModuleReference, hn as InterpreterDirective, hr as OptionalIndexedAccessType, ht as EnumDeclaration, i as Accessor, ia as TSTypeParameter, ii as TSConditionalType, in as ImportDeclaration, ir as ObjectMethod, it as Decorator, j as ClassDeclaration, ja as TypeScript, ji as TSModuleDeclaration, jn as JSXSpreadChild, jr as RecordExpression, jt as Expression, k as ClassAccessorProperty, ka as TypeParameterDeclaration, ki as TSMethodSignature, kn as JSXOpeningFragment, kr as Pureish, kt as ExportNamespaceSpecifier, l as ArrayPattern, la as TSTypeReference, li as TSEntityName, ln as ImportSpecifier, lr as ObjectTypeIndexer, lt as DoWhileStatement, m as AwaitExpression, ma as TaggedTemplateExpression, mi as TSExpressionWithTypeArguments, mn as InterfaceTypeAnnotation, mr as OptionalCallExpression, mt as EnumBooleanMember, na as TSTypeLiteral, ni as TSBooleanKeyword, nn as Import, nr as ObjectExpression, nt as DeclareVariable, o as AnyTypeAnnotation, oa as TSTypeParameterInstantiation, oi as TSConstructorType, on as ImportExpression, or as ObjectProperty, ot as Directive, p as AssignmentPattern, pa as TSVoidKeyword, pi as TSExportAssignment, pn as InterfaceExtends, pr as OpaqueType, pt as EnumBooleanBody, q as DeclareClass, qa as YieldExpression, qi as TSSymbolKeyword, qn as Node, qr as Super, qt as FunctionExpression, r as generate$1, ra as TSTypeOperator, ri as TSCallSignatureDeclaration, rn as ImportAttribute, rr as ObjectMember, rt as DeclaredPredicate, s as ArgumentPlaceholder, sa as TSTypePredicate, si as TSDeclareFunction, sn as ImportNamespaceSpecifier, sr as ObjectTypeAnnotation, st as DirectiveLiteral, t as GeneratorOptions, ta as TSTypeElement, ti as TSBigIntKeyword, tn as Immutable, tr as NumericLiteral, tt as DeclareTypeAlias, u as ArrayTypeAnnotation, ua as TSUndefinedKeyword, ui as TSEnumBody, un as IndexedAccessType, ur as ObjectTypeInternalSlot, ut as EmptyStatement, v as BindExpression, va as ThisExpression, vi as TSImportType, vn as JSXAttribute, vr as ParenthesizedExpression, vt as EnumNumberBody, w as BooleanTypeAnnotation, wa as TupleTypeAnnotation, wi as TSInterfaceDeclaration, wn as JSXFragment, wr as Placeholder, wt as ExportAllDeclaration, x as BlockStatement, xa as TopicReference, xi as TSInferType, xn as JSXElement, xr as PipelineBareFunction, xt as EnumStringMember, y as Block, ya as ThisTypeAnnotation, yi as TSIndexSignature, yn as JSXClosingElement, yr as Pattern, yt as EnumNumberMember, z as CommentTypeShorthand, za as VariableDeclaration, zi as TSOptionalType, zn as MetaProperty, zr as SpreadElement, zt as FlowType } from "../chunk-D7DwV41f.js";
 import * as recast from "recast";
 import { Options as RecastOptions } from "recast";
 
 //#region ../../node_modules/@babel/parser/typings/babel-parser.d.ts
 declare namespace babel_parser_d_exports {
-  export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult$1 as ParseResult, ParserOptions, PluginConfig as ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse$1 as parse, parseExpression, tokTypes };
+  export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult, ParserOptions, PluginConfig as ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse, parseExpression, tokTypes };
 }
 declare class Position {
   line: number;
@@ -185,7 +185,7 @@ interface Options {
 }
 type ParserOptions = Partial<Options>;
 type ParseError = ParseError$1<object>;
-type ParseResult$1<Result extends File | Expression = File> = Result & {
+type ParseResult<Result extends File | Expression = File> = Result & {
   comments: File["comments"];
   errors: null | ParseError[];
   tokens?: File["tokens"];
@@ -193,105 +193,25 @@ type ParseResult$1<Result extends File | Expression = File> = Result & {
 /**
  * Parse the provided code as an entire ECMAScript program.
  */
-declare function parse$1(input: string, options?: ParserOptions): ParseResult$1<File>;
-declare function parseExpression(input: string, options?: ParserOptions): ParseResult$1<Expression>;
+declare function parse(input: string, options?: ParserOptions): ParseResult<File>;
+declare function parseExpression(input: string, options?: ParserOptions): ParseResult<Expression>;
 declare const tokTypes: {
   // todo(flow->ts) real token type
   [name: string]: any;
 };
 //#endregion
-//#region ../../node_modules/@types/babel__template/index.d.ts
-interface TemplateBuilderOptions extends ParserOptions {
-  /**
-   * A set of placeholder names to automatically accept.
-   * Items in this list do not need to match `placeholderPattern`.
-   *
-   * This option cannot be used when using `%%foo%%` style placeholders.
-   */
-  placeholderWhitelist?: Set<string> | null | undefined;
-  /**
-   * A pattern to search for when looking for `Identifier` and `StringLiteral`
-   * nodes that should be considered as placeholders.
-   *
-   * `false` will disable placeholder searching placeholders, leaving only
-   * the `placeholderWhitelist` value to find replacements.
-   *
-   * This option cannot be used when using `%%foo%%` style placeholders.
-   *
-   * @default /^[_$A-Z0-9]+$/
-   */
-  placeholderPattern?: RegExp | false | null | undefined;
-  /**
-   * Set this to `true` to preserve comments from the template string
-   * into the resulting AST, or `false` to automatically discard comments.
-   *
-   * @default false
-   */
-  preserveComments?: boolean | null | undefined;
-  /**
-   * Set to `true` to use `%%foo%%` style placeholders, `false` to use legacy placeholders
-   * described by `placeholderPattern` or `placeholderWhitelist`.
-   *
-   * When it is not set, it behaves as `true` if there are syntactic placeholders, otherwise as `false`.
-   *
-   * @since 7.4.0
-   */
-  syntacticPlaceholders?: boolean | null | undefined;
-}
-interface TemplateBuilder<T> {
-  /**
-   * Build a new builder, merging the given options with the previous ones.
-   */
-  (opts: TemplateBuilderOptions): TemplateBuilder<T>;
-  /**
-   * Building from a string produces an AST builder function by default.
-   */
-  (code: string, opts?: TemplateBuilderOptions): (arg?: PublicReplacements) => T;
-  /**
-   * Building from a template literal produces an AST builder function by default.
-   */
-  (tpl: TemplateStringsArray, ...args: unknown[]): (arg?: PublicReplacements) => T;
-  /**
-   * Allow users to explicitly create templates that produce ASTs,
-   * skipping the need for an intermediate function.
-   *
-   * Does not allow `%%foo%%` style placeholders.
-   */
-  ast: {
-    (tpl: string, opts?: TemplateBuilderOptions): T;
-    (tpl: TemplateStringsArray, ...args: unknown[]): T;
-  };
-}
-type PublicReplacements = {
-  [index: string]: unknown;
-} | unknown[];
-declare const smart: TemplateBuilder<Statement | Statement[]>;
-declare const statement: TemplateBuilder<Statement>;
-declare const statements: TemplateBuilder<Statement[]>;
-declare const expression: TemplateBuilder<Expression>;
-declare const program: TemplateBuilder<Program>;
-type DefaultTemplateBuilder = typeof smart & {
-  smart: typeof smart;
-  statement: typeof statement;
-  statements: typeof statements;
-  expression: typeof expression;
-  program: typeof program;
-  ast: typeof smart.ast;
-};
-declare const templateBuilder: DefaultTemplateBuilder;
-//#endregion
 //#region ../../node_modules/@types/babel__traverse/index.d.ts
 declare const traverse$1: {
-  <S>(parent: Node$1, opts: TraverseOptions<S>, scope: Scope | undefined, state: S, parentPath?: NodePath): void;
-  (parent: Node$1, opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath): void;
+  <S>(parent: Node, opts: TraverseOptions<S>, scope: Scope | undefined, state: S, parentPath?: NodePath): void;
+  (parent: Node, opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath): void;
   visitors: typeof visitors;
   verify: typeof visitors.verify;
   explode: typeof visitors.explode;
-  cheap: (node: Node$1, enter: (node: Node$1) => void) => void;
-  node: (node: Node$1, opts: TraverseOptions, scope?: Scope, state?: any, path?: NodePath, skipKeys?: Record<string, boolean>) => void;
-  clearNode: (node: Node$1, opts?: Options$1) => void;
-  removeProperties: (tree: Node$1, opts?: Options$1) => Node$1;
-  hasType: (tree: Node$1, type: Node$1["type"], denylistTypes?: string[]) => boolean;
+  cheap: (node: Node, enter: (node: Node) => void) => void;
+  node: (node: Node, opts: TraverseOptions, scope?: Scope, state?: any, path?: NodePath, skipKeys?: Record<string, boolean>) => void;
+  clearNode: (node: Node, opts?: Options$1) => void;
+  removeProperties: (tree: Node, opts?: Options$1) => Node;
+  hasType: (tree: Node, type: Node["type"], denylistTypes?: string[]) => boolean;
   cache: typeof cache;
 };
 declare namespace visitors {
@@ -309,21 +229,21 @@ declare namespace visitors {
    * - Visitors of virtual types are wrapped, so that they are only visited when their dynamic check passes
    * - `enter` and `exit` functions are wrapped in arrays, to ease merging of visitors
    */
-  function explode<S = unknown>(visitor: Visitor<S>): { [Type in Exclude<Node$1, DeprecatedAliases>["type"]]?: VisitNodeObject<S, Extract<Node$1, {
+  function explode<S = unknown>(visitor: Visitor<S>): { [Type in Exclude<Node, DeprecatedAliases>["type"]]?: VisitNodeObject<S, Extract<Node, {
     type: Type;
   }>> };
   function verify(visitor: Visitor): void;
   function merge<State>(visitors: Array<Visitor<State>>): Visitor<State>;
-  function merge(visitors: Visitor[], states?: any[], wrapper?: (stateKey: any, visitorKey: keyof Visitor, func: VisitNodeFunction<unknown, Node$1>) => VisitNodeFunction<unknown, Node$1> | null): Visitor;
+  function merge(visitors: Visitor[], states?: any[], wrapper?: (stateKey: any, visitorKey: keyof Visitor, func: VisitNodeFunction<unknown, Node>) => VisitNodeFunction<unknown, Node> | null): Visitor;
 }
 declare namespace cache {
-  let path: WeakMap<Node$1, Map<Node$1, NodePath>>;
-  let scope: WeakMap<Node$1, Scope>;
+  let path: WeakMap<Node, Map<Node, NodePath>>;
+  let scope: WeakMap<Node, Scope>;
   function clear(): void;
   function clearPath(): void;
   function clearScope(): void;
 }
-type TraverseOptions<S = Node$1> = {
+type TraverseOptions<S = Node> = {
   scope?: Scope;
   noScope?: boolean;
   denylist?: NodeType[]; /** @deprecated will be removed in Babel 8 */
@@ -338,9 +258,9 @@ declare class Scope {
   constructor(path: NodePath, parentScope?: Scope);
   uid: number;
   path: NodePath;
-  block: Node$1;
+  block: Node;
   labels: Map<string, NodePath<LabeledStatement>>;
-  parentBlock: Node$1;
+  parentBlock: Node;
   parent: Scope;
   hub: HubInterface;
   bindings: {
@@ -361,8 +281,8 @@ declare class Scope {
   /** Variables available in current context. */
   static contextVariables: string[];
   /** Traverse node with current scope and path. */
-  traverse<S>(node: Node$1 | Node$1[], opts: TraverseOptions<S>, state: S): void;
-  traverse(node: Node$1 | Node$1[], opts?: TraverseOptions, state?: any): void;
+  traverse<S>(node: Node | Node[], opts: TraverseOptions<S>, state: S): void;
+  traverse(node: Node | Node[], opts?: TraverseOptions, state?: any): void;
   /** Generate a unique identifier and add it to the current scope. */
   generateDeclaredUidIdentifier(name?: string): Identifier;
   /** Generate a unique identifier. */
@@ -370,7 +290,7 @@ declare class Scope {
   /** Generate a unique `_id1` binding. */
   generateUid(name?: string): string;
   /** Generate a unique identifier based on a node. */
-  generateUidIdentifierBasedOnNode(parent: Node$1, defaultName?: string): Identifier;
+  generateUidIdentifierBasedOnNode(parent: Node, defaultName?: string): Identifier;
   /**
    * Determine whether evaluating the specific input `node` is a consequenceless reference. ie.
    * evaluating it wont result in potentially arbitrary code from being ran. The following are
@@ -380,13 +300,13 @@ declare class Scope {
    *  - `super` expressions
    *  - Bound identifiers
    */
-  isStatic(node: Node$1): boolean;
+  isStatic(node: Node): boolean;
   /** Possibly generate a memoised identifier if it is not static and has consequences. */
-  maybeGenerateMemoised(node: Node$1, dontPush?: boolean): Identifier;
+  maybeGenerateMemoised(node: Node, dontPush?: boolean): Identifier;
   checkBlockScopedCollisions(local: Binding, kind: BindingKind, name: string, id: object): void;
-  rename(oldName: string, newName?: string, block?: Node$1): void;
+  rename(oldName: string, newName?: string, block?: Node): void;
   dump(): void;
-  toArray(node: Node$1, i?: number | boolean, arrayLikeIsIterable?: boolean): ArrayExpression | CallExpression | Identifier;
+  toArray(node: Node, i?: number | boolean, arrayLikeIsIterable?: boolean): ArrayExpression | CallExpression | Identifier;
   hasLabel(name: string): boolean;
   getLabel(name: string): NodePath<LabeledStatement> | undefined;
   registerLabel(path: NodePath<LabeledStatement>): void;
@@ -398,7 +318,7 @@ declare class Scope {
   hasUid(name: string): boolean;
   hasGlobal(name: string): boolean;
   hasReference(name: string): boolean;
-  isPure(node: Node$1, constantsOnly?: boolean): boolean;
+  isPure(node: Node, constantsOnly?: boolean): boolean;
   /**
    * Set some arbitrary data on the current scope.
    */
@@ -439,7 +359,7 @@ declare class Scope {
   getAllBindings(): Record<string, Binding>;
   /** Walks the scope tree and gathers all declarations of `kind`. */
   getAllBindingsOfKind(...kinds: string[]): Record<string, Binding>;
-  bindingIdentifierEquals(name: string, node: Node$1): boolean;
+  bindingIdentifierEquals(name: string, node: Node): boolean;
   getBinding(name: string): Binding | undefined;
   getOwnBinding(name: string): Binding | undefined;
   getBindingIdentifier(name: string): Identifier;
@@ -498,28 +418,28 @@ declare class Binding {
   /** Decrement the amount of references to this binding. */
   dereference(): void;
 }
-type Visitor<S = unknown> = VisitNodeObject<S, Node$1> & { [N in Node$1 as N["type"]]?: VisitNode<S, N extends {
+type Visitor<S = unknown> = VisitNodeObject<S, Node> & { [N in Node as N["type"]]?: VisitNode<S, N extends {
   type: N["type"];
 } ? N : never> } & { [K in keyof Aliases]?: VisitNode<S, Aliases[K]> } & { [K in keyof VirtualTypeAliases]?: VisitNode<S, VirtualTypeAliases[K]> } & {
   // Babel supports `NodeTypesWithoutComment | NodeTypesWithoutComment | ... ` but it is
   // too complex for TS. So we type it as a general visitor only if the key contains `|`
   // this is good enough for non-visitor traverse options e.g. `noScope`
-  [k: `${string}|${string}`]: VisitNode<S, Node$1>;
+  [k: `${string}|${string}`]: VisitNode<S, Node>;
 };
-type VisitNode<S, P extends Node$1> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;
-type VisitNodeFunction<S, P extends Node$1> = (this: S, path: NodePath<P>, state: S) => void;
-type NodeType = Node$1["type"] | keyof Aliases;
-interface VisitNodeObject<S, P extends Node$1> {
+type VisitNode<S, P extends Node> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;
+type VisitNodeFunction<S, P extends Node> = (this: S, path: NodePath<P>, state: S) => void;
+type NodeType = Node["type"] | keyof Aliases;
+interface VisitNodeObject<S, P extends Node> {
   enter?: VisitNodeFunction<S, P>;
   exit?: VisitNodeFunction<S, P>;
 }
-type NodeKeyOfArrays<T extends Node$1> = { [P in keyof T]-?: T[P] extends Array<Node$1 | null | undefined> ? P : never }[keyof T];
-type NodePaths<T extends Node$1 | readonly Node$1[]> = T extends readonly Node$1[] ? { -readonly [K in keyof T]: NodePath<Extract<T[K], Node$1>> } : T extends Node$1 ? [NodePath<T>] : never;
-type NodeListType<N, K extends keyof N> = N[K] extends Array<infer P> ? (P extends Node$1 ? P : never) : never;
-type NodesInsertionParam<T extends Node$1> = T | readonly T[] | [T, ...T[]];
-declare class NodePath<T = Node$1> {
-  constructor(hub: HubInterface, parent: Node$1);
-  parent: Node$1;
+type NodeKeyOfArrays<T extends Node> = { [P in keyof T]-?: T[P] extends Array<Node | null | undefined> ? P : never }[keyof T];
+type NodePaths<T extends Node | readonly Node[]> = T extends readonly Node[] ? { -readonly [K in keyof T]: NodePath<Extract<T[K], Node>> } : T extends Node ? [NodePath<T>] : never;
+type NodeListType<N, K extends keyof N> = N[K] extends Array<infer P> ? (P extends Node ? P : never) : never;
+type NodesInsertionParam<T extends Node> = T | readonly T[] | [T, ...T[]];
+declare class NodePath<T = Node> {
+  constructor(hub: HubInterface, parent: Node);
+  parent: Node;
   hub: Hub;
   data: Record<string | symbol, unknown>;
   context: TraversalContext;
@@ -529,32 +449,32 @@ declare class NodePath<T = Node$1> {
   opts: any; // exploded TraverseOptions
   skipKeys: Record<string, boolean> | null;
   parentPath: T extends Program ? null : NodePath;
-  container: Node$1 | Node$1[] | null;
+  container: Node | Node[] | null;
   listKey: string | null;
   key: string | number | null;
   node: T;
-  type: T extends Node$1 ? T["type"] : T extends null | undefined ? undefined : Node$1["type"] | undefined;
+  type: T extends Node ? T["type"] : T extends null | undefined ? undefined : Node["type"] | undefined;
   shouldSkip: boolean;
   shouldStop: boolean;
   removed: boolean;
   inList: boolean;
   parentKey: string;
   typeAnnotation: object;
-  static get<C extends Node$1, K extends keyof C>(opts: {
+  static get<C extends Node, K extends keyof C>(opts: {
     hub?: HubInterface;
     parentPath: NodePath | null;
-    parent: Node$1;
+    parent: Node;
     container: C;
     key: K;
   }): NodePath<C[K]>;
-  static get<C extends Node$1, L extends NodeKeyOfArrays<C>>(opts: {
+  static get<C extends Node, L extends NodeKeyOfArrays<C>>(opts: {
     hub?: HubInterface;
     parentPath: NodePath | null;
-    parent: Node$1;
+    parent: Node;
     container: C;
     listKey: L;
     key: number;
-  }): C[L] extends Array<Node$1 | null | undefined> ? NodePath<C[L][number]> : never;
+  }): C[L] extends Array<Node | null | undefined> ? NodePath<C[L][number]> : never;
   getScope(scope: Scope): Scope;
   setData(key: string | symbol, val: any): any;
   getData(key: string | symbol, def?: any): any;
@@ -591,7 +511,7 @@ declare class NodePath<T = Node$1> {
    */
   getEarliestCommonAncestorFrom(paths: NodePath[]): NodePath;
   /** Get the earliest path in the tree where the provided `paths` intersect. */
-  getDeepestCommonAncestorFrom(paths: NodePath[], filter?: (deepest: Node$1, i: number, ancestries: NodePath[][]) => NodePath): NodePath;
+  getDeepestCommonAncestorFrom(paths: NodePath[], filter?: (deepest: Node, i: number, ancestries: NodePath[][]) => NodePath): NodePath;
   /**
    * Build an array of node paths containing the entire ancestry of the current node path.
    *
@@ -622,7 +542,7 @@ declare class NodePath<T = Node$1> {
    *  - Insert the provided nodes after the current node.
    *  - Remove the current node.
    */
-  replaceWithMultiple<Nodes extends Node$1 | readonly Node$1[] | [Node$1, ...Node$1[]]>(nodes: Nodes): NodePaths<Nodes>;
+  replaceWithMultiple<Nodes extends Node | readonly Node[] | [Node, ...Node[]]>(nodes: Nodes): NodePaths<Nodes>;
   /**
    * Parse a string as an expression and replace the current node with the result.
    *
@@ -632,7 +552,7 @@ declare class NodePath<T = Node$1> {
    */
   replaceWithSourceString(replacement: string): [NodePath];
   /** Replace the current node with another. */
-  replaceWith<R extends Node$1>(replacementPath: R | NodePath<R>): [NodePath<R>];
+  replaceWith<R extends Node>(replacementPath: R | NodePath<R>): [NodePath<R>];
   replaceWith<R extends NodePath>(replacementPath: R): [R];
   /**
    * This method takes an array of statements nodes and then explodes it
@@ -640,7 +560,7 @@ declare class NodePath<T = Node$1> {
    * extremely important to retain original semantics.
    */
   replaceExpressionWithStatements(nodes: Statement[]): NodePaths<Expression | Statement>;
-  replaceInline<Nodes extends Node$1 | readonly Node$1[] | [Node$1, ...Node$1[]]>(nodes: Nodes): NodePaths<Nodes>; // #endregion
+  replaceInline<Nodes extends Node | readonly Node[] | [Node, ...Node[]]>(nodes: Nodes): NodePaths<Nodes>; // #endregion
   // #region ------------------------- evaluation -------------------------
   /**
    * Walk the input `node` and statically evaluate if it's truthy.
@@ -712,7 +632,7 @@ declare class NodePath<T = Node$1> {
    * This is because arrow functions may implicitly return an expression, which
    * is the same as containing a block statement.
    */
-  canSwapBetweenExpressionAndStatement(replacement: Node$1): boolean;
+  canSwapBetweenExpressionAndStatement(replacement: Node): boolean;
   /** Check whether the current path references a completion record */
   isCompletionRecord(allowInsideFunction?: boolean): boolean;
   /**
@@ -781,12 +701,12 @@ declare class NodePath<T = Node$1> {
   }>; // #endregion
   // #region ------------------------- modification -------------------------
   /** Insert the provided nodes before the current one. */
-  insertBefore<Nodes extends NodesInsertionParam<Node$1>>(nodes: Nodes): NodePaths<Nodes>;
+  insertBefore<Nodes extends NodesInsertionParam<Node>>(nodes: Nodes): NodePaths<Nodes>;
   /**
    * Insert the provided nodes after the current one. When inserting nodes after an
    * expression, ensure that the completion record is correct by pushing the current node.
    */
-  insertAfter<Nodes extends NodesInsertionParam<Node$1>>(nodes: Nodes): NodePaths<Nodes>;
+  insertAfter<Nodes extends NodesInsertionParam<Node>>(nodes: Nodes): NodePaths<Nodes>;
   /** Update all sibling node paths after `fromIndex` by `incrementBy`. */
   updateSiblingKeys(fromIndex: number, incrementBy: number): void;
   /**
@@ -794,13 +714,13 @@ declare class NodePath<T = Node$1> {
    * @param listKey - The key at which the child nodes are stored (usually body).
    * @param nodes - the nodes to insert.
    */
-  unshiftContainer<T extends Node$1, K extends NodeKeyOfArrays<T>, Nodes extends NodesInsertionParam<NodeListType<T, K>>>(this: NodePath<T>, listKey: K, nodes: Nodes): NodePaths<Nodes>;
+  unshiftContainer<T extends Node, K extends NodeKeyOfArrays<T>, Nodes extends NodesInsertionParam<NodeListType<T, K>>>(this: NodePath<T>, listKey: K, nodes: Nodes): NodePaths<Nodes>;
   /**
    * Insert child nodes at the end of the current node.
    * @param listKey - The key at which the child nodes are stored (usually body).
    * @param nodes - the nodes to insert.
    */
-  pushContainer<T extends Node$1, K extends NodeKeyOfArrays<T>, Nodes extends NodesInsertionParam<NodeListType<T, K>>>(this: NodePath<T>, listKey: K, nodes: Nodes): NodePaths<Nodes>;
+  pushContainer<T extends Node, K extends NodeKeyOfArrays<T>, Nodes extends NodesInsertionParam<NodeListType<T, K>>>(this: NodePath<T>, listKey: K, nodes: Nodes): NodePaths<Nodes>;
   /** Hoist the current node to the highest scope possible and return a UID referencing it. */
   hoist(scope: Scope): void; // #endregion
   // #region ------------------------- family -------------------------
@@ -1478,14 +1398,14 @@ interface HubInterface {
   getCode(): string | undefined;
   getScope(): Scope | undefined;
   addHelper(name: string): any;
-  buildError(node: Node$1, msg: string, Error: ErrorConstructor): Error;
+  buildError(node: Node, msg: string, Error: ErrorConstructor): Error;
 }
 declare class Hub implements HubInterface {
   constructor();
   getCode(): string | undefined;
   getScope(): Scope | undefined;
   addHelper(name: string): any;
-  buildError(node: Node$1, msg: string, Error?: ErrorConstructor): Error;
+  buildError(node: Node, msg: string, Error?: ErrorConstructor): Error;
 }
 interface TraversalContext<S = unknown> {
   parentPath: NodePath;
@@ -1498,719 +1418,25 @@ interface TraversalContext<S = unknown> {
 type ImplGetOfArray<T extends readonly unknown[], K extends string> = K extends `${infer N extends number}` ? T[N] : K extends keyof T ? T[K] : never; // dprint-ignore
 type ImplGetByKey<T, K extends string> = T extends readonly unknown[] ? ImplGetOfArray<T, K> : K extends keyof T ? T[K] : K extends `${infer N extends number}` ? N extends keyof T ? T[N] : never : never; // dprint-ignore
 type ImplGetRecursive<T, K extends string> = K extends `${infer L}.${infer R}` ? ImplGetRecursive<ImplGetByKey<T, L>, R> : ImplGetByKey<T, K>;
-type NodePathResult<T> = (Extract<T, Node$1 | null | undefined> extends never ? never : NodePath<Extract<T, Node$1 | null | undefined>>) | (T extends Array<Node$1 | null | undefined> ? Array<NodePath<T[number]>> : never);
+type NodePathResult<T> = (Extract<T, Node | null | undefined> extends never ? never : NodePath<Extract<T, Node | null | undefined>>) | (T extends Array<Node | null | undefined> ? Array<NodePath<T[number]>> : never);
 interface VirtualTypeAliases {
   BindingIdentifier: Identifier;
-  BlockScoped: Node$1;
+  BlockScoped: Node;
   ExistentialTypeParam: ExistsTypeAnnotation;
   Flow: Flow | ImportDeclaration | ExportDeclaration | ImportSpecifier;
   ForAwaitStatement: ForOfStatement;
-  Generated: Node$1;
+  Generated: Node;
   NumericLiteralTypeAnnotation: NumberLiteralTypeAnnotation;
-  Pure: Node$1;
-  Referenced: Node$1;
+  Pure: Node;
+  Referenced: Node;
   ReferencedIdentifier: Identifier | JSXIdentifier;
   ReferencedMemberExpression: MemberExpression;
   RestProperty: RestElement;
   Scope: Scopable | Pattern;
   SpreadProperty: RestElement;
-  User: Node$1;
+  User: Node;
   Var: VariableDeclaration;
 }
-declare namespace index_d_exports {
-  export { BabelFile, BabelFileMetadata, BabelFileModulesMetadata, BabelFileResult, ConfigAPI, ConfigFunction, ConfigItem, CreateConfigItemOptions, DEFAULT_EXTENSIONS, EnvFunction, FileParseCallback, FileResultCallback, GeneratorOptions, MatchPattern, MatchPatternContext, Node, NodePath, ParseResult, ParserOptions, PartialConfig, PluginItem, PluginObj, PluginOptions, PluginPass, PluginTarget, SimpleCacheCallback, SimpleCacheConfigurator, SimpleCacheKey, TransformCaller, TransformOptions, Visitor, createConfigItem, loadOptions, loadPartialConfig, loadPartialConfigAsync, parse, parseAsync, parseSync, resolvePlugin, resolvePreset, templateBuilder as template, transform, transformAsync, transformFile, transformFileAsync, transformFileSync, transformFromAst, transformFromAstAsync, transformFromAstSync, transformSync, traverse$1 as traverse, index_d_exports$1 as types, version };
-}
-type Node = Node$1;
-type ParseResult = ReturnType<typeof parse$1>;
-declare const version: string;
-declare const DEFAULT_EXTENSIONS: [".js", ".jsx", ".es6", ".es", ".mjs"];
-/**
- * Source map standard format as to revision 3
- * @see {@link https://sourcemaps.info/spec.html}
- * @see {@link https://github.com/mozilla/source-map/blob/HEAD/source-map.d.ts}
- */
-interface InputSourceMap {
-  version: number;
-  sources: string[];
-  names: string[];
-  sourceRoot?: string | undefined;
-  sourcesContent?: string[] | undefined;
-  mappings: string;
-  file: string;
-}
-interface TransformOptions {
-  /**
-   * Specify which assumptions it can make about your code, to better optimize the compilation result. **NOTE**: This replaces the various `loose` options in plugins in favor of
-   * top-level options that can apply to multiple plugins
-   *
-   * @see https://babeljs.io/docs/en/assumptions
-   */
-  assumptions?: {
-    [name: string]: boolean;
-  } | null | undefined;
-  /**
-   * Include the AST in the returned object
-   *
-   * Default: `false`
-   */
-  ast?: boolean | null | undefined;
-  /**
-   * Attach a comment after all non-user injected code
-   *
-   * Default: `null`
-   */
-  auxiliaryCommentAfter?: string | null | undefined;
-  /**
-   * Attach a comment before all non-user injected code
-   *
-   * Default: `null`
-   */
-  auxiliaryCommentBefore?: string | null | undefined;
-  /**
-   * Specify the "root" folder that defines the location to search for "babel.config.js", and the default folder to allow `.babelrc` files inside of.
-   *
-   * Default: `"."`
-   */
-  root?: string | null | undefined;
-  /**
-   * This option, combined with the "root" value, defines how Babel chooses its project root.
-   * The different modes define different ways that Babel can process the "root" value to get
-   * the final project root.
-   *
-   * @see https://babeljs.io/docs/en/next/options#rootmode
-   */
-  rootMode?: "root" | "upward" | "upward-optional" | undefined;
-  /**
-   * The config file to load Babel's config from. Defaults to searching for "babel.config.js" inside the "root" folder. `false` will disable searching for config files.
-   *
-   * Default: `undefined`
-   */
-  configFile?: string | boolean | null | undefined;
-  /**
-   * Specify whether or not to use .babelrc and
-   * .babelignore files.
-   *
-   * Default: `true`
-   */
-  babelrc?: boolean | null | undefined;
-  /**
-   * Specify which packages should be search for .babelrc files when they are being compiled. `true` to always search, or a path string or an array of paths to packages to search
-   * inside of. Defaults to only searching the "root" package.
-   *
-   * Default: `(root)`
-   */
-  babelrcRoots?: boolean | MatchPattern | MatchPattern[] | null | undefined;
-  /**
-   * Toggles whether or not browserslist config sources are used, which includes searching for any browserslist files or referencing the browserslist key inside package.json.
-   * This is useful for projects that use a browserslist config for files that won't be compiled with Babel.
-   *
-   * If a string is specified, it must represent the path of a browserslist configuration file. Relative paths are resolved relative to the configuration file which specifies
-   * this option, or to `cwd` when it's passed as part of the programmatic options.
-   *
-   * Default: `true`
-   */
-  browserslistConfigFile?: boolean | null | undefined;
-  /**
-   * The Browserslist environment to use.
-   *
-   * Default: `undefined`
-   */
-  browserslistEnv?: string | null | undefined;
-  /**
-   * By default `babel.transformFromAst` will clone the input AST to avoid mutations.
-   * Specifying `cloneInputAst: false` can improve parsing performance if the input AST is not used elsewhere.
-   *
-   * Default: `true`
-   */
-  cloneInputAst?: boolean | null | undefined;
-  /**
-   * Defaults to environment variable `BABEL_ENV` if set, or else `NODE_ENV` if set, or else it defaults to `"development"`
-   *
-   * Default: env vars
-   */
-  envName?: string | undefined;
-  /**
-   * If any of patterns match, the current configuration object is considered inactive and is ignored during config processing.
-   */
-  exclude?: MatchPattern | MatchPattern[] | undefined;
-  /**
-   * Enable code generation
-   *
-   * Default: `true`
-   */
-  code?: boolean | null | undefined;
-  /**
-   * Output comments in generated output
-   *
-   * Default: `true`
-   */
-  comments?: boolean | null | undefined;
-  /**
-   * Do not include superfluous whitespace characters and line terminators. When set to `"auto"` compact is set to `true` on input sizes of >500KB
-   *
-   * Default: `"auto"`
-   */
-  compact?: boolean | "auto" | null | undefined;
-  /**
-   * The working directory that Babel's programmatic options are loaded relative to.
-   *
-   * Default: `"."`
-   */
-  cwd?: string | null | undefined;
-  /**
-   * Utilities may pass a caller object to identify themselves to Babel and
-   * pass capability-related flags for use by configs, presets and plugins.
-   *
-   * @see https://babeljs.io/docs/en/next/options#caller
-   */
-  caller?: TransformCaller | undefined;
-  /**
-   * This is an object of keys that represent different environments. For example, you may have: `{ env: { production: { \/* specific options *\/ } } }`
-   * which will use those options when the `envName` is `production`
-   *
-   * Default: `{}`
-   */
-  env?: {
-    [index: string]: TransformOptions | null | undefined;
-  } | null | undefined;
-  /**
-   * A path to a `.babelrc` file to extend
-   *
-   * Default: `null`
-   */
-  extends?: string | null | undefined;
-  /**
-   * Filename for use in errors etc
-   *
-   * Default: `"unknown"`
-   */
-  filename?: string | null | undefined;
-  /**
-   * Filename relative to `sourceRoot`
-   *
-   * Default: `(filename)`
-   */
-  filenameRelative?: string | null | undefined;
-  /**
-   * An object containing the options to be passed down to the babel code generator, @babel/generator
-   *
-   * Default: `{}`
-   */
-  generatorOpts?: GeneratorOptions | null | undefined;
-  /**
-   * Specify a custom callback to generate a module id with. Called as `getModuleId(moduleName)`. If falsy value is returned then the generated module id is used
-   *
-   * Default: `null`
-   */
-  getModuleId?: ((moduleName: string) => string | null | undefined) | null | undefined;
-  /**
-   * ANSI highlight syntax error code frames
-   *
-   * Default: `true`
-   */
-  highlightCode?: boolean | null | undefined;
-  /**
-   * Opposite to the `only` option. `ignore` is disregarded if `only` is specified
-   *
-   * Default: `null`
-   */
-  ignore?: MatchPattern[] | null | undefined;
-  /**
-   * This option is a synonym for "test"
-   */
-  include?: MatchPattern | MatchPattern[] | undefined;
-  /**
-   * A source map object that the output source map will be based on
-   *
-   * Default: `null`
-   */
-  inputSourceMap?: InputSourceMap | null | undefined;
-  /**
-   * Should the output be minified (not printing last semicolons in blocks, printing literal string values instead of escaped ones, stripping `()` from `new` when safe)
-   *
-   * Default: `false`
-   */
-  minified?: boolean | null | undefined;
-  /**
-   * Specify a custom name for module ids
-   *
-   * Default: `null`
-   */
-  moduleId?: string | null | undefined;
-  /**
-   * If truthy, insert an explicit id for modules. By default, all modules are anonymous. (Not available for `common` modules)
-   *
-   * Default: `false`
-   */
-  moduleIds?: boolean | null | undefined;
-  /**
-   * Optional prefix for the AMD module formatter that will be prepend to the filename on module definitions
-   *
-   * Default: `(sourceRoot)`
-   */
-  moduleRoot?: string | null | undefined;
-  /**
-   * A glob, regex, or mixed array of both, matching paths to **only** compile. Can also be an array of arrays containing paths to explicitly match. When attempting to compile
-   * a non-matching file it's returned verbatim
-   *
-   * Default: `null`
-   */
-  only?: MatchPattern[] | null | undefined;
-  /**
-   * Allows users to provide an array of options that will be merged into the current configuration one at a time.
-   * This feature is best used alongside the "test"/"include"/"exclude" options to provide conditions for which an override should apply
-   */
-  overrides?: TransformOptions[] | undefined;
-  /**
-   * An object containing the options to be passed down to the babel parser, @babel/parser
-   *
-   * Default: `{}`
-   */
-  parserOpts?: ParserOptions | null | undefined;
-  /**
-   * List of plugins to load and use
-   *
-   * Default: `[]`
-   */
-  plugins?: PluginItem[] | null | undefined;
-  /**
-   * List of presets (a set of plugins) to load and use
-   *
-   * Default: `[]`
-   */
-  presets?: PluginItem[] | null | undefined;
-  /**
-   * Retain line numbers. This will lead to wacky code but is handy for scenarios where you can't use source maps. (**NOTE**: This will not retain the columns)
-   *
-   * Default: `false`
-   */
-  retainLines?: boolean | null | undefined;
-  /**
-   * An optional callback that controls whether a comment should be output or not. Called as `shouldPrintComment(commentContents)`. **NOTE**: This overrides the `comment` option when used
-   *
-   * Default: `null`
-   */
-  shouldPrintComment?: ((commentContents: string) => boolean) | null | undefined;
-  /**
-   * Set `sources[0]` on returned source map
-   *
-   * Default: `(filenameRelative)`
-   */
-  sourceFileName?: string | null | undefined;
-  /**
-   * If truthy, adds a `map` property to returned output. If set to `"inline"`, a comment with a sourceMappingURL directive is added to the bottom of the returned code. If set to `"both"`
-   * then a `map` property is returned as well as a source map comment appended. **This does not emit sourcemap files by itself!**
-   *
-   * Default: `false`
-   */
-  sourceMaps?: boolean | "inline" | "both" | null | undefined;
-  /**
-   * The root from which all sources are relative
-   *
-   * Default: `(moduleRoot)`
-   */
-  sourceRoot?: string | null | undefined;
-  /**
-   * Indicate the mode the code should be parsed in. Can be one of "script", "module", or "unambiguous". `"unambiguous"` will make Babel attempt to guess, based on the presence of ES6
-   * `import` or `export` statements. Files with ES6 `import`s and `export`s are considered `"module"` and are otherwise `"script"`.
-   *
-   * Default: `("module")`
-   */
-  sourceType?: "script" | "module" | "unambiguous" | null | undefined;
-  /**
-   * If all patterns fail to match, the current configuration object is considered inactive and is ignored during config processing.
-   */
-  test?: MatchPattern | MatchPattern[] | undefined;
-  /**
-   * Describes the environments you support/target for your project.
-   * This can either be a [browserslist-compatible](https://github.com/ai/browserslist) query (with [caveats](https://babeljs.io/docs/en/babel-preset-env#ineffective-browserslist-queries))
-   *
-   * Default: `{}`
-   */
-  targets?: string | string[] | {
-    esmodules?: boolean;
-    node?: Omit<string, "current"> | "current" | true;
-    safari?: Omit<string, "tp"> | "tp";
-    browsers?: string | string[];
-    android?: string;
-    chrome?: string;
-    deno?: string;
-    edge?: string;
-    electron?: string;
-    firefox?: string;
-    ie?: string;
-    ios?: string;
-    opera?: string;
-    rhino?: string;
-    samsung?: string;
-  };
-  /**
-   * An optional callback that can be used to wrap visitor methods. **NOTE**: This is useful for things like introspection, and not really needed for implementing anything. Called as
-   * `wrapPluginVisitorMethod(pluginAlias, visitorType, callback)`.
-   */
-  wrapPluginVisitorMethod?: ((pluginAlias: string, visitorType: "enter" | "exit", callback: (path: NodePath, state: any) => void) => (path: NodePath, state: any) => void) | null | undefined;
-}
-interface TransformCaller {
-  // the only required property
-  name: string; // e.g. set to true by `babel-loader` and false by `babel-jest`
-  supportsStaticESM?: boolean | undefined;
-  supportsDynamicImport?: boolean | undefined;
-  supportsExportNamespaceFrom?: boolean | undefined;
-  supportsTopLevelAwait?: boolean | undefined; // augment this with a "declare module '@babel/core' { ... }" if you need more keys
-}
-type FileResultCallback = (err: Error | null, result: BabelFileResult | null) => any;
-interface MatchPatternContext {
-  envName: string;
-  dirname: string;
-  caller: TransformCaller | undefined;
-}
-type MatchPattern = string | RegExp | ((filename: string | undefined, context: MatchPatternContext) => boolean);
-/**
- * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST.
- */
-declare function transform(code: string, callback: FileResultCallback): void;
-/**
- * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST.
- */
-declare function transform(code: string, opts: TransformOptions | undefined, callback: FileResultCallback): void;
-/**
- * Here for backward-compatibility. Ideally use `transformSync` if you want a synchronous API.
- */
-declare function transform(code: string, opts?: TransformOptions): BabelFileResult | null;
-/**
- * Transforms the passed in code. Returning an object with the generated code, source map, and AST.
- */
-declare function transformSync(code: string, opts?: TransformOptions): BabelFileResult | null;
-/**
- * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST.
- */
-declare function transformAsync(code: string, opts?: TransformOptions): Promise<BabelFileResult | null>;
-/**
- * Asynchronously transforms the entire contents of a file.
- */
-declare function transformFile(filename: string, callback: FileResultCallback): void;
-/**
- * Asynchronously transforms the entire contents of a file.
- */
-declare function transformFile(filename: string, opts: TransformOptions | undefined, callback: FileResultCallback): void;
-/**
- * Synchronous version of `babel.transformFile`. Returns the transformed contents of the `filename`.
- */
-declare function transformFileSync(filename: string, opts?: TransformOptions): BabelFileResult | null;
-/**
- * Asynchronously transforms the entire contents of a file.
- */
-declare function transformFileAsync(filename: string, opts?: TransformOptions): Promise<BabelFileResult | null>;
-/**
- * Given an AST, transform it.
- */
-declare function transformFromAst(ast: Node, code: string | undefined, callback: FileResultCallback): void;
-/**
- * Given an AST, transform it.
- */
-declare function transformFromAst(ast: Node, code: string | undefined, opts: TransformOptions | undefined, callback: FileResultCallback): void;
-/**
- * Here for backward-compatibility. Ideally use ".transformSync" if you want a synchronous API.
- */
-declare function transformFromAstSync(ast: Node, code?: string, opts?: TransformOptions): BabelFileResult | null;
-/**
- * Given an AST, transform it.
- */
-declare function transformFromAstAsync(ast: Node, code?: string, opts?: TransformOptions): Promise<BabelFileResult | null>;
-// A babel plugin is a simple function which must return an object matching
-// the following interface. Babel will throw if it finds unknown properties.
-// The list of allowed plugin keys is here:
-// https://github.com/babel/babel/blob/4e50b2d9d9c376cee7a2cbf56553fe5b982ea53c/packages/babel-core/src/config/option-manager.js#L71
-interface PluginObj<S = PluginPass> {
-  name?: string | undefined;
-  manipulateOptions?(opts: any, parserOpts: any): void;
-  pre?(this: S, file: BabelFile): void;
-  visitor: Visitor<S>;
-  post?(this: S, file: BabelFile): void;
-  inherits?: any;
-}
-interface BabelFile {
-  ast: File;
-  opts: TransformOptions;
-  hub: Hub;
-  metadata: object;
-  path: NodePath<Program>;
-  scope: Scope;
-  inputMap: object | null;
-  code: string;
-}
-interface PluginPass {
-  file: BabelFile;
-  key: string;
-  opts: object;
-  cwd: string;
-  filename: string | undefined;
-  get(key: unknown): any;
-  set(key: unknown, value: unknown): void;
-  [key: string]: unknown;
-}
-interface BabelFileResult {
-  ast?: File | null | undefined;
-  code?: string | null | undefined;
-  ignored?: boolean | undefined;
-  map?: {
-    version: number;
-    sources: string[];
-    names: string[];
-    sourceRoot?: string | undefined;
-    sourcesContent?: string[] | undefined;
-    mappings: string;
-    file: string;
-  } | null | undefined;
-  metadata?: BabelFileMetadata | undefined;
-}
-interface BabelFileMetadata {
-  usedHelpers: string[];
-  marked: Array<{
-    type: string;
-    message: string;
-    loc: object;
-  }>;
-  modules: BabelFileModulesMetadata;
-}
-interface BabelFileModulesMetadata {
-  imports: object[];
-  exports: {
-    exported: object[];
-    specifiers: object[];
-  };
-}
-type FileParseCallback = (err: Error | null, result: ParseResult | null) => any;
-/**
- * Given some code, parse it using Babel's standard behavior.
- * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled.
- */
-declare function parse(code: string, callback: FileParseCallback): void;
-/**
- * Given some code, parse it using Babel's standard behavior.
- * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled.
- */
-declare function parse(code: string, options: TransformOptions | undefined, callback: FileParseCallback): void;
-/**
- * Given some code, parse it using Babel's standard behavior.
- * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled.
- */
-declare function parse(code: string, options?: TransformOptions): ParseResult | null;
-/**
- * Given some code, parse it using Babel's standard behavior.
- * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled.
- */
-declare function parseSync(code: string, options?: TransformOptions): ParseResult | null;
-/**
- * Given some code, parse it using Babel's standard behavior.
- * Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled.
- */
-declare function parseAsync(code: string, options?: TransformOptions): Promise<ParseResult | null>;
-/**
- * Resolve Babel's options fully, resulting in an options object where:
- *
- * * opts.plugins is a full list of Plugin instances.
- * * opts.presets is empty and all presets are flattened into opts.
- * * It can be safely passed back to Babel. Fields like babelrc have been set to false so that later calls to Babel
- * will not make a second attempt to load config files.
- *
- * Plugin instances aren't meant to be manipulated directly, but often callers will serialize this opts to JSON to
- * use it as a cache key representing the options Babel has received. Caching on this isn't 100% guaranteed to
- * invalidate properly, but it is the best we have at the moment.
- */
-declare function loadOptions(options?: TransformOptions): object | null;
-/**
- * To allow systems to easily manipulate and validate a user's config, this function resolves the plugins and
- * presets and proceeds no further. The expectation is that callers will take the config's .options, manipulate it
- * as then see fit and pass it back to Babel again.
- *
- * * `babelrc: string | void` - The path of the `.babelrc` file, if there was one.
- * * `babelignore: string | void` - The path of the `.babelignore` file, if there was one.
- * * `options: ValidatedOptions` - The partially resolved options, which can be manipulated and passed back
- * to Babel again.
- *  * `plugins: Array<ConfigItem>` - See below.
- *  * `presets: Array<ConfigItem>` - See below.
- *  * It can be safely passed back to Babel. Fields like `babelrc` have been set to false so that later calls to
- * Babel will not make a second attempt to load config files.
- *
- * `ConfigItem` instances expose properties to introspect the values, but each item should be treated as
- * immutable. If changes are desired, the item should be removed from the list and replaced with either a normal
- * Babel config value, or with a replacement item created by `babel.createConfigItem`. See that function for
- * information about `ConfigItem` fields.
- */
-declare function loadPartialConfig(options?: TransformOptions): Readonly<PartialConfig> | null;
-declare function loadPartialConfigAsync(options?: TransformOptions): Promise<Readonly<PartialConfig> | null>;
-interface PartialConfig {
-  options: TransformOptions;
-  babelrc?: string | undefined;
-  babelignore?: string | undefined;
-  config?: string | undefined;
-  hasFilesystemConfig: () => boolean;
-}
-interface ConfigItem {
-  /**
-   * The name that the user gave the plugin instance, e.g. `plugins: [ ['env', {}, 'my-env'] ]`
-   */
-  name?: string | undefined;
-  /**
-   * The resolved value of the plugin.
-   */
-  value: object | ((...args: any[]) => any);
-  /**
-   * The options object passed to the plugin.
-   */
-  options?: object | false | undefined;
-  /**
-   * The path that the options are relative to.
-   */
-  dirname: string;
-  /**
-   * Information about the plugin's file, if Babel knows it.
-   *  *
-   */
-  file?: {
-    /**
-     * The file that the user requested, e.g. `"@babel/env"`
-     */
-    request: string;
-    /**
-     * The full path of the resolved file, e.g. `"/tmp/node_modules/@babel/preset-env/lib/index.js"`
-     */
-    resolved: string;
-  } | null | undefined;
-}
-type PluginOptions = object | undefined | false;
-type PluginTarget = string | object | ((...args: any[]) => any);
-type PluginItem = ConfigItem | PluginObj<any> | PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | undefined];
-declare function resolvePlugin(name: string, dirname: string): string | null;
-declare function resolvePreset(name: string, dirname: string): string | null;
-interface CreateConfigItemOptions {
-  dirname?: string | undefined;
-  type?: "preset" | "plugin" | undefined;
-}
-/**
- * Allows build tooling to create and cache config items up front. If this function is called multiple times for a
- * given plugin, Babel will call the plugin's function itself multiple times. If you have a clear set of expected
- * plugins and presets to inject, pre-constructing the config items would be recommended.
- */
-declare function createConfigItem(value: PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | undefined], options?: CreateConfigItemOptions): ConfigItem;
-// NOTE: the documentation says the ConfigAPI also exposes @babel/core's exports, but it actually doesn't
-/**
- * @see https://babeljs.io/docs/en/next/config-files#config-function-api
- */
-interface ConfigAPI {
-  /**
-   * The version string for the Babel version that is loading the config file.
-   *
-   * @see https://babeljs.io/docs/en/next/config-files#apiversion
-   */
-  version: string;
-  /**
-   * @see https://babeljs.io/docs/en/next/config-files#apicache
-   */
-  cache: SimpleCacheConfigurator;
-  /**
-   * @see https://babeljs.io/docs/en/next/config-files#apienv
-   */
-  env: EnvFunction; // undocumented; currently hardcoded to return 'false'
-  // async(): boolean
-  /**
-   * This API is used as a way to access the `caller` data that has been passed to Babel.
-   * Since many instances of Babel may be running in the same process with different `caller` values,
-   * this API is designed to automatically configure `api.cache`, the same way `api.env()` does.
-   *
-   * The `caller` value is available as the first parameter of the callback function.
-   * It is best used with something like this to toggle configuration behavior
-   * based on a specific environment:
-   *
-   * @example
-   * function isBabelRegister(caller?: { name: string }) {
-   *   return !!(caller && caller.name === "@babel/register")
-   * }
-   * api.caller(isBabelRegister)
-   *
-   * @see https://babeljs.io/docs/en/next/config-files#apicallercb
-   */
-  caller<T extends SimpleCacheKey>(callerCallback: (caller: TransformOptions["caller"]) => T): T;
-  /**
-   * While `api.version` can be useful in general, it's sometimes nice to just declare your version.
-   * This API exposes a simple way to do that with:
-   *
-   * @example
-   * api.assertVersion(7) // major version only
-   * api.assertVersion("^7.2")
-   *
-   * @see https://babeljs.io/docs/en/next/config-files#apiassertversionrange
-   */
-  assertVersion(versionRange: number | string): boolean; // NOTE: this is an undocumented reexport from "@babel/parser" but it's missing from its types
-  // tokTypes: typeof tokTypes
-}
-/**
- * JS configs are great because they can compute a config on the fly,
- * but the downside there is that it makes caching harder.
- * Babel wants to avoid re-executing the config function every time a file is compiled,
- * because then it would also need to re-execute any plugin and preset functions
- * referenced in that config.
- *
- * To avoid this, Babel expects users of config functions to tell it how to manage caching
- * within a config file.
- *
- * @see https://babeljs.io/docs/en/next/config-files#apicache
- */
-interface SimpleCacheConfigurator {
-  // there is an undocumented call signature that is a shorthand for forever()/never()/using().
-  // (ever: boolean): void
-  // <T extends SimpleCacheKey>(callback: CacheCallback<T>): T
-  /**
-   * Permacache the computed config and never call the function again.
-   */
-  forever(): void;
-  /**
-   * Do not cache this config, and re-execute the function every time.
-   */
-  never(): void;
-  /**
-   * Any time the using callback returns a value other than the one that was expected,
-   * the overall config function will be called again and a new entry will be added to the cache.
-   *
-   * @example
-   * api.cache.using(() => process.env.NODE_ENV)
-   */
-  using<T extends SimpleCacheKey>(callback: SimpleCacheCallback<T>): T;
-  /**
-   * Any time the using callback returns a value other than the one that was expected,
-   * the overall config function will be called again and all entries in the cache will
-   * be replaced with the result.
-   *
-   * @example
-   * api.cache.invalidate(() => process.env.NODE_ENV)
-   */
-  invalidate<T extends SimpleCacheKey>(callback: SimpleCacheCallback<T>): T;
-}
-// https://github.com/babel/babel/blob/v7.3.3/packages/babel-core/src/config/caching.js#L231
-type SimpleCacheKey = string | boolean | number | null | undefined;
-type SimpleCacheCallback<T extends SimpleCacheKey> = () => T;
-/**
- * Since `NODE_ENV` is a fairly common way to toggle behavior, Babel also includes an API function
- * meant specifically for that. This API is used as a quick way to check the `"envName"` that Babel
- * was loaded with, which takes `NODE_ENV` into account if no other overriding environment is set.
- *
- * @see https://babeljs.io/docs/en/next/config-files#apienv
- */
-interface EnvFunction {
-  /**
-   * @returns the current `envName` string
-   */
-  (): string;
-  /**
-   * @returns `true` if the `envName` is `===` any of the given strings
-   */
-  (envName: string | readonly string[]): boolean; // the official documentation is misleading for this one...
-  // this just passes the callback to `cache.using` but with an additional argument.
-  // it returns its result instead of necessarily returning a boolean.
-  <T extends SimpleCacheKey>(envCallback: (envName: NonNullable<TransformOptions["envName"]>) => T): T;
-}
-type ConfigFunction = (api: ConfigAPI) => TransformOptions;
 //#endregion
 //#region .dts-emit/code/core/src/babel/babelParse.d.ts
 declare const parserOptions: ParserOptions;
@@ -2219,7 +1445,31 @@ interface ASTNode {
   type: string;
 }
 declare const babelPrint: (ast: ASTNode) => string;
-declare const babelParseExpression: (code: string) => ParseResult$1<Expression>;
+declare const babelParseExpression: (code: string) => ParseResult<Expression>;
+//#endregion
+//#region .dts-emit/code/core/src/babel/babel-file.d.ts
+/** A parsed file with its Program path, like the `File` of @babel/core. */
+interface BabelFile {
+  ast: File;
+  code: string;
+  opts: {
+    filename?: string;
+  };
+  path: NodePath<Program>;
+}
+/**
+ * Makes the Program path of `ast` the same way the `File` class of @babel/core does, without
+ * @babel/core. The hub gives `path.buildCodeFrameError` a code frame from `code`.
+ */
+declare function createBabelFile({
+  code,
+  ast,
+  filename
+}: {
+  code: string;
+  ast: File;
+  filename?: string;
+}): BabelFile;
 //#endregion
 //#region .dts-emit/code/core/src/babel/expression-resolver.d.ts
 /** Recursively unwraps TypeScript type annotation expressions (as X, satisfies X, <X>expr). */
@@ -2296,6 +1546,5 @@ declare const canUpdateVitestConfigFile: (fileContent: string) => boolean;
 //#region .dts-emit/code/core/src/babel/index.d.ts
 declare const traverse: typeof traverse$1;
 declare const generate: typeof generate$1;
-declare const BabelFileClass: any;
 //#endregion
-export { type BabelFile, BabelFileClass, type GeneratorOptions, type NodePath, type RecastOptions, babelParse, babelParseExpression, babelPrint, canUpdateVitestConfigFile, index_d_exports as core, generate, getConfigObjectFromMergeArg, getEffectiveMergeConfigCall, getTargetConfigObject, isDefineConfigLike, isImportedDefineConfigLikeIdentifier, babel_parser_d_exports as parser, parserOptions, recast, resolveExpression, transformSync, traverse, index_d_exports$1 as types, unwrapTSExpression };
+export { type BabelFile, type GeneratorOptions, type NodePath, type RecastOptions, babelParse, babelParseExpression, babelPrint, canUpdateVitestConfigFile, createBabelFile, generate, getConfigObjectFromMergeArg, getEffectiveMergeConfigCall, getTargetConfigObject, isDefineConfigLike, isImportedDefineConfigLikeIdentifier, babel_parser_d_exports as parser, parserOptions, recast, resolveExpression, traverse, index_d_exports as types, unwrapTSExpression };