@eslint-react/ast 5.2.0-next.0 → 5.2.1-beta.3

package/dist/index.d.ts

@@ -1,121 +1,5 @@
-import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
+import { TSESTree } from "@typescript-eslint/types";
 
-//#region src/node-types.d.ts
-/**
- * Represents function expressions and declarations in TSESTree
- */
-type TSESTreeFunction = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression;
-/**
- * Represents all function-related types including TypeScript function types
- */
-type TSESTreeFunctionType = TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSDeclareFunction | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignature | TSESTreeFunction;
-/**
- * Represents class declarations and expressions in TSESTree
- */
-type TSESTreeClass = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
-/**
- * Represents method definitions and property definitions in classes
- */
-type TSESTreeMethodOrProperty = TSESTree.PropertyDefinition | TSESTree.MethodDefinition;
-/**
- * Represents loop statements in TSESTree
- */
-type TSESTreeLoop = TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;
-/**
- * Represents TypeScript array and tuple types
- */
-type TSESTreeArrayTupleType = TSESTree.TSArrayType | TSESTree.TSTupleType;
-/**
- * Represents property-like nodes in TSESTree
- */
-type TSESTreeProperty = TSESTree.PropertyDefinition | TSESTree.TSIndexSignature | TSESTree.TSParameterProperty | TSESTree.TSPropertySignature;
-/**
- * Represents all JSX-related nodes in TSESTree
- * Note: This type is for type-level operations. The isJSX() runtime guard in node-is.ts
- * has a slightly different set of nodes as it includes JSXExpressionContainer which is
- * commonly needed for runtime checks but not included in this type union.
- */
-type TSESTreeJSX = TSESTree.JSXAttribute | TSESTree.JSXChild | TSESTree.JSXClosingElement | TSESTree.JSXClosingFragment | TSESTree.JSXEmptyExpression | TSESTree.JSXIdentifierToken | TSESTree.JSXOpeningElement | TSESTree.JSXOpeningFragment | TSESTree.JSXSpreadAttribute | TSESTree.JSXTagNameExpression | TSESTree.JSXTextToken;
-type TSESTreeJSXElementLike = TSESTree.JSXElement | TSESTree.JSXFragment;
-/**
- * Represents JSX attribute-like nodes (attributes and spread attributes)
- */
-type TSESTreeJSXAttributeLike = TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute;
-/**
- * Represents destructuring patterns in variable declarations
- */
-type TSESTreeDestructuringPattern = TSESTree.ArrayPattern | TSESTree.AssignmentPattern | TSESTree.ObjectPattern | TSESTree.RestElement;
-/**
- * Represents TypeScript type declaration nodes
- */
-type TSESTreeTypeDeclaration = TSESTree.TSInterfaceDeclaration | TSESTree.TSTypeAliasDeclaration;
-/**
- * Represents TypeScript type expression nodes (type assertions, non-null expressions, etc.)
- */
-type TSESTreeTypeExpression = TSESTree.TSAsExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.TSInstantiationExpression;
-/**
- * Represents TypeScript type assertion expressions (excluding instantiation expressions)
- */
-type TSESTreeTypeAssertionExpression = TSESTree.TSAsExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion;
-/**
- * Represents a directive expression statement in TSESTree (ex: "use strict";)
- */
-type TSESTreeDirective = TSESTree.ExpressionStatement & {
-  directive: string;
-  expression: TSESTree.StringLiteral;
-};
-/**
- * Represents a directive-like expression statement in TSESTree
- */
-type TSESTreeDirectiveLike = TSESTree.ExpressionStatement & {
-  expression: TSESTree.StringLiteral;
-};
-//#endregion
-//#region src/class-id.d.ts
-/**
- * Get the class identifier of a class node
- * @param node The class node to get the identifier from
- * @returns The class identifier or null if not found
- */
-declare function getClassId(node: TSESTreeClass): TSESTree.BindingName | null;
-//#endregion
-//#region src/directive-is.d.ts
-/**
- * Check if a node is a directive expression statement
- * @param node The node to check
- * @returns True if the node is a directive, false otherwise
- */
-declare function isDirective(node: TSESTree.Node): node is TSESTreeDirective;
-/**
- * Check if a node is a directive-like expression statement
- * @param node The node to check
- * @returns True if the node is a directive, false otherwise
- */
-declare function isDirectiveLike(node: TSESTree.Node): node is TSESTreeDirectiveLike;
-//#endregion
-//#region src/directive-kind.d.ts
-/**
- * Known directive kinds in React
- */
-type DirectiveKind = "use client" | "use server" | "use memo" | "use no memo";
-/**
- * Check if a node is a directive kind
- * @param kind The kind to check
- * @returns True if the kind is a directive kind, false otherwise
- */
-declare function isDirectiveKind(kind: string): kind is DirectiveKind;
-//#endregion
-//#region src/directive-name.d.ts
-/**
- * Check if a string is a directive name (heuristic check)
- * Note: This is a broad check that matches any string starting with "use ".
- * For strict validation against known directives, use isDirectiveKind.
- * @param name The string to check
- * @returns True if the string looks like a directive name, false otherwise
- * @see isDirectiveKind
- */
-declare function isDirectiveName(name: string): boolean;
-//#endregion
 //#region src/expression-is.d.ts
 /**
  * Check if the given expression is a 'this' expression
@@ -126,122 +10,14 @@ declare function isDirectiveName(name: string): boolean;
  */
 declare function isThisExpressionLoose(node: TSESTree.Expression): boolean;
 //#endregion
-//#region src/expression-nested.d.ts
-/**
- * Get all nested identifiers in a expression like node
- * @param node The node to get the nested identifiers from
- * @returns All nested identifiers
- */
-declare function getNestedIdentifiers(node: TSESTree.Node): readonly TSESTree.Identifier[];
-/**
- * Gets the nested return statements in the node that are within the same function
- * @param node The AST node
- * @returns The nested return statements in the node
- */
-declare function getNestedReturnStatements(node: TSESTree.Node): readonly TSESTree.ReturnStatement[];
-/**
- * Get all nested expressions of type T in an expression like node
- * @param type The type of the expression to retrieve within the node
- * @returns A partially applied function bound to a predicate of type AST. The returned function can be called passing a
- * node, and it will return an array of all nested expressions of type AST.
- */
-declare function getNestedExpressionsOfType<TNodeType extends AST_NODE_TYPES>(type: TNodeType): (node: TSESTree.Node) => Extract<TSESTree.Node, {
-  type: TNodeType;
-}>[];
-/**
- * Get all nested new expressions in an expression like node
- * @param node The node to get the nested new expressions from
- * @returns All nested new expressions
- */
-declare const getNestedNewExpressions: (node: TSESTree.Node) => TSESTree.NewExpression[];
-/**
- * Get all nested call expressions in a expression like node
- * @param node The node to get the nested call expressions from
- * @returns All nested call expressions
- */
-declare const getNestedCallExpressions: (node: TSESTree.Node) => TSESTree.CallExpression[];
-//#endregion
-//#region src/file-directive.d.ts
-/**
- * Get all directive expression statements from the top of a program AST node
- * @param node The program AST node
- * @returns The array of directive string literals (ex: "use strict")
- */
-declare function getFileDirectives(node: TSESTree.Program): TSESTreeDirective[];
+//#region src/file.d.ts
 /**
  * Check if a directive with the given name exists in the file directives
  * @param node The program AST node
  * @param name The directive name to check (ex: "use strict", "use memo", "use no memo")
  * @returns True if the directive exists, false otherwise
  */
-declare function isDirectiveInFile(node: TSESTree.Program, name: string): boolean;
-//#endregion
-//#region src/function-directive.d.ts
-/**
- * Get all directive expression statements from the top of a function AST node
- * @param node The function AST node
- * @returns The array of directive string literals (ex: "use memo", "use no memo")
- */
-declare function getFunctionDirectives(node: TSESTreeFunction): TSESTreeDirective[];
-/**
- * Check if a directive with the given name exists in the function directives
- * @param node The function AST node
- * @param name The directive name to check (ex: "use memo", "use no memo")
- * @returns True if the directive exists, false otherwise
- */
-declare function isDirectiveInFunction(node: TSESTreeFunction, name: string): boolean;
-//#endregion
-//#region src/function-id.d.ts
-/**
- * Gets the static name of a function AST node. For function declarations it is
- * easy. For anonymous function expressions it is much harder. If you search for
- * `IsAnonymousFunctionDefinition()` in the ECMAScript spec you'll find places
- * where JS gives anonymous function expressions names. We roughly detect the
- * same AST nodes with some exceptions to better fit our use case.
- */
-declare function getFunctionId(node: TSESTree.Expression | TSESTreeFunction): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | null;
-/**
- * Type representing the return type of getFunctionId
- */
-type FunctionID = ReturnType<typeof getFunctionId>;
-//#endregion
-//#region src/function-init-path.d.ts
-/**
- * Represents various AST paths for React component function declarations
- * Each tuple type represents a specific component definition pattern
- */
-type FunctionInitPath = readonly [TSESTree.FunctionDeclaration] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration | TSESTree.ClassExpression, TSESTree.ClassBody, TSESTree.MethodDefinition, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration | TSESTree.ClassExpression, TSESTree.ClassBody, TSESTree.PropertyDefinition, TSESTreeFunction];
-/**
- * Identifies the initialization path of a function node in the ast.
- * Determine what kind of component declaration pattern the function belongs to.
- *
- * @param node The function node to analyze
- * @returns The function initialization path or null if not identifiable
- */
-declare function getFunctionInitPath(node: TSESTreeFunction): null | FunctionInitPath;
-/**
- * Check if a specific function call exists in the function initialization path.
- * Useful for detecting HOCs like React.memo, React.forwardRef, etc.
- *
- * @param callName The name of the call to check for (ex: "memo", "forwardRef")
- * @param initPath The function initialization path to search in
- * @returns True if the call exists in the path, false otherwise
- */
-declare function hasCallInFunctionInitPath(callName: string, initPath: FunctionInitPath): boolean;
-//#endregion
-//#region src/function-is.d.ts
-/**
- * Check if a function is empty
- * @param node The function node to check
- * @returns True if the function is empty, false otherwise
- */
-declare function isFunctionEmpty(node: TSESTreeFunction): boolean;
-/**
- * Check if a function is immediately invoked
- * @param node The function node to check
- * @returns True if the function is immediately invoked, false otherwise
- */
-declare function isFunctionImmediatelyInvoked(node: TSESTreeFunction): boolean;
+declare function isFileHasDirective(node: TSESTree.Program, name: string): boolean;
 //#endregion
 //#region src/identifier-is.d.ts
 /**
@@ -252,16 +28,6 @@ declare function isFunctionImmediatelyInvoked(node: TSESTreeFunction): boolean;
  */
 declare function isIdentifier(node: TSESTree.Node | null, name?: string): node is TSESTree.Identifier;
 //#endregion
-//#region src/identifier-name.d.ts
-/**
- * Check if a string is a valid JavaScript identifier name
- * Note: This only checks for ASCII identifiers. Unicode identifiers (e.g., `const 变量 = 1`)
- * are not supported by this simple regex check.
- * @param name The string to check
- * @returns True if the string is a valid ASCII identifier name
- */
-declare function isIdentifierName(name: string): boolean;
-//#endregion
 //#region src/identifier-traverse.d.ts
 /**
  * Get the root identifier of a (possibly nested) member expression.
@@ -297,6 +63,40 @@ declare const isNodeEqual: {
   (a: TSESTree.Node, b: TSESTree.Node): boolean;
 };
 //#endregion
+//#region src/node-types.d.ts
+/**
+ * Represents function expressions and declarations in TSESTree
+ */
+type TSESTreeFunction = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression;
+/**
+ * Represents class declarations and expressions in TSESTree
+ */
+type TSESTreeClass = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+/**
+ * Represents method definitions and property definitions in classes
+ */
+type TSESTreeMethodOrProperty = TSESTree.PropertyDefinition | TSESTree.MethodDefinition;
+/**
+ * Represents all JSX-related nodes in TSESTree
+ * Note: This type is for type-level operations. The isJSX() runtime guard in node-is.ts
+ * has a slightly different set of nodes as it includes JSXExpressionContainer which is
+ * commonly needed for runtime checks but not included in this type union.
+ */
+type TSESTreeJSX = TSESTree.JSXAttribute | TSESTree.JSXChild | TSESTree.JSXClosingElement | TSESTree.JSXClosingFragment | TSESTree.JSXEmptyExpression | TSESTree.JSXIdentifierToken | TSESTree.JSXOpeningElement | TSESTree.JSXOpeningFragment | TSESTree.JSXSpreadAttribute | TSESTree.JSXTagNameExpression | TSESTree.JSXTextToken;
+type TSESTreeJSXElementLike = TSESTree.JSXElement | TSESTree.JSXFragment;
+/**
+ * Represents JSX attribute-like nodes (attributes and spread attributes)
+ */
+type TSESTreeJSXAttributeLike = TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute;
+/**
+ * Represents a directive expression statement in TSESTree (ex: "use strict";)
+ */
+type TSESTreeDirective = TSESTree.ExpressionStatement & {
+  directive: string;
+  expression: TSESTree.StringLiteral;
+};
+type TSESTreeTypeExpression = TSESTree.TSAsExpression | TSESTree.TSTypeAssertion | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSInstantiationExpression;
+//#endregion
 //#region src/node-is.d.ts
 /**
  * Type guard to check if a node is of a specific AST node type
@@ -320,12 +120,6 @@ declare const isOneOf: <NodeTypes extends readonly TSESTree.AST_NODE_TYPES[]>(no
  * @returns True if the node is a function
  */
 declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
