@eslint-react/core 1.47.5-next.0 → 1.48.2-beta.0

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var AST8 = require('@eslint-react/ast');
+var AST9 = require('@eslint-react/ast');
 var eff = require('@eslint-react/eff');
 var kit = require('@eslint-react/kit');
 var shared = require('@eslint-react/shared');
@@ -29,7 +29,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var AST8__namespace = /*#__PURE__*/_interopNamespace(AST8);
+var AST9__namespace = /*#__PURE__*/_interopNamespace(AST9);
 var VAR3__namespace = /*#__PURE__*/_interopNamespace(VAR3);
 var birecord__default = /*#__PURE__*/_interopDefault(birecord);
 
@@ -427,6 +427,10 @@ var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
     return payload;
   };
 });
+var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload) => payload;
+});
 function handleArrayResult(result, final, index) {
   if (result.issues.length) {
     final.issues.push(...prefixIssues(index, result.issues));
@@ -688,6 +692,12 @@ function _boolean(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _unknown(Class, params) {
+  return new Class({
+    type: "unknown",
+    ...normalizeParams(params)
+  });
+}
 
 // ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.0/node_modules/@zod/mini/dist/esm/parse.js
 var parse2 = /* @__PURE__ */ _parse.bind({ Error: $ZodError });
@@ -737,6 +747,13 @@ var ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def)
 function boolean2(params) {
   return _boolean(ZodMiniBoolean, params);
 }
+var ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
+  $ZodUnknown.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function unknown(params) {
+  return _unknown(ZodMiniUnknown, params);
+}
 var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodMiniType.init(inst, def);
@@ -854,7 +871,7 @@ var CustomHooksSchema = object({
   useSyncExternalStore: optional(array(string2())),
   useTransition: optional(array(string2()))
 });
-var ESLintReactSettingsSchema = object({
+object({
   /**
    * The source where React is imported from.
    * @description This allows to specify a custom import location for React when not using the official distribution.
@@ -882,13 +899,14 @@ var ESLintReactSettingsSchema = object({
    */
   polymorphicPropName: optional(string2()),
   /**
+   * @default `true`
    * @internal
    */
   strict: optional(boolean2()),
   /**
    * Check both the shape and the import to determine if an API is from React.
-   * @description This can prevent false positives when using a irrelevant third-party library that has similar APIs to React.
    * @default `true`
+   * @internal
    */
   skipImportCheck: optional(boolean2()),
   /**
@@ -913,14 +931,11 @@ var ESLintReactSettingsSchema = object({
 });
 optional(
   object({
-    "react-x": optional(ESLintReactSettingsSchema),
-    /** @deprecated Use `react-x` instead */
-    reactOptions: optional(ESLintReactSettingsSchema)
+    "react-x": optional(unknown())
   }),
   {}
 );
 var DEFAULT_ESLINT_REACT_SETTINGS = {
-  ...parse2(ESLintReactSettingsSchema, {}),
   importSource: "react"};
 function getInstanceId(node, prev) {
   switch (true) {
@@ -954,90 +969,44 @@ function isInitializedFromReact(name, importSource, initialScope) {
     }
     const args = getRequireExpressionArguments(init);
     const arg0 = args?.[0];
-    if (arg0 == null || !AST8__namespace.isLiteral(arg0, "string")) {
+    if (arg0 == null || !AST9__namespace.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;
 }
-
-// src/utils/is-from-react.ts
-var defaultImportSource = shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource;
-function isFromReactLoose(node, name) {
-  switch (node?.type) {
-    case types.AST_NODE_TYPES.Identifier:
-      return node.name === name;
-    case types.AST_NODE_TYPES.MemberExpression:
-      return node.object.type === types.AST_NODE_TYPES.Identifier && node.property.type === types.AST_NODE_TYPES.Identifier && node.property.name === name;
-    default:
-      return false;
-  }
-}
-function isFromReactStrict(node, name, importSource, initialScope) {
-  switch (node?.type) {
-    case types.AST_NODE_TYPES.Identifier:
-      return node.name === name && isInitializedFromReact(name, importSource, initialScope);
-    case types.AST_NODE_TYPES.MemberExpression:
-      return node.object.type === types.AST_NODE_TYPES.Identifier && node.property.type === types.AST_NODE_TYPES.Identifier && node.property.name === name && isInitializedFromReact(node.object.name, importSource, initialScope);
-    default:
-      return false;
-  }
-}
-function isFromReact(name) {
-  return eff.dual(2, (context, node) => {
-    if (node == null) return false;
-    const { importSource = defaultImportSource, skipImportCheck = true } = shared.unsafeDecodeSettings(context.settings);
-    if (skipImportCheck) return isFromReactLoose(node, name);
-    return isFromReactStrict(node, name, importSource, context.sourceCode.getScope(node));
-  });
-}
-function isFromReactObject(objectName, propertyName) {
-  return eff.dual(2, (context, node) => {
-    if (node?.type !== types.AST_NODE_TYPES.MemberExpression) return false;
-    const { importSource = defaultImportSource, skipImportCheck = true } = shared.unsafeDecodeSettings(context.settings);
-    const { object: object2, property } = node;
-    if (skipImportCheck) return isFromReactLoose(object2, objectName) && isFromReactLoose(property, propertyName);
-    return isFromReactStrict(
-      object2,
-      objectName,
-      importSource,
-      context.sourceCode.getScope(object2)
-    ) && isFromReactLoose(property, propertyName);
-  });
-}
-function isCallFromReact(name) {
-  return eff.dual(2, (context, node) => {
-    if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
-    return isFromReact(name)(context, node.callee);
-  });
-}
-function isCallFromReactObject(objectName, propertyName) {
-  return eff.dual(2, (context, node) => {
-    if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
-    return isFromReactObject(objectName, propertyName)(context, node.callee);
-  });
-}
 function isInstanceIdEqual(context, a, b) {
-  return AST8__namespace.isNodeEqual(a, b) || VAR3__namespace.isNodeValueEqual(a, b, [
+  return AST9__namespace.isNodeEqual(a, b) || VAR3__namespace.isNodeValueEqual(a, b, [
     context.sourceCode.getScope(a),
     context.sourceCode.getScope(b)
   ]);
 }
-
-// src/utils/is-react-api.ts
-function isReactAPI(arg0, arg1) {
-  return arg1 == null ? isFromReact(arg0) : isFromReactObject(arg0, arg1);
+function isReactAPI(api) {
+  const func = (context, node) => {
+    if (node == null) return false;
+    const getText = (n) => context.sourceCode.getText(n);
+    const name = AST9__namespace.toString(node, getText);
+    if (name === api) return true;
+    if (name.substring(name.indexOf(".") + 1) === api) return true;
+    return false;
+  };
+  return eff.dual(2, func);
 }
-function isReactAPICall(arg0, arg1) {
-  return arg1 == null ? isCallFromReact(arg0) : isCallFromReactObject(arg0, arg1);
+function isReactAPICall(api) {
+  const func = (context, node) => {
+    if (node == null) return false;
+    if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
+    return isReactAPI(api)(context, node.callee);
+  };
+  return eff.dual(2, func);
 }
 var isCaptureOwnerStack = isReactAPI("captureOwnerStack");
-var isChildrenCount = isReactAPI("Children", "count");
-var isChildrenForEach = isReactAPI("Children", "forEach");
-var isChildrenMap = isReactAPI("Children", "map");
-var isChildrenOnly = isReactAPI("Children", "only");
-var isChildrenToArray = isReactAPI("Children", "toArray");
+var isChildrenCount = isReactAPI("Children.count");
+var isChildrenForEach = isReactAPI("Children.forEach");
+var isChildrenMap = isReactAPI("Children.map");
+var isChildrenOnly = isReactAPI("Children.only");
+var isChildrenToArray = isReactAPI("Children.toArray");
 var isCloneElement = isReactAPI("cloneElement");
 var isCreateContext = isReactAPI("createContext");
 var isCreateElement = isReactAPI("createElement");
@@ -1046,11 +1015,11 @@ var isForwardRef = isReactAPI("forwardRef");
 var isMemo = isReactAPI("memo");
 var isLazy = isReactAPI("lazy");
 var isCaptureOwnerStackCall = isReactAPICall("captureOwnerStack");
-var isChildrenCountCall = isReactAPICall("Children", "count");
-var isChildrenForEachCall = isReactAPICall("Children", "forEach");
-var isChildrenMapCall = isReactAPICall("Children", "map");
-var isChildrenOnlyCall = isReactAPICall("Children", "only");
-var isChildrenToArrayCall = isReactAPICall("Children", "toArray");
+var isChildrenCountCall = isReactAPICall("Children.count");
+var isChildrenForEachCall = isReactAPICall("Children.forEach");
+var isChildrenMapCall = isReactAPICall("Children.map");
+var isChildrenOnlyCall = isReactAPICall("Children.only");
+var isChildrenToArrayCall = isReactAPICall("Children.toArray");
 var isCloneElementCall = isReactAPICall("cloneElement");
 var isCreateContextCall = isReactAPICall("createContext");
 var isCreateElementCall = isReactAPICall("createElement");
@@ -1067,7 +1036,7 @@ function isReactHookName(name) {
 // src/hook/hook-is.ts
 function isReactHook(node) {
   if (node == null) return false;
-  const id = AST8__namespace.getFunctionIdentifier(node);
+  const id = AST9__namespace.getFunctionIdentifier(node);
   return id?.name != null && isReactHookName(id.name);
 }
 function isReactHookCall(node) {
@@ -1088,7 +1057,7 @@ function isReactHookCallWithName(context, node) {
   const {
     importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
     skipImportCheck = true
-  } = shared.unsafeDecodeSettings(context.settings);
+  } = shared.coerceSettings(context.settings);
   const initialScope = context.sourceCode.getScope(node);
   return (name) => {
     switch (true) {
@@ -1118,7 +1087,7 @@ function isReactHookCallWithNameAlias(context, name, alias = []) {
   const {
     importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
     skipImportCheck = true
-  } = shared.unsafeDecodeSettings(context.settings);
+  } = shared.coerceSettings(context.settings);
   return (node) => {
     const initialScope = context.sourceCode.getScope(node);
     switch (true) {
@@ -1170,7 +1139,7 @@ function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
   const functionEntries = [];
   const onFunctionEnter = (node) => {
-    const id = AST8__namespace.getFunctionIdentifier(node);
+    const id = AST9__namespace.getFunctionIdentifier(node);
     const key = shared.getId();
     const name = id?.name;
     if (name != null && isReactHookName(name)) {
@@ -1224,9 +1193,9 @@ function isFunctionOfUseEffectSetup(node) {
 }
 function isFunctionOfUseEffectCleanup(node) {
   if (node == null) return false;
-  const pReturn = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
-  const pFaunction = AST8__namespace.findParentNode(node, AST8__namespace.isFunction);
-  const pFunctionOfReturn = AST8__namespace.findParentNode(pReturn, AST8__namespace.isFunction);
+  const pReturn = AST9__namespace.findParentNode(node, AST9__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
+  const pFaunction = AST9__namespace.findParentNode(node, AST9__namespace.isFunction);
+  const pFunctionOfReturn = AST9__namespace.findParentNode(pReturn, AST9__namespace.isFunction);
   if (pFaunction !== pFunctionOfReturn) return false;
   return isFunctionOfUseEffectSetup(pFaunction);
 }
@@ -1343,7 +1312,7 @@ function isJsxText(node) {
 }
 function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
   if (node == null) return false;
-  if (AST8__namespace.isJSX(node)) return true;
+  if (AST9__namespace.isJSX(node)) return true;
   switch (node.type) {
     case types.AST_NODE_TYPES.Literal: {
       switch (typeof node.value) {
@@ -1417,7 +1386,7 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
       if (name === "undefined") {
         return !(hint & JSXDetectionHint.SkipUndefined);
       }
-      if (AST8__namespace.isJSXTagNameExpression(node)) {
+      if (AST9__namespace.isJSXTagNameExpression(node)) {
         return true;
       }
       const variable = VAR3__namespace.findVariable(name, code.getScope(node));
@@ -1448,7 +1417,7 @@ function findParentAttribute(node, test = eff.constTrue) {
   const guard = (node2) => {
     return node2.type === types.AST_NODE_TYPES.JSXAttribute && test(node2);
   };
-  return AST8__namespace.findParentNode(node, guard);
+  return AST9__namespace.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);
@@ -1520,58 +1489,58 @@ function isPureComponent(node) {
   return false;
 }
 function isComponentDidCatch(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
 }
 function isComponentDidMount(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
 }
 function isComponentDidUpdate(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
 }
 function isComponentWillMount(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
 }
 function isComponentWillReceiveProps(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
 }
 function isComponentWillUnmount(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
 }
 function isComponentWillUpdate(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
 }
 function isGetChildContext(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
 }
 function isGetDefaultProps(node) {
-  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
+  return AST9__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
 }
 function isGetInitialState(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
 }
 function isGetSnapshotBeforeUpdate(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
 }
 function isShouldComponentUpdate(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
 function isUnsafeComponentWillMount(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
 }
 function isUnsafeComponentWillReceiveProps(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
 }
 function isUnsafeComponentWillUpdate(node) {
-  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
+  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
 }
 function isGetDerivedStateFromProps(node) {
-  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
+  return AST9__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
 }
 function isGetDerivedStateFromError(node) {
-  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
+  return AST9__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
 }
 function isRenderLike(node) {
-  return AST8__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 AST9__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
 }
 function isFunctionOfRender(node) {
   if (!isRenderLike(node.parent)) {
@@ -1580,7 +1549,7 @@ function isFunctionOfRender(node) {
   return isClassComponent(node.parent.parent.parent);
 }
 function isRenderMethodLike(node) {
-  return AST8__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 AST9__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;
 }
 
 // src/component/component-hierarchy.ts
@@ -1591,13 +1560,13 @@ function isChildrenOfCreateElement(context, node) {
   return parent.arguments.slice(2).some((arg) => arg === node);
 }
 function isInsideRenderMethod(node) {
-  return AST8__namespace.findParentNode(node, (n) => isRenderLike(n) && isClassComponent(n.parent.parent)) != null;
+  return AST9__namespace.findParentNode(node, (n) => isRenderLike(n) && isClassComponent(n.parent.parent)) != null;
 }
 function isFunctionOfComponentDidMount(node) {
-  return AST8__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+  return AST9__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfComponentWillUnmount(node) {
-  return AST8__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+  return AST9__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfRenderMethod(node) {
   if (!isRenderMethodLike(node.parent)) {
@@ -1637,12 +1606,12 @@ function isValidComponentDefinition(context, node, hint) {
   if (hint & ComponentDetectionHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) {
     return false;
   }
-  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST8__namespace.isArrayMapCall(node.parent)) {
+  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST9__namespace.isArrayMapCall(node.parent)) {
     return false;
   }
-  const significantParent = AST8__namespace.findParentNode(
+  const significantParent = AST9__namespace.findParentNode(
     node,
-    AST8__namespace.isOneOf([
+    AST9__namespace.isOneOf([
       types.AST_NODE_TYPES.JSXExpressionContainer,
       types.AST_NODE_TYPES.ArrowFunctionExpression,
       types.AST_NODE_TYPES.FunctionExpression,
@@ -1663,7 +1632,7 @@ function isComponentWrapperCallLoose(context, node) {
 
 // src/component/component-id.ts
 function getFunctionComponentId(context, node) {
-  const functionId = AST8__namespace.getFunctionIdentifier(node);
+  const functionId = AST9__namespace.getFunctionIdentifier(node);
   if (functionId != null) {
     return functionId;
   }
@@ -1690,10 +1659,10 @@ var ComponentFlag = {
 // src/component/component-init-path.ts
 function getComponentFlagFromInitPath(initPath) {
   let flag = ComponentFlag.None;
-  if (initPath != null && AST8__namespace.hasCallInFunctionInitPath("memo", initPath)) {
+  if (initPath != null && AST9__namespace.hasCallInFunctionInitPath("memo", initPath)) {
     flag |= ComponentFlag.Memo;
   }
-  if (initPath != null && AST8__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
+  if (initPath != null && AST9__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
     flag |= ComponentFlag.ForwardRef;
   }
   return flag;
@@ -1733,7 +1702,7 @@ function useComponentCollector(context, options = {}) {
     const entry = functionEntries.at(-1);
     if (entry == null) return;
     if (!entry.isComponent) return functionEntries.pop();
-    const shouldDrop = AST8__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
+    const shouldDrop = AST9__namespace.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) {
@@ -1760,7 +1729,7 @@ 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 = AST8__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST9__namespace.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       const key = shared.getId();
@@ -1801,7 +1770,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 = AST8__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST9__namespace.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       components.set(entry.key, {
@@ -1832,7 +1801,7 @@ function useComponentCollectorLegacy() {
     if (!isClassComponent(node)) {
       return;
     }
-    const id = AST8__namespace.getClassIdentifier(node);
+    const id = AST9__namespace.getClassIdentifier(node);
     const key = shared.getId();
     const flag = isPureComponent(node) ? ComponentFlag.PureComponent : ComponentFlag.None;
     components.set(
@@ -1865,7 +1834,7 @@ var ComponentPhaseRelevance = birecord__default.default({
 var isInversePhase = eff.dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
 function isRenderFunctionLoose(context, node) {
   const { body, parent } = node;
-  if (AST8__namespace.getFunctionIdentifier(node)?.name.startsWith("render")) {
+  if (AST9__namespace.getFunctionIdentifier(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");
   }
   return isJsxLike(
@@ -1878,7 +1847,7 @@ function isRenderPropLoose(context, node) {
   if (node.name.type !== types.AST_NODE_TYPES.JSXIdentifier) {
     return false;
   }
-  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST8__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
+  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST9__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
 }
 function isDirectValueOfRenderPropertyLoose(node) {
   const matching = (node2) => {
@@ -1890,7 +1859,7 @@ function isDeclaredInRenderPropLoose(node) {
   if (isDirectValueOfRenderPropertyLoose(node)) {
     return true;
   }
-  const parent = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  const parent = AST9__namespace.findParentNode(node, AST9__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
   if (parent?.type !== types.AST_NODE_TYPES.JSXAttribute) {
     return false;
   }
@@ -1898,11 +1867,11 @@ function isDeclaredInRenderPropLoose(node) {
 }
 function isThisSetState(node) {
   const { callee } = node;
-  return callee.type === types.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+  return callee.type === types.AST_NODE_TYPES.MemberExpression && AST9__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 function isAssignmentToThisState(node) {
   const { left } = node;
-  return left.type === types.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(left.object) && AST8__namespace.getPropertyName(left.property) === "state";
+  return left.type === types.AST_NODE_TYPES.MemberExpression && AST9__namespace.isThisExpression(left.object) && AST9__namespace.getPropertyName(left.property) === "state";
 }
 
 exports.ComponentDetectionHint = ComponentDetectionHint;
@@ -1925,8 +1894,6 @@ exports.hasAttribute = hasAttribute;
 exports.hasEveryAttribute = hasEveryAttribute;
 exports.hasNoneOrLooseComponentName = hasNoneOrLooseComponentName;
 exports.isAssignmentToThisState = isAssignmentToThisState;
-exports.isCallFromReact = isCallFromReact;
-exports.isCallFromReactObject = isCallFromReactObject;
 exports.isCaptureOwnerStack = isCaptureOwnerStack;
 exports.isCaptureOwnerStackCall = isCaptureOwnerStackCall;
 exports.isChildrenCount = isChildrenCount;
@@ -1965,10 +1932,6 @@ exports.isDirectValueOfRenderPropertyLoose = isDirectValueOfRenderPropertyLoose;
 exports.isForwardRef = isForwardRef;
 exports.isForwardRefCall = isForwardRefCall;
 exports.isFragmentElement = isFragmentElement;
-exports.isFromReact = isFromReact;
-exports.isFromReactLoose = isFromReactLoose;
-exports.isFromReactObject = isFromReactObject;
-exports.isFromReactStrict = isFromReactStrict;
 exports.isFunctionOfComponentDidMount = isFunctionOfComponentDidMount;
 exports.isFunctionOfComponentWillUnmount = isFunctionOfComponentWillUnmount;
 exports.isFunctionOfRender = isFunctionOfRender;