eslint-plugin-react-dom 2.0.0-beta.20 → 2.0.0-beta.200

package/dist/index.js

@@ -1,2071 +1,2084 @@
-import { getDocsUrl, getSettingsFromContext, DEFAULT_ESLINT_REACT_SETTINGS } from '@eslint-react/shared';
-import * as ER from '@eslint-react/core';
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { unit } from '@eslint-react/eff';
-import * as AST from '@eslint-react/ast';
-import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import { compare } from 'compare-versions';
-import { RegExp, Reporter } from '@eslint-react/kit';
+import { DEFAULT_ESLINT_REACT_SETTINGS, getConfigAdapters, getDocsUrl, getSettingsFromContext } from "@eslint-react/shared";
+import * as ER from "@eslint-react/core";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { compare } from "compare-versions";
+import { RE_JAVASCRIPT_PROTOCOL } from "@eslint-react/kit";
 
+//#region rolldown:runtime
 var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name3 in all)
-    __defProp(target, name3, { get: all[name3], enumerable: true });
+var __export = (all) => {
+	let target = {};
+	for (var name$2 in all) __defProp(target, name$2, {
+		get: all[name$2],
+		enumerable: true
+	});
+	return target;
 };
 
-// src/configs/recommended.ts
-var recommended_exports = {};
-__export(recommended_exports, {
-  name: () => name,
-  rules: () => rules,
-  settings: () => settings
+//#endregion
+//#region src/configs/recommended.ts
+var recommended_exports = /* @__PURE__ */ __export({
+	name: () => name$1,
+	rules: () => rules,
+	settings: () => settings
 });
-var name = "react-dom/recommended";
-var rules = {
-  "react-dom/no-dangerously-set-innerhtml": "warn",
-  "react-dom/no-dangerously-set-innerhtml-with-children": "error",
-  "react-dom/no-find-dom-node": "error",
-  "react-dom/no-flush-sync": "error",
-  "react-dom/no-hydrate": "error",
-  "react-dom/no-missing-button-type": "warn",
-  "react-dom/no-missing-iframe-sandbox": "warn",
-  "react-dom/no-namespace": "error",
-  "react-dom/no-render": "error",
-  "react-dom/no-render-return-value": "error",
-  "react-dom/no-script-url": "warn",
-  "react-dom/no-unsafe-iframe-sandbox": "warn",
-  "react-dom/no-unsafe-target-blank": "warn",
-  "react-dom/no-use-form-state": "error",
-  "react-dom/no-void-elements-with-children": "error"
-};
-var settings = {
-  "react-x": DEFAULT_ESLINT_REACT_SETTINGS
+const name$1 = "react-dom/recommended";
+const rules = {
+	"react-dom/no-dangerously-set-innerhtml": "warn",
+	"react-dom/no-dangerously-set-innerhtml-with-children": "error",
+	"react-dom/no-find-dom-node": "error",
+	"react-dom/no-flush-sync": "error",
+	"react-dom/no-hydrate": "error",
+	"react-dom/no-missing-button-type": "warn",
+	"react-dom/no-missing-iframe-sandbox": "warn",
+	"react-dom/no-namespace": "error",
+	"react-dom/no-render": "error",
+	"react-dom/no-render-return-value": "error",
+	"react-dom/no-script-url": "warn",
+	"react-dom/no-string-style-prop": "error",
+	"react-dom/no-unsafe-iframe-sandbox": "warn",
+	"react-dom/no-unsafe-target-blank": "warn",
+	"react-dom/no-use-form-state": "error",
+	"react-dom/no-void-elements-with-children": "error"
 };
+const settings = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
+
+//#endregion
+//#region package.json
+var name = "eslint-plugin-react-dom";
+var version = "2.0.0-beta.200";
 
-// package.json
-var name2 = "eslint-plugin-react-dom";
-var version = "2.0.0-beta.20";
+//#endregion
+//#region src/utils/create-jsx-element-resolver.ts
+/**
+* Creates a resolver for JSX elements that determines both the JSX element type
+* and the underlying DOM element type.
+*
+* This resolver handles:
+* 1. Regular HTML elements (div, span, etc.)
+* 2. Polymorphic components (components that can render as different elements via a prop)
+*
+* @param context - The ESLint rule context
+* @returns An object with a resolve method to determine element types
+*/
 function createJsxElementResolver(context) {
-  const { components, polymorphicPropName } = getSettingsFromContext(context);
-  return {
-    resolve(node) {
-      const name3 = ER.getElementType(context, node);
-      const component = components.findLast((c) => c.name === name3 || c.re.test(name3));
-      const result = {
-        attributes: component?.attributes ?? [],
-        domElementType: component?.as ?? name3,
-        jsxElementType: name3
-      };
-      if (name3 === name3.toLowerCase() || component != null || polymorphicPropName == null) {
-        return result;
-      }
-      const initialScope = context.sourceCode.getScope(node);
-      const polymorphicPropAttr = ER.getAttribute(
-        context,
-        polymorphicPropName,
-        node.openingElement.attributes,
-        initialScope
-      );
-      if (polymorphicPropAttr != null) {
-        const polymorphicPropValue = ER.getAttributeValue(
-          context,
-          polymorphicPropAttr,
-          polymorphicPropName
-        );
-        if (polymorphicPropValue.kind === "some" && typeof polymorphicPropValue.value === "string") {
-          return {
-            ...result,
-            domElementType: polymorphicPropValue.value
-          };
-        }
-      }
-      return result;
-    }
-  };
+	const { polymorphicPropName } = getSettingsFromContext(context);
+	return { resolve(node) {
+		const elementName = ER.getElementType(context, node);
+		const result = {
+			domElementType: elementName,
+			jsxElementType: elementName
+		};
+		if (elementName === elementName.toLowerCase() || polymorphicPropName == null) return result;
+		const polymorphicProp = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(polymorphicPropName);
+		if (polymorphicProp != null) {
+			const staticValue = ER.resolveAttributeValue(context, polymorphicProp).toStatic(polymorphicPropName);
+			if (typeof staticValue === "string") return {
+				...result,
+				domElementType: staticValue
+			};
+		}
+		return result;
+	} };
 }
-var createRule = ESLintUtils.RuleCreator(getDocsUrl("dom"));
 
-// src/utils/find-custom-component.ts
-function findCustomComponentProp(name3, props) {
-  return props.findLast((a) => a.as === name3);
-}
-function resolveAttribute(context, attributes, elementNode, attributeName) {
-  const customComponentProp = findCustomComponentProp(attributeName, attributes);
-  const propNameOnJsx = customComponentProp?.name ?? attributeName;
-  const attribute = ER.getAttribute(
-    context,
-    propNameOnJsx,
-    elementNode.openingElement.attributes,
-    context.sourceCode.getScope(elementNode)
-  );
-  if (attribute == null) {
-    return {
-      attribute: unit,
-      attributeName: propNameOnJsx,
-      attributeValue: unit,
-      attributeValueString: customComponentProp?.defaultValue
-    };
-  }
-  const attributeValue = ER.getAttributeValue(context, attribute, propNameOnJsx);
-  if (attributeValue.kind === "some" && typeof attributeValue.value === "string") {
-    return {
-      attribute,
-      attributeName: propNameOnJsx,
-      attributeValue,
-      attributeValueString: attributeValue.value
-    };
-  }
-  return {
-    attribute,
-    attributeName: propNameOnJsx,
-    attributeValue: unit,
-    attributeValueString: customComponentProp?.defaultValue ?? unit
-  };
-}
+//#endregion
+//#region src/utils/create-rule.ts
+const createRule = ESLintUtils.RuleCreator(getDocsUrl("dom"));
 
-// src/rules/no-dangerously-set-innerhtml.ts
-var RULE_NAME = "no-dangerously-set-innerhtml";
-var RULE_FEATURES = [];
+//#endregion
+//#region src/rules/no-dangerously-set-innerhtml.ts
+const RULE_NAME$16 = "no-dangerously-set-innerhtml";
+const RULE_FEATURES$15 = [];
 var no_dangerously_set_innerhtml_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `dangerouslySetInnerHTML`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES
-    },
-    messages: {
-      noDangerouslySetInnerhtml: "Using 'dangerouslySetInnerHTML' may have security implications."
-    },
-    schema: []
-  },
-  name: RULE_NAME,
-  create,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `dangerouslySetInnerHTML`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$15
+		},
+		messages: { noDangerouslySetInnerhtml: "Using 'dangerouslySetInnerHTML' may have security implications." },
+		schema: []
+	},
+	name: RULE_NAME$16,
+	create: create$16,
+	defaultOptions: []
 });
-var dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
-function create(context) {
-  if (!context.sourceCode.text.includes(dangerouslySetInnerHTML)) return {};
-  return {
-    JSXElement(node) {
-      const attribute = ER.getAttribute(
-        context,
-        dangerouslySetInnerHTML,
-        node.openingElement.attributes,
-        context.sourceCode.getScope(node)
-      );
-      if (attribute == null) return;
-      context.report({
-        messageId: "noDangerouslySetInnerhtml",
-        node: attribute
-      });
-    }
-  };
+const dangerouslySetInnerHTML$1 = "dangerouslySetInnerHTML";
+function create$16(context) {
+	if (!context.sourceCode.text.includes(dangerouslySetInnerHTML$1)) return {};
+	return { JSXElement(node) {
+		const attribute = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(dangerouslySetInnerHTML$1);
+		if (attribute == null) return;
+		context.report({
+			messageId: "noDangerouslySetInnerhtml",
+			node: attribute
+		});
+	} };
 }
-var RULE_NAME2 = "no-dangerously-set-innerhtml-with-children";
-var RULE_FEATURES2 = [];
+
+//#endregion
+//#region src/rules/no-dangerously-set-innerhtml-with-children.ts
+const RULE_NAME$15 = "no-dangerously-set-innerhtml-with-children";
+const RULE_FEATURES$14 = [];
 var no_dangerously_set_innerhtml_with_children_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `dangerouslySetInnerHTML` and `children` at the same time.",
-      [Symbol.for("rule_features")]: RULE_FEATURES2
-    },
-    messages: {
-      noDangerouslySetInnerhtmlWithChildren: "A DOM component cannot use both 'children' and 'dangerouslySetInnerHTML'."
-    },
-    schema: []
-  },
-  name: RULE_NAME2,
-  create: create2,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `dangerouslySetInnerHTML` and `children` at the same time.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$14
+		},
+		messages: { noDangerouslySetInnerhtmlWithChildren: "A DOM component cannot use both 'children' and 'dangerouslySetInnerHTML'." },
+		schema: []
+	},
+	name: RULE_NAME$15,
+	create: create$15,
+	defaultOptions: []
 });
-var dangerouslySetInnerHTML2 = "dangerouslySetInnerHTML";
-function create2(context) {
-  if (!context.sourceCode.text.includes(dangerouslySetInnerHTML2)) return {};
-  return {
-    JSXElement(node) {
-      const attributes = node.openingElement.attributes;
-      const initialScope = context.sourceCode.getScope(node);
-      const hasChildren = hasChildrenWithin(node) || ER.hasAttribute(context, "children", attributes, initialScope);
-      if (hasChildren && ER.hasAttribute(context, dangerouslySetInnerHTML2, attributes, initialScope)) {
-        context.report({
-          messageId: "noDangerouslySetInnerhtmlWithChildren",
-          node
-        });
-      }
-    }
-  };
+const dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
+function create$15(context) {
+	if (!context.sourceCode.text.includes(dangerouslySetInnerHTML)) return {};
+	return { JSXElement(node) {
+		const attributes = node.openingElement.attributes;
+		const initialScope = context.sourceCode.getScope(node);
+		if ((node.children.some(isSignificantChildren) || ER.hasAttribute(context, "children", attributes, initialScope)) && ER.hasAttribute(context, dangerouslySetInnerHTML, attributes, initialScope)) context.report({
+			messageId: "noDangerouslySetInnerhtmlWithChildren",
+			node
+		});
+	} };
+}
+/**
+* Check if a Literal or JSXText node is whitespace
+* @param node The AST node to check
+* @returns boolean `true` if the node is whitespace
+*/
+function isWhiteSpace(node) {
+	return typeof node.value === "string" && node.raw.trim() === "";
+}
+/**
+* Check if a Literal or JSXText node is padding spaces
+* @param node The AST node to check
+* @returns boolean
+*/
+function isPaddingSpaces(node) {
+	return ER.isJsxText(node) && isWhiteSpace(node) && node.raw.includes("\n");
 }
-function hasChildrenWithin(node) {
-  return node.children.length > 0 && node.children[0] != null && !AST.isLineBreak(node.children[0]);
+function isSignificantChildren(node) {
+	return node.type !== AST_NODE_TYPES.JSXText || !isPaddingSpaces(node);
 }
-var RULE_NAME3 = "no-find-dom-node";
-var RULE_FEATURES3 = [];
+
+//#endregion
+//#region src/rules/no-find-dom-node.ts
+const RULE_NAME$14 = "no-find-dom-node";
+const RULE_FEATURES$13 = [];
 var no_find_dom_node_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `findDOMNode`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES3
-    },
-    messages: {
-      noFindDomNode: "[Deprecated] Use alternatives instead."
-    },
-    schema: []
-  },
-  name: RULE_NAME3,
-  create: create3,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `findDOMNode`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$13
+		},
+		messages: { noFindDomNode: "[Deprecated] Use alternatives instead." },
+		schema: []
+	},
+	name: RULE_NAME$14,
+	create: create$14,
+	defaultOptions: []
 });
-var findDOMNode = "findDOMNode";
-function create3(context) {
-  if (!context.sourceCode.text.includes(findDOMNode)) return {};
-  return {
-    CallExpression(node) {
-      const { callee } = node;
-      switch (callee.type) {
-        case AST_NODE_TYPES.Identifier:
-          if (callee.name === findDOMNode) {
-            context.report({ messageId: "noFindDomNode", node });
-          }
-          return;
-        case AST_NODE_TYPES.MemberExpression:
-          if (callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === findDOMNode) {
-            context.report({ messageId: "noFindDomNode", node });
-          }
-          return;
-      }
-    }
-  };
+const findDOMNode = "findDOMNode";
+function create$14(context) {
+	if (!context.sourceCode.text.includes(findDOMNode)) return {};
+	return { CallExpression(node) {
+		const { callee } = node;
+		switch (callee.type) {
+			case AST_NODE_TYPES.Identifier:
+				if (callee.name === findDOMNode) context.report({
+					messageId: "noFindDomNode",
+					node
+				});
+				return;
+			case AST_NODE_TYPES.MemberExpression:
+				if (callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === findDOMNode) context.report({
+					messageId: "noFindDomNode",
+					node
+				});
+				return;
+		}
+	} };
 }
-var RULE_NAME4 = "no-flush-sync";
-var RULE_FEATURES4 = [];
+
+//#endregion
+//#region src/rules/no-flush-sync.ts
+const RULE_NAME$13 = "no-flush-sync";
+const RULE_FEATURES$12 = [];
 var no_flush_sync_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `flushSync`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES4
-    },
-    messages: {
-      noFlushSync: "Using 'flushSync' is uncommon and can hurt the performance of your app."
-    },
-    schema: []
-  },
-  name: RULE_NAME4,
-  create: create4,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `flushSync`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$12
+		},
+		messages: { noFlushSync: "Using 'flushSync' is uncommon and can hurt the performance of your app." },
+		schema: []
+	},
+	name: RULE_NAME$13,
+	create: create$13,
+	defaultOptions: []
 });
