@eslint-react/core 2.0.0-next.0 → 2.0.0-next.10

package/dist/index.js

@@ -1,57 +1,31 @@
-'use strict';
-
-var types = require('@typescript-eslint/types');
-var AST14 = require('@eslint-react/ast');
-var eff = require('@eslint-react/eff');
-var kit = require('@eslint-react/kit');
-var shared = require('@eslint-react/shared');
-var VAR3 = require('@eslint-react/var');
-var tsPattern = require('ts-pattern');
-var birecord = require('birecord');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var AST14__namespace = /*#__PURE__*/_interopNamespace(AST14);
-var VAR3__namespace = /*#__PURE__*/_interopNamespace(VAR3);
-var birecord__default = /*#__PURE__*/_interopDefault(birecord);
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import * as AST14 from '@eslint-react/ast';
+import { flip, dual, constFalse, identity, constTrue, _ } from '@eslint-react/eff';
+import { RegExp, Selector } from '@eslint-react/kit';
+import { coerceSettings, DEFAULT_ESLINT_REACT_SETTINGS, getId } from '@eslint-react/shared';
+import * as VAR3 from '@eslint-react/var';
+import { isMatching, P, match } from 'ts-pattern';
+import birecord from 'birecord';
 
 // src/component/component-children.ts
 function isReactAPI(api) {
   const func = (context, node) => {
     if (node == null) return false;
     const getText = (n) => context.sourceCode.getText(n);
-    const name = AST14__namespace.toString(node, getText);
+    const name = AST14.toString(node, getText);
     if (name === api) return true;
     if (name.substring(name.indexOf(".") + 1) === api) return true;
     return false;
   };
-  return eff.dual(2, func);
+  return dual(2, func);
 }
 function isReactAPICall(api) {
   const func = (context, node) => {
     if (node == null) return false;
-    if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
+    if (node.type !== AST_NODE_TYPES.CallExpression) return false;
     return isReactAPI(api)(context, node.callee);
   };
-  return eff.dual(2, func);
+  return dual(2, func);
 }
 var isCaptureOwnerStack = isReactAPI("captureOwnerStack");
 var isChildrenCount = isReactAPI("Children.count");