-/**
- * Check if a node is a function type (including TypeScript function types)
- * @param node The node to check
- * @returns True if the node is a function type
- */
-declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSDeclareFunctionNoDeclare | TSESTree.TSDeclareFunctionWithDeclare | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
 /**
  * Check if a node is a class declaration or expression
  * @param node The node to check
@@ -350,16 +144,10 @@ declare const isProperty: (node: TSESTree.Node | null | undefined) => node is TS
  * @returns True if the node is a JSX element
  */
 declare const isJSXElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXElement;
-/**
- * Check if a node is a JSX fragment
- * @param node The node to check
- * @returns True if the node is a JSX fragment
- */
-declare const isJSXFragment: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXFragment;
 /**
  * Check if a node is a JSX element or JSX fragment
  */
-declare const isJSXElementLike: (data: TSESTree.Node | null | undefined) => data is TSESTree.JSXElement | TSESTree.JSXFragment;
+declare const isJSXElementLike: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXElement | TSESTree.JSXFragment;
 /**
  * Check if a node is a JSX tag name expression (identifier, member expression, or namespaced name)
  * @param node The node to check
@@ -375,24 +163,6 @@ declare const isJSXTagNameExpression: (node: TSESTree.Node | null | undefined) =
  * @see TSESTreeJSX
  */
 declare const isJSX: (node: TSESTree.Node | null | undefined) => node is TSESTree.JSXAttribute | TSESTree.JSXClosingElement | TSESTree.JSXClosingFragment | TSESTree.JSXElement | TSESTree.JSXEmptyExpression | TSESTree.JSXExpressionContainer | TSESTree.JSXFragment | TSESTree.JSXIdentifier | TSESTree.JSXMemberExpression | TSESTree.JSXNamespacedName | TSESTree.JSXOpeningElement | TSESTree.JSXOpeningFragment | TSESTree.JSXSpreadAttribute | TSESTree.JSXSpreadChild | TSESTree.JSXText;
-/**
- * Check if a node is a loop statement
- * @param node The node to check
- * @returns True if the node is a loop
- */
-declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;
-/**
- * Check if a node is a control flow statement (loop, if, or switch)
- * @param node The node to check
- * @returns True if the node is a control flow statement
- */
-declare const isControlFlow: (data: TSESTree.Node | null | undefined) => data is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.IfStatement | TSESTree.SwitchStatement | TSESTree.WhileStatement;
-/**
- * Check if a node is a conditional expression or control flow statement
- * @param node The node to check
- * @returns True if the node is conditional
- */
-declare const isConditional: (data: TSESTree.Node | null | undefined) => data is TSESTree.ConditionalExpression | TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.IfStatement | TSESTree.LogicalExpression | TSESTree.SwitchStatement | TSESTree.WhileStatement;
 /**
  * Check if a node is a TypeScript type expression
  * @param node The node to check
@@ -405,24 +175,20 @@ declare const isTypeExpression: (node: TSESTree.Node | null | undefined) => node
  * @returns True if the node is a type assertion expression
  */
 declare const isTypeAssertionExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion;
+/**
+ * Check if a node is a directive expression statement
+ * @param node The node to check
+ * @returns True if the node is a directive, false otherwise
+ */
+declare function isDirective(node: TSESTree.Node): node is TSESTreeDirective;
 //#endregion
 //#region src/node-kind.d.ts
 declare function getHumanReadableKind(node: TSESTree.Node, delimiter?: string): "RegExp literal" | Lowercase<string> | `JSX ${Lowercase<string>}`;
 //#endregion
-//#region src/node-line.d.ts
-declare function isMultiLine(node: TSESTree.Node): boolean;
-declare function isLineBreak(node: TSESTree.Node): boolean;
-//#endregion
 //#region src/node-name.d.ts
 declare function getFullyQualifiedName(node: TSESTree.Node, getText: (node: TSESTree.Node) => string): string;
 //#endregion
 //#region src/node-selectors.d.ts
-/**
- * Represents an arrow function expression with an implicit return
- */
-type ImplicitReturnArrowFunctionExpression = TSESTree.ArrowFunctionExpression & {
-  body: TSESTree.Expression;
-};
 /**
  * Represents a variable declarator with object destructuring and an identifier initializer
  */
@@ -442,10 +208,6 @@ type DisplayNameAssignmentExpression = TSESTree.AssignmentExpression & {
   operator: "=";
   right: TSESTree.Literal;
 };
-/**
- * Selector for arrow function expressions with implicit return
- */
-declare const SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION = "ArrowFunctionExpression[body.type!='BlockStatement']";
 /**
  * Selector for variable declarators with object destructuring
  */
