@eslint-react/core 5.18.4 → 5.18.6

package/dist/index.js

@@ -6,480 +6,6 @@ import { resolve } from "@eslint-react/var";
 import ts from "typescript";
 import { P, isMatching, match } from "ts-pattern";
 
-//#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
-* )
-* console.log(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;
-})();
-/**
-* Provides small helpers for defining and reusing TypeScript functions.
-*
-* The main helpers are `pipe` and `flow` for left-to-right composition and
-* `dual` for APIs that support both direct and pipe-friendly call styles. The
-* module also contains small identity, constant, tuple, type-level, and
-* memoization helpers used across the library.
-*
-* @since 2.0.0
-*/
-/**
-* 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)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(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)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(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
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(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"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(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"
-* import * as assert from "node:assert"
-*
-* const constNull = Function.constant(null)
-*
-* assert.deepStrictEqual(constNull(), null)
-* assert.deepStrictEqual(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"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(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"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(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"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(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"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(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"
-* import * as assert from "node:assert"
-*
-* const increment = (n: number) => n + 1
-* const square = (n: number) => n * n
-*
-* assert.strictEqual(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>()
-* })
-*
-* console.log(typeof buildUser) // "function"
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
-const hole = cast(absurd);
-/**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
-* ```
-* @category array
-*/
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
-	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
-});
-/**
-* Takes the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array containing only the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { pipe, takeWhile } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
-* ```
-* @category array
-*/
-const takeWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
-	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
-});
-
-//#endregion
 //#region src/api.ts
 /**
 * Check if the node is a React API identifier or member expression.
@@ -496,7 +22,10 @@ function isAPI(api) {
 		if (name.endsWith(`.${api}`)) return true;
 		return false;
 	};
-	return dual(2, func);
+	function dual(context, ...rest) {
+		return rest.length === 1 ? func(context, rest[0]) : (node) => func(context, node);
+	}
+	return dual;
 }
 /**
 * Check if the node is a call expression to a specific React API.
@@ -509,7 +38,10 @@ function isAPICall(api) {
 		if (node.type !== AST_NODE_TYPES.CallExpression) return false;
 		return isAPI(api)(context, Extract.unwrap(node.callee));
 	};
-	return dual(2, func);
+	function dual(context, ...rest) {
+		return rest.length === 1 ? func(context, rest[0]) : (node) => func(context, node);
+	}
+	return dual;
 }
 /** Check if the node is a React `captureOwnerStack` API identifier or member expression. */
 const isCaptureOwnerStack = isAPI("captureOwnerStack");
