yuku-ast 0.1.2 → 0.1.3

package/README.md

@@ -6,6 +6,7 @@ node builders, type guards, a walker, and identifier validators. No runtime depe
 | Import                | Provides                                                     |
 | --------------------- | ------------------------------------------------------------ |
 | `yuku-ast`            | `walk`, `walkAsync`, `b` (node builders), `is` (type guards) |
+| `yuku-ast/utils`      | node utilities such as `nameOf`                              |
 | `yuku-ast/identifier` | identifier and reserved-word validators                      |
 
 ```ts
@@ -114,6 +115,9 @@ is.StringLiteral(node); // Literal variants
 is.StaticMemberExpression(node); // MemberExpression variants
 is.BindingIdentifier(node); // Identifier roles, via `kind`
 
+is.Identifier(node, "this"); // an Identifier with that exact name
+is.oneOf(node, ["CallExpression", "NewExpression"]); // any of these types
+
 walk(program, {
   Literal(node, path) {
     if (is.ArrayExpression(path.parent)) {
@@ -123,6 +127,32 @@ walk(program, {
 });
 ```
 
+`is.oneOf(node, types)` narrows to the union of the listed types, and
+`is.Identifier(node, name?)` narrows to `Identifier`. Both accept `null` or
+`undefined`.
+
+## Reading names (`nameOf`)
+
+`nameOf(node)` returns the static name a node denotes, an `Identifier`'s `name`
+or a string `Literal`'s `value`, and `null` for anything else (including `null`
+or `undefined`). It reads the common `Identifier | StringLiteral` slots, such as
+a `ModuleExportName` or a static property or member key, in one call.
+
+```ts
+import { walk } from "yuku-ast";
+import { nameOf } from "yuku-ast/utils";
+
+walk(program, {
+  ExportSpecifier(node) {
+    // `export { x as y }` and `export { x as "z" }` both resolve.
+    nameOf(node.exported); // "y", "z"
+  },
+  Property(node) {
+    if (!node.computed) nameOf(node.key); // static key name, else null
+  },
+});
+```
+
 ## Builders (`b`)
 
 A builder for every node type. Required fields are positional, the rest go in a

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 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";
+import { BigIntLiteral, BindingIdentifier, BooleanLiteral, ComputedMemberExpression, Directive, Identifier, IdentifierName, IdentifierReference, LabelIdentifier, Node, NullLiteral, NumericLiteral, PrivateFieldExpression, RegExpLiteral, StaticMemberExpression, StringLiteral } from "yuku-parser";
 
 //#region src/types.d.ts
 /** Discriminant `type` string of every AST node. */
@@ -95,6 +95,8 @@ type AliasMap = { [K in AliasName]: NodeOfType<(typeof ALIAS_GROUPS)[K][number]>
 //#region src/predicates.d.ts
 type MaybeNode = Node | null | undefined;
 declare const is: {
+  /** True when `node`'s `type` is one of `types`, narrowing to that union. */oneOf: <const K extends NodeType>(node: MaybeNode, types: readonly K[]) => node is NodeOfType<K>; /** An `Identifier`, optionally with the exact `name` (e.g. `is.Identifier(node, "this")`). */
+  Identifier: (node: MaybeNode, name?: string) => node is Identifier;
   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"];
@@ -120,37 +122,11 @@ declare const is: {
   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;
+  TSTypeAnnotation: (node: MaybeNode) => node is import("yuku-parser").TSTypeAnnotation;
+  Decorator: (node: MaybeNode) => node is import("yuku-parser").Decorator;
+  PrivateIdentifier: (node: MaybeNode) => node is import("yuku-parser").PrivateIdentifier;
   Literal: (node: MaybeNode) => node is NodeOfType<"Literal">;
+  TemplateElement: (node: MaybeNode) => node is import("yuku-parser").TemplateElement;
   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;
@@ -183,24 +159,19 @@ declare const is: {
   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;
+  RestElement: (node: MaybeNode) => node is import("yuku-parser").RestElement;
+  Property: (node: MaybeNode) => node is NodeOfType<"Property">;
+  SpreadElement: (node: MaybeNode) => node is import("yuku-parser").SpreadElement;
+  TSTypeParameterInstantiation: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameterInstantiation;
+  TSParameterProperty: (node: MaybeNode) => node is import("yuku-parser").TSParameterProperty;
+  BlockStatement: (node: MaybeNode) => node is import("yuku-parser").BlockStatement;
+  TSTypeParameterDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameterDeclaration;
+  FunctionDeclaration: (node: MaybeNode) => node is import("yuku-parser").FunctionDeclaration;
   ClassBody: (node: MaybeNode) => node is import("yuku-parser").ClassBody;
+  ClassDeclaration: (node: MaybeNode) => node is import("yuku-parser").ClassDeclaration;
   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;
@@ -208,27 +179,57 @@ declare const is: {
   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;
+  TSIndexSignature: (node: MaybeNode) => node is import("yuku-parser").TSIndexSignature;
   TSEmptyBodyFunctionExpression: (node: MaybeNode) => node is import("yuku-parser").TSEmptyBodyFunctionExpression;
+  ExpressionStatement: (node: MaybeNode) => node is NodeOfType<"ExpressionStatement">;
+  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;
+  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;
+  SwitchCase: (node: MaybeNode) => node is import("yuku-parser").SwitchCase;
+  CatchClause: (node: MaybeNode) => node is import("yuku-parser").CatchClause;
+  VariableDeclarator: (node: MaybeNode) => node is import("yuku-parser").VariableDeclarator;
   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;
+  ImportDeclaration: (node: MaybeNode) => node is import("yuku-parser").ImportDeclaration;
   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;
+  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;
   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;
+  JSXOpeningElement: (node: MaybeNode) => node is import("yuku-parser").JSXOpeningElement;
+  JSXText: (node: MaybeNode) => node is import("yuku-parser").JSXText;
+  JSXExpressionContainer: (node: MaybeNode) => node is import("yuku-parser").JSXExpressionContainer;
+  JSXSpreadChild: (node: MaybeNode) => node is import("yuku-parser").JSXSpreadChild;
+  JSXClosingElement: (node: MaybeNode) => node is import("yuku-parser").JSXClosingElement;
   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;
+  JSXOpeningFragment: (node: MaybeNode) => node is import("yuku-parser").JSXOpeningFragment;
+  JSXClosingFragment: (node: MaybeNode) => node is import("yuku-parser").JSXClosingFragment;
   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;
@@ -266,25 +267,25 @@ declare const is: {
   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;
+  TSTypeParameter: (node: MaybeNode) => node is import("yuku-parser").TSTypeParameter;
+  TSOptionalType: (node: MaybeNode) => node is import("yuku-parser").TSOptionalType;
+  TSRestType: (node: MaybeNode) => node is import("yuku-parser").TSRestType;
   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;
+  TSExportAssignment: (node: MaybeNode) => node is import("yuku-parser").TSExportAssignment;
+  TSNamespaceExportDeclaration: (node: MaybeNode) => node is import("yuku-parser").TSNamespaceExportDeclaration;
   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;
+  Hashbang: (node: MaybeNode) => node is import("yuku-parser").Hashbang;
+  Program: (node: MaybeNode) => node is import("yuku-parser").Program;
 };
 //#endregion
 //#region src/builders.d.ts

package/dist/index.mjs

@@ -548,6 +548,10 @@ function aliasGuard(name) {
 }
 const is = {
 	...Object.fromEntries(Object.keys(VISITOR_KEYS).map((type) => [type, (node) => node != null && node.type === type])),
+	/** True when `node`'s `type` is one of `types`, narrowing to that union. */
+	oneOf: (node, types) => node != null && types.includes(node.type),
+	/** An `Identifier`, optionally with the exact `name` (e.g. `is.Identifier(node, "this")`). */
+	Identifier: (node, name) => node?.type === "Identifier" && (name === void 0 || node.name === name),
 	Expression: aliasGuard("Expression"),
 	Statement: aliasGuard("Statement"),
 	Declaration: aliasGuard("Declaration"),

package/dist/utils.d.mts

@@ -0,0 +1,18 @@
+import { Node } from "yuku-parser";
+
+//#region src/utils/index.d.ts
+type MaybeNode = Node | null | undefined;
+/**
+ * The static name a node denotes: an `Identifier`'s `name`, or a string
+ * `Literal`'s `value`. Returns `null` for anything else, and for `null` or
+ * `undefined`, so the common `Identifier | StringLiteral` name slots (a
+ * `ModuleExportName`, or a static property or member key) read in one call.
+ *
+ * @example
+ * nameOf(b.identifier("x")) // "x"
+ * nameOf(b.stringLiteral("y")) // "y"
+ * nameOf(b.numericLiteral(1)) // null
+ */
+declare function nameOf(node: MaybeNode): string | null;
+//#endregion
+export { nameOf };

package/dist/utils.mjs

@@ -0,0 +1,20 @@
+//#region src/utils/index.ts
+/**
+* The static name a node denotes: an `Identifier`'s `name`, or a string
+* `Literal`'s `value`. Returns `null` for anything else, and for `null` or
+* `undefined`, so the common `Identifier | StringLiteral` name slots (a
+* `ModuleExportName`, or a static property or member key) read in one call.
+*
+* @example
+* nameOf(b.identifier("x")) // "x"
+* nameOf(b.stringLiteral("y")) // "y"
+* nameOf(b.numericLiteral(1)) // null
+*/
+function nameOf(node) {
+	if (node == null) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+//#endregion
+export { nameOf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuku-ast",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A fast, typed AST toolkit for yuku-parser's ESTree / TypeScript-ESTree AST: node builders, type guards, a walker, and identifier validators.",
   "keywords": [
     "ast",
@@ -30,6 +30,7 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./identifier": "./dist/identifier.mjs",
+    "./utils": "./dist/utils.mjs",
     "./package.json": "./package.json"
   },
   "scripts": {