eslint-plugin-react-dom 5.24.0 → 5.24.2

package/dist/index.js

@@ -26,7 +26,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$2 = "eslint-plugin-react-dom";
-var version = "5.24.0";
+var version = "5.24.2";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -214,54 +214,6 @@ function buildFix$2(context, node) {
 
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
-/**
-* 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;
@@ -281,110 +233,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));
@@ -413,314 +269,55 @@ 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");
 };
-/**
-* Creates a compile-time placeholder for a value of any type.
-*
-* **When to use**
-*
-* Use as a temporary typed placeholder while developing incomplete code.
-*
-* **Gotchas**
-*
-* `hole` is intended for temporary development use. If the placeholder is
-* evaluated at runtime, it throws.
-*
-* **Example** (Creating a development placeholder)
-*
-* ```ts
-* import { hole } from "effect"
-*
-* // Intentionally not called: `hole` throws if the placeholder is evaluated.
-* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
-*   id,
-*   name: hole<string>()
-* })
-*
-* console.log(typeof buildUser) // "function"
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const hole = cast(absurd);
-/**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
-* ```
-* @category array
-*/
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+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);
+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
 //#region src/utils/create-jsx-element-resolver.ts
-/**
-* Creates a resolver for JSX elements that determines the underlying DOM element type.
-*
-* This resolver handles:
-* 1. Regular HTML elements (div, span, etc.)
-* 2. Polymorphic components (components that render as a different element via a prop,
-*    ex: `<Box as="a">`). Only static string values of the polymorphic prop are
-*    supported; `<Box as={Component}>` cannot be resolved statically and falls back
-*    to the JSX element's own name.
-*
-* @param context The ESLint rule context
-* @returns An object with a resolve method to determine the element type
-*/
 function createJsxElementResolver(context) {
 	const { polymorphicPropName } = getSettingsFromContext(context);
-	return { 
-	/**
-	* Resolves the JSX element to determine its type and the underlying DOM element type
-	*
-	* @param node The JSX element node to resolve
-	* @returns An object containing the JSX element type and DOM element type
-	*/
-resolve(node) {
+	return { resolve(node) {
 		const elementName = getElementFullType(node);
 		const result = {
 			domElementType: elementName,
@@ -994,9 +591,6 @@ function create$5(context) {
 
 //#endregion
 //#region src/rules/no-unknown-property/lib.ts
-/**
-* Map of standard HTML attributes to their React counterparts
-*/
 const DOM_ATTRIBUTE_NAMES = {
 	"accept-charset": "acceptCharset",
 	class: "className",
@@ -1005,9 +599,6 @@ const DOM_ATTRIBUTE_NAMES = {
 	"http-equiv": "httpEquiv",
 	nomodule: "noModule"
 };
-/**
-* Map of SVG attributes to their React camelCase equivalents
-*/
 const SVGDOM_ATTRIBUTE_NAMES = {
 	"accent-height": "accentHeight",
 	"alignment-baseline": "alignmentBaseline",
@@ -1092,9 +683,6 @@ const SVGDOM_ATTRIBUTE_NAMES = {
 	"xml:lang": "xmlLang",
 	"xml:space": "xmlSpace"
 };
-/**
-* Map of attributes that are only valid on specific HTML tags
-*/
 const ATTRIBUTE_TAGS_MAP = {
 	abbr: ["th", "td"],
 	align: [
@@ -1240,9 +828,6 @@ const ATTRIBUTE_TAGS_MAP = {
 	webkitAllowFullScreen: ["iframe", "video"],
 	webkitDirectory: ["input"]
 };
-/**
-* Single-word HTML/DOM properties
-*/
 const DOM_PROPERTY_NAMES_ONE_WORD = [
 	"dir",
 	"draggable",
@@ -1435,9 +1020,6 @@ const DOM_PROPERTY_NAMES_ONE_WORD = [
 	"security",
 	"controls"
 ];
-/**
-* Multi-word (camelCase) HTML/DOM properties
-*/
 const DOM_PROPERTY_NAMES_TWO_WORDS = [
 	"accessKey",
 	"autoCapitalize",
@@ -1801,9 +1383,6 @@ const DOM_PROPERTY_NAMES_TWO_WORDS = [
 	"disablePictureInPicture",
 	"disableRemotePlayback"
 ];
-/**
-* DOM properties that are exempt from case sensitivity checks
-*/
 const DOM_PROPERTIES_IGNORE_CASE = [
 	"charset",
 	"allowFullScreen",
@@ -1811,9 +1390,6 @@ const DOM_PROPERTIES_IGNORE_CASE = [
 	"mozAllowFullScreen",
 	"webkitDirectory"
 ];
-/**
-* List of ARIA attributes
-*/
 const ARIA_PROPERTIES = [
 	"aria-atomic",
 	"aria-braillelabel",
@@ -1869,9 +1445,6 @@ const ARIA_PROPERTIES = [
 	"aria-rowspan",
 	"aria-setsize"
 ];
-/**
-* React-specific pointer event handlers added in React 16.4
-*/
 const REACT_ON_PROPS = [
 	"onGotPointerCapture",
 	"onGotPointerCaptureCapture",
@@ -1895,9 +1468,6 @@ const REACT_ON_PROPS = [
 	"onPointerUp",
 	"onPointerUpCapture"
 ];
-/**
-* Popover API properties added in React 19
-*/
 const POPOVER_API_PROPS = [
 	"popover",
 	"popoverTarget",
@@ -1906,9 +1476,6 @@ const POPOVER_API_PROPS = [
 	"onBeforeToggle"
 ];
 const REACT_19_PROPS = [...POPOVER_API_PROPS];
-/**
-* Tag-specific attributes added in React 19
-*/
 const REACT_19_ATTRIBUTE_TAGS_MAP = {
 	blocking: [
 		"link",
@@ -1917,9 +1484,6 @@ const REACT_19_ATTRIBUTE_TAGS_MAP = {
 	],
 	precedence: ["link", "style"]
 };
-/**
-* DOM properties added in React 19.3
-*/
 const REACT_19_3_PROPS = [
 	"credentialless",
 	"maskType",
@@ -1928,30 +1492,12 @@ const REACT_19_3_PROPS = [
 	"onFullscreenError",
 	"onFullscreenErrorCapture"
 ];
-/**
-* Tag-specific attributes added in React 19.3
-*/
 const REACT_19_3_ATTRIBUTE_TAGS_MAP = { credentialless: ["iframe"] };
-/**
-* SVG attribute mappings added in React 19.3
-*/
 const REACT_19_3_SVGDOM_ATTRIBUTE_NAMES = { "mask-type": "maskType" };
-/**
-* Tests React version against a comparator
-* @param context ESLint context
-* @param comparator Comparison operator
-* @param version Version to compare against
-* @returns Comparison result
-*/
 function testReactVersion(context, comparator, version) {
 	const { version: localVersion } = getSettingsFromContext(context);
 	return compare(localVersion, version, comparator);
 }
-/**
-* Gets all valid DOM property names based on React version
-* @param context ESLint rule context
-* @returns Array of valid DOM property names
-*/
 function getDOMPropertyNames(context) {
 	const ALL_DOM_PROPERTY_NAMES = DOM_PROPERTY_NAMES_TWO_WORDS.concat(DOM_PROPERTY_NAMES_ONE_WORD);
 	if (testReactVersion(context, "<=", "16.1.0")) {
@@ -1964,11 +1510,6 @@ function getDOMPropertyNames(context) {
 	if (testReactVersion(context, ">=", "19.3.0")) ALL_DOM_PROPERTY_NAMES.push(...REACT_19_3_PROPS);
 	return ALL_DOM_PROPERTY_NAMES;
 }
-/**
-* Gets the map of attributes to their allowed tags based on React version
-* @param context ESLint rule context
-* @returns Map of attributes to allowed tags
-*/
 function getAttributeTagsMap(context) {
 	let attributeTagsMap = ATTRIBUTE_TAGS_MAP;
 	if (testReactVersion(context, ">=", "19.0.0-rc.0")) attributeTagsMap = {
@@ -1981,80 +1522,32 @@ function getAttributeTagsMap(context) {
 	};
 	return attributeTagsMap;
 }
-/**
-* Check if a node's parent is a JSX tag that is written with lowercase letters,
-* and is not a custom web component.
-* @param childNode JSX element being tested
-* @returns Whether the node is a valid HTML tag in JSX
-*/
 function isValidHTMLTagInJSX(childNode) {
 	if (childNode.parent.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z][^-]*$/.test(childNode.parent.name.name)) return !childNode.parent.attributes.some((attrNode) => attrNode.type === AST_NODE_TYPES.JSXAttribute && attrNode.name.type === AST_NODE_TYPES.JSXIdentifier && attrNode.name.name === "is");
 	return false;
 }
-/**
-* Normalizes attribute names that should be case-insensitive
-* @param name Attribute name to normalize
-* @returns Normalized attribute name
-*/
 function normalizeAttributeCase(name) {
 	return DOM_PROPERTIES_IGNORE_CASE.find((element) => element.toLowerCase() === name.toLowerCase()) ?? name;
 }
-/**
-* Check if an attribute name is a valid data-* attribute
-* @param name Attribute name to test
-* @returns Whether the attribute is a valid data attribute
-*/
 function isValidDataAttribute(name) {
 	return !/^data-xml/i.test(name) && /^data-[^:]*$/.test(name);
 }
-/**
-* Check if an attribute name has uppercase characters
-* @param name Attribute name to test
-* @returns Whether the name has uppercase characters
-*/
 function hasUpperCaseCharacter(name) {
 	return name.toLowerCase() !== name;
 }
-/**
-* Check if an attribute is a valid ARIA attribute
-* @param name Attribute name to test
-* @returns Whether the attribute is a valid ARIA attribute
-*/
 function isValidAriaAttribute(name) {
 	return ARIA_PROPERTIES.some((element) => element === name);
 }
-/**
-* Gets the tag name for a JSXAttribute
-* @param node JSXAttribute to get tag name from
-* @returns Tag name or null
-*/
 function getTagName(node) {
 	if (node.parent.name.type === AST_NODE_TYPES.JSXIdentifier) return node.parent.name.name;
 	return null;
 }
-/**
-* Check if the tag name has a dot (member expression)
-* @param node JSXAttribute to check
-* @returns Whether the tag name has a dot
-*/
 function tagNameHasDot(node) {
 	return node.parent.name.type === AST_NODE_TYPES.JSXMemberExpression;
 }
-/**
-* Check if an object has a property
-* @param obj Object to check
-* @param key Key to check for
-* @returns Whether the object has the property
-*/
 function has(obj, key) {
 	return Object.hasOwn(obj, key);
 }
-/**
-* Gets the standard name of an attribute
-* @param name Attribute name
-* @param context ESLint context
-* @returns Standard name or undefined
-*/
 function getStandardName(name, context) {
 	if (has(DOM_ATTRIBUTE_NAMES, name)) return DOM_ATTRIBUTE_NAMES[name] ?? null;
 	const svgAttributeNames = testReactVersion(context, ">=", "19.3.0") ? {
@@ -2064,12 +1557,6 @@ function getStandardName(name, context) {
 	if (has(svgAttributeNames, name)) return svgAttributeNames[name] ?? null;
 	return getDOMPropertyNames(context).find((element) => element.toLowerCase() === name.toLowerCase()) ?? null;
 }
-/**
-* Gets text of a node
-* @param context ESLint context
-* @param node Node to get text from
-* @returns Node's text
-*/
 function getText(context, node) {
 	return context.sourceCode.getText(node);
 }
@@ -2213,22 +1700,10 @@ function create$3(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-target-blank/lib.ts
-/**
-* Check if a value appears to be an external link.
-* External links typically start with http(s):// or have protocol-relative format.
-* @param value The value to check
-* @returns Whether the value represents an external link
-*/
 function isExternalLinkLike(value) {
 	if (!isString(value)) return false;
 	return value.startsWith("https://") || /^(?:\w+:|\/\/)/u.test(value);
 }
-/**
-* Check if a rel prop value contains the necessary security attributes.
-* At minimum, it should contain "noreferrer".
-* @param value The rel prop value to check
-* @returns Whether the rel value is considered secure
-*/
 function isSafeRel(value) {
 	if (!isString(value)) return false;
 	return value === "noreferrer" || /\bnoreferrer\b/u.test(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-dom",
-  "version": "5.24.0",
+  "version": "5.24.2",
   "description": "ESLint React's ESLint plugin for DOM related rules.",
   "keywords": [
     "react",
@@ -37,11 +37,11 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.24.0",
-    "@eslint-react/eslint": "5.24.0",
-    "@eslint-react/jsx": "5.24.0",
-    "@eslint-react/shared": "5.24.0",
-    "@eslint-react/var": "5.24.0",
+    "@eslint-react/ast": "5.24.2",
+    "@eslint-react/eslint": "5.24.2",
+    "@eslint-react/jsx": "5.24.2",
+    "@eslint-react/shared": "5.24.2",
+    "@eslint-react/var": "5.24.2",
     "@typescript-eslint/types": "^8.71.0",
     "@typescript-eslint/utils": "^8.71.0",
     "compare-versions": "^6.1.1",
@@ -54,7 +54,7 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "dedent": "^1.7.2",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3"
   },