yuku-walk 0.0.1

package/README.md

@@ -0,0 +1,220 @@
+# yuku-walk
+
+A fast, fully typed AST walker for [`yuku-parser`](https://www.npmjs.com/package/yuku-parser).
+
+Type-keyed visitors with `enter`/`leave`, alias groups, in-place mutation, and a
+complete set of type guards and node builders. No runtime dependencies.
+
+```ts
+import { parse } from "yuku-parser";
+import { walk } from "yuku-walk";
+
+const { program } = parse("const greet = (name) => `hi ${name}`;");
+
+walk(program, {
+  Identifier(node) {
+    console.log(node.name); // greet, name, name
+  },
+});
+```
+
+## Install
+
+```sh
+bun add yuku-walk yuku-parser
+```
+
+`yuku-parser` is a peer dependency.
+
+## Visitors
+
+A visitor is keyed by node `type`, by an alias group, or by the universal
+`enter` / `leave`. Each handler receives the typed node and a [`path`](#the-path).
+
+```ts
+walk(program, {
+  // a concrete node type, `node` is precisely typed
+  CallExpression(node, path) {
+    if (path.parent?.type === "AwaitExpression") return;
+  },
+
+  // an alias group fires for a whole family
+  Function(node) {
+    node.params; // FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | ...
+  },
+
+  // enter/leave for any node type
+  MemberExpression: {
+    enter(node) {},
+    leave(node) {},
+  },
+
+  // run for every node
+  enter(node) {},
+  leave(node) {},
+});
+```
+
+Aliases: `Expression`, `Statement`, `Declaration`, `ModuleDeclaration`,
+`Function`, `Class`, `Method`, `Loop`, `Pattern`, `JSX`, `TSType`.
+
+When several handlers match a node, `enter` runs outermost first
+(universal, alias, concrete) and `leave` runs in reverse.
+
+## The path
+
+Every visitor receives a `path` describing where it is and how to change the tree.
+Each node has its own path, so it stays valid after the visit returns.
+
+```ts
+node: T                       // the current node
+parent: Node | null           // owner, or null at the root
+key: string | null            // field on the parent holding this node
+index: number | null          // position within an array field, else null
+ancestors: readonly Node[]    // root down to the parent
+state: S                      // value threaded through the walk
+
+skip()                        // do not descend into this node
+stop()                        // end the walk
+replace(next)                 // swap this node, then walk the replacement
+remove()                      // detach from the parent
+insertBefore(node)            // add a sibling before (array fields)
+insertAfter(node)             // add a sibling after (array fields)
+```
+
+```ts
+walk(program, {
+  DebuggerStatement(_node, path) {
+    path.remove();
+  },
+  Identifier(node, path) {
+    if (node.name === "foo") path.replace(b.identifier("bar"));
+  },
+});
+```
+
+`replace` walks into the replacement's children but does not re-run its own
+`enter`. A synthetic replacement (one built with `b.*`) inherits the replaced
+node's source span, so generated output still maps back to the original.
+
+## Type guards (`is`)
+
+A guard for every node `type`, the alias families, and the variants that share a
+`type` string. All accept `null` / `undefined` and return `false`.
+
+```ts
+import { is } from "yuku-walk";
+
+is.CallExpression(node); // every concrete type
+is.Expression(node); // families
+is.StringLiteral(node); // Literal variants
+is.StaticMemberExpression(node); // MemberExpression variants
+is.BindingIdentifier(node); // Identifier roles, via `kind`
+
+walk(program, {
+  Literal(node, path) {
+    if (is.ArrayExpression(path.parent)) {
+      // path.parent is narrowed to ArrayExpression
+    }
+  },
+});
+```
+
+## Builders (`b`)
+
+A builder for every node type. Required fields are positional, the rest go in a
+trailing options object. Synthetic nodes get a zero span.
+
+```ts
+import { b } from "yuku-walk";
+
+b.identifier("x");
+b.callExpression(b.identifier("f"), [b.numericLiteral(1)]);
+b.arrowFunctionExpression([b.identifier("a", "binding")], b.identifier("a"));
+b.variableDeclaration("const", [
+  b.variableDeclarator(b.identifier("x", "binding"), b.numericLiteral(0)),
+]);
+```
+
+## Transform and print
+
+Pair it with [`yuku-codegen`](https://www.npmjs.com/package/yuku-codegen) to parse,
+rewrite, and print back to source.
+
+```ts
+import { parse } from "yuku-parser";
+import { print } from "yuku-codegen";
+import { walk, is, b } from "yuku-walk";
+
+const { program } = parse("const x = 1; debugger; foo(x, 2);");
+
+walk(program, {
+  DebuggerStatement(_node, path) {
+    path.remove();
+  },
+  Identifier(node, path) {
+    if (node.name === "foo") path.replace(b.identifier("bar"));
+  },
+  Literal(node, path) {
+    if (is.NumericLiteral(node)) path.replace(b.numericLiteral((node.value ?? 0) * 10));
+  },
+});
+
+console.log(print(program).code);
+// const x = 10;
+// bar(x, 20);
+```
+
+`walk` edits the tree in place, so a transform is just a reusable visitor object,
+and passes compose: run as many as you like, then print once.
+
+```ts
+import { walk, b, type Visitors } from "yuku-walk";
+
+const stripDebugger: Visitors = {
+  DebuggerStatement: (_node, path) => path.remove(),
+};
+const inlineDevFlag: Visitors = {
+  Identifier(node, path) {
+    if (node.name === "__DEV__") path.replace(b.booleanLiteral(false));
+  },
+};
+
+const { program } = parse("if (__DEV__) log(); debugger; run();");
+for (const transform of [stripDebugger, inlineDevFlag]) {
+  walk(program, transform);
+}
+console.log(print(program).code);
+// if (false) log();
+// run();
+```
+
+Replacements built with `b.*` inherit the replaced node's source span, so
+`yuku-codegen` source maps still point back to the original input.
+
+## Async
+
+`walkAsync` is the same walk with awaitable visitors, run sequentially in
+depth-first order. Reach for it only when a visitor must await I/O; `walk` is
+faster otherwise.
+
+```ts
+import { walkAsync } from "yuku-walk";
+
+await walkAsync(program, {
+  async ImportDeclaration(node, path) {
+    if (!(await exists(node.source.value))) path.remove();
+  },
+});
+```
+
+## Performance
+
+The walk reads a fixed table of child fields per node type rather than reflecting
+over keys, and dispatches through a cached, per-type handler list. On a large
+TypeScript file it walks several times faster than `@babel/traverse` and on par
+with the lightest reflection walkers, while staying fully typed.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,642 @@
+import * as t from "yuku-parser";
+import { BigIntLiteral, BindingIdentifier, BooleanLiteral, ComputedMemberExpression, Directive, IdentifierName, IdentifierReference, LabelIdentifier, Node, NullLiteral, NumericLiteral, PrivateFieldExpression, RegExpLiteral, StaticMemberExpression, StringLiteral } from "yuku-parser";
+
+//#region src/aliases.d.ts
+/**
+ * Node types grouped under a shared alias. A visitor registered under an alias
+ * name runs for every member type. Membership is by node `type`.
+ */
+declare const ALIAS_GROUPS: {
+  readonly Expression: readonly ["Identifier", "Literal", "ThisExpression", "Super", "ArrayExpression", "ObjectExpression", "FunctionExpression", "ArrowFunctionExpression", "ClassExpression", "TaggedTemplateExpression", "TemplateLiteral", "MemberExpression", "CallExpression", "NewExpression", "ChainExpression", "SequenceExpression", "ParenthesizedExpression", "BinaryExpression", "LogicalExpression", "ConditionalExpression", "UnaryExpression", "UpdateExpression", "AssignmentExpression", "YieldExpression", "AwaitExpression", "ImportExpression", "MetaProperty", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "JSXElement", "JSXFragment"];
+  readonly Statement: readonly ["ExpressionStatement", "BlockStatement", "EmptyStatement", "DebuggerStatement", "ReturnStatement", "LabeledStatement", "BreakStatement", "ContinueStatement", "IfStatement", "SwitchStatement", "ThrowStatement", "TryStatement", "WhileStatement", "DoWhileStatement", "ForStatement", "ForInStatement", "ForOfStatement", "WithStatement", "FunctionDeclaration", "ClassDeclaration", "VariableDeclaration", "TSDeclareFunction", "TSTypeAliasDeclaration", "TSInterfaceDeclaration", "TSEnumDeclaration", "TSModuleDeclaration", "TSImportEqualsDeclaration"];
+  readonly Declaration: readonly ["FunctionDeclaration", "ClassDeclaration", "VariableDeclaration", "TSDeclareFunction", "TSTypeAliasDeclaration", "TSInterfaceDeclaration", "TSEnumDeclaration", "TSModuleDeclaration", "TSImportEqualsDeclaration"];
+  readonly ModuleDeclaration: readonly ["ImportDeclaration", "ExportNamedDeclaration", "ExportDefaultDeclaration", "ExportAllDeclaration", "TSExportAssignment", "TSNamespaceExportDeclaration"];
+  readonly Function: readonly ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression", "TSDeclareFunction", "TSEmptyBodyFunctionExpression"];
+  readonly Class: readonly ["ClassDeclaration", "ClassExpression"];
+  readonly Method: readonly ["MethodDefinition", "TSAbstractMethodDefinition"];
+  readonly Loop: readonly ["ForStatement", "ForInStatement", "ForOfStatement", "WhileStatement", "DoWhileStatement"];
+  readonly Pattern: readonly ["Identifier", "ArrayPattern", "ObjectPattern", "AssignmentPattern", "RestElement"];
+  readonly JSX: readonly ["JSXElement", "JSXOpeningElement", "JSXClosingElement", "JSXFragment", "JSXOpeningFragment", "JSXClosingFragment", "JSXIdentifier", "JSXNamespacedName", "JSXMemberExpression", "JSXAttribute", "JSXSpreadAttribute", "JSXExpressionContainer", "JSXEmptyExpression", "JSXText", "JSXSpreadChild"];
+  readonly TSType: readonly ["TSAnyKeyword", "TSUnknownKeyword", "TSNeverKeyword", "TSVoidKeyword", "TSNullKeyword", "TSUndefinedKeyword", "TSStringKeyword", "TSNumberKeyword", "TSBigIntKeyword", "TSBooleanKeyword", "TSSymbolKeyword", "TSObjectKeyword", "TSIntrinsicKeyword", "TSThisType", "TSTypeReference", "TSTypeQuery", "TSImportType", "TSLiteralType", "TSTemplateLiteralType", "TSArrayType", "TSIndexedAccessType", "TSTupleType", "TSNamedTupleMember", "TSJSDocNullableType", "TSJSDocNonNullableType", "TSJSDocUnknownType", "TSUnionType", "TSIntersectionType", "TSConditionalType", "TSInferType", "TSTypeOperator", "TSParenthesizedType", "TSFunctionType", "TSConstructorType", "TSTypePredicate", "TSTypeLiteral", "TSMappedType"];
+};
+/** Name of an alias group. */
+type AliasName = keyof typeof ALIAS_GROUPS;
+/** Node union matched by each alias group. */
+type AliasMap = { [K in AliasName]: NodeOfType<(typeof ALIAS_GROUPS)[K][number]> };
+//#endregion
+//#region src/types.d.ts
+/** Discriminant `type` string of every AST node. */
+type NodeType = Node["type"];
+/** The node, or union of nodes, carrying a given `type`. */
+type NodeOfType<K extends NodeType> = Extract<Node, {
+  type: K;
+}>;
+/** Field names of a node whose values hold child nodes. */
+type ChildKeys<N> = { [K in keyof N]-?: [NonNullable<N[K]>] extends [never] ? never : NonNullable<N[K]> extends Node ? K : NonNullable<N[K]> extends readonly (infer E)[] ? NonNullable<E> extends Node ? K : never : never }[keyof N];
+/**
+ * A node's position in the tree, passed to every visitor. It exposes the
+ * surrounding context and the operations for changing the tree. Each node has
+ * its own path, so a path stays valid after its visit returns.
+ */
+interface Path<T extends Node = Node, S = unknown> {
+  /** The node being visited. */
+  readonly node: T;
+  /** The node that holds {@link node}, or null at the root. */
+  readonly parent: Node | null;
+  /** The field on {@link parent} that holds {@link node} or its array, or null at the root. */
+  readonly key: string | null;
+  /** Index of {@link node} within an array field, or null when it sits in a plain field. */
+  readonly index: number | null;
+  /** Ancestors from the root down to {@link parent}, excluding {@link node}. */
+  readonly ancestors: readonly Node[];
+  /** State threaded through the walk. */
+  state: S;
+  /** Do not descend into the current node's children. */
+  skip(): void;
+  /** Stop the walk entirely. */
+  stop(): void;
+  /** Replace the current node, then walk the replacement's children. */
+  replace(next: Node): void;
+  /** Remove the current node from its parent. */
+  remove(): void;
+  /** Insert a sibling before the current node. Only valid in an array field. */
+  insertBefore(node: Node): void;
+  /** Insert a sibling after the current node. Only valid in an array field. */
+  insertAfter(node: Node): void;
+}
+/** Handler invoked with a node and the {@link Path} cursor. */
+type VisitFn<T extends Node, S> = (node: T, path: Path<T, S>) => void;
+/** A visitor: a function run on enter, or an object with `enter` and/or `leave`. */
+type Visitor<T extends Node, S> = VisitFn<T, S> | {
+  enter?: VisitFn<T, S>;
+  leave?: VisitFn<T, S>;
+};
+/**
+ * Visitors passed to {@link walk}. A key may be a node `type`, an alias group
+ * such as `Function` or `Expression`, or `enter`/`leave` to match every node.
+ */
+type Visitors<S = unknown> = { [K in NodeType]?: Visitor<NodeOfType<K>, S> } & { [K in keyof AliasMap]?: Visitor<AliasMap[K], S> } & {
+  enter?: VisitFn<Node, S>;
+  leave?: VisitFn<Node, S>;
+};
+/** Like {@link VisitFn}, but may return a promise that the walk awaits. */
+type AsyncVisitFn<T extends Node, S> = (node: T, path: Path<T, S>) => void | Promise<void>;
+/** A visitor for {@link walkAsync}: a function, or an object with `enter` and/or `leave`. */
+type AsyncVisitor<T extends Node, S> = AsyncVisitFn<T, S> | {
+  enter?: AsyncVisitFn<T, S>;
+  leave?: AsyncVisitFn<T, S>;
+};
+/** Visitors passed to {@link walkAsync}. Shaped like {@link Visitors}, with awaitable handlers. */
+type AsyncVisitors<S = unknown> = { [K in NodeType]?: AsyncVisitor<NodeOfType<K>, S> } & { [K in keyof AliasMap]?: AsyncVisitor<AliasMap[K], S> } & {
+  enter?: AsyncVisitFn<Node, S>;
+  leave?: AsyncVisitFn<Node, S>;
+};
+//#endregion
+//#region src/walk.d.ts
+/**
+ * Walk an AST depth first, dispatching to typed visitors and mutating in place.
+ *
+ * @param root     The node to start from, usually a `Program`.
+ * @param visitors Handlers keyed by node `type`, alias group, or `enter`/`leave`.
+ * @param state    Optional value exposed as `path.state` throughout the walk.
+ * @returns The root node, or its replacement if the root was replaced.
+ *
+ * @example
+ * ```ts
+ * walk(program, {
+ *   Identifier(node) {
+ *     console.log(node.name);
+ *   },
+ *   CallExpression(node, path) {
+ *     if (node.callee.type === "MemberExpression") path.skip();
+ *   },
+ * });
+ * ```
+ */
+declare function walk<T extends Node, S = unknown>(root: T, visitors: Visitors<S>, state?: S): T;
+//#endregion
+//#region src/walk-async.d.ts
+/**
+ * Like {@link walk}, but visitors may be `async`. Handlers are awaited one at a
+ * time in depth-first order, so mutation behaves exactly as in the sync walk.
+ * Reach for this only when a visitor needs to await I/O; prefer {@link walk}
+ * otherwise, as awaiting has per-node overhead.
+ *
+ * @returns A promise of the root node, or its replacement if the root was replaced.
+ */
+declare function walkAsync<T extends Node, S = unknown>(root: T, visitors: AsyncVisitors<S>, state?: S): Promise<T>;
+//#endregion
+//#region src/predicates.d.ts
+type MaybeNode = Node | null | undefined;
+declare const is: {
+  Expression: (node: MaybeNode) => node is NodeOfType<"Identifier" | "Literal" | "ThisExpression" | "Super" | "ArrayExpression" | "ObjectExpression" | "FunctionExpression" | "ArrowFunctionExpression" | "ClassExpression" | "TaggedTemplateExpression" | "TemplateLiteral" | "MemberExpression" | "CallExpression" | "NewExpression" | "ChainExpression" | "SequenceExpression" | "ParenthesizedExpression" | "BinaryExpression" | "LogicalExpression" | "ConditionalExpression" | "UnaryExpression" | "UpdateExpression" | "AssignmentExpression" | "YieldExpression" | "AwaitExpression" | "ImportExpression" | "MetaProperty" | "TSAsExpression" | "TSSatisfiesExpression" | "TSTypeAssertion" | "TSNonNullExpression" | "TSInstantiationExpression" | "JSXElement" | "JSXFragment">;
+  Statement: (node: MaybeNode) => node is AliasMap["Statement"];
+  Declaration: (node: MaybeNode) => node is AliasMap["Declaration"];
+  ModuleDeclaration: (node: MaybeNode) => node is AliasMap["ModuleDeclaration"];
+  Function: (node: MaybeNode) => node is AliasMap["Function"];
+  Class: (node: MaybeNode) => node is AliasMap["Class"];
+  Method: (node: MaybeNode) => node is AliasMap["Method"];
+  Loop: (node: MaybeNode) => node is AliasMap["Loop"];
+  Pattern: (node: MaybeNode) => node is AliasMap["Pattern"];
+  JSX: (node: MaybeNode) => node is AliasMap["JSX"];
+  TSType: (node: MaybeNode) => node is AliasMap["TSType"];
+  IdentifierReference: (node: MaybeNode) => node is IdentifierReference;
+  BindingIdentifier: (node: MaybeNode) => node is BindingIdentifier;
+  LabelIdentifier: (node: MaybeNode) => node is LabelIdentifier;
+  IdentifierName: (node: MaybeNode) => node is IdentifierName;
+  StringLiteral: (node: MaybeNode) => node is StringLiteral;
+  NumericLiteral: (node: MaybeNode) => node is NumericLiteral;
+  BooleanLiteral: (node: MaybeNode) => node is BooleanLiteral;
+  NullLiteral: (node: MaybeNode) => node is NullLiteral;
+  BigIntLiteral: (node: MaybeNode) => node is BigIntLiteral;
+  RegExpLiteral: (node: MaybeNode) => node is RegExpLiteral;
+  ComputedMemberExpression: (node: MaybeNode) => node is ComputedMemberExpression;
+  StaticMemberExpression: (node: MaybeNode) => node is StaticMemberExpression;
+  PrivateFieldExpression: (node: MaybeNode) => node is PrivateFieldExpression;
+  Directive: (node: MaybeNode) => node is Directive;
+  Program: (node: MaybeNode) => node is import("yuku-parser").Program;
+  Hashbang: (node: MaybeNode) => node is import("yuku-parser").Hashbang;
+  ExpressionStatement: (node: MaybeNode) => node is NodeOfType<"ExpressionStatement">;
+  BlockStatement: (node: MaybeNode) => node is import("yuku-parser").BlockStatement;
+  EmptyStatement: (node: MaybeNode) => node is import("yuku-parser").EmptyStatement;
+  DebuggerStatement: (node: MaybeNode) => node is import("yuku-parser").DebuggerStatement;
+  ReturnStatement: (node: MaybeNode) => node is import("yuku-parser").ReturnStatement;
+  LabeledStatement: (node: MaybeNode) => node is import("yuku-parser").LabeledStatement;
+  BreakStatement: (node: MaybeNode) => node is import("yuku-parser").BreakStatement;
+  ContinueStatement: (node: MaybeNode) => node is import("yuku-parser").ContinueStatement;
+  IfStatement: (node: MaybeNode) => node is import("yuku-parser").IfStatement;
+  SwitchStatement: (node: MaybeNode) => node is import("yuku-parser").SwitchStatement;
+  ThrowStatement: (node: MaybeNode) => node is import("yuku-parser").ThrowStatement;
+  TryStatement: (node: MaybeNode) => node is import("yuku-parser").TryStatement;
+  WhileStatement: (node: MaybeNode) => node is import("yuku-parser").WhileStatement;
+  DoWhileStatement: (node: MaybeNode) => node is import("yuku-parser").DoWhileStatement;
+  ForStatement: (node: MaybeNode) => node is import("yuku-parser").ForStatement;
+  ForInStatement: (node: MaybeNode) => node is import("yuku-parser").ForInStatement;
+  ForOfStatement: (node: MaybeNode) => node is import("yuku-parser").ForOfStatement;
+  WithStatement: (node: MaybeNode) => node is import("yuku-parser").WithStatement;
+  FunctionDeclaration: (node: MaybeNode) => node is import("yuku-parser").FunctionDeclaration;
+  ClassDeclaration: (node: MaybeNode) => node is import("yuku-parser").ClassDeclaration;
+  VariableDeclaration: (node: MaybeNode) => node is import("yuku-parser").VariableDeclaration;
+  TSDeclareFunction: (node: MaybeNode) => node is import("yuku-parser").TSDeclareFunction;
+  TSTypeAliasDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSTypeAliasDeclaration;
+  TSInterfaceDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSInterfaceDeclaration;
+  TSEnumDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSEnumDeclaration;
+  TSModuleDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSModuleDeclaration;
+  TSImportEqualsDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSImportEqualsDeclaration;
+  Identifier: (node: MaybeNode) => node is import("yuku-parser").Identifier;
+  Literal: (node: MaybeNode) => node is NodeOfType<"Literal">;
+  ThisExpression: (node: MaybeNode) => node is import("yuku-parser").ThisExpression;
+  Super: (node: MaybeNode) => node is import("yuku-parser").Super;
+  ArrayExpression: (node: MaybeNode) => node is import("yuku-parser").ArrayExpression;
+  ObjectExpression: (node: MaybeNode) => node is import("yuku-parser").ObjectExpression;
+  FunctionExpression: (node: MaybeNode) => node is import("yuku-parser").FunctionExpression;
+  ArrowFunctionExpression: (node: MaybeNode) => node is import("yuku-parser").ArrowFunctionExpression;
+  ClassExpression: (node: MaybeNode) => node is import("yuku-parser").ClassExpression;
+  TaggedTemplateExpression: (node: MaybeNode) => node is import("yuku-parser").TaggedTemplateExpression;
+  TemplateLiteral: (node: MaybeNode) => node is import("yuku-parser").TemplateLiteral;
+  MemberExpression: (node: MaybeNode) => node is NodeOfType<"MemberExpression">;
+  CallExpression: (node: MaybeNode) => node is import("yuku-parser").CallExpression;
+  NewExpression: (node: MaybeNode) => node is import("yuku-parser").NewExpression;
+  ChainExpression: (node: MaybeNode) => node is import("yuku-parser").ChainExpression;
+  SequenceExpression: (node: MaybeNode) => node is import("yuku-parser").SequenceExpression;
+  ParenthesizedExpression: (node: MaybeNode) => node is import("yuku-parser").ParenthesizedExpression;
+  BinaryExpression: (node: MaybeNode) => node is import("yuku-parser").BinaryExpression;
+  LogicalExpression: (node: MaybeNode) => node is import("yuku-parser").LogicalExpression;
+  ConditionalExpression: (node: MaybeNode) => node is import("yuku-parser").ConditionalExpression;
+  UnaryExpression: (node: MaybeNode) => node is import("yuku-parser").UnaryExpression;
+  UpdateExpression: (node: MaybeNode) => node is import("yuku-parser").UpdateExpression;
+  AssignmentExpression: (node: MaybeNode) => node is import("yuku-parser").AssignmentExpression;
+  YieldExpression: (node: MaybeNode) => node is import("yuku-parser").YieldExpression;
+  AwaitExpression: (node: MaybeNode) => node is import("yuku-parser").AwaitExpression;
+  ImportExpression: (node: MaybeNode) => node is import("yuku-parser").ImportExpression;
+  MetaProperty: (node: MaybeNode) => node is import("yuku-parser").MetaProperty;
+  TSAsExpression: (node: MaybeNode) => node is import("yuku-parser").TSAsExpression;
+  TSSatisfiesExpression: (node: MaybeNode) => node is import("yuku-parser").TSSatisfiesExpression;
+  TSTypeAssertion: (node: MaybeNode) => node is import("yuku-parser").TSTypeAssertion;
+  TSNonNullExpression: (node: MaybeNode) => node is import("yuku-parser").TSNonNullExpression;
+  TSInstantiationExpression: (node: MaybeNode) => node is import("yuku-parser").TSInstantiationExpression;
+  JSXElement: (node: MaybeNode) => node is import("yuku-parser").JSXElement;
+  JSXFragment: (node: MaybeNode) => node is import("yuku-parser").JSXFragment;
+  ImportDeclaration: (node: MaybeNode) => node is import("yuku-parser").ImportDeclaration;
+  ExportNamedDeclaration: (node: MaybeNode) => node is import("yuku-parser").ExportNamedDeclaration;
+  ExportDefaultDeclaration: (node: MaybeNode) => node is import("yuku-parser").ExportDefaultDeclaration;
+  ExportAllDeclaration: (node: MaybeNode) => node is import("yuku-parser").ExportAllDeclaration;
+  TSExportAssignment: (node: MaybeNode) => node is import("yuku-parser").TSExportAssignment;
+  TSNamespaceExportDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSNamespaceExportDeclaration;
+  Property: (node: MaybeNode) => node is NodeOfType<"Property">;
+  SpreadElement: (node: MaybeNode) => node is import("yuku-parser").SpreadElement;
+  PrivateIdentifier: (node: MaybeNode) => node is import("yuku-parser").PrivateIdentifier;
+  TemplateElement: (node: MaybeNode) => node is import("yuku-parser").TemplateElement;
+  VariableDeclarator: (node: MaybeNode) => node is import("yuku-parser").VariableDeclarator;
+  CatchClause: (node: MaybeNode) => node is import("yuku-parser").CatchClause;
+  SwitchCase: (node: MaybeNode) => node is import("yuku-parser").SwitchCase;
+  RestElement: (node: MaybeNode) => node is import("yuku-parser").RestElement;
+  ArrayPattern: (node: MaybeNode) => node is import("yuku-parser").ArrayPattern;
+  ObjectPattern: (node: MaybeNode) => node is import("yuku-parser").ObjectPattern;
+  AssignmentPattern: (node: MaybeNode) => node is import("yuku-parser").AssignmentPattern;
+  ClassBody: (node: MaybeNode) => node is import("yuku-parser").ClassBody;
+  MethodDefinition: (node: MaybeNode) => node is import("yuku-parser").MethodDefinition;
+  TSAbstractMethodDefinition: (node: MaybeNode) => node is import("yuku-parser").TSAbstractMethodDefinition;
+  PropertyDefinition: (node: MaybeNode) => node is import("yuku-parser").PropertyDefinition;
+  TSAbstractPropertyDefinition: (node: MaybeNode) => node is import("yuku-parser").TSAbstractPropertyDefinition;
+  AccessorProperty: (node: MaybeNode) => node is import("yuku-parser").AccessorProperty;
+  TSAbstractAccessorProperty: (node: MaybeNode) => node is import("yuku-parser").TSAbstractAccessorProperty;
+  StaticBlock: (node: MaybeNode) => node is import("yuku-parser").StaticBlock;
+  Decorator: (node: MaybeNode) => node is import("yuku-parser").Decorator;
+  TSEmptyBodyFunctionExpression: (node: MaybeNode) => node is import("yuku-parser").TSEmptyBodyFunctionExpression;
+  ImportSpecifier: (node: MaybeNode) => node is import("yuku-parser").ImportSpecifier;
+  ImportDefaultSpecifier: (node: MaybeNode) => node is import("yuku-parser").ImportDefaultSpecifier;
+  ImportNamespaceSpecifier: (node: MaybeNode) => node is import("yuku-parser").ImportNamespaceSpecifier;
+  ImportAttribute: (node: MaybeNode) => node is import("yuku-parser").ImportAttribute;
+  ExportSpecifier: (node: MaybeNode) => node is import("yuku-parser").ExportSpecifier;
+  JSXOpeningElement: (node: MaybeNode) => node is import("yuku-parser").JSXOpeningElement;
+  JSXClosingElement: (node: MaybeNode) => node is import("yuku-parser").JSXClosingElement;
+  JSXOpeningFragment: (node: MaybeNode) => node is import("yuku-parser").JSXOpeningFragment;
+  JSXClosingFragment: (node: MaybeNode) => node is import("yuku-parser").JSXClosingFragment;
+  JSXIdentifier: (node: MaybeNode) => node is import("yuku-parser").JSXIdentifier;
+  JSXNamespacedName: (node: MaybeNode) => node is import("yuku-parser").JSXNamespacedName;
+  JSXMemberExpression: (node: MaybeNode) => node is import("yuku-parser").JSXMemberExpression;
+  JSXAttribute: (node: MaybeNode) => node is import("yuku-parser").JSXAttribute;
+  JSXSpreadAttribute: (node: MaybeNode) => node is import("yuku-parser").JSXSpreadAttribute;
+  JSXExpressionContainer: (node: MaybeNode) => node is import("yuku-parser").JSXExpressionContainer;
+  JSXEmptyExpression: (node: MaybeNode) => node is import("yuku-parser").JSXEmptyExpression;
+  JSXText: (node: MaybeNode) => node is import("yuku-parser").JSXText;
+  JSXSpreadChild: (node: MaybeNode) => node is import("yuku-parser").JSXSpreadChild;
+  TSTypeAnnotation: (node: MaybeNode) => node is import("yuku-parser").TSTypeAnnotation;
+  TSAnyKeyword: (node: MaybeNode) => node is import("yuku-parser").TSAnyKeyword;
+  TSUnknownKeyword: (node: MaybeNode) => node is import("yuku-parser").TSUnknownKeyword;
+  TSNeverKeyword: (node: MaybeNode) => node is import("yuku-parser").TSNeverKeyword;
+  TSVoidKeyword: (node: MaybeNode) => node is import("yuku-parser").TSVoidKeyword;
+  TSNullKeyword: (node: MaybeNode) => node is import("yuku-parser").TSNullKeyword;
+  TSUndefinedKeyword: (node: MaybeNode) => node is import("yuku-parser").TSUndefinedKeyword;
+  TSStringKeyword: (node: MaybeNode) => node is import("yuku-parser").TSStringKeyword;
+  TSNumberKeyword: (node: MaybeNode) => node is import("yuku-parser").TSNumberKeyword;
+  TSBigIntKeyword: (node: MaybeNode) => node is import("yuku-parser").TSBigIntKeyword;
+  TSBooleanKeyword: (node: MaybeNode) => node is import("yuku-parser").TSBooleanKeyword;
+  TSSymbolKeyword: (node: MaybeNode) => node is import("yuku-parser").TSSymbolKeyword;
+  TSObjectKeyword: (node: MaybeNode) => node is import("yuku-parser").TSObjectKeyword;
+  TSIntrinsicKeyword: (node: MaybeNode) => node is import("yuku-parser").TSIntrinsicKeyword;
+  TSThisType: (node: MaybeNode) => node is import("yuku-parser").TSThisType;
+  TSTypeReference: (node: MaybeNode) => node is import("yuku-parser").TSTypeReference;
+  TSTypeQuery: (node: MaybeNode) => node is import("yuku-parser").TSTypeQuery;
+  TSImportType: (node: MaybeNode) => node is import("yuku-parser").TSImportType;
+  TSLiteralType: (node: MaybeNode) => node is import("yuku-parser").TSLiteralType;
+  TSTemplateLiteralType: (node: MaybeNode) => node is import("yuku-parser").TSTemplateLiteralType;
+  TSArrayType: (node: MaybeNode) => node is import("yuku-parser").TSArrayType;
+  TSIndexedAccessType: (node: MaybeNode) => node is import("yuku-parser").TSIndexedAccessType;
+  TSTupleType: (node: MaybeNode) => node is import("yuku-parser").TSTupleType;
+  TSNamedTupleMember: (node: MaybeNode) => node is import("yuku-parser").TSNamedTupleMember;
+  TSJSDocNullableType: (node: MaybeNode) => node is import("yuku-parser").TSJSDocNullableType;
+  TSJSDocNonNullableType: (node: MaybeNode) => node is import("yuku-parser").TSJSDocNonNullableType;
+  TSJSDocUnknownType: (node: MaybeNode) => node is import("yuku-parser").TSJSDocUnknownType;
+  TSUnionType: (node: MaybeNode) => node is import("yuku-parser").TSUnionType;
+  TSIntersectionType: (node: MaybeNode) => node is import("yuku-parser").TSIntersectionType;
+  TSConditionalType: (node: MaybeNode) => node is import("yuku-parser").TSConditionalType;
+  TSInferType: (node: MaybeNode) => node is import("yuku-parser").TSInferType;
+  TSTypeOperator: (node: MaybeNode) => node is import("yuku-parser").TSTypeOperator;
+  TSParenthesizedType: (node: MaybeNode) => node is import("yuku-parser").TSParenthesizedType;
+  TSFunctionType: (node: MaybeNode) => node is import("yuku-parser").TSFunctionType;
+  TSConstructorType: (node: MaybeNode) => node is import("yuku-parser").TSConstructorType;
+  TSTypePredicate: (node: MaybeNode) => node is import("yuku-parser").TSTypePredicate;
+  TSTypeLiteral: (node: MaybeNode) => node is import("yuku-parser").TSTypeLiteral;
+  TSMappedType: (node: MaybeNode) => node is import("yuku-parser").TSMappedType;
+  TSTypeParameter: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameter;
+  TSTypeParameterDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameterDeclaration;
+  TSTypeParameterInstantiation: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameterInstantiation;
+  TSQualifiedName: (node: MaybeNode) => node is import("yuku-parser").TSQualifiedName;
+  TSPropertySignature: (node: MaybeNode) => node is import("yuku-parser").TSPropertySignature;
+  TSMethodSignature: (node: MaybeNode) => node is import("yuku-parser").TSMethodSignature;
+  TSCallSignatureDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSCallSignatureDeclaration;
+  TSConstructSignatureDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSConstructSignatureDeclaration;
+  TSIndexSignature: (node: MaybeNode) => node is import("yuku-parser").TSIndexSignature;
+  TSInterfaceBody: (node: MaybeNode) => node is import("yuku-parser").TSInterfaceBody;
+  TSInterfaceHeritage: (node: MaybeNode) => node is import("yuku-parser").TSInterfaceHeritage;
+  TSClassImplements: (node: MaybeNode) => node is import("yuku-parser").TSClassImplements;
+  TSEnumBody: (node: MaybeNode) => node is import("yuku-parser").TSEnumBody;
+  TSEnumMember: (node: MaybeNode) => node is import("yuku-parser").TSEnumMember;
+  TSModuleBlock: (node: MaybeNode) => node is import("yuku-parser").TSModuleBlock;
+  TSParameterProperty: (node: MaybeNode) => node is import("yuku-parser").TSParameterProperty;
+  TSExternalModuleReference: (node: MaybeNode) => node is import("yuku-parser").TSExternalModuleReference;
+  TSOptionalType: (node: MaybeNode) => node is import("yuku-parser").TSOptionalType;
+  TSRestType: (node: MaybeNode) => node is import("yuku-parser").TSRestType;
+};
+//#endregion
+//#region src/builders.d.ts
+declare const b: {
+  identifier(name: string, kind?: t.IdentifierKind, opts?: {
+    typeAnnotation?: t.TSTypeAnnotation | null;
+    optional?: boolean;
+    decorators?: t.Decorator[];
+  }): t.Identifier;
+  privateIdentifier(name: string): t.PrivateIdentifier;
+  stringLiteral(value: string): t.StringLiteral;
+  numericLiteral(value: number): t.NumericLiteral;
+  booleanLiteral(value: boolean): t.BooleanLiteral;
+  nullLiteral(): t.NullLiteral;
+  bigIntLiteral(value: bigint): t.BigIntLiteral;
+  regExpLiteral(pattern: string, flags?: string): t.RegExpLiteral;
+  templateLiteral(quasis: t.TemplateElement[], expressions: t.Expression[]): t.TemplateLiteral;
+  templateElement(cooked: string, tail?: boolean): t.TemplateElement;
+  thisExpression(): t.ThisExpression;
+  super(): t.Super;
+  arrayPattern(elements: Array<t.BindingPattern | t.RestElement | null>): t.ArrayPattern;
+  objectPattern(properties: Array<t.BindingProperty | t.RestElement>): t.ObjectPattern;
+  assignmentPattern(left: t.BindingPattern, right: t.Expression): t.AssignmentPattern;
+  restElement(argument: t.BindingPattern): t.RestElement; /** A member of an `ObjectExpression`. For an `ObjectPattern` member, use {@link bindingProperty}. */
+  objectProperty(key: t.PropertyKey, value: t.Expression, opts?: {
+    computed?: boolean;
+    shorthand?: boolean;
+    kind?: t.PropertyKind;
+    method?: boolean;
+  }): t.ObjectProperty; /** A member of an `ObjectPattern`, whose value is a binding target. For an `ObjectExpression` member, use {@link objectProperty}. */
+  bindingProperty(key: t.PropertyKey, value: t.BindingPattern, opts?: {
+    computed?: boolean;
+    shorthand?: boolean;
+  }): t.BindingProperty;
+  arrayExpression(elements?: t.ArrayExpressionElement[]): t.ArrayExpression;
+  objectExpression(properties?: t.ObjectPropertyKind[]): t.ObjectExpression;
+  spreadElement(argument: t.Expression): t.SpreadElement;
+  sequenceExpression(expressions: t.Expression[]): t.SequenceExpression;
+  parenthesizedExpression(expression: t.Expression): t.ParenthesizedExpression;
+  unaryExpression(operator: t.UnaryOperator, argument: t.Expression): t.UnaryExpression;
+  updateExpression(operator: t.UpdateOperator, argument: t.Expression, prefix?: boolean): t.UpdateExpression;
+  binaryExpression(operator: t.BinaryOperator, left: t.Expression | t.PrivateIdentifier, right: t.Expression): t.BinaryExpression;
+  logicalExpression(operator: t.LogicalOperator, left: t.Expression, right: t.Expression): t.LogicalExpression;
+  assignmentExpression(operator: t.AssignmentOperator, left: t.AssignmentTarget, right: t.Expression): t.AssignmentExpression;
+  conditionalExpression(test: t.Expression, consequent: t.Expression, alternate: t.Expression): t.ConditionalExpression;
+  yieldExpression(argument?: t.Expression | null, delegate?: boolean): t.YieldExpression;
+  awaitExpression(argument: t.Expression): t.AwaitExpression;
+  memberExpression(object: t.Expression | t.Super, property: t.Expression | t.IdentifierName | t.PrivateIdentifier, opts?: {
+    computed?: boolean;
+    optional?: boolean;
+  }): t.MemberExpression;
+  callExpression(callee: t.Expression | t.Super, args?: t.Argument[], opts?: {
+    optional?: boolean;
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.CallExpression;
+  newExpression(callee: t.Expression, args?: t.Argument[], opts?: {
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.NewExpression;
+  chainExpression(expression: t.ChainElement): t.ChainExpression;
+  taggedTemplateExpression(tag: t.Expression, quasi: t.TemplateLiteral, opts?: {
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.TaggedTemplateExpression;
+  metaProperty(meta: string, property: string): t.MetaProperty;
+  importExpression(source: t.Expression, opts?: {
+    options?: t.Expression | null;
+    phase?: t.ImportPhase | null;
+  }): t.ImportExpression;
+  arrowFunctionExpression(params: t.FunctionParameter[], body: t.BlockStatement | t.Expression, opts?: {
+    async?: boolean;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    returnType?: t.TSTypeAnnotation | null;
+  }): t.ArrowFunctionExpression;
+  functionExpression(params: t.FunctionParameter[], body: t.BlockStatement, opts?: {
+    id?: t.Identifier | null;
+    async?: boolean;
+    generator?: boolean;
+  }): t.FunctionExpression;
+  functionDeclaration(id: t.Identifier | null, params: t.FunctionParameter[], body: t.BlockStatement | null, opts?: {
+    async?: boolean;
+    generator?: boolean;
+  }): t.FunctionDeclaration;
+  classDeclaration(id: t.Identifier | null, body: t.ClassBody, opts?: {
+    superClass?: t.Expression | null;
+    decorators?: t.Decorator[];
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    abstract?: boolean;
+  }): t.ClassDeclaration;
+  classExpression(id: t.Identifier | null, body: t.ClassBody, opts?: {
+    superClass?: t.Expression | null;
+    decorators?: t.Decorator[];
+  }): t.ClassExpression;
+  classBody(body?: t.ClassElement[]): t.ClassBody;
+  methodDefinition(key: t.PropertyKey, value: t.FunctionExpression | t.TSEmptyBodyFunctionExpression, opts?: {
+    kind?: t.MethodDefinitionKind;
+    computed?: boolean;
+    static?: boolean;
+  }): t.MethodDefinition;
+  propertyDefinition(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+    decorators?: t.Decorator[];
+  }): t.PropertyDefinition;
+  accessorProperty(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+  }): t.AccessorProperty;
+  tsAbstractMethodDefinition(key: t.PropertyKey, value: t.FunctionExpression | t.TSEmptyBodyFunctionExpression, opts?: {
+    kind?: t.MethodDefinitionKind;
+    computed?: boolean;
+    static?: boolean;
+  }): t.TSAbstractMethodDefinition;
+  tsAbstractPropertyDefinition(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+  }): t.TSAbstractPropertyDefinition;
+  tsAbstractAccessorProperty(key: t.PropertyKey, value?: t.Expression | null, opts?: {
+    computed?: boolean;
+    static?: boolean;
+  }): t.TSAbstractAccessorProperty;
+  staticBlock(body?: t.Statement[]): t.StaticBlock;
+  decorator(expression: t.Expression): t.Decorator;
+  expressionStatement(expression: t.Expression): t.ExpressionStatement;
+  directive(value: string): t.Directive;
+  blockStatement(body?: t.Statement[]): t.BlockStatement;
+  emptyStatement(): t.EmptyStatement;
+  debuggerStatement(): t.DebuggerStatement;
+  returnStatement(argument?: t.Expression | null): t.ReturnStatement;
+  ifStatement(test: t.Expression, consequent: t.Statement, alternate?: t.Statement | null): t.IfStatement;
+  switchStatement(discriminant: t.Expression, cases: t.SwitchCase[]): t.SwitchStatement;
+  switchCase(test: t.Expression | null, consequent: t.Statement[]): t.SwitchCase;
+  throwStatement(argument: t.Expression): t.ThrowStatement;
+  tryStatement(block: t.BlockStatement, handler?: t.CatchClause | null, finalizer?: t.BlockStatement | null): t.TryStatement;
+  catchClause(param: t.BindingPattern | null, body: t.BlockStatement): t.CatchClause;
+  whileStatement(test: t.Expression, body: t.Statement): t.WhileStatement;
+  doWhileStatement(body: t.Statement, test: t.Expression): t.DoWhileStatement;
+  forStatement(init: t.ForStatementInit | null, test: t.Expression | null, update: t.Expression | null, body: t.Statement): t.ForStatement;
+  forInStatement(left: t.ForStatementLeft, right: t.Expression, body: t.Statement): t.ForInStatement;
+  forOfStatement(left: t.ForStatementLeft, right: t.Expression, body: t.Statement, isAwait?: boolean): t.ForOfStatement;
+  labeledStatement(label: t.LabelIdentifier, body: t.Statement): t.LabeledStatement;
+  breakStatement(label?: t.LabelIdentifier | null): t.BreakStatement;
+  continueStatement(label?: t.LabelIdentifier | null): t.ContinueStatement;
+  withStatement(object: t.Expression, body: t.Statement): t.WithStatement;
+  variableDeclaration(kind: t.VariableDeclarationKind, declarations: t.VariableDeclarator[]): t.VariableDeclaration;
+  variableDeclarator(id: t.BindingPattern, init?: t.Expression | null): t.VariableDeclarator;
+  importDeclaration(specifiers: t.ImportDeclarationSpecifier[], source: t.StringLiteral, opts?: {
+    attributes?: t.ImportAttribute[];
+    phase?: t.ImportPhase | null;
+    importKind?: t.ImportOrExportKind;
+  }): t.ImportDeclaration;
+  importSpecifier(imported: t.IdentifierName | t.StringLiteral, local: t.BindingIdentifier): t.ImportSpecifier;
+  importDefaultSpecifier(local: t.BindingIdentifier): t.ImportDefaultSpecifier;
+  importNamespaceSpecifier(local: t.BindingIdentifier): t.ImportNamespaceSpecifier;
+  importAttribute(key: t.ImportAttributeKey, value: t.StringLiteral): t.ImportAttribute;
+  exportNamedDeclaration(declaration: t.Declaration | null, specifiers?: t.ExportSpecifier[], opts?: {
+    source?: t.StringLiteral | null;
+    attributes?: t.ImportAttribute[];
+    exportKind?: t.ImportOrExportKind;
+  }): t.ExportNamedDeclaration;
+  exportDefaultDeclaration(declaration: t.ExportDefaultDeclarationKind): t.ExportDefaultDeclaration;
+  exportAllDeclaration(source: t.StringLiteral, opts?: {
+    exported?: t.ModuleExportName | null;
+    attributes?: t.ImportAttribute[];
+    exportKind?: t.ImportOrExportKind;
+  }): t.ExportAllDeclaration;
+  exportSpecifier(local: t.ModuleExportName, exported: t.ModuleExportName): t.ExportSpecifier;
+  jsxIdentifier(name: string): t.JSXIdentifier;
+  jsxNamespacedName(namespace: t.JSXIdentifier, name: t.JSXIdentifier): t.JSXNamespacedName;
+  jsxMemberExpression(object: t.JSXMemberExpressionObject, property: t.JSXIdentifier): t.JSXMemberExpression;
+  jsxElement(openingElement: t.JSXOpeningElement, children?: t.JSXChild[], closingElement?: t.JSXClosingElement | null): t.JSXElement;
+  jsxOpeningElement(name: t.JSXElementName, attributes?: t.JSXAttributeItem[], selfClosing?: boolean): t.JSXOpeningElement;
+  jsxClosingElement(name: t.JSXElementName): t.JSXClosingElement;
+  jsxOpeningFragment(): t.JSXOpeningFragment;
+  jsxClosingFragment(): t.JSXClosingFragment;
+  jsxFragment(children?: t.JSXChild[]): t.JSXFragment;
+  jsxAttribute(name: t.JSXAttributeName, value?: t.JSXAttributeValue | null): t.JSXAttribute;
+  jsxSpreadAttribute(argument: t.Expression): t.JSXSpreadAttribute;
+  jsxExpressionContainer(expression: t.JSXExpression): t.JSXExpressionContainer;
+  jsxEmptyExpression(): t.JSXEmptyExpression;
+  jsxText(value: string): t.JSXText;
+  jsxSpreadChild(expression: t.Expression): t.JSXSpreadChild;
+  tsTypeAnnotation(typeAnnotation: t.TSType): t.TSTypeAnnotation;
+  tsAnyKeyword: () => t.TSAnyKeyword;
+  tsUnknownKeyword: () => t.TSUnknownKeyword;
+  tsNeverKeyword: () => t.TSNeverKeyword;
+  tsVoidKeyword: () => t.TSVoidKeyword;
+  tsNullKeyword: () => t.TSNullKeyword;
+  tsUndefinedKeyword: () => t.TSUndefinedKeyword;
+  tsStringKeyword: () => t.TSStringKeyword;
+  tsNumberKeyword: () => t.TSNumberKeyword;
+  tsBigIntKeyword: () => t.TSBigIntKeyword;
+  tsBooleanKeyword: () => t.TSBooleanKeyword;
+  tsSymbolKeyword: () => t.TSSymbolKeyword;
+  tsObjectKeyword: () => t.TSObjectKeyword;
+  tsIntrinsicKeyword: () => t.TSIntrinsicKeyword;
+  tsThisType: () => t.TSThisType;
+  tsTypeReference(typeName: t.TSTypeName, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSTypeReference;
+  tsQualifiedName(left: t.TSTypeName, right: t.IdentifierName): t.TSQualifiedName;
+  tsTypeQuery(exprName: t.TSTypeQueryExprName, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSTypeQuery;
+  tsImportType(source: t.StringLiteral, opts?: {
+    options?: t.ObjectExpression | null;
+    qualifier?: t.TSImportTypeQualifier | null;
+    typeArguments?: t.TSTypeParameterInstantiation | null;
+  }): t.TSImportType;
+  tsTypeParameter(name: t.BindingIdentifier, opts?: {
+    constraint?: t.TSType | null;
+    default?: t.TSType | null;
+    in?: boolean;
+    out?: boolean;
+    const?: boolean;
+  }): t.TSTypeParameter;
+  tsTypeParameterDeclaration(params: t.TSTypeParameter[]): t.TSTypeParameterDeclaration;
+  tsTypeParameterInstantiation(params: t.TSType[]): t.TSTypeParameterInstantiation;
+  tsLiteralType(literal: t.TSLiteralType["literal"]): t.TSLiteralType;
+  tsTemplateLiteralType(quasis: t.TemplateElement[], types: t.TSType[]): t.TSTemplateLiteralType;
+  tsArrayType(elementType: t.TSType): t.TSArrayType;
+  tsIndexedAccessType(objectType: t.TSType, indexType: t.TSType): t.TSIndexedAccessType;
+  tsTupleType(elementTypes: t.TSTupleElement[]): t.TSTupleType;
+  tsNamedTupleMember(label: t.IdentifierName, elementType: t.TSType, optional?: boolean): t.TSNamedTupleMember;
+  tsOptionalType(typeAnnotation: t.TSType): t.TSOptionalType;
+  tsRestType(typeAnnotation: t.TSType | t.TSNamedTupleMember): t.TSRestType;
+  tsJSDocNullableType(typeAnnotation: t.TSType, postfix?: boolean): t.TSJSDocNullableType;
+  tsJSDocNonNullableType(typeAnnotation: t.TSType, postfix?: boolean): t.TSJSDocNonNullableType;
+  tsJSDocUnknownType(): t.TSJSDocUnknownType;
+  tsUnionType(types: t.TSType[]): t.TSUnionType;
+  tsIntersectionType(types: t.TSType[]): t.TSIntersectionType;
+  tsConditionalType(checkType: t.TSType, extendsType: t.TSType, trueType: t.TSType, falseType: t.TSType): t.TSConditionalType;
+  tsInferType(typeParameter: t.TSTypeParameter): t.TSInferType;
+  tsTypeOperator(operator: t.TSTypeOperator["operator"], typeAnnotation: t.TSType): t.TSTypeOperator;
+  tsParenthesizedType(typeAnnotation: t.TSType): t.TSParenthesizedType;
+  tsFunctionType(params: t.FunctionParameter[], returnType: t.TSTypeAnnotation | null, typeParameters?: t.TSTypeParameterDeclaration | null): t.TSFunctionType;
+  tsConstructorType(params: t.FunctionParameter[], returnType: t.TSTypeAnnotation | null, opts?: {
+    abstract?: boolean;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+  }): t.TSConstructorType;
+  tsTypePredicate(parameterName: t.TSTypePredicateName, typeAnnotation?: t.TSTypeAnnotation | null, asserts?: boolean): t.TSTypePredicate;
+  tsTypeLiteral(members: t.TSSignature[]): t.TSTypeLiteral;
+  tsMappedType(key: t.BindingIdentifier, constraint: t.TSType, opts?: {
+    nameType?: t.TSType | null;
+    typeAnnotation?: t.TSType | null;
+    optional?: t.TSMappedTypeModifierOperator | false;
+    readonly?: t.TSMappedTypeModifierOperator | null;
+  }): t.TSMappedType;
+  tsPropertySignature(key: t.PropertyKey, opts?: {
+    typeAnnotation?: t.TSTypeAnnotation | null;
+    computed?: boolean;
+    optional?: boolean;
+    readonly?: boolean;
+  }): t.TSPropertySignature;
+  tsMethodSignature(key: t.PropertyKey, params: t.FunctionParameter[], opts?: {
+    kind?: t.TSMethodSignatureKind;
+    computed?: boolean;
+    optional?: boolean;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    returnType?: t.TSTypeAnnotation | null;
+  }): t.TSMethodSignature;
+  tsCallSignatureDeclaration(params: t.FunctionParameter[], returnType?: t.TSTypeAnnotation | null, typeParameters?: t.TSTypeParameterDeclaration | null): t.TSCallSignatureDeclaration;
+  tsConstructSignatureDeclaration(params: t.FunctionParameter[], returnType?: t.TSTypeAnnotation | null, typeParameters?: t.TSTypeParameterDeclaration | null): t.TSConstructSignatureDeclaration;
+  tsIndexSignature(parameters: t.BindingIdentifier[], typeAnnotation: t.TSTypeAnnotation, opts?: {
+    readonly?: boolean;
+    static?: boolean;
+  }): t.TSIndexSignature;
+  tsTypeAliasDeclaration(id: t.BindingIdentifier, typeAnnotation: t.TSType, opts?: {
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    declare?: boolean;
+  }): t.TSTypeAliasDeclaration;
+  tsInterfaceDeclaration(id: t.BindingIdentifier, body: t.TSInterfaceBody, opts?: {
+    extends?: t.TSInterfaceHeritage[];
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    declare?: boolean;
+  }): t.TSInterfaceDeclaration;
+  tsInterfaceBody(body: t.TSSignature[]): t.TSInterfaceBody;
+  tsInterfaceHeritage(expression: t.Expression, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSInterfaceHeritage;
+  tsClassImplements(expression: t.Expression, typeArguments?: t.TSTypeParameterInstantiation | null): t.TSClassImplements;
+  tsEnumDeclaration(id: t.BindingIdentifier, body: t.TSEnumBody, opts?: {
+    const?: boolean;
+    declare?: boolean;
+  }): t.TSEnumDeclaration;
+  tsEnumBody(members: t.TSEnumMember[]): t.TSEnumBody;
+  tsEnumMember(id: t.TSEnumMemberName, initializer?: t.Expression | null): t.TSEnumMember;
+  tsModuleDeclaration(id: t.TSModuleDeclaration["id"], body: t.TSModuleBlock | undefined, opts?: {
+    kind?: t.TSModuleDeclarationKind;
+    declare?: boolean;
+    global?: boolean;
+  }): t.TSModuleDeclaration;
+  tsModuleBlock(body?: t.Statement[]): t.TSModuleBlock;
+  tsParameterProperty(parameter: t.BindingIdentifier | t.AssignmentPattern, opts?: {
+    accessibility?: t.TSAccessibility | null;
+    readonly?: boolean;
+    override?: boolean;
+    decorators?: t.Decorator[];
+  }): t.TSParameterProperty;
+  tsAsExpression(expression: t.Expression, typeAnnotation: t.TSType): t.TSAsExpression;
+  tsSatisfiesExpression(expression: t.Expression, typeAnnotation: t.TSType): t.TSSatisfiesExpression;
+  tsTypeAssertion(typeAnnotation: t.TSType, expression: t.Expression): t.TSTypeAssertion;
+  tsNonNullExpression(expression: t.Expression): t.TSNonNullExpression;
+  tsInstantiationExpression(expression: t.Expression, typeArguments: t.TSTypeParameterInstantiation): t.TSInstantiationExpression;
+  tsExportAssignment(expression: t.Expression): t.TSExportAssignment;
+  tsNamespaceExportDeclaration(id: t.IdentifierName): t.TSNamespaceExportDeclaration;
+  tsImportEqualsDeclaration(id: t.BindingIdentifier, moduleReference: t.TSModuleReference, importKind?: t.ImportOrExportKind): t.TSImportEqualsDeclaration;
+  tsExternalModuleReference(expression: t.StringLiteral): t.TSExternalModuleReference;
+  tsDeclareFunction(id: t.BindingIdentifier | null, params: t.FunctionParameter[], opts?: {
+    async?: boolean;
+    generator?: boolean;
+    returnType?: t.TSTypeAnnotation | null;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+    declare?: boolean;
+  }): t.TSDeclareFunction;
+  tsEmptyBodyFunctionExpression(params: t.FunctionParameter[], opts?: {
+    id?: t.BindingIdentifier | null;
+    returnType?: t.TSTypeAnnotation | null;
+    typeParameters?: t.TSTypeParameterDeclaration | null;
+  }): t.TSEmptyBodyFunctionExpression;
+  hashbang(value: string): t.Hashbang;
+  program(body?: Array<t.Statement | t.ModuleDeclaration | t.Directive>, opts?: {
+    sourceType?: t.ModuleKind;
+    hashbang?: t.Hashbang | null;
+  }): t.Program;
+};
+//#endregion
+export { type AliasMap, type AliasName, type AsyncVisitFn, type AsyncVisitor, type AsyncVisitors, type ChildKeys, type NodeOfType, type NodeType, type Path, type VisitFn, type Visitor, type Visitors, b, is, walk, walkAsync };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,2 @@
+const e={Expression:`Identifier.Literal.ThisExpression.Super.ArrayExpression.ObjectExpression.FunctionExpression.ArrowFunctionExpression.ClassExpression.TaggedTemplateExpression.TemplateLiteral.MemberExpression.CallExpression.NewExpression.ChainExpression.SequenceExpression.ParenthesizedExpression.BinaryExpression.LogicalExpression.ConditionalExpression.UnaryExpression.UpdateExpression.AssignmentExpression.YieldExpression.AwaitExpression.ImportExpression.MetaProperty.TSAsExpression.TSSatisfiesExpression.TSTypeAssertion.TSNonNullExpression.TSInstantiationExpression.JSXElement.JSXFragment`.split(`.`),Statement:`ExpressionStatement.BlockStatement.EmptyStatement.DebuggerStatement.ReturnStatement.LabeledStatement.BreakStatement.ContinueStatement.IfStatement.SwitchStatement.ThrowStatement.TryStatement.WhileStatement.DoWhileStatement.ForStatement.ForInStatement.ForOfStatement.WithStatement.FunctionDeclaration.ClassDeclaration.VariableDeclaration.TSDeclareFunction.TSTypeAliasDeclaration.TSInterfaceDeclaration.TSEnumDeclaration.TSModuleDeclaration.TSImportEqualsDeclaration`.split(`.`),Declaration:[`FunctionDeclaration`,`ClassDeclaration`,`VariableDeclaration`,`TSDeclareFunction`,`TSTypeAliasDeclaration`,`TSInterfaceDeclaration`,`TSEnumDeclaration`,`TSModuleDeclaration`,`TSImportEqualsDeclaration`],ModuleDeclaration:[`ImportDeclaration`,`ExportNamedDeclaration`,`ExportDefaultDeclaration`,`ExportAllDeclaration`,`TSExportAssignment`,`TSNamespaceExportDeclaration`],Function:[`FunctionDeclaration`,`FunctionExpression`,`ArrowFunctionExpression`,`TSDeclareFunction`,`TSEmptyBodyFunctionExpression`],Class:[`ClassDeclaration`,`ClassExpression`],Method:[`MethodDefinition`,`TSAbstractMethodDefinition`],Loop:[`ForStatement`,`ForInStatement`,`ForOfStatement`,`WhileStatement`,`DoWhileStatement`],Pattern:[`Identifier`,`ArrayPattern`,`ObjectPattern`,`AssignmentPattern`,`RestElement`],JSX:[`JSXElement`,`JSXOpeningElement`,`JSXClosingElement`,`JSXFragment`,`JSXOpeningFragment`,`JSXClosingFragment`,`JSXIdentifier`,`JSXNamespacedName`,`JSXMemberExpression`,`JSXAttribute`,`JSXSpreadAttribute`,`JSXExpressionContainer`,`JSXEmptyExpression`,`JSXText`,`JSXSpreadChild`],TSType:`TSAnyKeyword.TSUnknownKeyword.TSNeverKeyword.TSVoidKeyword.TSNullKeyword.TSUndefinedKeyword.TSStringKeyword.TSNumberKeyword.TSBigIntKeyword.TSBooleanKeyword.TSSymbolKeyword.TSObjectKeyword.TSIntrinsicKeyword.TSThisType.TSTypeReference.TSTypeQuery.TSImportType.TSLiteralType.TSTemplateLiteralType.TSArrayType.TSIndexedAccessType.TSTupleType.TSNamedTupleMember.TSJSDocNullableType.TSJSDocNonNullableType.TSJSDocUnknownType.TSUnionType.TSIntersectionType.TSConditionalType.TSInferType.TSTypeOperator.TSParenthesizedType.TSFunctionType.TSConstructorType.TSTypePredicate.TSTypeLiteral.TSMappedType`.split(`.`)},t={Program:[`hashbang`,`body`],Hashbang:[],Identifier:[`decorators`,`typeAnnotation`],PrivateIdentifier:[],Literal:[],TemplateElement:[],Super:[],ThisExpression:[],ArrayPattern:[`decorators`,`elements`,`typeAnnotation`],ObjectPattern:[`decorators`,`properties`,`typeAnnotation`],AssignmentPattern:[`decorators`,`left`,`right`,`typeAnnotation`],RestElement:[`decorators`,`argument`,`typeAnnotation`],Property:[`key`,`value`],SequenceExpression:[`expressions`],ParenthesizedExpression:[`expression`],BinaryExpression:[`left`,`right`],LogicalExpression:[`left`,`right`],ConditionalExpression:[`test`,`consequent`,`alternate`],UnaryExpression:[`argument`],UpdateExpression:[`argument`],AssignmentExpression:[`left`,`right`],YieldExpression:[`argument`],AwaitExpression:[`argument`],ArrayExpression:[`elements`],ObjectExpression:[`properties`],SpreadElement:[`argument`],MemberExpression:[`object`,`property`],CallExpression:[`callee`,`typeArguments`,`arguments`],ChainExpression:[`expression`],TaggedTemplateExpression:[`tag`,`typeArguments`,`quasi`],NewExpression:[`callee`,`typeArguments`,`arguments`],MetaProperty:[`meta`,`property`],ImportExpression:[`source`,`options`],TemplateLiteral:[`quasis`,`expressions`],ExpressionStatement:[`expression`],BlockStatement:[`body`],IfStatement:[`test`,`consequent`,`alternate`],SwitchStatement:[`discriminant`,`cases`],SwitchCase:[`test`,`consequent`],ForStatement:[`init`,`test`,`update`,`body`],ForInStatement:[`left`,`right`,`body`],ForOfStatement:[`left`,`right`,`body`],WhileStatement:[`test`,`body`],DoWhileStatement:[`body`,`test`],BreakStatement:[`label`],ContinueStatement:[`label`],LabeledStatement:[`label`,`body`],WithStatement:[`object`,`body`],ReturnStatement:[`argument`],ThrowStatement:[`argument`],TryStatement:[`block`,`handler`,`finalizer`],CatchClause:[`param`,`body`],DebuggerStatement:[],EmptyStatement:[],VariableDeclaration:[`declarations`],VariableDeclarator:[`id`,`init`],FunctionDeclaration:[`id`,`typeParameters`,`params`,`returnType`,`body`],FunctionExpression:[`id`,`typeParameters`,`params`,`returnType`,`body`],TSDeclareFunction:[`id`,`typeParameters`,`params`,`returnType`],TSEmptyBodyFunctionExpression:[`id`,`typeParameters`,`params`,`returnType`],ArrowFunctionExpression:[`typeParameters`,`params`,`returnType`,`body`],ClassDeclaration:[`decorators`,`id`,`typeParameters`,`superClass`,`superTypeArguments`,`implements`,`body`],ClassExpression:[`decorators`,`id`,`typeParameters`,`superClass`,`superTypeArguments`,`implements`,`body`],ClassBody:[`body`],MethodDefinition:[`decorators`,`key`,`value`],TSAbstractMethodDefinition:[`decorators`,`key`,`value`],PropertyDefinition:[`decorators`,`key`,`typeAnnotation`,`value`],TSAbstractPropertyDefinition:[`decorators`,`key`,`typeAnnotation`,`value`],AccessorProperty:[`decorators`,`key`,`typeAnnotation`,`value`],TSAbstractAccessorProperty:[`decorators`,`key`,`typeAnnotation`,`value`],StaticBlock:[`body`],Decorator:[`expression`],ImportDeclaration:[`specifiers`,`source`,`attributes`],ImportSpecifier:[`imported`,`local`],ImportDefaultSpecifier:[`local`],ImportNamespaceSpecifier:[`local`],ImportAttribute:[`key`,`value`],ExportNamedDeclaration:[`declaration`,`specifiers`,`source`,`attributes`],ExportDefaultDeclaration:[`declaration`],ExportAllDeclaration:[`exported`,`source`,`attributes`],ExportSpecifier:[`local`,`exported`],JSXElement:[`openingElement`,`children`,`closingElement`],JSXOpeningElement:[`name`,`typeArguments`,`attributes`],JSXClosingElement:[`name`],JSXFragment:[`openingFragment`,`children`,`closingFragment`],JSXOpeningFragment:[],JSXClosingFragment:[],JSXIdentifier:[],JSXNamespacedName:[`namespace`,`name`],JSXMemberExpression:[`object`,`property`],JSXAttribute:[`name`,`value`],JSXSpreadAttribute:[`argument`],JSXExpressionContainer:[`expression`],JSXEmptyExpression:[],JSXText:[],JSXSpreadChild:[`expression`],TSTypeAnnotation:[`typeAnnotation`],TSAnyKeyword:[],TSUnknownKeyword:[],TSNeverKeyword:[],TSVoidKeyword:[],TSNullKeyword:[],TSUndefinedKeyword:[],TSStringKeyword:[],TSNumberKeyword:[],TSBigIntKeyword:[],TSBooleanKeyword:[],TSSymbolKeyword:[],TSObjectKeyword:[],TSIntrinsicKeyword:[],TSThisType:[],TSTypeReference:[`typeName`,`typeArguments`],TSQualifiedName:[`left`,`right`],TSTypeQuery:[`exprName`,`typeArguments`],TSImportType:[`source`,`options`,`qualifier`,`typeArguments`],TSTypeParameter:[`name`,`constraint`,`default`],TSTypeParameterDeclaration:[`params`],TSTypeParameterInstantiation:[`params`],TSLiteralType:[`literal`],TSTemplateLiteralType:[`quasis`,`types`],TSArrayType:[`elementType`],TSIndexedAccessType:[`objectType`,`indexType`],TSTupleType:[`elementTypes`],TSNamedTupleMember:[`label`,`elementType`],TSOptionalType:[`typeAnnotation`],TSRestType:[`typeAnnotation`],TSJSDocNullableType:[`typeAnnotation`],TSJSDocNonNullableType:[`typeAnnotation`],TSJSDocUnknownType:[],TSUnionType:[`types`],TSIntersectionType:[`types`],TSConditionalType:[`checkType`,`extendsType`,`trueType`,`falseType`],TSInferType:[`typeParameter`],TSTypeOperator:[`typeAnnotation`],TSParenthesizedType:[`typeAnnotation`],TSFunctionType:[`typeParameters`,`params`,`returnType`],TSConstructorType:[`typeParameters`,`params`,`returnType`],TSTypePredicate:[`parameterName`,`typeAnnotation`],TSTypeLiteral:[`members`],TSMappedType:[`key`,`constraint`,`nameType`,`typeAnnotation`],TSPropertySignature:[`key`,`typeAnnotation`],TSMethodSignature:[`key`,`typeParameters`,`params`,`returnType`],TSCallSignatureDeclaration:[`typeParameters`,`params`,`returnType`],TSConstructSignatureDeclaration:[`typeParameters`,`params`,`returnType`],TSIndexSignature:[`parameters`,`typeAnnotation`],TSTypeAliasDeclaration:[`id`,`typeParameters`,`typeAnnotation`],TSInterfaceDeclaration:[`id`,`typeParameters`,`extends`,`body`],TSInterfaceBody:[`body`],TSInterfaceHeritage:[`expression`,`typeArguments`],TSClassImplements:[`expression`,`typeArguments`],TSEnumDeclaration:[`id`,`body`],TSEnumBody:[`members`],TSEnumMember:[`id`,`initializer`],TSModuleDeclaration:[`id`,`body`],TSModuleBlock:[`body`],TSParameterProperty:[`decorators`,`parameter`],TSAsExpression:[`expression`,`typeAnnotation`],TSSatisfiesExpression:[`expression`,`typeAnnotation`],TSTypeAssertion:[`typeAnnotation`,`expression`],TSNonNullExpression:[`expression`],TSInstantiationExpression:[`expression`,`typeArguments`],TSExportAssignment:[`expression`],TSNamespaceExportDeclaration:[`id`],TSImportEqualsDeclaration:[`id`,`moduleReference`],TSExternalModuleReference:[`expression`]},n=Symbol(`yuku-walk/removed`),r=e=>e;var i=class{walker;parentPath;node;parent;key;index;constructor(e,t,n,r,i,a){this.walker=e,this.parentPath=t,this.node=n,this.parent=r,this.key=i,this.index=a}get state(){return this.walker.state}set state(e){this.walker.state=e}get ancestors(){let e=[];for(let t=this.parentPath;t!==null;t=t.parentPath)e.push(t.node);return e.reverse()}skip(){this.walker.skipFlag=!0}stop(){this.walker.stopFlag=!0}replace(e){e.start===0&&e.end===0&&(e.start=this.node.start,e.end=this.node.end),this.node=e,this.walker.replacement=e;let{parent:t,key:n,index:i}=this;if(t===null||n===null)return;let a=r(t);i===null?a[n]=e:a[n][i]=e}remove(){if(this.parent===null)throw Error(`yuku-walk: cannot remove the root node`);this.walker.removeFlag=!0}insertBefore(e){this.insertSibling(e,0)}insertAfter(e){this.insertSibling(e,1)}insertSibling(e,t){let{parent:n,key:i,index:a}=this;if(n===null||i===null||a===null)throw Error(`yuku-walk: insertBefore/insertAfter require a node in an array field`);let o=r(n)[i],s=o.indexOf(this.node);s!==-1&&o.splice(s+t,0,e)}},a=class{state;skipFlag=!1;stopFlag=!1;removeFlag=!1;replacement=null;universalEnter;universalLeave;concrete=new Map;aliasHandlers=[];cache=Object.create(null);constructor(t,n){this.state=n;let r=t,i=e;for(let e in r){let t=r[e];if(!t)continue;if(e===`enter`){typeof t==`function`&&(this.universalEnter=t);continue}if(e===`leave`){typeof t==`function`&&(this.universalLeave=t);continue}let n=typeof t==`function`?t:t.enter,a=typeof t==`function`?void 0:t.leave,o=i[e];if(o)this.aliasHandlers.push({types:new Set(o),enter:n,leave:a});else{let t=this.concrete.get(e);this.concrete.set(e,{enter:n??t?.enter,leave:a??t?.leave})}}}dispatchFor(e){let n=this.cache[e];if(n!==void 0)return n;let r=[],i=[],a=this.concrete.get(e);this.universalEnter&&r.push(this.universalEnter);for(let t=0;t<this.aliasHandlers.length;t++){let n=this.aliasHandlers[t];n.enter&&n.types.has(e)&&r.push(n.enter)}a?.enter&&r.push(a.enter),a?.leave&&i.push(a.leave);for(let t=this.aliasHandlers.length-1;t>=0;t--){let n=this.aliasHandlers[t];n.leave&&n.types.has(e)&&i.push(n.leave)}return this.universalLeave&&i.push(this.universalLeave),this.cache[e]={enter:r,leave:i,keys:t[e]}}newPath(e,t,n,r,a){return new i(this,e,n,t,r,a)}},o=class extends a{run(e){let t=this.visit(null,null,e,null,null);return t===n?e:t}apply(e,t,n){this.removeFlag=!1;for(let r=0;r<e.length&&(this.replacement=null,e[r](t,n),this.replacement!==null&&(t=this.replacement),!(this.removeFlag||this.stopFlag));r++);return t}visit(e,t,r,i,a){if(this.stopFlag)return r;let o=this.newPath(e,t,r,i,a);this.skipFlag=!1;let s=this.dispatchFor(r.type);if(s.enter.length>0){let e=r;if(r=this.apply(s.enter,r,o),this.removeFlag)return n;if(this.stopFlag)return r;r!==e&&(s=this.dispatchFor(r.type))}if(!this.skipFlag&&s.keys.length>0&&(this.descend(o,r,s.keys),this.stopFlag))return r;if(s.leave.length>0){if(r=this.apply(s.leave,r,o),this.removeFlag)return n;if(this.stopFlag)return r}return r}descend(e,t,i){let a=r(t);for(let r=0;r<i.length;r++){let o=i[r],s=a[o];if(s!=null){if(Array.isArray(s))for(let r=0;r<s.length;r++){let i=s[r];if(i==null)continue;let a=s.length;if(this.visit(e,t,i,o,r)===n?(s.splice(r,1),r--):r+=s.length-a,this.stopFlag)return}else if(this.visit(e,t,s,o,null)===n&&(a[o]=null),this.stopFlag)return}}}};function s(e,t,n){return new o(t,n).run(e)}var c=class extends a{async run(e){let t=await this.visit(null,null,e,null,null);return t===n?e:t}async apply(e,t,n){this.removeFlag=!1;for(let r=0;r<e.length&&(this.replacement=null,await e[r](t,n),this.replacement!==null&&(t=this.replacement),!(this.removeFlag||this.stopFlag));r++);return t}async visit(e,t,r,i,a){if(this.stopFlag)return r;let o=this.newPath(e,t,r,i,a);this.skipFlag=!1;let s=this.dispatchFor(r.type);if(s.enter.length>0){let e=r;if(r=await this.apply(s.enter,r,o),this.removeFlag)return n;if(this.stopFlag)return r;r!==e&&(s=this.dispatchFor(r.type))}if(!this.skipFlag&&s.keys.length>0&&(await this.descend(o,r,s.keys),this.stopFlag))return r;if(s.leave.length>0){if(r=await this.apply(s.leave,r,o),this.removeFlag)return n;if(this.stopFlag)return r}return r}async descend(e,t,i){let a=r(t);for(let r=0;r<i.length;r++){let o=i[r],s=a[o];if(s!=null){if(Array.isArray(s))for(let r=0;r<s.length;r++){let i=s[r];if(i==null)continue;let a=s.length;if(await this.visit(e,t,i,o,r)===n?(s.splice(r,1),r--):r+=s.length-a,this.stopFlag)return}else if(await this.visit(e,t,s,o,null)===n&&(a[o]=null),this.stopFlag)return}}}};function l(e,t,n){return new c(t,n).run(e)}function u(t){let n=new Set(e[t]);return e=>e!=null&&n.has(e.type)}const d={...Object.fromEntries(Object.keys(t).map(e=>[e,t=>t!=null&&t.type===e])),Expression:u(`Expression`),Statement:u(`Statement`),Declaration:u(`Declaration`),ModuleDeclaration:u(`ModuleDeclaration`),Function:u(`Function`),Class:u(`Class`),Method:u(`Method`),Loop:u(`Loop`),Pattern:u(`Pattern`),JSX:u(`JSX`),TSType:u(`TSType`),IdentifierReference:e=>e?.type===`Identifier`&&e.kind===`reference`,BindingIdentifier:e=>e?.type===`Identifier`&&e.kind===`binding`,LabelIdentifier:e=>e?.type===`Identifier`&&e.kind===`label`,IdentifierName:e=>e?.type===`Identifier`&&e.kind===`name`,StringLiteral:e=>e?.type===`Literal`&&typeof e.value==`string`,NumericLiteral:e=>e?.type===`Literal`&&typeof e.value==`number`,BooleanLiteral:e=>e?.type===`Literal`&&typeof e.value==`boolean`,NullLiteral:e=>e?.type===`Literal`&&e.raw===`null`,BigIntLiteral:e=>e?.type===`Literal`&&`bigint`in e,RegExpLiteral:e=>e?.type===`Literal`&&`regex`in e,ComputedMemberExpression:e=>e?.type===`MemberExpression`&&e.computed,StaticMemberExpression:e=>e?.type===`MemberExpression`&&!e.computed&&e.property.type===`Identifier`,PrivateFieldExpression:e=>e?.type===`MemberExpression`&&e.property.type===`PrivateIdentifier`,Directive:e=>e?.type===`ExpressionStatement`&&e.directive!=null},f={start:0,end:0},p=e=>e.type!==`Identifier`&&e.type!==`PrivateIdentifier`,m={identifier(e,t=`reference`,n={}){return{type:`Identifier`,name:e,kind:t,...n,...f}},privateIdentifier(e){return{type:`PrivateIdentifier`,name:e,...f}},stringLiteral(e){return{type:`Literal`,value:e,raw:JSON.stringify(e),...f}},numericLiteral(e){return{type:`Literal`,value:e,raw:String(e),...f}},booleanLiteral(e){return{type:`Literal`,value:e,raw:String(e),...f}},nullLiteral(){return{type:`Literal`,value:null,raw:`null`,...f}},bigIntLiteral(e){return{type:`Literal`,value:e,raw:`${e}n`,bigint:String(e),...f}},regExpLiteral(e,t=``){let n=null;try{n=new RegExp(e,t)}catch{}return{type:`Literal`,value:n,raw:`/${e}/${t}`,regex:{pattern:e,flags:t},...f}},templateLiteral(e,t){return{type:`TemplateLiteral`,quasis:e,expressions:t,...f}},templateElement(e,t=!1){return{type:`TemplateElement`,value:{raw:e,cooked:e},tail:t,...f}},thisExpression(){return{type:`ThisExpression`,...f}},super(){return{type:`Super`,...f}},arrayPattern(e){return{type:`ArrayPattern`,elements:e,...f}},objectPattern(e){return{type:`ObjectPattern`,properties:e,...f}},assignmentPattern(e,t){return{type:`AssignmentPattern`,left:e,right:t,...f}},restElement(e){return{type:`RestElement`,argument:e,...f}},objectProperty(e,t,n={}){return{type:`Property`,kind:n.kind??`init`,key:e,value:t,method:n.method??!1,shorthand:n.shorthand??!1,computed:n.computed??p(e),...f}},bindingProperty(e,t,n={}){return{type:`Property`,kind:`init`,key:e,value:t,method:!1,shorthand:n.shorthand??!1,computed:n.computed??p(e),...f}},arrayExpression(e=[]){return{type:`ArrayExpression`,elements:e,...f}},objectExpression(e=[]){return{type:`ObjectExpression`,properties:e,...f}},spreadElement(e){return{type:`SpreadElement`,argument:e,...f}},sequenceExpression(e){return{type:`SequenceExpression`,expressions:e,...f}},parenthesizedExpression(e){return{type:`ParenthesizedExpression`,expression:e,...f}},unaryExpression(e,t){return{type:`UnaryExpression`,operator:e,prefix:!0,argument:t,...f}},updateExpression(e,t,n=!1){return{type:`UpdateExpression`,operator:e,argument:t,prefix:n,...f}},binaryExpression(e,t,n){return{type:`BinaryExpression`,operator:e,left:t,right:n,...f}},logicalExpression(e,t,n){return{type:`LogicalExpression`,operator:e,left:t,right:n,...f}},assignmentExpression(e,t,n){return{type:`AssignmentExpression`,operator:e,left:t,right:n,...f}},conditionalExpression(e,t,n){return{type:`ConditionalExpression`,test:e,consequent:t,alternate:n,...f}},yieldExpression(e=null,t=!1){return{type:`YieldExpression`,delegate:t,argument:e,...f}},awaitExpression(e){return{type:`AwaitExpression`,argument:e,...f}},memberExpression(e,t,n={}){return{type:`MemberExpression`,object:e,property:t,computed:n.computed??p(t),optional:n.optional??!1,...f}},callExpression(e,t=[],n={}){return{type:`CallExpression`,callee:e,arguments:t,optional:n.optional??!1,...n,...f}},newExpression(e,t=[],n={}){return{type:`NewExpression`,callee:e,arguments:t,...n,...f}},chainExpression(e){return{type:`ChainExpression`,expression:e,...f}},taggedTemplateExpression(e,t,n={}){return{type:`TaggedTemplateExpression`,tag:e,quasi:t,...n,...f}},metaProperty(e,t){return{type:`MetaProperty`,meta:m.identifier(e,`name`),property:m.identifier(t,`name`),...f}},importExpression(e,t={}){return{type:`ImportExpression`,source:e,options:t.options??null,phase:t.phase??null,...f}},arrowFunctionExpression(e,t,n={}){return{type:`ArrowFunctionExpression`,id:null,generator:!1,async:n.async??!1,params:e,body:t,expression:t.type!==`BlockStatement`,...n,...f}},functionExpression(e,t,n={}){return{type:`FunctionExpression`,id:n.id??null,generator:n.generator??!1,async:n.async??!1,params:e,body:t,expression:!1,...f}},functionDeclaration(e,t,n,r={}){return{type:`FunctionDeclaration`,id:e,generator:r.generator??!1,async:r.async??!1,params:t,body:n,expression:!1,...f}},classDeclaration(e,t,n={}){return{type:`ClassDeclaration`,decorators:n.decorators??[],id:e,superClass:n.superClass??null,body:t,...n,...f}},classExpression(e,t,n={}){return{type:`ClassExpression`,decorators:n.decorators??[],id:e,superClass:n.superClass??null,body:t,...f}},classBody(e=[]){return{type:`ClassBody`,body:e,...f}},methodDefinition(e,t,n={}){return{type:`MethodDefinition`,decorators:[],key:e,value:t,kind:n.kind??`method`,computed:n.computed??p(e),static:n.static??!1,...f}},propertyDefinition(e,t=null,n={}){return{type:`PropertyDefinition`,decorators:n.decorators??[],key:e,value:t,computed:n.computed??p(e),static:n.static??!1,...f}},accessorProperty(e,t=null,n={}){return{type:`AccessorProperty`,decorators:[],key:e,value:t,computed:n.computed??p(e),static:n.static??!1,...f}},tsAbstractMethodDefinition(e,t,n={}){return{type:`TSAbstractMethodDefinition`,decorators:[],key:e,value:t,kind:n.kind??`method`,computed:n.computed??p(e),static:n.static??!1,...f}},tsAbstractPropertyDefinition(e,t=null,n={}){return{type:`TSAbstractPropertyDefinition`,decorators:[],key:e,value:t,computed:n.computed??p(e),static:n.static??!1,...f}},tsAbstractAccessorProperty(e,t=null,n={}){return{type:`TSAbstractAccessorProperty`,decorators:[],key:e,value:t,computed:n.computed??p(e),static:n.static??!1,...f}},staticBlock(e=[]){return{type:`StaticBlock`,body:e,...f}},decorator(e){return{type:`Decorator`,expression:e,...f}},expressionStatement(e){return{type:`ExpressionStatement`,expression:e,...f}},directive(e){return{type:`ExpressionStatement`,expression:m.stringLiteral(e),directive:e,...f}},blockStatement(e=[]){return{type:`BlockStatement`,body:e,...f}},emptyStatement(){return{type:`EmptyStatement`,...f}},debuggerStatement(){return{type:`DebuggerStatement`,...f}},returnStatement(e=null){return{type:`ReturnStatement`,argument:e,...f}},ifStatement(e,t,n=null){return{type:`IfStatement`,test:e,consequent:t,alternate:n,...f}},switchStatement(e,t){return{type:`SwitchStatement`,discriminant:e,cases:t,...f}},switchCase(e,t){return{type:`SwitchCase`,test:e,consequent:t,...f}},throwStatement(e){return{type:`ThrowStatement`,argument:e,...f}},tryStatement(e,t=null,n=null){return{type:`TryStatement`,block:e,handler:t,finalizer:n,...f}},catchClause(e,t){return{type:`CatchClause`,param:e,body:t,...f}},whileStatement(e,t){return{type:`WhileStatement`,test:e,body:t,...f}},doWhileStatement(e,t){return{type:`DoWhileStatement`,body:e,test:t,...f}},forStatement(e,t,n,r){return{type:`ForStatement`,init:e,test:t,update:n,body:r,...f}},forInStatement(e,t,n){return{type:`ForInStatement`,left:e,right:t,body:n,...f}},forOfStatement(e,t,n,r=!1){return{type:`ForOfStatement`,left:e,right:t,body:n,await:r,...f}},labeledStatement(e,t){return{type:`LabeledStatement`,label:e,body:t,...f}},breakStatement(e=null){return{type:`BreakStatement`,label:e,...f}},continueStatement(e=null){return{type:`ContinueStatement`,label:e,...f}},withStatement(e,t){return{type:`WithStatement`,object:e,body:t,...f}},variableDeclaration(e,t){return{type:`VariableDeclaration`,kind:e,declarations:t,...f}},variableDeclarator(e,t=null){return{type:`VariableDeclarator`,id:e,init:t,...f}},importDeclaration(e,t,n={}){return{type:`ImportDeclaration`,specifiers:e,source:t,phase:n.phase??null,attributes:n.attributes??[],...n,...f}},importSpecifier(e,t){return{type:`ImportSpecifier`,imported:e,local:t,...f}},importDefaultSpecifier(e){return{type:`ImportDefaultSpecifier`,local:e,...f}},importNamespaceSpecifier(e){return{type:`ImportNamespaceSpecifier`,local:e,...f}},importAttribute(e,t){return{type:`ImportAttribute`,key:e,value:t,...f}},exportNamedDeclaration(e,t=[],n={}){return{type:`ExportNamedDeclaration`,declaration:e,specifiers:t,source:n.source??null,attributes:n.attributes??[],...n,...f}},exportDefaultDeclaration(e){return{type:`ExportDefaultDeclaration`,declaration:e,...f}},exportAllDeclaration(e,t={}){return{type:`ExportAllDeclaration`,exported:t.exported??null,source:e,attributes:t.attributes??[],...t,...f}},exportSpecifier(e,t){return{type:`ExportSpecifier`,local:e,exported:t,...f}},jsxIdentifier(e){return{type:`JSXIdentifier`,name:e,...f}},jsxNamespacedName(e,t){return{type:`JSXNamespacedName`,namespace:e,name:t,...f}},jsxMemberExpression(e,t){return{type:`JSXMemberExpression`,object:e,property:t,...f}},jsxElement(e,t=[],n=null){return{type:`JSXElement`,openingElement:e,children:t,closingElement:n,...f}},jsxOpeningElement(e,t=[],n=!1){return{type:`JSXOpeningElement`,name:e,attributes:t,selfClosing:n,...f}},jsxClosingElement(e){return{type:`JSXClosingElement`,name:e,...f}},jsxOpeningFragment(){return{type:`JSXOpeningFragment`,...f}},jsxClosingFragment(){return{type:`JSXClosingFragment`,...f}},jsxFragment(e=[]){return{type:`JSXFragment`,openingFragment:m.jsxOpeningFragment(),children:e,closingFragment:m.jsxClosingFragment(),...f}},jsxAttribute(e,t=null){return{type:`JSXAttribute`,name:e,value:t,...f}},jsxSpreadAttribute(e){return{type:`JSXSpreadAttribute`,argument:e,...f}},jsxExpressionContainer(e){return{type:`JSXExpressionContainer`,expression:e,...f}},jsxEmptyExpression(){return{type:`JSXEmptyExpression`,...f}},jsxText(e){return{type:`JSXText`,value:e,raw:e,...f}},jsxSpreadChild(e){return{type:`JSXSpreadChild`,expression:e,...f}},tsTypeAnnotation(e){return{type:`TSTypeAnnotation`,typeAnnotation:e,...f}},tsAnyKeyword:()=>({type:`TSAnyKeyword`,...f}),tsUnknownKeyword:()=>({type:`TSUnknownKeyword`,...f}),tsNeverKeyword:()=>({type:`TSNeverKeyword`,...f}),tsVoidKeyword:()=>({type:`TSVoidKeyword`,...f}),tsNullKeyword:()=>({type:`TSNullKeyword`,...f}),tsUndefinedKeyword:()=>({type:`TSUndefinedKeyword`,...f}),tsStringKeyword:()=>({type:`TSStringKeyword`,...f}),tsNumberKeyword:()=>({type:`TSNumberKeyword`,...f}),tsBigIntKeyword:()=>({type:`TSBigIntKeyword`,...f}),tsBooleanKeyword:()=>({type:`TSBooleanKeyword`,...f}),tsSymbolKeyword:()=>({type:`TSSymbolKeyword`,...f}),tsObjectKeyword:()=>({type:`TSObjectKeyword`,...f}),tsIntrinsicKeyword:()=>({type:`TSIntrinsicKeyword`,...f}),tsThisType:()=>({type:`TSThisType`,...f}),tsTypeReference(e,t=null){return{type:`TSTypeReference`,typeName:e,typeArguments:t,...f}},tsQualifiedName(e,t){return{type:`TSQualifiedName`,left:e,right:t,...f}},tsTypeQuery(e,t=null){return{type:`TSTypeQuery`,exprName:e,typeArguments:t,...f}},tsImportType(e,t={}){return{type:`TSImportType`,source:e,options:t.options??null,qualifier:t.qualifier??null,typeArguments:t.typeArguments??null,...f}},tsTypeParameter(e,t={}){return{type:`TSTypeParameter`,name:e,constraint:t.constraint??null,default:t.default??null,in:t.in??!1,out:t.out??!1,const:t.const??!1,...f}},tsTypeParameterDeclaration(e){return{type:`TSTypeParameterDeclaration`,params:e,...f}},tsTypeParameterInstantiation(e){return{type:`TSTypeParameterInstantiation`,params:e,...f}},tsLiteralType(e){return{type:`TSLiteralType`,literal:e,...f}},tsTemplateLiteralType(e,t){return{type:`TSTemplateLiteralType`,quasis:e,types:t,...f}},tsArrayType(e){return{type:`TSArrayType`,elementType:e,...f}},tsIndexedAccessType(e,t){return{type:`TSIndexedAccessType`,objectType:e,indexType:t,...f}},tsTupleType(e){return{type:`TSTupleType`,elementTypes:e,...f}},tsNamedTupleMember(e,t,n=!1){return{type:`TSNamedTupleMember`,label:e,elementType:t,optional:n,...f}},tsOptionalType(e){return{type:`TSOptionalType`,typeAnnotation:e,...f}},tsRestType(e){return{type:`TSRestType`,typeAnnotation:e,...f}},tsJSDocNullableType(e,t=!1){return{type:`TSJSDocNullableType`,typeAnnotation:e,postfix:t,...f}},tsJSDocNonNullableType(e,t=!1){return{type:`TSJSDocNonNullableType`,typeAnnotation:e,postfix:t,...f}},tsJSDocUnknownType(){return{type:`TSJSDocUnknownType`,...f}},tsUnionType(e){return{type:`TSUnionType`,types:e,...f}},tsIntersectionType(e){return{type:`TSIntersectionType`,types:e,...f}},tsConditionalType(e,t,n,r){return{type:`TSConditionalType`,checkType:e,extendsType:t,trueType:n,falseType:r,...f}},tsInferType(e){return{type:`TSInferType`,typeParameter:e,...f}},tsTypeOperator(e,t){return{type:`TSTypeOperator`,operator:e,typeAnnotation:t,...f}},tsParenthesizedType(e){return{type:`TSParenthesizedType`,typeAnnotation:e,...f}},tsFunctionType(e,t,n=null){return{type:`TSFunctionType`,typeParameters:n,params:e,returnType:t,...f}},tsConstructorType(e,t,n={}){return{type:`TSConstructorType`,abstract:n.abstract??!1,typeParameters:n.typeParameters??null,params:e,returnType:t,...f}},tsTypePredicate(e,t=null,n=!1){return{type:`TSTypePredicate`,parameterName:e,typeAnnotation:t,asserts:n,...f}},tsTypeLiteral(e){return{type:`TSTypeLiteral`,members:e,...f}},tsMappedType(e,t,n={}){return{type:`TSMappedType`,key:e,constraint:t,nameType:n.nameType??null,typeAnnotation:n.typeAnnotation??null,optional:n.optional??!1,readonly:n.readonly??null,...f}},tsPropertySignature(e,t={}){return{type:`TSPropertySignature`,key:e,typeAnnotation:t.typeAnnotation??null,computed:t.computed??p(e),optional:t.optional??!1,readonly:t.readonly??!1,accessibility:null,static:!1,...f}},tsMethodSignature(e,t,n={}){return{type:`TSMethodSignature`,key:e,computed:n.computed??p(e),optional:n.optional??!1,kind:n.kind??`method`,typeParameters:n.typeParameters??null,params:t,returnType:n.returnType??null,accessibility:null,readonly:!1,static:!1,...f}},tsCallSignatureDeclaration(e,t=null,n=null){return{type:`TSCallSignatureDeclaration`,typeParameters:n,params:e,returnType:t,...f}},tsConstructSignatureDeclaration(e,t=null,n=null){return{type:`TSConstructSignatureDeclaration`,typeParameters:n,params:e,returnType:t,...f}},tsIndexSignature(e,t,n={}){return{type:`TSIndexSignature`,parameters:e,typeAnnotation:t,readonly:n.readonly??!1,static:n.static??!1,accessibility:null,...f}},tsTypeAliasDeclaration(e,t,n={}){return{type:`TSTypeAliasDeclaration`,id:e,typeParameters:n.typeParameters??null,typeAnnotation:t,declare:n.declare??!1,...f}},tsInterfaceDeclaration(e,t,n={}){return{type:`TSInterfaceDeclaration`,id:e,typeParameters:n.typeParameters??null,extends:n.extends??[],body:t,declare:n.declare??!1,...f}},tsInterfaceBody(e){return{type:`TSInterfaceBody`,body:e,...f}},tsInterfaceHeritage(e,t=null){return{type:`TSInterfaceHeritage`,expression:e,typeArguments:t,...f}},tsClassImplements(e,t=null){return{type:`TSClassImplements`,expression:e,typeArguments:t,...f}},tsEnumDeclaration(e,t,n={}){return{type:`TSEnumDeclaration`,id:e,body:t,const:n.const??!1,declare:n.declare??!1,...f}},tsEnumBody(e){return{type:`TSEnumBody`,members:e,...f}},tsEnumMember(e,t=null){return{type:`TSEnumMember`,id:e,initializer:t,computed:!1,...f}},tsModuleDeclaration(e,t,n={}){return{type:`TSModuleDeclaration`,id:e,body:t,kind:n.kind??`module`,declare:n.declare??!1,global:n.global??!1,...f}},tsModuleBlock(e=[]){return{type:`TSModuleBlock`,body:e,...f}},tsParameterProperty(e,t={}){return{type:`TSParameterProperty`,decorators:t.decorators??[],parameter:e,override:t.override??!1,readonly:t.readonly??!1,accessibility:t.accessibility??null,static:!1,...f}},tsAsExpression(e,t){return{type:`TSAsExpression`,expression:e,typeAnnotation:t,...f}},tsSatisfiesExpression(e,t){return{type:`TSSatisfiesExpression`,expression:e,typeAnnotation:t,...f}},tsTypeAssertion(e,t){return{type:`TSTypeAssertion`,typeAnnotation:e,expression:t,...f}},tsNonNullExpression(e){return{type:`TSNonNullExpression`,expression:e,...f}},tsInstantiationExpression(e,t){return{type:`TSInstantiationExpression`,expression:e,typeArguments:t,...f}},tsExportAssignment(e){return{type:`TSExportAssignment`,expression:e,...f}},tsNamespaceExportDeclaration(e){return{type:`TSNamespaceExportDeclaration`,id:e,...f}},tsImportEqualsDeclaration(e,t,n=`value`){return{type:`TSImportEqualsDeclaration`,id:e,moduleReference:t,importKind:n,...f}},tsExternalModuleReference(e){return{type:`TSExternalModuleReference`,expression:e,...f}},tsDeclareFunction(e,t,n={}){return{type:`TSDeclareFunction`,id:e,generator:n.generator??!1,async:n.async??!1,params:t,body:null,expression:!1,declare:n.declare??!1,typeParameters:n.typeParameters??null,returnType:n.returnType??null,...f}},tsEmptyBodyFunctionExpression(e,t={}){return{type:`TSEmptyBodyFunctionExpression`,id:t.id??null,generator:!1,async:!1,params:e,body:null,expression:!1,declare:!1,typeParameters:t.typeParameters??null,returnType:t.returnType??null,...f}},hashbang(e){return{type:`Hashbang`,value:e,...f}},program(e=[],t={}){return{type:`Program`,sourceType:t.sourceType??`module`,hashbang:t.hashbang??null,body:e,...f}}};export{m as b,d as is,s as walk,l as walkAsync};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/aliases.ts","../src/visitor-keys.ts","../src/walk-core.ts","../src/walk.ts","../src/walk-async.ts","../src/predicates.ts","../src/builders.ts"],"sourcesContent":["import type { NodeOfType, NodeType } from \"./types\";\n\n/**\n * Node types grouped under a shared alias. A visitor registered under an alias\n * name runs for every member type. Membership is by node `type`.\n */\nexport const ALIAS_GROUPS = {\n  Expression: [\n    \"Identifier\",\n    \"Literal\",\n    \"ThisExpression\",\n    \"Super\",\n    \"ArrayExpression\",\n    \"ObjectExpression\",\n    \"FunctionExpression\",\n    \"ArrowFunctionExpression\",\n    \"ClassExpression\",\n    \"TaggedTemplateExpression\",\n    \"TemplateLiteral\",\n    \"MemberExpression\",\n    \"CallExpression\",\n    \"NewExpression\",\n    \"ChainExpression\",\n    \"SequenceExpression\",\n    \"ParenthesizedExpression\",\n    \"BinaryExpression\",\n    \"LogicalExpression\",\n    \"ConditionalExpression\",\n    \"UnaryExpression\",\n    \"UpdateExpression\",\n    \"AssignmentExpression\",\n    \"YieldExpression\",\n    \"AwaitExpression\",\n    \"ImportExpression\",\n    \"MetaProperty\",\n    \"TSAsExpression\",\n    \"TSSatisfiesExpression\",\n    \"TSTypeAssertion\",\n    \"TSNonNullExpression\",\n    \"TSInstantiationExpression\",\n    \"JSXElement\",\n    \"JSXFragment\",\n  ],\n  Statement: [\n    \"ExpressionStatement\",\n    \"BlockStatement\",\n    \"EmptyStatement\",\n    \"DebuggerStatement\",\n    \"ReturnStatement\",\n    \"LabeledStatement\",\n    \"BreakStatement\",\n    \"ContinueStatement\",\n    \"IfStatement\",\n    \"SwitchStatement\",\n    \"ThrowStatement\",\n    \"TryStatement\",\n    \"WhileStatement\",\n    \"DoWhileStatement\",\n    \"ForStatement\",\n    \"ForInStatement\",\n    \"ForOfStatement\",\n    \"WithStatement\",\n    \"FunctionDeclaration\",\n    \"ClassDeclaration\",\n    \"VariableDeclaration\",\n    \"TSDeclareFunction\",\n    \"TSTypeAliasDeclaration\",\n    \"TSInterfaceDeclaration\",\n    \"TSEnumDeclaration\",\n    \"TSModuleDeclaration\",\n    \"TSImportEqualsDeclaration\",\n  ],\n  Declaration: [\n    \"FunctionDeclaration\",\n    \"ClassDeclaration\",\n    \"VariableDeclaration\",\n    \"TSDeclareFunction\",\n    \"TSTypeAliasDeclaration\",\n    \"TSInterfaceDeclaration\",\n    \"TSEnumDeclaration\",\n    \"TSModuleDeclaration\",\n    \"TSImportEqualsDeclaration\",\n  ],\n  ModuleDeclaration: [\n    \"ImportDeclaration\",\n    \"ExportNamedDeclaration\",\n    \"ExportDefaultDeclaration\",\n    \"ExportAllDeclaration\",\n    \"TSExportAssignment\",\n    \"TSNamespaceExportDeclaration\",\n  ],\n  // Includes arrow functions, unlike the parser's narrower Function type.\n  Function: [\n    \"FunctionDeclaration\",\n    \"FunctionExpression\",\n    \"ArrowFunctionExpression\",\n    \"TSDeclareFunction\",\n    \"TSEmptyBodyFunctionExpression\",\n  ],\n  Class: [\"ClassDeclaration\", \"ClassExpression\"],\n  Method: [\"MethodDefinition\", \"TSAbstractMethodDefinition\"],\n  Loop: [\n    \"ForStatement\",\n    \"ForInStatement\",\n    \"ForOfStatement\",\n    \"WhileStatement\",\n    \"DoWhileStatement\",\n  ],\n  Pattern: [\"Identifier\", \"ArrayPattern\", \"ObjectPattern\", \"AssignmentPattern\", \"RestElement\"],\n  JSX: [\n    \"JSXElement\",\n    \"JSXOpeningElement\",\n    \"JSXClosingElement\",\n    \"JSXFragment\",\n    \"JSXOpeningFragment\",\n    \"JSXClosingFragment\",\n    \"JSXIdentifier\",\n    \"JSXNamespacedName\",\n    \"JSXMemberExpression\",\n    \"JSXAttribute\",\n    \"JSXSpreadAttribute\",\n    \"JSXExpressionContainer\",\n    \"JSXEmptyExpression\",\n    \"JSXText\",\n    \"JSXSpreadChild\",\n  ],\n  TSType: [\n    \"TSAnyKeyword\",\n    \"TSUnknownKeyword\",\n    \"TSNeverKeyword\",\n    \"TSVoidKeyword\",\n    \"TSNullKeyword\",\n    \"TSUndefinedKeyword\",\n    \"TSStringKeyword\",\n    \"TSNumberKeyword\",\n    \"TSBigIntKeyword\",\n    \"TSBooleanKeyword\",\n    \"TSSymbolKeyword\",\n    \"TSObjectKeyword\",\n    \"TSIntrinsicKeyword\",\n    \"TSThisType\",\n    \"TSTypeReference\",\n    \"TSTypeQuery\",\n    \"TSImportType\",\n    \"TSLiteralType\",\n    \"TSTemplateLiteralType\",\n    \"TSArrayType\",\n    \"TSIndexedAccessType\",\n    \"TSTupleType\",\n    \"TSNamedTupleMember\",\n    \"TSJSDocNullableType\",\n    \"TSJSDocNonNullableType\",\n    \"TSJSDocUnknownType\",\n    \"TSUnionType\",\n    \"TSIntersectionType\",\n    \"TSConditionalType\",\n    \"TSInferType\",\n    \"TSTypeOperator\",\n    \"TSParenthesizedType\",\n    \"TSFunctionType\",\n    \"TSConstructorType\",\n    \"TSTypePredicate\",\n    \"TSTypeLiteral\",\n    \"TSMappedType\",\n  ],\n} as const satisfies Record<string, readonly NodeType[]>;\n\n/** Name of an alias group. */\nexport type AliasName = keyof typeof ALIAS_GROUPS;\n\n/** Node union matched by each alias group. */\nexport type AliasMap = {\n  [K in AliasName]: NodeOfType<(typeof ALIAS_GROUPS)[K][number]>;\n};\n","import type { ChildKeys, NodeOfType, NodeType } from \"./types\";\n\ntype VisitorKeysTable = { [K in NodeType]: readonly ChildKeys<NodeOfType<K>>[] };\n\n/**\n * Child fields of each node type, in traversal order. Names are validated\n * against the AST types, so a renamed, removed, or added field fails to compile.\n */\nexport const VISITOR_KEYS = {\n  Program: [\"hashbang\", \"body\"],\n  Hashbang: [],\n\n  Identifier: [\"decorators\", \"typeAnnotation\"],\n  PrivateIdentifier: [],\n  Literal: [],\n  TemplateElement: [],\n  Super: [],\n  ThisExpression: [],\n\n  ArrayPattern: [\"decorators\", \"elements\", \"typeAnnotation\"],\n  ObjectPattern: [\"decorators\", \"properties\", \"typeAnnotation\"],\n  AssignmentPattern: [\"decorators\", \"left\", \"right\", \"typeAnnotation\"],\n  RestElement: [\"decorators\", \"argument\", \"typeAnnotation\"],\n  Property: [\"key\", \"value\"],\n\n  // Expressions\n  SequenceExpression: [\"expressions\"],\n  ParenthesizedExpression: [\"expression\"],\n  BinaryExpression: [\"left\", \"right\"],\n  LogicalExpression: [\"left\", \"right\"],\n  ConditionalExpression: [\"test\", \"consequent\", \"alternate\"],\n  UnaryExpression: [\"argument\"],\n  UpdateExpression: [\"argument\"],\n  AssignmentExpression: [\"left\", \"right\"],\n  YieldExpression: [\"argument\"],\n  AwaitExpression: [\"argument\"],\n  ArrayExpression: [\"elements\"],\n  ObjectExpression: [\"properties\"],\n  SpreadElement: [\"argument\"],\n  MemberExpression: [\"object\", \"property\"],\n  CallExpression: [\"callee\", \"typeArguments\", \"arguments\"],\n  ChainExpression: [\"expression\"],\n  TaggedTemplateExpression: [\"tag\", \"typeArguments\", \"quasi\"],\n  NewExpression: [\"callee\", \"typeArguments\", \"arguments\"],\n  MetaProperty: [\"meta\", \"property\"],\n  ImportExpression: [\"source\", \"options\"],\n  TemplateLiteral: [\"quasis\", \"expressions\"],\n\n  // Statements\n  ExpressionStatement: [\"expression\"],\n  BlockStatement: [\"body\"],\n  IfStatement: [\"test\", \"consequent\", \"alternate\"],\n  SwitchStatement: [\"discriminant\", \"cases\"],\n  SwitchCase: [\"test\", \"consequent\"],\n  ForStatement: [\"init\", \"test\", \"update\", \"body\"],\n  ForInStatement: [\"left\", \"right\", \"body\"],\n  ForOfStatement: [\"left\", \"right\", \"body\"],\n  WhileStatement: [\"test\", \"body\"],\n  DoWhileStatement: [\"body\", \"test\"],\n  BreakStatement: [\"label\"],\n  ContinueStatement: [\"label\"],\n  LabeledStatement: [\"label\", \"body\"],\n  WithStatement: [\"object\", \"body\"],\n  ReturnStatement: [\"argument\"],\n  ThrowStatement: [\"argument\"],\n  TryStatement: [\"block\", \"handler\", \"finalizer\"],\n  CatchClause: [\"param\", \"body\"],\n  DebuggerStatement: [],\n  EmptyStatement: [],\n\n  VariableDeclaration: [\"declarations\"],\n  VariableDeclarator: [\"id\", \"init\"],\n\n  // Functions\n  FunctionDeclaration: [\"id\", \"typeParameters\", \"params\", \"returnType\", \"body\"],\n  FunctionExpression: [\"id\", \"typeParameters\", \"params\", \"returnType\", \"body\"],\n  TSDeclareFunction: [\"id\", \"typeParameters\", \"params\", \"returnType\"],\n  TSEmptyBodyFunctionExpression: [\"id\", \"typeParameters\", \"params\", \"returnType\"],\n  ArrowFunctionExpression: [\"typeParameters\", \"params\", \"returnType\", \"body\"],\n\n  ClassDeclaration: [\n    \"decorators\",\n    \"id\",\n    \"typeParameters\",\n    \"superClass\",\n    \"superTypeArguments\",\n    \"implements\",\n    \"body\",\n  ],\n  ClassExpression: [\n    \"decorators\",\n    \"id\",\n    \"typeParameters\",\n    \"superClass\",\n    \"superTypeArguments\",\n    \"implements\",\n    \"body\",\n  ],\n  ClassBody: [\"body\"],\n  MethodDefinition: [\"decorators\", \"key\", \"value\"],\n  TSAbstractMethodDefinition: [\"decorators\", \"key\", \"value\"],\n  PropertyDefinition: [\"decorators\", \"key\", \"typeAnnotation\", \"value\"],\n  TSAbstractPropertyDefinition: [\"decorators\", \"key\", \"typeAnnotation\", \"value\"],\n  AccessorProperty: [\"decorators\", \"key\", \"typeAnnotation\", \"value\"],\n  TSAbstractAccessorProperty: [\"decorators\", \"key\", \"typeAnnotation\", \"value\"],\n  StaticBlock: [\"body\"],\n  Decorator: [\"expression\"],\n\n  // Modules\n  ImportDeclaration: [\"specifiers\", \"source\", \"attributes\"],\n  ImportSpecifier: [\"imported\", \"local\"],\n  ImportDefaultSpecifier: [\"local\"],\n  ImportNamespaceSpecifier: [\"local\"],\n  ImportAttribute: [\"key\", \"value\"],\n  ExportNamedDeclaration: [\"declaration\", \"specifiers\", \"source\", \"attributes\"],\n  ExportDefaultDeclaration: [\"declaration\"],\n  ExportAllDeclaration: [\"exported\", \"source\", \"attributes\"],\n  ExportSpecifier: [\"local\", \"exported\"],\n\n  // JSX\n  JSXElement: [\"openingElement\", \"children\", \"closingElement\"],\n  JSXOpeningElement: [\"name\", \"typeArguments\", \"attributes\"],\n  JSXClosingElement: [\"name\"],\n  JSXFragment: [\"openingFragment\", \"children\", \"closingFragment\"],\n  JSXOpeningFragment: [],\n  JSXClosingFragment: [],\n  JSXIdentifier: [],\n  JSXNamespacedName: [\"namespace\", \"name\"],\n  JSXMemberExpression: [\"object\", \"property\"],\n  JSXAttribute: [\"name\", \"value\"],\n  JSXSpreadAttribute: [\"argument\"],\n  JSXExpressionContainer: [\"expression\"],\n  JSXEmptyExpression: [],\n  JSXText: [],\n  JSXSpreadChild: [\"expression\"],\n\n  // TypeScript\n  TSTypeAnnotation: [\"typeAnnotation\"],\n  TSAnyKeyword: [],\n  TSUnknownKeyword: [],\n  TSNeverKeyword: [],\n  TSVoidKeyword: [],\n  TSNullKeyword: [],\n  TSUndefinedKeyword: [],\n  TSStringKeyword: [],\n  TSNumberKeyword: [],\n  TSBigIntKeyword: [],\n  TSBooleanKeyword: [],\n  TSSymbolKeyword: [],\n  TSObjectKeyword: [],\n  TSIntrinsicKeyword: [],\n  TSThisType: [],\n\n  TSTypeReference: [\"typeName\", \"typeArguments\"],\n  TSQualifiedName: [\"left\", \"right\"],\n  TSTypeQuery: [\"exprName\", \"typeArguments\"],\n  TSImportType: [\"source\", \"options\", \"qualifier\", \"typeArguments\"],\n  TSTypeParameter: [\"name\", \"constraint\", \"default\"],\n  TSTypeParameterDeclaration: [\"params\"],\n  TSTypeParameterInstantiation: [\"params\"],\n  TSLiteralType: [\"literal\"],\n  TSTemplateLiteralType: [\"quasis\", \"types\"],\n  TSArrayType: [\"elementType\"],\n  TSIndexedAccessType: [\"objectType\", \"indexType\"],\n  TSTupleType: [\"elementTypes\"],\n  TSNamedTupleMember: [\"label\", \"elementType\"],\n  TSOptionalType: [\"typeAnnotation\"],\n  TSRestType: [\"typeAnnotation\"],\n  TSJSDocNullableType: [\"typeAnnotation\"],\n  TSJSDocNonNullableType: [\"typeAnnotation\"],\n  TSJSDocUnknownType: [],\n  TSUnionType: [\"types\"],\n  TSIntersectionType: [\"types\"],\n  TSConditionalType: [\"checkType\", \"extendsType\", \"trueType\", \"falseType\"],\n  TSInferType: [\"typeParameter\"],\n  TSTypeOperator: [\"typeAnnotation\"],\n  TSParenthesizedType: [\"typeAnnotation\"],\n  TSFunctionType: [\"typeParameters\", \"params\", \"returnType\"],\n  TSConstructorType: [\"typeParameters\", \"params\", \"returnType\"],\n  TSTypePredicate: [\"parameterName\", \"typeAnnotation\"],\n  TSTypeLiteral: [\"members\"],\n  TSMappedType: [\"key\", \"constraint\", \"nameType\", \"typeAnnotation\"],\n\n  TSPropertySignature: [\"key\", \"typeAnnotation\"],\n  TSMethodSignature: [\"key\", \"typeParameters\", \"params\", \"returnType\"],\n  TSCallSignatureDeclaration: [\"typeParameters\", \"params\", \"returnType\"],\n  TSConstructSignatureDeclaration: [\"typeParameters\", \"params\", \"returnType\"],\n  TSIndexSignature: [\"parameters\", \"typeAnnotation\"],\n\n  TSTypeAliasDeclaration: [\"id\", \"typeParameters\", \"typeAnnotation\"],\n  TSInterfaceDeclaration: [\"id\", \"typeParameters\", \"extends\", \"body\"],\n  TSInterfaceBody: [\"body\"],\n  TSInterfaceHeritage: [\"expression\", \"typeArguments\"],\n  TSClassImplements: [\"expression\", \"typeArguments\"],\n  TSEnumDeclaration: [\"id\", \"body\"],\n  TSEnumBody: [\"members\"],\n  TSEnumMember: [\"id\", \"initializer\"],\n  TSModuleDeclaration: [\"id\", \"body\"],\n  TSModuleBlock: [\"body\"],\n  TSParameterProperty: [\"decorators\", \"parameter\"],\n\n  TSAsExpression: [\"expression\", \"typeAnnotation\"],\n  TSSatisfiesExpression: [\"expression\", \"typeAnnotation\"],\n  TSTypeAssertion: [\"typeAnnotation\", \"expression\"],\n  TSNonNullExpression: [\"expression\"],\n  TSInstantiationExpression: [\"expression\", \"typeArguments\"],\n  TSExportAssignment: [\"expression\"],\n  TSNamespaceExportDeclaration: [\"id\"],\n  TSImportEqualsDeclaration: [\"id\", \"moduleReference\"],\n  TSExternalModuleReference: [\"expression\"],\n} as const satisfies VisitorKeysTable;\n\n// Completeness guard. `satisfies` above rejects a key that is not a child field,\n// but cannot tell that a child field is missing.\ntype UnlistedChildKeys = {\n  [K in NodeType as [Exclude<ChildKeys<NodeOfType<K>>, (typeof VISITOR_KEYS)[K][number]>] extends [never]\n    ? never\n    : K]: Exclude<ChildKeys<NodeOfType<K>>, (typeof VISITOR_KEYS)[K][number]>;\n};\nconst _allChildKeysListed: UnlistedChildKeys = {};\nvoid _allChildKeysListed;\n\n/** Child fields of a node type, in traversal order. */\nexport function getVisitorKeys(type: NodeType): readonly string[] {\n  return VISITOR_KEYS[type];\n}\n","import type { Node } from \"yuku-parser\";\nimport { ALIAS_GROUPS } from \"./aliases\";\nimport type { NodeType, Path } from \"./types\";\nimport { VISITOR_KEYS } from \"./visitor-keys\";\n\nexport type Handler<S> = (node: Node, path: Path<Node, S>) => unknown;\ntype Entry<S> = Handler<S> | { enter?: Handler<S>; leave?: Handler<S> };\ntype Fields = Record<string, unknown>;\n\nexport interface Dispatch<S> {\n  readonly enter: readonly Handler<S>[];\n  readonly leave: readonly Handler<S>[];\n  readonly keys: readonly string[];\n}\n\ninterface AliasHandler<S> {\n  readonly types: ReadonlySet<string>;\n  readonly enter?: Handler<S>;\n  readonly leave?: Handler<S>;\n}\n\n/** Returned up the stack when a visitor calls `remove()`. */\nexport const REMOVED = Symbol(\"yuku-walk/removed\");\n\n/** A node viewed as its fields, for traversal and mutation by key. */\nexport const fieldsOf = (node: Node): Fields => node as unknown as Fields;\n\n/**\n * One per visited node, holding its own position and a link to its parent path\n * so it stays valid, ancestors included, after the visit returns. Control flow\n * and mutation delegate to the owning walker.\n */\nexport class NodePath<S> implements Path<Node, S> {\n  constructor(\n    private readonly walker: WalkerCore<S>,\n    private readonly parentPath: NodePath<S> | null,\n    public node: Node,\n    public readonly parent: Node | null,\n    public readonly key: string | null,\n    public readonly index: number | null,\n  ) {}\n\n  get state(): S {\n    return this.walker.state;\n  }\n  set state(value: S) {\n    this.walker.state = value;\n  }\n\n  get ancestors(): readonly Node[] {\n    const out: Node[] = [];\n    for (let p = this.parentPath; p !== null; p = p.parentPath) out.push(p.node);\n    return out.reverse();\n  }\n\n  skip(): void {\n    this.walker.skipFlag = true;\n  }\n  stop(): void {\n    this.walker.stopFlag = true;\n  }\n\n  replace(next: Node): void {\n    // Synthetic replacements inherit the original span, for source maps.\n    if (next.start === 0 && next.end === 0) {\n      next.start = this.node.start;\n      next.end = this.node.end;\n    }\n    this.node = next;\n    this.walker.replacement = next;\n    const { parent, key, index } = this;\n    if (parent === null || key === null) return;\n    const fields = fieldsOf(parent);\n    if (index === null) fields[key] = next;\n    else (fields[key] as unknown[])[index] = next;\n  }\n\n  remove(): void {\n    if (this.parent === null) throw new Error(\"yuku-walk: cannot remove the root node\");\n    this.walker.removeFlag = true;\n  }\n\n  insertBefore(node: Node): void {\n    this.insertSibling(node, 0);\n  }\n\n  insertAfter(node: Node): void {\n    this.insertSibling(node, 1);\n  }\n\n  private insertSibling(node: Node, offset: 0 | 1): void {\n    const { parent, key, index } = this;\n    if (parent === null || key === null || index === null) {\n      throw new Error(\"yuku-walk: insertBefore/insertAfter require a node in an array field\");\n    }\n    const list = fieldsOf(parent)[key] as Node[];\n    const at = list.indexOf(this.node);\n    if (at !== -1) list.splice(at + offset, 0, node);\n  }\n}\n\n/** Shared dispatch and traversal state. The sync and async drivers extend this. */\nexport class WalkerCore<S> {\n  state: S;\n  skipFlag = false;\n  stopFlag = false;\n  removeFlag = false;\n  replacement: Node | null = null;\n\n  protected readonly universalEnter?: Handler<S>;\n  protected readonly universalLeave?: Handler<S>;\n  protected readonly concrete = new Map<string, { enter?: Handler<S>; leave?: Handler<S> }>();\n  protected readonly aliasHandlers: AliasHandler<S>[] = [];\n  private readonly cache: Record<string, Dispatch<S>> = Object.create(null);\n\n  constructor(visitors: object, state: S) {\n    this.state = state;\n    const entries = visitors as Record<string, Entry<S> | undefined>;\n    const aliases = ALIAS_GROUPS as Record<string, readonly NodeType[] | undefined>;\n\n    for (const name in entries) {\n      const entry = entries[name];\n      if (!entry) continue;\n      if (name === \"enter\") {\n        if (typeof entry === \"function\") this.universalEnter = entry;\n        continue;\n      }\n      if (name === \"leave\") {\n        if (typeof entry === \"function\") this.universalLeave = entry;\n        continue;\n      }\n\n      const enter = typeof entry === \"function\" ? entry : entry.enter;\n      const leave = typeof entry === \"function\" ? undefined : entry.leave;\n      const aliasTypes = aliases[name];\n      if (aliasTypes) {\n        this.aliasHandlers.push({ types: new Set(aliasTypes), enter, leave });\n      } else {\n        const prev = this.concrete.get(name);\n        this.concrete.set(name, { enter: enter ?? prev?.enter, leave: leave ?? prev?.leave });\n      }\n    }\n  }\n\n  protected dispatchFor(type: NodeType): Dispatch<S> {\n    const cached = this.cache[type];\n    if (cached !== undefined) return cached;\n\n    const enter: Handler<S>[] = [];\n    const leave: Handler<S>[] = [];\n    const concrete = this.concrete.get(type);\n\n    if (this.universalEnter) enter.push(this.universalEnter);\n    for (let i = 0; i < this.aliasHandlers.length; i++) {\n      const a = this.aliasHandlers[i]!;\n      if (a.enter && a.types.has(type)) enter.push(a.enter);\n    }\n    if (concrete?.enter) enter.push(concrete.enter);\n\n    // leave mirrors enter, concrete, then aliases reversed, then universal.\n    if (concrete?.leave) leave.push(concrete.leave);\n    for (let i = this.aliasHandlers.length - 1; i >= 0; i--) {\n      const a = this.aliasHandlers[i]!;\n      if (a.leave && a.types.has(type)) leave.push(a.leave);\n    }\n    if (this.universalLeave) leave.push(this.universalLeave);\n\n    return (this.cache[type] = { enter, leave, keys: VISITOR_KEYS[type] });\n  }\n\n  protected newPath(\n    parentPath: NodePath<S> | null,\n    parent: Node | null,\n    node: Node,\n    key: string | null,\n    index: number | null,\n  ): NodePath<S> {\n    return new NodePath<S>(this, parentPath, node, parent, key, index);\n  }\n}\n","import type { Node } from \"yuku-parser\";\nimport type { Visitors } from \"./types\";\nimport { type Handler, NodePath, REMOVED, WalkerCore, fieldsOf } from \"./walk-core\";\n\nclass Walker<S> extends WalkerCore<S> {\n  run(root: Node): Node {\n    const result = this.visit(null, null, root, null, null);\n    return result === REMOVED ? root : result;\n  }\n\n  private apply(handlers: readonly Handler<S>[], node: Node, path: NodePath<S>): Node {\n    this.removeFlag = false;\n    for (let i = 0; i < handlers.length; i++) {\n      this.replacement = null;\n      handlers[i]!(node, path);\n      if (this.replacement !== null) node = this.replacement;\n      if (this.removeFlag || this.stopFlag) break;\n    }\n    return node;\n  }\n\n  private visit(\n    parentPath: NodePath<S> | null,\n    parent: Node | null,\n    node: Node,\n    key: string | null,\n    index: number | null,\n  ): Node | typeof REMOVED {\n    if (this.stopFlag) return node;\n\n    const path = this.newPath(parentPath, parent, node, key, index);\n    this.skipFlag = false;\n    let dispatch = this.dispatchFor(node.type);\n\n    if (dispatch.enter.length > 0) {\n      const before = node;\n      node = this.apply(dispatch.enter, node, path);\n      if (this.removeFlag) return REMOVED;\n      if (this.stopFlag) return node;\n      // A replacement may be a different type with different children and handlers.\n      if (node !== before) dispatch = this.dispatchFor(node.type);\n    }\n\n    if (!this.skipFlag && dispatch.keys.length > 0) {\n      this.descend(path, node, dispatch.keys);\n      if (this.stopFlag) return node;\n    }\n\n    if (dispatch.leave.length > 0) {\n      node = this.apply(dispatch.leave, node, path);\n      if (this.removeFlag) return REMOVED;\n      if (this.stopFlag) return node;\n    }\n\n    return node;\n  }\n\n  private descend(path: NodePath<S>, node: Node, keys: readonly string[]): void {\n    const fields = fieldsOf(node);\n    for (let k = 0; k < keys.length; k++) {\n      const key = keys[k]!;\n      const value = fields[key];\n      if (value == null) continue;\n\n      if (Array.isArray(value)) {\n        for (let i = 0; i < value.length; i++) {\n          const child = value[i] as Node | null;\n          if (child == null) continue;\n          const before = value.length;\n          if (this.visit(path, node, child, key, i) === REMOVED) {\n            value.splice(i, 1);\n            i--;\n          } else {\n            i += value.length - before; // skip siblings inserted during the visit\n          }\n          if (this.stopFlag) return;\n        }\n      } else {\n        if (this.visit(path, node, value as Node, key, null) === REMOVED) fields[key] = null;\n        if (this.stopFlag) return;\n      }\n    }\n  }\n}\n\n/**\n * Walk an AST depth first, dispatching to typed visitors and mutating in place.\n *\n * @param root     The node to start from, usually a `Program`.\n * @param visitors Handlers keyed by node `type`, alias group, or `enter`/`leave`.\n * @param state    Optional value exposed as `path.state` throughout the walk.\n * @returns The root node, or its replacement if the root was replaced.\n *\n * @example\n * ```ts\n * walk(program, {\n *   Identifier(node) {\n *     console.log(node.name);\n *   },\n *   CallExpression(node, path) {\n *     if (node.callee.type === \"MemberExpression\") path.skip();\n *   },\n * });\n * ```\n */\nexport function walk<T extends Node, S = unknown>(root: T, visitors: Visitors<S>, state?: S): T {\n  return new Walker<S>(visitors, state as S).run(root) as T;\n}\n","import type { Node } from \"yuku-parser\";\nimport type { AsyncVisitors } from \"./types\";\nimport { type Handler, NodePath, REMOVED, WalkerCore, fieldsOf } from \"./walk-core\";\n\nclass AsyncWalker<S> extends WalkerCore<S> {\n  async run(root: Node): Promise<Node> {\n    const result = await this.visit(null, null, root, null, null);\n    return result === REMOVED ? root : result;\n  }\n\n  private async apply(handlers: readonly Handler<S>[], node: Node, path: NodePath<S>): Promise<Node> {\n    this.removeFlag = false;\n    for (let i = 0; i < handlers.length; i++) {\n      this.replacement = null;\n      await handlers[i]!(node, path);\n      if (this.replacement !== null) node = this.replacement;\n      if (this.removeFlag || this.stopFlag) break;\n    }\n    return node;\n  }\n\n  private async visit(\n    parentPath: NodePath<S> | null,\n    parent: Node | null,\n    node: Node,\n    key: string | null,\n    index: number | null,\n  ): Promise<Node | typeof REMOVED> {\n    if (this.stopFlag) return node;\n\n    const path = this.newPath(parentPath, parent, node, key, index);\n    this.skipFlag = false;\n    let dispatch = this.dispatchFor(node.type);\n\n    if (dispatch.enter.length > 0) {\n      const before = node;\n      node = await this.apply(dispatch.enter, node, path);\n      if (this.removeFlag) return REMOVED;\n      if (this.stopFlag) return node;\n      // A replacement may be a different type with different children and handlers.\n      if (node !== before) dispatch = this.dispatchFor(node.type);\n    }\n\n    if (!this.skipFlag && dispatch.keys.length > 0) {\n      await this.descend(path, node, dispatch.keys);\n      if (this.stopFlag) return node;\n    }\n\n    if (dispatch.leave.length > 0) {\n      node = await this.apply(dispatch.leave, node, path);\n      if (this.removeFlag) return REMOVED;\n      if (this.stopFlag) return node;\n    }\n\n    return node;\n  }\n\n  private async descend(path: NodePath<S>, node: Node, keys: readonly string[]): Promise<void> {\n    const fields = fieldsOf(node);\n    for (let k = 0; k < keys.length; k++) {\n      const key = keys[k]!;\n      const value = fields[key];\n      if (value == null) continue;\n\n      if (Array.isArray(value)) {\n        for (let i = 0; i < value.length; i++) {\n          const child = value[i] as Node | null;\n          if (child == null) continue;\n          const before = value.length;\n          if ((await this.visit(path, node, child, key, i)) === REMOVED) {\n            value.splice(i, 1);\n            i--;\n          } else {\n            i += value.length - before; // skip siblings inserted during the visit\n          }\n          if (this.stopFlag) return;\n        }\n      } else {\n        if ((await this.visit(path, node, value as Node, key, null)) === REMOVED) fields[key] = null;\n        if (this.stopFlag) return;\n      }\n    }\n  }\n}\n\n/**\n * Like {@link walk}, but visitors may be `async`. Handlers are awaited one at a\n * time in depth-first order, so mutation behaves exactly as in the sync walk.\n * Reach for this only when a visitor needs to await I/O; prefer {@link walk}\n * otherwise, as awaiting has per-node overhead.\n *\n * @returns A promise of the root node, or its replacement if the root was replaced.\n */\nexport function walkAsync<T extends Node, S = unknown>(\n  root: T,\n  visitors: AsyncVisitors<S>,\n  state?: S,\n): Promise<T> {\n  return new AsyncWalker<S>(visitors, state as S).run(root) as Promise<T>;\n}\n","import type {\n  BigIntLiteral,\n  BindingIdentifier,\n  BooleanLiteral,\n  ComputedMemberExpression,\n  Directive,\n  IdentifierName,\n  IdentifierReference,\n  LabelIdentifier,\n  Node,\n  NullLiteral,\n  NumericLiteral,\n  PrivateFieldExpression,\n  RegExpLiteral,\n  StaticMemberExpression,\n  StringLiteral,\n} from \"yuku-parser\";\nimport { ALIAS_GROUPS, type AliasMap, type AliasName } from \"./aliases\";\nimport type { NodeOfType, NodeType } from \"./types\";\nimport { VISITOR_KEYS } from \"./visitor-keys\";\n\ntype MaybeNode = Node | null | undefined;\n\nfunction aliasGuard<K extends AliasName>(name: K): (node: MaybeNode) => node is AliasMap[K] {\n  const set = new Set<string>(ALIAS_GROUPS[name]);\n  return (node): node is AliasMap[K] => node != null && set.has(node.type);\n}\n\n/** One guard per concrete node `type`, e.g. `is.CallExpression`. */\ntype ConcreteGuards = { [K in NodeType]: (node: MaybeNode) => node is NodeOfType<K> };\n\nconst concrete = Object.fromEntries(\n  (Object.keys(VISITOR_KEYS) as NodeType[]).map((type) => [\n    type,\n    (node: MaybeNode) => node != null && node.type === type,\n  ]),\n) as ConcreteGuards;\n\nexport const is = {\n  ...concrete,\n\n  Expression: aliasGuard(\"Expression\"),\n  Statement: aliasGuard(\"Statement\"),\n  Declaration: aliasGuard(\"Declaration\"),\n  ModuleDeclaration: aliasGuard(\"ModuleDeclaration\"),\n  Function: aliasGuard(\"Function\"),\n  Class: aliasGuard(\"Class\"),\n  Method: aliasGuard(\"Method\"),\n  Loop: aliasGuard(\"Loop\"),\n  Pattern: aliasGuard(\"Pattern\"),\n  JSX: aliasGuard(\"JSX\"),\n  TSType: aliasGuard(\"TSType\"),\n\n  IdentifierReference: (node: MaybeNode): node is IdentifierReference =>\n    node?.type === \"Identifier\" && node.kind === \"reference\",\n  BindingIdentifier: (node: MaybeNode): node is BindingIdentifier =>\n    node?.type === \"Identifier\" && node.kind === \"binding\",\n  LabelIdentifier: (node: MaybeNode): node is LabelIdentifier => node?.type === \"Identifier\" && node.kind === \"label\",\n  IdentifierName: (node: MaybeNode): node is IdentifierName => node?.type === \"Identifier\" && node.kind === \"name\",\n\n  StringLiteral: (node: MaybeNode): node is StringLiteral => node?.type === \"Literal\" && typeof node.value === \"string\",\n  NumericLiteral: (node: MaybeNode): node is NumericLiteral =>\n    node?.type === \"Literal\" && typeof node.value === \"number\",\n  BooleanLiteral: (node: MaybeNode): node is BooleanLiteral =>\n    node?.type === \"Literal\" && typeof node.value === \"boolean\",\n  NullLiteral: (node: MaybeNode): node is NullLiteral => node?.type === \"Literal\" && node.raw === \"null\",\n  BigIntLiteral: (node: MaybeNode): node is BigIntLiteral => node?.type === \"Literal\" && \"bigint\" in node,\n  RegExpLiteral: (node: MaybeNode): node is RegExpLiteral => node?.type === \"Literal\" && \"regex\" in node,\n\n  ComputedMemberExpression: (node: MaybeNode): node is ComputedMemberExpression =>\n    node?.type === \"MemberExpression\" && node.computed,\n  StaticMemberExpression: (node: MaybeNode): node is StaticMemberExpression =>\n    node?.type === \"MemberExpression\" && !node.computed && node.property.type === \"Identifier\",\n  PrivateFieldExpression: (node: MaybeNode): node is PrivateFieldExpression =>\n    node?.type === \"MemberExpression\" && node.property.type === \"PrivateIdentifier\",\n\n  Directive: (node: MaybeNode): node is Directive => node?.type === \"ExpressionStatement\" && node.directive != null,\n};\n","import type * as t from \"yuku-parser\";\n\nconst span = { start: 0, end: 0 };\n\nconst isComputedKey = (key: t.PropertyKey): boolean =>\n  key.type !== \"Identifier\" && key.type !== \"PrivateIdentifier\";\n\nexport const b = {\n  // Identifiers and literals\n  identifier(\n    name: string,\n    kind: t.IdentifierKind = \"reference\",\n    opts: { typeAnnotation?: t.TSTypeAnnotation | null; optional?: boolean; decorators?: t.Decorator[] } = {},\n  ): t.Identifier {\n    return { type: \"Identifier\", name, kind, ...opts, ...span };\n  },\n  privateIdentifier(name: string): t.PrivateIdentifier {\n    return { type: \"PrivateIdentifier\", name, ...span };\n  },\n  stringLiteral(value: string): t.StringLiteral {\n    return { type: \"Literal\", value, raw: JSON.stringify(value), ...span };\n  },\n  numericLiteral(value: number): t.NumericLiteral {\n    return { type: \"Literal\", value, raw: String(value), ...span };\n  },\n  booleanLiteral(value: boolean): t.BooleanLiteral {\n    return { type: \"Literal\", value, raw: String(value), ...span };\n  },\n  nullLiteral(): t.NullLiteral {\n    return { type: \"Literal\", value: null, raw: \"null\", ...span };\n  },\n  bigIntLiteral(value: bigint): t.BigIntLiteral {\n    return { type: \"Literal\", value, raw: `${value}n`, bigint: String(value), ...span };\n  },\n  regExpLiteral(pattern: string, flags = \"\"): t.RegExpLiteral {\n    let value: RegExp | null = null;\n    try {\n      value = new RegExp(pattern, flags);\n    } catch {}\n    return { type: \"Literal\", value, raw: `/${pattern}/${flags}`, regex: { pattern, flags }, ...span };\n  },\n  templateLiteral(quasis: t.TemplateElement[], expressions: t.Expression[]): t.TemplateLiteral {\n    return { type: \"TemplateLiteral\", quasis, expressions, ...span };\n  },\n  templateElement(cooked: string, tail = false): t.TemplateElement {\n    return { type: \"TemplateElement\", value: { raw: cooked, cooked }, tail, ...span };\n  },\n  thisExpression(): t.ThisExpression {\n    return { type: \"ThisExpression\", ...span };\n  },\n  super(): t.Super {\n    return { type: \"Super\", ...span };\n  },\n\n  // Patterns\n  arrayPattern(elements: Array<t.BindingPattern | t.RestElement | null>): t.ArrayPattern {\n    return { type: \"ArrayPattern\", elements, ...span };\n  },\n  objectPattern(properties: Array<t.BindingProperty | t.RestElement>): t.ObjectPattern {\n    return { type: \"ObjectPattern\", properties, ...span };\n  },\n  assignmentPattern(left: t.BindingPattern, right: t.Expression): t.AssignmentPattern {\n    return { type: \"AssignmentPattern\", left, right, ...span };\n  },\n  restElement(argument: t.BindingPattern): t.RestElement {\n    return { type: \"RestElement\", argument, ...span };\n  },\n  /** A member of an `ObjectExpression`. For an `ObjectPattern` member, use {@link bindingProperty}. */\n  objectProperty(\n    key: t.PropertyKey,\n    value: t.Expression,\n    opts: { computed?: boolean; shorthand?: boolean; kind?: t.PropertyKind; method?: boolean } = {},\n  ): t.ObjectProperty {\n    return {\n      type: \"Property\",\n      kind: opts.kind ?? \"init\",\n      key,\n      value,\n      method: opts.method ?? false,\n      shorthand: opts.shorthand ?? false,\n      computed: opts.computed ?? isComputedKey(key),\n      ...span,\n    };\n  },\n  /** A member of an `ObjectPattern`, whose value is a binding target. For an `ObjectExpression` member, use {@link objectProperty}. */\n  bindingProperty(\n    key: t.PropertyKey,\n    value: t.BindingPattern,\n    opts: { computed?: boolean; shorthand?: boolean } = {},\n  ): t.BindingProperty {\n    return {\n      type: \"Property\",\n      kind: \"init\",\n      key,\n      value,\n      method: false,\n      shorthand: opts.shorthand ?? false,\n      computed: opts.computed ?? isComputedKey(key),\n      ...span,\n    };\n  },\n\n  // Expressions\n  arrayExpression(elements: t.ArrayExpressionElement[] = []): t.ArrayExpression {\n    return { type: \"ArrayExpression\", elements, ...span };\n  },\n  objectExpression(properties: t.ObjectPropertyKind[] = []): t.ObjectExpression {\n    return { type: \"ObjectExpression\", properties, ...span };\n  },\n  spreadElement(argument: t.Expression): t.SpreadElement {\n    return { type: \"SpreadElement\", argument, ...span };\n  },\n  sequenceExpression(expressions: t.Expression[]): t.SequenceExpression {\n    return { type: \"SequenceExpression\", expressions, ...span };\n  },\n  parenthesizedExpression(expression: t.Expression): t.ParenthesizedExpression {\n    return { type: \"ParenthesizedExpression\", expression, ...span };\n  },\n  unaryExpression(operator: t.UnaryOperator, argument: t.Expression): t.UnaryExpression {\n    return { type: \"UnaryExpression\", operator, prefix: true, argument, ...span };\n  },\n  updateExpression(operator: t.UpdateOperator, argument: t.Expression, prefix = false): t.UpdateExpression {\n    return { type: \"UpdateExpression\", operator, argument, prefix, ...span };\n  },\n  binaryExpression(\n    operator: t.BinaryOperator,\n    left: t.Expression | t.PrivateIdentifier,\n    right: t.Expression,\n  ): t.BinaryExpression {\n    return { type: \"BinaryExpression\", operator, left, right, ...span };\n  },\n  logicalExpression(operator: t.LogicalOperator, left: t.Expression, right: t.Expression): t.LogicalExpression {\n    return { type: \"LogicalExpression\", operator, left, right, ...span };\n  },\n  assignmentExpression(\n    operator: t.AssignmentOperator,\n    left: t.AssignmentTarget,\n    right: t.Expression,\n  ): t.AssignmentExpression {\n    return { type: \"AssignmentExpression\", operator, left, right, ...span };\n  },\n  conditionalExpression(\n    test: t.Expression,\n    consequent: t.Expression,\n    alternate: t.Expression,\n  ): t.ConditionalExpression {\n    return { type: \"ConditionalExpression\", test, consequent, alternate, ...span };\n  },\n  yieldExpression(argument: t.Expression | null = null, delegate = false): t.YieldExpression {\n    return { type: \"YieldExpression\", delegate, argument, ...span };\n  },\n  awaitExpression(argument: t.Expression): t.AwaitExpression {\n    return { type: \"AwaitExpression\", argument, ...span };\n  },\n  memberExpression(\n    object: t.Expression | t.Super,\n    property: t.Expression | t.IdentifierName | t.PrivateIdentifier,\n    opts: { computed?: boolean; optional?: boolean } = {},\n  ): t.MemberExpression {\n    return {\n      type: \"MemberExpression\",\n      object,\n      property,\n      computed: opts.computed ?? isComputedKey(property as t.PropertyKey),\n      optional: opts.optional ?? false,\n      ...span,\n    } as t.MemberExpression;\n  },\n  callExpression(\n    callee: t.Expression | t.Super,\n    args: t.Argument[] = [],\n    opts: { optional?: boolean; typeArguments?: t.TSTypeParameterInstantiation | null } = {},\n  ): t.CallExpression {\n    return { type: \"CallExpression\", callee, arguments: args, optional: opts.optional ?? false, ...opts, ...span };\n  },\n  newExpression(\n    callee: t.Expression,\n    args: t.Argument[] = [],\n    opts: { typeArguments?: t.TSTypeParameterInstantiation | null } = {},\n  ): t.NewExpression {\n    return { type: \"NewExpression\", callee, arguments: args, ...opts, ...span };\n  },\n  chainExpression(expression: t.ChainElement): t.ChainExpression {\n    return { type: \"ChainExpression\", expression, ...span };\n  },\n  taggedTemplateExpression(\n    tag: t.Expression,\n    quasi: t.TemplateLiteral,\n    opts: { typeArguments?: t.TSTypeParameterInstantiation | null } = {},\n  ): t.TaggedTemplateExpression {\n    return { type: \"TaggedTemplateExpression\", tag, quasi, ...opts, ...span };\n  },\n  metaProperty(meta: string, property: string): t.MetaProperty {\n    return { type: \"MetaProperty\", meta: b.identifier(meta, \"name\"), property: b.identifier(property, \"name\"), ...span };\n  },\n  importExpression(\n    source: t.Expression,\n    opts: { options?: t.Expression | null; phase?: t.ImportPhase | null } = {},\n  ): t.ImportExpression {\n    return { type: \"ImportExpression\", source, options: opts.options ?? null, phase: opts.phase ?? null, ...span };\n  },\n\n  // Functions\n  arrowFunctionExpression(\n    params: t.FunctionParameter[],\n    body: t.BlockStatement | t.Expression,\n    opts: { async?: boolean; typeParameters?: t.TSTypeParameterDeclaration | null; returnType?: t.TSTypeAnnotation | null } = {},\n  ): t.ArrowFunctionExpression {\n    return {\n      type: \"ArrowFunctionExpression\",\n      id: null,\n      generator: false,\n      async: opts.async ?? false,\n      params,\n      body,\n      expression: body.type !== \"BlockStatement\",\n      ...opts,\n      ...span,\n    };\n  },\n  functionExpression(\n    params: t.FunctionParameter[],\n    body: t.BlockStatement,\n    opts: { id?: t.Identifier | null; async?: boolean; generator?: boolean } = {},\n  ): t.FunctionExpression {\n    return {\n      type: \"FunctionExpression\",\n      id: opts.id ?? null,\n      generator: opts.generator ?? false,\n      async: opts.async ?? false,\n      params,\n      body,\n      expression: false,\n      ...span,\n    };\n  },\n  functionDeclaration(\n    id: t.Identifier | null,\n    params: t.FunctionParameter[],\n    body: t.BlockStatement | null,\n    opts: { async?: boolean; generator?: boolean } = {},\n  ): t.FunctionDeclaration {\n    return {\n      type: \"FunctionDeclaration\",\n      id,\n      generator: opts.generator ?? false,\n      async: opts.async ?? false,\n      params,\n      body,\n      expression: false,\n      ...span,\n    };\n  },\n\n  // Classes\n  classDeclaration(\n    id: t.Identifier | null,\n    body: t.ClassBody,\n    opts: {\n      superClass?: t.Expression | null;\n      decorators?: t.Decorator[];\n      typeParameters?: t.TSTypeParameterDeclaration | null;\n      abstract?: boolean;\n    } = {},\n  ): t.ClassDeclaration {\n    return {\n      type: \"ClassDeclaration\",\n      decorators: opts.decorators ?? [],\n      id,\n      superClass: opts.superClass ?? null,\n      body,\n      ...opts,\n      ...span,\n    };\n  },\n  classExpression(\n    id: t.Identifier | null,\n    body: t.ClassBody,\n    opts: { superClass?: t.Expression | null; decorators?: t.Decorator[] } = {},\n  ): t.ClassExpression {\n    return {\n      type: \"ClassExpression\",\n      decorators: opts.decorators ?? [],\n      id,\n      superClass: opts.superClass ?? null,\n      body,\n      ...span,\n    };\n  },\n  classBody(body: t.ClassElement[] = []): t.ClassBody {\n    return { type: \"ClassBody\", body, ...span };\n  },\n  methodDefinition(\n    key: t.PropertyKey,\n    value: t.FunctionExpression | t.TSEmptyBodyFunctionExpression,\n    opts: { kind?: t.MethodDefinitionKind; computed?: boolean; static?: boolean } = {},\n  ): t.MethodDefinition {\n    return {\n      type: \"MethodDefinition\",\n      decorators: [],\n      key,\n      value,\n      kind: opts.kind ?? \"method\",\n      computed: opts.computed ?? isComputedKey(key),\n      static: opts.static ?? false,\n      ...span,\n    };\n  },\n  propertyDefinition(\n    key: t.PropertyKey,\n    value: t.Expression | null = null,\n    opts: { computed?: boolean; static?: boolean; decorators?: t.Decorator[] } = {},\n  ): t.PropertyDefinition {\n    return {\n      type: \"PropertyDefinition\",\n      decorators: opts.decorators ?? [],\n      key,\n      value,\n      computed: opts.computed ?? isComputedKey(key),\n      static: opts.static ?? false,\n      ...span,\n    };\n  },\n  accessorProperty(\n    key: t.PropertyKey,\n    value: t.Expression | null = null,\n    opts: { computed?: boolean; static?: boolean } = {},\n  ): t.AccessorProperty {\n    return {\n      type: \"AccessorProperty\",\n      decorators: [],\n      key,\n      value,\n      computed: opts.computed ?? isComputedKey(key),\n      static: opts.static ?? false,\n      ...span,\n    };\n  },\n  tsAbstractMethodDefinition(\n    key: t.PropertyKey,\n    value: t.FunctionExpression | t.TSEmptyBodyFunctionExpression,\n    opts: { kind?: t.MethodDefinitionKind; computed?: boolean; static?: boolean } = {},\n  ): t.TSAbstractMethodDefinition {\n    return {\n      type: \"TSAbstractMethodDefinition\",\n      decorators: [],\n      key,\n      value,\n      kind: opts.kind ?? \"method\",\n      computed: opts.computed ?? isComputedKey(key),\n      static: opts.static ?? false,\n      ...span,\n    };\n  },\n  tsAbstractPropertyDefinition(\n    key: t.PropertyKey,\n    value: t.Expression | null = null,\n    opts: { computed?: boolean; static?: boolean } = {},\n  ): t.TSAbstractPropertyDefinition {\n    return {\n      type: \"TSAbstractPropertyDefinition\",\n      decorators: [],\n      key,\n      value,\n      computed: opts.computed ?? isComputedKey(key),\n      static: opts.static ?? false,\n      ...span,\n    };\n  },\n  tsAbstractAccessorProperty(\n    key: t.PropertyKey,\n    value: t.Expression | null = null,\n    opts: { computed?: boolean; static?: boolean } = {},\n  ): t.TSAbstractAccessorProperty {\n    return {\n      type: \"TSAbstractAccessorProperty\",\n      decorators: [],\n      key,\n      value,\n      computed: opts.computed ?? isComputedKey(key),\n      static: opts.static ?? false,\n      ...span,\n    };\n  },\n  staticBlock(body: t.Statement[] = []): t.StaticBlock {\n    return { type: \"StaticBlock\", body, ...span };\n  },\n  decorator(expression: t.Expression): t.Decorator {\n    return { type: \"Decorator\", expression, ...span };\n  },\n\n  // Statements\n  expressionStatement(expression: t.Expression): t.ExpressionStatement {\n    return { type: \"ExpressionStatement\", expression, ...span };\n  },\n  directive(value: string): t.Directive {\n    return { type: \"ExpressionStatement\", expression: b.stringLiteral(value), directive: value, ...span };\n  },\n  blockStatement(body: t.Statement[] = []): t.BlockStatement {\n    return { type: \"BlockStatement\", body, ...span };\n  },\n  emptyStatement(): t.EmptyStatement {\n    return { type: \"EmptyStatement\", ...span };\n  },\n  debuggerStatement(): t.DebuggerStatement {\n    return { type: \"DebuggerStatement\", ...span };\n  },\n  returnStatement(argument: t.Expression | null = null): t.ReturnStatement {\n    return { type: \"ReturnStatement\", argument, ...span };\n  },\n  ifStatement(test: t.Expression, consequent: t.Statement, alternate: t.Statement | null = null): t.IfStatement {\n    return { type: \"IfStatement\", test, consequent, alternate, ...span };\n  },\n  switchStatement(discriminant: t.Expression, cases: t.SwitchCase[]): t.SwitchStatement {\n    return { type: \"SwitchStatement\", discriminant, cases, ...span };\n  },\n  switchCase(test: t.Expression | null, consequent: t.Statement[]): t.SwitchCase {\n    return { type: \"SwitchCase\", test, consequent, ...span };\n  },\n  throwStatement(argument: t.Expression): t.ThrowStatement {\n    return { type: \"ThrowStatement\", argument, ...span };\n  },\n  tryStatement(\n    block: t.BlockStatement,\n    handler: t.CatchClause | null = null,\n    finalizer: t.BlockStatement | null = null,\n  ): t.TryStatement {\n    return { type: \"TryStatement\", block, handler, finalizer, ...span };\n  },\n  catchClause(param: t.BindingPattern | null, body: t.BlockStatement): t.CatchClause {\n    return { type: \"CatchClause\", param, body, ...span };\n  },\n  whileStatement(test: t.Expression, body: t.Statement): t.WhileStatement {\n    return { type: \"WhileStatement\", test, body, ...span };\n  },\n  doWhileStatement(body: t.Statement, test: t.Expression): t.DoWhileStatement {\n    return { type: \"DoWhileStatement\", body, test, ...span };\n  },\n  forStatement(\n    init: t.ForStatementInit | null,\n    test: t.Expression | null,\n    update: t.Expression | null,\n    body: t.Statement,\n  ): t.ForStatement {\n    return { type: \"ForStatement\", init, test, update, body, ...span };\n  },\n  forInStatement(left: t.ForStatementLeft, right: t.Expression, body: t.Statement): t.ForInStatement {\n    return { type: \"ForInStatement\", left, right, body, ...span };\n  },\n  forOfStatement(\n    left: t.ForStatementLeft,\n    right: t.Expression,\n    body: t.Statement,\n    isAwait = false,\n  ): t.ForOfStatement {\n    return { type: \"ForOfStatement\", left, right, body, await: isAwait, ...span };\n  },\n  labeledStatement(label: t.LabelIdentifier, body: t.Statement): t.LabeledStatement {\n    return { type: \"LabeledStatement\", label, body, ...span };\n  },\n  breakStatement(label: t.LabelIdentifier | null = null): t.BreakStatement {\n    return { type: \"BreakStatement\", label, ...span };\n  },\n  continueStatement(label: t.LabelIdentifier | null = null): t.ContinueStatement {\n    return { type: \"ContinueStatement\", label, ...span };\n  },\n  withStatement(object: t.Expression, body: t.Statement): t.WithStatement {\n    return { type: \"WithStatement\", object, body, ...span };\n  },\n\n  // Variable declarations\n  variableDeclaration(kind: t.VariableDeclarationKind, declarations: t.VariableDeclarator[]): t.VariableDeclaration {\n    return { type: \"VariableDeclaration\", kind, declarations, ...span };\n  },\n  variableDeclarator(id: t.BindingPattern, init: t.Expression | null = null): t.VariableDeclarator {\n    return { type: \"VariableDeclarator\", id, init, ...span };\n  },\n\n  // Modules\n  importDeclaration(\n    specifiers: t.ImportDeclarationSpecifier[],\n    source: t.StringLiteral,\n    opts: { attributes?: t.ImportAttribute[]; phase?: t.ImportPhase | null; importKind?: t.ImportOrExportKind } = {},\n  ): t.ImportDeclaration {\n    return {\n      type: \"ImportDeclaration\",\n      specifiers,\n      source,\n      phase: opts.phase ?? null,\n      attributes: opts.attributes ?? [],\n      ...opts,\n      ...span,\n    };\n  },\n  importSpecifier(imported: t.IdentifierName | t.StringLiteral, local: t.BindingIdentifier): t.ImportSpecifier {\n    return { type: \"ImportSpecifier\", imported, local, ...span };\n  },\n  importDefaultSpecifier(local: t.BindingIdentifier): t.ImportDefaultSpecifier {\n    return { type: \"ImportDefaultSpecifier\", local, ...span };\n  },\n  importNamespaceSpecifier(local: t.BindingIdentifier): t.ImportNamespaceSpecifier {\n    return { type: \"ImportNamespaceSpecifier\", local, ...span };\n  },\n  importAttribute(key: t.ImportAttributeKey, value: t.StringLiteral): t.ImportAttribute {\n    return { type: \"ImportAttribute\", key, value, ...span };\n  },\n  exportNamedDeclaration(\n    declaration: t.Declaration | null,\n    specifiers: t.ExportSpecifier[] = [],\n    opts: { source?: t.StringLiteral | null; attributes?: t.ImportAttribute[]; exportKind?: t.ImportOrExportKind } = {},\n  ): t.ExportNamedDeclaration {\n    return {\n      type: \"ExportNamedDeclaration\",\n      declaration,\n      specifiers,\n      source: opts.source ?? null,\n      attributes: opts.attributes ?? [],\n      ...opts,\n      ...span,\n    };\n  },\n  exportDefaultDeclaration(declaration: t.ExportDefaultDeclarationKind): t.ExportDefaultDeclaration {\n    return { type: \"ExportDefaultDeclaration\", declaration, ...span };\n  },\n  exportAllDeclaration(\n    source: t.StringLiteral,\n    opts: { exported?: t.ModuleExportName | null; attributes?: t.ImportAttribute[]; exportKind?: t.ImportOrExportKind } = {},\n  ): t.ExportAllDeclaration {\n    return {\n      type: \"ExportAllDeclaration\",\n      exported: opts.exported ?? null,\n      source,\n      attributes: opts.attributes ?? [],\n      ...opts,\n      ...span,\n    };\n  },\n  exportSpecifier(local: t.ModuleExportName, exported: t.ModuleExportName): t.ExportSpecifier {\n    return { type: \"ExportSpecifier\", local, exported, ...span };\n  },\n\n  // JSX\n  jsxIdentifier(name: string): t.JSXIdentifier {\n    return { type: \"JSXIdentifier\", name, ...span };\n  },\n  jsxNamespacedName(namespace: t.JSXIdentifier, name: t.JSXIdentifier): t.JSXNamespacedName {\n    return { type: \"JSXNamespacedName\", namespace, name, ...span };\n  },\n  jsxMemberExpression(object: t.JSXMemberExpressionObject, property: t.JSXIdentifier): t.JSXMemberExpression {\n    return { type: \"JSXMemberExpression\", object, property, ...span };\n  },\n  jsxElement(\n    openingElement: t.JSXOpeningElement,\n    children: t.JSXChild[] = [],\n    closingElement: t.JSXClosingElement | null = null,\n  ): t.JSXElement {\n    return { type: \"JSXElement\", openingElement, children, closingElement, ...span };\n  },\n  jsxOpeningElement(\n    name: t.JSXElementName,\n    attributes: t.JSXAttributeItem[] = [],\n    selfClosing = false,\n  ): t.JSXOpeningElement {\n    return { type: \"JSXOpeningElement\", name, attributes, selfClosing, ...span };\n  },\n  jsxClosingElement(name: t.JSXElementName): t.JSXClosingElement {\n    return { type: \"JSXClosingElement\", name, ...span };\n  },\n  jsxOpeningFragment(): t.JSXOpeningFragment {\n    return { type: \"JSXOpeningFragment\", ...span };\n  },\n  jsxClosingFragment(): t.JSXClosingFragment {\n    return { type: \"JSXClosingFragment\", ...span };\n  },\n  jsxFragment(children: t.JSXChild[] = []): t.JSXFragment {\n    return {\n      type: \"JSXFragment\",\n      openingFragment: b.jsxOpeningFragment(),\n      children,\n      closingFragment: b.jsxClosingFragment(),\n      ...span,\n    };\n  },\n  jsxAttribute(name: t.JSXAttributeName, value: t.JSXAttributeValue | null = null): t.JSXAttribute {\n    return { type: \"JSXAttribute\", name, value, ...span };\n  },\n  jsxSpreadAttribute(argument: t.Expression): t.JSXSpreadAttribute {\n    return { type: \"JSXSpreadAttribute\", argument, ...span };\n  },\n  jsxExpressionContainer(expression: t.JSXExpression): t.JSXExpressionContainer {\n    return { type: \"JSXExpressionContainer\", expression, ...span };\n  },\n  jsxEmptyExpression(): t.JSXEmptyExpression {\n    return { type: \"JSXEmptyExpression\", ...span };\n  },\n  jsxText(value: string): t.JSXText {\n    return { type: \"JSXText\", value, raw: value, ...span };\n  },\n  jsxSpreadChild(expression: t.Expression): t.JSXSpreadChild {\n    return { type: \"JSXSpreadChild\", expression, ...span };\n  },\n\n  // TypeScript: type annotation and keywords\n  tsTypeAnnotation(typeAnnotation: t.TSType): t.TSTypeAnnotation {\n    return { type: \"TSTypeAnnotation\", typeAnnotation, ...span };\n  },\n  tsAnyKeyword: (): t.TSAnyKeyword => ({ type: \"TSAnyKeyword\", ...span }),\n  tsUnknownKeyword: (): t.TSUnknownKeyword => ({ type: \"TSUnknownKeyword\", ...span }),\n  tsNeverKeyword: (): t.TSNeverKeyword => ({ type: \"TSNeverKeyword\", ...span }),\n  tsVoidKeyword: (): t.TSVoidKeyword => ({ type: \"TSVoidKeyword\", ...span }),\n  tsNullKeyword: (): t.TSNullKeyword => ({ type: \"TSNullKeyword\", ...span }),\n  tsUndefinedKeyword: (): t.TSUndefinedKeyword => ({ type: \"TSUndefinedKeyword\", ...span }),\n  tsStringKeyword: (): t.TSStringKeyword => ({ type: \"TSStringKeyword\", ...span }),\n  tsNumberKeyword: (): t.TSNumberKeyword => ({ type: \"TSNumberKeyword\", ...span }),\n  tsBigIntKeyword: (): t.TSBigIntKeyword => ({ type: \"TSBigIntKeyword\", ...span }),\n  tsBooleanKeyword: (): t.TSBooleanKeyword => ({ type: \"TSBooleanKeyword\", ...span }),\n  tsSymbolKeyword: (): t.TSSymbolKeyword => ({ type: \"TSSymbolKeyword\", ...span }),\n  tsObjectKeyword: (): t.TSObjectKeyword => ({ type: \"TSObjectKeyword\", ...span }),\n  tsIntrinsicKeyword: (): t.TSIntrinsicKeyword => ({ type: \"TSIntrinsicKeyword\", ...span }),\n  tsThisType: (): t.TSThisType => ({ type: \"TSThisType\", ...span }),\n\n  // TypeScript: composite types\n  tsTypeReference(\n    typeName: t.TSTypeName,\n    typeArguments: t.TSTypeParameterInstantiation | null = null,\n  ): t.TSTypeReference {\n    return { type: \"TSTypeReference\", typeName, typeArguments, ...span };\n  },\n  tsQualifiedName(left: t.TSTypeName, right: t.IdentifierName): t.TSQualifiedName {\n    return { type: \"TSQualifiedName\", left, right, ...span };\n  },\n  tsTypeQuery(\n    exprName: t.TSTypeQueryExprName,\n    typeArguments: t.TSTypeParameterInstantiation | null = null,\n  ): t.TSTypeQuery {\n    return { type: \"TSTypeQuery\", exprName, typeArguments, ...span };\n  },\n  tsImportType(\n    source: t.StringLiteral,\n    opts: {\n      options?: t.ObjectExpression | null;\n      qualifier?: t.TSImportTypeQualifier | null;\n      typeArguments?: t.TSTypeParameterInstantiation | null;\n    } = {},\n  ): t.TSImportType {\n    return {\n      type: \"TSImportType\",\n      source,\n      options: opts.options ?? null,\n      qualifier: opts.qualifier ?? null,\n      typeArguments: opts.typeArguments ?? null,\n      ...span,\n    };\n  },\n  tsTypeParameter(\n    name: t.BindingIdentifier,\n    opts: { constraint?: t.TSType | null; default?: t.TSType | null; in?: boolean; out?: boolean; const?: boolean } = {},\n  ): t.TSTypeParameter {\n    return {\n      type: \"TSTypeParameter\",\n      name,\n      constraint: opts.constraint ?? null,\n      default: opts.default ?? null,\n      in: opts.in ?? false,\n      out: opts.out ?? false,\n      const: opts.const ?? false,\n      ...span,\n    };\n  },\n  tsTypeParameterDeclaration(params: t.TSTypeParameter[]): t.TSTypeParameterDeclaration {\n    return { type: \"TSTypeParameterDeclaration\", params, ...span };\n  },\n  tsTypeParameterInstantiation(params: t.TSType[]): t.TSTypeParameterInstantiation {\n    return { type: \"TSTypeParameterInstantiation\", params, ...span };\n  },\n  tsLiteralType(literal: t.TSLiteralType[\"literal\"]): t.TSLiteralType {\n    return { type: \"TSLiteralType\", literal, ...span };\n  },\n  tsTemplateLiteralType(quasis: t.TemplateElement[], types: t.TSType[]): t.TSTemplateLiteralType {\n    return { type: \"TSTemplateLiteralType\", quasis, types, ...span };\n  },\n  tsArrayType(elementType: t.TSType): t.TSArrayType {\n    return { type: \"TSArrayType\", elementType, ...span };\n  },\n  tsIndexedAccessType(objectType: t.TSType, indexType: t.TSType): t.TSIndexedAccessType {\n    return { type: \"TSIndexedAccessType\", objectType, indexType, ...span };\n  },\n  tsTupleType(elementTypes: t.TSTupleElement[]): t.TSTupleType {\n    return { type: \"TSTupleType\", elementTypes, ...span };\n  },\n  tsNamedTupleMember(label: t.IdentifierName, elementType: t.TSType, optional = false): t.TSNamedTupleMember {\n    return { type: \"TSNamedTupleMember\", label, elementType, optional, ...span };\n  },\n  tsOptionalType(typeAnnotation: t.TSType): t.TSOptionalType {\n    return { type: \"TSOptionalType\", typeAnnotation, ...span };\n  },\n  tsRestType(typeAnnotation: t.TSType | t.TSNamedTupleMember): t.TSRestType {\n    return { type: \"TSRestType\", typeAnnotation, ...span };\n  },\n  tsJSDocNullableType(typeAnnotation: t.TSType, postfix = false): t.TSJSDocNullableType {\n    return { type: \"TSJSDocNullableType\", typeAnnotation, postfix, ...span };\n  },\n  tsJSDocNonNullableType(typeAnnotation: t.TSType, postfix = false): t.TSJSDocNonNullableType {\n    return { type: \"TSJSDocNonNullableType\", typeAnnotation, postfix, ...span };\n  },\n  tsJSDocUnknownType(): t.TSJSDocUnknownType {\n    return { type: \"TSJSDocUnknownType\", ...span };\n  },\n  tsUnionType(types: t.TSType[]): t.TSUnionType {\n    return { type: \"TSUnionType\", types, ...span };\n  },\n  tsIntersectionType(types: t.TSType[]): t.TSIntersectionType {\n    return { type: \"TSIntersectionType\", types, ...span };\n  },\n  tsConditionalType(\n    checkType: t.TSType,\n    extendsType: t.TSType,\n    trueType: t.TSType,\n    falseType: t.TSType,\n  ): t.TSConditionalType {\n    return { type: \"TSConditionalType\", checkType, extendsType, trueType, falseType, ...span };\n  },\n  tsInferType(typeParameter: t.TSTypeParameter): t.TSInferType {\n    return { type: \"TSInferType\", typeParameter, ...span };\n  },\n  tsTypeOperator(operator: t.TSTypeOperator[\"operator\"], typeAnnotation: t.TSType): t.TSTypeOperator {\n    return { type: \"TSTypeOperator\", operator, typeAnnotation, ...span };\n  },\n  tsParenthesizedType(typeAnnotation: t.TSType): t.TSParenthesizedType {\n    return { type: \"TSParenthesizedType\", typeAnnotation, ...span };\n  },\n  tsFunctionType(\n    params: t.FunctionParameter[],\n    returnType: t.TSTypeAnnotation | null,\n    typeParameters: t.TSTypeParameterDeclaration | null = null,\n  ): t.TSFunctionType {\n    return { type: \"TSFunctionType\", typeParameters, params, returnType, ...span };\n  },\n  tsConstructorType(\n    params: t.FunctionParameter[],\n    returnType: t.TSTypeAnnotation | null,\n    opts: { abstract?: boolean; typeParameters?: t.TSTypeParameterDeclaration | null } = {},\n  ): t.TSConstructorType {\n    return {\n      type: \"TSConstructorType\",\n      abstract: opts.abstract ?? false,\n      typeParameters: opts.typeParameters ?? null,\n      params,\n      returnType,\n      ...span,\n    };\n  },\n  tsTypePredicate(\n    parameterName: t.TSTypePredicateName,\n    typeAnnotation: t.TSTypeAnnotation | null = null,\n    asserts = false,\n  ): t.TSTypePredicate {\n    return { type: \"TSTypePredicate\", parameterName, typeAnnotation, asserts, ...span };\n  },\n  tsTypeLiteral(members: t.TSSignature[]): t.TSTypeLiteral {\n    return { type: \"TSTypeLiteral\", members, ...span };\n  },\n  tsMappedType(\n    key: t.BindingIdentifier,\n    constraint: t.TSType,\n    opts: {\n      nameType?: t.TSType | null;\n      typeAnnotation?: t.TSType | null;\n      optional?: t.TSMappedTypeModifierOperator | false;\n      readonly?: t.TSMappedTypeModifierOperator | null;\n    } = {},\n  ): t.TSMappedType {\n    return {\n      type: \"TSMappedType\",\n      key,\n      constraint,\n      nameType: opts.nameType ?? null,\n      typeAnnotation: opts.typeAnnotation ?? null,\n      optional: opts.optional ?? false,\n      readonly: opts.readonly ?? null,\n      ...span,\n    };\n  },\n\n  // TypeScript: signatures\n  tsPropertySignature(\n    key: t.PropertyKey,\n    opts: { typeAnnotation?: t.TSTypeAnnotation | null; computed?: boolean; optional?: boolean; readonly?: boolean } = {},\n  ): t.TSPropertySignature {\n    return {\n      type: \"TSPropertySignature\",\n      key,\n      typeAnnotation: opts.typeAnnotation ?? null,\n      computed: opts.computed ?? isComputedKey(key),\n      optional: opts.optional ?? false,\n      readonly: opts.readonly ?? false,\n      accessibility: null,\n      static: false,\n      ...span,\n    };\n  },\n  tsMethodSignature(\n    key: t.PropertyKey,\n    params: t.FunctionParameter[],\n    opts: {\n      kind?: t.TSMethodSignatureKind;\n      computed?: boolean;\n      optional?: boolean;\n      typeParameters?: t.TSTypeParameterDeclaration | null;\n      returnType?: t.TSTypeAnnotation | null;\n    } = {},\n  ): t.TSMethodSignature {\n    return {\n      type: \"TSMethodSignature\",\n      key,\n      computed: opts.computed ?? isComputedKey(key),\n      optional: opts.optional ?? false,\n      kind: opts.kind ?? \"method\",\n      typeParameters: opts.typeParameters ?? null,\n      params,\n      returnType: opts.returnType ?? null,\n      accessibility: null,\n      readonly: false,\n      static: false,\n      ...span,\n    };\n  },\n  tsCallSignatureDeclaration(\n    params: t.FunctionParameter[],\n    returnType: t.TSTypeAnnotation | null = null,\n    typeParameters: t.TSTypeParameterDeclaration | null = null,\n  ): t.TSCallSignatureDeclaration {\n    return { type: \"TSCallSignatureDeclaration\", typeParameters, params, returnType, ...span };\n  },\n  tsConstructSignatureDeclaration(\n    params: t.FunctionParameter[],\n    returnType: t.TSTypeAnnotation | null = null,\n    typeParameters: t.TSTypeParameterDeclaration | null = null,\n  ): t.TSConstructSignatureDeclaration {\n    return { type: \"TSConstructSignatureDeclaration\", typeParameters, params, returnType, ...span };\n  },\n  tsIndexSignature(\n    parameters: t.BindingIdentifier[],\n    typeAnnotation: t.TSTypeAnnotation,\n    opts: { readonly?: boolean; static?: boolean } = {},\n  ): t.TSIndexSignature {\n    return {\n      type: \"TSIndexSignature\",\n      parameters,\n      typeAnnotation,\n      readonly: opts.readonly ?? false,\n      static: opts.static ?? false,\n      accessibility: null,\n      ...span,\n    };\n  },\n\n  // TypeScript: declarations\n  tsTypeAliasDeclaration(\n    id: t.BindingIdentifier,\n    typeAnnotation: t.TSType,\n    opts: { typeParameters?: t.TSTypeParameterDeclaration | null; declare?: boolean } = {},\n  ): t.TSTypeAliasDeclaration {\n    return {\n      type: \"TSTypeAliasDeclaration\",\n      id,\n      typeParameters: opts.typeParameters ?? null,\n      typeAnnotation,\n      declare: opts.declare ?? false,\n      ...span,\n    };\n  },\n  tsInterfaceDeclaration(\n    id: t.BindingIdentifier,\n    body: t.TSInterfaceBody,\n    opts: { extends?: t.TSInterfaceHeritage[]; typeParameters?: t.TSTypeParameterDeclaration | null; declare?: boolean } = {},\n  ): t.TSInterfaceDeclaration {\n    return {\n      type: \"TSInterfaceDeclaration\",\n      id,\n      typeParameters: opts.typeParameters ?? null,\n      extends: opts.extends ?? [],\n      body,\n      declare: opts.declare ?? false,\n      ...span,\n    };\n  },\n  tsInterfaceBody(body: t.TSSignature[]): t.TSInterfaceBody {\n    return { type: \"TSInterfaceBody\", body, ...span };\n  },\n  tsInterfaceHeritage(\n    expression: t.Expression,\n    typeArguments: t.TSTypeParameterInstantiation | null = null,\n  ): t.TSInterfaceHeritage {\n    return { type: \"TSInterfaceHeritage\", expression, typeArguments, ...span };\n  },\n  tsClassImplements(\n    expression: t.Expression,\n    typeArguments: t.TSTypeParameterInstantiation | null = null,\n  ): t.TSClassImplements {\n    return { type: \"TSClassImplements\", expression, typeArguments, ...span };\n  },\n  tsEnumDeclaration(\n    id: t.BindingIdentifier,\n    body: t.TSEnumBody,\n    opts: { const?: boolean; declare?: boolean } = {},\n  ): t.TSEnumDeclaration {\n    return { type: \"TSEnumDeclaration\", id, body, const: opts.const ?? false, declare: opts.declare ?? false, ...span };\n  },\n  tsEnumBody(members: t.TSEnumMember[]): t.TSEnumBody {\n    return { type: \"TSEnumBody\", members, ...span };\n  },\n  tsEnumMember(id: t.TSEnumMemberName, initializer: t.Expression | null = null): t.TSEnumMember {\n    return { type: \"TSEnumMember\", id, initializer, computed: false, ...span };\n  },\n  tsModuleDeclaration(\n    id: t.TSModuleDeclaration[\"id\"],\n    body: t.TSModuleBlock | undefined,\n    opts: { kind?: t.TSModuleDeclarationKind; declare?: boolean; global?: boolean } = {},\n  ): t.TSModuleDeclaration {\n    return {\n      type: \"TSModuleDeclaration\",\n      id,\n      body,\n      kind: opts.kind ?? \"module\",\n      declare: opts.declare ?? false,\n      global: opts.global ?? false,\n      ...span,\n    };\n  },\n  tsModuleBlock(body: t.Statement[] = []): t.TSModuleBlock {\n    return { type: \"TSModuleBlock\", body, ...span };\n  },\n  tsParameterProperty(\n    parameter: t.BindingIdentifier | t.AssignmentPattern,\n    opts: { accessibility?: t.TSAccessibility | null; readonly?: boolean; override?: boolean; decorators?: t.Decorator[] } = {},\n  ): t.TSParameterProperty {\n    return {\n      type: \"TSParameterProperty\",\n      decorators: opts.decorators ?? [],\n      parameter,\n      override: opts.override ?? false,\n      readonly: opts.readonly ?? false,\n      accessibility: opts.accessibility ?? null,\n      static: false,\n      ...span,\n    };\n  },\n\n  // TypeScript: expressions and module statements\n  tsAsExpression(expression: t.Expression, typeAnnotation: t.TSType): t.TSAsExpression {\n    return { type: \"TSAsExpression\", expression, typeAnnotation, ...span };\n  },\n  tsSatisfiesExpression(expression: t.Expression, typeAnnotation: t.TSType): t.TSSatisfiesExpression {\n    return { type: \"TSSatisfiesExpression\", expression, typeAnnotation, ...span };\n  },\n  tsTypeAssertion(typeAnnotation: t.TSType, expression: t.Expression): t.TSTypeAssertion {\n    return { type: \"TSTypeAssertion\", typeAnnotation, expression, ...span };\n  },\n  tsNonNullExpression(expression: t.Expression): t.TSNonNullExpression {\n    return { type: \"TSNonNullExpression\", expression, ...span };\n  },\n  tsInstantiationExpression(\n    expression: t.Expression,\n    typeArguments: t.TSTypeParameterInstantiation,\n  ): t.TSInstantiationExpression {\n    return { type: \"TSInstantiationExpression\", expression, typeArguments, ...span };\n  },\n  tsExportAssignment(expression: t.Expression): t.TSExportAssignment {\n    return { type: \"TSExportAssignment\", expression, ...span };\n  },\n  tsNamespaceExportDeclaration(id: t.IdentifierName): t.TSNamespaceExportDeclaration {\n    return { type: \"TSNamespaceExportDeclaration\", id, ...span };\n  },\n  tsImportEqualsDeclaration(\n    id: t.BindingIdentifier,\n    moduleReference: t.TSModuleReference,\n    importKind: t.ImportOrExportKind = \"value\",\n  ): t.TSImportEqualsDeclaration {\n    return { type: \"TSImportEqualsDeclaration\", id, moduleReference, importKind, ...span };\n  },\n  tsExternalModuleReference(expression: t.StringLiteral): t.TSExternalModuleReference {\n    return { type: \"TSExternalModuleReference\", expression, ...span };\n  },\n  tsDeclareFunction(\n    id: t.BindingIdentifier | null,\n    params: t.FunctionParameter[],\n    opts: { async?: boolean; generator?: boolean; returnType?: t.TSTypeAnnotation | null; typeParameters?: t.TSTypeParameterDeclaration | null; declare?: boolean } = {},\n  ): t.TSDeclareFunction {\n    return {\n      type: \"TSDeclareFunction\",\n      id,\n      generator: opts.generator ?? false,\n      async: opts.async ?? false,\n      params,\n      body: null,\n      expression: false,\n      declare: opts.declare ?? false,\n      typeParameters: opts.typeParameters ?? null,\n      returnType: opts.returnType ?? null,\n      ...span,\n    };\n  },\n\n  tsEmptyBodyFunctionExpression(\n    params: t.FunctionParameter[],\n    opts: { id?: t.BindingIdentifier | null; returnType?: t.TSTypeAnnotation | null; typeParameters?: t.TSTypeParameterDeclaration | null } = {},\n  ): t.TSEmptyBodyFunctionExpression {\n    return {\n      type: \"TSEmptyBodyFunctionExpression\",\n      id: opts.id ?? null,\n      generator: false,\n      async: false,\n      params,\n      body: null,\n      expression: false,\n      declare: false,\n      typeParameters: opts.typeParameters ?? null,\n      returnType: opts.returnType ?? null,\n      ...span,\n    };\n  },\n\n  // Program\n  hashbang(value: string): t.Hashbang {\n    return { type: \"Hashbang\", value, ...span };\n  },\n  program(\n    body: Array<t.Statement | t.ModuleDeclaration | t.Directive> = [],\n    opts: { sourceType?: t.ModuleKind; hashbang?: t.Hashbang | null } = {},\n  ): t.Program {\n    return {\n      type: \"Program\",\n      sourceType: opts.sourceType ?? \"module\",\n      hashbang: opts.hashbang ?? null,\n      body,\n      ...span,\n    };\n  },\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "yuku-walk",
+  "version": "0.0.1",
+  "description": "A fast, typed AST walker for yuku-parser's ESTree / TypeScript-ESTree AST.",
+  "keywords": [
+    "ast",
+    "codemod",
+    "estree",
+    "javascript",
+    "transform",
+    "traverse",
+    "typescript",
+    "visitor",
+    "walker",
+    "yuku"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "bun test",
+    "type-check": "tsc --noEmit",
+    "lint": "oxlint",
+    "format": "oxfmt"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "oxfmt": "^0.51.0",
+    "oxlint": "^1.66.0",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "yuku-codegen": "^0.5.17",
+    "yuku-parser": "^0.5.17"
+  },
+  "peerDependencies": {
+    "yuku-parser": "^0.5.16"
+  }
+}