@@ -480,26 +242,6 @@ declare function findParent(node: TSESTree.Node | null, test: (node: TSESTree.No
  */
 declare function getUnderlyingExpression(node: TSESTree.Node): Exclude<TSESTree.Node, TSESTreeTypeExpression>;
 //#endregion
-//#region src/pattern-process-env-node-env.d.ts
-/**
- * Check if the given node is a member expression that accesses `process.env.NODE_ENV`
- * @param node The AST node
- * @returns True if the node is a member expression that accesses `process.env.NODE_ENV`, false otherwise
- */
-declare function isProcessEnvNodeEnv(node: TSESTree.Node | null): node is TSESTree.MemberExpression;
-/**
- * Check if the given node is a binary expression that compares `process.env.NODE_ENV` with a string literal.
- * @param node The AST node
- * @param operator The operator used in the comparison
- * @param value The string literal value to compare against
- * @returns True if the node is a binary expression that compares `process.env.NODE_ENV` with the specified value, false otherwise
- */
-declare function isProcessEnvNodeEnvCompare(node: TSESTree.Node | null, operator: "===" | "!==", value: "development" | "production"): node is TSESTree.BinaryExpression;
-//#endregion
-//#region src/pattern-test-mock.d.ts
-declare function isTestMock(node: TSESTree.Node | null): node is TSESTree.MemberExpression;
-declare function isTestMockCallback(node: TSESTree.Node | null): boolean;
-//#endregion
 //#region src/property-name.d.ts
 /**
  * Get the name of a property from a node
@@ -520,4 +262,4 @@ declare function getPropertyName(node: TSESTree.Node): string | null;
  */
 declare function findProperty(properties: TSESTree.ObjectLiteralElement[], name: string): TSESTree.Property | null;
 //#endregion
-export { DirectiveKind, DisplayNameAssignmentExpression, FunctionID, FunctionInitPath, ImplicitReturnArrowFunctionExpression, ObjectDestructuringVariableDeclarator, SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, TSESTreeArrayTupleType, TSESTreeClass, TSESTreeDestructuringPattern, TSESTreeDirective, TSESTreeDirectiveLike, TSESTreeFunction, TSESTreeFunctionType, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeJSXElementLike, TSESTreeLoop, TSESTreeMethodOrProperty, TSESTreeProperty, TSESTreeTypeAssertionExpression, TSESTreeTypeDeclaration, TSESTreeTypeExpression, findParent, findProperty, getClassId, getFileDirectives, getFullyQualifiedName, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHumanReadableKind, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getRootIdentifier, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveInFile, isDirectiveInFunction, isDirectiveKind, isDirectiveLike, isDirectiveName, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifier, isIdentifierName, isJSX, isJSXElement, isJSXElementLike, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isTestMock, isTestMockCallback, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression };
+export { DisplayNameAssignmentExpression, ObjectDestructuringVariableDeclarator, SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, TSESTreeClass, TSESTreeDirective, TSESTreeFunction, TSESTreeJSX, TSESTreeJSXAttributeLike, TSESTreeJSXElementLike, TSESTreeMethodOrProperty, TSESTreeTypeExpression, findParent, findProperty, getFullyQualifiedName, getHumanReadableKind, getPropertyName, getRootIdentifier, getUnderlyingExpression, is, isClass, isDirective, isFileHasDirective, isFunction, isIdentifier, isJSX, isJSXElement, isJSXElementLike, isJSXTagNameExpression, isLiteral, isMethodOrProperty, isNodeEqual, isOneOf, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression };

package/dist/index.js

@@ -1,200 +1,7 @@
 import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
 import { ASTUtils } from "@typescript-eslint/utils";
-import { simpleTraverse } from "@typescript-eslint/typescript-estree";
 import { delimiterCase, replace, toLowerCase } from "string-ts";
 
-//#region src/class-id.ts
-/**
-* Get the class identifier of a class node
-* @param node The class node to get the identifier from
-* @returns The class identifier or null if not found
-*/
-function getClassId(node) {
-	if (node.id != null) return node.id;
-	if (node.parent.type === AST_NODE_TYPES.VariableDeclarator) return node.parent.id;
-	return null;
-}
-
-//#endregion
-//#region src/directive-name.ts
-/**
-* Check if a string is a directive name (heuristic check)
-* Note: This is a broad check that matches any string starting with "use ".
-* For strict validation against known directives, use isDirectiveKind.
-* @param name The string to check
-* @returns True if the string looks like a directive name, false otherwise
-* @see isDirectiveKind
-*/
-function isDirectiveName(name) {
-	return name.startsWith("use ") && name.length > 4;
-}
-
-//#endregion
-//#region src/literal-is.ts
-function isLiteral(node, type) {
-	if (node.type !== AST_NODE_TYPES.Literal) return false;
-	if (type == null) return true;
-	switch (type) {
-		case "boolean": return typeof node.value === "boolean";
-		case "null": return node.value === null;
-		case "number": return typeof node.value === "number";
-		case "regexp": return "regex" in node;
-		case "string": return typeof node.value === "string";
-	}
-}
-
-//#endregion
-//#region src/directive-is.ts
-/**
-* Check if a node is a directive expression statement
-* @param node The node to check
-* @returns True if the node is a directive, false otherwise
-*/
-function isDirective(node) {
-	return node.type === AST_NODE_TYPES.ExpressionStatement && node.directive != null;
-}
-/**
-* Check if a node is a directive-like expression statement
-* @param node The node to check
-* @returns True if the node is a directive, false otherwise
-*/
-function isDirectiveLike(node) {
-	return node.type === AST_NODE_TYPES.ExpressionStatement && isLiteral(node.expression, "string") && isDirectiveName(node.expression.value);
-}
-
-//#endregion
-//#region src/directive-kind.ts
-/**
-* Check if a node is a directive kind
-* @param kind The kind to check
-* @returns True if the kind is a directive kind, false otherwise
-*/
-function isDirectiveKind(kind) {
-	return kind === "use client" || kind === "use server" || kind === "use memo" || kind === "use no memo";
-}
-
-//#endregion
-//#region ../../../.pkgs/eff/dist/index.js
-function or(a, b) {
-	return (data) => a(data) || b(data);
-}
-/**
-* Creates a function that can be used in a data-last (aka `pipe`able) or
-* data-first style.
-*
-* The first parameter to `dual` is either the arity of the uncurried function
-* or a predicate that determines if the function is being used in a data-first
-* or data-last style.
-*
-* Using the arity is the most common use case, but there are some cases where
-* you may want to use a predicate. For example, if you have a function that
-* takes an optional argument, you can use a predicate to determine if the
-* function is being used in a data-first or data-last style.
-*
-* You can pass either the arity of the uncurried function or a predicate
-* which determines if the function is being used in a data-first or
-* data-last style.
-*
-* **Example** (Using arity to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using call signatures to define the overloads)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using a predicate to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body - The function to be curried.
-* @since 1.0.0
-*/
-const dual = function(arity, body) {
-	if (typeof arity === "function") return function() {
-		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
-	};
-	switch (arity) {
-		case 0:
-		case 1: throw new RangeError(`Invalid arity ${arity}`);
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body(a, b);
-			return function(self) {
-				return body(self, a);
-			};
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body(a, b, c);
-			return function(self) {
-				return body(self, a, b);
-			};
-		};
-		default: return function() {
-			if (arguments.length >= arity) return body.apply(this, arguments);
-			const args = arguments;
-			return function(self) {
-				return body(self, ...args);
-			};
-		};
-	}
-};
-/**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
-*
-* @param self - The first function to apply (or the composed function in data-last style).
-* @param bc - The second function to apply.
-* @returns A composed function that applies both functions in sequence.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { compose } from "effect/Function"
-*
-* const increment = (n: number) => n + 1;
-* const square = (n: number) => n * n;
-*
-* assert.strictEqual(compose(increment, square)(2), 9);
-* ```
-*
-* @since 1.0.0
-*/
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-
-//#endregion
 //#region src/node-is.ts
 /**
 * Type guard to check if a node is of a specific AST node type
@@ -219,22 +26,6 @@ const isFunction = isOneOf([
 	AST_NODE_TYPES.FunctionExpression
 ]);
 /**
-* Check if a node is a function type (including TypeScript function types)
-* @param node The node to check
-* @returns True if the node is a function type
-*/
-const isFunctionType = isOneOf([
-	AST_NODE_TYPES.ArrowFunctionExpression,
-	AST_NODE_TYPES.FunctionDeclaration,
-	AST_NODE_TYPES.FunctionExpression,
-	AST_NODE_TYPES.TSCallSignatureDeclaration,
-	AST_NODE_TYPES.TSConstructSignatureDeclaration,
-	AST_NODE_TYPES.TSDeclareFunction,
-	AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
-	AST_NODE_TYPES.TSFunctionType,
-	AST_NODE_TYPES.TSMethodSignature
-]);
-/**
 * Check if a node is a class declaration or expression
 * @param node The node to check
 * @returns True if the node is a class
@@ -264,15 +55,9 @@ const isProperty = isOneOf([
 */
 const isJSXElement = is(AST_NODE_TYPES.JSXElement);
 /**
-* Check if a node is a JSX fragment
-* @param node The node to check
-* @returns True if the node is a JSX fragment
-*/
-const isJSXFragment = is(AST_NODE_TYPES.JSXFragment);
-/**
 * Check if a node is a JSX element or JSX fragment
 */
-const isJSXElementLike = or(isJSXElement, isJSXFragment);
+const isJSXElementLike = isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment]);
 /**
 * Check if a node is a JSX tag name expression (identifier, member expression, or namespaced name)
 * @param node The node to check
@@ -309,30 +94,6 @@ const isJSX = isOneOf([
 	AST_NODE_TYPES.JSXText
 ]);
 /**
-* Check if a node is a loop statement
-* @param node The node to check
-* @returns True if the node is a loop
-*/
-const isLoop = isOneOf([
-	AST_NODE_TYPES.DoWhileStatement,
-	AST_NODE_TYPES.ForInStatement,
-	AST_NODE_TYPES.ForOfStatement,
-	AST_NODE_TYPES.ForStatement,
-	AST_NODE_TYPES.WhileStatement
-]);
-/**
-* Check if a node is a control flow statement (loop, if, or switch)
-* @param node The node to check
-* @returns True if the node is a control flow statement
-*/
-const isControlFlow = or(isLoop, isOneOf([AST_NODE_TYPES.IfStatement, AST_NODE_TYPES.SwitchStatement]));
-/**
-* Check if a node is a conditional expression or control flow statement
-* @param node The node to check
-* @returns True if the node is conditional
-*/
-const isConditional = or(isControlFlow, isOneOf([AST_NODE_TYPES.LogicalExpression, AST_NODE_TYPES.ConditionalExpression]));
-/**
 * Check if a node is a TypeScript type expression
 * @param node The node to check
 * @returns True if the node is a type expression
@@ -355,6 +116,14 @@ const isTypeAssertionExpression = isOneOf([
 	AST_NODE_TYPES.TSNonNullExpression,
 	AST_NODE_TYPES.TSSatisfiesExpression
 ]);
+/**
+* Check if a node is a directive expression statement
+* @param node The node to check
+* @returns True if the node is a directive, false otherwise
+*/
+function isDirective(node) {
+	return node.type === AST_NODE_TYPES.ExpressionStatement && node.directive != null;
+}
 
 //#endregion
 //#region src/node-unwrap.ts
