@flint.fyi/jsx 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -0,0 +1,3235 @@
+import { RuleCreator, createPlugin } from "@flint.fyi/core";
+import { SyntaxKind } from "typescript";
+import { getStaticStringValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { nullThrows } from "@flint.fyi/utils";
+import languageTags from "language-tags";
+//#region src/rules/ruleCreator.ts
+const ruleCreator = new RuleCreator({
+	docs: (ruleId) => `https://flint.fyi/rules/jsx/${ruleId.toLowerCase()}`,
+	pluginId: "jsx",
+	presets: [
+		"logical",
+		"logicalStrict",
+		"stylistic"
+	]
+});
+//#endregion
+//#region src/rules/accessKeys.ts
+var accessKeys_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow the use of the `accessKey` / `accesskey` attribute on JSX elements.",
+		id: "accessKeys",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { avoidAccessKey: {
+		primary: "The native DOM `{{ attribute }}` prop causes accessibility issues with keyboard-only users and screen readers.",
+		secondary: ["Access keys are inconsistent across browsers and can interfere with assistive technologies.", "Although they may work in limited use cases, it's best to avoid them."],
+		suggestions: ["Remove the attribute and provide a documented, configurable keyboard shortcut instead."]
+	} },
+	setup(context) {
+		return { visitors: { JsxAttribute(node, { sourceFile }) {
+			if (node.name.kind !== SyntaxKind.Identifier) return;
+			const attribute = node.name.text;
+			if (attribute.toLowerCase() !== "accesskey") return;
+			context.report({
+				data: { attribute },
+				message: "avoidAccessKey",
+				range: getTSNodeRange(node.name, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/altTexts.ts
+const alternateProperties = /* @__PURE__ */ new Set([
+	"aria-label",
+	"aria-labelledby",
+	"title"
+]);
+var altTexts_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports elements that require alt text but are missing it.",
+		id: "altTexts",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingAlt: {
+		primary: "{{ element }} element is missing alt text for non-visual users.",
+		secondary: [
+			"Alternative text provides a textual description for images and other media.",
+			"Screen readers use this text to describe the element to users who cannot see it.",
+			"This is required for WCAG 1.1.1 compliance."
+		],
+		suggestions: [
+			"Add an alt attribute with descriptive text",
+			"Use alt=\"\" for decorative images",
+			"Use aria-label or aria-labelledby for alternative labeling"
+		]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			const { attributes, tagName } = node;
+			if (tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = tagName.text.toLowerCase();
+			if (elementName === "img" || elementName === "area") checkAltAttribute(attributes, tagName, elementName, sourceFile);
+			else if (elementName === "input") checkInputElement(attributes, tagName, sourceFile);
+			else if (elementName === "object") checkObjectAccessibility(attributes, tagName, sourceFile);
+		}
+		function checkAltAttribute(attributes, tagName, elementName, sourceFile) {
+			const properties = attributes.properties.find((attr) => attr.kind === SyntaxKind.JsxAttribute && attr.name.kind === SyntaxKind.Identifier && attr.name.text === "alt");
+			if (attributes.properties.some((attr) => attr.kind === SyntaxKind.JsxAttribute && attr.name.kind === SyntaxKind.Identifier && (attr.name.text === "aria-label" || attr.name.text === "aria-labelledby") && attr.initializer)) return;
+			if (!properties) {
+				context.report({
+					data: { element: elementName },
+					message: "missingAlt",
+					range: getTSNodeRange(tagName, sourceFile)
+				});
+				return;
+			}
+			if (properties.kind === SyntaxKind.JsxAttribute && properties.initializer?.kind === SyntaxKind.JsxExpression) {
+				const { expression } = properties.initializer;
+				if (expression?.kind === SyntaxKind.Identifier && expression.text === "undefined") context.report({
+					data: { element: elementName },
+					message: "missingAlt",
+					range: getTSNodeRange(tagName, sourceFile)
+				});
+			}
+		}
+		function checkInputElement(attributes, tagName, sourceFile) {
+			const typeAttribute = attributes.properties.find((properties) => properties.kind === SyntaxKind.JsxAttribute && properties.name.kind === SyntaxKind.Identifier && properties.name.text === "type");
+			if (typeAttribute?.kind === SyntaxKind.JsxAttribute && typeAttribute.initializer?.kind === SyntaxKind.StringLiteral && typeAttribute.initializer.text === "image") checkAltAttribute(attributes, tagName, "input[type='image']", sourceFile);
+		}
+		function checkObjectAccessibility(attributes, tagName, sourceFile) {
+			if (!attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && alternateProperties.has(property.name.text) && property.initializer)) context.report({
+				data: { element: "object" },
+				message: "missingAlt",
+				range: getTSNodeRange(tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkNode,
+			JsxSelfClosingElement: checkNode
+		} };
+	}
+});
+//#endregion
+//#region src/rules/anchorAmbiguousText.ts
+const ambiguousWords = /* @__PURE__ */ new Set([
+	"a link",
+	"click here",
+	"here",
+	"learn more",
+	"link",
+	"more",
+	"read more"
+]);
+var anchorAmbiguousText_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports anchor elements with ambiguous text that doesn't describe the link destination.",
+		id: "anchorAmbiguousText",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { ambiguousText: {
+		primary: "This anchor element has ambiguous text that doesn't describe the link destination.",
+		secondary: [
+			"Ambiguous text like '{{ text }}' doesn't provide context about where the link goes.",
+			"Screen reader users often navigate by links and need descriptive text to understand the purpose.",
+			"Provide descriptive text that explains what the link does or where it leads."
+		],
+		suggestions: [
+			"Replace vague text with descriptive text that explains the link destination",
+			"Include the page or section name the link leads to",
+			"Describe the action that will occur when clicking the link"
+		]
+	} },
+	setup(context) {
+		function getTextContent(node) {
+			let text = "";
+			for (const child of node.children) if (child.kind === SyntaxKind.JsxText) text += child.text;
+			else if (child.kind === SyntaxKind.JsxElement) text += getTextContent(child);
+			else if (child.kind === SyntaxKind.JsxExpression && child.expression?.kind === SyntaxKind.StringLiteral) text += child.expression.text;
+			return text;
+		}
+		return { visitors: { JsxElement(node, { sourceFile }) {
+			if (node.openingElement.tagName.kind !== SyntaxKind.Identifier || node.openingElement.tagName.text !== "a") return;
+			const textContent = getTextContent(node);
+			if (!ambiguousWords.has(textContent.toLowerCase().trim())) return;
+			const textNodes = node.children.filter((child) => child.kind === SyntaxKind.JsxText && child.text.trim());
+			context.report({
+				data: { text: textContent.trim() },
+				message: "ambiguousText",
+				range: getTSNodeRange(textNodes[0] ?? node.openingElement, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/anchorContent.ts
+var anchorContent_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports anchor elements without accessible content.",
+		id: "anchorContent",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingContent: {
+		primary: "This anchor element is missing accessible content.",
+		secondary: [
+			"Non-visual tools such as screen readers and search engine crawlers need content to describe links.",
+			"Provide text content, aria-label, aria-labelledby, or title attribute.",
+			"This is required for WCAG 2.4.4 and 4.1.2 compliance."
+		],
+		suggestions: [
+			"Add text content inside the anchor",
+			"Add an aria-label attribute",
+			"Add a title attribute"
+		]
+	} },
+	setup(context) {
+		function hasAccessibleContent(element) {
+			return element.attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && (property.name.text === "aria-label" || property.name.text === "aria-labelledby" || property.name.text === "title") && property.initializer);
+		}
+		function hasTextContent(element) {
+			return element.children.some((child) => {
+				if (child.kind === SyntaxKind.JsxText && child.text.trim()) return true;
+				if (child.kind === SyntaxKind.JsxElement || child.kind === SyntaxKind.JsxSelfClosingElement) {
+					if (!(child.kind === SyntaxKind.JsxElement ? child.openingElement : child).attributes.properties.some((attr) => attr.kind === SyntaxKind.JsxAttribute && attr.name.kind === SyntaxKind.Identifier && attr.name.text === "aria-hidden")) return true;
+				}
+				if (child.kind === SyntaxKind.JsxExpression && child.expression) return true;
+			});
+		}
+		return { visitors: {
+			JsxElement(node, { sourceFile }) {
+				const openingElement = node.openingElement;
+				if (openingElement.tagName.kind === SyntaxKind.Identifier && openingElement.tagName.text === "a" && !hasAccessibleContent(openingElement) && !hasTextContent(node)) context.report({
+					message: "missingContent",
+					range: getTSNodeRange(openingElement, sourceFile)
+				});
+			},
+			JsxSelfClosingElement(node, { sourceFile }) {
+				if (node.tagName.kind === SyntaxKind.Identifier && node.tagName.text === "a" && !hasAccessibleContent(node)) context.report({
+					message: "missingContent",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/anchorValidity.ts
+var anchorValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid usage of anchor elements.",
+		id: "anchorValidity",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		invalidHref: {
+			primary: "Anchor has an invalid href value '{{ href }}'.",
+			secondary: [
+				"Anchors should navigate to valid URLs or page sections.",
+				"Use a button element for click handlers without navigation.",
+				"This is required for WCAG 2.4.4 compliance."
+			],
+			suggestions: ["Use a valid URL or fragment identifier", "Use a <button> element instead"]
+		},
+		missingHref: {
+			primary: "Anchor element is missing an href attribute.",
+			secondary: [
+				"Anchors without href are not keyboard accessible.",
+				"Use a button element for actions without navigation.",
+				"This is required for WCAG 4.1.2 compliance."
+			],
+			suggestions: ["Add a valid href attribute", "Use a <button> element instead"]
+		},
+		shouldBeButton: {
+			primary: "Anchor with onClick handler should be a button.",
+			secondary: [
+				"Interactive elements without valid href should use button elements.",
+				"Buttons provide better semantics and keyboard accessibility.",
+				"This is required for WCAG 4.1.2 compliance."
+			],
+			suggestions: ["Replace <a> with <button>"]
+		}
+	},
+	setup(context) {
+		function getHrefValue(attributes) {
+			const hrefProperty = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "href");
+			if (hrefProperty?.kind !== SyntaxKind.JsxAttribute) return;
+			if (hrefProperty.initializer?.kind === SyntaxKind.StringLiteral) return hrefProperty.initializer.text;
+			return "";
+		}
+		function hasOnClick(attributes) {
+			return attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "onClick");
+		}
+		function isInvalidHref(href) {
+			return href === "#" || href.startsWith("javascript:");
+		}
+		function checkAnchor(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text !== "a") return;
+			const href = getHrefValue(node.attributes);
+			const hasClick = hasOnClick(node.attributes);
+			if (href === void 0) {
+				context.report({
+					message: hasClick ? "shouldBeButton" : "missingHref",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+			if (typeof href === "string" && isInvalidHref(href)) context.report({
+				data: { href },
+				message: hasClick ? "shouldBeButton" : "invalidHref",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkAnchor,
+			JsxSelfClosingElement: checkAnchor
+		} };
+	}
+});
+//#endregion
+//#region src/rules/ariaActiveDescendantTabIndex.ts
+const inherentlyTabbableElements = /* @__PURE__ */ new Set([
+	"a",
+	"area",
+	"button",
+	"input",
+	"select",
+	"textarea"
+]);
+var ariaActiveDescendantTabIndex_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports elements with aria-activedescendant without tabIndex.",
+		id: "ariaActiveDescendantTabIndex",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingTabIndex: {
+		primary: "This element with `aria-activedescendant` is missing a `tabIndex` attribute to manage focus state.",
+		secondary: [
+			"aria-activedescendant is used to manage focus within a composite widget.",
+			"The element must be tabbable, either with an inherent tabIndex or explicit tabIndex attribute.",
+			"Without it, keyboard users cannot reach the element."
+		],
+		suggestions: ["Add tabIndex=\"0\" to make the element tabbable", "Add tabIndex=\"-1\" to make it programmatically focusable"]
+	} },
+	setup(context) {
+		function checkElement({ attributes, tagName }, { sourceFile }) {
+			if (tagName.kind === SyntaxKind.Identifier) {
+				const firstCharacter = tagName.text.charAt(0);
+				if (firstCharacter === firstCharacter.toUpperCase() && firstCharacter !== firstCharacter.toLowerCase()) return;
+			}
+			if (!attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "aria-activedescendant" && property.initializer)) return;
+			if (tagName.kind === SyntaxKind.Identifier && inherentlyTabbableElements.has(tagName.text.toLowerCase())) return;
+			if (!attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "tabindex")) {
+				const ariaProperty = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "aria-activedescendant");
+				if (ariaProperty?.kind === SyntaxKind.JsxAttribute) context.report({
+					message: "missingTabIndex",
+					range: getTSNodeRange(ariaProperty, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/ariaHiddenFocusables.ts
+const focusableElements = /* @__PURE__ */ new Set([
+	"a",
+	"audio",
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"video"
+]);
+var ariaHiddenFocusables_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports elements with aria-hidden='true' that are focusable.",
+		id: "ariaHiddenFocusables",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { ariaHiddenFocusable: {
+		primary: "This element has `aria-hidden=\"true\"` but is focusable, which is misleading to users navigating with keyboards.",
+		secondary: ["Elements with aria-hidden='true' should not be reachable via keyboard navigation.", "This creates confusion when users can focus elements they cannot perceive with a screen reader."],
+		suggestions: [
+			"Remove aria-hidden=\"true\"",
+			"Add tabIndex=\"-1\" to remove from focus order",
+			"Use a non-focusable element"
+		]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			const { attributes, tagName } = node;
+			if (tagName.kind !== SyntaxKind.Identifier) return;
+			const ariaHiddenProperty = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "aria-hidden");
+			if (ariaHiddenProperty?.kind !== SyntaxKind.JsxAttribute || !isAriaHiddenTrue(ariaHiddenProperty)) return;
+			const tabIndexValue = findTabIndexValue(node);
+			if (tabIndexValue === -1) return;
+			if (focusableElements.has(tagName.text.toLowerCase()) || tabIndexValue !== void 0 && tabIndexValue >= 0) context.report({
+				message: "ariaHiddenFocusable",
+				range: getTSNodeRange(ariaHiddenProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+function findTabIndexValue(node) {
+	const tabIndexProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "tabindex");
+	if (!tabIndexProperty?.initializer) return;
+	if (tabIndexProperty.initializer.kind === SyntaxKind.JsxExpression) {
+		const expression = tabIndexProperty.initializer.expression;
+		if (expression?.kind === SyntaxKind.NumericLiteral) return Number(expression.text);
+	}
+	if (tabIndexProperty.initializer.kind === SyntaxKind.StringLiteral) return Number(tabIndexProperty.initializer.text);
+}
+function isAriaHiddenTrue(ariaHiddenProperty) {
+	if (!ariaHiddenProperty.initializer) return false;
+	if (ariaHiddenProperty.initializer.kind === SyntaxKind.StringLiteral) return ariaHiddenProperty.initializer.text === "true";
+	if (ariaHiddenProperty.initializer.kind === SyntaxKind.JsxExpression) {
+		if (ariaHiddenProperty.initializer.expression?.kind === SyntaxKind.TrueKeyword) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/rules/ariaProps.ts
+const validAriaProps = /* @__PURE__ */ new Set([
+	"aria-activedescendant",
+	"aria-atomic",
+	"aria-autocomplete",
+	"aria-busy",
+	"aria-checked",
+	"aria-colcount",
+	"aria-colindex",
+	"aria-colspan",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-details",
+	"aria-disabled",
+	"aria-dropeffect",
+	"aria-errormessage",
+	"aria-expanded",
+	"aria-flowto",
+	"aria-grabbed",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-level",
+	"aria-live",
+	"aria-modal",
+	"aria-multiline",
+	"aria-multiselectable",
+	"aria-orientation",
+	"aria-owns",
+	"aria-placeholder",
+	"aria-posinset",
+	"aria-pressed",
+	"aria-readonly",
+	"aria-relevant",
+	"aria-required",
+	"aria-roledescription",
+	"aria-rowcount",
+	"aria-rowindex",
+	"aria-rowspan",
+	"aria-selected",
+	"aria-setsize",
+	"aria-sort",
+	"aria-valuemax",
+	"aria-valuemin",
+	"aria-valuenow",
+	"aria-valuetext"
+]);
+var ariaProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid ARIA properties.",
+		id: "ariaProps",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidAriaProp: {
+		primary: "`{{ prop }}` is not a valid ARIA property and so has no effect on the browser.",
+		secondary: [
+			"This aria-* attribute is not a valid ARIA property according to the WAI-ARIA spec.",
+			"Check the spelling of the property name.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Use a valid property from the WAI-ARIA specification."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propertyName = property.name.text;
+				if (!propertyName.startsWith("aria-")) continue;
+				if (!validAriaProps.has(propertyName.toLowerCase())) context.report({
+					data: { prop: propertyName },
+					message: "invalidAriaProp",
+					range: getTSNodeRange(property.name, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/ariaPropTypes.ts
+const ariaPropertyTypes = {
+	"aria-activedescendant": "id",
+	"aria-atomic": "boolean",
+	"aria-autocomplete": "token",
+	"aria-busy": "boolean",
+	"aria-checked": "tristate",
+	"aria-colcount": "integer",
+	"aria-colindex": "integer",
+	"aria-colspan": "integer",
+	"aria-controls": "idlist",
+	"aria-current": "token",
+	"aria-describedby": "idlist",
+	"aria-details": "id",
+	"aria-disabled": "boolean",
+	"aria-dropeffect": "token",
+	"aria-errormessage": "id",
+	"aria-expanded": "tristate",
+	"aria-flowto": "idlist",
+	"aria-grabbed": "tristate",
+	"aria-haspopup": "token",
+	"aria-hidden": "tristate",
+	"aria-invalid": "token",
+	"aria-keyshortcuts": "string",
+	"aria-label": "string",
+	"aria-labelledby": "idlist",
+	"aria-level": "integer",
+	"aria-live": "token",
+	"aria-modal": "boolean",
+	"aria-multiline": "boolean",
+	"aria-multiselectable": "boolean",
+	"aria-orientation": "token",
+	"aria-owns": "idlist",
+	"aria-placeholder": "string",
+	"aria-posinset": "integer",
+	"aria-pressed": "tristate",
+	"aria-readonly": "boolean",
+	"aria-relevant": "token",
+	"aria-required": "boolean",
+	"aria-roledescription": "string",
+	"aria-rowcount": "integer",
+	"aria-rowindex": "integer",
+	"aria-rowspan": "integer",
+	"aria-selected": "tristate",
+	"aria-setsize": "integer",
+	"aria-sort": "token",
+	"aria-valuemax": "number",
+	"aria-valuemin": "number",
+	"aria-valuenow": "number",
+	"aria-valuetext": "string"
+};
+const tokenValues = {
+	"aria-autocomplete": /* @__PURE__ */ new Set([
+		"both",
+		"inline",
+		"list",
+		"none"
+	]),
+	"aria-current": /* @__PURE__ */ new Set([
+		"date",
+		"false",
+		"location",
+		"page",
+		"step",
+		"time",
+		"true"
+	]),
+	"aria-dropeffect": /* @__PURE__ */ new Set([
+		"copy",
+		"execute",
+		"link",
+		"move",
+		"none",
+		"popup"
+	]),
+	"aria-haspopup": /* @__PURE__ */ new Set([
+		"dialog",
+		"false",
+		"grid",
+		"listbox",
+		"menu",
+		"tree",
+		"true"
+	]),
+	"aria-invalid": /* @__PURE__ */ new Set([
+		"false",
+		"grammar",
+		"spelling",
+		"true"
+	]),
+	"aria-live": /* @__PURE__ */ new Set([
+		"assertive",
+		"off",
+		"polite"
+	]),
+	"aria-orientation": /* @__PURE__ */ new Set([
+		"horizontal",
+		"undefined",
+		"vertical"
+	]),
+	"aria-relevant": /* @__PURE__ */ new Set([
+		"additions",
+		"additions text",
+		"all",
+		"removals",
+		"text"
+	]),
+	"aria-sort": /* @__PURE__ */ new Set([
+		"ascending",
+		"descending",
+		"none",
+		"other"
+	])
+};
+function getAttributeValue(property) {
+	if (!property.initializer) return true;
+	if (property.initializer.kind === SyntaxKind.StringLiteral) return property.initializer.text;
+	if (property.initializer.kind === SyntaxKind.JsxExpression) {
+		const expression = property.initializer.expression;
+		if (!expression) return;
+		if (expression.kind === SyntaxKind.TrueKeyword) return true;
+		if (expression.kind === SyntaxKind.FalseKeyword) return false;
+		if (expression.kind === SyntaxKind.NumericLiteral) return Number(expression.text);
+		if (expression.kind === SyntaxKind.StringLiteral) return expression.text;
+	}
+}
+function getExpectedValueDescription(propertyName, expectedType) {
+	switch (expectedType) {
+		case "boolean": return "true or false";
+		case "id": return "an ID reference";
+		case "idlist": return "a space-separated list of IDs";
+		case "integer": return "an integer";
+		case "number": return "a number";
+		case "string": return "a string";
+		case "token": {
+			const validTokens = tokenValues[propertyName];
+			if (validTokens !== void 0) {
+				const tokens = Array.from(validTokens).sort();
+				return tokens.length > 4 ? `one of: ${tokens.slice(0, 4).join(", ")}, ...` : `one of: ${tokens.join(", ")}`;
+			}
+			return "a valid token value";
+		}
+		case "tristate": return "true, false, or mixed";
+		default: return "a valid value";
+	}
+}
+function isValidPropertyValue(propertyName, value, expectedType) {
+	if (value === void 0) return true;
+	switch (expectedType) {
+		case "boolean": return value === "true" || value === "false" || typeof value === "boolean";
+		case "id": return typeof value === "string" && !!value.length;
+		case "idlist": return typeof value === "string" && !!value.trim().length;
+		case "integer":
+			if (typeof value === "number") return Number.isInteger(value);
+			if (typeof value === "string") {
+				const num = Number(value);
+				return !Number.isNaN(num) && Number.isInteger(num);
+			}
+			return false;
+		case "number":
+			if (typeof value === "number") return !Number.isNaN(value);
+			if (typeof value === "string") {
+				const num = Number(value);
+				return !Number.isNaN(num);
+			}
+			return false;
+		case "string": return typeof value === "string";
+		case "token":
+			if (typeof value !== "string") return false;
+			return tokenValues[propertyName]?.has(value.toLowerCase()) ?? true;
+		case "tristate": return value === "true" || value === "false" || value === "mixed" || typeof value === "boolean";
+		default: return true;
+	}
+}
+var ariaPropTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA properties with invalid value types.",
+		id: "ariaPropTypes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidPropType: {
+		primary: "`{{ prop }}` should have a value of {{ expected }}, but received `{{ actual }}`.",
+		secondary: [
+			"ARIA properties must have values that match their expected type according to the WAI-ARIA specification.",
+			"Invalid property values can confuse assistive technologies and lead to accessibility issues.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Provide a value that matches the expected type for this ARIA property."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propertyName = property.name.text.toLowerCase();
+				if (!propertyName.startsWith("aria-")) continue;
+				const expectedType = ariaPropertyTypes[propertyName];
+				if (expectedType === void 0) continue;
+				const value = getAttributeValue(property);
+				if (isValidPropertyValue(propertyName, value, expectedType)) return;
+				const expected = getExpectedValueDescription(propertyName, expectedType);
+				context.report({
+					data: {
+						actual: String(value),
+						expected,
+						prop: propertyName
+					},
+					message: "invalidPropType",
+					range: property.initializer ? getTSNodeRange(property.initializer, sourceFile) : getTSNodeRange(property.name, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/ariaRoleValidity.ts
+const validAriaRoles = /* @__PURE__ */ new Set([
+	"alert",
+	"alertdialog",
+	"application",
+	"article",
+	"banner",
+	"button",
+	"cell",
+	"checkbox",
+	"columnheader",
+	"combobox",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"dialog",
+	"directory",
+	"document",
+	"feed",
+	"figure",
+	"form",
+	"grid",
+	"gridcell",
+	"group",
+	"heading",
+	"img",
+	"link",
+	"list",
+	"listbox",
+	"listitem",
+	"log",
+	"main",
+	"marquee",
+	"math",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"meter",
+	"navigation",
+	"none",
+	"note",
+	"option",
+	"presentation",
+	"progressbar",
+	"radio",
+	"radiogroup",
+	"region",
+	"row",
+	"rowgroup",
+	"rowheader",
+	"scrollbar",
+	"search",
+	"searchbox",
+	"separator",
+	"slider",
+	"spinbutton",
+	"status",
+	"switch",
+	"tab",
+	"table",
+	"tablist",
+	"tabpanel",
+	"term",
+	"textbox",
+	"timer",
+	"toolbar",
+	"tooltip",
+	"tree",
+	"treegrid",
+	"treeitem"
+]);
+var ariaRoleValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid or abstract ARIA roles.",
+		id: "ariaRoleValidity",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidRole: {
+		primary: "Invalid ARIA role '{{ role }}'. Use a valid, non-abstract role.",
+		secondary: [
+			"ARIA roles must be valid according to the WAI-ARIA specification.",
+			"Abstract roles cannot be used directly in HTML.",
+			"Required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Use a valid ARIA role from the WAI-ARIA specification", "Remove the role attribute if not needed"]
+	} },
+	setup(context) {
+		function checkRole(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() !== node.tagName.text) return;
+			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier);
+			if (roleProperty?.initializer?.kind !== SyntaxKind.StringLiteral) return;
+			const role = roleProperty.initializer.text.trim();
+			if (!role || !validAriaRoles.has(role)) context.report({
+				data: { role: role || "(empty)" },
+				message: "invalidRole",
+				range: getTSNodeRange(roleProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkRole,
+			JsxSelfClosingElement: checkRole
+		} };
+	}
+});
+//#endregion
+//#region src/rules/ariaUnsupportedElements.ts
+const unsupportedElements = /* @__PURE__ */ new Set([
+	"base",
+	"body",
+	"caption",
+	"col",
+	"colgroup",
+	"datalist",
+	"dd",
+	"details",
+	"dialog",
+	"dt",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"frame",
+	"frameset",
+	"head",
+	"header",
+	"hgroup",
+	"html",
+	"iframe",
+	"legend",
+	"link",
+	"main",
+	"meta",
+	"meter",
+	"nav",
+	"noscript",
+	"optgroup",
+	"option",
+	"output",
+	"param",
+	"picture",
+	"progress",
+	"script",
+	"slot",
+	"style",
+	"template",
+	"textarea",
+	"title",
+	"track"
+]);
+var ariaUnsupportedElements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA attributes on elements that don't support them.",
+		id: "ariaUnsupportedElements",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unsupportedElement: {
+		primary: "The `{{ element }}` element does not support ARIA roles, states, or properties.",
+		secondary: [
+			"Certain reserved DOM elements do not support ARIA attributes.",
+			"These elements are often not visible or have specific semantic meaning.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Remove ARIA attributes from this element"]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = node.tagName.text.toLowerCase();
+			if (!unsupportedElements.has(elementName)) return;
+			if (node.attributes.properties.some((property) => {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) return false;
+				const attributeName = property.name.text.toLowerCase();
+				return attributeName === "role" || attributeName.startsWith("aria-");
+			})) context.report({
+				data: { element: elementName },
+				message: "unsupportedElement",
+				range: getTSNodeRange(node.tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/autocomplete.ts
+const validAutocompleteValues = /* @__PURE__ */ new Set([
+	"address-level1",
+	"address-level2",
+	"address-level3",
+	"address-level4",
+	"address-line1",
+	"address-line2",
+	"address-line3",
+	"bday",
+	"bday-day",
+	"bday-month",
+	"bday-year",
+	"cc-additional-name",
+	"cc-csc",
+	"cc-exp",
+	"cc-exp-month",
+	"cc-exp-year",
+	"cc-family-name",
+	"cc-given-name",
+	"cc-name",
+	"cc-number",
+	"cc-type",
+	"country",
+	"country-name",
+	"current-password",
+	"email",
+	"impp",
+	"language",
+	"name",
+	"new-password",
+	"off",
+	"on",
+	"one-time-code",
+	"organization",
+	"organization-title",
+	"photo",
+	"postal-code",
+	"sex",
+	"street-address",
+	"tel",
+	"tel-area-code",
+	"tel-country-code",
+	"tel-extension",
+	"tel-local",
+	"tel-national",
+	"transaction-amount",
+	"transaction-currency",
+	"url",
+	"username",
+	"webauthn"
+]);
+const billingAndShippingValues = /* @__PURE__ */ new Set([
+	"address-level1",
+	"address-level2",
+	"address-level3",
+	"address-level4",
+	"address-line1",
+	"address-line2",
+	"address-line3",
+	"country",
+	"country-name",
+	"postal-code",
+	"street-address"
+]);
+function isValidAutocompleteValue(value) {
+	const parts = value.trim().split(/\s+/);
+	if (parts.length === 1) return validAutocompleteValues.has(nullThrows(parts[0], "First part is expected to be present by prior length check"));
+	if (parts.length === 2) {
+		const [prefix, token] = parts;
+		if (prefix === "billing" || prefix === "shipping") return billingAndShippingValues.has(nullThrows(token, "Second part is expected to be present by prior length check"));
+	}
+	return false;
+}
+var autocomplete_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Ensure the autocomplete attribute is correct and suitable for the form field.",
+		id: "autocomplete",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalid: {
+		primary: "`{{ value }}` is not a valid value for autocomplete.",
+		secondary: [
+			"The autocomplete attribute must use valid tokens from the HTML specification.",
+			"Valid values help browsers and assistive technologies provide better user experiences.",
+			"This is required for WCAG 1.3.5 compliance."
+		],
+		suggestions: [
+			"Use standard autocomplete tokens like 'email', 'name', 'off', or 'tel'",
+			"For address fields, use 'billing' or 'shipping' prefix with appropriate field tokens",
+			"Check the HTML specification for the complete list of valid autocomplete tokens"
+		]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			const { attributes, tagName } = node;
+			if (tagName.kind !== SyntaxKind.Identifier) return;
+			if (tagName.text.toLowerCase() !== "input") return;
+			const autocomplete = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "autocomplete");
+			if (autocomplete?.kind !== SyntaxKind.JsxAttribute || !autocomplete.initializer) return;
+			const value = getStaticStringValue(autocomplete.initializer);
+			if (value === void 0 || isValidAutocompleteValue(value)) return;
+			context.report({
+				data: { value },
+				message: "invalid",
+				range: getTSNodeRange(autocomplete.name, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkNode,
+			JsxSelfClosingElement: checkNode
+		} };
+	}
+});
+//#endregion
+//#region src/rules/autoFocusProps.ts
+var autoFocusProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports autoFocus props that are not set to false.",
+		id: "autoFocusProps",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noAutoFocus: {
+		primary: "The `autoFocus` prop disruptively forces unintuitive focus behavior.",
+		secondary: [
+			"Auto-focusing elements can cause usability issues for sighted and non-sighted users.",
+			"It can be disruptive to users who rely on screen readers or keyboard navigation.",
+			"Consider letting users focus elements manually instead."
+		],
+		suggestions: ["Remove the autoFocus prop", "Set autoFocus to false: autoFocus={false}"]
+	} },
+	setup(context) {
+		function isSetToFalse(property) {
+			if (!property.initializer) return false;
+			if (property.initializer.kind === SyntaxKind.StringLiteral) return true;
+			if (property.initializer.kind === SyntaxKind.JsxExpression) {
+				if (property.initializer.expression?.kind === SyntaxKind.FalseKeyword) return true;
+			}
+			return false;
+		}
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "autofocus" && !isSetToFalse(property)) context.report({
+				message: "noAutoFocus",
+				range: getTSNodeRange(property, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/booleanValues.ts
+var booleanValues_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer shorthand boolean attributes over explicit {true} values in JSX.",
+		id: "booleanValues",
+		presets: ["stylistic"]
+	},
+	messages: { preferShorthand: {
+		primary: "Prefer shorthand boolean attribute `{{ name }}` over explicit `{{ name }}={true}`.",
+		secondary: ["Boolean attributes with explicit `{true}` values are redundant and verbose.", "The shorthand syntax is more concise and idiomatic in JSX."],
+		suggestions: ["Use the shorthand syntax: `{{ name }}`"]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.initializer?.kind === SyntaxKind.JsxExpression && property.initializer.expression?.kind === SyntaxKind.TrueKeyword) context.report({
+				data: { name: property.name.text },
+				message: "preferShorthand",
+				range: getTSNodeRange(property, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/bracedStatements.ts
+var bracedStatements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow unnecessary JSX curly braces around literals and JSX elements.",
+		id: "bracedStatements",
+		presets: ["stylistic"]
+	},
+	messages: { unnecessaryBraces: {
+		primary: "Curly braces are unnecessary around {{ type }}.",
+		secondary: ["Curly braces are unnecessary when they wrap simple literals or JSX elements.", "Removing them improves readability and reduces visual clutter."],
+		suggestions: ["Remove the curly braces and use the content directly."]
+	} },
+	setup(context) {
+		return { visitors: { JsxExpression(node, { sourceFile }) {
+			if (!node.expression || node.parent.kind !== SyntaxKind.JsxElement && node.parent.kind !== SyntaxKind.JsxFragment) return;
+			let unnecessaryType;
+			if (node.expression.kind === SyntaxKind.StringLiteral) unnecessaryType = "string literals";
+			else if (node.expression.kind === SyntaxKind.JsxElement || node.expression.kind === SyntaxKind.JsxSelfClosingElement || node.expression.kind === SyntaxKind.JsxFragment) unnecessaryType = "JSX elements";
+			if (unnecessaryType) context.report({
+				data: { type: unnecessaryType },
+				message: "unnecessaryBraces",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/buttonTypes.ts
+const validButtonTypes = /* @__PURE__ */ new Set([
+	"button",
+	"reset",
+	"submit"
+]);
+var buttonTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports button elements without an explicit type attribute.",
+		id: "buttonTypes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		invalidType: {
+			primary: "Button type '{{ type }}' is invalid. Use 'button', 'submit', or 'reset'.",
+			secondary: ["The type attribute must be one of: 'button', 'submit', or 'reset'.", "Invalid types will not behave as expected in all browsers."],
+			suggestions: [
+				"Change to type='button' for general action buttons",
+				"Change to type='submit' for form submission buttons",
+				"Change to type='reset' for form reset buttons"
+			]
+		},
+		missingType: {
+			primary: "It is generally preferable to add an explicit `type` attribute to buttons.",
+			secondary: [
+				"Buttons without an explicit type default to 'submit', which can cause unintended form submissions.",
+				"Valid button types are 'button', 'submit', and 'reset'.",
+				"Specify an explicit type to make the button's behavior clear."
+			],
+			suggestions: [
+				"Add type='button' for general action buttons",
+				"Add type='submit' for form submission buttons",
+				"Add type='reset' for form reset buttons"
+			]
+		}
+	},
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			if (node.tagName.text.toLowerCase() !== "button") return;
+			const typeAttribute = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "type");
+			if (!typeAttribute) {
+				context.report({
+					message: "missingType",
+					range: getTSNodeRange(node.tagName, sourceFile)
+				});
+				return;
+			}
+			const typeInitializer = typeAttribute.initializer;
+			const typeExpression = typeInitializer?.kind === SyntaxKind.JsxExpression ? typeInitializer.expression : typeInitializer;
+			const typeValue = typeExpression && getStaticStringValue(typeExpression);
+			if (typeValue && !validButtonTypes.has(typeValue)) context.report({
+				data: { type: typeValue },
+				message: "invalidType",
+				range: getTSNodeRange(typeAttribute, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/childrenProps.ts
+var childrenProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports usage of the children prop.",
+		id: "childrenProps",
+		presets: ["stylistic"]
+	},
+	messages: { noChildrenProp: {
+		primary: "Prefer providing children as content between opening and closing tags, not as a `children` prop.",
+		secondary: [
+			"Using the `children` prop is not idiomatic in JSX.",
+			"Pass children as content between opening and closing tags instead.",
+			"This makes the JSX more readable and maintainable."
+		],
+		suggestions: ["Remove the children prop and pass children as content between tags."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "children") {
+				context.report({
+					message: "noChildrenProp",
+					range: getTSNodeRange(property, sourceFile)
+				});
+				return;
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/clickEventKeyEvents.ts
+const interactiveElements$2 = /* @__PURE__ */ new Set([
+	"a",
+	"button",
+	"input",
+	"select",
+	"textarea"
+]);
+var clickEventKeyEvents_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports onClick without keyboard event handlers.",
+		id: "clickEventKeyEvents",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingKeyEvent: {
+		primary: "This `onClick` is missing accompanying `onKeyUp`, `onKeyDown`, and/or `onKeyPress` keyboard events.",
+		secondary: [
+			"Click events should have keyboard equivalents for users who cannot use a mouse.",
+			"This is important for users with physical disabilities and screen reader users.",
+			"Required for WCAG 2.1.1 compliance."
+		],
+		suggestions: ["Add onKeyDown, onKeyUp, and/or onKeyPress handlers", "Use a button element which is inherently keyboard accessible"]
+	} },
+	setup(context) {
+		function checkClickEvent(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() !== node.tagName.text) return;
+			const elementName = node.tagName.text.toLowerCase();
+			if (interactiveElements$2.has(elementName)) return;
+			let onClickName;
+			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier) switch (property.name.text) {
+				case "aria-hidden":
+				case "onKeyDown":
+				case "onKeyPress":
+				case "onKeyUp": return;
+				case "onClick":
+					onClickName = property.name;
+					break;
+			}
+			if (onClickName) context.report({
+				message: "missingKeyEvent",
+				range: getTSNodeRange(onClickName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkClickEvent,
+			JsxSelfClosingElement: checkClickEvent
+		} };
+	}
+});
+//#endregion
+//#region src/rules/commentTextNodes.ts
+var commentTextNodes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports JSX text nodes that contain comment syntax but are rendered as text.",
+		id: "commentTextNodes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { commentAsText: {
+		primary: "This text looks like a comment but will be rendered as text in the JSX output.",
+		secondary: [
+			"In JSX, text that looks like comments (// or /* */) is rendered as literal text.",
+			"To add actual comments in JSX, wrap them in braces: {/* comment */}.",
+			"If this is intentional text, consider making it clearer that it's not a comment."
+		],
+		suggestions: ["Use {/* comment */} for actual comments", "Remove the comment-like syntax if it's unintended"]
+	} },
+	setup(context) {
+		return { visitors: { JsxText(node, { sourceFile }) {
+			const text = node.text;
+			if (/^\s*(?:\/\/|\/\*)/.test(text)) context.report({
+				message: "commentAsText",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/distractingElements.ts
+const distractingElements = /* @__PURE__ */ new Set(["blink", "marquee"]);
+var distractingElements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports distracting elements like <marquee> and <blink>.",
+		id: "distractingElements",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noDistractingElement: {
+		primary: "The <{{ element }}> element is distracting and deprecated.",
+		secondary: [
+			"Visually distracting elements cause accessibility issues for users with visual impairments.",
+			"The <marquee> and <blink> elements are deprecated and should not be used.",
+			"Use modern CSS animations if movement is necessary for your design."
+		],
+		suggestions: ["Remove the distracting element", "Use CSS animations for visual effects"]
+	} },
+	setup(context) {
+		function checkElement({ tagName }, { sourceFile }) {
+			if (tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = tagName.text.toLowerCase();
+			if (distractingElements.has(elementName)) context.report({
+				data: { element: elementName },
+				message: "noDistractingElement",
+				range: getTSNodeRange(tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/elementChildrenValidity.ts
+const voidElements = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+var elementChildrenValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports void DOM elements that have children, which is invalid HTML.",
+		id: "elementChildrenValidity",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { voidElementWithChildren: {
+		primary: "The `<{{ element }}>` element is a void element and cannot have children.",
+		secondary: [
+			"Void elements are self-closing and cannot contain any content or children.",
+			"Remove the children or use a different element type.",
+			"This violates HTML specification and may cause rendering issues."
+		],
+		suggestions: ["Remove the children from the element", "Use a self-closing syntax: `<{{ element }} />`"]
+	} },
+	setup(context) {
+		return { visitors: { JsxElement(node, { sourceFile }) {
+			if (!node.children.length) return;
+			const openingElement = node.openingElement;
+			if (openingElement.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = openingElement.tagName.text.toLowerCase();
+			if (!voidElements.has(elementName)) return;
+			context.report({
+				data: { element: elementName },
+				message: "voidElementWithChildren",
+				range: getTSNodeRange(openingElement.tagName, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/headingContents.ts
+const headingElements = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+var headingContents_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports heading elements without accessible content.",
+		id: "headingContents",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyHeading: {
+		primary: "This heading element is missing accessible content.",
+		secondary: [
+			"Headings without content are not accessible to screen readers.",
+			"Ensure the heading has text content or uses aria-label/aria-labelledby.",
+			"This is required for WCAG 2.4.6 compliance."
+		],
+		suggestions: ["Add text content to the heading", "Use aria-label or aria-labelledby to provide accessible text"]
+	} },
+	setup(context) {
+		function checkHeading(node, { sourceFile }) {
+			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
+			if (tagName.kind !== SyntaxKind.Identifier || !headingElements.has(tagName.text.toLowerCase())) return;
+			if ((node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes).properties.some((property) => {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) return false;
+				return (property.name.text === "aria-label" || property.name.text === "aria-labelledby") && !!property.initializer;
+			})) return;
+			if (node.kind === SyntaxKind.JsxElement && node.children.some((child) => {
+				if (child.kind === SyntaxKind.JsxText) return !!child.text.trim().length;
+				return child.kind === SyntaxKind.JsxElement || child.kind === SyntaxKind.JsxSelfClosingElement || child.kind === SyntaxKind.JsxExpression;
+			})) return;
+			context.report({
+				message: "emptyHeading",
+				range: getTSNodeRange(tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxElement: checkHeading,
+			JsxSelfClosingElement: checkHeading
+		} };
+	}
+});
+//#endregion
+//#region src/rules/htmlLangs.ts
+var htmlLangs_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports <html> elements without a lang prop.",
+		id: "htmlLangs",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingLang: {
+		primary: "This <html> element is missing a `lang` prop.",
+		secondary: [
+			"The lang attribute identifies the language of the document for screen readers and assistive technologies.",
+			"Without it, screen readers may default to the user's system language, causing confusion.",
+			"This is required for WCAG 3.1.1 compliance."
+		],
+		suggestions: ["Add a lang prop with a valid language code (e.g., lang=\"en\")", "Use lang=\"en-US\" for more specific localization"]
+	} },
+	setup(context) {
+		return { visitors: { JsxOpeningElement(node, { sourceFile }) {
+			if (node.tagName.kind === SyntaxKind.Identifier && node.tagName.text === "html" && !node.attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "lang")) context.report({
+				message: "missingLang",
+				range: getTSNodeRange(node.tagName, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/iframeTitles.ts
+var iframeTitles_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports <iframe> elements without a title prop.",
+		id: "iframeTitles",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingTitle: {
+		primary: "This <iframe> element is missing a `title` prop.",
+		secondary: [
+			"The title attribute provides a label for the iframe that describes its content to screen reader users.",
+			"Without it, users may have difficulty understanding the purpose of the iframe.",
+			"This is required for WCAG 2.4.1 and 4.1.2 compliance."
+		],
+		suggestions: ["Add a descriptive title prop (e.g., title=\"Embedded content\")", "Ensure the title clearly describes the iframe's content"]
+	} },
+	setup(context) {
+		function checkIframe({ attributes, tagName }, { sourceFile }) {
+			if (tagName.kind !== SyntaxKind.Identifier || tagName.text.toLowerCase() !== "iframe") return;
+			const titleAttribute = attributes.properties.find((property) => {
+				return property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "title";
+			});
+			if (titleAttribute?.kind !== SyntaxKind.JsxAttribute) {
+				context.report({
+					message: "missingTitle",
+					range: getTSNodeRange(tagName, sourceFile)
+				});
+				return;
+			}
+			if (!titleAttribute.initializer) {
+				context.report({
+					message: "missingTitle",
+					range: getTSNodeRange(tagName, sourceFile)
+				});
+				return;
+			}
+			if (titleAttribute.initializer.kind === SyntaxKind.StringLiteral) {
+				if (titleAttribute.initializer.text === "") context.report({
+					message: "missingTitle",
+					range: getTSNodeRange(tagName, sourceFile)
+				});
+			} else if (titleAttribute.initializer.kind === SyntaxKind.JsxExpression) {
+				const { expression } = titleAttribute.initializer;
+				if (!expression) return;
+				if (expression.kind === SyntaxKind.StringLiteral && expression.text === "" || expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral && expression.text === "" || expression.kind === SyntaxKind.Identifier && expression.text === "undefined") context.report({
+					message: "missingTitle",
+					range: getTSNodeRange(tagName, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkIframe,
+			JsxSelfClosingElement: checkIframe
+		} };
+	}
+});
+//#endregion
+//#region src/rules/interactiveElementRoles.ts
+const interactiveElements$1 = /* @__PURE__ */ new Set([
+	"a",
+	"audio",
+	"button",
+	"details",
+	"input",
+	"select",
+	"summary",
+	"textarea",
+	"video"
+]);
+const nonInteractiveRoles$2 = /* @__PURE__ */ new Set([
+	"article",
+	"banner",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"directory",
+	"document",
+	"feed",
+	"figure",
+	"form",
+	"group",
+	"heading",
+	"img",
+	"list",
+	"listitem",
+	"log",
+	"main",
+	"marquee",
+	"math",
+	"meter",
+	"navigation",
+	"none",
+	"note",
+	"presentation",
+	"region",
+	"rowgroup",
+	"search",
+	"separator",
+	"status",
+	"table",
+	"tabpanel",
+	"term",
+	"timer",
+	"tooltip"
+]);
+var interactiveElementRoles_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports interactive elements with non-interactive ARIA roles.",
+		id: "interactiveElementRoles",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidRole: {
+		primary: "Interactive element <{{ element }}> should not have the non-interactive role `'{{ role }}'`.",
+		secondary: [
+			"Interactive elements should not be converted to non-interactive elements using ARIA roles.",
+			"This removes expected browser interactions from the element.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Remove the role attribute", "Use a native non-interactive element instead"]
+	} },
+	setup(context) {
+		function checkElement(element, { sourceFile }) {
+			if (element.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = element.tagName.text.toLowerCase();
+			if (!interactiveElements$1.has(elementName)) return;
+			const roleProperty = element.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (roleProperty?.kind !== SyntaxKind.JsxAttribute || roleProperty.initializer?.kind !== SyntaxKind.StringLiteral) return;
+			const role = roleProperty.initializer.text;
+			if (nonInteractiveRoles$2.has(role)) context.report({
+				data: {
+					element: elementName,
+					role
+				},
+				message: "invalidRole",
+				range: getTSNodeRange(roleProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/interactiveElementsFocusable.ts
+const interactiveHandlers$2 = [
+	"onClick",
+	"onKeyDown",
+	"onKeyPress",
+	"onKeyUp",
+	"onMouseDown",
+	"onMouseUp"
+];
+const interactiveRoles$2 = /* @__PURE__ */ new Set([
+	"button",
+	"checkbox",
+	"columnheader",
+	"combobox",
+	"grid",
+	"gridcell",
+	"link",
+	"listbox",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"option",
+	"progressbar",
+	"radio",
+	"radiogroup",
+	"row",
+	"rowheader",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"switch",
+	"tab",
+	"tablist",
+	"textbox",
+	"toolbar",
+	"tree",
+	"treegrid",
+	"treeitem"
+]);
+const inherentlyFocusableElements = /* @__PURE__ */ new Set([
+	"a",
+	"audio",
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"video"
+]);
+const nonInteractiveElements$3 = /* @__PURE__ */ new Set([
+	"article",
+	"aside",
+	"body",
+	"br",
+	"details",
+	"div",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"img",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"section",
+	"span",
+	"table",
+	"td",
+	"ul"
+]);
+const nonInteractiveRoles$1 = /* @__PURE__ */ new Set([
+	"article",
+	"banner",
+	"complementary",
+	"img",
+	"listitem",
+	"main",
+	"navigation",
+	"region",
+	"tooltip"
+]);
+var interactiveElementsFocusable_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports interactive elements that are not focusable via keyboard.",
+		id: "interactiveElementsFocusable",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { notFocusable: {
+		primary: "The '{{ role }}' role makes this element interactive, so it should also be focusable.",
+		secondary: [
+			"Interactive elements must be reachable via keyboard navigation.",
+			"Add a tabIndex attribute or use an inherently focusable element.",
+			"This is required for WCAG 2.1.1 compliance."
+		],
+		suggestions: [
+			"Add tabIndex={0} to make the element tabbable",
+			"Add tabIndex={-1} to make the element programmatically focusable",
+			"Use a native interactive element like <button> or <a>"
+		]
+	} },
+	setup(context) {
+		function getTabIndexValue(node) {
+			const tabIndex = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "tabIndex");
+			if (!tabIndex?.initializer) return;
+			if (tabIndex.initializer.kind === SyntaxKind.JsxExpression) {
+				const expression = tabIndex.initializer.expression;
+				if (expression?.kind === SyntaxKind.NumericLiteral) return Number(expression.text);
+			}
+			if (tabIndex.initializer.kind === SyntaxKind.StringLiteral) return Number(tabIndex.initializer.text);
+		}
+		function getRoleValue(node) {
+			const role = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (role?.kind === SyntaxKind.JsxAttribute && role.initializer?.kind === SyntaxKind.StringLiteral) return role.initializer.text;
+		}
+		function isAriaHidden(node) {
+			const ariaHidden = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "aria-hidden");
+			if (ariaHidden?.kind !== SyntaxKind.JsxAttribute || !ariaHidden.initializer) return false;
+			if (ariaHidden.initializer.kind === SyntaxKind.JsxExpression) return ariaHidden.initializer.expression?.kind === SyntaxKind.TrueKeyword;
+			if (ariaHidden.initializer.kind === SyntaxKind.StringLiteral) return ariaHidden.initializer.text === "true";
+			return false;
+		}
+		function hasInteractiveHandler(node) {
+			return node.attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && interactiveHandlers$2.includes(property.name.text));
+		}
+		function isDisabled(node) {
+			const disabledProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "disabled");
+			if (disabledProperty?.kind !== SyntaxKind.JsxAttribute) return false;
+			if (!disabledProperty.initializer) return true;
+			if (disabledProperty.initializer.kind === SyntaxKind.JsxExpression) return disabledProperty.initializer.expression?.kind === SyntaxKind.TrueKeyword;
+			return false;
+		}
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = node.tagName.text.toLowerCase();
+			if (elementName !== node.tagName.text || !hasInteractiveHandler(node) || isAriaHidden(node) || isDisabled(node)) return;
+			const role = getRoleValue(node);
+			if (role === "presentation" || role === "none") return;
+			if (!(role !== void 0 && interactiveRoles$2.has(role) || role === void 0 && !nonInteractiveElements$3.has(elementName))) return;
+			if (role && nonInteractiveRoles$1.has(role)) return;
+			const hasInherentFocus = inherentlyFocusableElements.has(elementName);
+			const hasFocusableTabIndex = getTabIndexValue(node) !== void 0;
+			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (!hasInherentFocus && !hasFocusableTabIndex) {
+				const displayRole = role ?? elementName;
+				context.report({
+					data: { role: displayRole },
+					message: "notFocusable",
+					range: getTSNodeRange(roleProperty?.kind === SyntaxKind.JsxAttribute ? roleProperty : node.tagName, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/labelAssociatedControls.ts
+const controlElements = /* @__PURE__ */ new Set([
+	"input",
+	"meter",
+	"output",
+	"progress",
+	"select",
+	"textarea"
+]);
+var labelAssociatedControls_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports <label> elements without an associated control element.",
+		id: "labelAssociatedControls",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingAssociatedControl: {
+		primary: "This <label> element is missing an associated control element.",
+		secondary: [
+			"Labels must be associated with a control element to be accessible to screen readers.",
+			"Use the htmlFor prop to reference a control by id, or nest the control inside the label.",
+			"This is required for WCAG 1.3.1, 2.4.6, and 4.1.2 compliance."
+		],
+		suggestions: ["Add an htmlFor prop that references a control element by id", "Nest a control element (input, select, textarea) inside the label"]
+	} },
+	setup(context) {
+		function hasHtmlForAttribute(attributes) {
+			return attributes.properties.some((property) => {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier || property.name.text !== "htmlFor" || !property.initializer) return false;
+				if (property.initializer.kind === SyntaxKind.StringLiteral) return property.initializer.text !== "";
+				if (property.initializer.kind === SyntaxKind.JsxExpression) {
+					const { expression } = property.initializer;
+					if (!expression) return false;
+					if (expression.kind === SyntaxKind.StringLiteral && expression.text === "" || expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral && expression.text === "" || expression.kind === SyntaxKind.Identifier && expression.text === "undefined" || expression.kind === SyntaxKind.NullKeyword) return false;
+				}
+				return true;
+			});
+		}
+		function hasNestedControl(children) {
+			return children.some((child) => {
+				if (child.kind === SyntaxKind.JsxElement) {
+					const { tagName } = child.openingElement;
+					return tagName.kind === SyntaxKind.Identifier && controlElements.has(tagName.text.toLowerCase()) || hasNestedControl(child.children);
+				}
+				if (child.kind === SyntaxKind.JsxSelfClosingElement) return child.tagName.kind === SyntaxKind.Identifier && controlElements.has(child.tagName.text.toLowerCase());
+				return false;
+			});
+		}
+		function checkLabel(node, { sourceFile }) {
+			if (node.kind === SyntaxKind.JsxElement && hasNestedControl(node.children)) return;
+			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
+			if (tagName.kind !== SyntaxKind.Identifier || tagName.text.toLowerCase() !== "label") return;
+			if (hasHtmlForAttribute(node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes)) return;
+			context.report({
+				message: "missingAssociatedControl",
+				range: getTSNodeRange(tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxElement: checkLabel,
+			JsxSelfClosingElement: checkLabel
+		} };
+	}
+});
+//#endregion
+//#region src/rules/langValidity.ts
+var langValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid lang attribute values.",
+		id: "langValidity",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidLang: {
+		primary: "The lang attribute value '{{ value }}' is not a valid BCP 47 language tag.",
+		secondary: [
+			"The lang attribute must contain a valid BCP 47 language tag.",
+			"Valid examples include 'en', 'en-US', 'zh-Hans', or 'fr-CA'.",
+			"This is required for WCAG 3.1.2 compliance."
+		],
+		suggestions: ["Use a valid BCP 47 language tag like 'en' or 'en-US'", "Check the language code spelling and format"]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			const langAttribute = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "lang");
+			if (!langAttribute?.initializer) return;
+			if (langAttribute.initializer.kind === SyntaxKind.StringLiteral) {
+				const langValue = langAttribute.initializer.text;
+				if (!languageTags.check(langValue)) context.report({
+					data: { value: langValue || "(empty)" },
+					message: "invalidLang",
+					range: getTSNodeRange(langAttribute.initializer, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/mediaCaptions.ts
+var mediaCaptions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports media elements without captions.",
+		id: "mediaCaptions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingCaptions: {
+		primary: "This media element is missing <track> element captions.",
+		secondary: [
+			"Captions are essential for deaf users to follow along with media content.",
+			"The <track> element with kind='captions' provides this accessibility feature.",
+			"This is required for WCAG 1.2.2 and 1.2.3 compliance."
+		],
+		suggestions: ["Add a <track kind=\"captions\"> element as a child", "Add the muted attribute if the media has no audio"]
+	} },
+	setup(context) {
+		function checkMediaElement(node, { sourceFile }) {
+			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
+			if (tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = tagName.text.toLowerCase();
+			if (elementName !== "audio" && elementName !== "video") return;
+			if ((node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes).properties.some((properties) => properties.kind === SyntaxKind.JsxAttribute && properties.name.kind === SyntaxKind.Identifier && properties.name.text === "muted")) return;
+			if (node.kind === SyntaxKind.JsxElement && node.children.some(isCaptionsTrack)) return;
+			context.report({
+				message: "missingCaptions",
+				range: getTSNodeRange(tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxElement: checkMediaElement,
+			JsxSelfClosingElement: checkMediaElement
+		} };
+	}
+});
+function isCaptionsTrack(node) {
+	if (node.kind !== SyntaxKind.JsxElement && node.kind !== SyntaxKind.JsxSelfClosingElement) return false;
+	const childTagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
+	if (childTagName.kind !== SyntaxKind.Identifier || childTagName.text !== "track") return false;
+	return (node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes).properties.some((property) => {
+		if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier || property.name.text !== "kind") return false;
+		if (property.initializer?.kind === SyntaxKind.StringLiteral) return property.initializer.text === "captions";
+		return false;
+	});
+}
+//#endregion
+//#region src/rules/mouseEventKeyEvents.ts
+const mouseNamesToKeyboardNames = /* @__PURE__ */ new Map([["onMouseOut", "onBlur"], ["onMouseOver", "onFocus"]]);
+var mouseEventKeyEvents_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports mouse events without corresponding keyboard events.",
+		id: "mouseEventKeyEvents",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingKeyEvent: {
+		primary: "`{{ mouseEvent }}` is missing an accompanying `{{ keyEvent }}` for keyboard accessibility.",
+		secondary: [
+			"Mouse events should have keyboard equivalents for users who cannot use a mouse.",
+			"This ensures that functionality is accessible to all users, such as those with limited hardware or personal disabilities.",
+			"Required for WCAG 2.1.1 compliance."
+		],
+		suggestions: ["Add the corresponding keyboard event handler", "Ensure both mouse and keyboard users can access the functionality"]
+	} },
+	setup(context) {
+		function checkMouseEvents(node, { sourceFile }) {
+			const { attributes } = node;
+			const presentAttributes = /* @__PURE__ */ new Set();
+			for (const property of attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier) presentAttributes.add(property.name.text);
+			for (const property of attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const mouseEvent = property.name.text;
+				const keyEvent = mouseNamesToKeyboardNames.get(mouseEvent);
+				if (keyEvent && !presentAttributes.has(keyEvent)) context.report({
+					data: {
+						keyEvent,
+						mouseEvent
+					},
+					message: "missingKeyEvent",
+					range: getTSNodeRange(property.name, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkMouseEvents,
+			JsxSelfClosingElement: checkMouseEvents
+		} };
+	}
+});
+//#endregion
+//#region src/rules/nonInteractiveElementInteractions.ts
+const interactiveHandlers$1 = [
+	"onClick",
+	"onKeyDown",
+	"onKeyPress",
+	"onKeyUp",
+	"onMouseDown",
+	"onMouseUp"
+];
+const nonInteractiveElements$2 = /* @__PURE__ */ new Set([
+	"area",
+	"article",
+	"aside",
+	"body",
+	"br",
+	"details",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"img",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"section",
+	"table",
+	"td",
+	"ul"
+]);
+const nonInteractiveRoles = /* @__PURE__ */ new Set([
+	"article",
+	"banner",
+	"complementary",
+	"img",
+	"listitem",
+	"main",
+	"navigation",
+	"region",
+	"tooltip"
+]);
+var nonInteractiveElementInteractions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-interactive elements with interactive event handlers.",
+		id: "nonInteractiveElementInteractions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidHandler: {
+		primary: "`<{{ element }}>` elements are non-interactive and so should not have interactive event handlers.",
+		secondary: [
+			"Non-interactive elements indicate content and containers in the user interface.",
+			"Use native interactive elements like <button> or <a> instead, or add an interactive role.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: [
+			"Use a native interactive element instead (e.g. <button>)",
+			"Add an interactive role attribute (e.g. role='button')",
+			"Move the handler to an inner element with an interactive role"
+		]
+	} },
+	setup(context) {
+		function checkElement(element, { sourceFile }) {
+			if (element.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = element.tagName.text.toLowerCase();
+			if (elementName !== element.tagName.text || !nonInteractiveElements$2.has(elementName)) return;
+			let hasInteractiveHandler = false;
+			for (const property of element.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier) {
+				if (property.name.text === "role" && property.initializer?.kind === SyntaxKind.StringLiteral && !nonInteractiveRoles.has(property.initializer.text)) return;
+				if (interactiveHandlers$1.includes(property.name.text)) hasInteractiveHandler = true;
+			}
+			if (hasInteractiveHandler) context.report({
+				data: { element: elementName },
+				message: "invalidHandler",
+				range: getTSNodeRange(element.tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/nonInteractiveElementRoles.ts
+const nonInteractiveElements$1 = /* @__PURE__ */ new Set([
+	"article",
+	"aside",
+	"body",
+	"br",
+	"details",
+	"div",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"img",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"section",
+	"table",
+	"td",
+	"ul"
+]);
+const interactiveRoles$1 = /* @__PURE__ */ new Set([
+	"button",
+	"checkbox",
+	"link",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"option",
+	"radio",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"switch",
+	"tab",
+	"textbox"
+]);
+const allowedExceptions = {
+	li: /* @__PURE__ */ new Set([
+		"menuitem",
+		"option",
+		"row",
+		"tab",
+		"treeitem"
+	]),
+	ol: /* @__PURE__ */ new Set([
+		"listbox",
+		"menu",
+		"menubar",
+		"radiogroup",
+		"tablist",
+		"tree",
+		"treegrid"
+	]),
+	table: /* @__PURE__ */ new Set(["grid"]),
+	td: /* @__PURE__ */ new Set(["gridcell"]),
+	ul: /* @__PURE__ */ new Set([
+		"listbox",
+		"menu",
+		"menubar",
+		"radiogroup",
+		"tablist",
+		"tree",
+		"treegrid"
+	])
+};
+var nonInteractiveElementRoles_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-interactive elements with interactive ARIA roles.",
+		id: "nonInteractiveElementRoles",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidRole: {
+		primary: "Non-interactive element <{{ element }}> should not have the interactive role `'{{ role }}'`.",
+		secondary: [
+			"Non-interactive elements should not be converted to interactive controls using ARIA roles.",
+			"Use native interactive elements like <button> or <a> instead.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Use a native interactive element instead", "Remove the role attribute"]
+	} },
+	setup(context) {
+		function checkElement(element, { sourceFile }) {
+			if (element.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = element.tagName.text.toLowerCase();
+			if (!nonInteractiveElements$1.has(elementName)) return;
+			const roleProperty = element.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (roleProperty?.kind !== SyntaxKind.JsxAttribute || roleProperty.initializer?.kind !== SyntaxKind.StringLiteral) return;
+			const role = roleProperty.initializer.text;
+			if (interactiveRoles$1.has(role) && !allowedExceptions[elementName]?.has(role)) context.report({
+				data: {
+					element: elementName,
+					role
+				},
+				message: "invalidRole",
+				range: getTSNodeRange(roleProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/nonInteractiveElementTabIndexes.ts
+const nonInteractiveElements = /* @__PURE__ */ new Set([
+	"article",
+	"aside",
+	"body",
+	"br",
+	"details",
+	"div",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"img",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"section",
+	"span",
+	"ul"
+]);
+const interactiveRoles = /* @__PURE__ */ new Set([
+	"button",
+	"checkbox",
+	"link",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"option",
+	"radio",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"switch",
+	"tab",
+	"textbox"
+]);
+var nonInteractiveElementTabIndexes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-interactive elements with positive or zero tabIndex values.",
+		id: "nonInteractiveElementTabIndexes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { nonInteractiveTabIndex: {
+		primary: "Non-interactive element `<{{ element }}>` should not have an explicit, non-negative `tabIndex`.",
+		secondary: [
+			"Tab navigation should be limited to interactive elements.",
+			"Non-interactive elements with tabIndex add unnecessary stops in the tab order.",
+			"Use tabIndex='-1' if you need to programmatically focus the element."
+		],
+		suggestions: [
+			"Remove the tabIndex attribute",
+			"Use tabIndex='-1' instead",
+			"Add an interactive role to the element"
+		]
+	} },
+	setup(context) {
+		function getTabIndexValue(attr) {
+			if (!attr.initializer) return;
+			if (attr.initializer.kind === SyntaxKind.StringLiteral) {
+				const value = parseInt(attr.initializer.text, 10);
+				return Number.isNaN(value) ? void 0 : value;
+			}
+			if (attr.initializer.kind === SyntaxKind.JsxExpression) {
+				const expr = attr.initializer.expression;
+				if (expr?.kind === SyntaxKind.NumericLiteral) {
+					const value = parseInt(expr.text, 10);
+					return Number.isNaN(value) ? void 0 : value;
+				}
+			}
+		}
+		function getRoleValue(attributes) {
+			const roleProperty = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (roleProperty?.kind === SyntaxKind.JsxAttribute && roleProperty.initializer?.kind === SyntaxKind.StringLiteral) return roleProperty.initializer.text;
+		}
+		function checkTabIndex(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = node.tagName.text.toLowerCase();
+			if (!nonInteractiveElements.has(elementName)) return;
+			const role = getRoleValue(node.attributes);
+			if (role && interactiveRoles.has(role)) return;
+			const tabIndexProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "tabIndex");
+			if (tabIndexProperty?.kind !== SyntaxKind.JsxAttribute) return;
+			const tabIndexValue = getTabIndexValue(tabIndexProperty);
+			if (tabIndexValue !== void 0 && tabIndexValue >= 0) context.report({
+				data: { element: elementName },
+				message: "nonInteractiveTabIndex",
+				range: getTSNodeRange(tabIndexProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkTabIndex,
+			JsxSelfClosingElement: checkTabIndex
+		} };
+	}
+});
+//#endregion
+//#region src/rules/propDuplicates.ts
+var propDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow duplicate props in JSX elements.",
+		id: "propDuplicates",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { duplicateProp: {
+		primary: "Duplicate prop `{{ propName }}` found in JSX element. The last occurrence will override earlier ones.",
+		secondary: ["Having duplicate props can lead to unexpected behavior since only the last value is used.", "This makes the code harder to understand and maintain."],
+		suggestions: ["Remove the duplicate prop and keep only one definition."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			const seenProps = /* @__PURE__ */ new Set();
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propName = property.name.text;
+				if (seenProps.has(propName)) context.report({
+					data: { propName },
+					message: "duplicateProp",
+					range: getTSNodeRange(property.name, sourceFile)
+				});
+				else seenProps.add(propName);
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/roleRedundancies.ts
+const implicitRoles$1 = {
+	a: "link",
+	article: "article",
+	aside: "complementary",
+	button: "button",
+	dialog: "dialog",
+	footer: "contentinfo",
+	form: "form",
+	h1: "heading",
+	h2: "heading",
+	h3: "heading",
+	h4: "heading",
+	h5: "heading",
+	h6: "heading",
+	header: "banner",
+	hr: "separator",
+	img: "img",
+	input: "textbox",
+	li: "listitem",
+	main: "main",
+	nav: "navigation",
+	ol: "list",
+	section: "region",
+	select: "listbox",
+	textarea: "textbox",
+	ul: "list"
+};
+var roleRedundancies_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports redundant ARIA roles on elements with implicit roles.",
+		id: "roleRedundancies",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { redundantRole: {
+		primary: "`<{{ element }}>` elements already implicitly have a role of `{{ role }}`. This explicit role is unnecessary.",
+		secondary: ["HTML elements have default semantics implemented by the browser.", "Setting an explicit role that matches the implicit role is redundant and doesn't provide any benefit."],
+		suggestions: ["Remove the redundant role attribute"]
+	} },
+	setup(context) {
+		function checkRedundantRole(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			const element = node.tagName.text.toLowerCase();
+			const implicitRole = implicitRoles$1[element];
+			if (!implicitRole) return;
+			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (roleProperty?.kind === SyntaxKind.JsxAttribute && roleProperty.initializer?.kind === SyntaxKind.StringLiteral && roleProperty.initializer.text === implicitRole) {
+				const range = getTSNodeRange(roleProperty, sourceFile);
+				context.report({
+					data: {
+						element,
+						role: roleProperty.initializer.text
+					},
+					message: "redundantRole",
+					range,
+					suggestions: [{
+						id: "removeRole",
+						range,
+						text: ""
+					}]
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkRedundantRole,
+			JsxSelfClosingElement: checkRedundantRole
+		} };
+	}
+});
+//#endregion
+//#region src/rules/roleRequiredAriaProps.ts
+const requiredAriaPropsForRole = {
+	checkbox: ["aria-checked"],
+	combobox: ["aria-controls", "aria-expanded"],
+	heading: ["aria-level"],
+	menuitemcheckbox: ["aria-checked"],
+	menuitemradio: ["aria-checked"],
+	option: ["aria-selected"],
+	radio: ["aria-checked"],
+	scrollbar: [
+		"aria-controls",
+		"aria-valuenow",
+		"aria-valuemax",
+		"aria-valuemin"
+	],
+	slider: [
+		"aria-valuenow",
+		"aria-valuemax",
+		"aria-valuemin"
+	],
+	spinbutton: [
+		"aria-valuenow",
+		"aria-valuemax",
+		"aria-valuemin"
+	],
+	switch: ["aria-checked"]
+};
+var roleRequiredAriaProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA roles missing their required ARIA properties.",
+		id: "roleRequiredAriaProps",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingRequiredProps: {
+		primary: "Elements with ARIA role `{{ role }}` must have the following ARIA property(s) defined: {{ props }}.",
+		secondary: [
+			"ARIA roles define how elements are exposed to assistive technologies.",
+			"Some roles require specific ARIA properties to function correctly.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Add the required ARIA properties to the element."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			const roleAttribute = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (roleAttribute?.kind !== SyntaxKind.JsxAttribute || roleAttribute.initializer?.kind !== SyntaxKind.StringLiteral) return;
+			const role = roleAttribute.initializer.text.toLowerCase();
+			const requiredProps = requiredAriaPropsForRole[role];
+			if (!requiredProps) return;
+			const existingProps = /* @__PURE__ */ new Set();
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propertyName = property.name.text.toLowerCase();
+				if (propertyName.startsWith("aria-")) existingProps.add(propertyName);
+			}
+			const missingProps = requiredProps.filter((prop) => !existingProps.has(prop));
+			if (missingProps.length) context.report({
+				data: {
+					props: missingProps.join(", "),
+					role
+				},
+				message: "missingRequiredProps",
+				range: getTSNodeRange(roleAttribute, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/roleSupportedAriaProps.ts
+const globalAriaProperties = /* @__PURE__ */ new Set([
+	"aria-atomic",
+	"aria-busy",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"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"
+]);
+const roleToSupportedProps = {
+	alert: /* @__PURE__ */ new Set(["aria-expanded"]),
+	alertdialog: /* @__PURE__ */ new Set(["aria-expanded", "aria-modal"]),
+	application: /* @__PURE__ */ new Set(["aria-activedescendant", "aria-expanded"]),
+	article: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-posinset",
+		"aria-setsize"
+	]),
+	banner: /* @__PURE__ */ new Set(["aria-expanded"]),
+	button: /* @__PURE__ */ new Set(["aria-expanded", "aria-pressed"]),
+	cell: /* @__PURE__ */ new Set([
+		"aria-colindex",
+		"aria-colspan",
+		"aria-expanded",
+		"aria-rowindex",
+		"aria-rowspan"
+	]),
+	checkbox: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required"
+	]),
+	columnheader: /* @__PURE__ */ new Set([
+		"aria-colindex",
+		"aria-colspan",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required",
+		"aria-rowindex",
+		"aria-rowspan",
+		"aria-selected",
+		"aria-sort"
+	]),
+	combobox: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-autocomplete",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required"
+	]),
+	command: /* @__PURE__ */ new Set(["aria-expanded"]),
+	complementary: /* @__PURE__ */ new Set(["aria-expanded"]),
+	composite: /* @__PURE__ */ new Set(["aria-activedescendant", "aria-expanded"]),
+	contentinfo: /* @__PURE__ */ new Set(["aria-expanded"]),
+	definition: /* @__PURE__ */ new Set(["aria-expanded"]),
+	dialog: /* @__PURE__ */ new Set(["aria-expanded", "aria-modal"]),
+	directory: /* @__PURE__ */ new Set(["aria-expanded"]),
+	document: /* @__PURE__ */ new Set(["aria-expanded"]),
+	feed: /* @__PURE__ */ new Set(["aria-expanded"]),
+	figure: /* @__PURE__ */ new Set(["aria-expanded"]),
+	form: /* @__PURE__ */ new Set(["aria-expanded"]),
+	grid: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-colcount",
+		"aria-expanded",
+		"aria-level",
+		"aria-multiselectable",
+		"aria-readonly",
+		"aria-rowcount"
+	]),
+	gridcell: /* @__PURE__ */ new Set([
+		"aria-colindex",
+		"aria-colspan",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required",
+		"aria-rowindex",
+		"aria-rowspan",
+		"aria-selected"
+	]),
+	group: /* @__PURE__ */ new Set(["aria-activedescendant", "aria-expanded"]),
+	heading: /* @__PURE__ */ new Set(["aria-expanded", "aria-level"]),
+	img: /* @__PURE__ */ new Set(["aria-expanded"]),
+	input: /* @__PURE__ */ new Set(["aria-expanded"]),
+	landmark: /* @__PURE__ */ new Set(["aria-expanded"]),
+	link: /* @__PURE__ */ new Set(["aria-expanded"]),
+	list: /* @__PURE__ */ new Set(["aria-expanded"]),
+	listbox: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-multiselectable",
+		"aria-orientation",
+		"aria-readonly",
+		"aria-required"
+	]),
+	listitem: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-level",
+		"aria-posinset",
+		"aria-setsize"
+	]),
+	log: /* @__PURE__ */ new Set(["aria-expanded"]),
+	main: /* @__PURE__ */ new Set(["aria-expanded"]),
+	marquee: /* @__PURE__ */ new Set(["aria-expanded"]),
+	math: /* @__PURE__ */ new Set(["aria-expanded"]),
+	menu: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-orientation"
+	]),
+	menubar: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-orientation"
+	]),
+	menuitem: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-posinset",
+		"aria-setsize"
+	]),
+	menuitemcheckbox: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-posinset",
+		"aria-readonly",
+		"aria-setsize"
+	]),
+	menuitemradio: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-posinset",
+		"aria-readonly",
+		"aria-setsize"
+	]),
+	navigation: /* @__PURE__ */ new Set(["aria-expanded"]),
+	none: /* @__PURE__ */ new Set([]),
+	note: /* @__PURE__ */ new Set(["aria-expanded"]),
+	option: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-posinset",
+		"aria-selected",
+		"aria-setsize"
+	]),
+	presentation: /* @__PURE__ */ new Set([]),
+	progressbar: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-valuemax",
+		"aria-valuemin",
+		"aria-valuenow",
+		"aria-valuetext"
+	]),
+	radio: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-posinset",
+		"aria-readonly",
+		"aria-setsize"
+	]),
+	radiogroup: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-orientation",
+		"aria-readonly",
+		"aria-required"
+	]),
+	range: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-valuemax",
+		"aria-valuemin",
+		"aria-valuenow",
+		"aria-valuetext"
+	]),
+	region: /* @__PURE__ */ new Set(["aria-expanded"]),
+	roletype: /* @__PURE__ */ new Set(["aria-expanded"]),
+	row: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-colindex",
+		"aria-expanded",
+		"aria-level",
+		"aria-rowindex",
+		"aria-selected"
+	]),
+	rowgroup: /* @__PURE__ */ new Set(["aria-activedescendant", "aria-expanded"]),
+	rowheader: /* @__PURE__ */ new Set([
+		"aria-colindex",
+		"aria-colspan",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required",
+		"aria-rowindex",
+		"aria-rowspan",
+		"aria-selected",
+		"aria-sort"
+	]),
+	scrollbar: /* @__PURE__ */ new Set([
+		"aria-controls",
+		"aria-expanded",
+		"aria-orientation",
+		"aria-valuemax",
+		"aria-valuemin",
+		"aria-valuenow",
+		"aria-valuetext"
+	]),
+	search: /* @__PURE__ */ new Set(["aria-expanded"]),
+	searchbox: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-autocomplete",
+		"aria-expanded",
+		"aria-multiline",
+		"aria-placeholder",
+		"aria-readonly",
+		"aria-required"
+	]),
+	section: /* @__PURE__ */ new Set(["aria-expanded"]),
+	sectionhead: /* @__PURE__ */ new Set(["aria-expanded"]),
+	select: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-orientation"
+	]),
+	separator: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-orientation",
+		"aria-valuemax",
+		"aria-valuemin",
+		"aria-valuenow",
+		"aria-valuetext"
+	]),
+	slider: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-orientation",
+		"aria-readonly",
+		"aria-valuemax",
+		"aria-valuemin",
+		"aria-valuenow",
+		"aria-valuetext"
+	]),
+	spinbutton: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required",
+		"aria-valuemax",
+		"aria-valuemin",
+		"aria-valuenow",
+		"aria-valuetext"
+	]),
+	status: /* @__PURE__ */ new Set(["aria-expanded"]),
+	structure: /* @__PURE__ */ new Set(["aria-expanded"]),
+	switch: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-readonly",
+		"aria-required"
+	]),
+	tab: /* @__PURE__ */ new Set([
+		"aria-expanded",
+		"aria-posinset",
+		"aria-selected",
+		"aria-setsize"
+	]),
+	table: /* @__PURE__ */ new Set([
+		"aria-colcount",
+		"aria-expanded",
+		"aria-level",
+		"aria-multiselectable",
+		"aria-rowcount"
+	]),
+	tablist: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-level",
+		"aria-multiselectable",
+		"aria-orientation"
+	]),
+	tabpanel: /* @__PURE__ */ new Set(["aria-expanded"]),
+	term: /* @__PURE__ */ new Set(["aria-expanded"]),
+	textbox: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-autocomplete",
+		"aria-expanded",
+		"aria-multiline",
+		"aria-placeholder",
+		"aria-readonly",
+		"aria-required"
+	]),
+	timer: /* @__PURE__ */ new Set(["aria-expanded"]),
+	toolbar: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-orientation"
+	]),
+	tooltip: /* @__PURE__ */ new Set(["aria-expanded"]),
+	tree: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-expanded",
+		"aria-multiselectable",
+		"aria-orientation",
+		"aria-required"
+	]),
+	treegrid: /* @__PURE__ */ new Set([
+		"aria-activedescendant",
+		"aria-colcount",
+		"aria-expanded",
+		"aria-level",
+		"aria-multiselectable",
+		"aria-orientation",
+		"aria-readonly",
+		"aria-required",
+		"aria-rowcount"
+	]),
+	treeitem: /* @__PURE__ */ new Set([
+		"aria-checked",
+		"aria-expanded",
+		"aria-level",
+		"aria-posinset",
+		"aria-selected",
+		"aria-setsize"
+	]),
+	widget: /* @__PURE__ */ new Set(["aria-expanded"]),
+	window: /* @__PURE__ */ new Set(["aria-expanded", "aria-modal"])
+};
+const implicitRoles = {
+	a: "link",
+	article: "article",
+	aside: "complementary",
+	button: "button",
+	dialog: "dialog",
+	footer: "contentinfo",
+	form: "form",
+	h1: "heading",
+	h2: "heading",
+	h3: "heading",
+	h4: "heading",
+	h5: "heading",
+	h6: "heading",
+	header: "banner",
+	hr: "separator",
+	img: "img",
+	input: "textbox",
+	li: "listitem",
+	main: "main",
+	nav: "navigation",
+	ol: "list",
+	section: "region",
+	select: "listbox",
+	textarea: "textbox",
+	ul: "list"
+};
+function getSupportedPropsForRole(role) {
+	return /* @__PURE__ */ new Set([...roleToSupportedProps[role] ?? [], ...globalAriaProperties]);
+}
+var roleSupportedAriaProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA properties that are not supported by an element's role.",
+		id: "roleSupportedAriaProps",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unsupportedProp: {
+		primary: "The `{{ prop }}` ARIA property is not supported by the `{{ role }}` role.",
+		secondary: [
+			"Elements with ARIA roles should only use ARIA properties that are supported by that role.",
+			"Using unsupported ARIA properties can confuse assistive technologies.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Remove the unsupported ARIA property or change the element's role."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = node.tagName.text.toLowerCase();
+			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			const role = roleProperty?.kind === SyntaxKind.JsxAttribute && roleProperty.initializer?.kind === SyntaxKind.StringLiteral ? roleProperty.initializer.text.toLowerCase() : implicitRoles[elementName];
+			if (!role) return;
+			const supportedProps = getSupportedPropsForRole(role);
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propertyName = property.name.text.toLowerCase();
+				if (!propertyName.startsWith("aria-") || supportedProps.has(propertyName)) continue;
+				context.report({
+					data: {
+						prop: propertyName,
+						role
+					},
+					message: "unsupportedProp",
+					range: getTSNodeRange(property.name, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/roleTags.ts
+const roleToElement = {
+	article: "article",
+	banner: "header",
+	button: "button",
+	checkbox: "input[type='checkbox']",
+	complementary: "aside",
+	contentinfo: "footer",
+	definition: "dd",
+	dialog: "dialog",
+	figure: "figure",
+	form: "form",
+	heading: "h1-h6",
+	img: "img",
+	link: "a",
+	list: "ul/ol",
+	listitem: "li",
+	main: "main",
+	navigation: "nav",
+	radio: "input[type='radio']",
+	region: "section",
+	row: "tr",
+	rowgroup: "tbody/tfoot/thead",
+	table: "table",
+	term: "dt",
+	textbox: "input[type='text']/textarea"
+};
+var roleTags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA roles that have semantic HTML element equivalents.",
+		id: "roleTags",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferSemanticElement: {
+		primary: "<{{ currentElement }}> with role='{{ role }}' is a less-accessible equivalent to <{{ semanticElement }}>.",
+		secondary: [
+			"Semantic HTML elements have built-in accessibility features.",
+			"Using native elements is more maintainable than ARIA roles.",
+			"Browsers provide better default behavior for semantic elements."
+		],
+		suggestions: ["Replace with the semantic HTML element"]
+	} },
+	setup(context) {
+		function checkRole(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() !== node.tagName.text) return;
+			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
+			if (roleProperty?.kind !== SyntaxKind.JsxAttribute || roleProperty.initializer?.kind !== SyntaxKind.StringLiteral) return;
+			const role = roleProperty.initializer.text;
+			const semanticElement = roleToElement[role];
+			if (semanticElement) context.report({
+				data: {
+					currentElement: node.tagName.text,
+					role,
+					semanticElement
+				},
+				message: "preferSemanticElement",
+				range: getTSNodeRange(roleProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkRole,
+			JsxSelfClosingElement: checkRole
+		} };
+	}
+});
+//#endregion
+//#region src/rules/scopeProps.ts
+var scopeProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports scope props on non-th elements.",
+		id: "scopeProps",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { invalidScope: {
+		primary: "The `scope` prop only has an effect on <th> elements.",
+		secondary: [
+			"The scope attribute defines whether a table header is a column header or row header.",
+			"Using it on non-<th> elements has no semantic meaning and may confuse assistive technologies.",
+			"This is required for WCAG 1.3.1 and 4.1.1 compliance."
+		],
+		suggestions: ["Remove the scope prop from this element", "Change this element to a <th> element if it's a table header"]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() === "th") return;
+			const scopeProperty = node.attributes.properties.find((property) => {
+				return property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "scope";
+			});
+			if (!scopeProperty) return;
+			context.report({
+				message: "invalidScope",
+				range: getTSNodeRange(scopeProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/staticElementInteractions.ts
+const interactiveHandlers = [
+	"onClick",
+	"onKeyDown",
+	"onKeyPress",
+	"onKeyUp",
+	"onMouseDown",
+	"onMouseUp"
+];
+const interactiveElements = /* @__PURE__ */ new Set([
+	"a",
+	"button",
+	"input",
+	"select",
+	"textarea"
+]);
+var staticElementInteractions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports static elements with event handlers that lack ARIA roles.",
+		id: "staticElementInteractions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingRole: {
+		primary: "This static element that handles events is missing a role attribute.",
+		secondary: [
+			"Static HTML elements like <div> and <span> have no semantic meaning.",
+			"Interactive handlers require a role to convey purpose to assistive technology and search engine crawlers.",
+			"Required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Add a role attribute (e.g. `role='button'`)", "Use a semantic HTML element instead (e.g. `<button>`)"]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() !== node.tagName.text) return;
+			const elementName = node.tagName.text.toLowerCase();
+			if (interactiveElements.has(elementName)) return;
+			let hadInteractiveHandler = false;
+			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier) {
+				if (property.name.text === "role") return;
+				if (interactiveHandlers.includes(property.name.text)) hadInteractiveHandler = true;
+			}
+			if (!hadInteractiveHandler) return;
+			context.report({
+				message: "missingRole",
+				range: getTSNodeRange(node.tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+//#endregion
+//#region src/rules/svgTitles.ts
+var svgTitles_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports <svg> elements without a <title> child element.",
+		id: "svgTitles",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { missingTitle: {
+		primary: "This <svg> element is missing a <title> child element.",
+		secondary: [
+			"SVG elements without a title are not accessible to screen readers.",
+			"The <title> element provides a text description of the SVG's content.",
+			"This is required for WCAG 1.1.1 compliance."
+		],
+		suggestions: ["Add a <title> child element with descriptive text", "Use aria-label or aria-labelledby as an alternative"]
+	} },
+	setup(context) {
+		function hasValidAriaLabel(attributes) {
+			return attributes.properties.some((property) => {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier || property.name.text !== "aria-label" && property.name.text !== "aria-labelledby") return false;
+				if (!property.initializer) return false;
+				if (property.initializer.kind === SyntaxKind.JsxExpression) {
+					const { expression } = property.initializer;
+					if (!expression) return false;
+					if (expression.kind === SyntaxKind.StringLiteral || expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return expression.text !== "";
+					if (expression.kind === SyntaxKind.Identifier) return expression.text !== "undefined";
+				}
+				if (property.initializer.kind === SyntaxKind.StringLiteral) return property.initializer.text !== "";
+				return false;
+			});
+		}
+		function checkElement(node, { sourceFile }) {
+			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
+			if (tagName.kind !== SyntaxKind.Identifier || tagName.text.toLowerCase() !== "svg") return;
+			if (hasValidAriaLabel(node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes)) return;
+			if (node.kind === SyntaxKind.JsxElement && node.children.some(isTitleElement)) return;
+			context.report({
+				message: "missingTitle",
+				range: getTSNodeRange(tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+function isTitleElement(node) {
+	if (node.kind !== SyntaxKind.JsxElement && node.kind !== SyntaxKind.JsxSelfClosingElement) return false;
+	const childTagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
+	return childTagName.kind === SyntaxKind.Identifier && childTagName.text === "title";
+}
+//#endregion
+//#region src/rules/tabIndexPositiveValues.ts
+var tabIndexPositiveValues_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports positive tabIndex values.",
+		id: "tabIndexPositiveValues",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noPositiveTabIndex: {
+		primary: "Positive `tabIndex` values disrupt tab order and make keyboard navigation unpredictable.",
+		secondary: [
+			"Injecting elements on top of the default tab order with positive `tabIndex` values changes from the intuitive order for users.",
+			"Use tabIndex=\"0\" to include elements in the natural tab order, or tabIndex=\"-1\" to make them programmatically focusable.",
+			"This is required for WCAG 2.4.3 compliance."
+		],
+		suggestions: [
+			"Use tabIndex=\"0\" for elements that should be in the tab order",
+			"Use tabIndex=\"-1\" for elements that should be programmatically focusable",
+			"Remove tabIndex to use the default tab order"
+		]
+	} },
+	setup(context) {
+		return { visitors: { JsxAttribute(node, { sourceFile }) {
+			if (node.name.kind !== SyntaxKind.Identifier || node.name.text.toLowerCase() !== "tabindex" || !node.initializer) return;
+			const value = getInitializerValue(node.initializer);
+			if (value !== void 0 && value > 0) context.report({
+				message: "noPositiveTabIndex",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+function getInitializerValue(initializer) {
+	if (initializer.kind === SyntaxKind.StringLiteral) {
+		const parsed = Number(initializer.text);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+	if (initializer.kind === SyntaxKind.JsxExpression) return initializer.expression?.kind === SyntaxKind.NumericLiteral ? Number(initializer.expression.text) : void 0;
+}
+//#endregion
+//#region src/rules/unescapedEntities.ts
+const problematicEntities = [
+	{
+		entity: "\"",
+		toBrace: "{\"\\\"\"}",
+		toHTML: "&quot;"
+	},
+	{
+		entity: "'",
+		toBrace: "{\"'\"}",
+		toHTML: "&#39;"
+	},
+	{
+		entity: ">",
+		toBrace: "{'>'}",
+		toHTML: "&gt;"
+	},
+	{
+		entity: "}",
+		toBrace: "{'}'}",
+		toHTML: "&#125;"
+	}
+];
+var unescapedEntities_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow unescaped HTML entities in JSX text that may cause rendering issues.",
+		id: "unescapedEntities",
+		presets: ["stylistic"]
+	},
+	messages: { unescapedEntity: {
+		primary: "This unescaped entity `{{ entity }}` may not render properly.",
+		secondary: ["Certain characters like >, <, \", ', {, and } can cause issues in JSX when not properly escaped.", "React may not render these characters correctly or they might break JSX syntax."],
+		suggestions: ["Use HTML entities: {{ html }}", "Wrap in JSX expression: {{ brace }}"]
+	} },
+	setup(context) {
+		return { visitors: { JsxText(node, { sourceFile }) {
+			const nodeStart = node.getStart(sourceFile);
+			const reports = [];
+			for (const { entity, toBrace, toHTML } of problematicEntities) {
+				let index = 0;
+				while ((index = node.text.indexOf(entity, index)) !== -1) {
+					reports.push({
+						begin: nodeStart + index,
+						data: {
+							brace: toBrace,
+							entity,
+							html: toHTML
+						},
+						end: nodeStart + index + entity.length
+					});
+					index += entity.length;
+				}
+			}
+			for (const report of reports.toSorted((a, b) => a.begin - b.begin)) context.report({
+				data: report.data,
+				message: "unescapedEntity",
+				range: {
+					begin: report.begin,
+					end: report.end
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+//#region src/rules/unnecessaryFragments.ts
+var unnecessaryFragments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow unnecessary JSX fragments that wrap a single child or have no children.",
+		id: "unnecessaryFragments",
+		presets: ["stylistic"]
+	},
+	messages: { unnecessaryFragment: {
+		primary: "Unnecessary fragment wrapping {{ childType }}.",
+		secondary: [
+			"Fragments are only needed when rendering multiple adjacent elements.",
+			"A fragment wrapping a single child or no children adds unnecessary complexity.",
+			"Remove the fragment and use the child directly, or remove empty fragments entirely."
+		],
+		suggestions: ["Remove the fragment wrapper and use the child element directly."]
+	} },
+	setup(context) {
+		function checkNodeChildren(node, range) {
+			const children = node.children.filter((child) => child.kind !== SyntaxKind.JsxText || !!child.text.trim().length);
+			let childType;
+			if (!children.length) childType = "no children";
+			else if (children.length === 1) childType = "a single child";
+			if (childType) context.report({
+				data: { childType },
+				message: "unnecessaryFragment",
+				range
+			});
+		}
+		return { visitors: {
+			JsxElement(node, { sourceFile }) {
+				if (node.openingElement.tagName.kind === SyntaxKind.Identifier && !node.openingElement.attributes.properties.length && node.openingElement.tagName.text === "Fragment") checkNodeChildren(node, {
+					begin: node.openingElement.getStart(sourceFile),
+					end: node.closingElement.getEnd()
+				});
+			},
+			JsxFragment(node, { sourceFile }) {
+				checkNodeChildren(node, {
+					begin: node.openingFragment.getStart(sourceFile),
+					end: node.closingFragment.getEnd()
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/plugin.ts
+const jsFiles = ["**/*.jsx"];
+const tsFiles = ["**/*.tsx"];
+const jsx = createPlugin({
+	files: {
+		all: [...jsFiles, ...tsFiles],
+		javascript: jsFiles,
+		typescript: tsFiles
+	},
+	name: "JSX",
+	rules: [
+		accessKeys_default,
+		altTexts_default,
+		anchorAmbiguousText_default,
+		anchorContent_default,
+		anchorValidity_default,
+		ariaActiveDescendantTabIndex_default,
+		ariaHiddenFocusables_default,
+		ariaProps_default,
+		ariaPropTypes_default,
+		ariaRoleValidity_default,
+		ariaUnsupportedElements_default,
+		autocomplete_default,
+		autoFocusProps_default,
+		booleanValues_default,
+		bracedStatements_default,
+		buttonTypes_default,
+		childrenProps_default,
+		clickEventKeyEvents_default,
+		commentTextNodes_default,
+		distractingElements_default,
+		elementChildrenValidity_default,
+		headingContents_default,
+		htmlLangs_default,
+		iframeTitles_default,
+		interactiveElementRoles_default,
+		interactiveElementsFocusable_default,
+		labelAssociatedControls_default,
+		langValidity_default,
+		mediaCaptions_default,
+		mouseEventKeyEvents_default,
+		nonInteractiveElementInteractions_default,
+		nonInteractiveElementRoles_default,
+		nonInteractiveElementTabIndexes_default,
+		propDuplicates_default,
+		roleRedundancies_default,
+		roleRequiredAriaProps_default,
+		roleSupportedAriaProps_default,
+		roleTags_default,
+		scopeProps_default,
+		staticElementInteractions_default,
+		svgTitles_default,
+		tabIndexPositiveValues_default,
+		unescapedEntities_default,
+		unnecessaryFragments_default
+	]
+});
+//#endregion
+export { jsx };