@@ -810,6 +342,95 @@ 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];
+	if (propsArg == null) return null;
+	const propsObject = Extract.unwrap(propsArg);
+	return propsObject.type === AST_NODE_TYPES.ObjectExpression ? propsObject : 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;
+	const prop = Traverse.findParent(node, Check.is(AST_NODE_TYPES.ObjectExpression));
+	if (prop == null) return false;
+	return prop === call.arguments[1];
+}
+
 //#endregion
 //#region src/function.ts
 /**
@@ -907,335 +528,800 @@ function isFunctionHasCallInInitPath(callName, initPath) {
 	});
 }
 /**
-* Check if a function is empty.
-*
-* @param node The function node to check.
-* @returns `true` if the function is empty, `false` otherwise.
+* 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;
+	function isDirective(node) {
+		return node.type === AST_NODE_TYPES.ExpressionStatement && node.directive != null;
+	}
+	for (const stmt of node.body.body) {
+		if (!isDirective(stmt)) continue;
+		directives.push(stmt);
+	}
+	return directives;
+}
+/**
+* Check if a directive with the given name exists in the function directives.
+*
+* @param node The function AST node.
+* @param name The directive name to check (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='=']",
+	"[left.type='MemberExpression']",
+	"[left.property.name='displayName']"
+].join("");
+
+//#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) {
+		if (node == null) return false;
+		if (Check.isJSX(node)) return true;
+		switch (node.type) {
+			case AST_NODE_TYPES.Literal:
+				switch (typeof node.value) {
+					case "boolean": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithBooleanValue);
+					case "string": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithStringValue);
+					case "number": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithNumberValue);
+					case "bigint": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithBigIntValue);
+				}
+				return node.value == null && !(hint & JsxDetectionHint.DoNotIncludeJsxWithNullValue);
+			case AST_NODE_TYPES.TemplateLiteral: return !(hint & JsxDetectionHint.DoNotIncludeJsxWithStringValue);
+			case AST_NODE_TYPES.ArrayExpression:
+				if (node.elements.length === 0) return !(hint & JsxDetectionHint.DoNotIncludeJsxWithEmptyArrayValue);
+				return hint & JsxDetectionHint.RequireAllArrayElementsToBeJsx ? node.elements.every(visit) : node.elements.some(visit);
+			case AST_NODE_TYPES.LogicalExpression:
+				if (hint & JsxDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx) return visit(node.left) && visit(node.right);
+				return visit(node.left) || visit(node.right);
+			case AST_NODE_TYPES.ConditionalExpression:
+				if (hint & JsxDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx) return visit(node.consequent) && visit(node.alternate);
+				return visit(node.consequent) || visit(node.alternate);
+			case AST_NODE_TYPES.SequenceExpression: return visit(node.expressions.at(-1) ?? null);
+			case AST_NODE_TYPES.CallExpression:
+				if (hint & JsxDetectionHint.DoNotIncludeJsxWithCreateElementValue) return false;
+				return Extract.getCalleeName(node) === "createElement";
+			case AST_NODE_TYPES.Identifier:
+				if (node.name === "undefined") return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
+				if (seen.has(node)) return false;
+				seen.add(node);
+				return visit(resolve(context, node));
+		}
+		return false;
+	}
+	return visit(node);
+}
+
+//#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;
+	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	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;
+	let parent = node.parent;
+	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	switch (true) {
+		case parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return parent.parent.id;
+		case parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent) && parent.parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent.parent) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return parent.parent.parent.id;
+		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;
+	if (id.type === AST_NODE_TYPES.Identifier) return isFunctionComponentNameLoose(id.name);
+	if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return isFunctionComponentNameLoose(id.property.name);
+	return false;
+}
+/**
+* Hints for component collector.
 */
-function isFunctionEmpty(node) {
-	return node.body.type === AST_NODE_TYPES.BlockStatement && node.body.body.length === 0;
-}
+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
+};
 /**
-* 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.
+* Default component detection hint.
 */
-function getFunctionDirectives(node) {
-	const directives = [];
-	if (node.body.type !== AST_NODE_TYPES.BlockStatement) return directives;
-	function isDirective(node) {
-		return node.type === AST_NODE_TYPES.ExpressionStatement && node.directive != null;
-	}
-	for (const stmt of node.body.body) {
-		if (!isDirective(stmt)) continue;
-		directives.push(stmt);
-	}
-	return directives;
-}
+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 a directive with the given name exists in the function directives.
+* Check if the function node is a valid React component definition.
 *