-var flushSync = "flushSync";
-function create4(context) {
-  if (!context.sourceCode.text.includes(flushSync)) return {};
-  return {
-    CallExpression(node) {
-      const { callee } = node;
-      switch (callee.type) {
-        case AST_NODE_TYPES.Identifier:
-          if (callee.name === flushSync) {
-            context.report({ messageId: "noFlushSync", node });
-          }
-          return;
-        case AST_NODE_TYPES.MemberExpression:
-          if (callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === flushSync) {
-            context.report({ messageId: "noFlushSync", node });
-          }
-          return;
-      }
-    }
-  };
+const flushSync = "flushSync";
+function create$13(context) {
+	if (!context.sourceCode.text.includes(flushSync)) return {};
+	return { CallExpression(node) {
+		const { callee } = node;
+		switch (callee.type) {
+			case AST_NODE_TYPES.Identifier:
+				if (callee.name === flushSync) context.report({
+					messageId: "noFlushSync",
+					node
+				});
+				return;
+			case AST_NODE_TYPES.MemberExpression:
+				if (callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === flushSync) context.report({
+					messageId: "noFlushSync",
+					node
+				});
+				return;
+		}
+	} };
 }
-var RULE_NAME5 = "no-hydrate";
-var RULE_FEATURES5 = [
-  "MOD"
-];
+
+//#endregion
+//#region src/rules/no-hydrate.ts
+const RULE_NAME$12 = "no-hydrate";
+const RULE_FEATURES$11 = ["MOD"];
 var no_hydrate_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Replaces usages of `ReactDom.hydrate()` with `hydrateRoot()`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES5
-    },
-    fixable: "code",
-    messages: {
-      noHydrate: "[Deprecated] Use 'hydrateRoot()' instead."
-    },
-    schema: []
-  },
-  name: RULE_NAME5,
-  create: create5,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Replaces usages of `ReactDom.hydrate()` with `hydrateRoot()`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$11
+		},
+		fixable: "code",
+		messages: { noHydrate: "[Deprecated] Use 'hydrateRoot()' instead." },
+		schema: []
+	},
+	name: RULE_NAME$12,
+	create: create$12,
+	defaultOptions: []
 });
-var hydrate = "hydrate";
-function create5(context) {
-  if (!context.sourceCode.text.includes(hydrate)) return {};
-  const settings2 = getSettingsFromContext(context);
-  if (compare(settings2.version, "18.0.0", "<")) return {};
-  const reactDomNames = /* @__PURE__ */ new Set();
-  const hydrateNames = /* @__PURE__ */ new Set();
-  return {
-    CallExpression(node) {
-      switch (true) {
-        case (node.callee.type === AST_NODE_TYPES.Identifier && hydrateNames.has(node.callee.name)):
-          context.report({
-            messageId: "noHydrate",
-            node,
-            fix: getFix(context, node)
-          });
-          return;
-        case (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === hydrate && reactDomNames.has(node.callee.object.name)):
-          context.report({
-            messageId: "noHydrate",
-            node,
-            fix: getFix(context, node)
-          });
-          return;
-      }
-    },
-    ImportDeclaration(node) {
-      const [baseSource] = node.source.value.split("/");
-      if (baseSource !== "react-dom") return;
-      for (const specifier of node.specifiers) {
-        switch (specifier.type) {
-          case AST_NODE_TYPES.ImportSpecifier:
-            if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
-            if (specifier.imported.name === hydrate) {
-              hydrateNames.add(specifier.local.name);
-            }
-            continue;
-          case AST_NODE_TYPES.ImportDefaultSpecifier:
-          case AST_NODE_TYPES.ImportNamespaceSpecifier:
-            reactDomNames.add(specifier.local.name);
-            continue;
-        }
-      }
-    }
-  };
+const hydrate = "hydrate";
+function create$12(context) {
+	if (!context.sourceCode.text.includes(hydrate)) return {};
+	const settings$1 = getSettingsFromContext(context);
+	if (compare(settings$1.version, "18.0.0", "<")) return {};
+	const reactDomNames = /* @__PURE__ */ new Set();
+	const hydrateNames = /* @__PURE__ */ new Set();
+	return {
+		CallExpression(node) {
+			switch (true) {
+				case node.callee.type === AST_NODE_TYPES.Identifier && hydrateNames.has(node.callee.name):
+					context.report({
+						messageId: "noHydrate",
+						node,
+						fix: getFix$2(context, node)
+					});
+					return;
+				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === hydrate && reactDomNames.has(node.callee.object.name):
+					context.report({
+						messageId: "noHydrate",
+						node,
+						fix: getFix$2(context, node)
+					});
+					return;
+			}
+		},
+		ImportDeclaration(node) {
+			const [baseSource] = node.source.value.split("/");
+			if (baseSource !== "react-dom") return;
+			for (const specifier of node.specifiers) switch (specifier.type) {
+				case AST_NODE_TYPES.ImportSpecifier:
+					if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
+					if (specifier.imported.name === hydrate) hydrateNames.add(specifier.local.name);
+					continue;
+				case AST_NODE_TYPES.ImportDefaultSpecifier:
+				case AST_NODE_TYPES.ImportNamespaceSpecifier:
+					reactDomNames.add(specifier.local.name);
+					continue;
+			}
+		}
+	};
 }
-function getFix(context, node) {
-  const getText2 = (n) => context.sourceCode.getText(n);
-  return (fixer) => {
-    const [arg0, arg1] = node.arguments;
-    if (arg0 == null || arg1 == null) return null;
-    return [
-      fixer.insertTextBefore(context.sourceCode.ast, 'import { hydrateRoot } from "react-dom/client";\n'),
-      fixer.replaceText(node, `hydrateRoot(${getText2(arg1)}, ${getText2(arg0)})`)
-    ];
-  };
+function getFix$2(context, node) {
+	const getText$1 = (n) => context.sourceCode.getText(n);
+	return (fixer) => {
+		const [arg0, arg1] = node.arguments;
+		if (arg0 == null || arg1 == null) return null;
+		return [fixer.insertTextBefore(context.sourceCode.ast, "import { hydrateRoot } from \"react-dom/client\";\n"), fixer.replaceText(node, `hydrateRoot(${getText$1(arg1)}, ${getText$1(arg0)})`)];
+	};
 }
 
-// src/rules/no-missing-button-type.ts
-var RULE_NAME6 = "no-missing-button-type";
-var RULE_FEATURES6 = [
-  "FIX"
+//#endregion
+//#region src/rules/no-missing-button-type.ts
+const RULE_NAME$11 = "no-missing-button-type";
+const RULE_FEATURES$10 = ["FIX"];
+const BUTTON_TYPES = [
+	"button",
+	"submit",
+	"reset"
 ];
-var BUTTON_TYPES = ["button", "submit", "reset"];
 var no_missing_button_type_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforces explicit `type` attribute for `button` elements.",
-      [Symbol.for("rule_features")]: RULE_FEATURES6
-    },
-    hasSuggestions: true,
-    messages: {
-      addButtonType: "Add 'type' attribute with value '{{type}}'.",
-      noMissingButtonType: "Add missing 'type' attribute on 'button' component."
-    },
-    schema: []
-  },
-  name: RULE_NAME6,
-  create: create6,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforces explicit `type` attribute for `button` elements.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$10
+		},
+		hasSuggestions: true,
+		messages: {
+			addButtonType: "Add 'type' attribute with value '{{type}}'.",
+			noMissingButtonType: "Add missing 'type' attribute on 'button' component."
+		},
+		schema: []
+	},
+	name: RULE_NAME$11,
+	create: create$11,
+	defaultOptions: []
 });
-function create6(context) {
-  const resolver = createJsxElementResolver(context);
-  return {
-    JSXElement(node) {
-      const { attributes, domElementType } = resolver.resolve(node);
-      if (domElementType !== "button") return;
-      const typeAttribute = resolveAttribute(context, attributes, node, "type");
-      if (typeAttribute.attributeValueString != null) return;
-      if (typeAttribute.attribute == null) {
-        context.report({
-          messageId: "noMissingButtonType",
-          node: node.openingElement,
-          suggest: getSuggest((type) => (fixer) => {
-            return fixer.insertTextAfter(node.openingElement.name, ` ${typeAttribute.attributeName}="${type}"`);
-          })
-        });
-        return;
-      }
-      context.report({
-        messageId: "noMissingButtonType",
-        node: typeAttribute.attributeValue?.node ?? typeAttribute.attribute,
-        suggest: getSuggest((type) => (fixer) => {
-          if (typeAttribute.attribute == null) return null;
-          return fixer.replaceText(typeAttribute.attribute, `${typeAttribute.attributeName}="${type}"`);
-        })
-      });
-    }
-  };
+function create$11(context) {
+	const resolver = createJsxElementResolver(context);
+	return { JSXElement(node) {
+		const { domElementType } = resolver.resolve(node);
+		if (domElementType !== "button") return;
+		const typeAttribute = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("type");
+		if (typeAttribute == null) {
+			context.report({
+				messageId: "noMissingButtonType",
+				node: node.openingElement,
+				suggest: getSuggest((type) => (fixer) => {
+					return fixer.insertTextAfter(node.openingElement.name, ` type="${type}"`);
+				})
+			});
+			return;
+		}
+		if (typeof ER.resolveAttributeValue(context, typeAttribute).toStatic("type") === "string") return;
+		context.report({
+			messageId: "noMissingButtonType",
+			node: typeAttribute,
+			suggest: getSuggest((type) => (fixer) => {
+				return fixer.replaceText(typeAttribute, `type="${type}"`);
+			})
+		});
+	} };
 }
-function getSuggest(getFix4) {
-  return BUTTON_TYPES.map((type) => ({
-    messageId: "addButtonType",
-    data: { type },
-    fix: getFix4(type)
-  }));
+function getSuggest(getFix$3) {
+	return BUTTON_TYPES.map((type) => ({
+		messageId: "addButtonType",
+		data: { type },
+		fix: getFix$3(type)
+	}));
 }
 
-// src/rules/no-missing-iframe-sandbox.ts
-var RULE_NAME7 = "no-missing-iframe-sandbox";
-var RULE_FEATURES7 = [
-  "FIX"
-];
+//#endregion
+//#region src/rules/no-missing-iframe-sandbox.ts
+const RULE_NAME$10 = "no-missing-iframe-sandbox";
+const RULE_FEATURES$9 = ["FIX"];
 var no_missing_iframe_sandbox_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforces explicit `sandbox` attribute for `iframe` elements.",
-      [Symbol.for("rule_features")]: RULE_FEATURES7
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      addIframeSandbox: "Add 'sandbox' attribute with value '{{value}}'.",
-      noMissingIframeSandbox: "Add missing 'sandbox' attribute on 'iframe' component."
-    },
-    schema: []
-  },
-  name: RULE_NAME7,
-  create: create7,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforces explicit `sandbox` attribute for `iframe` elements.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$9
+		},
+		fixable: "code",
+		hasSuggestions: true,
+		messages: {
+			addIframeSandbox: "Add 'sandbox' attribute with value '{{value}}'.",
+			noMissingIframeSandbox: "Add missing 'sandbox' attribute on 'iframe' component."
+		},
+		schema: []
+	},
+	name: RULE_NAME$10,
+	create: create$10,
+	defaultOptions: []
 });
-function create7(context) {
-  const resolver = createJsxElementResolver(context);
-  return {
-    JSXElement(node) {
-      const { attributes, domElementType } = resolver.resolve(node);
-      if (domElementType !== "iframe") return;
-      const sandboxAttribute = resolveAttribute(context, attributes, node, "sandbox");
-      if (sandboxAttribute.attributeValueString != null) return;
-      if (sandboxAttribute.attribute == null) {
-        context.report({
-          messageId: "noMissingIframeSandbox",
-          node: node.openingElement,
-          suggest: [{
-            messageId: "addIframeSandbox",
-            data: { value: "" },
-            fix(fixer) {
-              return fixer.insertTextAfter(node.openingElement.name, ` ${sandboxAttribute.attributeName}=""`);
-            }
-          }]
-        });
-        return;
-      }
-      context.report({
-        messageId: "noMissingIframeSandbox",
-        node: sandboxAttribute.attributeValue?.node ?? sandboxAttribute.attribute,
-        suggest: [{
-          messageId: "addIframeSandbox",
-          data: { value: "" },
-          fix(fixer) {
-            if (sandboxAttribute.attribute == null) return null;
-            return fixer.replaceText(sandboxAttribute.attribute, `${sandboxAttribute.attributeName}=""`);
-          }
-        }]
-      });
-    }
-  };
+function create$10(context) {
+	const resolver = createJsxElementResolver(context);
+	return { JSXElement(node) {
+		const { domElementType } = resolver.resolve(node);
+		if (domElementType !== "iframe") return;
+		const sandboxAttribute = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("sandbox");
+		if (sandboxAttribute == null) {
+			context.report({
+				messageId: "noMissingIframeSandbox",
+				node: node.openingElement,
+				suggest: [{
+					messageId: "addIframeSandbox",
+					data: { value: "" },
+					fix(fixer) {
+						return fixer.insertTextAfter(node.openingElement.name, ` sandbox=""`);
+					}
+				}]
+			});
+			return;
+		}
+		const sandboxAttributeValue = ER.resolveAttributeValue(context, sandboxAttribute);
+		if (typeof sandboxAttributeValue.toStatic("sandbox") === "string") return;
+		context.report({
+			messageId: "noMissingIframeSandbox",
+			node: sandboxAttributeValue.node ?? sandboxAttribute,
+			suggest: [{
+				messageId: "addIframeSandbox",
+				data: { value: "" },
+				fix(fixer) {
+					if (sandboxAttributeValue.kind.startsWith("spread")) return null;
+					return fixer.replaceText(sandboxAttribute, `sandbox=""`);
+				}
+			}]
+		});
+	} };
 }
-var RULE_NAME8 = "no-namespace";
-var RULE_FEATURES8 = [];
+
+//#endregion
+//#region src/rules/no-namespace.ts
+const RULE_NAME$9 = "no-namespace";
+const RULE_FEATURES$8 = [];
 var no_namespace_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforces the absence of a `namespace` in React elements.",
-      [Symbol.for("rule_features")]: RULE_FEATURES8
-    },
-    messages: {
-      noNamespace: "A React component '{{name}}' must not be in a namespace, as React does not support them."
-    },
-    schema: []
-  },
-  name: RULE_NAME8,
-  create: create8,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforces the absence of a `namespace` in React elements.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$8
+		},
+		messages: { noNamespace: "A React component '{{name}}' must not be in a namespace, as React does not support them." },
+		schema: []
+	},
+	name: RULE_NAME$9,
+	create: create$9,
+	defaultOptions: []
 });
-function create8(context) {
-  return {
-    JSXElement(node) {
-      const name3 = ER.getElementType(context, node);
-      if (typeof name3 !== "string" || !name3.includes(":")) {
-        return;
-      }
-      context.report({
-        messageId: "noNamespace",
-        node: node.openingElement.name,
-        data: {
-          name: name3
-        }
-      });
-    }
-  };
+function create$9(context) {
+	return { JSXElement(node) {
+		const name$2 = ER.getElementType(context, node);
+		if (typeof name$2 !== "string" || !name$2.includes(":")) return;
+		context.report({
+			messageId: "noNamespace",
+			node: node.openingElement.name,
+			data: { name: name$2 }
+		});
+	} };
 }
-var RULE_NAME9 = "no-render";
-var RULE_FEATURES9 = [
-  "MOD"
-];
+
+//#endregion
+//#region src/rules/no-render.ts
+const RULE_NAME$8 = "no-render";
+const RULE_FEATURES$7 = ["MOD"];
 var no_render_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Replaces usages of `ReactDom.render()` with `createRoot(node).render()`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES9
-    },
-    fixable: "code",
-    messages: {
-      noRender: "[Deprecated] Use 'createRoot(node).render()' instead."
-    },
-    schema: []
-  },
-  name: RULE_NAME9,
-  create: create9,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Replaces usages of `ReactDom.render()` with `createRoot(node).render()`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$7
+		},
+		fixable: "code",
+		messages: { noRender: "[Deprecated] Use 'createRoot(node).render()' instead." },
+		schema: []
+	},
+	name: RULE_NAME$8,
+	create: create$8,
+	defaultOptions: []
 });
-function create9(context) {
-  if (!context.sourceCode.text.includes("render")) return {};
-  const settings2 = getSettingsFromContext(context);
-  if (compare(settings2.version, "18.0.0", "<")) return {};
-  const reactDomNames = /* @__PURE__ */ new Set(["ReactDOM", "ReactDom"]);
-  const renderNames = /* @__PURE__ */ new Set();
-  return {
-    CallExpression(node) {
-      switch (true) {
-        case (node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name)):
-          context.report({
-            messageId: "noRender",
-            node,
-            fix: getFix2(context, node)
-          });
-          return;
-        case (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name)):
-          context.report({
-            messageId: "noRender",
-            node,
-            fix: getFix2(context, node)
-          });
-          return;
-      }
-    },
-    ImportDeclaration(node) {
-      const [baseSource] = node.source.value.split("/");
-      if (baseSource !== "react-dom") return;
-      for (const specifier of node.specifiers) {
-        switch (specifier.type) {
-          case AST_NODE_TYPES.ImportSpecifier:
-            if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
-            if (specifier.imported.name === "render") {
-              renderNames.add(specifier.local.name);
-            }
-            continue;
-          case AST_NODE_TYPES.ImportDefaultSpecifier:
-          case AST_NODE_TYPES.ImportNamespaceSpecifier:
-            reactDomNames.add(specifier.local.name);
-            continue;
-        }
-      }
-    }
-  };
+function create$8(context) {
+	if (!context.sourceCode.text.includes("render")) return {};
+	const settings$1 = getSettingsFromContext(context);
+	if (compare(settings$1.version, "18.0.0", "<")) return {};
+	const reactDomNames = new Set(["ReactDOM", "ReactDom"]);
+	const renderNames = /* @__PURE__ */ new Set();
+	return {
+		CallExpression(node) {
+			switch (true) {
+				case node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name):
+					context.report({
+						messageId: "noRender",
+						node,
+						fix: getFix$1(context, node)
+					});
+					return;
+				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name):
+					context.report({
+						messageId: "noRender",
+						node,
+						fix: getFix$1(context, node)
+					});
+					return;
+			}
+		},
+		ImportDeclaration(node) {
+			const [baseSource] = node.source.value.split("/");
+			if (baseSource !== "react-dom") return;
+			for (const specifier of node.specifiers) switch (specifier.type) {
+				case AST_NODE_TYPES.ImportSpecifier:
+					if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
+					if (specifier.imported.name === "render") renderNames.add(specifier.local.name);
+					continue;
+				case AST_NODE_TYPES.ImportDefaultSpecifier:
+				case AST_NODE_TYPES.ImportNamespaceSpecifier:
+					reactDomNames.add(specifier.local.name);
+					continue;
+			}
+		}
+	};
 }
-function getFix2(context, node) {
-  const getText2 = (n) => context.sourceCode.getText(n);
-  return (fixer) => {
-    const [arg0, arg1] = node.arguments;
-    if (arg0 == null || arg1 == null) return null;
-    return [
-      fixer.insertTextBefore(context.sourceCode.ast, 'import { createRoot } from "react-dom/client";\n'),
-      fixer.replaceText(node, `createRoot(${getText2(arg1)}).render(${getText2(arg0)})`)
-    ];
-  };
+function getFix$1(context, node) {
+	const getText$1 = (n) => context.sourceCode.getText(n);
+	return (fixer) => {
+		const [arg0, arg1] = node.arguments;
+		if (arg0 == null || arg1 == null) return null;
+		return [fixer.insertTextBefore(context.sourceCode.ast, "import { createRoot } from \"react-dom/client\";\n"), fixer.replaceText(node, `createRoot(${getText$1(arg1)}).render(${getText$1(arg0)})`)];
+	};
 }
-var RULE_NAME10 = "no-render-return-value";
-var RULE_FEATURES10 = [];
-var banParentTypes = [
-  AST_NODE_TYPES.VariableDeclarator,
-  AST_NODE_TYPES.Property,
-  AST_NODE_TYPES.ReturnStatement,
-  AST_NODE_TYPES.ArrowFunctionExpression,
-  AST_NODE_TYPES.AssignmentExpression
+
+//#endregion
+//#region src/rules/no-render-return-value.ts
+const RULE_NAME$7 = "no-render-return-value";
+const RULE_FEATURES$6 = [];
+const banParentTypes = [
+	AST_NODE_TYPES.VariableDeclarator,
+	AST_NODE_TYPES.Property,
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ArrowFunctionExpression,
+	AST_NODE_TYPES.AssignmentExpression
 ];
 var no_render_return_value_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow the return value of `ReactDOM.render`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES10
-    },
-    messages: {
-      noRenderReturnValue: "Do not depend on the return value from 'ReactDOM.render'."
-    },
-    schema: []
-  },
-  name: RULE_NAME10,
-  create: create10,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow the return value of `ReactDOM.render`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$6
+		},
+		messages: { noRenderReturnValue: "Do not depend on the return value from 'ReactDOM.render'." },
+		schema: []
+	},
+	name: RULE_NAME$7,
+	create: create$7,
+	defaultOptions: []
 });
-function create10(context) {
-  const reactDomNames = /* @__PURE__ */ new Set(["ReactDOM", "ReactDom"]);
-  const renderNames = /* @__PURE__ */ new Set();
-  return {
-    CallExpression(node) {
-      switch (true) {
-        case (node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name) && banParentTypes.includes(node.parent.type)):
-          context.report({
-            messageId: "noRenderReturnValue",
-            node
-          });
-          return;
-        case (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name) && banParentTypes.includes(node.parent.type)):
-          context.report({
-            messageId: "noRenderReturnValue",
-            node
-          });
-          return;
-      }
-    },
-    ImportDeclaration(node) {
-      const [baseSource] = node.source.value.split("/");
-      if (baseSource !== "react-dom") return;
-      for (const specifier of node.specifiers) {
-        switch (specifier.type) {
-          case AST_NODE_TYPES.ImportSpecifier:
-            if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
-            if (specifier.imported.name === "render") {
-              renderNames.add(specifier.local.name);
-            }
-            continue;
-          case AST_NODE_TYPES.ImportDefaultSpecifier:
-          case AST_NODE_TYPES.ImportNamespaceSpecifier:
-            reactDomNames.add(specifier.local.name);
-            continue;
-        }
-      }
-    }
-  };
+function create$7(context) {
+	const reactDomNames = new Set(["ReactDOM", "ReactDom"]);
+	const renderNames = /* @__PURE__ */ new Set();
+	return {
+		CallExpression(node) {
+			switch (true) {
+				case node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name) && banParentTypes.includes(node.parent.type):
+					context.report({
+						messageId: "noRenderReturnValue",
+						node
+					});
+					return;
+				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name) && banParentTypes.includes(node.parent.type):
+					context.report({
+						messageId: "noRenderReturnValue",
+						node
+					});
+					return;
+			}
+		},
+		ImportDeclaration(node) {
+			const [baseSource] = node.source.value.split("/");
+			if (baseSource !== "react-dom") return;
+			for (const specifier of node.specifiers) switch (specifier.type) {
+				case AST_NODE_TYPES.ImportSpecifier:
+					if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
+					if (specifier.imported.name === "render") renderNames.add(specifier.local.name);
+					continue;
+				case AST_NODE_TYPES.ImportDefaultSpecifier:
+				case AST_NODE_TYPES.ImportNamespaceSpecifier:
+					reactDomNames.add(specifier.local.name);
+					continue;
+			}
+		}
+	};
 }
-var RULE_NAME11 = "no-script-url";
-var RULE_FEATURES11 = [];
+
+//#endregion
+//#region src/rules/no-script-url.ts
+const RULE_NAME$6 = "no-script-url";
+const RULE_FEATURES$5 = [];
 var no_script_url_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `javascript:` URLs as attribute values.",
-      [Symbol.for("rule_features")]: RULE_FEATURES11
-    },
-    messages: {
-      noScriptUrl: "Using a `javascript:` URL is a security risk and should be avoided."
-    },
-    schema: []
-  },
-  name: RULE_NAME11,
-  create: create11,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `javascript:` URLs as attribute values.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$5
+		},
+		messages: { noScriptUrl: "Using a `javascript:` URL is a security risk and should be avoided." },
+		schema: []
+	},
+	name: RULE_NAME$6,
+	create: create$6,
+	defaultOptions: []
+});
+function create$6(context) {
+	return { JSXAttribute(node) {
+		if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.value == null) return;
+		const value = ER.resolveAttributeValue(context, node).toStatic();
+		if (typeof value === "string" && RE_JAVASCRIPT_PROTOCOL.test(value)) context.report({
+			messageId: "noScriptUrl",
+			node: node.value
+		});
+	} };
+}
+
+//#endregion
+//#region src/rules/no-string-style-prop.ts
+const RULE_NAME$5 = "no-string-style-prop";
+const RULE_FEATURES$4 = [];
+var no_string_style_prop_default = createRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallows the use of string style prop.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$4
+		},
+		messages: { noStringStyleProp: "Do not use string style prop. Use an object instead." },
+		schema: []
+	},
+	name: RULE_NAME$5,
+	create: create$5,
+	defaultOptions: []
 });
-function create11(context) {
-  return {
-    JSXAttribute(node) {
-      if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.value == null) {
-        return;
-      }
-      const attributeValue = ER.getAttributeValue(context, node, ER.getAttributeName(context, node));
-      if (attributeValue.kind === "none" || typeof attributeValue.value !== "string") return;
-      if (RegExp.JAVASCRIPT_PROTOCOL.test(attributeValue.value)) {
-        context.report({
-          messageId: "noScriptUrl",
-          node: node.value
-        });
-      }
-    }
-  };
+function create$5(context) {
+	return { JSXElement(node) {
+		if (!ER.isHostElement(context, node)) return;
+		const attribute = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("style");
+		if (attribute == null) return;
+		const attributeValue = ER.resolveAttributeValue(context, attribute);
+		if (typeof attributeValue.toStatic() === "string") context.report({
+			messageId: "noStringStyleProp",
+			node: attributeValue.node ?? attribute
+		});
+	} };
 }
