praxis-kit 6.5.0 → 6.6.0

package/dist/html/index.js

@@ -0,0 +1,860 @@
+// ../../lib/contract/src/diagnostics/aria.ts
+import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
+var 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 \u2014 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="\u2026" directly to the <${tag}> element.`
+        },
+        {
+          title: "Add aria-labelledby",
+          description: "Point aria-labelledby at the id of an existing heading or label 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" \u2014 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."
+    };
+  }
+};
+
+// ../../lib/contract/src/diagnostics/html.ts
+import { DiagnosticCategory as DiagnosticCategory2, DiagnosticCode as DiagnosticCode2 } from "../_shared/diagnostics.js";
+var ATTRIBUTE_IGNORED_CODES = {
+  checked: DiagnosticCode2.HtmlInputCheckedIgnoredForType,
+  multiple: DiagnosticCode2.HtmlInputMultipleIgnoredForType,
+  maxLength: DiagnosticCode2.HtmlInputMaxLengthIgnoredForType,
+  minLength: DiagnosticCode2.HtmlInputMinLengthIgnoredForType,
+  pattern: DiagnosticCode2.HtmlInputPatternIgnoredForType,
+  min: DiagnosticCode2.HtmlInputMinIgnoredForType,
+  max: DiagnosticCode2.HtmlInputMaxIgnoredForType,
+  step: DiagnosticCode2.HtmlInputStepIgnoredForType,
+  accept: DiagnosticCode2.HtmlInputAcceptIgnoredForType,
+  capture: DiagnosticCode2.HtmlInputCaptureIgnoredForType,
+  size: DiagnosticCode2.HtmlInputSizeIgnoredForType,
+  alt: DiagnosticCode2.HtmlInputAltIgnoredForType,
+  height: DiagnosticCode2.HtmlInputHeightIgnoredForType,
+  width: DiagnosticCode2.HtmlInputWidthIgnoredForType
+};
+var HtmlDiagnostics = {
+  emptyRole(tag) {
+    return {
+      code: DiagnosticCode2.HtmlEmptyRole,
+      category: DiagnosticCategory2.HTML,
+      severity: "warning",
+      message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
+    };
+  },
+  implicitRoleRedundant(tag, implicitRole) {
+    return {
+      code: DiagnosticCode2.HtmlImplicitRoleRedundant,
+      category: DiagnosticCategory2.HTML,
+      severity: "warning",
+      message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+    };
+  },
+  implicitRoleOverride(tag, implicitRole, role) {
+    return {
+      code: DiagnosticCode2.HtmlImplicitRoleOverride,
+      category: DiagnosticCategory2.HTML,
+      severity: "error",
+      message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+    };
+  },
+  standaloneRegionOverride(tag, implicitRole) {
+    return {
+      code: DiagnosticCode2.HtmlStandaloneRegionOverride,
+      category: DiagnosticCategory2.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: DiagnosticCode2.HtmlLandmarkRoleOverride,
+      category: DiagnosticCategory2.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: DiagnosticCode2.HtmlInvalidChild,
+      category: DiagnosticCategory2.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 \u2014 no explicit role is permitted on this element";
+    return {
+      code: DiagnosticCode2.HtmlRoleNotPermitted,
+      category: DiagnosticCategory2.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.'
+    };
+  },
+  // Reserved for <input>-specific facts (HTML3101–3199, see codes.ts) — later element families
+  // (button, img, table, ...) get their own reserved block and their own namespace here.
+  input: {
+    unsupportedType(type) {
+      return {
+        code: DiagnosticCode2.HtmlInputUnsupportedType,
+        category: DiagnosticCategory2.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 \u2014 the spec requires the "text" fallback \u2014 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.`
+          }
+        ]
+      };
+    },
+    // The user-visible problem is that the attribute is ignored — not that it "requires" a type;
+    // that's the rule's internal framing, not what the browser actually does.
+    attributeIgnoredForType(attribute, type, allowedTypes) {
+      const allowed = allowedTypes.map((t) => `"${t}"`).join(", ");
+      const code = ATTRIBUTE_IGNORED_CODES[attribute];
+      if (!code) throw new Error(`No DiagnosticCode registered for input attribute "${attribute}"`);
+      return {
+        code,
+        category: DiagnosticCategory2.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}.`
+          }
+        ]
+      };
+    }
+  }
+};
+
+// ../../lib/contract/src/diagnostics/input-accessibility.ts
+import { DiagnosticCategory as DiagnosticCategory3, DiagnosticCode as DiagnosticCode3 } from "../_shared/diagnostics.js";
+function accessibilityFact(input) {
+  return { category: DiagnosticCategory3.Accessibility, ...input };
+}
+var InputAccessibilityDiagnostics = {
+  missingAccessibleName() {
+    return accessibilityFact({
+      code: DiagnosticCode3.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="\u2026" directly on the input.' },
+        {
+          title: "Add an associated <label>",
+          description: 'Wrap the input in a <label>, or point a <label for="\u2026"> at its id.'
+        }
+      ]
+    });
+  },
+  placeholderIsNotLabel() {
+    return accessibilityFact({
+      code: DiagnosticCode3.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="\u2026" directly on the input.' },
+        {
+          title: "Add an associated <label>",
+          description: 'Wrap the input in a <label>, or point a <label for="\u2026"> at its id.'
+        }
+      ]
+    });
+  },
+  passwordMissingAutocomplete() {
+    return accessibilityFact({
+      code: DiagnosticCode3.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: DiagnosticCode3.A11yInputRequiredReadOnlyConflict,
+      severity: "warning",
+      message: "The required and readOnly attributes are both present. A read-only field cannot satisfy required validation through user interaction.",
+      rationale: "This combination is valid HTML but usually indicates an unintended state. Consider using disabled instead of readOnly, or only applying required when the field is editable."
+    });
+  }
+};
+
+// ../core/src/html/spec/vocabulary/input.ts
+var TEXT_INPUT_TYPES = ["text", "search", "url", "tel", "email", "password"];
+var NUMERIC_INPUT_TYPES = [
+  "number",
+  "range",
+  "date",
+  "month",
+  "week",
+  "time",
+  "datetime-local"
+];
+var HTML_INPUT_TYPES = /* @__PURE__ */ new Set([
+  ...TEXT_INPUT_TYPES,
+  ...NUMERIC_INPUT_TYPES,
+  "checkbox",
+  "radio",
+  "file",
+  "color",
+  "hidden",
+  "button",
+  "submit",
+  "reset",
+  "image"
+]);
+
+// ../core/src/html/spec/attributes/input.ts
+var 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"] }
+];
+
+// ../core/src/html/spec/constraints/input.ts
+var REQUIRED_READONLY_CONFLICT = {
+  props: ["required", "readOnly"],
+  diagnostic: () => InputAccessibilityDiagnostics.requiredReadOnlyConflict()
+};
+var INPUT_MUTUALLY_EXCLUSIVE_POLICIES = [
+  REQUIRED_READONLY_CONFLICT
+];
+
+// ../core/src/html/spec/validators/attribute-type-validator.ts
+var DEFAULT_INPUT_TYPE = "text";
+function omit(props, key) {
+  const next = { ...props };
+  delete next[key];
+  return next;
+}
+function removeAttributeFix(attribute) {
+  return {
+    kind: `removeAttribute:${attribute}`,
+    apply: ({ props }) => {
+      if (!(attribute in props)) return { applied: false, next: props };
+      return { applied: true, next: omit(props, attribute), previous: props };
+    }
+  };
+}
+function createInputAttributeTypeRule({
+  attribute,
+  allowedTypes
+}) {
+  const rule = ({ tag, props }) => {
+    if (tag !== "input" || !(attribute in props)) 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"] });
+}
+
+// ../core/src/html/spec/validators/mutually-exclusive-validator.ts
+function createMutuallyExclusiveRule({
+  props: conflictingProps,
+  diagnostic: createDiagnostic
+}) {
+  const [first, second] = conflictingProps;
+  const rule = ({ tag, props }) => {
+    if (tag !== "input" || !props[first] || !props[second]) return [];
+    const diagnostic = createDiagnostic();
+    return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
+  };
+  return Object.assign(rule, { readsProps: conflictingProps, tags: ["input"] });
+}
+
+// ../core/src/html/input-rules.ts
+var policyByAttribute = Object.fromEntries(
+  INPUT_ATTRIBUTE_TYPE_POLICIES.map((policy) => [policy.attribute, policy])
+);
+function policyFor(attribute) {
+  return policyByAttribute[attribute];
+}
+var 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"] }
+);
+var checkedRequiresCheckableTypeRule = createInputAttributeTypeRule(policyFor("checked"));
+var multipleRequiresSupportedTypeRule = createInputAttributeTypeRule(policyFor("multiple"));
+var maxLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("maxLength"));
+var minLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("minLength"));
+var patternRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("pattern"));
+var minRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("min"));
+var maxRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("max"));
+var stepRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("step"));
+var acceptRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("accept"));
+var captureRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("capture"));
+var sizeRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("size"));
+var altRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("alt"));
+var heightRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("height"));
+var widthRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("width"));
+var inputAccessibleNameRule = Object.assign(
+  ({ tag, props }) => {
+    if (tag !== "input" || props.type === "hidden") return [];
+    if ("aria-label" in props || "aria-labelledby" in props) return [];
+    const hasPlaceholder = typeof props.placeholder === "string" && props.placeholder.length > 0;
+    const diagnostic = hasPlaceholder ? InputAccessibilityDiagnostics.placeholderIsNotLabel() : InputAccessibilityDiagnostics.missingAccessibleName();
+    return [{ valid: false, fixable: false, severity: diagnostic.severity, diagnostic }];
+  },
+  {
+    readsProps: ["type", "aria-label", "aria-labelledby", "placeholder"],
+    tags: ["input"]
+  }
+);
+var PASSWORD_AUTOCOMPLETE_VALUES = ["current-password", "new-password"];
+var 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"] }
+);
+var requiredReadOnlyConflictRule = createMutuallyExclusiveRule(REQUIRED_READONLY_CONFLICT);
+var INPUT_RULES = [
+  supportedInputTypeRule,
+  checkedRequiresCheckableTypeRule,
+  multipleRequiresSupportedTypeRule,
+  maxLengthRequiresTextTypeRule,
+  minLengthRequiresTextTypeRule,
+  patternRequiresTextTypeRule,
+  minRequiresNumericTypeRule,
+  maxRequiresNumericTypeRule,
+  stepRequiresNumericTypeRule,
+  acceptRequiresFileTypeRule,
+  captureRequiresFileTypeRule,
+  sizeRequiresTextTypeRule,
+  altRequiresImageTypeRule,
+  heightRequiresImageTypeRule,
+  widthRequiresImageTypeRule,
+  inputAccessibleNameRule,
+  passwordAutocompleteRule,
+  requiredReadOnlyConflictRule
+];
+
+// ../core/src/html/spec/types.ts
+function definePropRolePolicy(prop, map, fallback) {
+  return { kind: "byProp", prop, map, fallback };
+}
+function resolveAllowedRoles(spec, props) {
+  const policy = spec.allowedRoles;
+  if (!policy) return void 0;
+  switch (policy.kind) {
+    case "fixed":
+      return policy.roles;
+    case "byProp": {
+      const value = typeof props[policy.prop] === "string" ? props[policy.prop] : policy.fallback;
+      return policy.map[value];
+    }
+    case "dynamic":
+      return policy.resolve({ props });
+  }
+}
+
+// ../core/src/html/spec/roles/input.ts
+var ALLOWED_INPUT_ROLES = {
+  checkbox: ["menuitemcheckbox", "option", "switch", "button"],
+  radio: ["menuitemradio"],
+  range: [],
+  number: [],
+  search: ["combobox"],
+  text: ["combobox", "searchbox", "spinbutton"],
+  email: ["combobox"],
+  tel: ["combobox"],
+  url: ["combobox"],
+  button: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  submit: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  reset: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  image: [
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  hidden: []
+};
+
+// ../core/src/html/spec/elements/input.ts
+var inputElementSpec = {
+  tag: "input",
+  allowedRoles: definePropRolePolicy("type", ALLOWED_INPUT_ROLES, "text"),
+  attributes: INPUT_ATTRIBUTE_TYPE_POLICIES,
+  mutuallyExclusive: INPUT_MUTUALLY_EXCLUSIVE_POLICIES
+};
+
+// ../core/src/html/spec/roles/img.ts
+var IMG_NAMED_ROLES = [
+  "button",
+  "checkbox",
+  "link",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "progressbar",
+  "scrollbar",
+  "separator",
+  "slider",
+  "switch",
+  "tab",
+  "treeitem"
+];
+
+// ../core/src/html/spec/elements/img.ts
+var imgElementSpec = {
+  tag: "img",
+  allowedRoles: {
+    kind: "dynamic",
+    resolve: ({ props }) => props.alt === "" ? [] : IMG_NAMED_ROLES
+  }
+};
+
+// ../core/src/html/spec/roles/table.ts
+var ALLOWED_TABLE_ROLES = ["grid", "treegrid"];
+
+// ../core/src/html/spec/elements/table.ts
+var tableElementSpec = {
+  tag: "table",
+  allowedRoles: { kind: "fixed", roles: ALLOWED_TABLE_ROLES }
+};
+
+// ../core/src/html/role-restrictions.ts
+var ALLOWED_ROLES = {
+  article: ["application", "document", "feed", "main", "none", "presentation", "region"],
+  aside: ["feed", "none", "presentation", "region", "search"],
+  footer: ["group", "none", "presentation"],
+  header: ["group", "none", "presentation"],
+  main: [],
+  nav: [],
+  a: [
+    "button",
+    "checkbox",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab",
+    "treeitem"
+  ],
+  button: [
+    "checkbox",
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "switch",
+    "tab"
+  ],
+  select: ["menu"],
+  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: [
+    "directory",
+    "group",
+    "listbox",
+    "menu",
+    "menubar",
+    "radiogroup",
+    "tablist",
+    "toolbar",
+    "tree"
+  ],
+  ol: [
+    "directory",
+    "group",
+    "listbox",
+    "menu",
+    "menubar",
+    "radiogroup",
+    "tablist",
+    "toolbar",
+    "tree"
+  ],
+  li: [
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "none",
+    "presentation",
+    "radio",
+    "separator",
+    "tab",
+    "treeitem"
+  ],
+  dialog: ["alertdialog"],
+  fieldset: ["none", "presentation", "radiogroup"]
+};
+var ELEMENT_SPECS = {
+  input: inputElementSpec,
+  img: imgElementSpec,
+  table: tableElementSpec
+};
+function getAllowedRoles(tag, props) {
+  const spec = ELEMENT_SPECS[tag];
+  if (spec) return resolveAllowedRoles(spec, props);
+  return ALLOWED_ROLES[tag];
+}
+var 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 };
+  }
+};
+var 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"] }
+);
+
+// ../core/src/html/aria-rules.ts
+var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
+var 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 };
+  }
+};
+var landmarkRoleRule = Object.assign(
+  ({ tag, props, implicitRole }) => {
+    if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
+    const role = props.role;
+    if (!role || role === implicitRole) return [];
+    const diagnostic = HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role);
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: diagnostic.severity,
+        fix: removeLandmarkRoleOverride,
+        diagnostic
+      }
+    ];
+  },
+  { tags: [...LANDMARK_TAG_SET] }
+);
+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)
+    }
+  ];
+}
+var NAMED_LANDMARK_TAGS = /* @__PURE__ */ new Set(["nav", "aside"]);
+var landmarkNameAdvisory = Object.assign(
+  (ctx) => {
+    if (!ctx.implicitRole || !NAMED_LANDMARK_TAGS.has(ctx.tag)) return [];
+    return requireAccessibleName(ctx);
+  },
+  { tags: [...NAMED_LANDMARK_TAGS] }
+);
+var HTML_ARIA_RULES = [
+  landmarkRoleRule,
+  landmarkNameAdvisory,
+  roleNotPermittedRule,
+  ...INPUT_RULES
+];
+export {
+  HTML_ARIA_RULES,
+  INPUT_RULES,
+  acceptRequiresFileTypeRule,
+  altRequiresImageTypeRule,
+  captureRequiresFileTypeRule,
+  checkedRequiresCheckableTypeRule,
+  heightRequiresImageTypeRule,
+  inputAccessibleNameRule,
+  landmarkNameAdvisory,
+  landmarkRoleRule,
+  maxLengthRequiresTextTypeRule,
+  maxRequiresNumericTypeRule,
+  minLengthRequiresTextTypeRule,
+  minRequiresNumericTypeRule,
+  multipleRequiresSupportedTypeRule,
+  passwordAutocompleteRule,
+  patternRequiresTextTypeRule,
+  requireAccessibleName,
+  requiredReadOnlyConflictRule,
+  roleNotPermittedRule,
+  sizeRequiresTextTypeRule,
+  stepRequiresNumericTypeRule,
+  supportedInputTypeRule,
+  widthRequiresImageTypeRule
+};