eslint-plugin-react-jsx 5.24.1 → 5.24.3

package/dist/index.js

@@ -26,7 +26,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$2 = "eslint-plugin-react-jsx";
-var version = "5.24.1";
+var version = "5.24.3";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -37,13 +37,6 @@ const createRule = ESLintUtils.RuleCreator(getDocsUrl);
 
 //#endregion
 //#region src/utils/remove-jsx-attribute.ts
-/**
-* Builds a fix that removes a JSX attribute along with the whitespace before it.
-* @param context The rule context
-* @param fixer The rule fixer
-* @param attribute The `JSXAttribute` node to remove
-* @returns A fix that removes the attribute and its preceding whitespace
-*/
 function removeJsxAttribute(context, fixer, attribute) {
 	let start = attribute.range[0];
 	while (start > 0 && /\s/.test(context.sourceCode.text[start - 1] ?? "")) start--;
@@ -171,12 +164,6 @@ function create$6(context) {
 		}
 	};
 }
-/**
-* Turns the value of a 'children' JSXAttribute into text usable as element content
-* @param context The rule context
-* @param attribute The 'children' JSXAttribute node
-* @returns The text to insert as element content, or `null` when no usable value exists
-*/
 function getChildrenText(context, attribute) {
 	const { value } = attribute;
 	if (value?.type === AST_NODE_TYPES.Literal) return escapeJsxText(String(value.value));
@@ -186,22 +173,9 @@ function getChildrenText(context, attribute) {
 	}
 	return null;
 }
-/**
-* Escapes characters that would be parsed as markup in JSX text
-* @param text The raw string value
-* @returns The escaped text safe for insertion as JSX content
-*/
 function escapeJsxText(text) {
 	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("{", "&#123;").replaceAll("}", "&#125;");
 }