-var RULE_NAME12 = "no-unknown-property";
-var DEFAULTS = {
-  ignore: [],
-  requireDataLowercase: false
+
+//#endregion
+//#region src/rules/no-unknown-property.ts
+const RULE_NAME$4 = "no-unknown-property";
+const DEFAULTS = {
+	ignore: [],
+	requireDataLowercase: false
 };
-var DOM_ATTRIBUTE_NAMES = {
-  "accept-charset": "acceptCharset",
-  class: "className",
-  crossorigin: "crossOrigin",
-  for: "htmlFor",
-  "http-equiv": "httpEquiv",
-  nomodule: "noModule"
+/**
+* Map of standard HTML attributes to their React counterparts
+*/
+const DOM_ATTRIBUTE_NAMES = {
+	"accept-charset": "acceptCharset",
+	class: "className",
+	crossorigin: "crossOrigin",
+	for: "htmlFor",
+	"http-equiv": "httpEquiv",
+	nomodule: "noModule"
 };
-var ATTRIBUTE_TAGS_MAP = {
-  as: ["link"],
-  abbr: ["th", "td"],
-  align: [
-    "applet",
-    "caption",
-    "col",
-    "colgroup",
-    "hr",
-    "iframe",
-    "img",
-    "table",
-    "tbody",
-    "td",
-    "tfoot",
-    "th",
-    "thead",
-    "tr"
-  ],
-  // deprecated, but known
-  allowFullScreen: ["iframe", "video"],
-  autoPictureInPicture: ["video"],
-  charset: ["meta"],
-  checked: ["input"],
-  controls: ["audio", "video"],
-  controlsList: ["audio", "video"],
-  // image is required for SVG support, all other tags are HTML.
-  crossOrigin: ["script", "img", "video", "audio", "link", "image"],
-  disablePictureInPicture: ["video"],
-  disableRemotePlayback: ["audio", "video"],
-  displaystyle: ["math"],
-  // https://html.spec.whatwg.org/multipage/links.html#downloading-resources
-  download: ["a", "area"],
-  fill: [
-    // https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill
-    // Fill color
-    "altGlyph",
-    "circle",
-    "ellipse",
-    "g",
-    "line",
-    "marker",
-    "mask",
-    "path",
-    "polygon",
-    "polyline",
-    "rect",
-    "svg",
-    "symbol",
-    "text",
-    "textPath",
-    "tref",
-    "tspan",
-    "use",
-    // Animation final state
-    "animate",
-    "animateColor",
-    "animateMotion",
-    "animateTransform",
-    "set"
-  ],
-  focusable: ["svg"],
-  imageSizes: ["link"],
-  imageSrcSet: ["link"],
-  loop: ["audio", "video"],
-  mozAllowFullScreen: ["iframe", "video"],
-  muted: ["audio", "video"],
-  noModule: ["script"],
-  // Media events allowed only on audio and video tags, see https://github.com/facebook/react/blob/256aefbea1449869620fb26f6ec695536ab453f5/CHANGELOG.md#notable-enhancements
-  onAbort: ["audio", "video"],
-  onCanPlay: ["audio", "video"],
-  onCanPlayThrough: ["audio", "video"],
-  onCancel: ["dialog"],
-  onClose: ["dialog"],
-  onDurationChange: ["audio", "video"],
-  onEmptied: ["audio", "video"],
-  onEncrypted: ["audio", "video"],
-  onEnded: ["audio", "video"],
-  onError: ["audio", "video", "img", "link", "source", "script", "picture", "iframe"],
-  onLoad: ["script", "img", "link", "picture", "iframe", "object", "source"],
-  onLoadStart: ["audio", "video"],
-  onLoadedData: ["audio", "video"],
-  onLoadedMetadata: ["audio", "video"],
-  onPause: ["audio", "video"],
-  onPlay: ["audio", "video"],
-  onPlaying: ["audio", "video"],
-  onProgress: ["audio", "video"],
-  onRateChange: ["audio", "video"],
-  onResize: ["audio", "video"],
-  onSeeked: ["audio", "video"],
-  onSeeking: ["audio", "video"],
-  onStalled: ["audio", "video"],
-  onSuspend: ["audio", "video"],
-  onTimeUpdate: ["audio", "video"],
-  onVolumeChange: ["audio", "video"],
-  onWaiting: ["audio", "video"],
-  playsInline: ["video"],
-  poster: ["video"],
-  preload: ["audio", "video"],
-  property: ["meta"],
-  returnValue: ["dialog"],
-  scrolling: ["iframe"],
-  valign: ["tr", "td", "th", "thead", "tbody", "tfoot", "colgroup", "col"],
-  // deprecated, but known
-  viewBox: ["marker", "pattern", "svg", "symbol", "view"],
-  webkitAllowFullScreen: ["iframe", "video"],
-  webkitDirectory: ["input"]
+/**
+* Map of SVG attributes to their React camelCase equivalents
+*/
+const SVGDOM_ATTRIBUTE_NAMES = {
+	"accent-height": "accentHeight",
+	"alignment-baseline": "alignmentBaseline",
+	"arabic-form": "arabicForm",
+	"baseline-shift": "baselineShift",
+	"cap-height": "capHeight",
+	"clip-path": "clipPath",
+	"clip-rule": "clipRule",
+	"color-interpolation": "colorInterpolation",
+	"color-interpolation-filters": "colorInterpolationFilters",
+	"color-profile": "colorProfile",
+	"color-rendering": "colorRendering",
+	"dominant-baseline": "dominantBaseline",
+	"enable-background": "enableBackground",
+	"fill-opacity": "fillOpacity",
+	"fill-rule": "fillRule",
+	"flood-color": "floodColor",
+	"flood-opacity": "floodOpacity",
+	"font-family": "fontFamily",
+	"font-size": "fontSize",
+	"font-size-adjust": "fontSizeAdjust",
+	"font-stretch": "fontStretch",
+	"font-style": "fontStyle",
+	"font-variant": "fontVariant",
+	"font-weight": "fontWeight",
+	"glyph-name": "glyphName",
+	"glyph-orientation-horizontal": "glyphOrientationHorizontal",
+	"glyph-orientation-vertical": "glyphOrientationVertical",
+	"horiz-adv-x": "horizAdvX",
+	"horiz-origin-x": "horizOriginX",
+	"image-rendering": "imageRendering",
+	"letter-spacing": "letterSpacing",
+	"lighting-color": "lightingColor",
+	"marker-end": "markerEnd",
+	"marker-mid": "markerMid",
+	"marker-start": "markerStart",
+	"overline-position": "overlinePosition",
+	"overline-thickness": "overlineThickness",
+	"paint-order": "paintOrder",
+	"panose-1": "panose1",
+	"pointer-events": "pointerEvents",
+	"rendering-intent": "renderingIntent",
+	"shape-rendering": "shapeRendering",
+	"stop-color": "stopColor",
+	"stop-opacity": "stopOpacity",
+	"strikethrough-position": "strikethroughPosition",
+	"strikethrough-thickness": "strikethroughThickness",
+	"stroke-dasharray": "strokeDasharray",
+	"stroke-dashoffset": "strokeDashoffset",
+	"stroke-linecap": "strokeLinecap",
+	"stroke-linejoin": "strokeLinejoin",
+	"stroke-miterlimit": "strokeMiterlimit",
+	"stroke-opacity": "strokeOpacity",
+	"stroke-width": "strokeWidth",
+	"text-anchor": "textAnchor",
+	"text-decoration": "textDecoration",
+	"text-rendering": "textRendering",
+	"underline-position": "underlinePosition",
+	"underline-thickness": "underlineThickness",
+	"unicode-bidi": "unicodeBidi",
+	"unicode-range": "unicodeRange",
+	"units-per-em": "unitsPerEm",
+	"v-alphabetic": "vAlphabetic",
+	"v-hanging": "vHanging",
+	"v-ideographic": "vIdeographic",
+	"v-mathematical": "vMathematical",
+	"vector-effect": "vectorEffect",
+	"vert-adv-y": "vertAdvY",
+	"vert-origin-x": "vertOriginX",
+	"vert-origin-y": "vertOriginY",
+	"word-spacing": "wordSpacing",
+	"writing-mode": "writingMode",
+	"x-height": "xHeight",
+	"xlink:actuate": "xlinkActuate",
+	"xlink:arcrole": "xlinkArcrole",
+	"xlink:href": "xlinkHref",
+	"xlink:role": "xlinkRole",
+	"xlink:show": "xlinkShow",
+	"xlink:title": "xlinkTitle",
+	"xlink:type": "xlinkType",
+	"xml:base": "xmlBase",
+	"xml:lang": "xmlLang",
+	"xml:space": "xmlSpace"
 };
-var SVGDOM_ATTRIBUTE_NAMES = {
-  "accent-height": "accentHeight",
-  "alignment-baseline": "alignmentBaseline",
-  "arabic-form": "arabicForm",
-  "baseline-shift": "baselineShift",
-  "cap-height": "capHeight",
-  "clip-path": "clipPath",
-  "clip-rule": "clipRule",
-  "color-interpolation": "colorInterpolation",
-  "color-interpolation-filters": "colorInterpolationFilters",
-  "color-profile": "colorProfile",
-  "color-rendering": "colorRendering",
-  "dominant-baseline": "dominantBaseline",
-  "enable-background": "enableBackground",
-  "fill-opacity": "fillOpacity",
-  "fill-rule": "fillRule",
-  "flood-color": "floodColor",
-  "flood-opacity": "floodOpacity",
-  "font-family": "fontFamily",
-  "font-size": "fontSize",
-  "font-size-adjust": "fontSizeAdjust",
-  "font-stretch": "fontStretch",
-  "font-style": "fontStyle",
-  "font-variant": "fontVariant",
-  "font-weight": "fontWeight",
-  "glyph-name": "glyphName",
-  "glyph-orientation-horizontal": "glyphOrientationHorizontal",
-  "glyph-orientation-vertical": "glyphOrientationVertical",
-  "horiz-adv-x": "horizAdvX",
-  "horiz-origin-x": "horizOriginX",
-  "image-rendering": "imageRendering",
-  "letter-spacing": "letterSpacing",
-  "lighting-color": "lightingColor",
-  "marker-end": "markerEnd",
-  "marker-mid": "markerMid",
-  "marker-start": "markerStart",
-  "overline-position": "overlinePosition",
-  "overline-thickness": "overlineThickness",
-  "paint-order": "paintOrder",
-  "panose-1": "panose1",
-  "pointer-events": "pointerEvents",
-  "rendering-intent": "renderingIntent",
-  "shape-rendering": "shapeRendering",
-  "stop-color": "stopColor",
-  "stop-opacity": "stopOpacity",
-  "strikethrough-position": "strikethroughPosition",
-  "strikethrough-thickness": "strikethroughThickness",
-  "stroke-dasharray": "strokeDasharray",
-  "stroke-dashoffset": "strokeDashoffset",
-  "stroke-linecap": "strokeLinecap",
-  "stroke-linejoin": "strokeLinejoin",
-  "stroke-miterlimit": "strokeMiterlimit",
-  "stroke-opacity": "strokeOpacity",
-  "stroke-width": "strokeWidth",
-  "text-anchor": "textAnchor",
-  "text-decoration": "textDecoration",
-  "text-rendering": "textRendering",
-  "underline-position": "underlinePosition",
-  "underline-thickness": "underlineThickness",
-  "unicode-bidi": "unicodeBidi",
-  "unicode-range": "unicodeRange",
-  "units-per-em": "unitsPerEm",
-  "v-alphabetic": "vAlphabetic",
-  "v-hanging": "vHanging",
-  "v-ideographic": "vIdeographic",
-  "v-mathematical": "vMathematical",
-  "vector-effect": "vectorEffect",
-  "vert-adv-y": "vertAdvY",
-  "vert-origin-x": "vertOriginX",
-  "vert-origin-y": "vertOriginY",
-  "word-spacing": "wordSpacing",
-  "writing-mode": "writingMode",
-  "x-height": "xHeight",
-  "xlink:actuate": "xlinkActuate",
-  "xlink:arcrole": "xlinkArcrole",
-  "xlink:href": "xlinkHref",
-  "xlink:role": "xlinkRole",
-  "xlink:show": "xlinkShow",
-  "xlink:title": "xlinkTitle",
-  "xlink:type": "xlinkType",
-  "xml:base": "xmlBase",
-  "xml:lang": "xmlLang",
-  "xml:space": "xmlSpace"
+/**
+* Map of attributes that are only valid on specific HTML tags
+*/
+const ATTRIBUTE_TAGS_MAP = {
+	as: ["link"],
+	abbr: ["th", "td"],
+	align: [
+		"applet",
+		"caption",
+		"col",
+		"colgroup",
+		"hr",
+		"iframe",
+		"img",
+		"table",
+		"tbody",
+		"td",
+		"tfoot",
+		"th",
+		"thead",
+		"tr"
+	],
+	allowFullScreen: ["iframe", "video"],
+	autoPictureInPicture: ["video"],
+	charset: ["meta"],
+	checked: ["input"],
+	controls: ["audio", "video"],
+	controlsList: ["audio", "video"],
+	crossOrigin: [
+		"script",
+		"img",
+		"video",
+		"audio",
+		"link",
+		"image"
+	],
+	disablePictureInPicture: ["video"],
+	disableRemotePlayback: ["audio", "video"],
+	displaystyle: ["math"],
+	download: ["a", "area"],
+	fill: [
+		"altGlyph",
+		"circle",
+		"ellipse",
+		"g",
+		"line",
+		"marker",
+		"mask",
+		"path",
+		"polygon",
+		"polyline",
+		"rect",
+		"svg",
+		"symbol",
+		"text",
+		"textPath",
+		"tref",
+		"tspan",
+		"use",
+		"animate",
+		"animateColor",
+		"animateMotion",
+		"animateTransform",
+		"set"
+	],
+	focusable: ["svg"],
+	imageSizes: ["link"],
+	imageSrcSet: ["link"],
+	loop: ["audio", "video"],
+	mozAllowFullScreen: ["iframe", "video"],
+	muted: ["audio", "video"],
+	noModule: ["script"],
+	onAbort: ["audio", "video"],
+	onCanPlay: ["audio", "video"],
+	onCanPlayThrough: ["audio", "video"],
+	onCancel: ["dialog"],
+	onClose: ["dialog"],
+	onDurationChange: ["audio", "video"],
+	onEmptied: ["audio", "video"],
+	onEncrypted: ["audio", "video"],
+	onEnded: ["audio", "video"],
+	onError: [
+		"audio",
+		"video",
+		"img",
+		"link",
+		"source",
+		"script",
+		"picture",
+		"iframe"
+	],
+	onLoad: [
+		"script",
+		"img",
+		"link",
+		"picture",
+		"iframe",
+		"object",
+		"source"
+	],
+	onLoadStart: ["audio", "video"],
+	onLoadedData: ["audio", "video"],
+	onLoadedMetadata: ["audio", "video"],
+	onPause: ["audio", "video"],
+	onPlay: ["audio", "video"],
+	onPlaying: ["audio", "video"],
+	onProgress: ["audio", "video"],
+	onRateChange: ["audio", "video"],
+	onResize: ["audio", "video"],
+	onSeeked: ["audio", "video"],
+	onSeeking: ["audio", "video"],
+	onStalled: ["audio", "video"],
+	onSuspend: ["audio", "video"],
+	onTimeUpdate: ["audio", "video"],
+	onVolumeChange: ["audio", "video"],
+	onWaiting: ["audio", "video"],
+	playsInline: ["video"],
+	poster: ["video"],
+	preload: ["audio", "video"],
+	property: ["meta"],
+	returnValue: ["dialog"],
+	scrolling: ["iframe"],
+	valign: [
+		"tr",
+		"td",
+		"th",
+		"thead",
+		"tbody",
+		"tfoot",
+		"colgroup",
+		"col"
+	],
+	viewBox: [
+		"marker",
+		"pattern",
+		"svg",
+		"symbol",
+		"view"
+	],
+	webkitAllowFullScreen: ["iframe", "video"],
+	webkitDirectory: ["input"]
 };
-var DOM_PROPERTY_NAMES_ONE_WORD = [
-  // Global attributes - can be used on any HTML/DOM element
-  // See https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
-  "dir",
-  "draggable",
-  "hidden",
-  "id",
-  "lang",
-  "nonce",
-  "part",
-  "slot",
-  "style",
-  "title",
-  "translate",
-  "inert",
-  // Element specific attributes
-  // See https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes (includes global attributes too)
-  // To be considered if these should be added also to ATTRIBUTE_TAGS_MAP
-  "accept",
-  "action",
-  "allow",
-  "alt",
-  "as",
-  "async",
-  "buffered",
-  "capture",
-  "challenge",
-  "cite",
-  "code",
-  "cols",
-  "content",
-  "coords",
-  "csp",
-  "data",
-  "decoding",
-  "default",
-  "defer",
-  "disabled",
-  "form",
-  "headers",
-  "height",
-  "high",
-  "href",
-  "icon",
-  "importance",
-  "integrity",
-  "kind",
-  "label",
-  "language",
-  "loading",
-  "list",
-  "loop",
-  "low",
-  "manifest",
-  "max",
-  "media",
-  "method",
-  "min",
-  "multiple",
-  "muted",
-  "name",
-  "open",
-  "optimum",
-  "pattern",
-  "ping",
-  "placeholder",
-  "poster",
-  "preload",
-  "profile",
-  "rel",
-  "required",
-  "reversed",
-  "role",
-  "rows",
-  "sandbox",
-  "scope",
-  "seamless",
-  "selected",
-  "shape",
-  "size",
-  "sizes",
-  "span",
-  "src",
-  "start",
-  "step",
-  "summary",
-  "target",
-  "type",
-  "value",
-  "width",
-  "wmode",
-  "wrap",
-  // SVG attributes
-  // See https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute
-  "accumulate",
-  "additive",
-  "alphabetic",
-  "amplitude",
-  "ascent",
-  "azimuth",
-  "bbox",
-  "begin",
-  "bias",
-  "by",
-  "clip",
-  "color",
-  "cursor",
-  "cx",
-  "cy",
-  "d",
-  "decelerate",
-  "descent",
-  "direction",
-  "display",
-  "divisor",
-  "dur",
-  "dx",
-  "dy",
-  "elevation",
-  "end",
-  "exponent",
-  "fill",
-  "filter",
-  "format",
-  "from",
-  "fr",
-  "fx",
-  "fy",
-  "g1",
-  "g2",
-  "hanging",
-  "height",
-  "hreflang",
-  "ideographic",
-  "in",
-  "in2",
-  "intercept",
-  "k",
-  "k1",
-  "k2",
-  "k3",
-  "k4",
-  "kerning",
-  "local",
-  "mask",
-  "mode",
-  "offset",
-  "opacity",
-  "operator",
-  "order",
-  "orient",
-  "orientation",
-  "origin",
-  "overflow",
-  "path",
-  "ping",
-  "points",
-  "r",
-  "radius",
-  "rel",
-  "restart",
-  "result",
-  "rotate",
-  "rx",
-  "ry",
-  "scale",
-  "seed",
-  "slope",
-  "spacing",
-  "speed",
-  "stemh",
-  "stemv",
-  "string",
-  "stroke",
-  "to",
-  "transform",
-  "u1",
-  "u2",
-  "unicode",
-  "values",
-  "version",
-  "visibility",
-  "widths",
-  "x",
-  "x1",
-  "x2",
-  "xmlns",
-  "y",
-  "y1",
-  "y2",
-  "z",
-  // OpenGraph meta tag attributes
-  "property",
-  // React specific attributes
-  "ref",
-  "key",
-  "children",
-  // Non-standard
-  "results",
-  "security",
-  // Video specific
-  "controls"
+/**
+* Single-word HTML/DOM properties
+*/
+const DOM_PROPERTY_NAMES_ONE_WORD = [
+	"dir",
+	"draggable",
+	"hidden",
+	"id",
+	"lang",
+	"nonce",
+	"part",
+	"slot",
+	"style",
+	"title",
+	"translate",
+	"inert",
+	"accept",
+	"action",
+	"allow",
+	"alt",
+	"as",
+	"async",
+	"buffered",
+	"capture",
+	"challenge",
+	"cite",
+	"code",
+	"cols",
+	"content",
+	"coords",
+	"csp",
+	"data",
+	"decoding",
+	"default",
+	"defer",
+	"disabled",
+	"form",
+	"headers",
+	"height",
+	"high",
+	"href",
+	"icon",
+	"importance",
+	"integrity",
+	"kind",
+	"label",
+	"language",
+	"loading",
+	"list",
+	"loop",
+	"low",
+	"manifest",
+	"max",
+	"media",
+	"method",
+	"min",
+	"multiple",
+	"muted",
+	"name",
+	"open",
+	"optimum",
+	"pattern",
+	"ping",
+	"placeholder",
+	"poster",
+	"preload",
+	"profile",
+	"rel",
+	"required",
+	"reversed",
+	"role",
+	"rows",
+	"sandbox",
+	"scope",
+	"seamless",
+	"selected",
+	"shape",
+	"size",
+	"sizes",
+	"span",
+	"src",
+	"start",
+	"step",
+	"summary",
+	"target",
+	"type",
+	"value",
+	"width",
+	"wmode",
+	"wrap",
+	"accumulate",
+	"additive",
+	"alphabetic",
+	"amplitude",
+	"ascent",
+	"azimuth",
+	"bbox",
+	"begin",
+	"bias",
+	"by",
+	"clip",
+	"color",
+	"cursor",
+	"cx",
+	"cy",
+	"d",
+	"decelerate",
+	"descent",
+	"direction",
+	"display",
+	"divisor",
+	"dur",
+	"dx",
+	"dy",
+	"elevation",
+	"end",
+	"exponent",
+	"fill",
+	"filter",
+	"format",
+	"from",
+	"fr",
+	"fx",
+	"fy",
+	"g1",
+	"g2",
+	"hanging",
+	"height",
+	"hreflang",
+	"ideographic",
+	"in",
+	"in2",
+	"intercept",
+	"k",
+	"k1",
+	"k2",
+	"k3",
+	"k4",
+	"kerning",
+	"local",
+	"mask",
+	"mode",
+	"offset",
+	"opacity",
+	"operator",
+	"order",
+	"orient",
+	"orientation",
+	"origin",
+	"overflow",
+	"path",
+	"ping",
+	"points",
+	"r",
+	"radius",
+	"rel",
+	"restart",
+	"result",
+	"rotate",
+	"rx",
+	"ry",
+	"scale",
+	"seed",
+	"slope",
+	"spacing",
+	"speed",
+	"stemh",
+	"stemv",
+	"string",
+	"stroke",
+	"to",
+	"transform",
+	"u1",
+	"u2",
+	"unicode",
+	"values",
+	"version",
+	"visibility",
+	"widths",
+	"x",
+	"x1",
+	"x2",
+	"xmlns",
+	"y",
+	"y1",
+	"y2",
+	"z",
+	"property",
+	"ref",
+	"key",
+	"children",
+	"results",
+	"security",
+	"controls"
 ];
-var DOM_PROPERTY_NAMES_TWO_WORDS = [
-  // Global attributes - can be used on any HTML/DOM element
-  // See https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
-  "accessKey",
-  "autoCapitalize",
-  "autoFocus",
-  "contentEditable",
-  "enterKeyHint",
-  "exportParts",
-  "inputMode",
-  "itemID",
-  "itemRef",
-  "itemProp",
-  "itemScope",
-  "itemType",
-  "spellCheck",
-  "tabIndex",
-  // Element specific attributes
-  // See https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes (includes global attributes too)
-  // To be considered if these should be added also to ATTRIBUTE_TAGS_MAP
-  "acceptCharset",
-  "autoComplete",
-  "autoPlay",
-  "border",
-  "cellPadding",
-  "cellSpacing",
-  "classID",
-  "codeBase",
-  "colSpan",
-  "contextMenu",
-  "dateTime",
-  "encType",
-  "formAction",
-  "formEncType",
-  "formMethod",
-  "formNoValidate",
-  "formTarget",
-  "frameBorder",
-  "hrefLang",
-  "httpEquiv",
-  "imageSizes",
-  "imageSrcSet",
-  "isMap",
-  "keyParams",
-  "keyType",
-  "marginHeight",
-  "marginWidth",
-  "maxLength",
-  "mediaGroup",
-  "minLength",
-  "noValidate",
-  "onAnimationEnd",
-  "onAnimationIteration",
-  "onAnimationStart",
-  "onBlur",
-  "onChange",
-  "onClick",
-  "onContextMenu",
-  "onCopy",
-  "onCompositionEnd",
-  "onCompositionStart",
-  "onCompositionUpdate",
-  "onCut",
-  "onDoubleClick",
-  "onDrag",
-  "onDragEnd",
-  "onDragEnter",
-  "onDragExit",
-  "onDragLeave",
-  "onError",
-  "onFocus",
-  "onInput",
-  "onKeyDown",
-  "onKeyPress",
-  "onKeyUp",
-  "onLoad",
-  "onWheel",
-  "onDragOver",
-  "onDragStart",
-  "onDrop",
-  "onMouseDown",
-  "onMouseEnter",
-  "onMouseLeave",
-  "onMouseMove",
-  "onMouseOut",
-  "onMouseOver",
-  "onMouseUp",
-  "onPaste",
-  "onScroll",
-  "onSelect",
-  "onSubmit",
-  "onToggle",
-  "onTransitionEnd",
-  "radioGroup",
-  "readOnly",
-  "referrerPolicy",
-  "rowSpan",
-  "srcDoc",
-  "srcLang",
-  "srcSet",
-  "useMap",
-  "fetchPriority",
-  // SVG attributes
-  // See https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute
-  "crossOrigin",
-  "accentHeight",
-  "alignmentBaseline",
-  "arabicForm",
-  "attributeName",
-  "attributeType",
-  "baseFrequency",
-  "baselineShift",
-  "baseProfile",
-  "calcMode",
-  "capHeight",
-  "clipPathUnits",
-  "clipPath",
-  "clipRule",
-  "colorInterpolation",
-  "colorInterpolationFilters",
-  "colorProfile",
-  "colorRendering",
-  "contentScriptType",
-  "contentStyleType",
-  "diffuseConstant",
-  "dominantBaseline",
-  "edgeMode",
-  "enableBackground",
-  "fillOpacity",
-  "fillRule",
-  "filterRes",
-  "filterUnits",
-  "floodColor",
-  "floodOpacity",
-  "fontFamily",
-  "fontSize",
-  "fontSizeAdjust",
-  "fontStretch",
-  "fontStyle",
-  "fontVariant",
-  "fontWeight",
-  "glyphName",
-  "glyphOrientationHorizontal",
-  "glyphOrientationVertical",
-  "glyphRef",
-  "gradientTransform",
-  "gradientUnits",
-  "horizAdvX",
-  "horizOriginX",
-  "imageRendering",
-  "kernelMatrix",
-  "kernelUnitLength",
-  "keyPoints",
-  "keySplines",
-  "keyTimes",
-  "lengthAdjust",
-  "letterSpacing",
-  "lightingColor",
-  "limitingConeAngle",
-  "markerEnd",
-  "markerMid",
-  "markerStart",
-  "markerHeight",
-  "markerUnits",
-  "markerWidth",
-  "maskContentUnits",
-  "maskUnits",
-  "mathematical",
-  "numOctaves",
-  "overlinePosition",
-  "overlineThickness",
-  "panose1",
-  "paintOrder",
-  "pathLength",
-  "patternContentUnits",
-  "patternTransform",
-  "patternUnits",
-  "pointerEvents",
-  "pointsAtX",
-  "pointsAtY",
-  "pointsAtZ",
-  "preserveAlpha",
-  "preserveAspectRatio",
-  "primitiveUnits",
-  "referrerPolicy",
-  "refX",
-  "refY",
-  "rendering-intent",
-  "repeatCount",
-  "repeatDur",
-  "requiredExtensions",
-  "requiredFeatures",
-  "shapeRendering",
-  "specularConstant",
-  "specularExponent",
-  "spreadMethod",
-  "startOffset",
-  "stdDeviation",
-  "stitchTiles",
-  "stopColor",
-  "stopOpacity",
-  "strikethroughPosition",
-  "strikethroughThickness",
-  "strokeDasharray",
-  "strokeDashoffset",
-  "strokeLinecap",
-  "strokeLinejoin",
-  "strokeMiterlimit",
-  "strokeOpacity",
-  "strokeWidth",
-  "surfaceScale",
-  "systemLanguage",
-  "tableValues",
-  "targetX",
-  "targetY",
-  "textAnchor",
-  "textDecoration",
-  "textRendering",
-  "textLength",
-  "transformOrigin",
-  "underlinePosition",
-  "underlineThickness",
-  "unicodeBidi",
-  "unicodeRange",
-  "unitsPerEm",
-  "vAlphabetic",
-  "vHanging",
-  "vIdeographic",
-  "vMathematical",
-  "vectorEffect",
-  "vertAdvY",
-  "vertOriginX",
-  "vertOriginY",
-  "viewBox",
-  "viewTarget",
-  "wordSpacing",
-  "writingMode",
-  "xHeight",
-  "xChannelSelector",
-  "xlinkActuate",
-  "xlinkArcrole",
-  "xlinkHref",
-  "xlinkRole",
-  "xlinkShow",
-  "xlinkTitle",
-  "xlinkType",
-  "xmlBase",
-  "xmlLang",
-  "xmlnsXlink",
-  "xmlSpace",
-  "yChannelSelector",
-  "zoomAndPan",
-  // Safari/Apple specific, no listing available
-  "autoCorrect",
-  // https://stackoverflow.com/questions/47985384/html-autocorrect-for-text-input-is-not-working
-  "autoSave",
-  // https://stackoverflow.com/questions/25456396/what-is-autosave-attribute-supposed-to-do-how-do-i-use-it
-  // React specific attributes https://reactjs.org/docs/dom-elements.html#differences-in-attributes
-  "className",
-  "dangerouslySetInnerHTML",
-  "defaultValue",
-  "defaultChecked",
-  "htmlFor",
-  // Events' capture events
-  "onBeforeInput",
-  "onChange",
-  "onInvalid",
-  "onReset",
-  "onTouchCancel",
-  "onTouchEnd",
-  "onTouchMove",
-  "onTouchStart",
-  "suppressContentEditableWarning",
-  "suppressHydrationWarning",
-  "onAbort",
-  "onCanPlay",
-  "onCanPlayThrough",
-  "onDurationChange",
-  "onEmptied",
-  "onEncrypted",
-  "onEnded",
-  "onLoadedData",
-  "onLoadedMetadata",
-  "onLoadStart",
-  "onPause",
-  "onPlay",
-  "onPlaying",
-  "onProgress",
-  "onRateChange",
-  "onResize",
-  "onSeeked",
-  "onSeeking",
-  "onStalled",
-  "onSuspend",
-  "onTimeUpdate",
-  "onVolumeChange",
-  "onWaiting",
-  "onCopyCapture",
-  "onCutCapture",
-  "onPasteCapture",
-  "onCompositionEndCapture",
-  "onCompositionStartCapture",
-  "onCompositionUpdateCapture",
-  "onFocusCapture",
-  "onBlurCapture",
-  "onChangeCapture",
-  "onBeforeInputCapture",
-  "onInputCapture",
-  "onResetCapture",
-  "onSubmitCapture",
-  "onInvalidCapture",
-  "onLoadCapture",
-  "onErrorCapture",
-  "onKeyDownCapture",
-  "onKeyPressCapture",
-  "onKeyUpCapture",
-  "onAbortCapture",
-  "onCanPlayCapture",
-  "onCanPlayThroughCapture",
-  "onDurationChangeCapture",
-  "onEmptiedCapture",
-  "onEncryptedCapture",
-  "onEndedCapture",
-  "onLoadedDataCapture",
-  "onLoadedMetadataCapture",
-  "onLoadStartCapture",
-  "onPauseCapture",
-  "onPlayCapture",
-  "onPlayingCapture",
-  "onProgressCapture",
-  "onRateChangeCapture",
-  "onSeekedCapture",
-  "onSeekingCapture",
-  "onStalledCapture",
-  "onSuspendCapture",
-  "onTimeUpdateCapture",
-  "onVolumeChangeCapture",
-  "onWaitingCapture",
-  "onSelectCapture",
-  "onTouchCancelCapture",
-  "onTouchEndCapture",
-  "onTouchMoveCapture",
-  "onTouchStartCapture",
-  "onScrollCapture",
-  "onWheelCapture",
-  "onAnimationEndCapture",
-  "onAnimationIteration",
-  "onAnimationStartCapture",
-  "onTransitionEndCapture",
-  "onAuxClick",
-  "onAuxClickCapture",
-  "onClickCapture",
-  "onContextMenuCapture",
-  "onDoubleClickCapture",
-  "onDragCapture",
-  "onDragEndCapture",
-  "onDragEnterCapture",
-  "onDragExitCapture",
-  "onDragLeaveCapture",
-  "onDragOverCapture",
-  "onDragStartCapture",
-  "onDropCapture",
-  "onMouseDown",
-  "onMouseDownCapture",
-  "onMouseMoveCapture",
-  "onMouseOutCapture",
-  "onMouseOverCapture",
-  "onMouseUpCapture",
-  // Video specific
-  "autoPictureInPicture",
-  "controlsList",
-  "disablePictureInPicture",
-  "disableRemotePlayback"
+/**
+* Multi-word (camelCase) HTML/DOM properties
+*/
+const DOM_PROPERTY_NAMES_TWO_WORDS = [
+	"accessKey",
+	"autoCapitalize",
+	"autoFocus",
+	"contentEditable",
+	"enterKeyHint",
+	"exportParts",
+	"inputMode",
+	"itemID",
+	"itemRef",
+	"itemProp",
+	"itemScope",
+	"itemType",
+	"spellCheck",
+	"tabIndex",
+	"acceptCharset",
+	"autoComplete",
+	"autoPlay",
+	"border",
+	"cellPadding",
+	"cellSpacing",
+	"classID",
+	"codeBase",
+	"colSpan",
+	"contextMenu",
+	"dateTime",
+	"encType",
+	"formAction",
+	"formEncType",
+	"formMethod",
+	"formNoValidate",
+	"formTarget",
+	"frameBorder",
+	"hrefLang",
+	"httpEquiv",
+	"imageSizes",
+	"imageSrcSet",
+	"isMap",
+	"keyParams",
+	"keyType",
+	"marginHeight",
+	"marginWidth",
+	"maxLength",
+	"mediaGroup",
+	"minLength",
+	"noValidate",
+	"onAnimationEnd",
+	"onAnimationIteration",
+	"onAnimationStart",
+	"onBlur",
+	"onChange",
+	"onClick",
+	"onContextMenu",
+	"onCopy",
+	"onCompositionEnd",
+	"onCompositionStart",
+	"onCompositionUpdate",
+	"onCut",
+	"onDoubleClick",
+	"onDrag",
+	"onDragEnd",
+	"onDragEnter",
+	"onDragExit",
+	"onDragLeave",
+	"onError",
+	"onFocus",
+	"onInput",
+	"onKeyDown",
+	"onKeyPress",
+	"onKeyUp",
+	"onLoad",
+	"onWheel",
+	"onDragOver",
+	"onDragStart",
+	"onDrop",
+	"onMouseDown",
+	"onMouseEnter",
+	"onMouseLeave",
+	"onMouseMove",
+	"onMouseOut",
+	"onMouseOver",
+	"onMouseUp",
+	"onPaste",
+	"onScroll",
+	"onSelect",
+	"onSubmit",
+	"onToggle",
+	"onTransitionEnd",
+	"radioGroup",
+	"readOnly",
+	"referrerPolicy",
+	"rowSpan",
+	"srcDoc",
+	"srcLang",
+	"srcSet",
+	"useMap",
+	"fetchPriority",
+	"crossOrigin",
+	"accentHeight",
+	"alignmentBaseline",
+	"arabicForm",
+	"attributeName",
+	"attributeType",
+	"baseFrequency",
+	"baselineShift",
+	"baseProfile",
+	"calcMode",
+	"capHeight",
+	"clipPathUnits",
+	"clipPath",
+	"clipRule",
+	"colorInterpolation",
+	"colorInterpolationFilters",
+	"colorProfile",
+	"colorRendering",
+	"contentScriptType",
+	"contentStyleType",
+	"diffuseConstant",
+	"dominantBaseline",
+	"edgeMode",
+	"enableBackground",
+	"fillOpacity",
+	"fillRule",
+	"filterRes",
+	"filterUnits",
+	"floodColor",
+	"floodOpacity",
+	"fontFamily",
+	"fontSize",
+	"fontSizeAdjust",
+	"fontStretch",
+	"fontStyle",
+	"fontVariant",
+	"fontWeight",
+	"glyphName",
+	"glyphOrientationHorizontal",
+	"glyphOrientationVertical",
+	"glyphRef",
+	"gradientTransform",
+	"gradientUnits",
+	"horizAdvX",
+	"horizOriginX",
+	"imageRendering",
+	"kernelMatrix",
+	"kernelUnitLength",
+	"keyPoints",
+	"keySplines",
+	"keyTimes",
+	"lengthAdjust",
+	"letterSpacing",
+	"lightingColor",
+	"limitingConeAngle",
+	"markerEnd",
+	"markerMid",
+	"markerStart",
+	"markerHeight",
+	"markerUnits",
+	"markerWidth",
+	"maskContentUnits",
+	"maskUnits",
+	"mathematical",
+	"numOctaves",
+	"overlinePosition",
+	"overlineThickness",
+	"panose1",
+	"paintOrder",
+	"pathLength",
+	"patternContentUnits",
+	"patternTransform",
+	"patternUnits",
+	"pointerEvents",
+	"pointsAtX",
+	"pointsAtY",
+	"pointsAtZ",
+	"preserveAlpha",
+	"preserveAspectRatio",
+	"primitiveUnits",
+	"referrerPolicy",
+	"refX",
+	"refY",
+	"rendering-intent",
+	"repeatCount",
+	"repeatDur",
+	"requiredExtensions",
+	"requiredFeatures",
+	"shapeRendering",
+	"specularConstant",
+	"specularExponent",
+	"spreadMethod",
+	"startOffset",
+	"stdDeviation",
+	"stitchTiles",
+	"stopColor",
+	"stopOpacity",
+	"strikethroughPosition",
+	"strikethroughThickness",
+	"strokeDasharray",
+	"strokeDashoffset",
+	"strokeLinecap",
+	"strokeLinejoin",
+	"strokeMiterlimit",
+	"strokeOpacity",
+	"strokeWidth",
+	"surfaceScale",
+	"systemLanguage",
+	"tableValues",
+	"targetX",
+	"targetY",
+	"textAnchor",
+	"textDecoration",
+	"textRendering",
+	"textLength",
+	"transformOrigin",
+	"underlinePosition",
+	"underlineThickness",
+	"unicodeBidi",
+	"unicodeRange",
+	"unitsPerEm",
+	"vAlphabetic",
+	"vHanging",
+	"vIdeographic",
+	"vMathematical",
+	"vectorEffect",
+	"vertAdvY",
+	"vertOriginX",
+	"vertOriginY",
+	"viewBox",
+	"viewTarget",
+	"wordSpacing",
+	"writingMode",
+	"xHeight",
+	"xChannelSelector",
+	"xlinkActuate",
+	"xlinkArcrole",
+	"xlinkHref",
+	"xlinkRole",
+	"xlinkShow",
+	"xlinkTitle",
+	"xlinkType",
+	"xmlBase",
+	"xmlLang",
+	"xmlnsXlink",
+	"xmlSpace",
+	"yChannelSelector",
+	"zoomAndPan",
+	"autoCorrect",
+	"autoSave",
+	"className",
+	"dangerouslySetInnerHTML",
+	"defaultValue",
+	"defaultChecked",
+	"htmlFor",
+	"onBeforeInput",
+	"onChange",
+	"onInvalid",
+	"onReset",
+	"onTouchCancel",
+	"onTouchEnd",
+	"onTouchMove",
+	"onTouchStart",
+	"suppressContentEditableWarning",
+	"suppressHydrationWarning",
+	"onAbort",
+	"onCanPlay",
+	"onCanPlayThrough",
+	"onDurationChange",
+	"onEmptied",
+	"onEncrypted",
+	"onEnded",
+	"onLoadedData",
+	"onLoadedMetadata",
+	"onLoadStart",
+	"onPause",
+	"onPlay",
+	"onPlaying",
+	"onProgress",
+	"onRateChange",
+	"onResize",
+	"onSeeked",
+	"onSeeking",
+	"onStalled",
+	"onSuspend",
+	"onTimeUpdate",
+	"onVolumeChange",
+	"onWaiting",
+	"onCopyCapture",
+	"onCutCapture",
+	"onPasteCapture",
+	"onCompositionEndCapture",
+	"onCompositionStartCapture",
+	"onCompositionUpdateCapture",
+	"onFocusCapture",
+	"onBlurCapture",
+	"onChangeCapture",
+	"onBeforeInputCapture",
+	"onInputCapture",
+	"onResetCapture",
+	"onSubmitCapture",
+	"onInvalidCapture",
+	"onLoadCapture",
+	"onErrorCapture",
+	"onKeyDownCapture",
+	"onKeyPressCapture",
+	"onKeyUpCapture",
+	"onAbortCapture",
+	"onCanPlayCapture",
+	"onCanPlayThroughCapture",
+	"onDurationChangeCapture",
+	"onEmptiedCapture",
+	"onEncryptedCapture",
+	"onEndedCapture",
+	"onLoadedDataCapture",
+	"onLoadedMetadataCapture",
+	"onLoadStartCapture",
+	"onPauseCapture",
+	"onPlayCapture",
+	"onPlayingCapture",
+	"onProgressCapture",
+	"onRateChangeCapture",
+	"onSeekedCapture",
+	"onSeekingCapture",
+	"onStalledCapture",
+	"onSuspendCapture",
+	"onTimeUpdateCapture",
+	"onVolumeChangeCapture",
+	"onWaitingCapture",
+	"onSelectCapture",
+	"onTouchCancelCapture",
+	"onTouchEndCapture",
+	"onTouchMoveCapture",
+	"onTouchStartCapture",
+	"onScrollCapture",
+	"onWheelCapture",
+	"onAnimationEndCapture",
+	"onAnimationIteration",
+	"onAnimationStartCapture",
+	"onTransitionEndCapture",
+	"onAuxClick",
+	"onAuxClickCapture",
+	"onClickCapture",
+	"onContextMenuCapture",
+	"onDoubleClickCapture",
+	"onDragCapture",
+	"onDragEndCapture",
+	"onDragEnterCapture",
+	"onDragExitCapture",
+	"onDragLeaveCapture",
+	"onDragOverCapture",
+	"onDragStartCapture",
+	"onDropCapture",
+	"onMouseDown",
+	"onMouseDownCapture",
+	"onMouseMoveCapture",
+	"onMouseOutCapture",
+	"onMouseOverCapture",
+	"onMouseUpCapture",
+	"autoPictureInPicture",
+	"controlsList",
+	"disablePictureInPicture",
+	"disableRemotePlayback"
 ];
-var DOM_PROPERTIES_IGNORE_CASE = [
-  "charset",
-  "allowFullScreen",
-  "webkitAllowFullScreen",
-  "mozAllowFullScreen",
-  "webkitDirectory"
+/**
+* DOM properties that are exempt from case sensitivity checks
+*/
+const DOM_PROPERTIES_IGNORE_CASE = [
+	"charset",
+	"allowFullScreen",
+	"webkitAllowFullScreen",
+	"mozAllowFullScreen",
+	"webkitDirectory"
 ];
-var ARIA_PROPERTIES = [
-  // See https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes
-  // Global attributes
-  "aria-atomic",
-  "aria-braillelabel",
-  "aria-brailleroledescription",
-  "aria-busy",
-  "aria-controls",
-  "aria-current",
-  "aria-describedby",
-  "aria-description",
-  "aria-details",
-  "aria-disabled",
-  "aria-dropeffect",
-  "aria-errormessage",
-  "aria-flowto",
-  "aria-grabbed",
-  "aria-haspopup",
-  "aria-hidden",
-  "aria-invalid",
-  "aria-keyshortcuts",
-  "aria-label",
-  "aria-labelledby",
-  "aria-live",
-  "aria-owns",
-  "aria-relevant",
-  "aria-roledescription",
-  // Widget attributes
-  "aria-autocomplete",
-  "aria-checked",
-  "aria-expanded",
-  "aria-level",
-  "aria-modal",
-  "aria-multiline",
-  "aria-multiselectable",
-  "aria-orientation",
-  "aria-placeholder",
-  "aria-pressed",
-  "aria-readonly",
-  "aria-required",
-  "aria-selected",
-  "aria-sort",
-  "aria-valuemax",
-  "aria-valuemin",
-  "aria-valuenow",
-  "aria-valuetext",
-  // Relationship attributes
-  "aria-activedescendant",
-  "aria-colcount",
-  "aria-colindex",
-  "aria-colindextext",
-  "aria-colspan",
-  "aria-posinset",
-  "aria-rowcount",
-  "aria-rowindex",
-  "aria-rowindextext",
-  "aria-rowspan",
-  "aria-setsize"
+/**
+* List of ARIA attributes
+*/
+const ARIA_PROPERTIES = [
+	"aria-atomic",
+	"aria-braillelabel",
+	"aria-brailleroledescription",
+	"aria-busy",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-description",
+	"aria-details",
+	"aria-disabled",
+	"aria-dropeffect",
+	"aria-errormessage",
+	"aria-flowto",
+	"aria-grabbed",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-live",
+	"aria-owns",
+	"aria-relevant",
+	"aria-roledescription",
+	"aria-autocomplete",
+	"aria-checked",
+	"aria-expanded",
+	"aria-level",
+	"aria-modal",
+	"aria-multiline",
+	"aria-multiselectable",
+	"aria-orientation",
+	"aria-placeholder",
+	"aria-pressed",
+	"aria-readonly",
+	"aria-required",
+	"aria-selected",
+	"aria-sort",
+	"aria-valuemax",
+	"aria-valuemin",
+	"aria-valuenow",
+	"aria-valuetext",
+	"aria-activedescendant",
+	"aria-colcount",
+	"aria-colindex",
+	"aria-colindextext",
+	"aria-colspan",
+	"aria-posinset",
+	"aria-rowcount",
+	"aria-rowindex",
+	"aria-rowindextext",
+	"aria-rowspan",
+	"aria-setsize"
 ];
-var REACT_ON_PROPS = [
-  "onGotPointerCapture",
-  "onGotPointerCaptureCapture",
-  "onLostPointerCapture",
-  "onLostPointerCapture",
-  "onLostPointerCaptureCapture",
-  "onPointerCancel",
-  "onPointerCancelCapture",
-  "onPointerDown",
-  "onPointerDownCapture",
-  "onPointerEnter",
-  "onPointerEnterCapture",
-  "onPointerLeave",
-  "onPointerLeaveCapture",
-  "onPointerMove",
-  "onPointerMoveCapture",
-  "onPointerOut",
-  "onPointerOutCapture",
-  "onPointerOver",
-  "onPointerOverCapture",
-  "onPointerUp",
-  "onPointerUpCapture"
+/**
+* React-specific pointer event handlers added in React 16.4
+*/
+const REACT_ON_PROPS = [
+	"onGotPointerCapture",
+	"onGotPointerCaptureCapture",
+	"onLostPointerCapture",
+	"onLostPointerCapture",
+	"onLostPointerCaptureCapture",
+	"onPointerCancel",
+	"onPointerCancelCapture",
+	"onPointerDown",
+	"onPointerDownCapture",
+	"onPointerEnter",
+	"onPointerEnterCapture",
+	"onPointerLeave",
+	"onPointerLeaveCapture",
+	"onPointerMove",
+	"onPointerMoveCapture",
+	"onPointerOut",
+	"onPointerOutCapture",
+	"onPointerOver",
+	"onPointerOverCapture",
+	"onPointerUp",
+	"onPointerUpCapture"
 ];
-var POPOVER_API_PROPS = [
-  "popover",
-  "popoverTarget",
-  "popoverTargetAction",
-  "onToggle",
-  "onBeforeToggle"
+/**
+* Popover API properties added in React 19
+*/
+const POPOVER_API_PROPS = [
+	"popover",
+	"popoverTarget",
+	"popoverTargetAction",
+	"onToggle",
+	"onBeforeToggle"
 ];
+/**
+* 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")) {
-    ALL_DOM_PROPERTY_NAMES.push("allowTransparency");
-    return ALL_DOM_PROPERTY_NAMES;
-  }
-  if (testReactVersion(context, ">=", "16.4.0")) {
-    ALL_DOM_PROPERTY_NAMES.push(...REACT_ON_PROPS);
-  }
-  testReactVersion(context, ">=", "19.0.0-rc.0") ? ALL_DOM_PROPERTY_NAMES.push(...POPOVER_API_PROPS) : ALL_DOM_PROPERTY_NAMES.push(...POPOVER_API_PROPS.map((prop) => prop.toLowerCase()));
-  return ALL_DOM_PROPERTY_NAMES;
+	const ALL_DOM_PROPERTY_NAMES = DOM_PROPERTY_NAMES_TWO_WORDS.concat(DOM_PROPERTY_NAMES_ONE_WORD);
+	if (testReactVersion(context, "<=", "16.1.0")) {
+		ALL_DOM_PROPERTY_NAMES.push("allowTransparency");
+		return ALL_DOM_PROPERTY_NAMES;
+	}
+	if (testReactVersion(context, ">=", "16.4.0")) ALL_DOM_PROPERTY_NAMES.push(...REACT_ON_PROPS);
+	testReactVersion(context, ">=", "19.0.0-rc.0") ? ALL_DOM_PROPERTY_NAMES.push(...POPOVER_API_PROPS) : ALL_DOM_PROPERTY_NAMES.push(...POPOVER_API_PROPS.map((prop) => prop.toLowerCase()));
+	return ALL_DOM_PROPERTY_NAMES;
 }
+/**
+* Checks 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) {
-  const tagConvention = /^[a-z][^-]*$/;
-  if (tagConvention.test(childNode.parent.name.name)) {
-    return !childNode.parent.attributes.some(
-      (attrNode) => attrNode.type === "JSXAttribute" && attrNode.name.type === "JSXIdentifier" && attrNode.name.name === "is"
-      // To learn more about custom web components and `is` attribute,
-      // see https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements-customized-builtin-example
-    );
-  }
-  return false;
+	if (/^[a-z][^-]*$/.test(childNode.parent.name.name)) return !childNode.parent.attributes.some((attrNode) => attrNode.type === "JSXAttribute" && attrNode.name.type === "JSXIdentifier" && attrNode.name.name === "is");
+	return false;
 }
-function normalizeAttributeCase(name3) {
-  return DOM_PROPERTIES_IGNORE_CASE.find((element) => element.toLowerCase() === name3.toLowerCase()) || name3;
+/**
+* Normalizes attribute names that should be case-insensitive
+* @param name - Attribute name to normalize
+* @returns Normalized attribute name
+*/
+function normalizeAttributeCase(name$2) {
+	return DOM_PROPERTIES_IGNORE_CASE.find((element) => element.toLowerCase() === name$2.toLowerCase()) || name$2;
 }
-function isValidDataAttribute(name3) {
-  return !/^data-xml/i.test(name3) && /^data-[^:]*$/.test(name3);
+/**
+* Checks 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$2) {
+	return !/^data-xml/i.test(name$2) && /^data-[^:]*$/.test(name$2);
 }
-function hasUpperCaseCharacter(name3) {
-  return name3.toLowerCase() !== name3;
+/**
+* Checks if an attribute name has uppercase characters
+* @param name - Attribute name to test
+* @returns Whether the name has uppercase characters
+*/
+function hasUpperCaseCharacter(name$2) {
+	return name$2.toLowerCase() !== name$2;
 }
-function isValidAriaAttribute(name3) {
-  return ARIA_PROPERTIES.some((element) => element === name3);
+/**
+* Checks 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$2) {
+	return ARIA_PROPERTIES.some((element) => element === name$2);
 }
+/**
+* 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) {
-    return node.parent.name.name;
-  }
-  return null;
+	if (node?.parent?.name) return node.parent.name.name;
+	return null;
 }
+/**
+* Checks 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 && node.parent.name.type === "JSXMemberExpression");
+	return !!(node.parent?.name && node.parent.name.type === "JSXMemberExpression");
 }
-function getStandardName(name3, context) {
-  if (has(DOM_ATTRIBUTE_NAMES, name3)) {
-    return DOM_ATTRIBUTE_NAMES[name3];
-  }
-  if (has(SVGDOM_ATTRIBUTE_NAMES, name3)) {
-    return SVGDOM_ATTRIBUTE_NAMES[name3];
-  }
-  const names = getDOMPropertyNames(context);
-  return names.find((element) => element.toLowerCase() === name3.toLowerCase());
-}
-var messages = {
-  dataLowercaseRequired: "React does not recognize data-* props with uppercase characters on a DOM element. Found '{{name}}', use '{{lowerCaseName}}' instead",
-  invalidPropOnTag: "Invalid property '{{name}}' found on tag '{{tagName}}', but it is only allowed on: {{allowedTags}}",
-  unknownProp: "Unknown property '{{name}}' found",
-  unknownPropWithStandardName: "Unknown property '{{name}}' found, use '{{standardName}}' instead"
-};
-var no_unknown_property_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow unknown `DOM` property."
-    },
-    fixable: "code",
-    messages,
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        ignore: {
-          type: "array",
-          items: {
-            type: "string"
-          }
-        },
-        requireDataLowercase: {
-          type: "boolean",
-          default: false
-        }
-      }
-    }]
-  },
-  name: RULE_NAME12,
-  create: create12,
-  defaultOptions: []
-});
-function create12(context) {
-  const report = Reporter.make(context);
-  function getIgnoreConfig() {
-    return context.options[0]?.ignore || DEFAULTS.ignore;
-  }
-  function getRequireDataLowercase() {
-    return context.options[0] && typeof context.options[0].requireDataLowercase !== "undefined" ? !!context.options[0].requireDataLowercase : DEFAULTS.requireDataLowercase;
-  }
-  return {
-    JSXAttribute(node) {
-      const ignoreNames = getIgnoreConfig();
-      const actualName = getText(context, node.name);
-      if (ignoreNames.indexOf(actualName) >= 0) {
-        return;
-      }
-      const name3 = normalizeAttributeCase(actualName);
-      if (tagNameHasDot(node)) {
-        return;
-      }
-      if (isValidDataAttribute(name3)) {
-        if (getRequireDataLowercase() && hasUpperCaseCharacter(name3)) {
-          report.send({
-            node,
-            messageId: "dataLowercaseRequired",
-            data: {
-              name: actualName,
-              lowerCaseName: actualName.toLowerCase()
-            }
-          });
-        }
-        return;
-      }
-      if (isValidAriaAttribute(name3)) return;
-      const tagName = getTagName(node);
-      if (tagName === "fbt" || tagName === "fbs") return;
-      if (!isValidHTMLTagInJSX(node)) return;
-      const allowedTags = has(ATTRIBUTE_TAGS_MAP, name3) ? ATTRIBUTE_TAGS_MAP[name3] : null;
-      if (tagName && allowedTags) {
-        if (allowedTags.indexOf(tagName) === -1) {
-          report.send({
-            node,
-            messageId: "invalidPropOnTag",
-            data: {
-              name: actualName,
-              allowedTags: allowedTags.join(", "),
-              tagName
-            }
-          });
-        }
-        return;
-      }
-      const standardName = getStandardName(name3, context);
-      const hasStandardNameButIsNotUsed = standardName && standardName !== name3;
-      const usesStandardName = standardName && standardName === name3;
-      if (usesStandardName) {
-        return;
-      }
-      if (hasStandardNameButIsNotUsed) {
-        report.send({
-          node,
-          messageId: "unknownPropWithStandardName",
-          data: {
-            name: actualName,
-            standardName
-          },
-          fix(fixer) {
-            return fixer.replaceText(node.name, standardName);
-          }
-        });
-        return;
-      }
-      report.send({
-        node,
-        messageId: "unknownProp",
-        data: {
-          name: actualName
-        }
-      });
-    }
-  };
+/**
+* Gets the standard name of an attribute
+* @param name - Attribute name
+* @param context - ESLint context
+* @returns Standard name or undefined
+*/
+function getStandardName(name$2, context) {
+	if (has(DOM_ATTRIBUTE_NAMES, name$2)) return DOM_ATTRIBUTE_NAMES[name$2];
+	if (has(SVGDOM_ATTRIBUTE_NAMES, name$2)) return SVGDOM_ATTRIBUTE_NAMES[name$2];
+	return getDOMPropertyNames(context).find((element) => element.toLowerCase() === name$2.toLowerCase());
 }
+/**
+* Checks 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);
+	return Object.hasOwn(obj, key);
 }
+/**
+* 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);
+	return context.sourceCode.getText(node);
+}
+/**
+* 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$1) {
+	const { version: localVersion } = getSettingsFromContext(context);
+	return compare(localVersion, version$1, comparator);
 }
-function testReactVersion(context, comparator, version2) {
-  const { version: localVersion } = getSettingsFromContext(context);
-  return compare(localVersion, version2, comparator);
+const messages = {
+	dataLowercaseRequired: "React does not recognize data-* props with uppercase characters on a DOM element. Found '{{name}}', use '{{lowerCaseName}}' instead",
+	invalidPropOnTag: "Invalid property '{{name}}' found on tag '{{tagName}}', but it is only allowed on: {{allowedTags}}",
+	unknownProp: "Unknown property '{{name}}' found",
+	unknownPropWithStandardName: "Unknown property '{{name}}' found, use '{{standardName}}' instead"
+};
+var no_unknown_property_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow unknown `DOM` property." },
+		fixable: "code",
+		messages,
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				ignore: {
+					type: "array",
+					items: { type: "string" }
+				},
+				requireDataLowercase: {
+					type: "boolean",
+					default: false
+				}
+			}
+		}]
+	},
+	name: RULE_NAME$4,
+	create: create$4,
+	defaultOptions: []
+});
+/**
+* Create function for the ESLint rule
+* @param context - ESLint rule context
+* @returns Rule listener
+*/
+function create$4(context) {
+	/**
+	* Gets the ignore configuration from rule options
+	* @returns Array of attribute names to ignore
+	*/
+	function getIgnoreConfig() {
+		return context.options[0]?.ignore || DEFAULTS.ignore;
+	}
+	/**
+	* Gets the requireDataLowercase option from rule options
+	* @returns Whether data attributes must be lowercase
+	*/
+	function getRequireDataLowercase() {
+		return context.options[0] && typeof context.options[0].requireDataLowercase !== "undefined" ? !!context.options[0].requireDataLowercase : DEFAULTS.requireDataLowercase;
+	}
+	return { JSXAttribute(node) {
+		const ignoreNames = getIgnoreConfig();
+		const actualName = getText(context, node.name);
+		if (ignoreNames.indexOf(actualName) >= 0) return;
+		const name$2 = normalizeAttributeCase(actualName);
+		if (tagNameHasDot(node)) return;
+		if (isValidDataAttribute(name$2)) {
+			if (getRequireDataLowercase() && hasUpperCaseCharacter(name$2)) context.report({
+				node,
+				messageId: "dataLowercaseRequired",
+				data: {
+					name: actualName,
+					lowerCaseName: actualName.toLowerCase()
+				}
+			});
+			return;
+		}
+		if (isValidAriaAttribute(name$2)) return;
+		const tagName = getTagName(node);
+		if (tagName === "fbt" || tagName === "fbs") return;
+		if (!isValidHTMLTagInJSX(node)) return;
+		const allowedTags = has(ATTRIBUTE_TAGS_MAP, name$2) ? ATTRIBUTE_TAGS_MAP[name$2] : null;
+		if (tagName && allowedTags) {
+			if (allowedTags.indexOf(tagName) === -1) context.report({
+				node,
+				messageId: "invalidPropOnTag",
+				data: {
+					name: actualName,
+					allowedTags: allowedTags.join(", "),
+					tagName
+				}
+			});
+			return;
+		}
+		const standardName = getStandardName(name$2, context);
+		const hasStandardNameButIsNotUsed = !!standardName && standardName !== name$2;
+		if (!!standardName && standardName === name$2) return;
+		if (hasStandardNameButIsNotUsed) {
+			context.report({
+				node,
+				messageId: "unknownPropWithStandardName",
+				data: {
+					name: actualName,
+					standardName
+				},
+				fix(fixer) {
+					return fixer.replaceText(node.name, standardName);
+				}
+			});
+			return;
+		}
+		context.report({
+			node,
+			messageId: "unknownProp",
+			data: { name: actualName }
+		});
+	} };
 }
 
-// src/rules/no-unsafe-iframe-sandbox.ts
-var RULE_NAME13 = "no-unsafe-iframe-sandbox";
-var RULE_FEATURES12 = [];
-var unsafeSandboxValues = [
-  ["allow-scripts", "allow-same-origin"]
-];
+//#endregion
+//#region src/rules/no-unsafe-iframe-sandbox.ts
+const RULE_NAME$3 = "no-unsafe-iframe-sandbox";
+const RULE_FEATURES$3 = [];
+const unsafeSandboxValues = [["allow-scripts", "allow-same-origin"]];
 function isSafeSandbox(value) {
-  if (typeof value !== "string") return false;
-  return !unsafeSandboxValues.some((values) => {
-    return values.every((v) => value.includes(v));
-  });
+	if (typeof value !== "string") return false;
+	return !unsafeSandboxValues.some((values) => {
+		return values.every((v) => value.includes(v));
+	});
 }
 var no_unsafe_iframe_sandbox_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforces `sandbox` attribute for `iframe` elements is not set to unsafe combinations.",
-      [Symbol.for("rule_features")]: RULE_FEATURES12
-    },
-    messages: {
-      noUnsafeIframeSandbox: "Unsafe 'sandbox' attribute value on 'iframe' component."
-    },
-    schema: []
-  },
-  name: RULE_NAME13,
-  create: create13,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforces `sandbox` attribute for `iframe` elements is not set to unsafe combinations.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$3
+		},
+		messages: { noUnsafeIframeSandbox: "Unsafe 'sandbox' attribute value on 'iframe' component." },
+		schema: []
+	},
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: []
 });
-function create13(context) {
-  const resolver = createJsxElementResolver(context);
-  return {
-    JSXElement(node) {
-      const { attributes, domElementType } = resolver.resolve(node);
-      if (domElementType !== "iframe") return;
-      const sandboxAttribute = resolveAttribute(context, attributes, node, "sandbox");
-      if (!isSafeSandbox(sandboxAttribute.attributeValueString)) {
-        context.report({
-          messageId: "noUnsafeIframeSandbox",
-          node: sandboxAttribute.attributeValue?.node ?? sandboxAttribute.attribute ?? node
-        });
-      }
-    }
-  };
+function create$3(context) {
+	const resolver = createJsxElementResolver(context);
+	return { JSXElement(node) {
+		const { domElementType } = resolver.resolve(node);
+		if (domElementType !== "iframe") return;
+		const sandboxAttribute = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("sandbox");
+		if (sandboxAttribute == null) return;
+		const sandboxValue = ER.resolveAttributeValue(context, sandboxAttribute);
+		const sandboxValueStatic = sandboxValue.toStatic("sandbox");
+		if (!isSafeSandbox(sandboxValueStatic)) context.report({
+			messageId: "noUnsafeIframeSandbox",
+			node: sandboxValue.node ?? sandboxAttribute
+		});
+	} };
 }
 
-// src/rules/no-unsafe-target-blank.ts
-var RULE_NAME14 = "no-unsafe-target-blank";
-var RULE_FEATURES13 = [
-  "FIX"
-];
+//#endregion
+//#region src/rules/no-unsafe-target-blank.ts
+const RULE_NAME$2 = "no-unsafe-target-blank";
+const RULE_FEATURES$2 = ["FIX"];
+/**
+* Checks 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 (value == null) return false;
-  return value.startsWith("https://") || /^(?:\w+:|\/\/)/u.test(value);
+	if (typeof value !== "string") return false;
+	return value.startsWith("https://") || /^(?:\w+:|\/\/)/u.test(value);
 }
+/**
+* Checks if a rel attribute value contains the necessary security attributes.
+* At minimum, it should contain "noreferrer".
+* @param value - The rel attribute value to check
+* @returns Whether the rel value is considered secure
+*/
 function isSafeRel(value) {
-  if (value == null) return false;
-  return value === "noreferrer" || /\bnoreferrer\b/u.test(value);
+	if (typeof value !== "string") return false;
+	return value === "noreferrer" || /\bnoreferrer\b/u.test(value);
 }
 var no_unsafe_target_blank_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: 'Disallow `target="_blank"` without `rel="noreferrer noopener"`.',
-      [Symbol.for("rule_features")]: RULE_FEATURES13
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      addRelNoreferrerNoopener: `Add 'rel="noreferrer noopener"' to the link to prevent security risks.`,
-      noUnsafeTargetBlank: `Using 'target="_blank"' on an external link without 'rel="noreferrer noopener"' is a security risk.`
-    },
-    schema: []
-  },
-  name: RULE_NAME14,
-  create: create14,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `target=\"_blank\"` without `rel=\"noreferrer noopener\"`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$2
+		},
+		fixable: "code",
+		hasSuggestions: true,
+		messages: {
+			addRelNoreferrerNoopener: `Add 'rel="noreferrer noopener"' to the link to prevent security risks.`,
+			noUnsafeTargetBlank: `Using 'target="_blank"' on an external link without 'rel="noreferrer noopener"' is a security risk.`
+		},
+		schema: []
+	},
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: []
 });
-function create14(context) {
-  const resolver = createJsxElementResolver(context);
-  return {
-    JSXElement(node) {
-      const { attributes, domElementType } = resolver.resolve(node);
-      if (domElementType !== "a") return;
-      const targetAttribute = resolveAttribute(context, attributes, node, "target");
-      if (targetAttribute.attributeValueString !== "_blank") {
-        return;
-      }
-      const hrefAttribute = resolveAttribute(context, attributes, node, "href");
-      if (!isExternalLinkLike(hrefAttribute.attributeValueString)) {
-        return;
-      }
-      const relAttribute = resolveAttribute(context, attributes, node, "rel");
-      if (isSafeRel(relAttribute.attributeValueString)) {
-        return;
-      }
-      if (relAttribute.attribute == null) {
-        context.report({
-          messageId: "noUnsafeTargetBlank",
-          node: node.openingElement,
-          suggest: [{
-            messageId: "addRelNoreferrerNoopener",
-            fix(fixer) {
-              return fixer.insertTextAfter(
-                node.openingElement.name,
-                ` ${relAttribute.attributeName}="noreferrer noopener"`
-              );
-            }
-          }]
-        });
-        return;
-      }
-      context.report({
-        messageId: "noUnsafeTargetBlank",
-        node: relAttribute.attributeValue?.node ?? relAttribute.attribute,
-        suggest: [{
-          messageId: "addRelNoreferrerNoopener",
-          fix(fixer) {
-            if (relAttribute.attribute == null) return null;
-            return fixer.replaceText(relAttribute.attribute, `${relAttribute.attributeName}="noreferrer noopener"`);
-          }
-        }]
-      });
-    }
-  };
+function create$2(context) {
+	const resolver = createJsxElementResolver(context);
+	return { JSXElement(node) {
+		const { domElementType } = resolver.resolve(node);
+		if (domElementType !== "a") return;
+		const getAttributes = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node));
+		const targetAttribute = getAttributes("target");
+		if (targetAttribute == null) return;
+		if (ER.resolveAttributeValue(context, targetAttribute).toStatic("target") !== "_blank") return;
+		const hrefAttribute = getAttributes("href");
+		if (hrefAttribute == null) return;
+		const hrefAttributeValue = ER.resolveAttributeValue(context, hrefAttribute).toStatic("href");
+		if (!isExternalLinkLike(hrefAttributeValue)) return;
+		const relAttribute = getAttributes("rel");
+		if (relAttribute == null) {
+			context.report({
+				messageId: "noUnsafeTargetBlank",
+				node: node.openingElement,
+				suggest: [{
+					messageId: "addRelNoreferrerNoopener",
+					fix(fixer) {
+						return fixer.insertTextAfter(node.openingElement.name, ` rel="noreferrer noopener"`);
+					}
+				}]
+			});
+			return;
+		}
+		const relAttributeValue = ER.resolveAttributeValue(context, relAttribute).toStatic("rel");
+		if (isSafeRel(relAttributeValue)) return;
+		context.report({
+			messageId: "noUnsafeTargetBlank",
+			node: relAttribute,
+			suggest: [{
+				messageId: "addRelNoreferrerNoopener",
+				fix(fixer) {
+					return fixer.replaceText(relAttribute, `rel="noreferrer noopener"`);
+				}
+			}]
+		});
+	} };
 }