@@ -83,51 +57,51 @@ var isLazyCall = isReactAPICall("lazy");
 // src/component/component-children.ts
 function isChildrenOfCreateElement(context, node) {
   const parent = node.parent;
-  if (parent == null || parent.type !== types.AST_NODE_TYPES.CallExpression) return false;
+  if (parent == null || parent.type !== AST_NODE_TYPES.CallExpression) return false;
   if (!isCreateElementCall(context, parent)) return false;
   return parent.arguments.slice(2).some((arg) => arg === node);
 }
 function getInstanceId(node, prev) {
   switch (true) {
-    case (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init === prev):
+    case (node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev):
       return node.id;
-    case (node.type === types.AST_NODE_TYPES.AssignmentExpression && node.right === prev):
+    case (node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev):
       return node.left;
-    case (node.type === types.AST_NODE_TYPES.PropertyDefinition && node.value === prev):
+    case (node.type === AST_NODE_TYPES.PropertyDefinition && node.value === prev):
       return node.key;
-    case (node.type === types.AST_NODE_TYPES.BlockStatement || node.type === types.AST_NODE_TYPES.Program || node.parent === node):
-      return eff._;
+    case (node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node):
+      return _;
     default:
       return getInstanceId(node.parent, node);
   }
 }
 function getRequireExpressionArguments(node) {
-  return tsPattern.match(node).with({ type: types.AST_NODE_TYPES.CallExpression, arguments: tsPattern.P.select(), callee: { type: types.AST_NODE_TYPES.Identifier, name: "require" } }, eff.identity).with({ type: types.AST_NODE_TYPES.MemberExpression, object: tsPattern.P.select() }, getRequireExpressionArguments).otherwise(() => null);
+  return match(node).with({ type: AST_NODE_TYPES.CallExpression, arguments: P.select(), callee: { type: AST_NODE_TYPES.Identifier, name: "require" } }, identity).with({ type: AST_NODE_TYPES.MemberExpression, object: P.select() }, getRequireExpressionArguments).otherwise(() => null);
 }
 function isInitializedFromReact(name, importSource, initialScope) {
   if (name.toLowerCase() === "react") return true;
-  const latestDef = VAR3__namespace.findVariable(name, initialScope)?.defs.at(-1);
+  const latestDef = VAR3.findVariable(name, initialScope)?.defs.at(-1);
   if (latestDef == null) return false;
   const { node, parent } = latestDef;
-  if (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init != null) {
+  if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
     const { init } = node;
-    if (init.type === types.AST_NODE_TYPES.MemberExpression && init.object.type === types.AST_NODE_TYPES.Identifier) {
+    if (init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier) {
       return isInitializedFromReact(init.object.name, importSource, initialScope);
     }
-    if (init.type === types.AST_NODE_TYPES.Identifier) {
+    if (init.type === AST_NODE_TYPES.Identifier) {
       return isInitializedFromReact(init.name, importSource, initialScope);
     }
     const args = getRequireExpressionArguments(init);
     const arg0 = args?.[0];
-    if (arg0 == null || !AST14__namespace.isLiteral(arg0, "string")) {
+    if (arg0 == null || !AST14.isLiteral(arg0, "string")) {
       return false;
     }
     return arg0.value === importSource || arg0.value.startsWith(`${importSource}/`);
   }
-  return parent?.type === types.AST_NODE_TYPES.ImportDeclaration && parent.source.value === importSource;
+  return parent?.type === AST_NODE_TYPES.ImportDeclaration && parent.source.value === importSource;
 }
 function isInstanceIdEqual(context, a, b) {
-  return AST14__namespace.isNodeEqual(a, b) || VAR3__namespace.isNodeValueEqual(a, b, [
+  return AST14.isNodeEqual(a, b) || VAR3.isNodeValueEqual(a, b, [
     context.sourceCode.getScope(a),
     context.sourceCode.getScope(b)
   ]);
@@ -141,34 +115,34 @@ function isReactHookName(name) {
 // src/hook/hook-is.ts
 function isReactHook(node) {
   if (node == null) return false;
-  const id = AST14__namespace.getFunctionId(node);
+  const id = AST14.getFunctionId(node);
   return id?.name != null && isReactHookName(id.name);
 }
 function isReactHookCall(node) {
   if (node == null) return false;
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) {
+  if (node.type !== AST_NODE_TYPES.CallExpression) {
     return false;
   }
-  if (node.callee.type === types.AST_NODE_TYPES.Identifier) {
+  if (node.callee.type === AST_NODE_TYPES.Identifier) {
     return isReactHookName(node.callee.name);
   }
-  if (node.callee.type === types.AST_NODE_TYPES.MemberExpression) {
-    return node.callee.property.type === types.AST_NODE_TYPES.Identifier && isReactHookName(node.callee.property.name);
+  if (node.callee.type === AST_NODE_TYPES.MemberExpression) {
+    return node.callee.property.type === AST_NODE_TYPES.Identifier && isReactHookName(node.callee.property.name);
   }
   return false;
 }
 function isReactHookCallWithName(context, node) {
-  if (node == null || node.type !== types.AST_NODE_TYPES.CallExpression) return eff.constFalse;
+  if (node == null || node.type !== AST_NODE_TYPES.CallExpression) return constFalse;
   const {
-    importSource = shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource,
+    importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
     skipImportCheck = true
-  } = shared.coerceSettings(context.settings);
+  } = coerceSettings(context.settings);
   const initialScope = context.sourceCode.getScope(node);
   return (name) => {
     switch (true) {
-      case (node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === name):
+      case (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === name):
         return skipImportCheck || isInitializedFromReact(name, importSource, initialScope);
-      case (node.callee.type === types.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
+      case (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
         return skipImportCheck || isInitializedFromReact(node.callee.object.name, importSource, initialScope);
       default:
         return false;
@@ -176,13 +150,13 @@ function isReactHookCallWithName(context, node) {
   };
 }
 function isReactHookCallWithNameLoose(node) {
-  if (node == null || node.type !== types.AST_NODE_TYPES.CallExpression) return eff.constFalse;
+  if (node == null || node.type !== AST_NODE_TYPES.CallExpression) return constFalse;
   return (name) => {
     switch (node.callee.type) {
-      case types.AST_NODE_TYPES.Identifier:
+      case AST_NODE_TYPES.Identifier:
         return node.callee.name === name;
-      case types.AST_NODE_TYPES.MemberExpression:
-        return node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === name;
+      case AST_NODE_TYPES.MemberExpression:
+        return node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === name;
       default:
         return false;
     }
@@ -190,15 +164,15 @@ function isReactHookCallWithNameLoose(node) {
 }
 function isReactHookCallWithNameAlias(context, name, alias = []) {
   const {
-    importSource = shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource,
+    importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
     skipImportCheck = true
-  } = shared.coerceSettings(context.settings);
+  } = coerceSettings(context.settings);
   return (node) => {
     const initialScope = context.sourceCode.getScope(node);
     switch (true) {
-      case (node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === name):
+      case (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === name):
         return skipImportCheck || isInitializedFromReact(name, importSource, initialScope);
-      case (node.callee.type === types.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
+      case (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
         return skipImportCheck || isInitializedFromReact(node.callee.object.name, importSource, initialScope);
       default:
         return alias.some(isReactHookCallWithNameLoose(node));
@@ -207,45 +181,45 @@ function isReactHookCallWithNameAlias(context, name, alias = []) {
 }
 function isUseEffectCallLoose(node) {
   if (node == null) return false;
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) {
+  if (node.type !== AST_NODE_TYPES.CallExpression) {
     return false;
   }
   switch (node.callee.type) {
-    case types.AST_NODE_TYPES.Identifier:
+    case AST_NODE_TYPES.Identifier:
       return /^use\w*Effect$/u.test(node.callee.name);
-    case types.AST_NODE_TYPES.MemberExpression:
-      return node.callee.property.type === types.AST_NODE_TYPES.Identifier && /^use\w*Effect$/u.test(node.callee.property.name);
+    case AST_NODE_TYPES.MemberExpression:
+      return node.callee.property.type === AST_NODE_TYPES.Identifier && /^use\w*Effect$/u.test(node.callee.property.name);
     default:
       return false;
   }
 }
-var isUseCall = eff.flip(isReactHookCallWithName)("use");
-var isUseActionStateCall = eff.flip(isReactHookCallWithName)("useActionState");
-var isUseCallbackCall = eff.flip(isReactHookCallWithName)("useCallback");
-var isUseContextCall = eff.flip(isReactHookCallWithName)("useContext");
-var isUseDebugValueCall = eff.flip(isReactHookCallWithName)("useDebugValue");
-var isUseDeferredValueCall = eff.flip(isReactHookCallWithName)("useDeferredValue");
-var isUseEffectCall = eff.flip(isReactHookCallWithName)("useEffect");
-var isUseFormStatusCall = eff.flip(isReactHookCallWithName)("useFormStatus");
-var isUseIdCall = eff.flip(isReactHookCallWithName)("useId");
-var isUseImperativeHandleCall = eff.flip(isReactHookCallWithName)("useImperativeHandle");
-var isUseInsertionEffectCall = eff.flip(isReactHookCallWithName)("useInsertionEffect");
-var isUseLayoutEffectCall = eff.flip(isReactHookCallWithName)("useLayoutEffect");
-var isUseMemoCall = eff.flip(isReactHookCallWithName)("useMemo");
-var isUseOptimisticCall = eff.flip(isReactHookCallWithName)("useOptimistic");
-var isUseReducerCall = eff.flip(isReactHookCallWithName)("useReducer");
-var isUseRefCall = eff.flip(isReactHookCallWithName)("useRef");
-var isUseStateCall = eff.flip(isReactHookCallWithName)("useState");
-var isUseSyncExternalStoreCall = eff.flip(isReactHookCallWithName)("useSyncExternalStore");
-var isUseTransitionCall = eff.flip(isReactHookCallWithName)("useTransition");
+var isUseCall = flip(isReactHookCallWithName)("use");
+var isUseActionStateCall = flip(isReactHookCallWithName)("useActionState");
+var isUseCallbackCall = flip(isReactHookCallWithName)("useCallback");
+var isUseContextCall = flip(isReactHookCallWithName)("useContext");
+var isUseDebugValueCall = flip(isReactHookCallWithName)("useDebugValue");
+var isUseDeferredValueCall = flip(isReactHookCallWithName)("useDeferredValue");
+var isUseEffectCall = flip(isReactHookCallWithName)("useEffect");
+var isUseFormStatusCall = flip(isReactHookCallWithName)("useFormStatus");
+var isUseIdCall = flip(isReactHookCallWithName)("useId");
+var isUseImperativeHandleCall = flip(isReactHookCallWithName)("useImperativeHandle");
+var isUseInsertionEffectCall = flip(isReactHookCallWithName)("useInsertionEffect");
+var isUseLayoutEffectCall = flip(isReactHookCallWithName)("useLayoutEffect");
+var isUseMemoCall = flip(isReactHookCallWithName)("useMemo");
+var isUseOptimisticCall = flip(isReactHookCallWithName)("useOptimistic");
+var isUseReducerCall = flip(isReactHookCallWithName)("useReducer");
+var isUseRefCall = flip(isReactHookCallWithName)("useRef");
+var isUseStateCall = flip(isReactHookCallWithName)("useState");
+var isUseSyncExternalStoreCall = flip(isReactHookCallWithName)("useSyncExternalStore");
+var isUseTransitionCall = flip(isReactHookCallWithName)("useTransition");
 
 // src/hook/hook-collector.ts
 function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
   const functionEntries = [];
   const onFunctionEnter = (node) => {
-    const id = AST14__namespace.getFunctionId(node);
-    const key = shared.getId();
+    const id = AST14.getFunctionId(node);
+    const key = getId();
     const name = id?.name;
     if (name != null && isReactHookName(name)) {
       functionEntries.push({ key, node, isHook: true });
@@ -292,23 +266,33 @@ function useHookCollector() {
   };
   return { ctx, listeners };
 }
+function isReactHookId(id) {
+  switch (id.type) {
+    case AST_NODE_TYPES.Identifier:
+      return isReactHookName(id.name);
+    case AST_NODE_TYPES.MemberExpression:
+      return "name" in id.property && isReactHookName(id.property.name);
+    default:
+      return false;
+  }
+}
 function stringifyJsx(node) {
   switch (node.type) {
-    case types.AST_NODE_TYPES.JSXIdentifier:
+    case AST_NODE_TYPES.JSXIdentifier:
       return node.name;
-    case types.AST_NODE_TYPES.JSXNamespacedName:
+    case AST_NODE_TYPES.JSXNamespacedName:
       return `${node.namespace.name}:${node.name.name}`;
-    case types.AST_NODE_TYPES.JSXMemberExpression:
+    case AST_NODE_TYPES.JSXMemberExpression:
       return `${stringifyJsx(node.object)}.${stringifyJsx(node.property)}`;
-    case types.AST_NODE_TYPES.JSXText:
+    case AST_NODE_TYPES.JSXText:
       return node.value;
-    case types.AST_NODE_TYPES.JSXOpeningElement:
+    case AST_NODE_TYPES.JSXOpeningElement:
       return `<${stringifyJsx(node.name)}>`;
-    case types.AST_NODE_TYPES.JSXClosingElement:
+    case AST_NODE_TYPES.JSXClosingElement:
       return `</${stringifyJsx(node.name)}>`;
-    case types.AST_NODE_TYPES.JSXOpeningFragment:
+    case AST_NODE_TYPES.JSXOpeningFragment:
       return "<>";
-    case types.AST_NODE_TYPES.JSXClosingFragment:
+    case AST_NODE_TYPES.JSXClosingFragment:
       return "</>";
   }
 }
@@ -321,21 +305,21 @@ function getAttributeName(context, node) {
 // src/jsx/jsx-attribute.ts
 function getAttribute(context, name, attributes, initialScope) {
   return attributes.findLast((attr) => {
-    if (attr.type === types.AST_NODE_TYPES.JSXAttribute) {
+    if (attr.type === AST_NODE_TYPES.JSXAttribute) {
       return getAttributeName(context, attr) === name;
     }
     if (initialScope == null) return false;
     switch (attr.argument.type) {
-      case types.AST_NODE_TYPES.Identifier: {
-        const variable = VAR3__namespace.findVariable(attr.argument.name, initialScope);
-        const variableNode = VAR3__namespace.getVariableInitNode(variable, 0);
-        if (variableNode?.type === types.AST_NODE_TYPES.ObjectExpression) {
-          return VAR3__namespace.findPropertyInProperties(name, variableNode.properties, initialScope) != null;
+      case AST_NODE_TYPES.Identifier: {
+        const variable = VAR3.findVariable(attr.argument.name, initialScope);
+        const variableNode = VAR3.getVariableInitNode(variable, 0);
+        if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
+          return VAR3.findPropertyInProperties(name, variableNode.properties, initialScope) != null;
         }
         return false;
       }
-      case types.AST_NODE_TYPES.ObjectExpression:
-        return VAR3__namespace.findPropertyInProperties(name, attr.argument.properties, initialScope) != null;
+      case AST_NODE_TYPES.ObjectExpression:
+        return VAR3.findPropertyInProperties(name, attr.argument.properties, initialScope) != null;
     }
     return false;
   });
@@ -343,8 +327,8 @@ function getAttribute(context, name, attributes, initialScope) {
 function getAttributeValue(context, node, name) {
   const initialScope = context.sourceCode.getScope(node);
   switch (node.type) {
-    case types.AST_NODE_TYPES.JSXAttribute:
-      if (node.value?.type === types.AST_NODE_TYPES.Literal) {
+    case AST_NODE_TYPES.JSXAttribute:
+      if (node.value?.type === AST_NODE_TYPES.Literal) {
         return {
           kind: "some",
           node: node.value,
@@ -352,16 +336,16 @@ function getAttributeValue(context, node, name) {
           value: node.value.value
         };
       }
-      if (node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer) {
-        return VAR3__namespace.toStaticValue({
+      if (node.value?.type === AST_NODE_TYPES.JSXExpressionContainer) {
+        return VAR3.toStaticValue({
           kind: "lazy",
           node: node.value.expression,
           initialScope
         });
       }
       return { kind: "none", node, initialScope };
-    case types.AST_NODE_TYPES.JSXSpreadAttribute: {
-      const staticValue = VAR3__namespace.toStaticValue({
+    case AST_NODE_TYPES.JSXSpreadAttribute: {
+      const staticValue = VAR3.toStaticValue({
         kind: "lazy",
         node: node.argument,
         initialScope
@@ -369,7 +353,7 @@ function getAttributeValue(context, node, name) {
       if (staticValue.kind === "none") {
         return staticValue;
       }
-      return tsPattern.match(staticValue.value).with({ [name]: tsPattern.P.select(tsPattern.P.any) }, (value) => ({
+      return match(staticValue.value).with({ [name]: P.select(P.any) }, (value) => ({
         kind: "some",
         node: node.argument,
         initialScope,
@@ -401,13 +385,13 @@ var DEFAULT_JSX_DETECTION_HINT = 0n | JSXDetectionHint.SkipUndefined | JSXDetect
 // src/jsx/jsx-detection.ts
 function isJsxText(node) {
   if (node == null) return false;
-  return node.type === types.AST_NODE_TYPES.JSXText || node.type === types.AST_NODE_TYPES.Literal;
+  return node.type === AST_NODE_TYPES.JSXText || node.type === AST_NODE_TYPES.Literal;
 }
 function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
   if (node == null) return false;
-  if (AST14__namespace.isJSX(node)) return true;
+  if (AST14.isJSX(node)) return true;
   switch (node.type) {
-    case types.AST_NODE_TYPES.Literal: {
+    case AST_NODE_TYPES.Literal: {
       switch (typeof node.value) {
         case "boolean":
           return !(hint & JSXDetectionHint.SkipBooleanLiteral);
@@ -423,22 +407,22 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
       }
       return false;
     }
-    case types.AST_NODE_TYPES.TemplateLiteral: {
+    case AST_NODE_TYPES.TemplateLiteral: {
       return !(hint & JSXDetectionHint.SkipStringLiteral);
     }
-    case types.AST_NODE_TYPES.ArrayExpression: {
+    case AST_NODE_TYPES.ArrayExpression: {
       if (hint & JSXDetectionHint.StrictArray) {
         return node.elements.every((n) => isJsxLike(code, n, hint));
       }
       return node.elements.some((n) => isJsxLike(code, n, hint));
     }
-    case types.AST_NODE_TYPES.LogicalExpression: {
+    case AST_NODE_TYPES.LogicalExpression: {
       if (hint & JSXDetectionHint.StrictLogical) {
         return isJsxLike(code, node.left, hint) && isJsxLike(code, node.right, hint);
       }
       return isJsxLike(code, node.left, hint) || isJsxLike(code, node.right, hint);
     }
-    case types.AST_NODE_TYPES.ConditionalExpression: {
+    case AST_NODE_TYPES.ConditionalExpression: {
       let leftHasJSX2 = function(node2) {
         if (Array.isArray(node2.consequent)) {
           if (node2.consequent.length === 0) {
@@ -458,39 +442,39 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
       }
       return leftHasJSX2(node) || rightHasJSX2(node);
     }
-    case types.AST_NODE_TYPES.SequenceExpression: {
+    case AST_NODE_TYPES.SequenceExpression: {
       const exp = node.expressions.at(-1);
       return isJsxLike(code, exp, hint);
     }
-    case types.AST_NODE_TYPES.CallExpression: {
+    case AST_NODE_TYPES.CallExpression: {
       if (hint & JSXDetectionHint.SkipCreateElement) {
         return false;
       }
       switch (node.callee.type) {
-        case types.AST_NODE_TYPES.Identifier:
+        case AST_NODE_TYPES.Identifier:
           return node.callee.name === "createElement";
-        case types.AST_NODE_TYPES.MemberExpression:
-          return node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === "createElement";
+        case AST_NODE_TYPES.MemberExpression:
+          return node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "createElement";
       }
       return false;
     }
-    case types.AST_NODE_TYPES.Identifier: {
+    case AST_NODE_TYPES.Identifier: {
       const { name } = node;
       if (name === "undefined") {
         return !(hint & JSXDetectionHint.SkipUndefined);
       }
-      if (AST14__namespace.isJSXTagNameExpression(node)) {
+      if (AST14.isJSXTagNameExpression(node)) {
         return true;
       }
-      const variable = VAR3__namespace.findVariable(name, code.getScope(node));
-      const variableNode = variable && VAR3__namespace.getVariableInitNode(variable, 0);
+      const variable = VAR3.findVariable(name, code.getScope(node));
+      const variableNode = variable && VAR3.getVariableInitNode(variable, 0);
       return !!variableNode && isJsxLike(code, variableNode, hint);
     }
   }
   return false;
 }
 function getElementType(context, node) {
-  if (node.type === types.AST_NODE_TYPES.JSXFragment) {
+  if (node.type === AST_NODE_TYPES.JSXFragment) {
     return "";
   }
   return stringifyJsx(node.openingElement.name);
@@ -506,22 +490,22 @@ function hasAnyAttribute(context, names, attributes, initialScope) {
 function hasEveryAttribute(context, names, attributes, initialScope) {
   return names.every((n) => hasAttribute(context, n, attributes, initialScope));
 }
-function findParentAttribute(node, test = eff.constTrue) {
+function findParentAttribute(node, test = constTrue) {
   const guard = (node2) => {
-    return node2.type === types.AST_NODE_TYPES.JSXAttribute && test(node2);
+    return node2.type === AST_NODE_TYPES.JSXAttribute && test(node2);
   };
-  return AST14__namespace.findParentNode(node, guard);
+  return AST14.findParentNode(node, guard);
 }
 function isHostElement(context, node) {
-  return node.type === types.AST_NODE_TYPES.JSXElement && node.openingElement.name.type === types.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
+  return node.type === AST_NODE_TYPES.JSXElement && node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
 }
 function isKeyedElement(context, node, initialScope) {
-  return node.type === types.AST_NODE_TYPES.JSXElement && hasAttribute(context, "key", node.openingElement.attributes, initialScope);
+  return node.type === AST_NODE_TYPES.JSXElement && hasAttribute(context, "key", node.openingElement.attributes, initialScope);
 }
 function isFragmentElement(context, node, allowJSXFragment = false) {
   if (node == null) return false;
-  if (node.type !== types.AST_NODE_TYPES.JSXElement && node.type !== types.AST_NODE_TYPES.JSXFragment) return false;
-  if (node.type === types.AST_NODE_TYPES.JSXFragment) return allowJSXFragment;
+  if (node.type !== AST_NODE_TYPES.JSXElement && node.type !== AST_NODE_TYPES.JSXFragment) return false;
+  if (node.type === AST_NODE_TYPES.JSXFragment) return allowJSXFragment;
   return getElementType(context, node).split(".").at(-1) === "Fragment";
 }
 
@@ -561,9 +545,9 @@ function isClassComponent(node) {
   if ("superClass" in node && node.superClass != null) {
     const re = /^(?:Pure)?Component$/u;
     switch (true) {
-      case node.superClass.type === types.AST_NODE_TYPES.Identifier:
+      case node.superClass.type === AST_NODE_TYPES.Identifier:
         return re.test(node.superClass.name);
-      case (node.superClass.type === types.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types.AST_NODE_TYPES.Identifier):
+      case (node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier):
         return re.test(node.superClass.property.name);
     }
   }
@@ -573,33 +557,33 @@ function isPureComponent(node) {
   if ("superClass" in node && node.superClass != null) {
     const re = /^PureComponent$/u;
     switch (true) {
-      case node.superClass.type === types.AST_NODE_TYPES.Identifier:
+      case node.superClass.type === AST_NODE_TYPES.Identifier:
         return re.test(node.superClass.name);
-      case (node.superClass.type === types.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types.AST_NODE_TYPES.Identifier):
+      case (node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier):
         return re.test(node.superClass.property.name);
     }
   }
   return false;
 }
 function isRenderMethodLike(node) {
-  return AST14__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
+  return AST14.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
 }
 
 // src/component/component-definition.ts
-var isFunctionOfClassMethod = tsPattern.isMatching({
-  type: tsPattern.P.union(types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression),
-  parent: types.AST_NODE_TYPES.MethodDefinition
+var isFunctionOfClassMethod = isMatching({
+  type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
+  parent: AST_NODE_TYPES.MethodDefinition
 });
-var isFunctionOfClassProperty = tsPattern.isMatching({
-  type: tsPattern.P.union(types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression),
-  parent: types.AST_NODE_TYPES.Property
+var isFunctionOfClassProperty = isMatching({
+  type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
+  parent: AST_NODE_TYPES.Property
 });
-var isFunctionOfObjectMethod = tsPattern.isMatching({
-  type: tsPattern.P.union(types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression),
+var isFunctionOfObjectMethod = isMatching({
+  type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
   parent: {
-    type: types.AST_NODE_TYPES.Property,
+    type: AST_NODE_TYPES.Property,
     parent: {
-      type: types.AST_NODE_TYPES.ObjectExpression
+      type: AST_NODE_TYPES.ObjectExpression
     }
   }
 });
@@ -622,44 +606,44 @@ function isValidComponentDefinition(context, node, hint) {
   if (hint & ComponentDetectionHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) {
     return false;
   }
-  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST14__namespace.isArrayMapCall(node.parent)) {
+  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST14.isArrayMapCall(node.parent)) {
     return false;
   }
-  const significantParent = AST14__namespace.findParentNode(
+  const significantParent = AST14.findParentNode(
     node,
-    AST14__namespace.isOneOf([
-      types.AST_NODE_TYPES.JSXExpressionContainer,
-      types.AST_NODE_TYPES.ArrowFunctionExpression,
-      types.AST_NODE_TYPES.FunctionExpression,
-      types.AST_NODE_TYPES.Property,
-      types.AST_NODE_TYPES.ClassBody
+    AST14.isOneOf([
+      AST_NODE_TYPES.JSXExpressionContainer,
+      AST_NODE_TYPES.ArrowFunctionExpression,
+      AST_NODE_TYPES.FunctionExpression,
+      AST_NODE_TYPES.Property,
+      AST_NODE_TYPES.ClassBody
     ])
   );
-  return significantParent == null || significantParent.type !== types.AST_NODE_TYPES.JSXExpressionContainer;
+  return significantParent == null || significantParent.type !== AST_NODE_TYPES.JSXExpressionContainer;
 }
 function isComponentWrapperCall(context, node) {
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== AST_NODE_TYPES.CallExpression) return false;
   return isMemoCall(context, node) || isForwardRefCall(context, node);
 }
 function isComponentWrapperCallLoose(context, node) {
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== AST_NODE_TYPES.CallExpression) return false;
   return isComponentWrapperCall(context, node) || isUseCallbackCall(context, node);
 }
 
 // src/component/component-id.ts
 function getFunctionComponentId(context, node) {
-  const functionId = AST14__namespace.getFunctionId(node);
+  const functionId = AST14.getFunctionId(node);
   if (functionId != null) {
     return functionId;
   }
   const { parent } = node;
-  if (parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent) && parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator && parent.parent.id.type === types.AST_NODE_TYPES.Identifier) {
+  if (parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator && parent.parent.id.type === AST_NODE_TYPES.Identifier) {
     return parent.parent.id;
   }
-  if (parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent) && parent.parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent.parent) && parent.parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator && parent.parent.parent.id.type === types.AST_NODE_TYPES.Identifier) {
+  if (parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent) && parent.parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent.parent) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator && parent.parent.parent.id.type === AST_NODE_TYPES.Identifier) {
     return parent.parent.parent.id;
   }
-  return eff._;
+  return _;
 }
 
 // src/component/component-flag.ts
@@ -675,22 +659,22 @@ var ComponentFlag = {
 // src/component/component-init-path.ts
 function getComponentFlagFromInitPath(initPath) {
   let flag = ComponentFlag.None;
-  if (initPath != null && AST14__namespace.hasCallInFunctionInitPath("memo", initPath)) {
+  if (initPath != null && AST14.hasCallInFunctionInitPath("memo", initPath)) {
     flag |= ComponentFlag.Memo;
   }
-  if (initPath != null && AST14__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
+  if (initPath != null && AST14.hasCallInFunctionInitPath("forwardRef", initPath)) {
     flag |= ComponentFlag.ForwardRef;
   }
   return flag;
 }
 function isComponentName(name) {
-  return kit.RegExp.COMPONENT_NAME.test(name);
+  return RegExp.COMPONENT_NAME.test(name);
 }
 function isComponentNameLoose(name) {
-  return kit.RegExp.COMPONENT_NAME_LOOSE.test(name);
+  return RegExp.COMPONENT_NAME_LOOSE.test(name);
 }
 function getComponentNameFromId(id) {
-  if (id == null) return eff._;
+  if (id == null) return _;
   return Array.isArray(id) ? id.map((n) => n.name).join(".") : id.name;
 }
 function hasNoneOrLooseComponentName(context, fn) {
@@ -711,14 +695,14 @@ function useComponentCollector(context, options = {}) {
   const functionEntries = [];
   const getCurrentEntry = () => functionEntries.at(-1);
   const onFunctionEnter = (node) => {
-    const key = shared.getId();
+    const key = getId();
     functionEntries.push({ key, node, hookCalls: [], isComponent: false });
   };
   const onFunctionExit = () => {
     const entry = functionEntries.at(-1);
     if (entry == null) return;
     if (!entry.isComponent) return functionEntries.pop();
-    const shouldDrop = AST14__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
+    const shouldDrop = AST14.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
       return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !isJsxLike(context.sourceCode, r.argument, hint);
     });
     if (shouldDrop) {
@@ -745,17 +729,17 @@ function useComponentCollector(context, options = {}) {
       const { body } = entry.node;
       const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, body, hint) && isValidComponentDefinition(context, entry.node, hint);
       if (!isComponent) return;
-      const initPath = AST14__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST14.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
-      const key = shared.getId();
+      const key = getId();
       components.set(key, {
         id,
         key,
         kind: "function",
         name,
         node: entry.node,
-        displayName: eff._,
+        displayName: _,
         flag: getComponentFlagFromInitPath(initPath),
         hint,
         hookCalls: entry.hookCalls,
@@ -763,10 +747,10 @@ function useComponentCollector(context, options = {}) {
       });
     },
     ...collectDisplayName ? {
-      [kit.Selector.DISPLAY_NAME_ASSIGNMENT_EXPRESSION](node) {
+      [Selector.DISPLAY_NAME_ASSIGNMENT_EXPRESSION](node) {
         const { left, right } = node;
-        if (left.type !== types.AST_NODE_TYPES.MemberExpression) return;
-        const componentName = left.object.type === types.AST_NODE_TYPES.Identifier ? left.object.name : eff._;
+        if (left.type !== AST_NODE_TYPES.MemberExpression) return;
+        const componentName = left.object.type === AST_NODE_TYPES.Identifier ? left.object.name : _;
         const component = [...components.values()].findLast(({ name }) => name != null && name === componentName);
         if (component == null) return;
         component.displayName = right;
@@ -786,7 +770,7 @@ function useComponentCollector(context, options = {}) {
       const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, node.argument, hint) && isValidComponentDefinition(context, entry.node, hint);
       if (!isComponent) return;
       entry.isComponent = true;
-      const initPath = AST14__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST14.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       components.set(entry.key, {
@@ -795,7 +779,7 @@ function useComponentCollector(context, options = {}) {
         kind: "function",
         name,
         node: entry.node,
-        displayName: eff._,
+        displayName: _,
         flag: getComponentFlagFromInitPath(initPath),
         hint,
         hookCalls: entry.hookCalls,
@@ -817,8 +801,8 @@ function useComponentCollectorLegacy() {
     if (!isClassComponent(node)) {
       return;
     }
-    const id = AST14__namespace.getClassId(node);
-    const key = shared.getId();
+    const id = AST14.getClassId(node);
+    const key = getId();
     const flag = isPureComponent(node) ? ComponentFlag.PureComponent : ComponentFlag.None;
     components.set(
       key,
@@ -829,7 +813,7 @@ function useComponentCollectorLegacy() {
         name: id?.name,
         node,
         // TODO: Get displayName of class component
-        displayName: eff._,
+        displayName: _,
         flag,
         hint: 0n,
         // TODO: Get methods of class component
@@ -844,63 +828,63 @@ function useComponentCollectorLegacy() {
   return { ctx, listeners };
 }
 function isComponentDidCatch(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
 }
 function isComponentDidMount(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
 }
 function isComponentDidUpdate(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
 }
 function isComponentWillMount(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
 }
 function isComponentWillReceiveProps(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
 }
 function isComponentWillUnmount(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
 }
 function isComponentWillUpdate(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
 }
 function isGetChildContext(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
 }
 function isGetDefaultProps(node) {
-  return AST14__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
+  return AST14.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
 }
 function isGetInitialState(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
 }
 function isGetSnapshotBeforeUpdate(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
 }
 function isShouldComponentUpdate(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
 function isUnsafeComponentWillMount(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
 }
 function isUnsafeComponentWillReceiveProps(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
 }
 function isUnsafeComponentWillUpdate(node) {
-  return AST14__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
+  return AST14.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
 }
 function isGetDerivedStateFromProps(node) {
-  return AST14__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
+  return AST14.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
 }
 function isGetDerivedStateFromError(node) {
-  return AST14__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
+  return AST14.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
 }
-var ComponentPhaseRelevance = birecord__default.default({
+var ComponentPhaseRelevance = birecord({
   mount: "unmount",
   setup: "cleanup"
 });
-var isInversePhase = eff.dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
+var isInversePhase = dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
 function isRenderLike(node) {
-  return AST14__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
+  return AST14.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
 }
 function isFunctionOfRender(node) {
   if (!isRenderLike(node.parent)) {
@@ -910,8 +894,8 @@ function isFunctionOfRender(node) {
 }
 function isRenderFunctionLoose(context, node) {
   const { body, parent } = node;
-  if (AST14__namespace.getFunctionId(node)?.name.startsWith("render")) {
-    return parent.type === types.AST_NODE_TYPES.JSXExpressionContainer && parent.parent.type === types.AST_NODE_TYPES.JSXAttribute && parent.parent.name.type === types.AST_NODE_TYPES.JSXIdentifier && parent.parent.name.name.startsWith("render");
+  if (AST14.getFunctionId(node)?.name.startsWith("render")) {
+    return parent.type === AST_NODE_TYPES.JSXExpressionContainer && parent.parent.type === AST_NODE_TYPES.JSXAttribute && parent.parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.parent.name.name.startsWith("render");
   }
   return isJsxLike(
     context.sourceCode,
@@ -920,14 +904,14 @@ function isRenderFunctionLoose(context, node) {
   );
 }
 function isRenderPropLoose(context, node) {
-  if (node.name.type !== types.AST_NODE_TYPES.JSXIdentifier) {
+  if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) {
     return false;
   }
-  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST14__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
+  return node.name.name.startsWith("render") && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && AST14.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
 }
 function isDirectValueOfRenderPropertyLoose(node) {
   const matching = (node2) => {
-    return node2.type === types.AST_NODE_TYPES.Property && node2.key.type === types.AST_NODE_TYPES.Identifier && node2.key.name.startsWith("render");
+    return node2.type === AST_NODE_TYPES.Property && node2.key.type === AST_NODE_TYPES.Identifier && node2.key.name.startsWith("render");
   };
   return matching(node) || node.parent != null && matching(node.parent);
 }
@@ -935,138 +919,19 @@ function isDeclaredInRenderPropLoose(node) {
   if (isDirectValueOfRenderPropertyLoose(node)) {
     return true;
   }
-  const parent = AST14__namespace.findParentNode(node, AST14__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
-  if (parent?.type !== types.AST_NODE_TYPES.JSXAttribute) {
+  const parent = AST14.findParentNode(node, AST14.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  if (parent?.type !== AST_NODE_TYPES.JSXAttribute) {
     return false;
   }
-  return parent.name.type === types.AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
+  return parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
 }
 function isThisSetState(node) {
   const { callee } = node;
-  return callee.type === types.AST_NODE_TYPES.MemberExpression && AST14__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+  return callee.type === AST_NODE_TYPES.MemberExpression && AST14.isThisExpression(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 function isAssignmentToThisState(node) {
   const { left } = node;
-  return left.type === types.AST_NODE_TYPES.MemberExpression && AST14__namespace.isThisExpression(left.object) && AST14__namespace.getPropertyName(left.property) === "state";
+  return left.type === AST_NODE_TYPES.MemberExpression && AST14.isThisExpression(left.object) && AST14.getPropertyName(left.property) === "state";
 }
 
-exports.ComponentDetectionHint = ComponentDetectionHint;
-exports.ComponentFlag = ComponentFlag;
-exports.ComponentPhaseRelevance = ComponentPhaseRelevance;
-exports.DEFAULT_COMPONENT_DETECTION_HINT = DEFAULT_COMPONENT_DETECTION_HINT;
-exports.DEFAULT_JSX_DETECTION_HINT = DEFAULT_JSX_DETECTION_HINT;
-exports.JSXDetectionHint = JSXDetectionHint;
-exports.findParentAttribute = findParentAttribute;
-exports.getAttribute = getAttribute;
-exports.getAttributeName = getAttributeName;
-exports.getAttributeValue = getAttributeValue;
-exports.getComponentFlagFromInitPath = getComponentFlagFromInitPath;
-exports.getComponentNameFromId = getComponentNameFromId;
-exports.getElementType = getElementType;
-exports.getFunctionComponentId = getFunctionComponentId;
-exports.getInstanceId = getInstanceId;
-exports.hasAnyAttribute = hasAnyAttribute;
-exports.hasAttribute = hasAttribute;
-exports.hasEveryAttribute = hasEveryAttribute;
-exports.hasNoneOrLooseComponentName = hasNoneOrLooseComponentName;
-exports.isAssignmentToThisState = isAssignmentToThisState;
-exports.isCaptureOwnerStack = isCaptureOwnerStack;
-exports.isCaptureOwnerStackCall = isCaptureOwnerStackCall;
-exports.isChildrenCount = isChildrenCount;
-exports.isChildrenCountCall = isChildrenCountCall;
-exports.isChildrenForEach = isChildrenForEach;
-exports.isChildrenForEachCall = isChildrenForEachCall;
-exports.isChildrenMap = isChildrenMap;
-exports.isChildrenMapCall = isChildrenMapCall;
-exports.isChildrenOfCreateElement = isChildrenOfCreateElement;
-exports.isChildrenOnly = isChildrenOnly;
-exports.isChildrenOnlyCall = isChildrenOnlyCall;
-exports.isChildrenToArray = isChildrenToArray;
-exports.isChildrenToArrayCall = isChildrenToArrayCall;
-exports.isClassComponent = isClassComponent;
-exports.isCloneElement = isCloneElement;
-exports.isCloneElementCall = isCloneElementCall;
-exports.isComponentDidCatch = isComponentDidCatch;
-exports.isComponentDidMount = isComponentDidMount;
-exports.isComponentDidUpdate = isComponentDidUpdate;
-exports.isComponentName = isComponentName;
-exports.isComponentNameLoose = isComponentNameLoose;
-exports.isComponentWillMount = isComponentWillMount;
-exports.isComponentWillReceiveProps = isComponentWillReceiveProps;
-exports.isComponentWillUnmount = isComponentWillUnmount;
-exports.isComponentWillUpdate = isComponentWillUpdate;
-exports.isComponentWrapperCall = isComponentWrapperCall;
-exports.isComponentWrapperCallLoose = isComponentWrapperCallLoose;
-exports.isCreateContext = isCreateContext;
-exports.isCreateContextCall = isCreateContextCall;
-exports.isCreateElement = isCreateElement;
-exports.isCreateElementCall = isCreateElementCall;
-exports.isCreateRef = isCreateRef;
-exports.isCreateRefCall = isCreateRefCall;
-exports.isDeclaredInRenderPropLoose = isDeclaredInRenderPropLoose;
-exports.isDirectValueOfRenderPropertyLoose = isDirectValueOfRenderPropertyLoose;
-exports.isForwardRef = isForwardRef;
-exports.isForwardRefCall = isForwardRefCall;
-exports.isFragmentElement = isFragmentElement;
-exports.isFunctionOfRender = isFunctionOfRender;
-exports.isFunctionOfRenderMethod = isFunctionOfRenderMethod;
-exports.isGetChildContext = isGetChildContext;
-exports.isGetDefaultProps = isGetDefaultProps;
-exports.isGetDerivedStateFromError = isGetDerivedStateFromError;
-exports.isGetDerivedStateFromProps = isGetDerivedStateFromProps;
-exports.isGetInitialState = isGetInitialState;
-exports.isGetSnapshotBeforeUpdate = isGetSnapshotBeforeUpdate;
-exports.isHostElement = isHostElement;
-exports.isInitializedFromReact = isInitializedFromReact;
-exports.isInstanceIdEqual = isInstanceIdEqual;
-exports.isInversePhase = isInversePhase;
-exports.isJsxLike = isJsxLike;
-exports.isJsxText = isJsxText;
-exports.isKeyedElement = isKeyedElement;
-exports.isLazy = isLazy;
-exports.isLazyCall = isLazyCall;
-exports.isMemo = isMemo;
-exports.isMemoCall = isMemoCall;
-exports.isPureComponent = isPureComponent;
-exports.isReactAPI = isReactAPI;
-exports.isReactAPICall = isReactAPICall;
-exports.isReactHook = isReactHook;
-exports.isReactHookCall = isReactHookCall;
-exports.isReactHookCallWithName = isReactHookCallWithName;
-exports.isReactHookCallWithNameAlias = isReactHookCallWithNameAlias;
-exports.isReactHookCallWithNameLoose = isReactHookCallWithNameLoose;
-exports.isReactHookName = isReactHookName;
-exports.isRenderFunctionLoose = isRenderFunctionLoose;
-exports.isRenderLike = isRenderLike;
-exports.isRenderMethodLike = isRenderMethodLike;
-exports.isRenderPropLoose = isRenderPropLoose;
-exports.isShouldComponentUpdate = isShouldComponentUpdate;
-exports.isThisSetState = isThisSetState;
-exports.isUnsafeComponentWillMount = isUnsafeComponentWillMount;
-exports.isUnsafeComponentWillReceiveProps = isUnsafeComponentWillReceiveProps;
-exports.isUnsafeComponentWillUpdate = isUnsafeComponentWillUpdate;
-exports.isUseActionStateCall = isUseActionStateCall;
-exports.isUseCall = isUseCall;
-exports.isUseCallbackCall = isUseCallbackCall;
-exports.isUseContextCall = isUseContextCall;
-exports.isUseDebugValueCall = isUseDebugValueCall;
-exports.isUseDeferredValueCall = isUseDeferredValueCall;
-exports.isUseEffectCall = isUseEffectCall;
-exports.isUseEffectCallLoose = isUseEffectCallLoose;
-exports.isUseFormStatusCall = isUseFormStatusCall;
-exports.isUseIdCall = isUseIdCall;
-exports.isUseImperativeHandleCall = isUseImperativeHandleCall;
-exports.isUseInsertionEffectCall = isUseInsertionEffectCall;
-exports.isUseLayoutEffectCall = isUseLayoutEffectCall;
-exports.isUseMemoCall = isUseMemoCall;
-exports.isUseOptimisticCall = isUseOptimisticCall;
-exports.isUseReducerCall = isUseReducerCall;
-exports.isUseRefCall = isUseRefCall;
-exports.isUseStateCall = isUseStateCall;
-exports.isUseSyncExternalStoreCall = isUseSyncExternalStoreCall;
-exports.isUseTransitionCall = isUseTransitionCall;
-exports.isValidComponentDefinition = isValidComponentDefinition;
-exports.stringifyJsx = stringifyJsx;
-exports.useComponentCollector = useComponentCollector;
-exports.useComponentCollectorLegacy = useComponentCollectorLegacy;
-exports.useHookCollector = useHookCollector;
+export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JSXDetectionHint, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRender, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isKeyedElement, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRenderFunctionLoose, isRenderLike, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, isValidComponentDefinition, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };