eslint-plugin-react-x 5.24.0 → 5.24.2

package/dist/index.js

@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.24.0";
+var version = "5.24.2";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -257,17 +257,11 @@ const rule$1 = {
 			}
 			context.report(problem);
 		}
-		/**
-		* SourceCode that also works down to ESLint 3.0.0
-		*/
 		const getSourceCode = typeof context.getSourceCode === "function" ? () => {
 			return context.getSourceCode();
 		} : () => {
 			return context.sourceCode;
 		};
-		/**
-		* SourceCode#getScope that also works down to ESLint 3.0.0
-		*/
 		const getScope = typeof context.getScope === "function" ? () => {
 			return context.getScope();
 		} : (node) => {
@@ -287,9 +281,6 @@ const rule$1 = {
 				return result;
 			};
 		}
-		/**
-		* Visitor for both function expressions and arrow function expressions.
-		*/
 		function visitFunctionWithDependencies(node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect, isAutoDepsHook) {
 			if (isEffect && node.async) reportProblem({
 				node,
@@ -989,24 +980,11 @@ function scanForConstructions({ declaredDependencies, declaredDependenciesNode,
 		isUsedOutsideOfHook: isUsedOutsideOfHook(ref)
 	}));
 }
-/**
-* Assuming () means the passed/returned node:
-* (props) => (props)
-* props.(foo) => (props.foo)
-* props.foo.(bar) => (props).foo.bar
-* props.foo.bar.(baz) => (props).foo.bar.baz
-*/
 function getDependency(node) {
 	if (node.parent && (node.parent.type === "MemberExpression" || node.parent.type === "OptionalMemberExpression") && node.parent.object === node && "name" in node.parent.property && node.parent.property.name !== "current" && !node.parent.computed && !(node.parent.parent != null && (node.parent.parent.type === "CallExpression" || node.parent.parent.type === "OptionalCallExpression") && node.parent.parent.callee === node.parent)) return getDependency(node.parent);
 	else if (node.type === "MemberExpression" && node.parent && node.parent.type === "AssignmentExpression" && node.parent.left === node) return node.object;
 	else return node;
 }
-/**
-* Mark a node as either optional or required.
-* Note: If the node argument is an OptionalMemberExpression, it doesn't necessarily mean it is optional.
-* It just means there is an optional member somewhere inside.
-* This particular node might still represent a required member, so check .optional field.
-*/
 function markNode(node, optionalChains, result) {
 	if (optionalChains) {
 		if ("optional" in node && node.optional) {
@@ -1014,13 +992,6 @@ function markNode(node, optionalChains, result) {
 		} else optionalChains.set(result, false);
 	}
 }
-/**
-* Assuming () means the passed node.
-* (foo) -> 'foo'
-* foo(.)bar -> 'foo.bar'
-* foo.bar(.)baz -> 'foo.bar.baz'
-* Otherwise throw.
-*/
 function analyzePropertyChain(node, optionalChains) {
 	if (node.type === "Identifier" || node.type === "JSXIdentifier") {
 		const result = node.name;
@@ -1067,16 +1038,6 @@ function getReactiveHookCallbackIndex(calleeNode, options) {
 		} else return -1;
 	}
 }
-/**
-* ESLint won't assign node.parent to references from context.getScope()
-*
-* So instead we search for the node from an ancestor assigning node.parent
-* as we go. This mutates the AST.
-*
-* This traversal is:
-* - optimized by only searching nodes with a range surrounding our target node
-* - agnostic to AST node types, it looks for `{ type: string, ... }`
-*/
 function fastFindReferenceWithParent(start, target) {
 	const queue = [start];
 	let item;
@@ -1127,10 +1088,6 @@ function getUnknownDependenciesMessage(reactiveHookName) {
 
 //#endregion
 //#region src/rules/globals/helpers.ts
-/**
-* Array methods that mutate the array in place.
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
-*/
 const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"copyWithin",
 	"fill",
@@ -1142,7 +1099,6 @@ const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
-/** Resolve a direct call target, following simple function aliases. */
 function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
 	const expression = Extract.unwrap(node);
 	if (Check.isFunction(expression)) return expression;
@@ -1222,22 +1178,11 @@ function createFactCollector$6() {
 
 //#endregion
 //#region src/rules/globals/origins.ts
-/**
-* Return whether an identifier is an unresolved global or is declared in the
-* global/module scope.
-*/
 function isGlobalVariable(context, node) {
 	const variable = findVariable(context.sourceCode.getScope(node), node);
 	if (variable == null || variable.defs.length === 0) return true;
 	return variable.scope.type === ScopeType.global || variable.scope.type === ScopeType.module;
 }
-/**
-* Resolve an object expression to the global/module binding it aliases.
-*
-* This intentionally follows only stable `const alias = value` declarations.
-* It gives the rule useful Alias effects without pretending to perform full
-* control-flow analysis for reassigned locals.
-*/
 function resolveGlobalOrigin(context, node, seen = /* @__PURE__ */ new Set()) {
 	const expression = Extract.unwrap(node);
 	if (seen.has(expression)) return null;
@@ -1257,11 +1202,6 @@ function resolveGlobalOrigin(context, node, seen = /* @__PURE__ */ new Set()) {
 
 //#endregion
 //#region src/rules/globals/effects.ts
-/**
-* Classify the collected writes and mutating method calls, keeping only the
-* ones that reach a global/module binding, grouped by the function that
-* performs them.
-*/
 function inferGlobalMutations(context, facts) {
 	const directEffects = /* @__PURE__ */ new Map();
 	function pushEffect(enclosingFunction, effect) {
@@ -1300,7 +1240,6 @@ function inferGlobalMutations(context, facts) {
 	}
 	return directEffects;
 }
-/** Resolve the collected call edges into a function-to-function call graph. */
 function inferCallGraph$1(context, callEdges) {
 	const callGraph = /* @__PURE__ */ new Map();
 	for (const edge of callEdges) {
@@ -1312,11 +1251,6 @@ function inferCallGraph$1(context, callEdges) {
 	}
 	return callGraph;
 }
-/**
-* Like the SPEC's function signatures, these summaries keep creation of an
-* effect separate from applying it in a component or hook render: walk the
-* call graph from each render function and gather every reachable effect once.
-*/
 function collectReachableEffects(renderFunctions, directEffects, callGraph) {
 	const visited = /* @__PURE__ */ new Set();
 	const reported = /* @__PURE__ */ new Set();
@@ -1377,12 +1311,6 @@ function create$49(context) {
 
 //#endregion
 //#region src/rules/immutability/helpers.ts
-/**
-* Methods that mutate their receiver in place.
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
-*/
 const KNOWN_MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"add",
 	"clear",
@@ -1398,9 +1326,6 @@ const KNOWN_MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
-/**
-* Known mutating hooks.
-*/
 const KNOWN_MUTATING_HOOKS = /* @__PURE__ */ new Set([
 	"useHistory",
 	"useNavigate",
@@ -1571,17 +1496,6 @@ function createFactCollector$5() {
 
 //#endregion
 //#region src/rules/immutability/origins.ts
-/**
-* Classify whether a variable ultimately holds a value that must be treated as
-* immutable: a component's props, a state value returned from `useState`-like or
-* `useReducer` calls, a shallow copy (spread literal) of either, or a `for...of`
-* iterator variable whose iterated collection resolves to one of those.
-* @param context The rule context.
-* @param variable The variable to classify.
-* @param components The confirmed function component nodes in the file.
-* @param seen Variables already visited during spread/iterator recursion.
-* @returns The frozen origin, or `null` when the variable is not derived from one.
-*/
 function classifyFrozenOrigin(context, variable, components, seen = /* @__PURE__ */ new Set()) {
 	if (seen.has(variable)) return null;
 	seen.add(variable);
@@ -1835,12 +1749,6 @@ function create$47(context) {
 
 //#endregion
 //#region src/rules/no-array-index-key/lib.ts
-/**
-* Iterator-like methods that pass the item's index to their callback,
-* mapped to the position of the index parameter in the callback's parameter list.
-* `map` and `forEach` also cover `Children.map` and `Children.forEach`,
-* whose callback is the second argument instead of the first.
-*/
 const INDEX_PARAM_POSITIONS$1 = /* @__PURE__ */ new Map([
 	["every", 1],
 	["filter", 1],
@@ -1855,13 +1763,6 @@ const INDEX_PARAM_POSITIONS$1 = /* @__PURE__ */ new Map([
 	["reduceRight", 2],
 	["some", 1]
 ]);
-/**
-* Checks whether an identifier is a reference to the index parameter of an
-* iterator-like method's callback (e.g. `i` in `items.map((item, i) => ...)`).
-* @param context The ESLint rule context.
-* @param node The identifier to check.
-* @returns `true` if the identifier resolves to an array index parameter.
-*/
 function isArrayIndexReference(context, node) {
 	const def = findVariable(context.sourceCode.getScope(node), node)?.defs.at(0);
 	if (def == null || def.type !== DefinitionType.Parameter) return false;
@@ -1882,12 +1783,6 @@ function isArrayIndexReference(context, node) {
 	if (param == null) return false;
 	return param === def.name || param.type === AST_NODE_TYPES.AssignmentPattern && param.left === def.name;
 }
-/**
-* Recursively collects all identifiers from a binary expression.
-* e.g., for `a + b + c`, it returns identifiers for a, b, and c.
-* @param side The binary expression (or one of its sides) to collect from.
-* @returns The identifiers found in the expression.
-*/
 function getIdentifiersFromBinaryExpression(side) {
 	if (Check.isIdentifier(side)) return [side];
 	if (side.type === AST_NODE_TYPES.BinaryExpression) return [...getIdentifiersFromBinaryExpression(side.left), ...getIdentifiersFromBinaryExpression(side.right)];
@@ -1897,7 +1792,6 @@ function getIdentifiersFromBinaryExpression(side) {
 //#endregion
 //#region src/rules/no-array-index-key/no-array-index-key.ts
 const RULE_NAME$46 = "no-array-index-key";
-/** Global functions that convert their first argument while preserving its identity as a key. */
 const COERCION_FUNCTIONS = /* @__PURE__ */ new Set(["Number", "String"]);
 var no_array_index_key_default = createRule({
 	meta: {
@@ -1920,12 +1814,6 @@ function create$46(context) {
 		if (!core.isCloneElementCall(context, node)) return null;
 		return props?.type === AST_NODE_TYPES.ObjectExpression ? props : null;
 	}
-	/**
-	* Checks an expression used as a 'key' value, recursing into the branches
-	* it may evaluate to and reporting every array index it is derived from.
-	* @param node The key value expression to check.
-	* @returns The report descriptors for the violations found.
-	*/
 	function visitKeyExpression(node) {
 		switch (node.type) {
 			case AST_NODE_TYPES.Identifier: return isArrayIndex(node) ? [{
@@ -2094,60 +1982,6 @@ function create$41(context) {
 
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
-function not(predicate) {
-	return (data) => !predicate(data);
-}
-function or(a, b) {
-	return (data) => a(data) || b(data);
-}
-/**
-* A function that checks if the passed parameter is a string and narrows its type accordingly.
-*
-* @param data - The variable to check.
-* @returns True if the passed input is a string, false otherwise.
-* @category guards
-*/
-function isString(data) {
-	return typeof data === "string";
-}
-/**
-* 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;
@@ -2167,110 +2001,14 @@ const pipeArguments = (self, args) => {
 		}
 	}
 };
-/**
-* 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));
@@ -2299,203 +2037,14 @@ const dual = function(arity, body) {
 		};
 	}
 };
-/**
-* 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");
 };
@@ -2528,93 +2077,46 @@ function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
 		};
 	}
 }
-/**
-* 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);
+function not(predicate) {
+	return (data) => !predicate(data);
+}
+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 isString(input) {
+	return typeof input === "string";
+}
+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);
 function getOrInsertComputed(map, key, callback) {
 	if (map.has(key)) return map.get(key);
 	const value = callback(key);
 	map.set(key, value);
 	return value;
 }
-/**
-* 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;
+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 && pred(xs[idx])) idx++;
-	return xs.slice(idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.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;
+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 && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
 });
 
 //#endregion
@@ -2694,7 +2196,7 @@ function create$38(context) {
 			const { body } = component.body;
 			for (const member of body) if (core.isComponentWillMount(member)) context.report({
 				fix(fixer) {
-					if (!("key" in member)) return null;
+					if (!hasProperty(member, "key")) return null;
 					return fixer.replaceText(member.key, "UNSAFE_componentWillMount");
 				},
 				messageId: "default",
@@ -2727,7 +2229,7 @@ function create$37(context) {
 			const { body } = component.body;
 			for (const member of body) if (core.isComponentWillReceiveProps(member)) context.report({
 				fix(fixer) {
-					if (!("key" in member)) return null;
+					if (!hasProperty(member, "key")) return null;
 					return fixer.replaceText(member.key, "UNSAFE_componentWillReceiveProps");
 				},
 				messageId: "default",
@@ -2760,7 +2262,7 @@ function create$36(context) {
 			const { body } = component.body;
 			for (const member of body) if (core.isComponentWillUpdate(member)) context.report({
 				fix(fixer) {
-					if (!("key" in member)) return null;
+					if (!hasProperty(member, "key")) return null;
 					return fixer.replaceText(member.key, "UNSAFE_componentWillUpdate");
 				},
 				messageId: "default",
@@ -3005,14 +2507,6 @@ function create$31(context) {
 		});
 	} };
 }
-/**
-* Determine whether the given CallExpression can be safely auto-fixed by replacing
-* the usage of `forwardRef` with passing `ref` as a prop
-*
-* @param context The rule context object
-* @param node The CallExpression node to check
-* @returns True if the call can be auto-fixed, false otherwise
-*/
 function couldFix(context, node) {
 	const { importSource } = getSettingsFromContext(context);
 	const initialScope = context.sourceCode.getScope(node);
@@ -3023,12 +2517,6 @@ function couldFix(context, node) {
 		default: return false;
 	}
 }
-/**
-* Generates the fix for the `forwardRef` call
-* @param context The rule context
-* @param node The `forwardRef` call expression
-* @returns A fixer function that applies the changes
-*/
 function buildFix(context, node) {
 	return (fixer) => {
 		const [componentNode] = node.arguments;
@@ -3040,14 +2528,6 @@ function buildFix(context, node) {
 		];
 	};
 }
-/**
-* Generates fixes for the component's props and ref arguments
-* @param context The rule context
-* @param fixer The rule fixer
-* @param node The function component node
-* @param typeArguments The type arguments from the `forwardRef` call
-* @returns An array of fixes for the component's signature
-*/
 function buildFixForComponentProps(context, fixer, node, typeArguments) {
 	const getText = (node) => context.sourceCode.getText(node);
 	const [arg0, arg1] = node.params;
@@ -3093,22 +2573,6 @@ function buildFixForComponentProps(context, fixer, node, typeArguments) {
 
 //#endregion
 //#region src/utils/create-implicit-prop-listener.ts
-/**
-* Creates a listener that detects JSX spread attributes implicitly passing a given prop
-* (ex: 'children', 'key', 'ref') to a component.
-*
-* For each union constituent of the spread argument's type, the prop is reported unless:
-* 1. The prop symbol's fully qualified name is allowed (pass-through of React internally defined props)
-* 2. The fully qualified name of the prop's type symbol (or its alias) is allowed (React type aliases)
-*
-* @param context The ESLint rule context
-* @param options The prop name, the allow-list predicates (receive lowercased fully qualified names), and the report callback
-* @param options.name The name of the prop to detect
-* @param options.isAllowedProp A predicate that receives the prop symbol's lowercased fully qualified name and returns `true` if it is allowed
-* @param options.isAllowedType A predicate that receives the prop's type symbol's lowercased fully qualified name and returns `true` if it is allowed
-* @param options.onImplicitProp A callback invoked with the spread attribute node when an implicit prop is detected
-* @returns A rule listener reporting on JSX spread attributes
-*/
 function createImplicitPropListener(context, options) {
 	const { name, isAllowedProp, isAllowedType, onImplicitProp } = options;
 	const services = ESLintUtils.getParserServices(context, false);
@@ -3244,12 +2708,6 @@ function create$27(context) {
 		...compare(version, "18.0.0", "<") ? [] : ["string", "falsy string"]
 	];
 	const services = ESLintUtils.getParserServices(context, false);
-	/**
-	* Recursively inspects a node to find potential leaked conditional rendering
-	* @param node The AST node to inspect
-	* @param seen A set of visited identifier names to prevent infinite recursion.
-	* @returns A report descriptor if a problem is found, otherwise `null`
-	*/
 	function visit(node, seen = /* @__PURE__ */ new Set()) {
 		if (node == null) return null;
 		if (Check.isJSXExpressionContainer(node)) return visit(node.expression, seen);
@@ -3387,21 +2845,11 @@ function create$25(context) {
 
 //#endregion
 //#region src/rules/no-missing-key/lib.ts
-/**
-* Iterator-like methods whose callback's return value becomes an item in a rendered list,
-* mapped to the position of the callback in the call's argument list.
-* `from` covers `Array.from(iterable, mapFn)`.
-*/
 const INDEX_PARAM_POSITIONS = /* @__PURE__ */ new Map([
 	["flatMap", 0],
 	["from", 1],
 	["map", 0]
 ]);
-/**
-* Gets the nested return statements in the node that are within the same function
-* @param node The AST node
-* @returns The nested return statements in the node
-*/
 function getNestedReturnStatements$1(node) {
 	const statements = [];
 	const boundary = Check.isFunction(node) ? node : Traverse.findParent(node, Check.isFunction);
@@ -3430,11 +2878,6 @@ var no_missing_key_default = createRule({
 	create: create$24,
 	defaultOptions: []
 });
-/**
-* Gets the mapping callback of an iterator-like call expression (e.g. `.map(cb)`, `.flatMap(cb)`, `Array.from(it, cb)`).
-* @param node The call expression to inspect.
-* @returns The callback function node, or `null` if the call is not an iterator-like call with a function callback.
-*/
 function getIteratorCallback(node) {
 	const callee = Extract.unwrap(node.callee);
 	if (callee.type !== AST_NODE_TYPES.MemberExpression) return null;
@@ -3447,12 +2890,6 @@ function getIteratorCallback(node) {
 }
 function create$24(context) {
 	let childrenToArrayDepth = 0;
-	/**
-	* Checks an expression that is rendered as an item of a list,
-	* recursing into the branches it may evaluate to.
-	* @param node The expression to check.
-	* @returns The report descriptors for the violations found.
-	*/
 	function visitItemExpression(node) {
 		switch (node.type) {
 			case AST_NODE_TYPES.ChainExpression:
@@ -3474,12 +2911,6 @@ function create$24(context) {
 			default: return [];
 		}
 	}
-	/**
-	* Checks every value an iterator callback may produce as a list item,
-	* whether from an expression body or from return statements in a block body.
-	* @param node The callback function to check.
-	* @returns The report descriptors for the violations found.
-	*/
 	function visitIteratorCallback(node) {
 		if (node.body.type !== AST_NODE_TYPES.BlockStatement) return visitItemExpression(node.body);
 		return getNestedReturnStatements$1(node.body).flatMap((stmt) => stmt.argument == null ? [] : visitItemExpression(stmt.argument));
@@ -3510,23 +2941,9 @@ function create$24(context) {
 
 //#endregion
 //#region src/rules/no-misused-capture-owner-stack/lib.ts
-/**
-* Check if the given node is a member expression that accesses `process.env.NODE_ENV`
-* @param context The rule context
-* @param node The AST node
-* @returns True if the node is a member expression that accesses `process.env.NODE_ENV`, false otherwise
-*/
 function isProcessEnvNodeEnv(context, node) {
 	return node != null && core.isAPI("process.env.NODE_ENV")(context, node);
 }
-/**
-* Check if the given node is a binary expression that compares `process.env.NODE_ENV` with a string literal.
-* @param context The rule context
-* @param node The AST node
-* @param operator The operator used in the comparison
-* @param value The string literal value to compare against
-* @returns True if the node is a binary expression that compares `process.env.NODE_ENV` with the specified value, false otherwise
-*/
 function isProcessEnvNodeEnvCompare(context, node, operator, value) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.BinaryExpression) return false;
@@ -3588,44 +3005,21 @@ function create$23(context) {
 
 //#endregion
 //#region src/rules/no-nested-component-definitions/lib.ts
-/** Check if the node is a call expression to react-redux's `connect`. */
 const isConnectCall = core.isAPICall("connect");
-/** Check if the node is a call expression to Relay's `createFragmentContainer`. */
 const isCreateFragmentContainerCall = core.isAPICall("createFragmentContainer");
-/** Check if the node is a call expression to Relay's `createPaginationContainer`. */
 const isCreatePaginationContainerCall = core.isAPICall("createPaginationContainer");
-/** Check if the node is a call expression to Relay's `createRefetchContainer`. */
 const isCreateRefetchContainerCall = core.isAPICall("createRefetchContainer");
-/** Check if the node is a call expression to React's `forwardRef`. */
 const isForwardRefCall = core.isAPICall("forwardRef");
-/** Check if the node is a call expression to a `graphql` tag function (e.g. from Relay or Apollo). */
 const isGraphqlCall = core.isAPICall("graphql");
-/** Check if the node is a call expression to React's `memo`. */
 const isMemoCall = core.isAPICall("memo");
-/** Check if the node is a call expression to MobX's `observer`. */
 const isObserverCall = core.isAPICall("observer");
-/** Check if the node is a call expression to React's `useCallback`. */
 const isUseCallbackCall = core.isAPICall("useCallback");
-/** Check if the node is a call expression to Formik's `withFormik`. */
 const isWithFormikCall = core.isAPICall("withFormik");
-/** Check if the node is a call expression to recompose's `withHandlers`. */
 const isWithHandlersCall = core.isAPICall("withHandlers");
-/** Check if the node is a call expression to recompose's `withLifecycle`. */
 const isWithLifecycleCall = core.isAPICall("withLifecycle");
-/** Check if the node is a call expression to recompose's `withProps`. */
 const isWithPropsCall = core.isAPICall("withProps");
-/** Check if the node is a call expression to react-router v5's `withRouter`. */
 const isWithRouterCall = core.isAPICall("withRouter");
-/** Check if the node is a call expression to recompose's `withState`. */
 const isWithStateCall = core.isAPICall("withState");
-/**
-* Check if a call is a well-known component wrapper call (e.g. `memo`, `connect`, `withFormik`).
-* Curried forms like `connect(...)(Component)` are matched via the innermost callee call.
-* @param context The rule context
-* @param call The call expression to check
-* @param arg The function node passed to the call
-* @returns `true` if the call is a component wrapper call
-*/
 function isComponentWrapperCall(context, call, arg) {
 	if (Extract.unwrap(call.callee) === arg) return false;
 	call = getInnermostCall(call);
@@ -3646,12 +3040,6 @@ function isComponentWrapperCall(context, call, arg) {
 	if (isWithStateCall(context, call)) return true;
 	return false;
 }
-/**
-* Unwrap curried call wrappers like `connect(...)(Component)` to get the innermost call expression.
-* Type expressions and chain expressions around each callee are unwrapped along the way.
-* @param node The outermost call expression to inspect.
-* @returns The innermost call expression, whose callee is not itself a call expression.
-*/
 function getInnermostCall(node) {
 	let call = node;
 	let callee = Extract.unwrap(call.callee);
@@ -3661,12 +3049,6 @@ function getInnermostCall(node) {
 	}
 	return call;
 }
-/**
-* Resolve the name a function is bound to through wrapping calls (e.g. `const C = useCallback(...)` → `C`).
-* @param context The rule context
-* @param node The function node to resolve the bound name for
-* @returns The bound name, or `null` if the call chain does not end at an identifier declarator
-*/
 function getWrapperCallBoundName(context, node) {
 	let current = node;
 	let parent = current.parent;
@@ -3685,20 +3067,9 @@ function getWrapperCallBoundName(context, node) {
 	if (parent.type !== AST_NODE_TYPES.VariableDeclarator || !Check.isIdentifier(parent.id)) return null;
 	return parent.id.name;
 }
-/**
-* Check if the node is inside a JSX attribute value
-* @param node The AST node to check
-* @returns `true` if the node is inside a JSX attribute value
-*/
 function isInsideJSXAttributeValue(node) {
 	return node.parent.type === AST_NODE_TYPES.JSXAttribute || findParentAttribute(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer) != null;
 }
-/**
-* Check if the node is declared inside a class component's render block
-* Ex: class C extends React.Component { render() { const Nested = () => <div />; } }
-* @param node The AST node to check
-* @returns `true` if the node is inside a class component's render block
-*/
 function isInsideRenderMethod(node) {
 	return Traverse.findParent(node, (n) => core.isRenderMethodLike(n) && core.isClassComponent(n.parent.parent)) != null;
 }
@@ -4066,7 +3437,7 @@ function isContextName(name, isReact18OrBelow) {
 }
 function getHumanReadableKind$1(node) {
 	if (node.type === AST_NODE_TYPES.Literal) {
-		if ("regex" in node) return "regexp literal";
+		if (hasProperty(node, "regex")) return "regexp literal";
 		if (node.value === null) return "null literal";
 		return `${typeof node.value} literal`;
 	}
@@ -4103,7 +3474,7 @@ function create$13(context) {
 			if (enclosingFunction == null) return;
 			if (compilationMode === "annotation" && core.isFunctionHasDirective(enclosingFunction, "use memo")) return;
 			const attribute = node.attributes.find((attribute) => attribute.type === AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value");
-			if (attribute == null || !("value" in attribute)) return;
+			if (attribute == null || !hasProperty(attribute, "value")) return;
 			const value = attribute.value;
 			if (value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
 			const valueExpression = value.expression;
@@ -4141,7 +3512,7 @@ const SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR = [
 ].join("");
 function getHumanReadableKind(node) {
 	if (node.type === AST_NODE_TYPES.Literal) {
-		if ("regex" in node) return "regexp literal";
+		if (hasProperty(node, "regex")) return "regexp literal";
 		if (node.value === null) return "null literal";
 		return `${typeof node.value} literal`;
 	}
@@ -4528,9 +3899,6 @@ function create$8(context) {
 
 //#endregion
 //#region src/rules/purity/lib.ts
-/**
-* Known impure functions
-*/
 const IMPURE_FUNCS = /* @__PURE__ */ new Map([
 	["Atomics", /* @__PURE__ */ new Set([
 		"add",
@@ -4781,9 +4149,6 @@ const IMPURE_FUNCS = /* @__PURE__ */ new Map([
 		"structuredClone"
 	])]
 ]);
-/**
-* Known impure global constructors used with `new`
-*/
 const IMPURE_CTORS = /* @__PURE__ */ new Set([
 	"Audio",
 	"AudioContext",
@@ -4809,9 +4174,6 @@ const IMPURE_CTORS = /* @__PURE__ */ new Set([
 	"Worker",
 	"XMLHttpRequest"
 ]);
-/**
-* Known pure functions
-*/
 const PURE_FUNCS = /* @__PURE__ */ new Map([
 	["Array", /* @__PURE__ */ new Set([
 		"from",
@@ -4919,18 +4281,9 @@ const PURE_FUNCS = /* @__PURE__ */ new Map([
 function isCatalogObject(name) {
 	return IMPURE_FUNCS.has(name) || PURE_FUNCS.has(name);
 }
-/**
-* Check if the program has a top-level `use client` directive, marking the
-* module as a client module in React Server Components conventions.
-*/
 function hasUseClientDirective(program) {
 	return program.body.some((stmt) => stmt.type === AST_NODE_TYPES.ExpressionStatement && stmt.directive === "use client");
 }
-/**
-* Find the property key under which `name` is bound in an object destructuring
-* pattern, e.g. `"random"` for `random` in `const { random } = Math` or for
-* `r` in `const { random: r } = Math`.
-*/
 function getDestructuredPropertyName(pattern, name) {
 	for (const property of pattern.properties) {
 		if (property.type !== AST_NODE_TYPES.Property) continue;
@@ -4939,13 +4292,6 @@ function getDestructuredPropertyName(pattern, name) {
 	}
 	return null;
 }
-/**
-* Resolve a member expression to a builtin object name and property, e.g.
-* `window.Math.random` resolves to `{ object: "Math", property: "random" }`.
-* Intermediate segments are followed only while they name known catalog
-* objects (`window`, `Math`, ...), so unknown-global chains like
-* `foo.Math.random` do not resolve.
-*/
 function resolveBuiltinMember(context, node, seen = /* @__PURE__ */ new Set()) {
 	const chain = Extract.getMemberChain(node);
 	const rootId = chain.at(0);
@@ -4965,17 +4311,6 @@ function resolveBuiltinMember(context, node, seen = /* @__PURE__ */ new Set()) {
 		property: names.at(-1) ?? null
 	};
 }
-/**
-* Recursively resolve an identifier to a builtin global object name and
-* optional property. Follows simple assignment chains like `const M = Math`,
-* member-function aliases like `const random = Math.random`, and destructured
-* aliases like `const { random } = Math`.
-* Returns `null` if the identifier is locally defined (parameter, import, function declaration, etc.)
-* or resolves to a non-builtin source.
-* @param context - The rule context.
-* @param node - The identifier node to resolve.
-* @param seen - A set of already visited identifier names to prevent infinite loops.
-*/
 function resolveBuiltinObjectName(context, node, seen = /* @__PURE__ */ new Set()) {
 	if (seen.has(node.name)) return null;
 	seen.add(node.name);
@@ -5147,13 +4482,6 @@ function getRefAccess(node) {
 		node
 	};
 }
-/**
-* Check whether `node` (a `ref.current` MemberExpression) is assigned through a
-* destructuring pattern or a for-in/of loop target, e.g.
-* `({ a: ref.current } = value)`, `[ref.current] = value`,
-* `({ a: ref.current.x } = value)`, or `for (ref.current of items)`. Defaults
-* and computed keys inside patterns are reads, not writes.
-*/
 function isPatternWriteTarget(node) {
 	let child = node;
 	let current = node.parent;
@@ -5180,10 +4508,6 @@ function isPatternWriteTarget(node) {
 		current = current.parent;
 	}
 }
-/**
-* Check whether `node` (a `ref.current` MemberExpression) is being written to indirectly through
-* a nested property write, e.g. `ref.current.inner = value` or `ref.current.inner++`.
-*/
 function isNestedRefCurrentWrite(node) {
 	let outer = node;
 	let sawNesting = false;
@@ -5202,11 +4526,6 @@ function isNestedRefCurrentWrite(node) {
 		return false;
 	}
 }
-/**
-* Parse an exact nullish check and return the branch where the checked value is null/undefined.
-* Truthiness checks such as `!ref.current` are deliberately excluded: falsy ref values are not
-* necessarily uninitialized.
-*/
 function getNullCheckBranch(test, isCheckedValue, isNullishValue) {
 	const unwrapped = Extract.unwrap(test);
 	if (unwrapped.type === AST_NODE_TYPES.UnaryExpression && unwrapped.operator === "!") {
@@ -5245,7 +4564,6 @@ function getGuardDisposition(node, getNullBranch) {
 	}
 	return null;
 }
-/** Return whether every path through a statement exits the current function. */
 function isUnconditionallyTerminating(statement) {
 	switch (statement.type) {
 		case AST_NODE_TYPES.ReturnStatement:
@@ -5279,14 +4597,6 @@ function isAfterTerminatingNonNullGuard(node, getNullBranch) {
 
 //#endregion
 //#region src/rules/refs/collect.ts
-/**
-* Collect the raw facts the refs rule reasons about: identifier/member/function
-* bindings with their source positions, JSX `ref` attribute targets, call
-* expressions, ref pass sites (calls, constructor calls, tagged templates), and
-* every `.current` member access. Facts outside any function are never
-* reachable during render and are not collected. All inference is deferred to
-* `Program:exit`.
-*/
 function createFactCollector$4() {
 	const facts = {
 		bindings: [],
@@ -5386,11 +4696,9 @@ function createFactCollector$4() {
 
 //#endregion
 //#region src/rules/refs/effects.ts
-/** The nearest strict ancestor of `node` that is a component or hook. */
 function findBoundary(node, boundaries) {
 	return Traverse.findParent(node, (candidate) => Check.isFunction(candidate) && boundaries.has(candidate));
 }
-/** The boundary containing `node`, where `node` is the nearest enclosing function of the fact. */
 function getBoundaryOf(node, boundaries) {
 	return boundaries.has(node) ? node : findBoundary(node, boundaries);
 }
@@ -5398,12 +4706,6 @@ function isReachedDuringRender(node, boundary, reachability) {
 	const reached = reachability.get(boundary);
 	return reached != null && isReachedThroughFunctions(node, boundary, reached);
 }
-/**
-* Resolve the collected call edges into a per-boundary render call graph.
-* Direct calls, IIFEs, known synchronous callbacks, function declarations,
-* aliases, and simple object-property bindings all share the same
-* identity-based resolver. Each call target is resolved exactly once.
-*/
 function inferCallGraph(boundaries, callEdges, resolveCallable) {
 	const callGraph = /* @__PURE__ */ new Map();
 	for (const edge of callEdges) {
@@ -5426,10 +4728,6 @@ function inferCallGraph(boundaries, callEdges, resolveCallable) {
 	}
 	return callGraph;
 }
-/**
-* Walk the call graph from each render boundary and gather every function
-* reached during that boundary's render.
-*/
 function collectReachableFunctions(boundaries, callGraph) {
 	const reachedByBoundary = /* @__PURE__ */ new Map();
 	for (const boundary of boundaries) {
@@ -5446,10 +4744,6 @@ function collectReachableFunctions(boundaries, callGraph) {
 	}
 	return reachedByBoundary;
 }
-/**
-* Validate the reached `.current` accesses and track the one permitted lazy
-* initialization per ref.
-*/
 function inferRefViolations(accesses, boundaries, reachability, resolver) {
 	const violations = [];
 	const initializedRefs = /* @__PURE__ */ new Map();
@@ -5486,31 +4780,18 @@ function inferRefViolations(accesses, boundaries, reachability, resolver) {
 	}
 	return violations;
 }
-/**
-* Get the statically known name of a pass-site callee, whether it is a plain
-* call, a constructor call, or a tagged template.
-*/
 function getPassSiteCalleeName(node) {
 	const callee = Extract.unwrap(node.type === AST_NODE_TYPES.TaggedTemplateExpression ? node.tag : node.callee);
 	if (Check.isIdentifier(callee)) return callee.name;
 	if (callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && Check.isIdentifier(callee.property)) return callee.property.name;
 	return null;
 }
-/**
-* The `mergeRefs` exemption is name-based but alias-aware: a simple variable
-* alias of a `mergeRefs` binding keeps the exemption.
-*/
 function isMergeRefsCallee(callee, calleeName, position, resolver) {
 	if (calleeName === "mergeRefs") return true;
 	if (callee.type !== AST_NODE_TYPES.Identifier) return false;
 	const variable = resolver.getVariable(callee);
 	return variable != null && resolver.resolveAliasTarget(variable, position).name === "mergeRefs";
 }
-/**
-* Passing a ref to an unknown function can expose its value during render.
-* Hook callbacks, mergeRefs, and the existing render-prop compatibility case
-* remain exempt.
-*/
 function inferRefPassViolations(passSites, boundaries, reachability, resolver) {
 	const violations = [];
 	for (const site of passSites) {
@@ -5540,11 +4821,6 @@ function inferRefPassViolations(passSites, boundaries, reachability, resolver) {
 
 //#endregion
 //#region src/rules/refs/origins.ts
-/**
-* Resolve which variables hold refs and which resolve to callable functions.
-* Maps are keyed by ESLint variables, not source names, so shadowed
-* identifiers and separate components cannot contaminate each other.
-*/
 function createBindingResolver(context, facts) {
 	const { additionalRefHooks } = getSettingsFromContext(context);
 	const bindings = /* @__PURE__ */ new Map();
@@ -5637,11 +4913,6 @@ function createBindingResolver(context, facts) {
 			case "unknown": return null;
 		}
 	}
-	/**
-	* Follow simple variable-to-variable aliases to the terminal variable, e.g.
-	* `const combine = mergeRefs` resolves to the `mergeRefs` variable itself.
-	* Position-aware, so a reassigned alias resolves to its latest source.
-	*/
 	function resolveAliasTarget(variable, position, seen = /* @__PURE__ */ new Set()) {
 		if (seen.has(variable)) return variable;
 		seen.add(variable);
@@ -5753,38 +5024,17 @@ function create$6(context) {
 function assert(cond, message) {
 	if (!cond) throw new Error(message ?? "Assertion violated.");
 }
-/**
-* Checks whether or not a given segment is reachable.
-*/
 function isReachable$1(segment) {
 	return segment.reachable;
 }
-/**
-* A code path segment.
-*/
 var CodePathSegment = class CodePathSegment {
-	/**
-	* The identifier of this code path.
-	* Rules use it to store additional information of each rule.
-	*/
 	id;
-	/** An array of the next reachable segments. */
 	nextSegments;
-	/** An array of the previous reachable segments. */
 	prevSegments;
-	/** An array of all next segments (including unreachable). */
 	allNextSegments;
-	/** An array of all previous segments (including unreachable). */
 	allPrevSegments;
-	/** Whether this segment is reachable. */
 	reachable;
-	/** Internal bookkeeping data. */
 	internal;
-	/**
-	* @param id An identifier.
-	* @param allPrevSegments An array of the previous segments (including unreachable).
-	* @param reachable Whether this segment is reachable.
-	*/
 	constructor(id, allPrevSegments, reachable) {
 		this.id = id;
 		this.nextSegments = [];
@@ -5797,44 +5047,23 @@ var CodePathSegment = class CodePathSegment {
 			loopedPrevSegments: []
 		};
 	}
-	/**
-	* Checks if a given previous segment is coming from the end of a loop.
-	*/
 	isLoopedPrevSegment(segment) {
 		return this.internal.loopedPrevSegments.includes(segment);
 	}
-	/**
-	* Creates the root segment.
-	*/
 	static newRoot(id) {
 		return new CodePathSegment(id, [], true);
 	}
-	/**
-	* Creates a segment that follows given segments.
-	*/
 	static newNext(id, allPrevSegments) {
 		return new CodePathSegment(id, CodePathSegment.flattenUnusedSegments(allPrevSegments), allPrevSegments.some(isReachable$1));
 	}
-	/**
-	* Creates an unreachable segment that follows given segments.
-	*/
 	static newUnreachable(id, allPrevSegments) {
 		const segment = new CodePathSegment(id, CodePathSegment.flattenUnusedSegments(allPrevSegments), false);
 		CodePathSegment.markUsed(segment);
 		return segment;
 	}
-	/**
-	* Creates a segment that follows given segments.
-	* This factory method does not connect with `allPrevSegments`.
-	* But this inherits `reachable` flag.
-	*/
 	static newDisconnected(id, allPrevSegments) {
 		return new CodePathSegment(id, [], allPrevSegments.some(isReachable$1));
 	}
-	/**
-	* Makes a given segment being used.
-	* Also registers the segment into the previous segments as a next.
-	*/
 	static markUsed(segment) {
 		if (segment.internal.used) return;
 		segment.internal.used = true;
@@ -5846,15 +5075,9 @@ var CodePathSegment = class CodePathSegment {
 		}
 		else for (i = 0; i < segment.allPrevSegments.length; ++i) segment.allPrevSegments[i].allNextSegments.push(segment);
 	}
-	/**
-	* Marks a previous segment as looped.
-	*/
 	static markPrevSegmentAsLooped(segment, prevSegment) {
 		segment.internal.loopedPrevSegments.push(prevSegment);
 	}
-	/**
-	* Replaces unused segments with the previous segments of each unused segment.
-	*/
 	static flattenUnusedSegments(segments) {
 		const done = Object.create(null);
 		const retv = [];
@@ -5876,19 +5099,9 @@ var CodePathSegment = class CodePathSegment {
 		return retv;
 	}
 };
-/**
-* Gets whether or not a given segment is reachable.
-*/
 function isReachable(segment) {
 	return segment.reachable;
 }
-/**
-* Creates new segments from the specific range of `context.segmentsList`.
-*
-* When `context.segmentsList` is `[[a, b], [c, d], [e, f]]`, `begin` is `0`, and
-* `end` is `-1`, this creates `[g, h]`. This `g` is from `a`, `c`, and `e`.
-* This `h` is from `b`, `d`, and `f`.
-*/
 function makeSegments(context, begin, end, create) {
 	const list = context.segmentsList;
 	const normalizedBegin = begin >= 0 ? begin : list.length + begin;
@@ -5901,12 +5114,6 @@ function makeSegments(context, begin, end, create) {
 	}
 	return segments;
 }
-/**
-* `segments` becomes doubly in a `finally` block. Then if a code path exits by a
-* control statement (such as `break`, `continue`) from the `finally` block, the
-* destination's segments may be half of the source segments. In that case, this
-* merges segments.
-*/
 function mergeExtraSegments(context, segments) {
 	let currentSegments = segments;
 	while (currentSegments.length > context.count) {
@@ -5916,9 +5123,6 @@ function mergeExtraSegments(context, segments) {
 	}
 	return currentSegments;
 }
-/**
-* A class to manage forking.
-*/
 var ForkContext = class ForkContext {
 	idGenerator;
 	upper;
@@ -5930,91 +5134,51 @@ var ForkContext = class ForkContext {
 		this.count = count;
 		this.segmentsList = [];
 	}
-	/** The head segments. */
 	get head() {
 		const list = this.segmentsList;
 		return list.length === 0 ? [] : list[list.length - 1];
 	}
-	/** Whether the segments list is empty. */
 	get empty() {
 		return this.segmentsList.length === 0;
 	}
-	/** Whether any head segment is reachable. */
 	get reachable() {
 		const segments = this.head;
 		return segments.length > 0 && segments.some(isReachable);
 	}
-	/**
-	* Creates new segments from this context.
-	*/
 	makeNext(begin, end) {
 		return makeSegments(this, begin, end, CodePathSegment.newNext);
 	}
-	/**
-	* Creates new unreachable segments from this context.
-	*/
 	makeUnreachable(begin, end) {
 		return makeSegments(this, begin, end, CodePathSegment.newUnreachable);
 	}
-	/**
-	* Creates new disconnected segments from this context.
-	* The new segments don't have connections for previous segments,
-	* but inherit the reachable flag.
-	*/
 	makeDisconnected(begin, end) {
 		return makeSegments(this, begin, end, CodePathSegment.newDisconnected);
 	}
-	/**
-	* Adds segments into this context. The added segments become the head.
-	*/
 	add(segments) {
 		assert(segments.length >= this.count, `${segments.length} >= ${this.count}`);
 		this.segmentsList.push(mergeExtraSegments(this, segments));
 	}
-	/**
-	* Replaces the head segments with given segments.
-	* The current head segments are removed.
-	*/
 	replaceHead(segments) {
 		assert(segments.length >= this.count, `${segments.length} >= ${this.count}`);
 		this.segmentsList.splice(-1, 1, mergeExtraSegments(this, segments));
 	}
-	/**
-	* Adds all segments of a given fork context into this context.
-	*/
 	addAll(context) {
 		assert(context.count === this.count);
 		const source = context.segmentsList;
 		for (let i = 0; i < source.length; ++i) this.segmentsList.push(source[i]);
 	}
-	/**
-	* Clears all segments in this context.
-	*/
 	clear() {
 		this.segmentsList = [];
 	}
-	/**
-	* Creates the root fork context.
-	*/
 	static newRoot(idGenerator) {
 		const context = new ForkContext(idGenerator, null, 1);
 		context.add([CodePathSegment.newRoot(idGenerator.next())]);
 		return context;
 	}
-	/**
-	* Creates an empty fork context preceded by a given context.
-	*/
 	static newEmpty(parentContext, forkLeavingPath) {
 		return new ForkContext(parentContext.idGenerator, parentContext, (forkLeavingPath ? 2 : 1) * parentContext.count);
 	}
 };
-/**
-* Adds given segments into the `dest` array.
-* If the `others` array does not include the given segments, adds to the `all`
-* array as well.
-*
-* This adds only reachable and used segments.
-*/
 function addToReturnedOrThrown(dest, others, all, segments) {
 	for (let i = 0; i < segments.length; ++i) {
 		const segment = segments[i];
@@ -6022,9 +5186,6 @@ function addToReturnedOrThrown(dest, others, all, segments) {
 		if (!others.includes(segment)) all.push(segment);
 	}
 }
-/**
-* Gets a loop-context for a `continue` statement.
-*/
 function getContinueContext(state, label) {
 	if (!label) return state.loopContext;
 	let context = state.loopContext;
@@ -6035,9 +5196,6 @@ function getContinueContext(state, label) {
 	/* c8 ignore next */
 	return null;
 }
-/**
-* Gets a context for a `break` statement.
-*/
 function getBreakContext(state, label) {
 	let context = state.breakContext;
 	while (context) {
@@ -6047,9 +5205,6 @@ function getBreakContext(state, label) {
 	/* c8 ignore next */
 	return null;
 }
-/**
-* Gets a context for a `return` statement.
-*/
 function getReturnContext(state) {
 	let context = state.tryContext;
 	while (context) {
@@ -6058,9 +5213,6 @@ function getReturnContext(state) {
 	}
 	return state;
 }
-/**
-* Gets a context for a `throw` statement.
-*/
 function getThrowContext(state) {
 	let context = state.tryContext;
 	while (context) {
@@ -6069,19 +5221,9 @@ function getThrowContext(state) {
 	}
 	return state;
 }
-/**
-* Removes a given element from a given array.
-*/
 function remove(xs, x) {
 	xs.splice(xs.indexOf(x), 1);
 }
-/**
-* Disconnect given segments.
-*
-* This is used in a process for switch statements.
-* If there is the "default" chunk before other cases, the order is different
-* between node's and running's.
-*/
 function removeConnection(prevSegments, nextSegments) {
 	for (let i = 0; i < prevSegments.length; ++i) {
 		const prevSegment = prevSegments[i];
@@ -6092,9 +5234,6 @@ function removeConnection(prevSegments, nextSegments) {
 		remove(nextSegment.allPrevSegments, prevSegment);
 	}
 }
-/**
-* Creates looping path.
-*/
 function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
 	const fromSegments = CodePathSegment.flattenUnusedSegments(unflattenedFromSegments);
 	const toSegments = CodePathSegment.flattenUnusedSegments(unflattenedToSegments);
@@ -6110,12 +5249,6 @@ function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
 		state.notifyLooped(fromSegment, toSegment);
 	}
 }
-/**
-* Finalizes segments of `test` chunk of a ForStatement.
-*
-* - Adds `false` paths to paths which are leaving from the loop.
-* - Sets `true` paths to paths which go to the body.
-*/
 function finalizeTestSegmentsOfFor(context, choiceContext, head) {
 	if (!choiceContext.processed) {
 		choiceContext.trueForkContext.add(head);
@@ -6125,9 +5258,6 @@ function finalizeTestSegmentsOfFor(context, choiceContext, head) {
 	if (context.test !== true) context.brokenForkContext.addAll(choiceContext.falseForkContext);
 	context.endOfTestSegments = choiceContext.trueForkContext.makeNext(0, -1);
 }
-/**
-* A class which manages state to analyze code paths.
-*/
 var CodePathState = class {
 	idGenerator;
 	notifyLooped;
@@ -6164,60 +5294,29 @@ var CodePathState = class {
 		returned.add = addToReturnedOrThrown.bind(null, returned, thrown, final);
 		thrown.add = addToReturnedOrThrown.bind(null, thrown, returned, final);
 	}
-	/** The head segments. */
 	get headSegments() {
 		return this.forkContext.head;
 	}
-	/**
-	* The parent forking context.
-	* This is used for the root of new forks.
-	*/
 	get parentForkContext() {
 		const current = this.forkContext;
 		return current && current.upper;
 	}
-	/**
-	* Creates and stacks new forking context.
-	*/
 	pushForkContext(forkLeavingPath) {
 		this.forkContext = ForkContext.newEmpty(this.forkContext, forkLeavingPath);
 		return this.forkContext;
 	}
-	/**
-	* Pops and merges the last forking context.
-	*/
 	popForkContext() {
 		const lastContext = this.forkContext;
 		this.forkContext = lastContext.upper;
 		this.forkContext.replaceHead(lastContext.makeNext(0, -1));
 		return lastContext;
 	}
-	/**
-	* Creates a new path.
-	*/
 	forkPath() {
 		this.forkContext.add(this.parentForkContext.makeNext(-1, -1));
 	}
-	/**
-	* Creates a bypass path.
-	* This is used for such as IfStatement which does not have "else" chunk.
-	*/
 	forkBypassPath() {
 		this.forkContext.add(this.parentForkContext.head);
 	}
-	/**
-	* Creates a context for ConditionalExpression, LogicalExpression,
-	* AssignmentExpression (logical assignments only), IfStatement,
-	* WhileStatement, DoWhileStatement, or ForStatement.
-	*
-	* @param kind A kind string.
-	*   If the new context is LogicalExpression's or AssignmentExpression's,
-	*   this is `"&&"` or `"||"` or `"??"`.
-	*   If it's IfStatement's or ConditionalExpression's, this is `"test"`.
-	*   Otherwise, this is `"loop"`.
-	* @param isForkingAsResult A flag that shows that goes different
-	*   paths between `true` and `false`.
-	*/
 	pushChoiceContext(kind, isForkingAsResult) {
 		this.choiceContext = {
 			upper: this.choiceContext,
@@ -6229,9 +5328,6 @@ var CodePathState = class {
 			processed: false
 		};
 	}
-	/**
-	* Pops the last choice context and finalizes it.
-	*/
 	popChoiceContext() {
 		const context = this.choiceContext;
 		this.choiceContext = context.upper;
@@ -6272,10 +5368,6 @@ var CodePathState = class {
 		forkContext.replaceHead(prevForkContext.makeNext(0, -1));
 		return context;
 	}
-	/**
-	* Makes a code path segment of the right-hand operand of a logical
-	* expression.
-	*/
 	makeLogicalRight() {
 		const context = this.choiceContext;
 		const forkContext = this.forkContext;
@@ -6313,9 +5405,6 @@ var CodePathState = class {
 			forkContext.replaceHead(forkContext.makeNext(-1, -1));
 		}
 	}
-	/**
-	* Makes a code path segment of the `if` block.
-	*/
 	makeIfConsequent() {
 		const context = this.choiceContext;
 		const forkContext = this.forkContext;
@@ -6327,9 +5416,6 @@ var CodePathState = class {
 		context.processed = false;
 		forkContext.replaceHead(context.trueForkContext.makeNext(0, -1));
 	}
-	/**
-	* Makes a code path segment of the `else` block.
-	*/
 	makeIfAlternate() {
 		const context = this.choiceContext;
 		const forkContext = this.forkContext;
@@ -6338,50 +5424,26 @@ var CodePathState = class {
 		context.processed = true;
 		forkContext.replaceHead(context.falseForkContext.makeNext(0, -1));
 	}
-	/**
-	* Push a new `ChainExpression` context to the stack.
-	* This method is called on entering to each `ChainExpression` node.
-	* This context is used to count forking in the optional chain then merge
-	* them on exiting from the `ChainExpression` node.
-	*/
 	pushChainContext() {
 		this.chainContext = {
 			upper: this.chainContext,
 			countChoiceContexts: 0
 		};
 	}
-	/**
-	* Pop a `ChainExpression` context from the stack.
-	* This method is called on exiting from each `ChainExpression` node.
-	* This merges all forks of the last optional chaining.
-	*/
 	popChainContext() {
 		const context = this.chainContext;
 		this.chainContext = context.upper;
 		for (let i = context.countChoiceContexts; i > 0; --i) this.popChoiceContext();
 	}
-	/**
-	* Create a choice context for optional access.
-	* This method is called on entering to each `(Call|Member)Expression[optional=true]` node.
-	* This creates a choice context as similar to `LogicalExpression[operator="??"]` node.
-	*/
 	makeOptionalNode() {
 		if (this.chainContext) {
 			this.chainContext.countChoiceContexts += 1;
 			this.pushChoiceContext("??", false);
 		}
 	}
-	/**
-	* Create a fork.
-	* This method is called on entering to the `arguments|property` property
-	* of each `(Call|Member)Expression` node.
-	*/
 	makeOptionalRight() {
 		if (this.chainContext) this.makeLogicalRight();
 	}
-	/**
-	* Creates a context object of SwitchStatement and stacks it.
-	*/
 	pushSwitchContext(hasCase, label) {
 		this.switchContext = {
 			upper: this.switchContext,
@@ -6394,14 +5456,6 @@ var CodePathState = class {
 		};
 		this.pushBreakContext(true, label);
 	}
-	/**
-	* Pops the last context of SwitchStatement and finalizes it.
-	*
-	* - Disposes all forking stack for `case` and `default`.
-	* - Creates the next code path segment from `context.brokenForkContext`.
-	* - If the last `SwitchCase` node is not a `default` part, creates a path
-	*   to the `default` body.
-	*/
 	popSwitchContext() {
 		const context = this.switchContext;
 		this.switchContext = context.upper;
@@ -6427,9 +5481,6 @@ var CodePathState = class {
 		for (let i = 0; i < context.countForks; ++i) this.forkContext = this.forkContext.upper;
 		this.forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
 	}
-	/**
-	* Makes a code path segment for a `SwitchCase` node.
-	*/
 	makeSwitchCaseBody(isEmpty, isDefault) {
 		const context = this.switchContext;
 		if (!context.hasCase) return;
@@ -6447,9 +5498,6 @@ var CodePathState = class {
 		context.lastIsDefault = isDefault;
 		context.countForks += 1;
 	}
-	/**
-	* Creates a context object of TryStatement and stacks it.
-	*/
 	pushTryContext(hasFinalizer) {
 		this.tryContext = {
 			upper: this.tryContext,
@@ -6461,9 +5509,6 @@ var CodePathState = class {
 			lastOfCatchIsReachable: false
 		};
 	}
-	/**
-	* Pops the last context of TryStatement and finalizes it.
-	*/
 	popTryContext() {
 		const context = this.tryContext;
 		this.tryContext = context.upper;
@@ -6483,9 +5528,6 @@ var CodePathState = class {
 		this.forkContext.replaceHead(normalSegments);
 		if (!context.lastOfTryIsReachable && !context.lastOfCatchIsReachable) this.forkContext.makeUnreachable(-1, -1);
 	}
-	/**
-	* Makes a code path segment for a `catch` block.
-	*/
 	makeCatchBlock() {
 		const context = this.tryContext;
 		const forkContext = this.forkContext;
@@ -6499,13 +5541,6 @@ var CodePathState = class {
 		this.forkBypassPath();
 		this.forkContext.add(thrownSegments);
 	}
-	/**
-	* Makes a code path segment for a `finally` block.
-	*
-	* In the `finally` block, parallel paths are created. The parallel paths
-	* are used as leaving-paths. The leaving-paths are paths from `return`
-	* statements and `throw` statements in a `try` block or a `catch` block.
-	*/
 	makeFinallyBlock() {
 		const context = this.tryContext;
 		let forkContext = this.forkContext;
@@ -6529,10 +5564,6 @@ var CodePathState = class {
 		this.pushForkContext(true);
 		this.forkContext.add(segments);
 	}
-	/**
-	* Makes a code path segment from the first throwable node to the `catch`
-	* block or the `finally` block.
-	*/
 	makeFirstThrowablePathInTryBlock() {
 		const forkContext = this.forkContext;
 		if (!forkContext.reachable) return;
@@ -6541,9 +5572,6 @@ var CodePathState = class {
 		context.thrownForkContext.add(forkContext.head);
 		forkContext.replaceHead(forkContext.makeNext(-1, -1));
 	}
-	/**
-	* Creates a context object of a loop statement and stacks it.
-	*/
 	pushLoopContext(type, label) {
 		const forkContext = this.forkContext;
 		const breakContext = this.pushBreakContext(true, label);
@@ -6603,9 +5631,6 @@ var CodePathState = class {
 			default: throw new Error(`unknown type: "${type}"`);
 		}
 	}
-	/**
-	* Pops the last context of a loop statement and finalizes it.
-	*/
 	popLoopContext() {
 		const context = this.loopContext;
 		this.loopContext = context.upper;
@@ -6638,9 +5663,6 @@ var CodePathState = class {
 		if (brokenForkContext.empty) forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
 		else forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
 	}
-	/**
-	* Makes a code path segment for the test part of a WhileStatement.
-	*/
 	makeWhileTest(test) {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6649,9 +5671,6 @@ var CodePathState = class {
 		context.continueDestSegments = testSegments;
 		forkContext.replaceHead(testSegments);
 	}
-	/**
-	* Makes a code path segment for the body part of a WhileStatement.
-	*/
 	makeWhileBody() {
 		const context = this.loopContext;
 		const choiceContext = this.choiceContext;
@@ -6663,9 +5682,6 @@ var CodePathState = class {
 		if (context.test !== true) context.brokenForkContext.addAll(choiceContext.falseForkContext);
 		forkContext.replaceHead(choiceContext.trueForkContext.makeNext(0, -1));
 	}
-	/**
-	* Makes a code path segment for the body part of a DoWhileStatement.
-	*/
 	makeDoWhileBody() {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6673,9 +5689,6 @@ var CodePathState = class {
 		context.entrySegments = bodySegments;
 		forkContext.replaceHead(bodySegments);
 	}
-	/**
-	* Makes a code path segment for the test part of a DoWhileStatement.
-	*/
 	makeDoWhileTest(test) {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6686,9 +5699,6 @@ var CodePathState = class {
 			forkContext.replaceHead(testSegments);
 		}
 	}
-	/**
-	* Makes a code path segment for the test part of a ForStatement.
-	*/
 	makeForTest(test) {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6699,9 +5709,6 @@ var CodePathState = class {
 		context.continueDestSegments = context.testSegments = testSegments;
 		forkContext.replaceHead(testSegments);
 	}
-	/**
-	* Makes a code path segment for the update part of a ForStatement.
-	*/
 	makeForUpdate() {
 		const context = this.loopContext;
 		const choiceContext = this.choiceContext;
@@ -6712,9 +5719,6 @@ var CodePathState = class {
 		context.continueDestSegments = context.updateSegments = updateSegments;
 		forkContext.replaceHead(updateSegments);
 	}
-	/**
-	* Makes a code path segment for the body part of a ForStatement.
-	*/
 	makeForBody() {
 		const context = this.loopContext;
 		const choiceContext = this.choiceContext;
@@ -6734,10 +5738,6 @@ var CodePathState = class {
 		context.continueDestSegments = context.continueDestSegments || bodySegments;
 		forkContext.replaceHead(bodySegments);
 	}
-	/**
-	* Makes a code path segment for the left part of a ForInStatement and a
-	* ForOfStatement.
-	*/
 	makeForInOfLeft() {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6746,10 +5746,6 @@ var CodePathState = class {
 		context.leftSegments = context.continueDestSegments = leftSegments;
 		forkContext.replaceHead(leftSegments);
 	}
-	/**
-	* Makes a code path segment for the right part of a ForInStatement and a
-	* ForOfStatement.
-	*/
 	makeForInOfRight() {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6759,10 +5755,6 @@ var CodePathState = class {
 		context.endOfLeftSegments = forkContext.head;
 		forkContext.replaceHead(rightSegments);
 	}
-	/**
-	* Makes a code path segment for the body part of a ForInStatement and a
-	* ForOfStatement.
-	*/
 	makeForInOfBody() {
 		const context = this.loopContext;
 		const forkContext = this.forkContext;
@@ -6773,9 +5765,6 @@ var CodePathState = class {
 		context.brokenForkContext.add(forkContext.head);
 		forkContext.replaceHead(bodySegments);
 	}
-	/**
-	* Creates new context for BreakStatement.
-	*/
 	pushBreakContext(breakable, label) {
 		this.breakContext = {
 			upper: this.breakContext,
@@ -6785,9 +5774,6 @@ var CodePathState = class {
 		};
 		return this.breakContext;
 	}
-	/**
-	* Removes the top item of the break context stack.
-	*/
 	popBreakContext() {
 		const context = this.breakContext;
 		const forkContext = this.forkContext;
@@ -6801,12 +5787,6 @@ var CodePathState = class {
 		}
 		return context;
 	}
-	/**
-	* Makes a path for a `break` statement.
-	*
-	* It registers the head segment to a context of `break`.
-	* It makes new unreachable segment, then it set the head with the segment.
-	*/
 	makeBreak(label) {
 		const forkContext = this.forkContext;
 		if (!forkContext.reachable) return;
@@ -6815,12 +5795,6 @@ var CodePathState = class {
 		/* c8 ignore next */
 		forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
 	}
-	/**
-	* Makes a path for a `continue` statement.
-	*
-	* It makes a looping path.
-	* It makes new unreachable segment, then it set the head with the segment.
-	*/
 	makeContinue(label) {
 		const forkContext = this.forkContext;
 		if (!forkContext.reachable) return;
@@ -6833,12 +5807,6 @@ var CodePathState = class {
 		}
 		forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
 	}
-	/**
-	* Makes a path for a `return` statement.
-	*
-	* It registers the head segment to a context of `return`.
-	* It makes new unreachable segment, then it set the head with the segment.
-	*/
 	makeReturn() {
 		const forkContext = this.forkContext;
 		if (forkContext.reachable) {
@@ -6846,12 +5814,6 @@ var CodePathState = class {
 			forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
 		}
 	}
-	/**
-	* Makes a path for a `throw` statement.
-	*
-	* It registers the head segment to a context of `throw`.
-	* It makes new unreachable segment, then it set the head with the segment.
-	*/
 	makeThrow() {
 		const forkContext = this.forkContext;
 		if (forkContext.reachable) {
@@ -6859,17 +5821,11 @@ var CodePathState = class {
 			forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
 		}
 	}
-	/**
-	* Makes the final path.
-	*/
 	makeFinal() {
 		const segments = this.currentSegments;
 		if (segments.length > 0 && segments[0].reachable) this.returnedForkContext.add(segments);
 	}
 };
-/**
-* A generator for unique ids.
-*/
 var IdGenerator = class {
 	prefix;
 	n;
@@ -6877,9 +5833,6 @@ var IdGenerator = class {
 		this.prefix = String(prefix);
 		this.n = 0;
 	}
-	/**
-	* Generates id.
-	*/
 	next() {
 		this.n = 1 + this.n | 0;
 		/* c8 ignore start */
@@ -6887,22 +5840,11 @@ var IdGenerator = class {
 		return this.prefix + this.n;
 	}
 };
-/**
-* A code path.
-*/
 var CodePath = class {
-	/** The identifier of this code path. */
 	id;
-	/**
-	* The reason that this code path was started. May be "program",
-	* "function", "class-field-initializer", or "class-static-block".
-	*/
 	origin;
-	/** The code path of the upper function scope. */
 	upper;
-	/** The code paths of nested function scopes. */
 	childCodePaths;
-	/** Internal state for the code path. */
 	internal;
 	constructor({ id, origin, upper, onLooped }) {
 		this.id = id;
@@ -6912,48 +5854,24 @@ var CodePath = class {
 		this.internal = new CodePathState(new IdGenerator(`${id}_`), onLooped);
 		if (upper) upper.childCodePaths.push(this);
 	}
-	/**
-	* Gets the state of a given code path.
-	*/
 	static getState(codePath) {
 		return codePath.internal;
 	}
-	/** The initial code path segment. */
 	get initialSegment() {
 		return this.internal.initialSegment;
 	}
-	/**
-	* Final code path segments.
-	* This array is a mix of `returnedSegments` and `thrownSegments`.
-	*/
 	get finalSegments() {
 		return this.internal.finalSegments;
 	}
-	/**
-	* Final code path segments which is with `return` statements.
-	* This array contains the last path segment if it's reachable.
-	* Since the reachable last path returns `undefined`.
-	*/
 	get returnedSegments() {
 		return this.internal.returnedForkContext;
 	}
-	/** Final code path segments which is with `throw` statements. */
 	get thrownSegments() {
 		return this.internal.thrownForkContext;
 	}
-	/** Current code path segments. */
 	get currentSegments() {
 		return this.internal.currentSegments;
 	}
-	/**
-	* Traverses all segments in this code path.
-	*
-	* This method enumerates segments in order from the head.
-	*
-	* The `controller` object has two methods:
-	* - `controller.skip()` - Skip the following segments in this branch.
-	* - `controller.break()` - Skip all following segments.
-	*/
 	traverseSegments(options, callback) {
 		let resolvedOptions;
 		let resolvedCallback;
@@ -7019,45 +5937,23 @@ var CodePath = class {
 	}
 };
 const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
-/**
-* Checks whether or not a given node is a `case` node (not `default` node).
-*/
 function isCaseNode(node) {
 	return Boolean(node.test);
 }
-/**
-* Checks if a given node appears as the value of a PropertyDefinition node.
-*/
 function isPropertyDefinitionValue(node) {
 	const parent = node.parent;
 	return parent && parent.type === "PropertyDefinition" && parent.value === node;
 }
-/**
-* Checks whether the given logical operator is taken into account for the code
-* path analysis.
-*/
 function isHandledLogicalOperator(operator) {
 	return operator === "&&" || operator === "||" || operator === "??";
 }
-/**
-* Checks whether the given assignment operator is a logical assignment operator.
-* Logical assignments are taken into account for the code path analysis
-* because of their short-circuiting semantics.
-*/
 function isLogicalAssignmentOperator(operator) {
 	return operator === "&&=" || operator === "||=" || operator === "??=";
 }
-/**
-* Gets the label if the parent node of a given node is a LabeledStatement.
-*/
 function getLabel(node) {
 	if (node.parent.type === "LabeledStatement") return node.parent.label.name;
 	return null;
 }
-/**
-* Checks whether or not a given logical expression node goes different path
-* between the `true` case and the `false` case.
-*/
 function isForkingByTrueOrFalse(node) {
 	const parent = node.parent;
 	switch (parent.type) {
@@ -7071,21 +5967,9 @@ function isForkingByTrueOrFalse(node) {
 		default: return false;
 	}
 }
-/**
-* Gets the boolean value of a given literal node.
-*
-* This is used to detect infinity loops (ex: `while (true) {}`).
-* Statements preceded by an infinity loop are unreachable if the loop didn't
-* have any `break` statement.
-*/
 function getBooleanValueIfSimpleConstant(node) {
 	if (node.type === "Literal") return Boolean(node.value);
 }
-/**
-* Checks that a given identifier node is a reference or not.
-*
-* This is used to detect the first throwable node in a `try` block.
-*/
 function isIdentifierReference(node) {
 	const parent = node.parent;
 	switch (parent.type) {
@@ -7113,15 +5997,6 @@ function isIdentifierReference(node) {
 		default: return true;
 	}
 }
-/**
-* Updates the current segment with the head segment.
-* This is similar to local branches and tracking branches of git.
-*
-* To separate the current and the head is in order to not make useless segments.
-*
-* In this process, both "onCodePathSegmentStart" and "onCodePathSegmentEnd"
-* events are fired.
-*/
 function forwardCurrentToHead(analyzer, node) {
 	const codePath = analyzer.codePath;
 	const state = CodePath.getState(codePath);
@@ -7148,10 +6023,6 @@ function forwardCurrentToHead(analyzer, node) {
 		}
 	}
 }
-/**
-* Updates the current segment with empty.
-* This is called at the last of functions or the program.
-*/
 function leaveFromCurrentSegment(analyzer, node) {
 	const state = CodePath.getState(analyzer.codePath);
 	const currentSegments = state.currentSegments;
@@ -7161,13 +6032,6 @@ function leaveFromCurrentSegment(analyzer, node) {
 	}
 	state.currentSegments = [];
 }
-/**
-* Updates the code path due to the position of a given node in the parent node
-* thereof.
-*
-* For example, if the node is `parent.consequent`, this creates a fork from the
-* current path.
-*/
 function preprocess(analyzer, node) {
 	const codePath = analyzer.codePath;
 	const state = CodePath.getState(codePath);
@@ -7232,17 +6096,10 @@ function preprocess(analyzer, node) {
 		}
 	}
 }
-/**
-* Updates the code path due to the type of a given node in entering.
-*/
 function processCodePathToEnter(analyzer, node) {
 	let codePath = analyzer.codePath;
 	let state = codePath && CodePath.getState(codePath);
 	const parent = node.parent;
-	/**
-	* Creates a new code path and trigger the onCodePathStart event
-	* based on the currently selected node.
-	*/
 	function startCodePath(origin) {
 		if (codePath) forwardCurrentToHead(analyzer, node);
 		codePath = analyzer.codePath = new CodePath({
@@ -7308,9 +6165,6 @@ function processCodePathToEnter(analyzer, node) {
 	}
 	forwardCurrentToHead(analyzer, node);
 }
-/**
-* Updates the code path due to the type of a given node in leaving.
-*/
 function processCodePathToExit(analyzer, node) {
 	const codePath = analyzer.codePath;
 	const state = CodePath.getState(codePath);
@@ -7386,9 +6240,6 @@ function processCodePathToExit(analyzer, node) {
 	}
 	if (!dontForward) forwardCurrentToHead(analyzer, node);
 }
-/**
-* Updates the code path to finalize the current code path.
-*/
 function postprocess(analyzer, node) {
 	function endCodePath() {
 		const codePath = analyzer.codePath;
@@ -7411,10 +6262,6 @@ function postprocess(analyzer, node) {
 	}
 	if (isPropertyDefinitionValue(node)) endCodePath();
 }
-/**
-* The class to analyze code paths.
-* This class implements the EventGenerator interface.
-*/
 var CodePathAnalyzer = class {
 	emitter;
 	codePath;
@@ -7430,30 +6277,18 @@ var CodePathAnalyzer = class {
 		this.currentNode = null;
 		this.onLooped = this._onLooped.bind(this);
 	}
-	/**
-	* Does the process to enter a given AST node.
-	* This updates state of analysis and calls `enterNode` of the wrapped.
-	*/
 	enterNode(node) {
 		this.currentNode = node;
 		if (node.parent) preprocess(this, node);
 		processCodePathToEnter(this, node);
 		this.currentNode = null;
 	}
-	/**
-	* Does the process to leave a given AST node.
-	* This updates state of analysis and calls `leaveNode` of the wrapped.
-	*/
 	leaveNode(node) {
 		this.currentNode = node;
 		processCodePathToExit(this, node);
 		postprocess(this, node);
 		this.currentNode = null;
 	}
-	/**
-	* This is called on a code path looped.
-	* Then this raises a looped event.
-	*/
 	_onLooped(fromSegment, toSegment) {
 		if (fromSegment.reachable && toSegment.reachable) this.emitter.emit("onCodePathSegmentLoop", fromSegment, toSegment, this.currentNode);
 	}
@@ -7461,17 +6296,9 @@ var CodePathAnalyzer = class {
 
 //#endregion
 //#region src/rules/rules-of-hooks/rules-of-hooks.ts
-/**
-* Catch all identifiers that begin with "use" followed by an uppercase Latin
-* character to exclude identifiers like "user".
-*/
 function isHookName(s) {
 	return s === "use" || /^use[A-Z0-9]/.test(s);
 }
-/**
-* We consider hooks to be a hook name identifier or a member expression
-* containing a hook name.
-*/
 function isHook(node) {
 	const expr = Extract.unwrap(node);
 	if (expr.type === "Identifier") return isHookName(expr.name);
@@ -7480,27 +6307,15 @@ function isHook(node) {
 		return obj.type === "Identifier" && /^[A-Z].*/.test(obj.name);
 	} else return false;
 }
-/**
-* Checks if the node is a React component name. React component names must
-* always start with an uppercase letter.
-*/
 function isComponentName(node) {
 	return node.type === "Identifier" && /^[A-Z]/.test(node.name);
 }
 function isReactFunction(node, functionName) {
 	return "name" in node && node.name === functionName || node.type === "MemberExpression" && "name" in node.object && node.object.name === "React" && "name" in node.property && node.property.name === functionName;
 }
-/**
-* Checks if the node is a callback argument of forwardRef. This render function
-* should follow the rules of hooks.
-*/
 function isForwardRefCallback(node) {
 	return !!(node.parent && "callee" in node.parent && node.parent.callee && isReactFunction(node.parent.callee, "forwardRef"));
 }
-/**
-* Checks if the node is a callback argument of React.memo. This anonymous
-* functional component should follow the rules of hooks.
-*/
 function isMemoCallback(node) {
 	return !!(node.parent && "callee" in node.parent && node.parent.callee && isReactFunction(node.parent.callee, "memo"));
 }
@@ -7579,17 +6394,11 @@ const rule = {
 				}
 			}
 		}
-		/**
-		* SourceCode that also works down to ESLint 3.0.0
-		*/
 		const getSourceCode = typeof context.getSourceCode === "function" ? () => {
 			return context.getSourceCode();
 		} : () => {
 			return context.sourceCode;
 		};
-		/**
-		* SourceCode#getScope that also works down to ESLint 3.0.0
-		*/
 		const getScope = typeof context.getScope === "function" ? () => {
 			return context.getScope();
 		} : (node) => {
@@ -7609,27 +6418,6 @@ const rule = {
 				if (reactHooksMap?.size === 0) return;
 				else if (typeof reactHooksMap === "undefined") throw new Error("Unexpected undefined reactHooksMap");
 				const cyclic = /* @__PURE__ */ new Set();
-				/**
-				* Count the number of code paths from the start of the function to this
-				* segment. For example:
-				*
-				* ```js
-				* function MyComponent() {
-				*   if (condition) {
-				*     // Segment 1
-				*   } else {
-				*     // Segment 2
-				*   }
-				*   // Segment 3
-				* }
-				* ```
-				*
-				* Segments 1 and 2 have one path to the beginning of `MyComponent` and
-				* segment 3 has two paths to the beginning of `MyComponent` since we
-				* could have either taken the path of segment 1 or segment 2.
-				*
-				* Populates `cyclic` with cyclic segments.
-				*/
 				function countPathsFromStart(segment, pathHistory) {
 					const { cache } = countPathsFromStart;
 					let paths = cache.get(segment.id);
@@ -7652,27 +6440,6 @@ const rule = {
 					else cache.set(segment.id, paths);
 					return paths;
 				}
-				/**
-				* Count the number of code paths from this segment to the end of the
-				* function. For example:
-				*
-				* ```js
-				* function MyComponent() {
-				*   // Segment 1
-				*   if (condition) {
-				*     // Segment 2
-				*   } else {
-				*     // Segment 3
-				*   }
-				* }
-				* ```
-				*
-				* Segments 2 and 3 have one path to the end of `MyComponent` and
-				* segment 1 has two paths to the end of `MyComponent` since we could
-				* either take the path of segment 1 or segment 2.
-				*
-				* Populates `cyclic` with cyclic segments.
-				*/
 				function countPathsToEnd(segment, pathHistory) {
 					const { cache } = countPathsToEnd;
 					let paths = cache.get(segment.id);
@@ -7694,27 +6461,6 @@ const rule = {
 					cache.set(segment.id, paths);
 					return paths;
 				}
-				/**
-				* Gets the shortest path length to the start of a code path.
-				* For example:
-				*
-				* ```js
-				* function MyComponent() {
-				*   if (condition) {
-				*     // Segment 1
-				*   }
-				*   // Segment 2
-				* }
-				* ```
-				*
-				* There is only one path from segment 1 to the code path start. Its
-				* length is one so that is the shortest path.
-				*
-				* There are two paths from segment 2 to the code path start. One
-				* through segment 1 with a length of two and another directly to the
-				* start with a length of one. The shortest path has a length of one
-				* so we would return that.
-				*/
 				function shortestPathLengthToStart(segment) {
 					const { cache } = shortestPathLengthToStart;
 					let length = cache.get(segment.id);
@@ -7858,13 +6604,6 @@ const rule = {
 		};
 	}
 };
-/**
-* Gets the static name of a function AST node. For function declarations it is
-* easy. For anonymous function expressions it is much harder. If you search for
-* `IsAnonymousFunctionDefinition()` in the ECMAScript spec you'll find places
-* where JS gives anonymous function expressions names. We roughly detect the
-* same AST nodes with some exceptions to better fit our use case.
-*/
 function getFunctionName(node) {
 	if (node.type === "ComponentDeclaration" || node.type === "HookDeclaration" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" && node.id) return node.id;
 	else if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
@@ -7875,9 +6614,6 @@ function getFunctionName(node) {
 		else return;
 	} else return;
 }
-/**
-* Convenience function for peeking the last item in a stack.
-*/
 function last(array) {
 	return array[array.length - 1];
 }
@@ -7920,11 +6656,6 @@ const IDENTIFIER_VISITOR_KEYS = {
 	[AST_NODE_TYPES.UpdateExpression]: ["argument"],
 	[AST_NODE_TYPES.YieldExpression]: ["argument"]
 };
-/**
-* Get all nested identifiers in a expression like node
-* @param node The node to get the nested identifiers from
-* @returns All nested identifiers
-*/
 function getNestedIdentifiers(node) {
 	const identifiers = [];
 	simpleTraverse(node, {
@@ -7953,23 +6684,10 @@ function isTerminatingStatement(node) {
 	if (node.type === AST_NODE_TYPES.BlockStatement) return node.body.some(isTerminatingStatement);
 	return false;
 }
-/**
-* Get the display name of a setState call reference for reporting.
-* @param node The setState call node (CallExpression or Identifier)
-* @param getText The source text getter
-* @returns The fully qualified name of the call
-*/
 function getCallName(node, getText) {
 	if (node.type === AST_NODE_TYPES.CallExpression) return Extract.getFullyQualifiedName(node.callee, getText);
 	return Extract.getFullyQualifiedName(node, getText);
 }
-/**
-* Get the actual CallExpression node from a setState call reference.
-* When the node is an Identifier that is the callee of a CallExpression,
-* returns the parent CallExpression; otherwise returns the node itself.
-* @param node The setState call node (CallExpression or Identifier)
-* @returns The actual CallExpression node
-*/
 function getSetStateCallExpression(node) {
 	return Check.isIdentifier(node) && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node ? node.parent : node;
 }
@@ -8057,13 +6775,6 @@ function createFactCollector$3(additionalStateHooks, additionalEffectHooks) {
 
 //#endregion
 //#region src/rules/set-state-in-effect/origins.ts
-/**
-* Create a resolver that answers whether an identifier or call originates from
-* a `useState`-like hook's setter function (the element at index 1 of the
-* returned tuple).
-* @param context The rule context
-* @returns The setState provenance resolver
-*/
 function createSetStateResolver$1(context) {
 	const { additionalStateHooks } = getSettingsFromContext(context);
 	function isUseStateCall(node) {
@@ -8075,7 +6786,7 @@ function createSetStateResolver$1(context) {
 		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		if (!isUseStateCall(initNode)) return false;
 		const variableNodeParent = initNode.parent;
-		if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		if (!hasProperty(variableNodeParent, "id") || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
 		return variableNodeParent.id.elements.findIndex((e) => e != null && Check.isIdentifier(e, id.name)) === at;
 	}
 	function isSetStateCall(node) {
@@ -8084,7 +6795,7 @@ function createSetStateResolver$1(context) {
 			case AST_NODE_TYPES.CallExpression: {
 				const innerCallee = Extract.unwrap(callee.callee);
 				if (innerCallee.type !== AST_NODE_TYPES.MemberExpression) return false;
-				if (!("name" in innerCallee.object)) return false;
+				if (!hasProperty(innerCallee.object, "name")) return false;
 				const isAt = Extract.getCalleeName(callee) === "at";
 				const [index] = callee.arguments;
 				if (!isAt || index == null) return false;
@@ -8093,7 +6804,7 @@ function createSetStateResolver$1(context) {
 			}
 			case AST_NODE_TYPES.Identifier: return isSetStateId(callee, 1);
 			case AST_NODE_TYPES.MemberExpression: {
-				if (!("name" in callee.object)) return false;
+				if (!hasProperty(callee.object, "name")) return false;
 				const property = callee.property;
 				const propertyScope = context.sourceCode.getScope(node);
 				return getStaticValue(property, propertyScope)?.value === 1 && isSetStateId(callee.object, 1);
@@ -8141,12 +6852,6 @@ function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ *
 	}
 	return false;
 }
-/**
-* Check if the setState call is using a ref value, which is safe to use in an effect (ex: `setState(ref.current.scrollTop)`)
-* @param context The rule context
-* @param node The setState call argument to check
-* @returns `true` if the argument value is derived from a ref
-*/
 function isArgumentUsingRefValue(context, node) {
 	const isUsingRefValue = (n) => {
 		switch (n.type) {
@@ -8172,13 +6877,6 @@ function isArgumentUsingRefValue(context, node) {
 	if (isUsingRefValue(node)) return true;
 	return Check.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
 }
-/**
-* Check if a setState call is inside a conditional block whose test expression
-* is derived from a ref value (e.g. `if (prevRef.current !== value) setState(...)`).
-* @param context The ESLint rule context
-* @param node The AST node to check
-* @returns `true` if the node is inside a ref-gated conditional block
-*/
 function isRefGatedContext(context, node) {
 	let child = node;
 	let current = node.parent;
@@ -8206,11 +6904,6 @@ function isRefGatedContext(context, node) {
 function isRefInExpression(context, node) {
 	return getNestedIdentifiers(node).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id)));
 }
-/**
-* Get the name that identifies the source of a `.current` member access.
-* @param node The object of the member expression
-* @returns The identifier name, the last property name of a member chain, or null
-*/
 function getRefSourceName(node) {
 	switch (node.type) {
 		case AST_NODE_TYPES.Identifier: return node.name;
@@ -8224,15 +6917,6 @@ function getRefSourceName(node) {
 
 //#endregion
 //#region src/rules/set-state-in-effect/effects.ts
-/**
-* Infer the setState calls that run synchronously during an effect setup from
-* the collected facts: calls made directly in the setup body (or an IIFE within
-* it), and calls reached indirectly through local functions, hook callbacks, or
-* setup identifiers passed to the effect.
-* @param context The rule context
-* @param facts The collected facts
-* @returns The violations to report, in report order
-*/
 function inferViolations$2(context, facts) {
 	const { additionalEffectHooks } = getSettingsFromContext(context);
 	const resolver = createSetStateResolver$1(context);
@@ -8453,13 +7137,6 @@ function createFactCollector$2(additionalStateHooks) {
 
 //#endregion
 //#region src/rules/set-state-in-render/origins.ts
-/**
-* Create a resolver that answers whether an identifier or call originates from
-* a `useState`-like hook's setter function (the element at index 1 of the
-* returned tuple).
-* @param context The rule context
-* @returns The setState provenance resolver
-*/
 function createSetStateResolver(context) {
 	const { additionalStateHooks } = getSettingsFromContext(context);
 	function isUseStateCall(node) {
@@ -8471,7 +7148,7 @@ function createSetStateResolver(context) {
 		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		if (!isUseStateCall(initNode)) return false;
 		const variableNodeParent = initNode.parent;
-		if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		if (!hasProperty(variableNodeParent, "id") || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
 		return variableNodeParent.id.elements.findIndex((e) => e != null && Check.isIdentifier(e, id.name)) === at;
 	}
 	function isSetStateCall(node) {
@@ -8480,7 +7157,7 @@ function createSetStateResolver(context) {
 			case AST_NODE_TYPES.CallExpression: {
 				const innerCallee = Extract.unwrap(callee.callee);
 				if (innerCallee.type !== AST_NODE_TYPES.MemberExpression) return false;
-				if (!("name" in innerCallee.object)) return false;
+				if (!hasProperty(innerCallee.object, "name")) return false;
 				const isAt = Extract.getCalleeName(callee) === "at";
 				const [index] = callee.arguments;
 				if (!isAt || index == null) return false;
@@ -8489,7 +7166,7 @@ function createSetStateResolver(context) {
 			}
 			case AST_NODE_TYPES.Identifier: return isSetStateId(callee, 1);
 			case AST_NODE_TYPES.MemberExpression: {
-				if (!("name" in callee.object)) return false;
+				if (!hasProperty(callee.object, "name")) return false;
 				const property = callee.property;
 				const propertyScope = context.sourceCode.getScope(node);
 				return getStaticValue(property, propertyScope)?.value === 1 && isSetStateId(callee.object, 1);
@@ -8506,14 +7183,6 @@ function createSetStateResolver(context) {
 
 //#endregion
 //#region src/rules/set-state-in-render/effects.ts
-/**
-* Infer the setState calls that run unconditionally during render from the
-* collected facts: calls made directly in a component function body that are
-* neither guarded by a conditional nor positioned after an early return.
-* @param context The rule context
-* @param facts The collected facts
-* @returns The violations to report, in report order
-*/
 function inferViolations$1(context, facts) {
 	const resolver = createSetStateResolver(context);
 	const getText = (n) => context.sourceCode.getText(n);
@@ -8580,10 +7249,6 @@ function createFactCollector$1() {
 
 //#endregion
 //#region src/rules/static-components/helpers.ts
-/**
-* Expression kinds that always produce a brand-new value on every evaluation, and are
-* therefore considered "dynamically created" when used as a component's value.
-*/
 const KNOWN_DYNAMIC_EXPRESSION_TYPES = /* @__PURE__ */ new Set([
 	AST_NODE_TYPES.ArrowFunctionExpression,
 	AST_NODE_TYPES.CallExpression,
@@ -8591,10 +7256,6 @@ const KNOWN_DYNAMIC_EXPRESSION_TYPES = /* @__PURE__ */ new Set([
 	AST_NODE_TYPES.FunctionExpression,
 	AST_NODE_TYPES.NewExpression
 ]);
-/**
-* Builds a predicate that tells whether a given node lies within the body of one of the
-* collected function or class components, i.e. whether it is "created during render".
-*/
 function createRenderBoundaryChecker(componentNodes) {
 	const components = new Set(componentNodes);
 	return (node) => Traverse.findParent(node, (n) => (Check.isFunction(n) || Check.isClass(n)) && components.has(n)) != null;
@@ -8602,11 +7263,6 @@ function createRenderBoundaryChecker(componentNodes) {
 
 //#endregion
 //#region src/rules/static-components/origins.ts
-/**
-* Resolves an expression down to the node that dynamically created its value, if any.
-* Recurses through identifier references, both branches of ternaries and logical
-* expressions, and the final element of sequence expressions.
-*/
 function findDynamicCreationSite(context, node, isInsideRender, seen) {
 	const expr = Extract.unwrap(node);
 	if (KNOWN_DYNAMIC_EXPRESSION_TYPES.has(expr.type)) return expr;
@@ -8626,10 +7282,6 @@ function findDynamicCreationSite(context, node, isInsideRender, seen) {
 		default: return null;
 	}
 }
-/**
-* Looks for a reassignment of `variable` (e.g. `Component = createComponent();`) whose
-* right-hand side is dynamically created.
-*/
 function findReassignmentCreationSite(context, variable, isInsideRender, seen) {
 	for (const ref of variable.references) {
 		if (!ref.isWrite()) continue;
@@ -8640,10 +7292,6 @@ function findReassignmentCreationSite(context, variable, isInsideRender, seen) {
 	}
 	return null;
 }
-/**
-* Resolves a component binding to the node that dynamically created its value, if the
-* value is created during render (a fresh function/class/call result on every render).
-*/
 function resolveDynamicComponentOrigin(context, variable, isInsideRender, seen = /* @__PURE__ */ new Set()) {
 	if (seen.has(variable)) return {
 		creationNode: null,
@@ -8677,11 +7325,6 @@ function resolveDynamicComponentOrigin(context, variable, isInsideRender, seen =
 
 //#endregion
 //#region src/rules/static-components/effects.ts
-/**
-* Turn collected JSX component usages into effects: a usage is an effect when the
-* binding it refers to is declared inside a component's render body and its value is
-* dynamically created, i.e. the component is recreated on every render.
-*/
 function inferCreatedComponents(context, componentUsages, isInsideRender) {
 	const effects = [];
 	for (const usage of componentUsages) {
@@ -8822,22 +7465,11 @@ function create$2(context) {
 
 //#endregion
 //#region src/rules/use-memo/helpers.ts
-/**
-* Check whether the result of a `useMemo` call is used (assigned, returned,
-* passed as an argument, etc.) rather than discarded as a bare statement.
-* @param node The `useMemo` call expression
-* @returns `true` when the call result flows into a surrounding expression
-*/
 function isResultUsed(node) {
 	let parent = node.parent;
 	while (Check.isTypeExpression(parent)) parent = parent.parent;
 	return parent.type === AST_NODE_TYPES.VariableDeclarator || parent.type === AST_NODE_TYPES.AssignmentExpression || parent.type === AST_NODE_TYPES.AssignmentPattern || parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.ReturnStatement || parent.type === AST_NODE_TYPES.JSXExpressionContainer || parent.type === AST_NODE_TYPES.CallExpression || parent.type === AST_NODE_TYPES.NewExpression || parent.type === AST_NODE_TYPES.ArrayExpression || parent.type === AST_NODE_TYPES.ConditionalExpression || parent.type === AST_NODE_TYPES.LogicalExpression || parent.type === AST_NODE_TYPES.SequenceExpression || parent.type === AST_NODE_TYPES.SpreadElement || parent.type === AST_NODE_TYPES.TemplateLiteral || parent.type === AST_NODE_TYPES.BinaryExpression || parent.type === AST_NODE_TYPES.UnaryExpression || parent.type === AST_NODE_TYPES.MemberExpression || parent.type === AST_NODE_TYPES.TaggedTemplateExpression || parent.type === AST_NODE_TYPES.ChainExpression || parent.type === AST_NODE_TYPES.ArrowFunctionExpression || parent.type === AST_NODE_TYPES.ForOfStatement || parent.type === AST_NODE_TYPES.ForInStatement;
 }
-/**
-* Gets the nested return statements in the node that are within the same function
-* @param node The AST node
-* @returns The nested return statements in the node
-*/
 function getNestedReturnStatements(node) {
 	const statements = [];
 	const boundary = Check.isFunction(node) ? node : Traverse.findParent(node, Check.isFunction);
@@ -8906,15 +7538,6 @@ function isDeclaredInsideCallback(variable, callback) {
 	}
 	return false;
 }
-/**
-* Resolve whether an identifier written inside a `useMemo` callback refers to a
-* variable declared outside the callback. Unresolved identifiers and variables
-* without definitions are treated as outer variables.
-* @param context The rule context
-* @param target The written identifier
-* @param callback The `useMemo` callback the write occurs in
-* @returns `true` when the write reassigns an outer variable
-*/
 function isOuterVariable(context, target, callback) {
 	const scope = context.sourceCode.getScope(target);
 	const variable = findVariable(scope, target);
@@ -8924,14 +7547,6 @@ function isOuterVariable(context, target, callback) {
 
 //#endregion
 //#region src/rules/use-memo/effects.ts
-/**
-* Infer the `useMemo` usage violations from the collected facts: unused
-* results, callbacks with parameters, async or generator callbacks, outer
-* variable reassignments, and callbacks that never return a value.
-* @param context The rule context
-* @param facts The collected facts
-* @returns The violations to report, in report order
-*/
 function inferViolations(context, facts) {
 	const violations = [];
 	for (const fact of facts.calls) {
@@ -9064,12 +7679,6 @@ const EXPRESSION_VISITOR_KEYS = {
 	[AST_NODE_TYPES.WhileStatement]: ["test"],
 	[AST_NODE_TYPES.YieldExpression]: ["argument"]
 };
-/**
-* Get all nested expressions of type T in an expression like node
-* @param type The type of the expression to retrieve within the node
-* @returns A partially applied function bound to a predicate of type AST. The returned function can be called passing a
-* node, and it will return an array of all nested expressions of type AST.
-*/
 function getNestedExpressionsOfType(type) {
 	const isNodeOfType = Check.is(type);
 	const recurse = (node) => {
@@ -9085,17 +7694,7 @@ function getNestedExpressionsOfType(type) {
 	};
 	return recurse;
 }
-/**
-* Get all nested new expressions in an expression like node
-* @param node The node to get the nested new expressions from
-* @returns All nested new expressions
-*/
 const getNestedNewExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.NewExpression);
-/**
-* Get all nested call expressions in a expression like node
-* @param node The node to get the nested call expressions from
-* @returns All nested call expressions
-*/
 const getNestedCallExpressions = getNestedExpressionsOfType(AST_NODE_TYPES.CallExpression);
 
 //#endregion
@@ -9148,7 +7747,7 @@ function create(context) {
 			const [useStateInput] = node.arguments;
 			if (useStateInput != null) {
 				for (const expr of getNestedNewExpressions(useStateInput)) {
-					if (!("name" in expr.callee)) continue;
+					if (!hasProperty(expr.callee, "name")) continue;
 					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
 					if (Traverse.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
 					context.report({
@@ -9157,7 +7756,7 @@ function create(context) {
 					});
 				}
 				for (const expr of getNestedCallExpressions(useStateInput)) {
-					if (!("name" in expr.callee)) continue;
+					if (!hasProperty(expr.callee, "name")) continue;
 					if (core.isHookName(expr.callee.name)) continue;
 					if (LAZY_INIT_ALLOW_LIST.includes(expr.callee.name)) continue;
 					if (Traverse.findParent(expr, (n) => core.isUseCall(context, n)) != null) continue;
@@ -9429,45 +8028,15 @@ function createConfig(base) {
 const finalPlugin = {
 	...plugin,
 	configs: {
-		/**
-		* Disable rules in `eslint-plugin-react` that conflict with rules in this plugin
-		*/
 		["disable-conflict-eslint-plugin-react"]: createConfig(disable_conflict_eslint_plugin_react_exports),
-		/**
-		* Disable rules in `eslint-plugin-react-hooks` that conflict with rules in this plugin
-		*/
 		["disable-conflict-eslint-plugin-react-hooks"]: createConfig(disable_conflict_eslint_plugin_react_hooks_exports),
-		/**
-		* Disable experimental rules that might be subject to change in the future
-		*/
 		["disable-experimental"]: createConfig(disable_experimental_exports),
-		/**
-		* Disable rules that can be enforced by TypeScript
-		*/
 		["disable-type-checked"]: createConfig(disable_type_checked_exports),
-		/**
-		* Enforce rules that are recommended by ESLint React for general purpose React + React DOM projects
-		*/
 		["recommended"]: createConfig(recommended_exports),
-		/**
-		* Same as the `recommended-typescript` preset but enables additional rules that require type information
-		*/
 		["recommended-type-checked"]: createConfig(recommended_type_checked_exports),
-		/**
-		* Same as the `recommended` preset but disables rules that can be enforced by TypeScript
-		*/
 		["recommended-typescript"]: createConfig(recommended_typescript_exports),
-		/**
-		* More strict version of the `recommended` preset
-		*/
 		["strict"]: createConfig(strict_exports),
-		/**
-		* Same as the `strict-typescript` preset but enables additional rules that require type information
-		*/
 		["strict-type-checked"]: createConfig(strict_type_checked_exports),
-		/**
-		* Same as the `strict` preset but disables rules that can be enforced by TypeScript
-		*/
 		["strict-typescript"]: createConfig(strict_typescript_exports)
 	}
 };