-var RULE_NAME15 = "no-use-form-state";
-var RULE_FEATURES14 = [
-  "MOD"
-];
+
+//#endregion
+//#region src/rules/no-use-form-state.ts
+const RULE_NAME$1 = "no-use-form-state";
+const RULE_FEATURES$1 = ["MOD"];
 var no_use_form_state_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Replaces usages of `useFormState` with `useActionState`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES14
-    },
-    fixable: "code",
-    messages: {
-      noUseFormState: "[Deprecated] Use 'useActionState' from 'react' package instead."
-    },
-    schema: []
-  },
-  name: RULE_NAME15,
-  create: create15,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Replaces usages of `useFormState` with `useActionState`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES$1
+		},
+		fixable: "code",
+		messages: { noUseFormState: "[Deprecated] Use 'useActionState' from 'react' package instead." },
+		schema: []
+	},
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: []
 });
-function create15(context) {
-  if (!context.sourceCode.text.includes("useFormState")) return {};
-  const settings2 = getSettingsFromContext(context);
-  if (compare(settings2.version, "19.0.0", "<")) return {};
-  const reactDomNames = /* @__PURE__ */ new Set();
-  const useFormStateNames = /* @__PURE__ */ new Set();
-  return {
-    CallExpression(node) {
-      switch (true) {
-        case (node.callee.type === AST_NODE_TYPES.Identifier && useFormStateNames.has(node.callee.name)):
-          context.report({
-            messageId: "noUseFormState",
-            node,
-            fix: getFix3(context, node)
-          });
-          return;
-        case (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "useFormState" && reactDomNames.has(node.callee.object.name)):
-          context.report({
-            messageId: "noUseFormState",
-            node,
-            fix: getFix3(context, node)
-          });
-          return;
-      }
-    },
-    ImportDeclaration(node) {
-      const [baseSource] = node.source.value.split("/");
-      if (baseSource !== "react-dom") return;
-      for (const specifier of node.specifiers) {
-        switch (specifier.type) {
-          case AST_NODE_TYPES.ImportSpecifier:
-            if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
-            if (specifier.imported.name === "useFormState") {
-              useFormStateNames.add(specifier.local.name);
-            }
-            continue;
-          case AST_NODE_TYPES.ImportDefaultSpecifier:
-          case AST_NODE_TYPES.ImportNamespaceSpecifier:
-            reactDomNames.add(specifier.local.name);
-            continue;
-        }
-      }
-    }
-  };
+function create$1(context) {
+	if (!context.sourceCode.text.includes("useFormState")) return {};
+	const settings$1 = getSettingsFromContext(context);
+	if (compare(settings$1.version, "19.0.0", "<")) return {};
+	const reactDomNames = /* @__PURE__ */ new Set();
+	const useFormStateNames = /* @__PURE__ */ new Set();
+	return {
+		CallExpression(node) {
+			switch (true) {
+				case node.callee.type === AST_NODE_TYPES.Identifier && useFormStateNames.has(node.callee.name):
+					context.report({
+						messageId: "noUseFormState",
+						node,
+						fix: getFix(context, node)
+					});
+					return;
+				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "useFormState" && reactDomNames.has(node.callee.object.name):
+					context.report({
+						messageId: "noUseFormState",
+						node,
+						fix: getFix(context, node)
+					});
+					return;
+			}
+		},
+		ImportDeclaration(node) {
+			const [baseSource] = node.source.value.split("/");
+			if (baseSource !== "react-dom") return;
+			for (const specifier of node.specifiers) switch (specifier.type) {
+				case AST_NODE_TYPES.ImportSpecifier:
+					if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
+					if (specifier.imported.name === "useFormState") useFormStateNames.add(specifier.local.name);
+					continue;
+				case AST_NODE_TYPES.ImportDefaultSpecifier:
+				case AST_NODE_TYPES.ImportNamespaceSpecifier:
+					reactDomNames.add(specifier.local.name);
+					continue;
+			}
+		}
+	};
 }
-function getFix3(context, node) {
-  const { importSource } = getSettingsFromContext(context);
-  return (fixer) => {
-    return [
-      fixer.insertTextBefore(context.sourceCode.ast, `import { useActionState } from "${importSource}";
-`),
-      fixer.replaceText(node.callee, "useActionState")
-    ];
-  };
+function getFix(context, node) {
+	const { importSource } = getSettingsFromContext(context);
+	return (fixer) => {
+		return [fixer.insertTextBefore(context.sourceCode.ast, `import { useActionState } from "${importSource}";\n`), fixer.replaceText(node.callee, "useActionState")];
+	};
 }
-var RULE_NAME16 = "no-void-elements-with-children";
-var RULE_FEATURES15 = [];
-var voidElements = /* @__PURE__ */ new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "keygen",
-  "link",
-  "menuitem",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
+
+//#endregion
+//#region src/rules/no-void-elements-with-children.ts
+const RULE_NAME = "no-void-elements-with-children";
+const RULE_FEATURES = [];
+const voidElements = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"menuitem",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
 ]);
 var no_void_elements_with_children_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `children` in void DOM elements.",
-      [Symbol.for("rule_features")]: RULE_FEATURES15
-    },
-    messages: {
-      noVoidElementsWithChildren: "'{{element}}' is a void element tag and must not have children."
-    },
-    schema: []
-  },
-  name: RULE_NAME16,
-  create: create16,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow `children` in void DOM elements.",
+			[Symbol.for("rule_features")]: RULE_FEATURES
+		},
+		messages: { noVoidElementsWithChildren: "'{{element}}' is a void element tag and must not have children." },
+		schema: []
+	},
+	name: RULE_NAME,
+	create,
+	defaultOptions: []
 });
-function create16(context) {
-  const resolver = createJsxElementResolver(context);
-  return {
-    JSXElement(node) {
-      const { domElementType: elementName } = resolver.resolve(node);
-      if (elementName.length === 0 || !voidElements.has(elementName)) {
-        return;
-      }
-      if (node.children.length > 0) {
-        context.report({
-          messageId: "noVoidElementsWithChildren",
-          node,
-          data: {
-            element: elementName
-          }
-        });
-      }
-      const { attributes } = node.openingElement;
-      const initialScope = context.sourceCode.getScope(node);
-      const hasAttribute3 = (name3) => ER.hasAttribute(context, name3, attributes, initialScope);
-      if (hasAttribute3("children") || hasAttribute3("dangerouslySetInnerHTML")) {
-        context.report({
-          messageId: "noVoidElementsWithChildren",
-          node,
-          data: {
-            element: elementName
-          }
-        });
-      }
-    }
-  };
+function create(context) {
+	const resolver = createJsxElementResolver(context);
+	return { JSXElement(node) {
+		const { domElementType: elementName } = resolver.resolve(node);
+		if (elementName.length === 0 || !voidElements.has(elementName)) return;
+		if (node.children.length > 0) context.report({
+			messageId: "noVoidElementsWithChildren",
+			node,
+			data: { element: elementName }
+		});
+		const { attributes } = node.openingElement;
+		const initialScope = context.sourceCode.getScope(node);
+		const hasAttribute = (name$2) => ER.hasAttribute(context, name$2, attributes, initialScope);
+		if (hasAttribute("children") || hasAttribute("dangerouslySetInnerHTML")) context.report({
+			messageId: "noVoidElementsWithChildren",
+			node,
+			data: { element: elementName }
+		});
+	} };
 }
 
-// src/plugin.ts
-var plugin = {
-  meta: {
-    name: name2,
-    version
-  },
-  rules: {
-    "no-dangerously-set-innerhtml": no_dangerously_set_innerhtml_default,
-    "no-dangerously-set-innerhtml-with-children": no_dangerously_set_innerhtml_with_children_default,
-    "no-find-dom-node": no_find_dom_node_default,
-    "no-flush-sync": no_flush_sync_default,
-    "no-hydrate": no_hydrate_default,
-    "no-missing-button-type": no_missing_button_type_default,
-    "no-missing-iframe-sandbox": no_missing_iframe_sandbox_default,
-    "no-namespace": no_namespace_default,
-    "no-render": no_render_default,
-    "no-render-return-value": no_render_return_value_default,
-    "no-script-url": no_script_url_default,
-    "no-unknown-property": no_unknown_property_default,
-    "no-unsafe-iframe-sandbox": no_unsafe_iframe_sandbox_default,
-    "no-unsafe-target-blank": no_unsafe_target_blank_default,
-    "no-use-form-state": no_use_form_state_default,
-    "no-void-elements-with-children": no_void_elements_with_children_default
-  }
+//#endregion
+//#region src/plugin.ts
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules: {
+		"no-dangerously-set-innerhtml": no_dangerously_set_innerhtml_default,
+		"no-dangerously-set-innerhtml-with-children": no_dangerously_set_innerhtml_with_children_default,
+		"no-find-dom-node": no_find_dom_node_default,
+		"no-flush-sync": no_flush_sync_default,
+		"no-hydrate": no_hydrate_default,
+		"no-missing-button-type": no_missing_button_type_default,
+		"no-missing-iframe-sandbox": no_missing_iframe_sandbox_default,
+		"no-namespace": no_namespace_default,
+		"no-render": no_render_default,
+		"no-render-return-value": no_render_return_value_default,
+		"no-script-url": no_script_url_default,
+		"no-string-style-prop": no_string_style_prop_default,
+		"no-unknown-property": no_unknown_property_default,
+		"no-unsafe-iframe-sandbox": no_unsafe_iframe_sandbox_default,
+		"no-unsafe-target-blank": no_unsafe_target_blank_default,
+		"no-use-form-state": no_use_form_state_default,
+		"no-void-elements-with-children": no_void_elements_with_children_default
+	}
 };
 
-// src/index.ts
-function makeConfig(config) {
-  return {
-    ...config,
-    plugins: {
-      "react-dom": plugin
-    }
-  };
-}
-function makeLegacyConfig({ rules: rules2 }) {
-  return {
-    plugins: ["react-dom"],
-    rules: rules2
-  };
-}
-var index_default = {
-  ...plugin,
-  configs: {
-    ["recommended"]: makeConfig(recommended_exports),
-    ["recommended-legacy"]: makeLegacyConfig(recommended_exports)
-  }
+//#endregion
+//#region src/index.ts
+const { toFlatConfig } = getConfigAdapters("react-dom", plugin);
+var src_default = {
+	...plugin,
+	configs: { ["recommended"]: toFlatConfig(recommended_exports) }
 };
 
-export { index_default as default };
+//#endregion
+export { src_default as default };