-* @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.
+* @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 isFunctionHasDirective(node, name) {
-	return getFunctionDirectives(node).some((d) => d.directive === name);
+function isFunctionComponentDefinition(context, node, hint) {
+	if (!isFunctionWithLooseComponentName(context, node, true)) return false;
+	let parent = node.parent;
+	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	if (isRenderMethodCallback(node)) return false;
+	if (isCreateElementChildrenArgument(context, node)) return false;
+	const [parentCallee, parentCalleeName] = parent.type === AST_NODE_TYPES.CallExpression ? [Extract.unwrap(parent.callee), Extract.getCalleeName(parent)] : [null, null];
+	switch (true) {
+		case Check.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.Property && parent.parent.type === AST_NODE_TYPES.ObjectExpression:
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsObjectMethod) return false;
+			break;
+		case Check.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.MethodDefinition:
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassMethod) return false;
+			break;
+		case Check.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.PropertyDefinition:
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassProperty) return false;
+			break;
+		case parent.type === AST_NODE_TYPES.ArrayPattern:
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement) return false;
+			break;
+		case parent.type === AST_NODE_TYPES.ArrayExpression:
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement) return false;
+			break;
+		case parentCallee != null && parentCallee.type === AST_NODE_TYPES.MemberExpression && parentCalleeName === "map":
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
+			break;
+		case parentCallee != null && parentCallee.type === AST_NODE_TYPES.MemberExpression && parentCalleeName === "flatMap":
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
+			break;
+		case parent.type === AST_NODE_TYPES.CallExpression && getFunctionId(node) == null && !isFunctionComponentWrapperCall(context, parent) && !isCreateElementCall(context, parent): if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback) return false;
+	}
+	const significantParent = Traverse.findParent(node, Check.isOneOf([
+		AST_NODE_TYPES.JSXExpressionContainer,
+		AST_NODE_TYPES.ArrowFunctionExpression,
+		AST_NODE_TYPES.FunctionExpression,
+		AST_NODE_TYPES.Property,
+		AST_NODE_TYPES.ClassBody
+	]));
+	if (significantParent == null) return true;
+	if (significantParent.type === AST_NODE_TYPES.JSXExpressionContainer) return false;
+	return true;
 }
-/** The esquery selector matching `displayName` assignment expressions. */
-const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT = [
-	"AssignmentExpression",
-	"[operator='=']",
-	"[left.type='MemberExpression']",
-	"[left.property.name='displayName']"
-].join("");
 
 //#endregion
-//#region src/jsx.ts
+//#region ../../.pkgs/eff/dist/index.js
 /**
-* Hints for JSX detection.
+* 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
+* )
+* console.log(result) // 21
+* ```
+*
+* @category combinators
+* @since 2.0.0
 */
-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
+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;
+		}
+	}
 };
 /**
-* Default JSX detection hint.
+* Reusable prototype that implements `Pipeable.pipe`.
 *
-* 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.
+* **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 DEFAULT_JSX_DETECTION_HINT = 0n | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue;
+const Prototype = { pipe() {
+	return pipeArguments(this, arguments);
+} };
 /**
-* Check if the node represents JSX-like content based on heuristics.
+* 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;
+})();
+/**
+* Provides small helpers for defining and reusing TypeScript functions.
+*
+* The main helpers are `pipe` and `flow` for left-to-right composition and
+* `dual` for APIs that support both direct and pipe-friendly call styles. The
+* module also contains small identity, constant, tuple, type-level, and
+* memoization helpers used across the library.
+*
+* @since 2.0.0
+*/
+/**
+* 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)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Defining overloads with call signatures)
 *
-* The detection behavior is configurable through {@link JsxDetectionHint}
-* bit-flags so that callers can opt individual value kinds in or out.
+* ```ts
+* import { Function, pipe } from "effect"
 *
-* 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.
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = Function.dual(2, (self: number, that: number): number => self + that)
 *
-* @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.
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Selecting data-first or data-last style with a predicate)
 *
-* @example
 * ```ts
-* import { isJsxLike } from "@eslint-react/core";
+* import { Function, pipe } from "effect"
 *
-* if (isJsxLike(context, node)) {
-*   // node looks like it evaluates to a React element
-* }
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
 * ```
+*
+* @category combinators
+* @since 2.0.0
 */
-function isJsxLike(context, node, hint = DEFAULT_JSX_DETECTION_HINT) {
-	const seen = /* @__PURE__ */ new Set();
-	function visit(node) {
-		if (node == null) return false;
-		if (Check.isJSX(node)) return true;
-		switch (node.type) {
-			case AST_NODE_TYPES.Literal:
-				switch (typeof node.value) {
-					case "boolean": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithBooleanValue);
-					case "string": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithStringValue);
-					case "number": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithNumberValue);
-					case "bigint": return !(hint & JsxDetectionHint.DoNotIncludeJsxWithBigIntValue);
-				}
-				return node.value == null && !(hint & JsxDetectionHint.DoNotIncludeJsxWithNullValue);
-			case AST_NODE_TYPES.TemplateLiteral: return !(hint & JsxDetectionHint.DoNotIncludeJsxWithStringValue);
-			case AST_NODE_TYPES.ArrayExpression:
-				if (node.elements.length === 0) return !(hint & JsxDetectionHint.DoNotIncludeJsxWithEmptyArrayValue);
-				return hint & JsxDetectionHint.RequireAllArrayElementsToBeJsx ? node.elements.every(visit) : node.elements.some(visit);
-			case AST_NODE_TYPES.LogicalExpression:
-				if (hint & JsxDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx) return visit(node.left) && visit(node.right);
-				return visit(node.left) || visit(node.right);
-			case AST_NODE_TYPES.ConditionalExpression:
-				if (hint & JsxDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx) return visit(node.consequent) && visit(node.alternate);
-				return visit(node.consequent) || visit(node.alternate);
-			case AST_NODE_TYPES.SequenceExpression: return visit(node.expressions.at(-1) ?? null);
-			case AST_NODE_TYPES.CallExpression:
-				if (hint & JsxDetectionHint.DoNotIncludeJsxWithCreateElementValue) return false;
-				return Extract.getCalleeName(node) === "createElement";
-			case AST_NODE_TYPES.Identifier:
-				if (node.name === "undefined") return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
-				if (seen.has(node)) return false;
-				seen.add(node);
-				return visit(resolve(context, node));
-		}
-		return false;
+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);
+			};
+		};
 	}
-	return visit(node);
-}
-
-//#endregion
-//#region src/function-component.ts
+};
 /**
-* Component flag constants.
+* 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"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(identity(5), 5)
+* ```
+*
+* @category combinators
+* @since 2.0.0
 */
-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
-};
+const identity = (a) => a;
 /**
-* Get component flag from init path.
-* @param initPath The init path of the function component.
-* @returns The component flag.
-* @internal
+* 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
 */
-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;
-}
+const cast = identity;
 /**
-* 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.
+* 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"
+* import * as assert from "node:assert"
+*
+* const constNull = Function.constant(null)
+*
+* assert.deepStrictEqual(constNull(), null)
+* assert.deepStrictEqual(constNull(), null)
+* ```
+*
+* @category constructors
+* @since 2.0.0
 */
-function isFunctionComponentWrapperCall(context, node) {
-	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-	return isMemoCall(context, node) || isForwardRefCall(context, node);
-}
+const constant = (value) => () => value;
 /**
-* 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.
+* 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"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constTrue(), true)
+* ```
+*
+* @category constants
+* @since 2.0.0
 */
-function isFunctionComponentWrapperCallback(context, node) {
-	if (!Check.isFunction(node)) return false;
-	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	if (parent.type !== AST_NODE_TYPES.CallExpression) return false;
-	return isFunctionComponentWrapperCall(context, parent);
-}
+const constTrue = constant(true);
 /**
-* 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
+* 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"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constFalse(), false)
+* ```
+*
+* @category constants
+* @since 2.0.0
 */
-function getFunctionComponentId(context, node) {
-	const functionId = getFunctionId(node);
-	if (functionId != null) return functionId;
-	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	switch (true) {
-		case parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return parent.parent.id;
-		case parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent) && parent.parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent.parent) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return parent.parent.parent.id;
-		default: return null;
-	}
-}
+const constFalse = constant(false);
 /**
-* 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.
+* 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"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constNull(), null)
+* ```
+*
+* @category constants
+* @since 2.0.0
 */
-function isFunctionComponentName(name) {
-	return RE_COMPONENT_NAME.test(name);
-}
+const constNull = constant(null);
 /**
-* 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.
+* 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"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constUndefined(), undefined)
+* ```
+*
+* @category constants
+* @since 2.0.0
 */
-function isFunctionComponentNameLoose(name) {
-	return RE_COMPONENT_NAME_LOOSE.test(name);
-}
+const constUndefined = constant(void 0);
 /**
-* 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.
+* 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"
+* import * as assert from "node:assert"
+*
+* const increment = (n: number) => n + 1
+* const square = (n: number) => n * n
+*
+* assert.strictEqual(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
 */
-function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
-	const id = getFunctionComponentId(context, fn);
-	if (id == null) return allowNone;
-	if (id.type === AST_NODE_TYPES.Identifier) return isFunctionComponentNameLoose(id.name);
-	if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return isFunctionComponentNameLoose(id.property.name);
-	return false;
-}
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 /**
-* Hints for component collector.
+* 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 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
+const absurd = (_) => {
+	throw new Error("Called `absurd` function which should be uncallable");
 };
 /**
-* Default component detection hint.
+* 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>()
+* })
+*
+* console.log(typeof buildUser) // "function"
+* ```
+*
+* @category utility types
+* @since 2.0.0
 */
-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;
+const hole = cast(absurd);
 /**
-* Check if the function node is a valid React component definition.
+* Drops the longest prefix of elements from an array that satisfy the given predicate.
 *
-* @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.
+* Supports both data-first and data-last (`pipe`-friendly) call styles.
+*
+* @param pred - The predicate to test each element with.
+* @returns A new array without the matching prefix.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { dropWhile, pipe } from "@local/eff"
+*
+* // data-first
+* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
+*
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
+* ```
+* @category array
 */
-function isFunctionComponentDefinition(context, node, hint) {
-	if (!isFunctionWithLooseComponentName(context, node, true)) return false;
-	const isCreateElementArg = (() => {
-		let p = node.parent;
-		while (Check.isTypeExpression(p)) p = p.parent;
-		if (p.type !== AST_NODE_TYPES.CallExpression || !isCreateElementCall(context, p)) return false;
-		return p.arguments.slice(2).some((arg) => Extract.unwrap(arg) === node);
-	})();
-	switch (true) {
-		case isCreateElementArg: return false;
-		case isRenderMethodCallback(node): return false;
-	}
-	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	const parentCallee = parent.type === AST_NODE_TYPES.CallExpression ? Extract.unwrap(parent.callee) : null;
-	const parentCalleeName = parent.type === AST_NODE_TYPES.CallExpression ? Extract.getCalleeName(parent) : null;
-	switch (true) {
-		case Check.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.Property && parent.parent.type === AST_NODE_TYPES.ObjectExpression:
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsObjectMethod) return false;
-			break;
-		case Check.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.MethodDefinition:
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassMethod) return false;
-			break;
-		case Check.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.PropertyDefinition:
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassProperty) return false;
-			break;
-		case parent.type === AST_NODE_TYPES.ArrayPattern:
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement) return false;
-			break;
-		case parent.type === AST_NODE_TYPES.ArrayExpression:
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement) return false;
-			break;
-		case parentCallee != null && parentCallee.type === AST_NODE_TYPES.MemberExpression && parentCalleeName === "map":
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
-			break;
-		case parentCallee != null && parentCallee.type === AST_NODE_TYPES.MemberExpression && parentCalleeName === "flatMap":
-			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
-			break;
-		case parent.type === AST_NODE_TYPES.CallExpression && getFunctionId(node) == null && !isFunctionComponentWrapperCall(context, parent) && !isCreateElementCall(context, parent): if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback) return false;
-	}
-	const significantParent = Traverse.findParent(node, Check.isOneOf([
-		AST_NODE_TYPES.JSXExpressionContainer,
-		AST_NODE_TYPES.ArrowFunctionExpression,
-		AST_NODE_TYPES.FunctionExpression,
-		AST_NODE_TYPES.Property,
-		AST_NODE_TYPES.ClassBody
-	]));
-	if (significantParent == null) return true;
-	if (significantParent.type === AST_NODE_TYPES.JSXExpressionContainer) return false;
-	return true;
-}
+const dropWhile = dual(2, (xs, pred) => {
+	const len = xs.length;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(idx);
+});
+/**
+* Takes the longest prefix of elements from an array that satisfy the given predicate.
+*
+* Supports both data-first and data-last (`pipe`-friendly) call styles.
+*
+* @param pred - The predicate to test each element with.
+* @returns A new array containing only the matching prefix.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { pipe, takeWhile } from "@local/eff"
+*
+* // data-first
+* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+*
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
+* ```
+* @category array
+*/
+const takeWhile = dual(2, (xs, pred) => {
+	const len = xs.length;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(0, idx);
+});
 
 //#endregion
 //#region src/hook.ts