-/**
-* Builds the fix that moves the 'children' prop value into the element's content
-* @param context The rule context object
-* @param node The JSXElement node being reported
-* @param prop The 'children' JSXAttribute to remove
-* @param childrenText The text to insert as element content
-* @returns A fixer function that applies the changes
-*/
 function buildFix$1(context, node, prop, childrenText) {
 	return (fixer) => {
 		const sourceCode = context.sourceCode;
@@ -246,44 +220,6 @@ function create$5(context) {
 
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
-/**
-* Applies a `pipe` method's variadic arguments to an initial value from left
-* to right.
-*
-* **When to use**
-*
-* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
-* object.
-*
-* **Details**
-*
-* This helper is intended for implementing `Pipeable.pipe` methods that
-* receive JavaScript's `arguments` object. With no functions it returns the
-* original value; otherwise it feeds each result into the next function.
-*
-* **Example** (Implementing a pipe method)
-*
-* ```ts
-* import { Pipeable } from "effect"
-*
-* class NumberBox {
-*   constructor(readonly value: number) {}
-*
-*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
-*     return Pipeable.pipeArguments(this.value, arguments) as number
-*   }
-* }
-*
-* const result = new NumberBox(5).pipe(
-*   (n) => n + 2,
-*   (n) => n * 3
-* )
-* result // => 21
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const pipeArguments = (self, args) => {
 	switch (args.length) {
 		case 0: return self;
@@ -303,100 +239,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;
 })();
-/**
-* Creates a function that can be called in data-first style or data-last
-* (`pipe`-friendly) style.
-*
-* **When to use**
-*
-* Use to expose one implementation through both direct and `pipe`-friendly
-* call styles.
-*
-* **Details**
-*
-* Pass either the arity of the uncurried function or a predicate that decides
-* whether the current call is data-first. Arity is the common case. Use a
-* predicate when optional arguments make arity ambiguous.
-*
-* **Example** (Selecting data-first or data-last style by arity)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* sum(2, 3) // => 5
-* pipe(2, sum(3)) // => 5
-* ```
-*
-* **Example** (Defining overloads with call signatures)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = Function.dual(2, (self: number, that: number): number => self + that)
-*
-* sum(2, 3) // => 5
-* pipe(2, sum(3)) // => 5
-* ```
-*
-* **Example** (Selecting data-first or data-last style with a predicate)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* sum(2, 3) // => 5
-* pipe(2, sum(3)) // => 5
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const dual = function(arity, body) {
 	if (typeof arity === "function") return function() {
 		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
@@ -425,558 +275,35 @@ 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"
-*
-* identity(5) // => 5
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const identity = (a) => a;
-/**
-* Returns the input value with a different static type.
-*
-* **When to use**
-*
-* Use when you need an explicit type-level cast and accept that the value is
-* returned unchanged at runtime.
-*
-* **Gotchas**
-*
-* This is a type-level cast only; it performs no runtime validation or
-* conversion.
-*
-* @see {@link satisfies} for checking assignability without changing the resulting type
-*
-* @category utility types
-* @since 4.0.0
-*/
 const cast = identity;
-/**
-* Creates a zero-argument function that always returns the provided value.
-*
-* **When to use**
-*
-* Use when you need a thunk or callback that returns the same value on every
-* invocation.
-*
-* **Example** (Creating a constant thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* const constNull = Function.constant(null)
-*
-* constNull() // => null
-* constNull() // => null
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
 const constant = (value) => () => value;
-/**
-* Returns `true` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `true` on every invocation.
-*
-* **Example** (Returning true from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constTrue() // => true
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constTrue = constant(true);
-/**
-* Returns `false` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `false` on every invocation.
-*
-* **Example** (Returning false from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constFalse() // => false
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constFalse = constant(false);
-/**
-* Returns `null` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `null` on every invocation.
-*
-* **Example** (Returning null from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constNull() // => null
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constNull = constant(null);
-/**
-* Returns `undefined` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `undefined` on every invocation.
-*
-* **Example** (Returning undefined from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* Function.constUndefined() // => undefined
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constUndefined = constant(void 0);
-/**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
-*
-* **When to use**
-*
-* Use to compose exactly two unary functions into a reusable unary function.
-*
-* **Example** (Composing two functions)
-*
-* ```ts
-* import { Function } from "effect"
-*
-* const increment = (n: number) => n + 1
-* const square = (n: number) => n * n
-*
-* Function.compose(increment, square)(2) // => 9
-* ```
-*
-* @see {@link flow} for composing a left-to-right sequence of functions
-* @see {@link pipe} for applying a value through a left-to-right sequence immediately
-*
-* @category combinators
-* @since 2.0.0
-*/
 const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-/**
-* Marks an impossible branch by accepting a `never` value and returning any
-* type.
-*
-* **When to use**
-*
-* Use when you need a return value in a branch that exhaustive checks prove
-* cannot be reached.
-*
-* **Gotchas**
-*
-* Calling `absurd` throws, because a value of type `never` should be
-* impossible at runtime.
-*
-* **Example** (Handling impossible values)
-*
-* ```ts
-* import { absurd } from "effect"
-*
-* const handleNever = (value: never) => {
-*   return absurd(value) // This will throw an error if called
-* }
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const absurd = (_) => {
 	throw new Error("Called `absurd` function which should be uncallable");
 };
-/**
-* Creates a compile-time placeholder for a value of any type.
-*
-* **When to use**
-*
-* Use as a temporary typed placeholder while developing incomplete code.
-*
-* **Gotchas**
-*
-* `hole` is intended for temporary development use. If the placeholder is
-* evaluated at runtime, it throws.
-*
-* **Example** (Creating a development placeholder)
-*
-* ```ts
-* import { hole } from "effect"
-*
-* // Intentionally not called: `hole` throws if the placeholder is evaluated.
-* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
-*   id,
-*   name: hole<string>()
-* })
-*
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const hole = cast(absurd);
 function not(predicate) {
 	return (data) => !predicate(data);
 }
-/**
-* Creates a predicate that returns `true` only if both predicates are `true`.
-*
-* **When to use**
-*
-* Use when you want to combine `Predicate`s with AND, accepting values that
-* satisfy multiple conditions, including refinements that narrow to an
-* intersection.
-*
-* **Details**
-*
-* Evaluation short-circuits on the first `false`. For refinements, the output
-* type is an intersection.
-*
-* **Example** (Checking both conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const hasAAndB = Predicate.and(
-*   Predicate.hasProperty("a"),
-*   Predicate.hasProperty("b")
-* )
-*
-* const input: unknown = JSON.parse(`{"a":1,"b":"ok"}`)
-* if (hasAAndB(input)) {
-*   // input has both properties at this point
-*   const a = input.a
-*   const b = input.b
-*
-*   const values = [a, b] // => [1, "ok"]
-* }
-* ```
-*
-* @see {@link or}
-* @see {@link not}
-* @category combinators
-* @since 2.0.0
-*/
 const and = dual(2, (a, b) => (data) => a(data) && b(data));
-/**
-* Creates a predicate that returns `true` if either predicate is `true`.
-*
-* **When to use**
-*
-* Use when you want to combine `Predicate`s with OR, accepting values that
-* satisfy at least one condition, including refinements that narrow to a union.
-*
-* **Details**
-*
-* Evaluation short-circuits on the first `true`. For refinements, the output
-* type is a union.
-*
-* **Example** (Checking either condition)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
-*
-* isStringOrNumber("a") // => true
-* ```
-*
-* @see {@link and}
-* @see {@link xor}
-* @category combinators
-* @since 2.0.0
-*/
 const or = dual(2, (a, b) => (data) => a(data) || b(data));
-/**
-* Creates a predicate that returns `true` if exactly one predicate is `true`.
-*
-* **When to use**
-*
-* Use when you want to combine two `Predicate`s with exclusive-or semantics.
-*
-* **Details**
-*
-* Returns `true` when results differ.
-*
-* **Example** (Checking exclusive-or conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isEven = (n: number) => n % 2 === 0
-* const isPositive = (n: number) => n > 0
-* const either = Predicate.xor(isEven, isPositive)
-*
-* either(-2) // => true
-* ```
-*
-* @see {@link or}
-* @see {@link and}
-* @category combinators
-* @since 2.0.0
-*/
 const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
-/**
-* Creates a predicate that returns `true` when both predicates agree.
-*
-* **When to use**
-*
-* Use when you want to check equivalence of two `Predicate`s.
-*
-* **Details**
-*
-* Returns `true` when both results are equal.
-*
-* **Example** (Defining equivalence)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isEven = (n: number) => n % 2 === 0
-* const same = Predicate.eqv(isEven, isEven)
-*
-* same(3) // => true
-* ```
-*
-* @see {@link xor}
-* @category combinators
-* @since 2.0.0
-*/
 const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
-/**
-* Creates a predicate representing logical implication: if `antecedent`, then `consequent`.
-*
-* **When to use**
-*
-* Use when you need to encode logical implication between `Predicate` rules,
-* where one rule only applies when a precondition holds.
-*
-* **Details**
-*
-* Models constraints like "if A then B" and returns `true` when the antecedent
-* is `false`.
-*
-* **Example** (Checking implication)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isAdult = (age: number) => age >= 18
-* const canVote = (age: number) => age >= 18
-* const implies = Predicate.implies(isAdult, canVote)
-*
-* implies(16) // => true
-* ```
-*
-* @see {@link and}
-* @see {@link or}
-* @category combinators
-* @since 2.0.0
-*/
 const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
-/**
-* Creates a predicate that returns `true` when neither predicate is `true`.
-*
-* **When to use**
-*
-* Use when you want to combine two `Predicate`s with logical NOR semantics.
-*
-* **Details**
-*
-* Returns the negation of `or`.
-*
-* **Example** (Checking NOR conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
-*
-* neither(true) // => true
-* ```
-*
-* @see {@link or}
-* @see {@link not}
-* @category combinators
-* @since 2.0.0
-*/
 const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
-/**
-* Creates a predicate that returns `true` unless both predicates are `true`.
-*
-* **When to use**
-*
-* Use when you want to combine two `Predicate`s with logical NAND semantics.
-*
-* **Details**
-*
-* Returns the negation of `and`.
-*
-* **Example** (Checking NAND conditions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
-*
-* notBoth("a") // => true
-* ```
-*
-* @see {@link and}
-* @see {@link not}
-* @category combinators
-* @since 2.0.0
-*/
 const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
-/**
-* Checks whether a value is a `function`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* callable function.
-*
-* **Details**
-*
-* Uses `typeof input === "function"`.
-*
-* **Example** (Guarding functions)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = () => 1
-*
-* if (Predicate.isFunction(data)) {
-*   data() // => 1
-* }
-* ```
-*
-* @see {@link isObjectKeyword}
-* @category guards
-* @since 2.0.0
-*/
 function isFunction(input) {
 	return typeof input === "function";
 }
-/**
-* Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard that accepts arrays and functions as
-* well as objects.
-*
-* **Details**
-*
-* Returns `true` for arrays and functions, and `false` for `null`.
-*
-* **Example** (Checking object keywords)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* Predicate.isObjectKeyword(() => 1) // => true
-* Predicate.isObjectKeyword(null) // => false
-* ```
-*
-* @see {@link isObject}
-* @see {@link isObjectOrArray}
-* @category guards
-* @since 4.0.0
-*/
 function isObjectKeyword(input) {
 	return typeof input === "object" && input !== null || isFunction(input);
 }
-/**
-* Checks whether a value has a given property key.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for property access on `unknown`
-* values with a simple structural object check.
-*
-* **Details**
-*
-* Uses the `in` operator and `isObjectKeyword`. This does not check property
-* value types.
-*
-* **Example** (Guarding object properties)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const hasName = Predicate.hasProperty("name")
-* const data: unknown = { name: "Ada" }
-*
-* if (hasName(data)) {
-*   data.name // => "Ada"
-* }
-* ```
-*
-* @see {@link isTagged}
-* @see {@link isObjectKeyword}
-* @category guards
-* @since 2.0.0
-*/
 const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
-/**
-* Drops elements from the start while the predicate holds, returning the rest.
-*
-* **When to use**
-*
-* Use to remove a leading prefix of elements that satisfy a predicate.
-*
-* **Details**
-*
-* The predicate receives `(element, index)`.
-*
-* **Example** (Dropping while condition holds)
-*
-* ```ts
-* import { Array } from "effect"
-*
-* Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4) // => [4, 5]
-* ```
-*
-* @see {@link takeWhile} — keep the matching prefix instead
-* @see {@link drop} — drop a fixed count
-*
-* @category getters
-* @since 2.0.0
-*/
 const dropWhile = dual(2, (self, predicate) => {
 	const input = Array.isArray(self) ? self : Array.from(self);
 	const len = input.length;
@@ -984,35 +311,6 @@ const dropWhile = dual(2, (self, predicate) => {
 	while (idx < len && predicate(input[idx], idx)) idx++;
 	return input.slice(idx);
 });
-/**
-* Takes elements from the start while the predicate holds, stopping at the
-* first element that fails.
-*
-* **When to use**
-*
-* Use to keep the leading elements of an iterable while each element satisfies
-* a predicate, returning the retained prefix as an array.
-*
-* **Details**
-*
-* Supports refinements for type narrowing. The predicate receives
-* `(element, index)`.
-*
-* **Example** (Taking while condition holds)
-*
-* ```ts
-* import { Array } from "effect"
-*
-* Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
-* ```
-*
-* @see {@link take} for keeping a fixed number of leading elements
-* @see {@link dropWhile} for removing the matching prefix and keeping the rest
-* @see {@link span} for splitting the matching prefix from the remaining elements
-*
-* @category getters
-* @since 2.0.0
-*/
 const takeWhile = dual(2, (self, predicate) => {
 	const input = Array.isArray(self) ? self : Array.from(self);
 	const len = input.length;
@@ -1097,11 +395,6 @@ function create$3(context) {
 		JSXFragment: visit
 	};
 }
-/**
-* Whether a JSX child carries no renderable content: padding whitespace, an
-* empty expression (ex: `{}` or a comment), or an empty string expression.
-* @param child The JSX child node to check.
-*/
 const isWhitespaceOrEmptyStringExpression = or(isWhitespaceText, isEmptyStringExpression);
 function isNonSubstantiveChild(child) {
 	if (isWhitespaceOrEmptyStringExpression(child)) return true;
@@ -1220,16 +513,6 @@ function create(context, [option]) {
 		}
 	};
 }
-/**
-* Inspect a fragment node and report if it is useless.
-*
-* A fragment may be reported for **two independent reasons** on the same
-* node (e.g. `<p><>foo</></p>` is both "placed inside a host component"
-* and "contains less than two children").
-* @param context The rule context.
-* @param node The fragment node to inspect.
-* @param options The resolved rule options.
-*/
 function visitFragment(context, node, options) {
 	const reasons = [];
 	if (isHostElement(node.parent)) reasons.push("placed inside a host component");
@@ -1243,12 +526,6 @@ function visitFragment(context, node, options) {
 		node
 	});
 }
-/**
-* Whether the fragment has too few meaningful children to justify its
-* existence (the "contains less than two children" reason).
-* @param node The fragment node to check.
-* @param options The resolved rule options.
-*/
 function isContentUseless(node, options) {
 	const { allowEmptyFragment, allowExpressions } = options;
 	if (node.children.length === 0) return !allowEmptyFragment;
@@ -1260,10 +537,6 @@ function isContentUseless(node, options) {
 	if (meaningful[0]?.type === AST_NODE_TYPES.JSXExpressionContainer) return !allowExpressions;
 	return true;
 }
-/**
-* Whether it is safe to auto-fix the fragment by unwrapping it.
-* @param node The fragment node to check.
-*/
 function isSafeToFix(node) {
 	if (node.type === AST_NODE_TYPES.JSXElement && node.openingElement.attributes.some((attr) => attr.type === AST_NODE_TYPES.JSXSpreadAttribute)) return false;
 	if (Check.isJSXElementOrFragment(node.parent)) return isHostElement(node.parent);
@@ -1273,12 +546,6 @@ function isSafeToFix(node) {
 		return child.type === AST_NODE_TYPES.JSXText && isWhitespaceText(child);
 	});
 }
-/**
-* Build an autofix that unwraps the fragment, replacing it with its
-* meaningful children content.  Returns `null` when the fix is unsafe.
-* @param context The rule context.
-* @param node The fragment node to fix.
-*/
 function buildFix(context, node) {
 	if (!isSafeToFix(node)) return null;
 	return (fixer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-jsx",
-  "version": "5.24.1",
+  "version": "5.24.3",
   "description": "ESLint React's ESLint plugin for React Flavored JSX rules.",
   "keywords": [
     "react",
@@ -37,11 +37,11 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.24.1",
-    "@eslint-react/core": "5.24.1",
-    "@eslint-react/eslint": "5.24.1",
-    "@eslint-react/jsx": "5.24.1",
-    "@eslint-react/shared": "5.24.1",
+    "@eslint-react/ast": "5.24.3",
+    "@eslint-react/core": "5.24.3",
+    "@eslint-react/eslint": "5.24.3",
+    "@eslint-react/jsx": "5.24.3",
+    "@eslint-react/shared": "5.24.3",
     "@typescript-eslint/types": "^8.71.0",
     "@typescript-eslint/utils": "^8.71.0"
   },