@eslint-react/core 5.24.1 → 5.24.2

package/dist/index.js

@@ -7,11 +7,6 @@ import { P, isMatching, match } from "ts-pattern";
 import ts from "typescript";
 
 //#region src/api.ts
-/**
-* Check if the node is a React API identifier or member expression.
-* @param api The React API name to check against (ex: "useState", "React.memo").
-* @returns A predicate function to check if a node matches the API.
-*/
 function isAPI(api) {
 	const func = (context, node) => {
 		if (node == null) return false;
@@ -25,11 +20,6 @@ function isAPI(api) {
 	}
 	return dual;
 }
-/**
-* Check if the node is a call expression to a specific React API.
-* @param api The React API name to check against.
-* @returns A predicate function to check if a node is a call to the API.
-*/
 function isAPICall(api) {
 	const func = (context, node) => {
 		if (node == null) return false;
@@ -41,157 +31,181 @@ function isAPICall(api) {
 	}
 	return dual;
 }
-/** Check if the node is a React `captureOwnerStack` API identifier or member expression. */
 const isCaptureOwnerStack = isAPI("captureOwnerStack");
-/** Check if the node is a React `Children.count` API identifier or member expression. */
 const isChildrenCount = isAPI("Children.count");
-/** Check if the node is a React `Children.forEach` API identifier or member expression. */
 const isChildrenForEach = isAPI("Children.forEach");
-/** Check if the node is a React `Children.map` API identifier or member expression. */
 const isChildrenMap = isAPI("Children.map");
-/** Check if the node is a React `Children.only` API identifier or member expression. */
 const isChildrenOnly = isAPI("Children.only");
-/** Check if the node is a React `Children.toArray` API identifier or member expression. */
 const isChildrenToArray = isAPI("Children.toArray");
-/** Check if the node is a React `cloneElement` API identifier or member expression. */
 const isCloneElement = isAPI("cloneElement");
-/** Check if the node is a React `createContext` API identifier or member expression. */
 const isCreateContext = isAPI("createContext");
-/** Check if the node is a React `createElement` API identifier or member expression. */
 const isCreateElement = isAPI("createElement");
-/** Check if the node is a React `createRef` API identifier or member expression. */
 const isCreateRef = isAPI("createRef");
-/** Check if the node is a React `forwardRef` API identifier or member expression. */
 const isForwardRef = isAPI("forwardRef");
-/** Check if the node is a React `memo` API identifier or member expression. */
 const isMemo = isAPI("memo");
-/** Check if the node is a React `lazy` API identifier or member expression. */
 const isLazy = isAPI("lazy");
-/** Check if the node is a call expression to the React `captureOwnerStack` API. */
 const isCaptureOwnerStackCall = isAPICall("captureOwnerStack");
-/** Check if the node is a call expression to the React `Children.count` API. */
 const isChildrenCountCall = isAPICall("Children.count");
-/** Check if the node is a call expression to the React `Children.forEach` API. */
 const isChildrenForEachCall = isAPICall("Children.forEach");
-/** Check if the node is a call expression to the React `Children.map` API. */
 const isChildrenMapCall = isAPICall("Children.map");
-/** Check if the node is a call expression to the React `Children.only` API. */
 const isChildrenOnlyCall = isAPICall("Children.only");
-/** Check if the node is a call expression to the React `Children.toArray` API. */
 const isChildrenToArrayCall = isAPICall("Children.toArray");
-/** Check if the node is a call expression to the React `cloneElement` API. */
 const isCloneElementCall = isAPICall("cloneElement");
-/** Check if the node is a call expression to the React `createContext` API. */
 const isCreateContextCall = isAPICall("createContext");
-/** Check if the node is a call expression to the React `createElement` API. */
 const isCreateElementCall = isAPICall("createElement");
-/** Check if the node is a call expression to the React `createRef` API. */
 const isCreateRefCall = isAPICall("createRef");
-/** Check if the node is a call expression to the React `forwardRef` API. */
 const isForwardRefCall = isAPICall("forwardRef");
-/** Check if the node is a call expression to the React `memo` API. */
 const isMemoCall = isAPICall("memo");
-/** Check if the node is a call expression to the React `lazy` API. */
 const isLazyCall = isAPICall("lazy");
-/** Check if the node is a React `use` API identifier or member expression. */
 const isUse = isAPI("use");
-/** Check if the node is a React `useActionState` API identifier or member expression. */
 const isUseActionState = isAPI("useActionState");
-/** Check if the node is a React `useCallback` API identifier or member expression. */
 const isUseCallback = isAPI("useCallback");
-/** Check if the node is a React `useContext` API identifier or member expression. */
 const isUseContext = isAPI("useContext");
-/** Check if the node is a React `useDebugValue` API identifier or member expression. */
 const isUseDebugValue = isAPI("useDebugValue");
-/** Check if the node is a React `useDeferredValue` API identifier or member expression. */
 const isUseDeferredValue = isAPI("useDeferredValue");
-/** Check if the node is a React `useEffect` API identifier or member expression. */
 const isUseEffect = isAPI("useEffect");
-/** Check if the node is a React `useFormStatus` API identifier or member expression. */
 const isUseFormStatus = isAPI("useFormStatus");
-/** Check if the node is a React `useId` API identifier or member expression. */
 const isUseId = isAPI("useId");
-/** Check if the node is a React `useImperativeHandle` API identifier or member expression. */
 const isUseImperativeHandle = isAPI("useImperativeHandle");
-/** Check if the node is a React `useInsertionEffect` API identifier or member expression. */
 const isUseInsertionEffect = isAPI("useInsertionEffect");
-/** Check if the node is a React `useLayoutEffect` API identifier or member expression. */
 const isUseLayoutEffect = isAPI("useLayoutEffect");
-/** Check if the node is a React `useMemo` API identifier or member expression. */
 const isUseMemo = isAPI("useMemo");
-/** Check if the node is a React `useOptimistic` API identifier or member expression. */
 const isUseOptimistic = isAPI("useOptimistic");
-/** Check if the node is a React `useReducer` API identifier or member expression. */
 const isUseReducer = isAPI("useReducer");
-/** Check if the node is a React `useRef` API identifier or member expression. */
 const isUseRef = isAPI("useRef");
-/** Check if the node is a React `useState` API identifier or member expression. */
 const isUseState = isAPI("useState");
-/** Check if the node is a React `useSyncExternalStore` API identifier or member expression. */
 const isUseSyncExternalStore = isAPI("useSyncExternalStore");
-/** Check if the node is a React `useTransition` API identifier or member expression. */
 const isUseTransition = isAPI("useTransition");
-/** Check if the node is a call expression to the React `use` API. */
 const isUseCall = isAPICall("use");
-/** Check if the node is a call expression to the React `useActionState` API. */
 const isUseActionStateCall = isAPICall("useActionState");
-/** Check if the node is a call expression to the React `useCallback` API. */
 const isUseCallbackCall = isAPICall("useCallback");
-/** Check if the node is a call expression to the React `useContext` API. */
 const isUseContextCall = isAPICall("useContext");
-/** Check if the node is a call expression to the React `useDebugValue` API. */
 const isUseDebugValueCall = isAPICall("useDebugValue");
-/** Check if the node is a call expression to the React `useDeferredValue` API. */
 const isUseDeferredValueCall = isAPICall("useDeferredValue");
-/** Check if the node is a call expression to the React `useEffect` API. */
 const isUseEffectCall = isAPICall("useEffect");
-/** Check if the node is a call expression to the React `useFormStatus` API. */
 const isUseFormStatusCall = isAPICall("useFormStatus");
-/** Check if the node is a call expression to the React `useId` API. */
 const isUseIdCall = isAPICall("useId");
-/** Check if the node is a call expression to the React `useImperativeHandle` API. */
 const isUseImperativeHandleCall = isAPICall("useImperativeHandle");
-/** Check if the node is a call expression to the React `useInsertionEffect` API. */
 const isUseInsertionEffectCall = isAPICall("useInsertionEffect");
-/** Check if the node is a call expression to the React `useLayoutEffect` API. */
 const isUseLayoutEffectCall = isAPICall("useLayoutEffect");
-/** Check if the node is a call expression to the React `useMemo` API. */
 const isUseMemoCall = isAPICall("useMemo");
-/** Check if the node is a call expression to the React `useOptimistic` API. */
 const isUseOptimisticCall = isAPICall("useOptimistic");
-/** Check if the node is a call expression to the React `useReducer` API. */
 const isUseReducerCall = isAPICall("useReducer");
-/** Check if the node is a call expression to the React `useRef` API. */
 const isUseRefCall = isAPICall("useRef");
-/** Check if the node is a call expression to the React `useState` API. */
 const isUseStateCall = isAPICall("useState");
-/** Check if the node is a call expression to the React `useSyncExternalStore` API. */
 const isUseSyncExternalStoreCall = isAPICall("useSyncExternalStore");
-/** Check if the node is a call expression to the React `useTransition` API. */
 const isUseTransitionCall = isAPICall("useTransition");
 
 //#endregion
 //#region src/class.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 ../../.pkgs/eff/dist/index.js
+const pipeArguments = (self, args) => {
+	switch (args.length) {
+		case 0: return self;
+		case 1: return args[0](self);
+		case 2: return args[1](args[0](self));
+		case 3: return args[2](args[1](args[0](self)));
+		case 4: return args[3](args[2](args[1](args[0](self))));
+		case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
+		case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+		case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+		case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+		case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+		default: {
+			let ret = self;
+			for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
+			return ret;
+		}
+	}
+};
+const Prototype = { pipe() {
+	return pipeArguments(this, arguments);
+} };
+const Class = (function() {
+	function PipeableBase() {}
+	PipeableBase.prototype = Prototype;
+	return PipeableBase;
+})();
+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);
+			};
+		};
+	}
+};
+const identity = (a) => a;
+const cast = identity;
+const constant = (value) => () => value;
+const constTrue = constant(true);
+const constFalse = constant(false);
+const constNull = constant(null);
+const constUndefined = constant(void 0);
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+const absurd = (_) => {
+	throw new Error("Called `absurd` function which should be uncallable");
+};
+const hole = cast(absurd);
+const and = dual(2, (a, b) => (data) => a(data) && b(data));
+const or = dual(2, (a, b) => (data) => a(data) || b(data));
+const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
+const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
+const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
+const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
+const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
+function isFunction(input) {
+	return typeof input === "function";
+}
+function isObjectKeyword(input) {
+	return typeof input === "object" && input !== null || isFunction(input);
+}
+const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
+const dropWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
+	let idx = 0;
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(idx);
+});
+const takeWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
+	let idx = 0;
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
+});
+
 //#endregion
 //#region src/class-component.ts
-/**
-* Check if the node is a class component (extends `Component` or `PureComponent`).
-* @param node The node to check.
-* @returns `true` if the node is a class component.
-*/
 function isClassComponent(node) {
-	if ("superClass" in node && node.superClass != null) {
+	if (hasProperty(node, "superClass") && node.superClass != null) {
 		const re = /^(?:Pure)?Component$/u;
 		switch (true) {
 			case Check.isIdentifier(node.superClass): return re.test(node.superClass.name);
@@ -200,14 +214,8 @@ function isClassComponent(node) {
 	}
 	return false;
 }
-/**
-* Check if the node is a pure component (extends `PureComponent`).
-* @param node The AST node to check.
-* @returns `true` if the node is a pure component.
-* @deprecated Class components are legacy. This function exists only to support legacy rules.
-*/
 function isPureComponent(node) {
-	if ("superClass" in node && node.superClass != null) {
+	if (hasProperty(node, "superClass") && node.superClass != null) {
 		const re = /^PureComponent$/u;
 		switch (true) {
 			case Check.isIdentifier(node.superClass): return re.test(node.superClass.name);
@@ -219,68 +227,33 @@ function isPureComponent(node) {
 function createLifecycleChecker(methodName, isStatic = false) {
 	return (node) => Check.isPropertyOrMethod(node) && node.static === isStatic && Check.isIdentifier(node.key, methodName);
 }
-/** @deprecated Class components are legacy. */
 const isRender = createLifecycleChecker("render");
-/** @deprecated Class components are legacy. */
 const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
-/** @deprecated Class components are legacy. */
 const isComponentDidMount = createLifecycleChecker("componentDidMount");
-/** @deprecated Class components are legacy. */
 const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate");
-/** @deprecated Class components are legacy. */
 const isComponentWillMount = createLifecycleChecker("componentWillMount");
-/** @deprecated Class components are legacy. */
 const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps");
-/** @deprecated Class components are legacy. */
 const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount");
-/** @deprecated Class components are legacy. */
 const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate");
-/** @deprecated Class components are legacy. */
 const isGetChildContext = createLifecycleChecker("getChildContext");
-/** @deprecated Class components are legacy. */
 const isGetInitialState = createLifecycleChecker("getInitialState");
-/** @deprecated Class components are legacy. */
 const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate");
-/** @deprecated Class components are legacy. */
 const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate");
-/** @deprecated Class components are legacy. */
 const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount");
-/** @deprecated Class components are legacy. */
 const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
-/** @deprecated Class components are legacy. */
 const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
-/** @deprecated Class components are legacy. */
 const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
-/** @deprecated Class components are legacy. */
 const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
-/** @deprecated Class components are legacy. */
 const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStateFromError", true);
-/**
-* Check if the node is a render-like method of a class component.
-* @param node The AST node to check.
-* @returns `true` if the node is a render-like method.
-* @deprecated Class components are legacy. This function exists only to support legacy rules.
-*/
 function isRenderMethodLike(node) {
 	return Check.isPropertyOrMethod(node) && Check.isIdentifier(node.key) && node.key.name.startsWith("render") && Check.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression])(node.parent.parent);
 }
-/**
-* Check if the function is a callback passed to a class component's render method.
-* @param node The function node to check.
-* @returns `true` if the function is a render method callback.
-*/
 function isRenderMethodCallback(node) {
 	const parent = node.parent;
 	const greatGrandparent = parent.parent?.parent;
 	if (greatGrandparent == null) return false;
 	return isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
 }
-/**
-* Check if the call expression is a `this.setState(...)` call.
-* @param node The call expression node to check.
-* @returns `true` if the node is a `this.setState(...)` call.
-* @deprecated Class components are legacy. This function exists only to support legacy rules.
-*/
 function isThisSetStateCall(node) {
 	const callee = Extract.unwrap(node.callee);
 	return callee.type === AST_NODE_TYPES.MemberExpression && Extract.unwrap(callee.object).type === AST_NODE_TYPES.ThisExpression && Extract.getCalleeName(node) === "setState";
@@ -288,11 +261,6 @@ function isThisSetStateCall(node) {
 
 //#endregion
 //#region src/class-component-collector.ts
-/**
-* Get an api and visitor object for the rule to collect class components.
-* @param context The rule context.
-* @deprecated Class components are legacy. This function exists only to support legacy rules.
-*/
 function getClassComponentCollector(context) {
 	const components = /* @__PURE__ */ new Map();
 	const getText = (n) => context.sourceCode.getText(n);
@@ -326,27 +294,10 @@ function getClassComponentCollector(context) {
 
 //#endregion
 //#region src/create-element.ts
-/**
-* Get the type argument (the first argument) of a `createElement` call.
-* @param context The ESLint rule context.
-* @param node The node to inspect.
-* @returns The type argument, or `null` when the node is not a `createElement` call or has no arguments.
-*/
 function getCreateElementTypeArgument(context, node) {
 	if (!isCreateElementCall(context, node)) return null;
 	return node.arguments[0] ?? null;
 }
-/**
-* Get the props object (the second argument) of a `createElement` call.
-*
-* Type expressions and chain expressions wrapping the argument are unwrapped
-* before the object check; `null`, spread, or otherwise non-object props
-* arguments yield `null`.
-*
-* @param context The ESLint rule context.
-* @param node The node to inspect.
-* @returns The props `ObjectExpression`, or `null` when absent or not statically an object literal.
-*/
 function getCreateElementPropsObject(context, node) {
 	if (!isCreateElementCall(context, node)) return null;
 	const propsArg = node.arguments[1];
@@ -354,57 +305,21 @@ function getCreateElementPropsObject(context, node) {
 	const expr = Extract.unwrap(propsArg);
 	return expr.type === AST_NODE_TYPES.ObjectExpression ? expr : null;
 }
-/**
-* Get the children arguments (the arguments after the props object) of a `createElement` call.
-* @param context The ESLint rule context.
-* @param node The node to inspect.
-* @returns The children arguments, or an empty array when the node is not a `createElement` call.
-*/
 function getCreateElementChildrenArguments(context, node) {
 	if (!isCreateElementCall(context, node)) return [];
 	return node.arguments.slice(2);
 }
-/**
-* Find a statically named property in the props object of a `createElement` call.
-*
-* Statically resolvable names include plain identifier keys as well as
-* string-literal and simple template-literal keys (computed or not).
-* @param context The ESLint rule context.
-* @param node The node to inspect.
-* @param name The property name to look for (ex: `"children"`, `"key"`).
-* @returns The matching `Property` node, or `null` when the call has no static property with that name.
-*
-* @example
-* ```ts
-* import { getCreateElementProp } from "@eslint-react/core";
-*
-* const childrenProp = getCreateElementProp(context, node, "children");
-* ```
-*/
 function getCreateElementProp(context, node, name) {
 	const propsObject = getCreateElementPropsObject(context, node);
 	if (propsObject == null) return null;
 	for (const prop of propsObject.properties) if (prop.type === AST_NODE_TYPES.Property && Extract.getPropertyName(prop, "max") === name) return prop;
 	return null;
 }
-/**
-* Check if the node is passed as a children argument (the third argument or
-* later) of a `createElement` call.
-* @param context The ESLint rule context.
-* @param node The node to check.
-* @returns `true` if the node is a direct children argument of a `createElement` call.
-*/
 function isCreateElementChildrenArgument(context, node) {
 	let parent = node.parent;
 	while (Check.isTypeExpression(parent)) parent = parent.parent;
 	return parent?.type === AST_NODE_TYPES.CallExpression && isCreateElementCall(context, parent) && parent.arguments.slice(2).some((arg) => Extract.unwrap(arg) === node);
 }
-/**
-* Check if the node is inside the props object (the second argument) of a `createElement` call.
-* @param context The ESLint rule context.
-* @param node The node to check.
-* @returns `true` if the node is inside `createElement`'s props object.
-*/
 function isInsideCreateElementProps(context, node) {
 	const call = Traverse.findParent(node, isCreateElementCall(context));
 	if (call == null) return false;
@@ -415,23 +330,9 @@ function isInsideCreateElementProps(context, node) {
 
 //#endregion
 //#region src/function.ts
-/**
-* Get the static identifier of a function AST node.
-*
-* @remarks
-* For function declarations this is straightforward. For anonymous function
-* expressions it is more complex. This function roughly detects the same AST
-* nodes as the ECMAScript spec's `IsAnonymousFunctionDefinition()` with some
-* exceptions to better fit our use case.
-*
-* Ported from {@link https://github.com/facebook/react/blob/bb8a76c6cc77ea2976d690ea09f5a1b3d9b1792a/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L860 | RulesOfHooks.ts}
-*
-* @param node The function node to analyze.
-* @returns The identifier node if found, `null` otherwise.
-*/
 function getFunctionId(node) {
 	switch (true) {
-		case "id" in node && node.id != null: return node.id;
+		case hasProperty(node, "id") && 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;
@@ -442,12 +343,6 @@ function getFunctionId(node) {
 	}
 	return null;
 }
-/**
-* Get the initialization path of a function node in the AST.
-*
-* @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;
@@ -493,36 +388,18 @@ function getFunctionInitPath(node) {
 	}
 	return null;
 }
-/**
-* Check if a specific function call exists in the function initialization path.
-*
-* @param callName The name of the call to check for (e.g., "memo", "forwardRef").
-* @param initPath The function initialization path to search in.
-* @returns `true` if the call exists in the path, `false` otherwise.
-*/
 function isFunctionHasCallInInitPath(callName, initPath) {
 	return initPath.some((node) => {
 		if (node.type !== AST_NODE_TYPES.CallExpression) return false;
 		const callee = Extract.unwrap(node.callee);
 		if (Check.isIdentifier(callee)) return callee.name === callName;
-		if (callee.type === AST_NODE_TYPES.MemberExpression && "name" in callee.property) return callee.property.name === callName;
+		if (callee.type === AST_NODE_TYPES.MemberExpression && hasProperty(callee.property, "name")) return callee.property.name === callName;
 		return false;
 	});
 }
-/**
-* 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;
 }
-/**
-* Get the directives of a function (ex: "use strict", "use client", "use server").
-* @param node The function node to get the directives from.
-* @returns The directives of the function.
-*/
 function getFunctionDirectives(node) {
 	const directives = [];
 	if (node.body.type !== AST_NODE_TYPES.BlockStatement) return directives;
@@ -535,17 +412,9 @@ function getFunctionDirectives(node) {
 	}
 	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 (e.g., "use memo", "use no memo").
-* @returns `true` if the directive exists, `false` otherwise.
-*/
 function isFunctionHasDirective(node, name) {
 	return getFunctionDirectives(node).some((d) => d.directive === name);
 }
-/** The esquery selector matching `displayName` assignment expressions. */
 const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT = [
 	"AssignmentExpression",
 	"[operator='=']",
@@ -555,67 +424,21 @@ const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT = [
 
 //#endregion
 //#region src/jsx.ts
-/**
-* Hints for JSX detection.
-*/
 const JsxDetectionHint = {
-	/** No hints set. */
 	None: 0n,
-	/** Do not treat `null` values as JSX-like. */
 	DoNotIncludeJsxWithNullValue: 1n << 0n,
-	/** Do not treat number values as JSX-like. */
 	DoNotIncludeJsxWithNumberValue: 1n << 1n,
-	/** Do not treat bigint values as JSX-like. */
 	DoNotIncludeJsxWithBigIntValue: 1n << 2n,
-	/** Do not treat string values as JSX-like. */
 	DoNotIncludeJsxWithStringValue: 1n << 3n,
-	/** Do not treat boolean values as JSX-like. */
 	DoNotIncludeJsxWithBooleanValue: 1n << 4n,
-	/** Do not treat undefined values as JSX-like. */
 	DoNotIncludeJsxWithUndefinedValue: 1n << 5n,
-	/** Do not treat empty array values as JSX-like. */
 	DoNotIncludeJsxWithEmptyArrayValue: 1n << 6n,
-	/** Do not treat `createElement` calls as JSX-like. */
 	DoNotIncludeJsxWithCreateElementValue: 1n << 7n,
-	/** Require all array elements to be JSX-like for the array to be JSX-like. */
 	RequireAllArrayElementsToBeJsx: 1n << 8n,
-	/** Require both sides of a logical expression to be JSX-like. */
 	RequireBothSidesOfLogicalExpressionToBeJsx: 1n << 9n,
-	/** Require both branches of a conditional expression to be JSX-like. */
 	RequireBothBranchesOfConditionalExpressionToBeJsx: 1n << 10n
 };
-/**
-* Default JSX detection hint.
-*
-* Skips number, bigint, boolean, string, and undefined literals,
-* the value types that are commonly returned alongside JSX in React
-* components but are not themselves renderable elements.
-*/
 const DEFAULT_JSX_DETECTION_HINT = 0n | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue;
-/**
-* Check if the node represents JSX-like content based on heuristics.
-*
-* The detection behavior is configurable through {@link JsxDetectionHint}
-* bit-flags so that callers can opt individual value kinds in or out.
-*
-* Identifiers are resolved to their definitions via scope analysis;
-* circular definitions (e.g. `var a = b; var b = a;`) are detected and
-* treated as not JSX-like instead of recursing indefinitely.
-*
-* @param context The ESLint rule context (needed for variable resolution).
-* @param node The AST node to analyze.
-* @param hint Optional bit-flags to adjust detection behavior. Defaults to {@link DEFAULT_JSX_DETECTION_HINT}.
-* @returns Whether the node is considered JSX-like.
-*
-* @example
-* ```ts
-* import { isJsxLike } from "@eslint-react/core";
-*
-* if (isJsxLike(context, node)) {
-*   // node looks like it evaluates to a React element
-* }
-* ```
-*/
 function isJsxLike(context, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 	const seen = /* @__PURE__ */ new Set();
 	function visit(node) {
@@ -655,49 +478,23 @@ function isJsxLike(context, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 
 //#endregion
 //#region src/function-component.ts
-/**
-* Component flag constants.
-*/
 const FunctionComponentFlag = {
-	/** No flags set. */
 	None: 0n,
-	/** Indicates the component is a pure component (ex: extends PureComponent). */
 	PureComponent: 1n << 0n,
-	/** Indicates the component creates elements using `createElement` instead of JSX. */
 	CreateElement: 1n << 1n,
-	/** Indicates the component is memoized (ex: React.memo). */
 	Memo: 1n << 2n,
-	/** Indicates the component forwards a ref (ex: React.forwardRef). */
 	ForwardRef: 1n << 3n
 };
-/**
-* Get component flag from init path.
-* @param initPath The init path of the function component.
-* @returns The component flag.
-* @internal
-*/
 function getFunctionComponentFlagFromInitPath(initPath) {
 	let flag = FunctionComponentFlag.None;
 	if (initPath != null && isFunctionHasCallInInitPath("memo", initPath)) flag |= FunctionComponentFlag.Memo;
 	if (initPath != null && isFunctionHasCallInInitPath("forwardRef", initPath)) flag |= FunctionComponentFlag.ForwardRef;
 	return flag;
 }
-/**
-* Check if the node is a call expression for a component wrapper.
-* @param context The ESLint rule context.
-* @param node The node to check.
-* @returns `true` if the node is a call expression for a component wrapper.
-*/
 function isFunctionComponentWrapperCall(context, node) {
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
 	return isMemoCall(context, node) || isForwardRefCall(context, node);
 }
-/**
-* Check if the node is a callback function passed to a component wrapper.
-* @param context The ESLint rule context.
-* @param node The node to check.
-* @returns `true` if the node is a callback function passed to a component wrapper.
-*/
 function isFunctionComponentWrapperCallback(context, node) {
 	if (!Check.isFunction(node)) return false;
 	let parent = node.parent;
@@ -705,12 +502,6 @@ function isFunctionComponentWrapperCallback(context, node) {
 	if (parent.type !== AST_NODE_TYPES.CallExpression) return false;
 	return isFunctionComponentWrapperCall(context, parent);
 }
-/**
-* Get function component identifier from `const Component = memo(() => {});`.
-* @param context The rule context.
-* @param node The AST node to get the function component identifier from.
-* @internal
-*/
 function getFunctionComponentId(context, node) {
 	const functionId = getFunctionId(node);
 	if (functionId != null) return functionId;
@@ -722,29 +513,12 @@ function getFunctionComponentId(context, node) {
 		default: return null;
 	}
 }
-/**
-* Check if a string matches the strict component name pattern.
-* @param name The name to check.
-* @returns `true` if the name matches the strict component name pattern.
-*/
 function isFunctionComponentName(name) {
 	return RE_COMPONENT_NAME.test(name);
 }
-/**
-* Check if a string matches the loose component name pattern.
-* @param name The name to check.
-* @returns `true` if the name matches the loose component name pattern.
-*/
 function isFunctionComponentNameLoose(name) {
 	return RE_COMPONENT_NAME_LOOSE.test(name);
 }
-/**
-* Check if a function has a loose component name.
-* @param context The rule context.
-* @param fn The function to check.
-* @param allowNone Whether to allow no name.
-* @returns `true` if the function has a loose component name.
-*/
 function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 	const id = getFunctionComponentId(context, fn);
 	if (id == null) return allowNone;
@@ -752,40 +526,18 @@ function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 	if (id.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(id.property)) return isFunctionComponentNameLoose(id.property.name);
 	return false;
 }
-/**
-* Hints for component collector.
-*/
 const FunctionComponentDetectionHint = {
 	...JsxDetectionHint,
-	/** Exclude functions defined as class methods from component detection. */
 	DoNotIncludeFunctionDefinedAsClassMethod: 1n << 11n,
-	/** Exclude functions defined as class properties from component detection. */
 	DoNotIncludeFunctionDefinedAsClassProperty: 1n << 12n,
-	/** Exclude functions defined as object methods from component detection. */
 	DoNotIncludeFunctionDefinedAsObjectMethod: 1n << 13n,
-	/** Exclude functions defined as array expression elements from component detection. */
 	DoNotIncludeFunctionDefinedAsArrayExpressionElement: 1n << 14n,
-	/** Exclude functions defined as array pattern elements from component detection. */
 	DoNotIncludeFunctionDefinedAsArrayPatternElement: 1n << 15n,
-	/** Exclude functions defined as array flatMap callbacks from component detection. */
 	DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: 1n << 16n,
-	/** Exclude functions defined as array map callbacks from component detection. */
 	DoNotIncludeFunctionDefinedAsArrayMapCallback: 1n << 17n,
-	/** Exclude functions defined as arbitrary call expression callbacks from component detection. */
 	DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback: 1n << 18n
 };
-/**
-* Default component detection hint.
-*/
 const DEFAULT_COMPONENT_DETECTION_HINT = 0n | FunctionComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithNumberValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithStringValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | FunctionComponentDetectionHint.RequireAllArrayElementsToBeJsx | FunctionComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | FunctionComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
-/**
-* Check if the function node is a valid React component definition.
-*
-* @param context The rule context.
-* @param node The function node to analyze.
-* @param hint Component detection hints (bit flags) to customize detection logic.
-* @returns `true` if the node is considered a component definition.
-*/
 function isFunctionComponentDefinition(context, node, hint) {
 	if (!isFunctionWithLooseComponentName(context, node, true)) return false;
 	let parent = node.parent;
@@ -828,783 +580,8 @@ function isFunctionComponentDefinition(context, node, hint) {
 	return significantParent.type !== AST_NODE_TYPES.JSXExpressionContainer;
 }
 
-//#endregion
-//#region ../../.pkgs/eff/dist/index.js
-/**
-* Applies a `pipe` method's variadic arguments to an initial value from left
-* to right.
-*
-* **When to use**
-*
-* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
-* object.
-*
-* **Details**
-*
-* This helper is intended for implementing `Pipeable.pipe` methods that
-* receive JavaScript's `arguments` object. With no functions it returns the
-* original value; otherwise it feeds each result into the next function.
-*
-* **Example** (Implementing a pipe method)
-*
-* ```ts
-* import { Pipeable } from "effect"
-*
-* class NumberBox {
-*   constructor(readonly value: number) {}
-*
-*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
-*     return Pipeable.pipeArguments(this.value, arguments) as number
-*   }
-* }
-*
-* const result = new NumberBox(5).pipe(
-*   (n) => n + 2,
-*   (n) => n * 3
-* )
-* result // => 21
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
-const pipeArguments = (self, args) => {
-	switch (args.length) {
-		case 0: return self;
-		case 1: return args[0](self);
-		case 2: return args[1](args[0](self));
-		case 3: return args[2](args[1](args[0](self)));
-		case 4: return args[3](args[2](args[1](args[0](self))));
-		case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
-		case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
-		case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
-		case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
-		case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
-		default: {
-			let ret = self;
-			for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
-			return ret;
-		}
-	}
-};
-/**
-* Reusable prototype that implements `Pipeable.pipe`.
-*
-* **When to use**
-*
-* Use when classes or object prototypes can reuse this value when they need the
-* standard pipe implementation backed by `pipeArguments`.
-*
-* @category prototypes
-* @since 3.15.0
-*/
-const Prototype = { pipe() {
-	return pipeArguments(this, arguments);
-} };
-/**
-* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
-* method.
-*
-* **When to use**
-*
-* Use when you need to define a class that supports Effect-style method
-* chaining through `.pipe(...)`.
-*
-* @category constructors
-* @since 3.15.0
-*/
-const Class = (function() {
-	function PipeableBase() {}
-	PipeableBase.prototype = Prototype;
-	return PipeableBase;
-})();
-/**
-* Creates a function that can be called in data-first style or data-last
-* (`pipe`-friendly) style.
-*
-* **When to use**
-*
-* Use to expose one implementation through both direct and `pipe`-friendly
-* call styles.
-*
-* **Details**
-*
-* Pass either the arity of the uncurried function or a predicate that decides
-* whether the current call is data-first. Arity is the common case. Use a
-* predicate when optional arguments make arity ambiguous.
-*
-* **Example** (Selecting data-first or data-last style by arity)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* sum(2, 3) // => 5
-* pipe(2, sum(3)) // => 5
-* ```
-*
-* **Example** (Defining overloads with call signatures)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = Function.dual(2, (self: number, that: number): number => self + that)
-*
-* sum(2, 3) // => 5
-* pipe(2, sum(3)) // => 5
-* ```
-*
-* **Example** (Selecting data-first or data-last style with a predicate)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* sum(2, 3) // => 5
-* pipe(2, sum(3)) // => 5
-* ```
-*
-* @category combinators
-* @since 2.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);
-			};
-		};
-	}
-};
-/**
-* Returns its input argument unchanged.
-*
-* **When to use**
-*
-* Use to return a value unchanged where a function is required.
-*
-* **Example** (Returning the same value)
-*
-* ```ts
-* import { identity } from "effect"
-*
-* identity(5) // => 5
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
-const identity = (a) => a;
-/**
-* Returns the input value with a different static type.
-*
-* **When to use**
-*
-* Use when you need an explicit type-level cast and accept that the value is
-* returned unchanged at runtime.
-*
-* **Gotchas**
-*
-* This is a type-level cast only; it performs no runtime validation or
-* conversion.
-*
-* @see {@link satisfies} for checking assignability without changing the resulting type
-*
-* @category utility types
-* @since 4.0.0
-*/
-const cast = identity;
-/**
-* Creates a zero-argument function that always returns the provided value.
-*
-* **When to use**
-*
-* Use when you need a thunk or callback that returns the same value on every
-* invocation.
-*
-* **Example** (Creating a constant thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* const constNull = Function.constant(null)
-*
-* constNull() // => null
-* constNull() // => null
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const constant = (value) => () => value;
-/**
-* Returns `true` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `true` on every invocation.
-*
-* **Example** (Returning true from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constTrue() // => true
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constTrue = constant(true);
-/**
-* Returns `false` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `false` on every invocation.
-*
-* **Example** (Returning false from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constFalse() // => false
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constFalse = constant(false);
-/**
-* Returns `null` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `null` on every invocation.
-*
-* **Example** (Returning null from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constNull() // => null
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constNull = constant(null);
-/**
-* Returns `undefined` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `undefined` on every invocation.
-*
-* **Example** (Returning undefined from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constUndefined() // => undefined
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constUndefined = constant(void 0);
-/**
-* 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`.
-*
-* **When to use**
-*
-* Use to compose exactly two unary functions into a reusable unary function.
-*
-* **Example** (Composing two functions)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* const increment = (n: number) => n + 1
-* const square = (n: number) => n * n
-*
-* Function.compose(increment, square)(2) // => 9
-* ```
-*
-* @see {@link flow} for composing a left-to-right sequence of functions
-* @see {@link pipe} for applying a value through a left-to-right sequence immediately
-*
-* @category combinators
-* @since 2.0.0
-*/
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-/**
-* Marks an impossible branch by accepting a `never` value and returning any
-* type.
-*
-* **When to use**
-*
-* Use when you need a return value in a branch that exhaustive checks prove
-* cannot be reached.
-*
-* **Gotchas**
-*
-* Calling `absurd` throws, because a value of type `never` should be
-* impossible at runtime.
-*
-* **Example** (Handling impossible values)
-*
-* ```ts
-* import { absurd } from "effect"
-*
-* const handleNever = (value: never) => {
-*   return absurd(value) // This will throw an error if called
-* }
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
-const absurd = (_) => {
-	throw new Error("Called `absurd` function which should be uncallable");
-};
-/**
-* Creates a compile-time placeholder for a value of any type.
-*
-* **When to use**
-*
-* Use as a temporary typed placeholder while developing incomplete code.
-*
-* **Gotchas**
-*
-* `hole` is intended for temporary development use. If the placeholder is
-* evaluated at runtime, it throws.
-*
-* **Example** (Creating a development placeholder)
-*
-* ```ts
-* import { hole } from "effect"
-*
-* // Intentionally not called: `hole` throws if the placeholder is evaluated.
-* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
-*   id,
-*   name: hole<string>()
-* })
-*
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
-const hole = cast(absurd);
-/**
-* Creates a predicate that returns `true` only if both predicates are `true`.
-*
-* **When to use**
-*
-* Use when you want to combine `Predicate`s with AND, accepting values that
-* satisfy multiple conditions, including refinements that narrow to an
-* intersection.
-*
-* **Details**
-*
-* Evaluation short-circuits on the first `false`. For refinements, the output
-* type is an intersection.
-*
-* **Example** (Checking both conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const hasAAndB = Predicate.and(
-*   Predicate.hasProperty("a"),
-*   Predicate.hasProperty("b")
-* )
-*
-* const input: unknown = JSON.parse(`{"a":1,"b":"ok"}`)
-* if (hasAAndB(input)) {
-*   // input has both properties at this point
-*   const a = input.a
-*   const b = input.b
-*
-*   const values = [a, b] // => [1, "ok"]
-* }
-* ```
-*
-* @see {@link or}
-* @see {@link not}
-* @category combinators
-* @since 2.0.0
-*/
-const and = dual(2, (a, b) => (data) => a(data) && b(data));
-/**
-* Creates a predicate that returns `true` if either predicate is `true`.
-*
-* **When to use**
-*
-* Use when you want to combine `Predicate`s with OR, accepting values that
-* satisfy at least one condition, including refinements that narrow to a union.
-*
-* **Details**
-*
-* Evaluation short-circuits on the first `true`. For refinements, the output
-* type is a union.
-*
-* **Example** (Checking either condition)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
-*
-* isStringOrNumber("a") // => true
-* ```
-*
-* @see {@link and}
-* @see {@link xor}
-* @category combinators
-* @since 2.0.0
-*/
-const or = dual(2, (a, b) => (data) => a(data) || b(data));
-/**
-* Creates a predicate that returns `true` if exactly one predicate is `true`.
-*
-* **When to use**
-*
-* Use when you want to combine two `Predicate`s with exclusive-or semantics.
-*
-* **Details**
-*
-* Returns `true` when results differ.
-*
-* **Example** (Checking exclusive-or conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isEven = (n: number) => n % 2 === 0
-* const isPositive = (n: number) => n > 0
-* const either = Predicate.xor(isEven, isPositive)
-*
-* either(-2) // => true
-* ```
-*
-* @see {@link or}
-* @see {@link and}
-* @category combinators
-* @since 2.0.0
-*/
-const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
-/**
-* Creates a predicate that returns `true` when both predicates agree.
-*
-* **When to use**
-*
-* Use when you want to check equivalence of two `Predicate`s.
-*
-* **Details**
-*
-* Returns `true` when both results are equal.
-*
-* **Example** (Defining equivalence)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isEven = (n: number) => n % 2 === 0
-* const same = Predicate.eqv(isEven, isEven)
-*
-* same(3) // => true
-* ```
-*
-* @see {@link xor}
-* @category combinators
-* @since 2.0.0
-*/
-const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
-/**
-* Creates a predicate representing logical implication: if `antecedent`, then `consequent`.
-*
-* **When to use**
-*
-* Use when you need to encode logical implication between `Predicate` rules,
-* where one rule only applies when a precondition holds.
-*
-* **Details**
-*
-* Models constraints like "if A then B" and returns `true` when the antecedent
-* is `false`.
-*
-* **Example** (Checking implication)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isAdult = (age: number) => age >= 18
-* const canVote = (age: number) => age >= 18
-* const implies = Predicate.implies(isAdult, canVote)
-*
-* implies(16) // => true
-* ```
-*
-* @see {@link and}
-* @see {@link or}
-* @category combinators
-* @since 2.0.0
-*/
-const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
-/**
-* Creates a predicate that returns `true` when neither predicate is `true`.
-*
-* **When to use**
-*
-* Use when you want to combine two `Predicate`s with logical NOR semantics.
-*
-* **Details**
-*
-* Returns the negation of `or`.
-*
-* **Example** (Checking NOR conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
-*
-* neither(true) // => true
-* ```
-*
-* @see {@link or}
-* @see {@link not}
-* @category combinators
-* @since 2.0.0
-*/
-const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
-/**
-* Creates a predicate that returns `true` unless both predicates are `true`.
-*
-* **When to use**
-*
-* Use when you want to combine two `Predicate`s with logical NAND semantics.
-*
-* **Details**
-*
-* Returns the negation of `and`.
-*
-* **Example** (Checking NAND conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
-*
-* notBoth("a") // => true
-* ```
-*
-* @see {@link and}
-* @see {@link not}
-* @category combinators
-* @since 2.0.0
-*/
-const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
-/**
-* Checks whether a value is a `function`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* callable function.
-*
-* **Details**
-*
-* Uses `typeof input === "function"`.
-*
-* **Example** (Guarding functions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = () => 1
-*
-* if (Predicate.isFunction(data)) {
-*   data() // => 1
-* }
-* ```
-*
-* @see {@link isObjectKeyword}
-* @category guards
-* @since 2.0.0
-*/
-function isFunction(input) {
-	return typeof input === "function";
-}
-/**
-* Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard that accepts arrays and functions as
-* well as objects.
-*
-* **Details**
-*
-* Returns `true` for arrays and functions, and `false` for `null`.
-*
-* **Example** (Checking object keywords)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* Predicate.isObjectKeyword(() => 1) // => true
-* Predicate.isObjectKeyword(null) // => false
-* ```
-*
-* @see {@link isObject}
-* @see {@link isObjectOrArray}
-* @category guards
-* @since 4.0.0
-*/
-function isObjectKeyword(input) {
-	return typeof input === "object" && input !== null || isFunction(input);
-}
-/**
-* Checks whether a value has a given property key.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for property access on `unknown`
-* values with a simple structural object check.
-*
-* **Details**
-*
-* Uses the `in` operator and `isObjectKeyword`. This does not check property
-* value types.
-*
-* **Example** (Guarding object properties)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const hasName = Predicate.hasProperty("name")
-* const data: unknown = { name: "Ada" }
-*
-* if (hasName(data)) {
-*   data.name // => "Ada"
-* }
-* ```
-*
-* @see {@link isTagged}
-* @see {@link isObjectKeyword}
-* @category guards
-* @since 2.0.0
-*/
-const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
-/**
-* Drops elements from the start while the predicate holds, returning the rest.
-*
-* **When to use**
-*
-* Use to remove a leading prefix of elements that satisfy a predicate.
-*
-* **Details**
-*
-* The predicate receives `(element, index)`.
-*
-* **Example** (Dropping while condition holds)
-*
-* ```ts
-* import { Array } from "effect"
-*
-* Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4) // => [4, 5]
-* ```
-*
-* @see {@link takeWhile} — keep the matching prefix instead
-* @see {@link drop} — drop a fixed count
-*
-* @category getters
-* @since 2.0.0
-*/
-const dropWhile = dual(2, (self, predicate) => {
-	const input = Array.isArray(self) ? self : Array.from(self);
-	const len = input.length;
-	let idx = 0;
-	while (idx < len && predicate(input[idx], idx)) idx++;
-	return input.slice(idx);
-});
-/**
-* Takes elements from the start while the predicate holds, stopping at the
-* first element that fails.
-*
-* **When to use**
-*
-* Use to keep the leading elements of an iterable while each element satisfies
-* a predicate, returning the retained prefix as an array.
-*
-* **Details**
-*
-* Supports refinements for type narrowing. The predicate receives
-* `(element, index)`.
-*
-* **Example** (Taking while condition holds)
-*
-* ```ts
-* import { Array } from "effect"
-*
-* Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
-* ```
-*
-* @see {@link take} for keeping a fixed number of leading elements
-* @see {@link dropWhile} for removing the matching prefix and keeping the rest
-* @see {@link span} for splitting the matching prefix from the remaining elements
-*
-* @category getters
-* @since 2.0.0
-*/
-const takeWhile = dual(2, (self, predicate) => {
-	const input = Array.isArray(self) ? self : Array.from(self);
-	const len = input.length;
-	let idx = 0;
-	while (idx < len && predicate(input[idx], idx)) idx++;
-	return input.slice(0, idx);
-});
-
 //#endregion
 //#region src/hook.ts
-/** The names of React's built-in hooks. */
 const REACT_BUILTIN_HOOK_NAMES = [
 	"use",
 	"useActionState",
@@ -1626,55 +603,29 @@ const REACT_BUILTIN_HOOK_NAMES = [
 	"useSyncExternalStore",
 	"useTransition"
 ];
-/**
-* Check if the name is a hook name (starts with `use` followed by an uppercase letter or digit).
-* @param name The name of the identifier to check.
-* @returns `true` if the name is a hook name.
-* @see https://github.com/facebook/react/blob/1d6c8168db1d82713202e842df3167787ffa00ed/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L16
-*/
 function isHookName(name) {
 	return name === "use" || /^use[A-Z0-9]/.test(name);
 }
-/**
-* Checks if the given node is a hook identifier.
-* @param id The AST node to check.
-* @returns `true` if the node is a hook identifier or member expression with hook name, `false` otherwise.
-*/
 function isHookId(id) {
 	switch (id.type) {
 		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
-		case AST_NODE_TYPES.MemberExpression: return "name" in id.property && isHookName(id.property.name);
+		case AST_NODE_TYPES.MemberExpression: return hasProperty(id.property, "name") && isHookName(id.property.name);
 		default: return false;
 	}
 }
-/**
-* Checks if the given expression is a hook tag (callee / tagged template tag).
-* @param tag The expression node to check.
-* @returns `true` if the expression is a hook identifier or member expression with hook name, `false` otherwise.
-*/
 function isHookTag(tag) {
 	if (tag == null) return false;
 	return isHookId(Extract.unwrap(tag));
 }
-/**
-* Check if the function node is a hook definition based on its name.
-* @param node The function node to check.
-* @returns `true` if the function is a hook definition.
-*/
 function isHookDefinition(node) {
 	if (node == null) return false;
 	const id = getFunctionId(node);
 	switch (id?.type) {
 		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
-		case AST_NODE_TYPES.MemberExpression: return "name" in id.property && isHookName(id.property.name);
+		case AST_NODE_TYPES.MemberExpression: return hasProperty(id.property, "name") && isHookName(id.property.name);
 		default: return false;
 	}
 }
-/**
-* Check if the node is a React Hook call by its name.
-* @param node The node to check.
-* @returns `true` if the node is a React Hook call, `false` otherwise.
-*/
 function isHookCall(node) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -1682,12 +633,6 @@ function isHookCall(node) {
 	if (name == null) return false;
 	return isHookName(name);
 }
-/**
-* Check if the node is a useRef-like call (ex: `useRef` or a custom ref hook).
-* @param node The AST node to check.
-* @param additionalRefHooks Regex pattern matching custom hooks that should be treated as ref hooks.
-* @returns `true` if the node is a useRef-like call.
-*/
 function isUseRefLikeCall(node, additionalRefHooks = { test: constFalse }) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -1695,12 +640,6 @@ function isUseRefLikeCall(node, additionalRefHooks = { test: constFalse }) {
 	if (name == null) return false;
 	return name === "useRef" || additionalRefHooks.test(name);
 }
-/**
-* Check if the node is a useState-like call (ex: `useState` or a custom state hook).
-* @param node The AST node to check.
-* @param additionalStateHooks Regex pattern matching custom hooks that should be treated as state hooks.
-* @returns `true` if the node is a useState-like call.
-*/
 function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -1708,12 +647,6 @@ function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
 	if (name == null) return false;
 	return name === "useState" || additionalStateHooks.test(name);
 }
-/**
-* Check if the node is a useEffect-like call (ex: `useEffect`, `useLayoutEffect`, or a custom effect hook).
-* @param node The AST node to check.
-* @param additionalEffectHooks Regex pattern matching custom hooks that should be treated as effect hooks.
-* @returns `true` if the node is a useEffect-like call.
-*/
 function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse }) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -1721,21 +654,11 @@ function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse })
 	if (name == null) return false;
 	return /^use\w*Effect$/u.test(name) || additionalEffectHooks.test(name);
 }
-/**
-* Check if the node is the setup callback passed to a useEffect-like call.
-* @param node The AST node to check.
-* @returns `true` if the node is a useEffect setup callback.
-*/
 function isUseEffectSetupCallback(node) {
 	if (node == null) return false;
 	const expr = Extract.unwrap(node);
 	return expr.parent?.type === AST_NODE_TYPES.CallExpression && expr.parent.arguments.at(0) === expr && isUseEffectLikeCall(expr.parent);
 }
-/**
-* Check if the node is the cleanup callback returned by a useEffect-like setup callback.
-* @param node The AST node to check.
-* @returns `true` if the node is a useEffect cleanup callback.
-*/
 function isUseEffectCleanupCallback(node) {
 	if (node == null) return false;
 	const expr = Extract.unwrap(node);
@@ -1747,12 +670,6 @@ function isUseEffectCleanupCallback(node) {
 
 //#endregion
 //#region src/function-component-collector.ts
-/**
-* Get an api and visitor object for the rule to collect function components.
-* @param context The ESLint rule context.
-* @param options The options to use.
-* @returns The api and visitor of the collector.
-*/
 function getFunctionComponentCollector(context, options = {}) {
 	const { collectDisplayName = false, hint = DEFAULT_COMPONENT_DETECTION_HINT } = options;
 	const functionEntries = [];
@@ -1848,11 +765,6 @@ function getFunctionComponentCollector(context, options = {}) {
 
 //#endregion
 //#region src/hook-collector.ts
-/**
-* Get an api and visitor object for the rule to collect hooks.
-* @param context The ESLint rule context.
-* @returns The api and visitor of the collector.
-*/
 function getHookCollector(context) {
 	const functionEntries = [];
 	const hooks = /* @__PURE__ */ new Map();
@@ -1918,25 +830,8 @@ function getHookCollector(context) {
 
 //#endregion
 //#region src/jsx-config.ts
-/**
-* Weak‑map cache keyed by `sourceCode` so that the (potentially expensive)
-* pragma‑scanning pass runs at most once per file.
-*/
 const annotationCache = /* @__PURE__ */ new WeakMap();
-/**
-* Weak‑map cache for the fully‑merged config (compiler options + annotation).
-*/
 const mergedCache = /* @__PURE__ */ new WeakMap();
-/**
-* Read JSX configuration from the TypeScript compiler options exposed by the
-* parser services.
-*
-* Falls back to sensible React defaults when no compiler options are
-* available (e.g. when the file is parsed without type information).
-*
-* @param context The ESLint rule context.
-* @returns Fully‑populated `JsxConfig` derived from compiler options.
-*/
 function getJsxConfigFromCompilerOptions(context) {
 	const options = context.sourceCode.parserServices?.program?.getCompilerOptions() ?? {};
 	return {
@@ -1946,16 +841,6 @@ function getJsxConfigFromCompilerOptions(context) {
 		jsxImportSource: options.jsxImportSource ?? "react"
 	};
 }
-/**
-* Extract JSX configuration from `@jsx`, `@jsxFrag`, `@jsxRuntime` and
-* `@jsxImportSource` pragma comments in the source file.
-*
-* The result is cached per `sourceCode` instance via a `WeakMap` so that
-* repeated calls from different rules analysing the same file are free.
-*
-* @param context The ESLint rule context.
-* @returns Partial `JsxConfig` containing only the values found in pragmas.
-*/
 function getJsxConfigFromAnnotation(context) {
 	const cached = annotationCache.get(context.sourceCode);
 	if (cached != null) return cached;
@@ -1979,17 +864,6 @@ function getJsxConfigFromAnnotation(context) {
 	annotationCache.set(context.sourceCode, options);
 	return options;
 }
-/**
-* Get the fully‑merged JSX configuration for the current file.
-*
-* Compiler options provide the base values; pragma annotations found in the
-* source override them where present. The result is cached per `sourceCode`.
-*
-* This is the main entry‑point most consumers should use.
-*
-* @param context The ESLint rule context.
-* @returns Fully‑populated, merged `JsxConfig`.
-*/
 function getJsxConfig(context) {
 	const cached = mergedCache.get(context.sourceCode);
 	if (cached != null) return cached;
@@ -2010,113 +884,30 @@ function isFlagSetOnObject(obj, flag) {
 	return isFlagSet(obj.flags, flag);
 }
 const isTypeFlagSet = isFlagSetOnObject;
-/**
-* Check if the type is a boolean literal type.
-* @param type The type to check.
-* @returns `true` if the type is a boolean literal type.
-*/
 function isBooleanLiteralType(type) {
 	return isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral);
 }
-/**
-* Check if the type is the `false` literal type.
-* @internal
-*/
 const isFalseLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "false";
-/**
-* Check if the type is the `true` literal type.
-* @internal
-*/
 const isTrueLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "true";
-/**
-* Check if the type is an any-like type.
-* @internal
-*/
 const isAnyType = (type) => isTypeFlagSet(type, ts.TypeFlags.TypeParameter | ts.TypeFlags.Any);
-/**
-* Check if the type is a bigint-like type.
-* @internal
-*/
 const isBigIntType = (type) => isTypeFlagSet(type, ts.TypeFlags.BigIntLike);
-/**
-* Check if the type is a boolean-like type.
-* @internal
-*/
 const isBooleanType = (type) => isTypeFlagSet(type, ts.TypeFlags.BooleanLike);
-/**
-* Check if the type is an enum-like type.
-* @internal
-*/
 const isEnumType = (type) => isTypeFlagSet(type, ts.TypeFlags.EnumLike);
-/**
-* Check if the type is a falsy bigint literal type.
-* @internal
-*/
 const isFalsyBigIntType = (type) => type.isLiteral() && isMatching({ value: { base10Value: "0" } }, type);
-/**
-* Check if the type is a falsy number literal type.
-* @internal
-*/
 const isFalsyNumberType = (type) => type.isNumberLiteral() && type.value === 0;
-/**
-* Check if the type is a falsy string literal type.
-* @internal
-*/
 const isFalsyStringType = (type) => type.isStringLiteral() && type.value === "";
-/**
-* Check if the type is the never type.
-* @internal
-*/
 const isNeverType = (type) => isTypeFlagSet(type, ts.TypeFlags.Never);
-/**
-* Check if the type is a nullish type (null, undefined, or void).
-* @internal
-*/
 const isNullishType = (type) => isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike);
-/**
-* Check if the type is a number-like type.
-* @internal
-*/
 const isNumberType = (type) => isTypeFlagSet(type, ts.TypeFlags.NumberLike);
-/**
-* Check if the type is an object type.
-* @internal
-*/
 const isObjectType = (type) => !isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.TypeParameter | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never);
-/**
-* Check if the type is a string-like type.
-* @internal
-*/
 const isStringType = (type) => isTypeFlagSet(type, ts.TypeFlags.StringLike);
-/**
-* Check if the type is a truthy bigint literal type.
-* @internal
-*/
 const isTruthyBigIntType = (type) => type.isLiteral() && isMatching({ value: { base10Value: P.not("0") } }, type);
-/**
-* Check if the type is a truthy number literal type.
-* @internal
-*/
 const isTruthyNumberType = (type) => type.isNumberLiteral() && type.value !== 0;
-/**
-* Check if the type is a truthy string literal type.
-* @internal
-*/
 const isTruthyStringType = (type) => type.isStringLiteral() && type.value !== "";
-/**
-* Check if the type is the unknown type.
-* @internal
-*/
 const isUnknownType = (type) => isTypeFlagSet(type, ts.TypeFlags.Unknown);
 
 //#endregion
 //#region src/type-name.ts
-/**
-* Get the fully qualified name of a symbol, handling cases that `ts.TypeChecker.getFullyQualifiedName` does not handle (ex: `export as namespace preact`).
-* @param checker The TypeScript type checker.
-* @param symbol The symbol to get fully qualified name for.
-* @returns The fully qualified name of the symbol.
-*/
 function getFullyQualifiedNameEx(checker, symbol) {
 	let name = symbol.name;
 	let parent = symbol.declarations?.at(0)?.parent;
@@ -2163,13 +954,6 @@ function getFullyQualifiedNameEx(checker, symbol) {
 
 //#endregion
 //#region src/type-variant.ts
-/**
-* Get the variants of an array of types.
-* @param types The types to get the variants of.
-* @returns The variants of the types.
-* @remarks Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements.
-* @internal
-*/
 function getTypeVariants(types) {
 	const variants = /* @__PURE__ */ new Set();
 	if (types.some(isUnknownType)) {