@@ -383,372 +152,16 @@ function isThisExpressionLoose(node) {
 }
 
 //#endregion
-//#region src/node-traverse.ts
-function findParent(node, test) {
-	if (node == null) return null;
-	let parent = node.parent;
-	while (parent != null && parent.type !== AST_NODE_TYPES.Program) {
-		if (test(parent)) return parent;
-		parent = parent.parent;
-	}
-	return null;
-}
-
-//#endregion
-//#region src/expression-nested.ts
-/**
-* Get all nested identifiers in a expression like node
-* @param node The node to get the nested identifiers from
-* @returns All nested identifiers
-*/
-function getNestedIdentifiers(node) {
-	const identifiers = [];
-	if (node.type === AST_NODE_TYPES.Identifier) identifiers.push(node);
-	if ("arguments" in node) {
-		const chunk = node.arguments.flatMap(getNestedIdentifiers);
-		identifiers.push(...chunk);
-	}
-	if ("elements" in node) {
-		const chunk = node.elements.filter((x) => x != null).flatMap(getNestedIdentifiers);
-		identifiers.push(...chunk);
-	}
-	if ("properties" in node) {
-		const chunk = node.properties.flatMap(getNestedIdentifiers);
-		identifiers.push(...chunk);
-	}
-	if ("expressions" in node) {
-		const chunk = node.expressions.flatMap(getNestedIdentifiers);
-		identifiers.push(...chunk);
-	}
-	if ("left" in node) {
-		const chunk = getNestedIdentifiers(node.left);
-		identifiers.push(...chunk);
-	}
-	if ("right" in node) {
-		const chunk = getNestedIdentifiers(node.right);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.Property) {
-		const chunk = getNestedIdentifiers(node.value);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.SpreadElement) {
-		const chunk = getNestedIdentifiers(node.argument);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.MemberExpression) {
-		identifiers.push(...getNestedIdentifiers(node.object));
-		if (node.computed) identifiers.push(...getNestedIdentifiers(node.property));
-	}
-	if (node.type === AST_NODE_TYPES.UnaryExpression) {
-		const chunk = getNestedIdentifiers(node.argument);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.ChainExpression) {
-		const chunk = getNestedIdentifiers(node.expression);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.TSNonNullExpression) {
-		const chunk = getNestedIdentifiers(node.expression);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.TSAsExpression) {
-		const chunk = getNestedIdentifiers(node.expression);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.TSSatisfiesExpression) {
-		const chunk = getNestedIdentifiers(node.expression);
-		identifiers.push(...chunk);
-	}
-	if (node.type === AST_NODE_TYPES.ConditionalExpression) {
-		identifiers.push(...getNestedIdentifiers(node.test));
-		identifiers.push(...getNestedIdentifiers(node.consequent));
-		identifiers.push(...getNestedIdentifiers(node.alternate));
-	}
-	if (node.type === AST_NODE_TYPES.AwaitExpression) identifiers.push(...getNestedIdentifiers(node.argument));
-	if (node.type === AST_NODE_TYPES.YieldExpression && node.argument != null) identifiers.push(...getNestedIdentifiers(node.argument));
-	if (node.type === AST_NODE_TYPES.UpdateExpression) identifiers.push(...getNestedIdentifiers(node.argument));
-	if (node.type === AST_NODE_TYPES.CallExpression || node.type === AST_NODE_TYPES.NewExpression) identifiers.push(...getNestedIdentifiers(node.callee));
-	if (node.type === AST_NODE_TYPES.TaggedTemplateExpression) {
-		identifiers.push(...getNestedIdentifiers(node.tag));
-		identifiers.push(...getNestedIdentifiers(node.quasi));
-	}
-	if (node.type === AST_NODE_TYPES.ImportExpression) identifiers.push(...getNestedIdentifiers(node.source));
-	if (node.type === AST_NODE_TYPES.TSTypeAssertion) identifiers.push(...getNestedIdentifiers(node.expression));
-	if (node.type === AST_NODE_TYPES.TSInstantiationExpression) identifiers.push(...getNestedIdentifiers(node.expression));
-	return identifiers;
-}
-/**
-* Gets the nested return statements in the node that are within the same function
-* @param node The AST node
-* @returns The nested return statements in the node
-*/
-function getNestedReturnStatements(node) {
-	const statements = [];
-	const boundaryNode = isFunction(node) ? node : findParent(node, isFunction);
-	simpleTraverse(node, { enter(node) {
-		if (node.type !== AST_NODE_TYPES.ReturnStatement) return;
-		if (findParent(node, isFunction) !== boundaryNode) return;
-		statements.push(node);
-	} });
-	return statements;
-}
-/**
-* Get all nested expressions of type T in an expression like node
-* @param type The type of the expression to retrieve within the node
-* @returns A partially applied function bound to a predicate of type AST. The returned function can be called passing a
-* node, and it will return an array of all nested expressions of type AST.
-*/
-function getNestedExpressionsOfType(type) {
-	const isNodeOfType = is(type);
-	const recurse = (node) => {
-		const expressions = [];
-		if (isNodeOfType(node)) expressions.push(node);
-		if ("arguments" in node) {
-			const chunk = node.arguments.flatMap(recurse);
-			expressions.push(...chunk);
-		}
-		if ("expression" in node && node.expression !== true && node.expression !== false) {
-			const chunk = recurse(node.expression);
-			expressions.push(...chunk);
-		}
-		if ("left" in node) {
-			const chunk = recurse(node.left);
-			expressions.push(...chunk);
-		}
-		if ("right" in node) {
-			const chunk = recurse(node.right);
-			expressions.push(...chunk);
-		}
-		if ("test" in node && node.test != null) {
-			const chunk = recurse(node.test);
-			expressions.push(...chunk);
-		}
-		if ("consequent" in node) {
-			const chunk = Array.isArray(node.consequent) ? node.consequent.flatMap(recurse) : recurse(node.consequent);
-			expressions.push(...chunk);
-		}
-		if ("alternate" in node && node.alternate != null) {
-			const chunk = Array.isArray(node.alternate) ? node.alternate.flatMap(recurse) : recurse(node.alternate);
-			expressions.push(...chunk);
-		}
-		if ("elements" in node) {
-			const chunk = node.elements.filter((x) => x != null).flatMap(recurse);
-			expressions.push(...chunk);
-		}
-		if ("properties" in node) {
-			const chunk = node.properties.flatMap(recurse);
-			expressions.push(...chunk);
-		}
-		if ("expressions" in node) {
-			const chunk = node.expressions.flatMap(recurse);
-			expressions.push(...chunk);
-		}
-		if (node.type === AST_NODE_TYPES.Property) {
-			const chunk = recurse(node.value);
-			expressions.push(...chunk);
-		}
-		if (node.type === AST_NODE_TYPES.SpreadElement) {
-			const chunk = recurse(node.argument);
-			expressions.push(...chunk);
-		}
-		if (node.type === AST_NODE_TYPES.MemberExpression) {
-			expressions.push(...recurse(node.object));
-			if (node.computed) expressions.push(...recurse(node.property));
-		}
-		if (node.type === AST_NODE_TYPES.UnaryExpression) {
-			const chunk = recurse(node.argument);
-			expressions.push(...chunk);
-		}
-		if (node.type === AST_NODE_TYPES.AwaitExpression) expressions.push(...recurse(node.argument));
-		if (node.type === AST_NODE_TYPES.YieldExpression && node.argument != null) expressions.push(...recurse(node.argument));
-		if (node.type === AST_NODE_TYPES.UpdateExpression) expressions.push(...recurse(node.argument));
-		if (node.type === AST_NODE_TYPES.CallExpression || node.type === AST_NODE_TYPES.NewExpression) expressions.push(...recurse(node.callee));
-		if (node.type === AST_NODE_TYPES.TaggedTemplateExpression) {
-			expressions.push(...recurse(node.tag));
-			expressions.push(...recurse(node.quasi));
-		}
-		if (node.type === AST_NODE_TYPES.ImportExpression) expressions.push(...recurse(node.source));
-		return expressions;
-	};
-	return recurse;
-}
-/**
-* Get all nested new expressions in an expression like node
-* @param node The node to get the nested new expressions from
-* @returns All nested new expressions
-*/
-const getNestedNewExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.NewExpression);
-/**
-* Get all nested call expressions in a expression like node
-* @param node The node to get the nested call expressions from
-* @returns All nested call expressions
-*/
-const getNestedCallExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.CallExpression);
-
-//#endregion
-//#region src/file-directive.ts
-/**
-* Get all directive expression statements from the top of a program AST node
-* @param node The program AST node
-* @returns The array of directive string literals (ex: "use strict")
-*/
-function getFileDirectives(node) {
-	const directives = [];
-	for (const stmt of node.body) {
-		if (!isDirective(stmt)) continue;
-		directives.push(stmt);
-	}
-	return directives;
-}
+//#region src/file.ts
 /**
 * Check if a directive with the given name exists in the file directives
 * @param node The program AST node
 * @param name The directive name to check (ex: "use strict", "use memo", "use no memo")
 * @returns True if the directive exists, false otherwise
 */
-function isDirectiveInFile(node, name) {
-	return getFileDirectives(node).some((d) => d.directive === name);
-}
-
-//#endregion
-//#region src/function-directive.ts
-/**
-* Get all directive expression statements from the top of a function AST node
-* @param node The function AST node
-* @returns The array of directive string literals (ex: "use memo", "use no memo")
-*/
-function getFunctionDirectives(node) {
-	const directives = [];
-	if (node.body.type !== AST_NODE_TYPES.BlockStatement) return directives;
-	for (const stmt of node.body.body) {
-		if (!isDirective(stmt)) continue;
-		directives.push(stmt);
-	}
-	return directives;
-}
-/**
-* Check if a directive with the given name exists in the function directives
-* @param node The function AST node
-* @param name The directive name to check (ex: "use memo", "use no memo")
-* @returns True if the directive exists, false otherwise
-*/
-function isDirectiveInFunction(node, name) {
-	return getFunctionDirectives(node).some((d) => d.directive === name);
-}
-
-//#endregion
-//#region src/function-id.ts
-/**
-* Gets the static name of a function AST node. For function declarations it is
-* easy. For anonymous function expressions it is much harder. If you search for
-* `IsAnonymousFunctionDefinition()` in the ECMAScript spec you'll find places
-* where JS gives anonymous function expressions names. We roughly detect the
-* same AST nodes with some exceptions to better fit our use case.
-*/
-function getFunctionId(node) {
-	switch (true) {
-		case "id" in node && node.id != null: return node.id;
-		case node.parent.type === AST_NODE_TYPES.VariableDeclarator && node.parent.init === node: return node.parent.id;
-		case node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.right === node && node.parent.operator === "=": return node.parent.left;
-		case node.parent.type === AST_NODE_TYPES.Property && node.parent.value === node && !node.parent.computed: return node.parent.key;
-		case isMethodOrProperty(node.parent) && node.parent.value === node: return node.parent.key;
-		case node.parent.type === AST_NODE_TYPES.AssignmentPattern && node.parent.right === node: return node.parent.left;
-		case node.parent.type === AST_NODE_TYPES.ConditionalExpression: return getFunctionId(node.parent);
-		case isTypeAssertionExpression(node.parent): return getFunctionId(node.parent);
-	}
-	return null;
-}
-
-//#endregion
-//#region src/function-init-path.ts
-/**
-* Identifies the initialization path of a function node in the ast.
-* Determine what kind of component declaration pattern the function belongs to.
-*
-* @param node The function node to analyze
-* @returns The function initialization path or null if not identifiable
-*/
-function getFunctionInitPath(node) {
-	if (node.type === AST_NODE_TYPES.FunctionDeclaration) return [node];
-	let parent = node.parent;
-	while (isTypeExpression(parent)) parent = parent.parent;
-	switch (true) {
-		case parent.type === AST_NODE_TYPES.VariableDeclarator: return [
-			parent.parent,
-			parent,
-			node
-		];
-		case parent.type === AST_NODE_TYPES.CallExpression && parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
-			parent.parent.parent,
-			parent.parent,
-			parent,
-			node
-		];
-		case parent.type === AST_NODE_TYPES.CallExpression && parent.parent.type === AST_NODE_TYPES.CallExpression && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
-			parent.parent.parent.parent,
-			parent.parent.parent,
-			parent.parent,
-			parent,
-			node
-		];
-		case parent.type === AST_NODE_TYPES.Property && parent.parent.type === AST_NODE_TYPES.ObjectExpression && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
-			parent.parent.parent.parent,
-			parent.parent.parent,
-			parent.parent,
-			parent,
-			node
-		];
-		case parent.type === AST_NODE_TYPES.MethodDefinition: return [
-			parent.parent.parent,
-			parent.parent,
-			parent,
-			node
-		];
-		case parent.type === AST_NODE_TYPES.PropertyDefinition: return [
-			parent.parent.parent,
-			parent.parent,
-			parent,
-			node
-		];
-	}
-	return null;
-}
-/**
-* Check if a specific function call exists in the function initialization path.
-* Useful for detecting HOCs like React.memo, React.forwardRef, etc.
-*
-* @param callName The name of the call to check for (ex: "memo", "forwardRef")
-* @param initPath The function initialization path to search in
-* @returns True if the call exists in the path, false otherwise
-*/
-function hasCallInFunctionInitPath(callName, initPath) {
-	return initPath.some((node) => {
-		if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-		const { callee } = node;
-		if (callee.type === AST_NODE_TYPES.Identifier) return callee.name === callName;
-		if (callee.type === AST_NODE_TYPES.MemberExpression && "name" in callee.property) return callee.property.name === callName;
-		return false;
-	});
-}
-
-//#endregion
-//#region src/function-is.ts
-/**
-* Check if a function is empty
-* @param node The function node to check
-* @returns True if the function is empty, false otherwise
-*/
-function isFunctionEmpty(node) {
-	return node.body.type === AST_NODE_TYPES.BlockStatement && node.body.body.length === 0;
-}
-/**
-* Check if a function is immediately invoked
-* @param node The function node to check
-* @returns True if the function is immediately invoked, false otherwise
-*/
-function isFunctionImmediatelyInvoked(node) {
-	return node.type !== AST_NODE_TYPES.FunctionDeclaration && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node;
+function isFileHasDirective(node, name) {
+	for (const stmt of node.body) if (isDirective(stmt) && stmt.directive === name) return true;
+	return false;
 }
 
 //#endregion
@@ -763,19 +176,6 @@ function isIdentifier(node, name) {
 	return node != null && node.type === AST_NODE_TYPES.Identifier && (name == null || node.name === name);
 }
 
-//#endregion
-//#region src/identifier-name.ts
-/**
-* Check if a string is a valid JavaScript identifier name
-* Note: This only checks for ASCII identifiers. Unicode identifiers (e.g., `const 变量 = 1`)
-* are not supported by this simple regex check.
-* @param name The string to check
-* @returns True if the string is a valid ASCII identifier name
-*/
-function isIdentifierName(name) {
-	return /^[A-Z$_][\w$]*$/i.test(name);
-}
-
 //#endregion
 //#region src/identifier-traverse.ts
 /**
@@ -793,6 +193,138 @@ function getRootIdentifier(node) {
 	}
 }
 
+//#endregion
+//#region src/literal-is.ts
+function isLiteral(node, type) {
+	if (node.type !== AST_NODE_TYPES.Literal) return false;
+	if (type == null) return true;
+	switch (type) {
+		case "boolean": return typeof node.value === "boolean";
+		case "null": return node.value === null;
+		case "number": return typeof node.value === "number";
+		case "regexp": return "regex" in node;
+		case "string": return typeof node.value === "string";
+	}
+}
+
+//#endregion
+//#region ../../.pkgs/eff/dist/index.js
+/**
+* Creates a function that can be used in a data-last (aka `pipe`able) or
+* data-first style.
+*
+* The first parameter to `dual` is either the arity of the uncurried function
+* or a predicate that determines if the function is being used in a data-first
+* or data-last style.
+*
+* Using the arity is the most common use case, but there are some cases where
+* you may want to use a predicate. For example, if you have a function that
+* takes an optional argument, you can use a predicate to determine if the
+* function is being used in a data-first or data-last style.
+*
+* You can pass either the arity of the uncurried function or a predicate
+* which determines if the function is being used in a data-first or
+* data-last style.
+*
+* **Example** (Using arity to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using call signatures to define the overloads)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using a predicate to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
+* @since 1.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { compose } from "effect/Function"
+*
+* const increment = (n: number) => n + 1;
+* const square = (n: number) => n * n;
+*
+* assert.strictEqual(compose(increment, square)(2), 9);
+* ```
+*
+* @since 1.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+
 //#endregion
 //#region src/node-equality.ts
 /**
@@ -849,15 +381,6 @@ function getHumanReadableKind(node, delimiter = " ") {
 	return toLowerCase(delimiterCase(node.type, delimiter));
 }
 
-//#endregion
-//#region src/node-line.ts
-function isMultiLine(node) {
-	return node.loc.start.line !== node.loc.end.line;
-}
-function isLineBreak(node) {
-	return isOneOf([AST_NODE_TYPES.Literal, AST_NODE_TYPES.JSXText])(node) && typeof node.value === "string" && node.value.trim() === "" && isMultiLine(node);
-}
-
 //#endregion
 //#region src/node-name.ts
 function getFullyQualifiedName(node, getText) {
@@ -877,10 +400,6 @@ function getFullyQualifiedName(node, getText) {
 //#endregion
 //#region src/node-selectors.ts
 /**
-* Selector for arrow function expressions with implicit return
-*/
-const SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION = "ArrowFunctionExpression[body.type!='BlockStatement']";
-/**
 * Selector for variable declarators with object destructuring
 */
 const SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR = [
@@ -899,38 +418,15 @@ const SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION = [
 ].join("");
 
 //#endregion
-//#region src/pattern-process-env-node-env.ts
-/**
-* Check if the given node is a member expression that accesses `process.env.NODE_ENV`
-* @param node The AST node
-* @returns True if the node is a member expression that accesses `process.env.NODE_ENV`, false otherwise
-*/
-function isProcessEnvNodeEnv(node) {
-	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.MemberExpression && node.object.object.type === AST_NODE_TYPES.Identifier && node.object.object.name === "process" && node.object.property.type === AST_NODE_TYPES.Identifier && node.object.property.name === "env" && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "NODE_ENV";
-}
-/**
-* Check if the given node is a binary expression that compares `process.env.NODE_ENV` with a string literal.
-* @param node The AST node
-* @param operator The operator used in the comparison
-* @param value The string literal value to compare against
-* @returns True if the node is a binary expression that compares `process.env.NODE_ENV` with the specified value, false otherwise
-*/
-function isProcessEnvNodeEnvCompare(node, operator, value) {
-	if (node == null) return false;
-	if (node.type !== AST_NODE_TYPES.BinaryExpression) return false;
-	if (node.operator !== operator) return false;
-	if (isProcessEnvNodeEnv(node.left) && isLiteral(node.right, "string")) return node.right.value === value;
-	if (isLiteral(node.left, "string") && isProcessEnvNodeEnv(node.right)) return node.left.value === value;
-	return false;
-}
-
-//#endregion
-//#region src/pattern-test-mock.ts
-function isTestMock(node) {
-	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "mock";
-}
-function isTestMockCallback(node) {
-	return node != null && isFunction(node) && node.parent.type === AST_NODE_TYPES.CallExpression && isTestMock(node.parent.callee) && node.parent.arguments[1] === node;
+//#region src/node-traverse.ts
+function findParent(node, test) {
+	if (node == null) return null;
+	let parent = node.parent;
+	while (parent != null && parent.type !== AST_NODE_TYPES.Program) {
+		if (test(parent)) return parent;
+		parent = parent.parent;
+	}
+	return null;
 }
 
 //#endregion
@@ -971,4 +467,4 @@ function findProperty(properties, name) {
 }
 
 //#endregion
-export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_IMPLICIT_RETURN_ARROW_FUNCTION_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParent, findProperty, getClassId, getFileDirectives, getFullyQualifiedName, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHumanReadableKind, getNestedCallExpressions, getNestedExpressionsOfType, getNestedIdentifiers, getNestedNewExpressions, getNestedReturnStatements, getPropertyName, getRootIdentifier, getUnderlyingExpression, hasCallInFunctionInitPath, is, isClass, isConditional, isControlFlow, isDirective, isDirectiveInFile, isDirectiveInFunction, isDirectiveKind, isDirectiveLike, isDirectiveName, isFunction, isFunctionEmpty, isFunctionImmediatelyInvoked, isFunctionType, isIdentifier, isIdentifierName, isJSX, isJSXElement, isJSXElementLike, isJSXFragment, isJSXTagNameExpression, isLineBreak, isLiteral, isLoop, isMethodOrProperty, isMultiLine, isNodeEqual, isOneOf, isProcessEnvNodeEnv, isProcessEnvNodeEnvCompare, isProperty, isTestMock, isTestMockCallback, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression };
+export { SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION, SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR, findParent, findProperty, getFullyQualifiedName, getHumanReadableKind, getPropertyName, getRootIdentifier, getUnderlyingExpression, is, isClass, isDirective, isFileHasDirective, isFunction, isIdentifier, isJSX, isJSXElement, isJSXElementLike, isJSXTagNameExpression, isLiteral, isMethodOrProperty, isNodeEqual, isOneOf, isProperty, isThisExpressionLoose, isTypeAssertionExpression, isTypeExpression };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "5.2.0-next.0",
+  "version": "5.2.1-beta.3",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -9,7 +9,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Rel1cx/eslint-react.git",
-    "directory": "packages/@eslint-react/ast"
+    "directory": "packages/ast"
   },
   "license": "MIT",
   "author": "Rel1cx",
@@ -37,8 +37,8 @@
   },
   "devDependencies": {
     "tsdown": "^0.21.7",
-    "@local/eff": "3.0.0-beta.72",
-    "@local/configs": "0.0.0"
+    "@local/configs": "0.0.0",
+    "@local/eff": "3.0.0-beta.72"
   },
   "peerDependencies": {
     "eslint": "^10.2.0",