@@ -1841,4 +1927,4 @@ function getTypeVariants(types) {
 }
 
 //#endregion
-export { DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FunctionComponentDetectionHint, FunctionComponentFlag, JsxDetectionHint, REACT_BUILTIN_HOOK_NAMES, SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT, getClassComponentCollector, getClassId, getFullyQualifiedNameEx, getFunctionComponentCollector, getFunctionComponentFlagFromInitPath, getFunctionComponentId, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHookCollector, getJsxConfig, getJsxConfigFromAnnotation, getJsxConfigFromCompilerOptions, getTypeVariants, isAPI, isAPICall, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanLiteralType, isBooleanType, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFunctionComponentDefinition, isFunctionComponentName, isFunctionComponentNameLoose, isFunctionComponentWrapperCall, isFunctionComponentWrapperCallback, isFunctionEmpty, isFunctionHasCallInInitPath, isFunctionHasDirective, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHookCall, isHookDefinition, isHookId, isHookName, isHookTag, isJsxLike, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isStringType, isThisSetStateCall, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUse, isUseActionState, isUseActionStateCall, isUseCall, isUseCallback, isUseCallbackCall, isUseContext, isUseContextCall, isUseDebugValue, isUseDebugValueCall, isUseDeferredValue, isUseDeferredValueCall, isUseEffect, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatus, isUseFormStatusCall, isUseId, isUseIdCall, isUseImperativeHandle, isUseImperativeHandleCall, isUseInsertionEffect, isUseInsertionEffectCall, isUseLayoutEffect, isUseLayoutEffectCall, isUseMemo, isUseMemoCall, isUseOptimistic, isUseOptimisticCall, isUseReducer, isUseReducerCall, isUseRef, isUseRefCall, isUseRefLikeCall, isUseState, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStore, isUseSyncExternalStoreCall, isUseTransition, isUseTransitionCall };
+export { DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FunctionComponentDetectionHint, FunctionComponentFlag, JsxDetectionHint, REACT_BUILTIN_HOOK_NAMES, SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT, getClassComponentCollector, getClassId, getCreateElementChildrenArguments, getCreateElementProp, getCreateElementPropsObject, getCreateElementTypeArgument, getFullyQualifiedNameEx, getFunctionComponentCollector, getFunctionComponentFlagFromInitPath, getFunctionComponentId, getFunctionDirectives, getFunctionId, getFunctionInitPath, getHookCollector, getJsxConfig, getJsxConfigFromAnnotation, getJsxConfigFromCompilerOptions, getTypeVariants, isAPI, isAPICall, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanLiteralType, isBooleanType, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateElementChildrenArgument, isCreateRef, isCreateRefCall, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFunctionComponentDefinition, isFunctionComponentName, isFunctionComponentNameLoose, isFunctionComponentWrapperCall, isFunctionComponentWrapperCallback, isFunctionEmpty, isFunctionHasCallInInitPath, isFunctionHasDirective, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHookCall, isHookDefinition, isHookId, isHookName, isHookTag, isInsideCreateElementProps, isJsxLike, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isStringType, isThisSetStateCall, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUse, isUseActionState, isUseActionStateCall, isUseCall, isUseCallback, isUseCallbackCall, isUseContext, isUseContextCall, isUseDebugValue, isUseDebugValueCall, isUseDeferredValue, isUseDeferredValueCall, isUseEffect, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatus, isUseFormStatusCall, isUseId, isUseIdCall, isUseImperativeHandle, isUseImperativeHandleCall, isUseInsertionEffect, isUseInsertionEffectCall, isUseLayoutEffect, isUseLayoutEffectCall, isUseMemo, isUseMemoCall, isUseOptimistic, isUseOptimisticCall, isUseReducer, isUseReducerCall, isUseRef, isUseRefCall, isUseRefLikeCall, isUseState, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStore, isUseSyncExternalStoreCall, isUseTransition, isUseTransitionCall };