praxis-kit 0.1.0

package/dist/html/index.js

@@ -0,0 +1,1244 @@
+import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
+//#region ../../lib/foundation/src/type-guards.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+function isUndefined(value) {
+	return value === void 0;
+}
+function isNull(value) {
+	return value === null;
+}
+function isNonNull(value) {
+	return value != null;
+}
+function isNullish(value) {
+	return isNull(value) || isUndefined(value);
+}
+//#endregion
+//#region ../../lib/contract/src/diagnostics/anchor-accessibility.ts
+function createDiagnostic(input) {
+	return {
+		category: DiagnosticCategory.Accessibility,
+		...input
+	};
+}
+const AnchorAccessibilityDiagnostics = {
+	roleButtonWithHref() {
+		return createDiagnostic({
+			code: DiagnosticCode.A11yAnchorRoleButtonWithHref,
+			severity: "warning",
+			message: "role=\"button\" on an <a> with an href overrides its navigation semantics for assistive technology; use a real <button> element, or remove href, if this element should not navigate.",
+			rationale: "Assistive technology announces role=\"button\" as a button, not a link — but the element still follows the link when activated by mouse or keyboard, which is confusing and inconsistent with how a button is expected to behave.",
+			suggestions: [{
+				title: "Use a real <button>",
+				description: "If this element should not navigate, render a <button> instead of an <a>."
+			}, {
+				title: "Remove role=\"button\"",
+				description: "If this element should navigate, keep the default link role."
+			}]
+		});
+	},
+	ariaDisabledInert() {
+		return createDiagnostic({
+			code: DiagnosticCode.A11yAnchorAriaDisabledInert,
+			severity: "warning",
+			message: "aria-disabled does not prevent an <a> from being focused, clicked, or navigated via keyboard; remove href, or prevent navigation yourself, if this link should be inert.",
+			rationale: "Unlike a native form control, an <a> has no disabled state the browser enforces — aria-disabled only changes what assistive technology announces, not what actually happens when the link is activated by mouse or keyboard.",
+			suggestions: [{
+				title: "Remove href",
+				description: "If this element is temporarily unavailable, remove href until it can be activated."
+			}, {
+				title: "Prevent navigation when disabled",
+				description: "Prevent the click and keyboard activation when the link is disabled so it behaves consistently for all users."
+			}]
+		});
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/aria.ts
+const AriaDiagnostics = {
+	/** Generic bridge for violations produced by external AriaRule functions. */
+	fromViolation(v) {
+		return {
+			code: DiagnosticCode.AriaViolation,
+			category: DiagnosticCategory.ARIA,
+			message: v.message
+		};
+	},
+	attributeInvalid(key, role) {
+		return {
+			code: DiagnosticCode.AriaAttributeInvalid,
+			category: DiagnosticCategory.ARIA,
+			message: `"${key}" is not valid on role="${role}". It will be removed.`,
+			rationale: "Invalid ARIA attributes are ignored by assistive technology and may trigger accessibility-tree warnings in browser devtools.",
+			suggestions: [{
+				title: "Remove the attribute",
+				description: `"${key}" is not in the allowed attribute set for role="${role}".`
+			}]
+		};
+	},
+	missingLiveRegion(role, impliedLive) {
+		return {
+			code: DiagnosticCode.AriaMissingLiveRegion,
+			category: DiagnosticCategory.ARIA,
+			message: `role="${role}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`,
+			rationale: "Live-region roles announce dynamic content changes to screen readers. Without aria-live the politeness level is unspecified and announcements may be silent.",
+			suggestions: [{
+				title: `Add aria-live="${impliedLive}"`,
+				description: `role="${role}" conventionally implies aria-live="${impliedLive}".`,
+				fix: `aria-live="${impliedLive}"`
+			}]
+		};
+	},
+	missingAtomic(role) {
+		return {
+			code: DiagnosticCode.AriaMissingAtomic,
+			category: DiagnosticCategory.ARIA,
+			message: `role="${role}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`,
+			rationale: "aria-atomic controls whether assistive technology announces the entire live region or only the changed nodes. Omitting it leaves the behaviour browser-defined."
+		};
+	},
+	relevantInvalidTokens(invalid) {
+		const quoted = invalid.map((t) => `"${t}"`).join(", ");
+		return {
+			code: DiagnosticCode.AriaRelevantInvalidToken,
+			category: DiagnosticCategory.ARIA,
+			message: `aria-relevant contains invalid token(s): ${quoted}. Valid tokens are: additions, removals, text, all.`,
+			rationale: "aria-relevant accepts a space-separated list of change types. Unrecognised tokens are silently ignored by assistive technology, making the attribute ineffective.",
+			suggestions: [{
+				title: "Use only valid tokens",
+				description: "Valid values are: additions, removals, text, all (or a space-separated combination)."
+			}]
+		};
+	},
+	relevantSuperseded() {
+		return {
+			code: DiagnosticCode.AriaRelevantSuperseded,
+			category: DiagnosticCategory.ARIA,
+			message: "aria-relevant includes \"all\" alongside other tokens. \"all\" supersedes additions, removals, and text — use aria-relevant=\"all\" alone.",
+			rationale: "\"all\" is equivalent to \"additions removals text\". Combining it with other tokens is redundant and may confuse readers of the markup.",
+			suggestions: [{
+				title: "Use aria-relevant=\"all\"",
+				fix: "aria-relevant=\"all\""
+			}]
+		};
+	},
+	missingAccessibleName(tag) {
+		return {
+			code: DiagnosticCode.AriaMissingAccessibleName,
+			category: DiagnosticCategory.ARIA,
+			message: `<${tag}> has no accessible name. Add aria-label or aria-labelledby.`,
+			rationale: "Elements with a landmark or interactive role must have an accessible name so that assistive technology can identify them when presenting the page outline.",
+			suggestions: [{
+				title: "Add aria-label",
+				description: `Add aria-label="…" directly to the <${tag}> element.`
+			}, {
+				title: "Add aria-labelledby",
+				description: "Point aria-labelledby at the id of an existing heading or label element."
+			}]
+		};
+	},
+	nameProhibited(attr, role) {
+		return {
+			code: DiagnosticCode.AriaNameProhibited,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" is prohibited on role="${role}" — this role does not support a name from the author. It will be removed.`,
+			rationale: "WAI-ARIA 1.2 lists a set of roles (generic, presentation/none, and the inline text-level roles) as Name Prohibited: aria-label / aria-labelledby on them are a conformance error and are ignored by assistive technology.",
+			suggestions: [{
+				title: "Remove the attribute",
+				description: `role="${role}" cannot be named. If the element needs an accessible name, give it a role that supports one (or use visible text / a wrapping labelled element).`
+			}]
+		};
+	},
+	attributeOnPresentational(attr, tag) {
+		return {
+			code: DiagnosticCode.AriaAttributeOnPresentational,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" is not allowed on a presentational <${tag}>. Presentational elements are invisible to assistive technology.`,
+			rationale: "role=\"none\" and role=\"presentation\" (including <img alt=\"\">) remove an element from the accessibility tree. ARIA attributes on such elements are ignored by assistive technology.",
+			suggestions: [{
+				title: "Remove the attribute",
+				description: `"${attr}" has no effect when the element has role="none" or role="presentation".`
+			}]
+		};
+	},
+	ariaHiddenOnFocusable(tag) {
+		return {
+			code: DiagnosticCode.AriaHiddenOnFocusable,
+			category: DiagnosticCategory.ARIA,
+			message: `aria-hidden="true" must not be used on focusable <${tag}> elements. Screen reader users who navigate by keyboard will encounter the element but receive no information about it.`,
+			rationale: "aria-hidden removes an element from the accessibility tree while leaving it keyboard-reachable. This creates a \"ghost\" — a focusable element assistive technology cannot describe.",
+			suggestions: [{
+				title: "Remove aria-hidden",
+				description: "If the element should be hidden from all users, use the HTML hidden attribute or CSS display:none instead."
+			}, {
+				title: "Make the element non-focusable",
+				description: "If the element is intentionally decorative, add tabindex=\"-1\" and disable it so it is not reachable by keyboard."
+			}]
+		};
+	},
+	invalidAttributeValue(attr, value, expected) {
+		const got = value === null ? "null" : value === void 0 ? "undefined" : typeof value === "string" ? `"${value}"` : String(value);
+		return {
+			code: DiagnosticCode.AriaInvalidAttributeValue,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" has an invalid value (${got}). Expected: ${expected}.`,
+			rationale: "ARIA attributes with invalid values are silently ignored by assistive technology, making the markup semantically inert.",
+			suggestions: [{
+				title: `Use a valid value for ${attr}`,
+				description: `Valid values are: ${expected}.`
+			}]
+		};
+	},
+	redundantAriaLevel(tag, level) {
+		return {
+			code: DiagnosticCode.AriaRedundantLevelAttribute,
+			category: DiagnosticCategory.ARIA,
+			message: `aria-level="${level}" is redundant on <${tag}>: the element already has an implicit heading level of ${level}. Remove the attribute.`,
+			rationale: "Restating the implicit aria-level adds noise without semantic value. Use aria-level only to override the native heading level (e.g. aria-level=\"3\" on <h2>).",
+			suggestions: [{
+				title: "Remove aria-level",
+				description: `<${tag}> already implies aria-level="${level}".`
+			}]
+		};
+	},
+	requiredProperty(attr, role) {
+		return {
+			code: DiagnosticCode.AriaRequiredProperty,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" is required for role="${role}" but is missing.`,
+			rationale: `WAI-ARIA 1.2 specifies required states and properties for certain roles. Without "${attr}", assistive technology cannot correctly communicate the element's state to users.`,
+			suggestions: [{
+				title: `Add ${attr}`,
+				description: `role="${role}" requires "${attr}" to be present.`
+			}]
+		};
+	},
+	invalidRole(role, tag) {
+		return {
+			code: DiagnosticCode.AriaInvalidRole,
+			category: DiagnosticCategory.ARIA,
+			message: `Invalid role "${role ?? ""}" on <${tag}>.`,
+			rationale: "An unrecognised or misapplied ARIA role is ignored by assistive technology and may degrade the accessibility of the element."
+		};
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/html.ts
+const ATTRIBUTE_IGNORED_CODES = {
+	checked: DiagnosticCode.HtmlInputCheckedIgnoredForType,
+	multiple: DiagnosticCode.HtmlInputMultipleIgnoredForType,
+	maxLength: DiagnosticCode.HtmlInputMaxLengthIgnoredForType,
+	minLength: DiagnosticCode.HtmlInputMinLengthIgnoredForType,
+	pattern: DiagnosticCode.HtmlInputPatternIgnoredForType,
+	min: DiagnosticCode.HtmlInputMinIgnoredForType,
+	max: DiagnosticCode.HtmlInputMaxIgnoredForType,
+	step: DiagnosticCode.HtmlInputStepIgnoredForType,
+	accept: DiagnosticCode.HtmlInputAcceptIgnoredForType,
+	capture: DiagnosticCode.HtmlInputCaptureIgnoredForType,
+	size: DiagnosticCode.HtmlInputSizeIgnoredForType,
+	alt: DiagnosticCode.HtmlInputAltIgnoredForType,
+	height: DiagnosticCode.HtmlInputHeightIgnoredForType,
+	width: DiagnosticCode.HtmlInputWidthIgnoredForType
+};
+const HtmlDiagnostics = {
+	emptyRole(tag) {
+		return {
+			code: DiagnosticCode.HtmlEmptyRole,
+			category: DiagnosticCategory.HTML,
+			severity: "warning",
+			message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
+		};
+	},
+	implicitRoleRedundant(tag, implicitRole) {
+		return {
+			code: DiagnosticCode.HtmlImplicitRoleRedundant,
+			category: DiagnosticCategory.HTML,
+			severity: "warning",
+			message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+		};
+	},
+	implicitRoleOverride(tag, implicitRole, role) {
+		return {
+			code: DiagnosticCode.HtmlImplicitRoleOverride,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+		};
+	},
+	standaloneRegionOverride(tag, implicitRole) {
+		return {
+			code: DiagnosticCode.HtmlStandaloneRegionOverride,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
+		};
+	},
+	landmarkRoleOverride(tag, implicitRole, role) {
+		return {
+			code: DiagnosticCode.HtmlLandmarkRoleOverride,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
+		};
+	},
+	invalidChild(child, parent, allowed) {
+		return {
+			code: DiagnosticCode.HtmlInvalidChild,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${child}> is not a valid direct child of <${parent}>. Allowed: ${allowed}.`
+		};
+	},
+	roleNotPermitted(tag, role, allowedRoles) {
+		const allowed = allowedRoles.length > 0 ? allowedRoles.map((r) => `"${r}"`).join(", ") : "none — no explicit role is permitted on this element";
+		return {
+			code: DiagnosticCode.HtmlRoleNotPermitted,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `role="${role}" is not permitted on <${tag}>. Allowed alternate role(s): ${allowed}.`,
+			rationale: "The WAI-ARIA \"ARIA in HTML\" specification restricts which explicit roles a native element may take. A role outside that set is ignored or produces undefined behavior in assistive technology."
+		};
+	},
+	input: {
+		unsupportedType(type) {
+			return {
+				code: DiagnosticCode.HtmlInputUnsupportedType,
+				category: DiagnosticCategory.HTML,
+				severity: "warning",
+				message: `type="${type}" is not a value defined by the HTML specification. Browsers silently fall back to type="text".`,
+				rationale: "An unrecognized input type is not invalid markup — the spec requires the \"text\" fallback — but it usually means a typo, since the input keeps working while silently losing the intended type-specific behavior (validation, virtual keyboard, picker UI).",
+				suggestions: [{
+					title: "Check for a typo in the type value",
+					description: `"${type}" does not match any HTML5 input type.`
+				}]
+			};
+		},
+		attributeIgnoredForType(attribute, type, allowedTypes) {
+			const allowed = allowedTypes.map((t) => `"${t}"`).join(", ");
+			return {
+				code: ATTRIBUTE_IGNORED_CODES[attribute],
+				category: DiagnosticCategory.HTML,
+				severity: "warning",
+				message: `"${attribute}" is ignored on <input type="${type}">.`,
+				rationale: `"${attribute}" only has an effect when type is one of: ${allowed}. Browsers silently ignore it on other input types.`,
+				suggestions: [{
+					title: `Remove "${attribute}"`,
+					description: `"${attribute}" only affects <input> when type is one of: ${allowed}.`
+				}]
+			};
+		}
+	},
+	anchor: { dangerousHref(href) {
+		return {
+			code: DiagnosticCode.HtmlAnchorDangerousHref,
+			category: DiagnosticCategory.HTML,
+			severity: "warning",
+			message: `href="${href}" uses a scheme that executes attacker-controlled content when navigated to. It has been removed.`,
+			rationale: "\"javascript:\", \"data:\", and \"vbscript:\" URLs are a common XSS vector when href comes from untrusted input — none of the three are needed for legitimate navigation."
+		};
+	} }
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/input-accessibility.ts
+function accessibilityFact(input) {
+	return {
+		category: DiagnosticCategory.Accessibility,
+		...input
+	};
+}
+const InputAccessibilityDiagnostics = {
+	missingAccessibleName() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputMissingAccessibleName,
+			severity: "warning",
+			message: "This input has no accessible name. Add an associated <label>, aria-label, or aria-labelledby.",
+			rationale: "Assistive technology announces a form field by its accessible name; without one, users of screen readers cannot tell what the field is for.",
+			suggestions: [{
+				title: "Add aria-label",
+				description: "Set aria-label=\"…\" directly on the input."
+			}, {
+				title: "Add an associated <label>",
+				description: "Wrap the input in a <label>, or point a <label for=\"…\"> at its id."
+			}]
+		});
+	},
+	placeholderIsNotLabel() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputPlaceholderNotLabel,
+			severity: "warning",
+			message: "Placeholder text does not provide an accessible name. Add an associated <label>, aria-label, or aria-labelledby.",
+			rationale: "Placeholder text disappears as users interact with the field and is not treated as the control's accessible name by many assistive technologies.",
+			suggestions: [{
+				title: "Add aria-label",
+				description: "Set aria-label=\"…\" directly on the input."
+			}, {
+				title: "Add an associated <label>",
+				description: "Wrap the input in a <label>, or point a <label for=\"…\"> at its id."
+			}]
+		});
+	},
+	passwordMissingAutocomplete() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputPasswordAutocomplete,
+			severity: "warning",
+			message: "Password inputs should specify an autoComplete value.",
+			rationale: "Without an explicit autocomplete hint, password managers and browsers cannot reliably tell a sign-in field apart from a password-creation field.",
+			suggestions: [{
+				title: "Set autoComplete=\"current-password\"",
+				description: "Use this for sign-in forms."
+			}, {
+				title: "Set autoComplete=\"new-password\"",
+				description: "Use this for sign-up / change-password forms."
+			}]
+		});
+	},
+	requiredReadOnlyConflict() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputRequiredReadOnlyConflict,
+			severity: "warning",
+			message: "\"required\" has no effect while this field is readOnly — the two attributes together usually signal an unintended state.",
+			rationale: "The combination is valid HTML, but a readOnly control cannot be edited, so its \"required\" constraint can never be satisfied or violated through user interaction. Consider using disabled instead of readOnly, or only applying required when the field is editable."
+		});
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/aria/factories.ts
+/**
+* Builds a correctly-literal-typed `fixable: false` `AriaResult`. Exists so a rule author can
+* extract shared branch logic (severity/attribute/message computed once, reused across multiple
+* `return`s) without TypeScript silently widening `valid: false`/`fixable: false` to `boolean`
+* the moment those values leave an object-literal-in-return-position — the widening only happens
+* on plain object literals; a function's declared return type narrows unconditionally.
+*/
+function invalidWithoutFix(input) {
+	return {
+		valid: false,
+		fixable: false,
+		severity: input.severity,
+		...isDefined(input.attribute) && { attribute: input.attribute },
+		...isDefined(input.message) && { message: input.message },
+		...isDefined(input.diagnostic) && { diagnostic: input.diagnostic }
+	};
+}
+/** Same as {@link invalidWithoutFix}, for the `fixable: true` branch — requires a `fix`. */
+function invalidWithFix(input) {
+	return {
+		valid: false,
+		fixable: true,
+		severity: input.severity,
+		...isDefined(input.attribute) && { attribute: input.attribute },
+		...isDefined(input.message) && { message: input.message },
+		...isDefined(input.diagnostic) && { diagnostic: input.diagnostic },
+		fix: input.fix
+	};
+}
+function removeProp(props, key) {
+	const next = { ...props };
+	delete next[key];
+	return next;
+}
+/**
+* Builds an `AriaFix` that strips a single attribute — the shape `dangerousHrefRule`-style
+* "strip this attribute when it's dangerous/redundant" rules need. A no-op (`applied: false`) when
+* the attribute isn't present, so applying the fix twice (or applying it when nothing triggered it)
+* is always safe. Frozen — a fix is a value object; nothing should mutate `kind`/`attribute`/`apply`
+* after construction.
+*/
+function removeAttributeFix(attribute) {
+	return Object.freeze({
+		kind: "removeAttribute",
+		attribute,
+		apply: ({ props }) => {
+			if (!(attribute in props)) return {
+				applied: false,
+				next: props
+			};
+			return {
+				applied: true,
+				next: removeProp(props, attribute),
+				previous: props
+			};
+		}
+	});
+}
+function defineRuleMetadata(rule, metadata) {
+	const descriptors = {};
+	for (const key of Object.keys(metadata)) descriptors[key] = {
+		value: metadata[key],
+		enumerable: false
+	};
+	Object.defineProperties(rule, descriptors);
+	return rule;
+}
+/**
+* Convenience factory for the single most common `enforcement.aria`/`enforcement.rules` shape:
+* "strip this attribute when some condition on the element's own props holds" — covers
+* security-style guards (a dangerous URL scheme on `href`) and redundant-attribute rules alike,
+* without hand-writing the rule function, the `AriaFix`, and the `invalidWithFix` call each time.
+* A rule with no fix (a warn-only advisory) still needs the raw `AriaRule` shape directly — this
+* factory is deliberately scoped to the strip-on-match case, not a general rule builder.
+*/
+function createRemoveAttributeRule(attribute, options) {
+	const { when, severity = "warning", message, diagnostic, readsProps, tags } = options;
+	const fix = removeAttributeFix(attribute);
+	const rule = (context) => {
+		if (!when(context)) return [];
+		return [invalidWithFix({
+			severity,
+			attribute,
+			...isDefined(message) && { message },
+			...isDefined(diagnostic) && { diagnostic: diagnostic(context) },
+			fix
+		})];
+	};
+	return defineRuleMetadata(rule, {
+		...isDefined(readsProps) && { readsProps },
+		...isDefined(tags) && { tags }
+	});
+}
+//#endregion
+//#region ../core/src/html/contracts/categories.ts
+/**
+* HTML elements with implicit landmark roles.
+*
+* `<section>` and `<form>` are intentionally excluded because their landmark
+* semantics depend on having an accessible name.
+*/
+const LANDMARK_TAGS = [
+	"article",
+	"aside",
+	"footer",
+	"header",
+	"main",
+	"nav"
+];
+//#endregion
+//#region ../core/src/html/anchor-rules.ts
+const DANGEROUS_URL_SCHEMES = [
+	"javascript:",
+	"data:",
+	"vbscript:"
+];
+function normalizeForSchemeCheck(href) {
+	return href.replace(/[\x00-\x20]/g, "").toLowerCase();
+}
+function isDangerousUrl(href) {
+	if (!isString(href)) return false;
+	const normalized = normalizeForSchemeCheck(href);
+	return DANGEROUS_URL_SCHEMES.some((scheme) => normalized.startsWith(scheme));
+}
+const dangerousHrefRule = createRemoveAttributeRule("href", {
+	when: ({ props }) => isDangerousUrl(props.href),
+	severity: "warning",
+	diagnostic: ({ props }) => HtmlDiagnostics.anchor.dangerousHref(props.href),
+	readsProps: ["href"],
+	tags: ["a"]
+});
+const roleButtonWithHrefRule = Object.assign(({ props }) => {
+	if (props.role !== "button" || !isString(props.href) || props.href.length === 0) return [];
+	const diagnostic = AnchorAccessibilityDiagnostics.roleButtonWithHref();
+	return [invalidWithoutFix({
+		severity: diagnostic.severity,
+		attribute: "role",
+		diagnostic
+	})];
+}, {
+	readsProps: ["role", "href"],
+	tags: ["a"]
+});
+const ariaDisabledInertRule = Object.assign(({ props }) => {
+	const ariaDisabled = props["aria-disabled"];
+	const isDisabled = ariaDisabled === true || ariaDisabled === "true";
+	const hasHref = isString(props.href) && props.href.length > 0;
+	if (!isDisabled || !hasHref) return [];
+	const diagnostic = AnchorAccessibilityDiagnostics.ariaDisabledInert();
+	return [invalidWithoutFix({
+		severity: diagnostic.severity,
+		attribute: "aria-disabled",
+		diagnostic
+	})];
+}, {
+	readsProps: ["aria-disabled", "href"],
+	tags: ["a"]
+});
+const ANCHOR_RULES = [
+	dangerousHrefRule,
+	roleButtonWithHrefRule,
+	ariaDisabledInertRule
+];
+//#endregion
+//#region ../core/src/html/spec/vocabulary/input.ts
+const TEXT_INPUT_TYPES = [
+	"text",
+	"search",
+	"url",
+	"tel",
+	"email",
+	"password"
+];
+const NUMERIC_INPUT_TYPES = [
+	"number",
+	"range",
+	"date",
+	"month",
+	"week",
+	"time",
+	"datetime-local"
+];
+const HTML_INPUT_TYPES = /* @__PURE__ */ new Set([
+	...TEXT_INPUT_TYPES,
+	...NUMERIC_INPUT_TYPES,
+	"checkbox",
+	"radio",
+	"file",
+	"color",
+	"hidden",
+	"button",
+	"submit",
+	"reset",
+	"image"
+]);
+//#endregion
+//#region ../core/src/html/spec/attributes/input.ts
+const INPUT_ATTRIBUTE_TYPE_POLICIES = [
+	{
+		attribute: "checked",
+		allowedTypes: ["checkbox", "radio"]
+	},
+	{
+		attribute: "multiple",
+		allowedTypes: ["email", "file"]
+	},
+	{
+		attribute: "maxLength",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "minLength",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "pattern",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "min",
+		allowedTypes: NUMERIC_INPUT_TYPES
+	},
+	{
+		attribute: "max",
+		allowedTypes: NUMERIC_INPUT_TYPES
+	},
+	{
+		attribute: "step",
+		allowedTypes: NUMERIC_INPUT_TYPES
+	},
+	{
+		attribute: "accept",
+		allowedTypes: ["file"]
+	},
+	{
+		attribute: "capture",
+		allowedTypes: ["file"]
+	},
+	{
+		attribute: "size",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "alt",
+		allowedTypes: ["image"]
+	},
+	{
+		attribute: "height",
+		allowedTypes: ["image"]
+	},
+	{
+		attribute: "width",
+		allowedTypes: ["image"]
+	}
+];
+//#endregion
+//#region ../core/src/html/spec/constraints/input.ts
+const REQUIRED_READONLY_CONFLICT = {
+	props: ["required", "readOnly"],
+	diagnostic: () => InputAccessibilityDiagnostics.requiredReadOnlyConflict()
+};
+const INPUT_MUTUALLY_EXCLUSIVE_POLICIES = [REQUIRED_READONLY_CONFLICT];
+//#endregion
+//#region ../core/src/html/spec/validators/attribute-type-validator.ts
+const DEFAULT_INPUT_TYPE = "text";
+function createInputAttributeTypeRule({ attribute, allowedTypes }) {
+	const rule = ({ tag, props, variantKeys }) => {
+		if (tag !== "input" || !(attribute in props)) return [];
+		if (variantKeys?.has(attribute)) return [];
+		const type = typeof props.type === "string" ? props.type : DEFAULT_INPUT_TYPE;
+		if (allowedTypes.includes(type)) return [];
+		const diagnostic = HtmlDiagnostics.input.attributeIgnoredForType(attribute, type, allowedTypes);
+		return [{
+			valid: false,
+			fixable: true,
+			severity: diagnostic.severity,
+			fix: removeAttributeFix(attribute),
+			diagnostic
+		}];
+	};
+	return Object.assign(rule, {
+		readsProps: ["type", attribute],
+		tags: ["input"]
+	});
+}
+//#endregion
+//#region ../core/src/html/spec/validators/mutually-exclusive-validator.ts
+function isBooleanAttrSet(value) {
+	return value !== void 0 && value !== null && value !== false;
+}
+function createMutuallyExclusiveRule({ props: conflictingProps, diagnostic: createDiagnostic }) {
+	const [first, second] = conflictingProps;
+	const rule = ({ tag, props }) => {
+		if (tag !== "input" || !isBooleanAttrSet(props[first]) || !isBooleanAttrSet(props[second])) return [];
+		const diagnostic = createDiagnostic();
+		return [{
+			valid: false,
+			fixable: false,
+			severity: diagnostic.severity,
+			diagnostic
+		}];
+	};
+	return Object.assign(rule, {
+		readsProps: conflictingProps,
+		tags: ["input"]
+	});
+}
+//#endregion
+//#region ../core/src/html/input-rules.ts
+const policyByAttribute = Object.fromEntries(INPUT_ATTRIBUTE_TYPE_POLICIES.map((policy) => [policy.attribute, policy]));
+function policyFor(attribute) {
+	return policyByAttribute[attribute];
+}
+const supportedInputTypeRule = Object.assign(({ tag, props }) => {
+	if (tag !== "input" || typeof props.type !== "string") return [];
+	const type = props.type;
+	if (HTML_INPUT_TYPES.has(type)) return [];
+	const diagnostic = HtmlDiagnostics.input.unsupportedType(type);
+	return [{
+		valid: false,
+		fixable: false,
+		severity: diagnostic.severity,
+		diagnostic
+	}];
+}, {
+	readsProps: ["type"],
+	tags: ["input"]
+});
+const checkedRequiresCheckableTypeRule = createInputAttributeTypeRule(policyFor("checked"));
+const multipleRequiresSupportedTypeRule = createInputAttributeTypeRule(policyFor("multiple"));
+const maxLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("maxLength"));
+const minLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("minLength"));
+const patternRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("pattern"));
+const minRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("min"));
+const maxRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("max"));
+const stepRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("step"));
+const acceptRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("accept"));
+const captureRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("capture"));
+const sizeRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("size"));
+const altRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("alt"));
+const heightRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("height"));
+const widthRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("width"));
+const inputAccessibleNameRule = Object.assign(({ tag, props }) => {
+	if (tag !== "input" || props.type === "hidden") return [];
+	if ("aria-label" in props || "aria-labelledby" in props) return [];
+	const diagnostic = typeof props.placeholder === "string" && props.placeholder.length > 0 ? InputAccessibilityDiagnostics.placeholderIsNotLabel() : InputAccessibilityDiagnostics.missingAccessibleName();
+	return [{
+		valid: false,
+		fixable: false,
+		severity: diagnostic.severity,
+		diagnostic
+	}];
+}, {
+	readsProps: [
+		"type",
+		"aria-label",
+		"aria-labelledby",
+		"placeholder"
+	],
+	tags: ["input"]
+});
+const PASSWORD_AUTOCOMPLETE_VALUES = ["current-password", "new-password"];
+const passwordAutocompleteRule = Object.assign(({ tag, props }) => {
+	if (tag !== "input" || props.type !== "password") return [];
+	const autoComplete = props.autoComplete;
+	const tokens = typeof autoComplete === "string" ? autoComplete.split(" ") : [];
+	if (PASSWORD_AUTOCOMPLETE_VALUES.some((value) => tokens.includes(value))) return [];
+	const diagnostic = InputAccessibilityDiagnostics.passwordMissingAutocomplete();
+	return [{
+		valid: false,
+		fixable: false,
+		severity: diagnostic.severity,
+		diagnostic
+	}];
+}, {
+	readsProps: ["type", "autoComplete"],
+	tags: ["input"]
+});
+const requiredReadOnlyConflictRule = createMutuallyExclusiveRule(REQUIRED_READONLY_CONFLICT);
+const INPUT_RULES = [
+	supportedInputTypeRule,
+	checkedRequiresCheckableTypeRule,
+	multipleRequiresSupportedTypeRule,
+	maxLengthRequiresTextTypeRule,
+	minLengthRequiresTextTypeRule,
+	patternRequiresTextTypeRule,
+	minRequiresNumericTypeRule,
+	maxRequiresNumericTypeRule,
+	stepRequiresNumericTypeRule,
+	acceptRequiresFileTypeRule,
+	captureRequiresFileTypeRule,
+	sizeRequiresTextTypeRule,
+	altRequiresImageTypeRule,
+	heightRequiresImageTypeRule,
+	widthRequiresImageTypeRule,
+	inputAccessibleNameRule,
+	passwordAutocompleteRule,
+	requiredReadOnlyConflictRule
+];
+//#endregion
+//#region ../core/src/html/spec/types.ts
+function resolveAllowedRoles(spec, props) {
+	const policy = spec.allowedRoles;
+	if (!policy) return void 0;
+	switch (policy.kind) {
+		case "fixed": return policy.roles;
+		case "byProp": {
+			const raw = props[policy.prop];
+			const value = typeof raw === "string" && raw in policy.map ? raw : policy.fallback;
+			return policy.map[value];
+		}
+		case "dynamic": return policy.resolve({ props });
+	}
+}
+//#endregion
+//#region ../core/src/html/spec/roles/input.ts
+const ALLOWED_INPUT_ROLES = {
+	checkbox: [
+		"menuitemcheckbox",
+		"option",
+		"switch",
+		"button"
+	],
+	radio: ["menuitemradio"],
+	range: [],
+	number: [],
+	search: [],
+	text: [
+		"combobox",
+		"searchbox",
+		"spinbutton"
+	],
+	email: [],
+	tel: [],
+	url: [],
+	button: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	submit: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	reset: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	image: [
+		"checkbox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	hidden: []
+};
+//#endregion
+//#region ../core/src/html/spec/elements/input.ts
+const LIST_ELIGIBLE_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"search",
+	"tel",
+	"url",
+	"email"
+]);
+function rolesForType(type) {
+	return ALLOWED_INPUT_ROLES[type in ALLOWED_INPUT_ROLES ? type : "text"];
+}
+const inputElementSpec = {
+	tag: "input",
+	allowedRoles: {
+		kind: "dynamic",
+		resolve: ({ props }) => {
+			const type = isString(props.type) ? props.type : "text";
+			if (isNonNull(props.list) && LIST_ELIGIBLE_TYPES.has(type)) return [];
+			return rolesForType(type);
+		}
+	},
+	attributes: INPUT_ATTRIBUTE_TYPE_POLICIES,
+	mutuallyExclusive: INPUT_MUTUALLY_EXCLUSIVE_POLICIES
+};
+//#endregion
+//#region ../core/src/html/spec/roles/img.ts
+const IMG_DECORATIVE_ROLES = ["none", "presentation"];
+const IMG_NAMED_ROLES = [
+	"button",
+	"checkbox",
+	"link",
+	"math",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"meter",
+	"option",
+	"progressbar",
+	"radio",
+	"scrollbar",
+	"separator",
+	"slider",
+	"switch",
+	"tab",
+	"treeitem"
+];
+//#endregion
+//#region ../core/src/html/spec/elements/img.ts
+const imgElementSpec = {
+	tag: "img",
+	allowedRoles: {
+		kind: "dynamic",
+		resolve: ({ props }) => {
+			if (isNullish(props.alt)) return IMG_DECORATIVE_ROLES;
+			return props.alt === "" ? [] : IMG_NAMED_ROLES;
+		}
+	}
+};
+//#endregion
+//#region ../core/src/html/spec/roles/select.ts
+const ALLOWED_SELECT_ROLES = ["menu"];
+//#endregion
+//#region ../core/src/html/spec/elements/select.ts
+function isListBoxSelect(props) {
+	const { multiple, size } = props;
+	if (isNonNull(multiple) && multiple !== false && (!isString(multiple) || multiple.toLowerCase() !== "false")) return true;
+	const parsed = isNumber(size) ? size : isString(size) ? Number(size) : NaN;
+	return Number.isFinite(parsed) && parsed > 1;
+}
+const selectElementSpec = {
+	tag: "select",
+	allowedRoles: {
+		kind: "dynamic",
+		resolve: ({ props }) => isListBoxSelect(props) ? [] : ALLOWED_SELECT_ROLES
+	}
+};
+//#endregion
+//#region ../core/src/html/spec/elements/table.ts
+const tableElementSpec = {
+	tag: "table",
+	allowedRoles: {
+		kind: "fixed",
+		roles: ["grid", "treegrid"]
+	}
+};
+//#endregion
+//#region ../core/src/html/role-restrictions.ts
+const ALLOWED_ROLES = {
+	article: [
+		"application",
+		"document",
+		"feed",
+		"main",
+		"none",
+		"presentation",
+		"region"
+	],
+	aside: [
+		"feed",
+		"none",
+		"note",
+		"presentation",
+		"region",
+		"search"
+	],
+	footer: [
+		"group",
+		"none",
+		"presentation"
+	],
+	header: [
+		"group",
+		"none",
+		"presentation"
+	],
+	main: [],
+	nav: [
+		"menu",
+		"menubar",
+		"none",
+		"presentation",
+		"tablist"
+	],
+	a: [
+		"button",
+		"checkbox",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	button: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	h1: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h2: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h3: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h4: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h5: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h6: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	ul: [
+		"group",
+		"listbox",
+		"menu",
+		"menubar",
+		"none",
+		"presentation",
+		"radiogroup",
+		"tablist",
+		"toolbar",
+		"tree"
+	],
+	ol: [
+		"group",
+		"listbox",
+		"menu",
+		"menubar",
+		"none",
+		"presentation",
+		"radiogroup",
+		"tablist",
+		"toolbar",
+		"tree"
+	],
+	li: [
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"none",
+		"presentation",
+		"radio",
+		"separator",
+		"tab",
+		"treeitem"
+	],
+	dialog: ["alertdialog"],
+	fieldset: [
+		"none",
+		"presentation",
+		"radiogroup"
+	],
+	label: []
+};
+const ELEMENT_SPECS = {
+	input: inputElementSpec,
+	img: imgElementSpec,
+	select: selectElementSpec,
+	table: tableElementSpec
+};
+function getAllowedRoles(tag, props) {
+	const spec = ELEMENT_SPECS[tag];
+	if (spec) return resolveAllowedRoles(spec, props);
+	return ALLOWED_ROLES[tag];
+}
+const removeRoleFix = {
+	kind: "removeRole",
+	apply: ({ props }) => {
+		if (!("role" in props)) return {
+			applied: false,
+			next: props
+		};
+		const { role: _role, ...rest } = props;
+		return {
+			applied: true,
+			next: rest,
+			previous: props
+		};
+	}
+};
+const roleNotPermittedRule = Object.assign(({ tag, props, implicitRole }) => {
+	const role = props.role;
+	if (typeof role !== "string" || role.length === 0 || role === implicitRole) return [];
+	const allowed = getAllowedRoles(tag, props);
+	if (allowed === void 0 || allowed.includes(role)) return [];
+	const diagnostic = HtmlDiagnostics.roleNotPermitted(tag, role, allowed);
+	return [{
+		valid: false,
+		fixable: true,
+		severity: diagnostic.severity,
+		fix: removeRoleFix,
+		diagnostic
+	}];
+}, { readsProps: [
+	"role",
+	"type",
+	"alt",
+	"list",
+	"multiple",
+	"size"
+] });
+//#endregion
+//#region ../core/src/html/aria-rules.ts
+function defineAriaRule(tags, rule) {
+	return Object.assign(rule, { tags });
+}
+const LANDMARK_TAG_SET = new Set(LANDMARK_TAGS);
+const removeLandmarkRoleOverride = {
+	kind: "removeRole",
+	apply: ({ props }) => {
+		if (!("role" in props)) return {
+			applied: false,
+			next: props
+		};
+		const { role: _r, ...rest } = props;
+		return {
+			applied: true,
+			next: rest,
+			previous: props
+		};
+	}
+};
+const landmarkRoleRule = defineAriaRule(LANDMARK_TAGS, ({ tag, props, implicitRole }) => {
+	if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
+	const { role } = props;
+	if (!role || role === implicitRole) return [];
+	const diagnostic = HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role);
+	return [{
+		valid: false,
+		fixable: true,
+		severity: diagnostic.severity,
+		fix: removeLandmarkRoleOverride,
+		diagnostic
+	}];
+});
+function requireAccessibleName({ tag, props }) {
+	if ("aria-label" in props || "aria-labelledby" in props) return [];
+	return [{
+		valid: false,
+		fixable: false,
+		severity: "warning",
+		diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+	}];
+}
+const NAMED_LANDMARK_TAGS = ["nav", "aside"];
+const NAMED_LANDMARK_TAG_SET = new Set(NAMED_LANDMARK_TAGS);
+const landmarkAccessibleNameRule = defineAriaRule(NAMED_LANDMARK_TAGS, (ctx) => {
+	if (!ctx.implicitRole || !NAMED_LANDMARK_TAG_SET.has(ctx.tag)) return [];
+	return requireAccessibleName(ctx);
+});
+const HTML_ARIA_RULES = [
+	landmarkRoleRule,
+	landmarkAccessibleNameRule,
+	roleNotPermittedRule,
+	...INPUT_RULES,
+	...ANCHOR_RULES
+];
+//#endregion
+export { ANCHOR_RULES, HTML_ARIA_RULES, INPUT_RULES, acceptRequiresFileTypeRule, altRequiresImageTypeRule, ariaDisabledInertRule, captureRequiresFileTypeRule, checkedRequiresCheckableTypeRule, dangerousHrefRule, heightRequiresImageTypeRule, inputAccessibleNameRule, landmarkAccessibleNameRule, landmarkRoleRule, maxLengthRequiresTextTypeRule, maxRequiresNumericTypeRule, minLengthRequiresTextTypeRule, minRequiresNumericTypeRule, multipleRequiresSupportedTypeRule, passwordAutocompleteRule, patternRequiresTextTypeRule, requireAccessibleName, requiredReadOnlyConflictRule, roleButtonWithHrefRule, roleNotPermittedRule, sizeRequiresTextTypeRule, stepRequiresNumericTypeRule, supportedInputTypeRule, widthRequiresImageTypeRule };