eslint-plugin-a11y 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1891 @@
+// src/core/aria-spec.ts
+var DEPRECATED_ARIA = {
+  roles: [],
+  properties: ["aria-dropeffect", "aria-grabbed"],
+  states: ["aria-grabbed"]
+};
+var ARIA_IN_HTML = {
+  // Attributes that are global but discouraged on certain elements
+  discouraged: {
+    'input[type="text"]': ["aria-label"],
+    // Should use <label> instead
+    'input[type="email"]': ["aria-label"],
+    'input[type="password"]': ["aria-label"],
+    'input[type="number"]': ["aria-label"],
+    'input[type="tel"]': ["aria-label"],
+    'input[type="url"]': ["aria-label"],
+    'input[type="search"]': ["aria-label"],
+    "button": ["role"],
+    // Redundant if role="button"
+    "a": ["role"],
+    // Redundant if role="link"
+    "h1": ["role"],
+    // Redundant if role="heading"
+    "h2": ["role"],
+    "h3": ["role"],
+    "h4": ["role"],
+    "h5": ["role"],
+    "h6": ["role"],
+    "img": ["role"],
+    // Redundant if role="img"
+    "ul": ["role"],
+    // Redundant if role="list"
+    "ol": ["role"],
+    "li": ["role"],
+    // Redundant if role="listitem"
+    "nav": ["role"],
+    // Redundant if role="navigation"
+    "main": ["role"],
+    // Redundant if role="main"
+    "article": ["role"],
+    // Redundant if role="article"
+    "section": ["role"],
+    // Redundant if role="section"
+    "header": ["role"],
+    // Redundant if role="banner"
+    "footer": ["role"],
+    // Redundant if role="contentinfo"
+    "aside": ["role"],
+    // Redundant if role="complementary"
+    "form": ["role"],
+    // Redundant if role="form"
+    "dialog": ["role"]
+    // Redundant if role="dialog"
+  },
+  // Native elements that already have implicit roles
+  implicitRoles: {
+    "button": "button",
+    "a": "link",
+    "img": "img",
+    "h1": "heading",
+    "h2": "heading",
+    "h3": "heading",
+    "h4": "heading",
+    "h5": "heading",
+    "h6": "heading",
+    "ul": "list",
+    "ol": "list",
+    "li": "listitem",
+    "nav": "navigation",
+    "main": "main",
+    "article": "article",
+    "section": "region",
+    "header": "banner",
+    "footer": "contentinfo",
+    "aside": "complementary",
+    "form": "form",
+    "dialog": "dialog",
+    'input[type="button"]': "button",
+    'input[type="submit"]': "button",
+    'input[type="reset"]': "button",
+    'input[type="checkbox"]': "checkbox",
+    'input[type="radio"]': "radio",
+    'input[type="text"]': "textbox",
+    'input[type="email"]': "textbox",
+    'input[type="password"]': "textbox",
+    'input[type="number"]': "spinbutton",
+    'input[type="search"]': "searchbox",
+    "select": "combobox",
+    "textarea": "textbox"
+  }
+};
+var ARIA_ROLES = {
+  // Widget Roles
+  "button": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-pressed", "aria-expanded", "aria-disabled", "aria-haspopup"],
+    allowedOn: ["button", "a", "div", "span", "input"],
+    deprecated: false,
+    abstract: false
+  },
+  "checkbox": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-checked", "aria-required", "aria-disabled"],
+    allowedOn: ["input", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "radio": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-checked", "aria-required", "aria-disabled"],
+    allowedOn: ["input", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "switch": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-checked", "aria-required", "aria-disabled"],
+    allowedOn: ["button", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "tab": {
+    requiredProperties: [],
+    allowedProperties: ["aria-selected", "aria-controls", "aria-labelledby", "aria-disabled"],
+    allowedOn: ["button", "a", "div", "span"],
+    requiredContext: "tablist",
+    deprecated: false,
+    abstract: false
+  },
+  "tabpanel": {
+    requiredProperties: [],
+    allowedProperties: ["aria-labelledby"],
+    allowedOn: ["div", "section"],
+    deprecated: false,
+    abstract: false
+  },
+  "combobox": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded", "aria-controls", "aria-autocomplete", "aria-required"],
+    allowedOn: ["input", "select", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "slider": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation"],
+    allowedOn: ["input", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "spinbutton": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-required"],
+    allowedOn: ["input", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "textbox": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-multiline", "aria-required", "aria-readonly", "aria-invalid", "aria-autocomplete"],
+    allowedOn: ["input", "textarea", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "searchbox": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-required", "aria-autocomplete"],
+    allowedOn: ["input", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "menuitem": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-disabled"],
+    allowedOn: ["li", "div", "span"],
+    requiredContext: ["menu", "menubar"],
+    deprecated: false,
+    abstract: false
+  },
+  "menuitemcheckbox": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-checked", "aria-disabled"],
+    allowedOn: ["li", "div", "span"],
+    requiredContext: ["menu", "menubar"],
+    deprecated: false,
+    abstract: false
+  },
+  "menuitemradio": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-checked", "aria-disabled"],
+    allowedOn: ["li", "div", "span"],
+    requiredContext: ["menu", "menubar"],
+    deprecated: false,
+    abstract: false
+  },
+  "option": {
+    requiredProperties: [],
+    allowedProperties: ["aria-selected", "aria-checked", "aria-disabled"],
+    allowedOn: ["li", "div", "span"],
+    requiredContext: "listbox",
+    deprecated: false,
+    abstract: false
+  },
+  "treeitem": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded", "aria-selected", "aria-level"],
+    allowedOn: ["li", "div", "span"],
+    requiredContext: "tree",
+    deprecated: false,
+    abstract: false
+  },
+  // Composite Widget Roles
+  "menu": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["ul", "menu", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "menubar": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["ul", "menu", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "tablist": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-orientation"],
+    allowedOn: ["ul", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "tree": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-required"],
+    allowedOn: ["ul", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "treegrid": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded", "aria-level"],
+    allowedOn: ["table", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "grid": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded", "aria-level"],
+    allowedOn: ["table", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "listbox": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-required", "aria-multiselectable"],
+    allowedOn: ["ul", "select", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  // Document Structure Roles
+  "article": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded"],
+    allowedOn: ["article", "div", "section"],
+    deprecated: false,
+    abstract: false
+  },
+  "section": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded"],
+    allowedOn: ["section", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "navigation": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["nav", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "main": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["main", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "complementary": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["aside", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "contentinfo": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["footer", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "search": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["form", "div", "section"],
+    deprecated: false,
+    abstract: false
+  },
+  "form": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["form", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "region": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["section", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  // Landmark Roles
+  "banner": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["header", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "application": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  // Live Region Roles
+  "alert": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "status": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-live", "aria-atomic"],
+    allowedOn: ["div", "span", "output"],
+    deprecated: false,
+    abstract: false
+  },
+  "log": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-live", "aria-atomic"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "marquee": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-live", "aria-atomic"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "timer": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-live", "aria-atomic"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  // Window Roles
+  "dialog": {
+    requiredProperties: ["aria-label", "aria-labelledby"],
+    // One required
+    allowedProperties: ["aria-modal", "aria-describedby"],
+    allowedOn: ["dialog", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  "alertdialog": {
+    requiredProperties: ["aria-label", "aria-labelledby"],
+    // One required
+    allowedProperties: ["aria-modal", "aria-describedby"],
+    allowedOn: ["dialog", "div"],
+    deprecated: false,
+    abstract: false
+  },
+  // High Priority Additions
+  "link": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-expanded"],
+    allowedOn: ["a", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "heading": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-level"],
+    allowedOn: ["h1", "h2", "h3", "h4", "h5", "h6", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "img": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["img", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "progressbar": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext"],
+    allowedOn: ["progress", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "meter": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext"],
+    allowedOn: ["meter", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "separator": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-orientation"],
+    allowedOn: ["hr", "div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "toolbar": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby", "aria-orientation"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "tooltip": {
+    requiredProperties: [],
+    allowedProperties: ["aria-label", "aria-labelledby"],
+    allowedOn: ["div", "span"],
+    deprecated: false,
+    abstract: false
+  },
+  "none": {
+    requiredProperties: [],
+    allowedProperties: [],
+    allowedOn: ["*"],
+    deprecated: false,
+    abstract: false
+  },
+  "presentation": {
+    requiredProperties: [],
+    allowedProperties: [],
+    allowedOn: ["*"],
+    deprecated: false,
+    abstract: false
+  }
+};
+var ARIA_PROPERTIES = {
+  // Labeling Properties
+  "aria-label": {
+    type: "string",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-labelledby": {
+    type: "idrefs",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-describedby": {
+    type: "idrefs",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  // Relationship Properties
+  "aria-owns": {
+    type: "idrefs",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-controls": {
+    type: "idrefs",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-flowto": {
+    type: "idrefs",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-activedescendant": {
+    type: "idref",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  // Live Region Properties
+  "aria-live": {
+    type: "enum",
+    enumValues: ["off", "polite", "assertive"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-atomic": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-relevant": {
+    type: "enum",
+    enumValues: ["additions", "removals", "text", "all"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-busy": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  // Drag and Drop Properties (Deprecated)
+  "aria-dropeffect": {
+    type: "enum",
+    enumValues: ["copy", "move", "link", "execute", "popup", "none"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: true
+  },
+  "aria-grabbed": {
+    type: "enum",
+    enumValues: ["true", "false"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: true
+  },
+  // Global Properties
+  "aria-hidden": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-invalid": {
+    type: "enum",
+    enumValues: ["true", "false", "grammar", "spelling"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-required": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-readonly": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-disabled": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  // Widget Properties
+  "aria-autocomplete": {
+    type: "enum",
+    enumValues: ["none", "inline", "list", "both"],
+    required: false,
+    allowedOn: ["input", "textarea", "div", "span"],
+    deprecated: false
+  },
+  "aria-checked": {
+    type: "tristate",
+    required: false,
+    allowedOn: ["input", "div", "span"],
+    deprecated: false
+  },
+  "aria-expanded": {
+    type: "tristate",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-haspopup": {
+    type: "enum",
+    enumValues: ["true", "false", "menu", "listbox", "tree", "grid", "dialog"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-level": {
+    type: "integer",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-modal": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["dialog", "div"],
+    deprecated: false
+  },
+  "aria-multiline": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["textarea", "div", "span"],
+    deprecated: false
+  },
+  "aria-multiselectable": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["select", "div", "span"],
+    deprecated: false
+  },
+  "aria-orientation": {
+    type: "enum",
+    enumValues: ["horizontal", "vertical"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-pressed": {
+    type: "tristate",
+    required: false,
+    allowedOn: ["button", "div", "span"],
+    deprecated: false
+  },
+  "aria-selected": {
+    type: "boolean",
+    required: false,
+    allowedOn: ["option", "tab", "treeitem", "div", "span"],
+    deprecated: false
+  },
+  "aria-sort": {
+    type: "enum",
+    enumValues: ["ascending", "descending", "none", "other"],
+    required: false,
+    allowedOn: ["th", "td", "div", "span"],
+    deprecated: false
+  },
+  // Range Properties
+  "aria-valuemax": {
+    type: "number",
+    required: false,
+    allowedOn: ["input", "progress", "meter", "div", "span"],
+    deprecated: false
+  },
+  "aria-valuemin": {
+    type: "number",
+    required: false,
+    allowedOn: ["input", "progress", "meter", "div", "span"],
+    deprecated: false
+  },
+  "aria-valuenow": {
+    type: "number",
+    required: false,
+    allowedOn: ["input", "progress", "meter", "div", "span"],
+    deprecated: false
+  },
+  "aria-valuetext": {
+    type: "string",
+    required: false,
+    allowedOn: ["input", "progress", "meter", "div", "span"],
+    deprecated: false
+  },
+  // High Priority Additions
+  "aria-current": {
+    type: "enum",
+    enumValues: ["page", "step", "location", "date", "time", "true", "false"],
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-keyshortcuts": {
+    type: "string",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-roledescription": {
+    type: "string",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-posinset": {
+    type: "integer",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  },
+  "aria-setsize": {
+    type: "integer",
+    required: false,
+    allowedOn: ["*"],
+    deprecated: false
+  }
+};
+
+// src/core/a11y-checker.ts
+var A11yChecker = class {
+  static checkImageAlt(element) {
+    const violations = [];
+    const images = element.getElementsByTagName("img");
+    for (const img of Array.from(images)) {
+      if (!img.hasAttribute("alt")) {
+        violations.push({
+          id: "image-alt",
+          description: "Image must have an alt attribute",
+          element: img,
+          impact: "serious"
+        });
+      } else if (img.getAttribute("alt")?.trim() === "") {
+        violations.push({
+          id: "image-alt",
+          description: "Image alt attribute must not be empty",
+          element: img,
+          impact: "serious"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkButtonLabel(element) {
+    const violations = [];
+    const buttons = element.getElementsByTagName("button");
+    for (const button of Array.from(buttons)) {
+      if (!button.textContent?.trim() && !button.getAttribute("aria-label")) {
+        violations.push({
+          id: "button-label",
+          description: "Button must have a label or aria-label",
+          element: button,
+          impact: "critical"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkFormLabels(element) {
+    const violations = [];
+    const inputs = element.querySelectorAll("input, select, textarea");
+    for (const input of Array.from(inputs)) {
+      const hasLabel = input.hasAttribute("id") && element.querySelector(`label[for="${input.getAttribute("id")}"]`);
+      const hasAriaLabel = input.hasAttribute("aria-label");
+      const hasAriaLabelledBy = input.hasAttribute("aria-labelledby") && document.getElementById(input.getAttribute("aria-labelledby") || "");
+      if (!hasLabel && !hasAriaLabel && !hasAriaLabelledBy) {
+        violations.push({
+          id: "form-label",
+          description: "Form control must have an associated label",
+          element: input,
+          impact: "critical"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkHeadingOrder(element) {
+    const violations = [];
+    const headings = element.querySelectorAll("h1, h2, h3, h4, h5, h6");
+    let previousLevel = 0;
+    for (const heading of Array.from(headings)) {
+      const currentLevel = parseInt(heading.tagName[1]);
+      if (previousLevel > 0 && currentLevel - previousLevel > 1) {
+        violations.push({
+          id: "heading-order",
+          description: `Heading level skipped from h${previousLevel} to h${currentLevel}`,
+          element: heading,
+          impact: "moderate"
+        });
+      }
+      previousLevel = currentLevel;
+    }
+    return violations;
+  }
+  static checkLinkText(element) {
+    const violations = [];
+    const links = element.getElementsByTagName("a");
+    for (const link of Array.from(links)) {
+      const text = link.textContent?.trim().toLowerCase() || "";
+      const ariaLabel = link.getAttribute("aria-label")?.toLowerCase();
+      if (!text && !ariaLabel) {
+        violations.push({
+          id: "link-text",
+          description: "Link must have descriptive text",
+          element: link,
+          impact: "serious"
+        });
+      } else if (["click here", "read more", "more"].includes(text) && !ariaLabel) {
+        violations.push({
+          id: "link-text-descriptive",
+          description: "Link text should be more descriptive",
+          element: link,
+          impact: "moderate"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkIframeTitle(element) {
+    const violations = [];
+    const iframes = element.getElementsByTagName("iframe");
+    for (const iframe of Array.from(iframes)) {
+      if (!iframe.hasAttribute("title")) {
+        violations.push({
+          id: "iframe-title",
+          description: "iframe must have a title attribute",
+          element: iframe,
+          impact: "serious"
+        });
+      } else if (iframe.getAttribute("title")?.trim() === "") {
+        violations.push({
+          id: "iframe-title",
+          description: "iframe title attribute must not be empty",
+          element: iframe,
+          impact: "serious"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkFieldsetLegend(element) {
+    const violations = [];
+    const fieldsets = element.getElementsByTagName("fieldset");
+    for (const fieldset of Array.from(fieldsets)) {
+      const legend = Array.from(fieldset.children).find(
+        (child) => child.tagName.toLowerCase() === "legend"
+      );
+      if (!legend) {
+        violations.push({
+          id: "fieldset-legend",
+          description: "fieldset must have a legend element as a direct child",
+          element: fieldset,
+          impact: "serious"
+        });
+      } else if (!legend.textContent?.trim()) {
+        violations.push({
+          id: "fieldset-legend-empty",
+          description: "fieldset legend must have non-empty text content",
+          element: fieldset,
+          impact: "serious"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkTableStructure(element) {
+    const violations = [];
+    const tables = element.getElementsByTagName("table");
+    for (const table of Array.from(tables)) {
+      const hasCaption = table.querySelector("caption");
+      const hasAriaLabel = table.hasAttribute("aria-label");
+      const hasAriaLabelledBy = table.hasAttribute("aria-labelledby");
+      if (!hasCaption && !hasAriaLabel && !hasAriaLabelledBy) {
+        violations.push({
+          id: "table-caption",
+          description: "Table must have a caption or aria-label/aria-labelledby",
+          element: table,
+          impact: "serious"
+        });
+      }
+      const headerCells = table.querySelectorAll("th");
+      const dataCells = table.querySelectorAll("td");
+      if (dataCells.length > 0 && headerCells.length === 0) {
+        violations.push({
+          id: "table-headers",
+          description: "Table must have header cells (th elements) when it has data cells",
+          element: table,
+          impact: "serious"
+        });
+      }
+      for (const th of Array.from(headerCells)) {
+        if (!th.hasAttribute("scope")) {
+          violations.push({
+            id: "table-header-scope",
+            description: "Table header cells (th) should have a scope attribute",
+            element: th,
+            impact: "moderate"
+          });
+        }
+      }
+    }
+    return violations;
+  }
+  static checkDetailsSummary(element) {
+    const violations = [];
+    const detailsElements = element.getElementsByTagName("details");
+    for (const details of Array.from(detailsElements)) {
+      const firstChild = details.firstElementChild;
+      if (!firstChild || firstChild.tagName.toLowerCase() !== "summary") {
+        violations.push({
+          id: "details-summary",
+          description: "details element must have a summary element as its first child",
+          element: details,
+          impact: "serious"
+        });
+      } else if (!firstChild.textContent?.trim()) {
+        violations.push({
+          id: "details-summary-empty",
+          description: "details summary element must have non-empty text content",
+          element: details,
+          impact: "serious"
+        });
+      }
+    }
+    return violations;
+  }
+  static checkVideoCaptions(element) {
+    const violations = [];
+    const videos = element.getElementsByTagName("video");
+    for (const video of Array.from(videos)) {
+      const tracks = video.querySelectorAll("track");
+      const captionTracks = Array.from(tracks).filter(
+        (track) => track.getAttribute("kind")?.toLowerCase() === "captions"
+      );
+      if (captionTracks.length === 0) {
+        violations.push({
+          id: "video-captions",
+          description: 'Video element must have at least one track element with kind="captions"',
+          element: video,
+          impact: "serious"
+        });
+      } else {
+        for (const track of captionTracks) {
+          if (!track.hasAttribute("srclang")) {
+            violations.push({
+              id: "video-track-srclang",
+              description: "Video caption track must have a srclang attribute",
+              element: track,
+              impact: "serious"
+            });
+          }
+          if (!track.hasAttribute("label")) {
+            violations.push({
+              id: "video-track-label",
+              description: "Video caption track should have a label attribute",
+              element: track,
+              impact: "moderate"
+            });
+          }
+        }
+      }
+    }
+    return violations;
+  }
+  static checkAudioCaptions(element) {
+    const violations = [];
+    const audios = element.getElementsByTagName("audio");
+    for (const audio of Array.from(audios)) {
+      const tracks = audio.querySelectorAll("track");
+      const hasTranscript = audio.hasAttribute("aria-describedby") || audio.querySelector('a[href*="transcript"]') || audio.closest("div")?.querySelector('a[href*="transcript"]');
+      if (tracks.length === 0 && !hasTranscript) {
+        violations.push({
+          id: "audio-captions",
+          description: "Audio element must have track elements or a transcript link",
+          element: audio,
+          impact: "serious"
+        });
+      } else if (tracks.length > 0) {
+        for (const track of Array.from(tracks)) {
+          if (!track.hasAttribute("srclang")) {
+            violations.push({
+              id: "audio-track-srclang",
+              description: "Audio track must have a srclang attribute",
+              element: track,
+              impact: "serious"
+            });
+          }
+          if (!track.hasAttribute("label")) {
+            violations.push({
+              id: "audio-track-label",
+              description: "Audio track should have a label attribute",
+              element: track,
+              impact: "moderate"
+            });
+          }
+        }
+      }
+    }
+    return violations;
+  }
+  static checkLandmarks(element) {
+    const violations = [];
+    const landmarkTags = ["nav", "main", "header", "footer", "aside", "section", "article"];
+    const mainElements = element.getElementsByTagName("main");
+    if (mainElements.length > 1) {
+      const mains = Array.from(mainElements);
+      for (let i = 1; i < mains.length; i++) {
+        violations.push({
+          id: "landmark-multiple-main",
+          description: "Page should have only one main element",
+          element: mains[i],
+          impact: "serious"
+        });
+      }
+    }
+    for (const tag of landmarkTags) {
+      const landmarks = element.getElementsByTagName(tag);
+      for (const landmark of Array.from(landmarks)) {
+        if (tag === "section" || tag === "article") {
+          const hasHeading = landmark.querySelector("h1, h2, h3, h4, h5, h6");
+          const hasAriaLabel = landmark.hasAttribute("aria-label");
+          const hasAriaLabelledBy = landmark.hasAttribute("aria-labelledby");
+          if (!hasHeading && !hasAriaLabel && !hasAriaLabelledBy) {
+            violations.push({
+              id: "landmark-missing-name",
+              description: `${tag} element should have an accessible name (heading, aria-label, or aria-labelledby)`,
+              element: landmark,
+              impact: "moderate"
+            });
+          }
+        }
+        if (tag === "nav" || tag === "aside") {
+          const hasAriaLabel = landmark.hasAttribute("aria-label");
+          const hasAriaLabelledBy = landmark.hasAttribute("aria-labelledby");
+          const sameType = Array.from(element.getElementsByTagName(tag));
+          const unnamed = sameType.filter(
+            (l) => !l.hasAttribute("aria-label") && !l.hasAttribute("aria-labelledby")
+          );
+          if (unnamed.length > 1 && !hasAriaLabel && !hasAriaLabelledBy) {
+            violations.push({
+              id: "landmark-duplicate-unnamed",
+              description: `Multiple ${tag} elements found. Each should have an accessible name (aria-label or aria-labelledby)`,
+              element: landmark,
+              impact: "moderate"
+            });
+          }
+        }
+      }
+    }
+    return violations;
+  }
+  static checkDialogModal(element) {
+    const violations = [];
+    const dialogs = element.getElementsByTagName("dialog");
+    for (const dialog of Array.from(dialogs)) {
+      const hasAriaLabel = dialog.hasAttribute("aria-label");
+      const hasAriaLabelledBy = dialog.hasAttribute("aria-labelledby");
+      const hasHeading = dialog.querySelector("h1, h2, h3, h4, h5, h6");
+      if (!hasAriaLabel && !hasAriaLabelledBy && !hasHeading) {
+        violations.push({
+          id: "dialog-missing-name",
+          description: "Dialog element must have an accessible name (aria-label, aria-labelledby, or heading)",
+          element: dialog,
+          impact: "serious"
+        });
+      }
+      const isModal = dialog.hasAttribute("open") || dialog.getAttribute("aria-modal") === "true";
+      if (isModal && !dialog.hasAttribute("aria-modal")) {
+        violations.push({
+          id: "dialog-missing-modal",
+          description: 'Modal dialog should have aria-modal="true" attribute',
+          element: dialog,
+          impact: "moderate"
+        });
+      }
+      const hasRole = dialog.hasAttribute("role");
+      const roleValue = dialog.getAttribute("role");
+      if (hasRole && roleValue !== "dialog" && roleValue !== "alertdialog") {
+        violations.push({
+          id: "dialog-invalid-role",
+          description: 'Dialog element should have role="dialog" or role="alertdialog"',
+          element: dialog,
+          impact: "moderate"
+        });
+      }
+    }
+    return violations;
+  }
+  static async check(element) {
+    const violations = [
+      ...this.checkImageAlt(element),
+      ...this.checkLinkText(element),
+      ...this.checkButtonLabel(element),
+      ...this.checkFormLabels(element),
+      ...this.checkHeadingOrder(element),
+      ...this.checkIframeTitle(element),
+      ...this.checkFieldsetLegend(element),
+      ...this.checkTableStructure(element),
+      ...this.checkDetailsSummary(element),
+      ...this.checkVideoCaptions(element),
+      ...this.checkAudioCaptions(element),
+      ...this.checkLandmarks(element),
+      ...this.checkDialogModal(element),
+      // Phase 1: ARIA Validation
+      ...this.checkAriaRoles(element),
+      ...this.checkAriaProperties(element),
+      ...this.checkAriaRelationships(element),
+      ...this.checkAccessibleName(element),
+      ...this.checkCompositePatterns(element),
+      // Phase 1: Semantic HTML Validation
+      ...this.checkSemanticHTML(element),
+      // Phase 1: Form Validation Messages
+      ...this.checkFormValidationMessages(element)
+    ];
+    if (violations.length > 0) {
+      console.warn("\nAccessibility Violations Found:");
+      violations.forEach((violation, index) => {
+        console.warn(`
+${index + 1}. ${violation.id} (${violation.impact})`);
+        console.warn(`   Description: ${violation.description}`);
+        console.warn(`   Element: ${violation.element.outerHTML}`);
+      });
+      console.warn("\n");
+    }
+    return { violations };
+  }
+  /**
+   * Check ARIA roles for validity, appropriateness, and context
+   */
+  static checkAriaRoles(element) {
+    const violations = [];
+    const allElements = element.querySelectorAll("[role]");
+    for (const el of Array.from(allElements)) {
+      const role = el.getAttribute("role");
+      if (!role)
+        continue;
+      const tagName = el.tagName.toLowerCase();
+      const inputType = el.getAttribute("type");
+      const elementKey = inputType ? `${tagName}[type="${inputType}"]` : tagName;
+      if (!ARIA_ROLES[role]) {
+        violations.push({
+          id: "aria-invalid-role",
+          description: `Invalid ARIA role: ${role}`,
+          element: el,
+          impact: "serious"
+        });
+        continue;
+      }
+      const roleDef = ARIA_ROLES[role];
+      if (DEPRECATED_ARIA.roles.includes(role)) {
+        violations.push({
+          id: "aria-deprecated-role",
+          description: `ARIA role "${role}" is deprecated`,
+          element: el,
+          impact: "moderate"
+        });
+      }
+      if (roleDef.abstract) {
+        violations.push({
+          id: "aria-abstract-role",
+          description: `ARIA role "${role}" is abstract and should not be used`,
+          element: el,
+          impact: "moderate"
+        });
+      }
+      const implicitRole = ARIA_IN_HTML.implicitRoles[elementKey] || ARIA_IN_HTML.implicitRoles[tagName] || null;
+      if (implicitRole === role) {
+        violations.push({
+          id: "aria-redundant-role",
+          description: `Redundant role: <${tagName}> already has implicit role "${role}"`,
+          element: el,
+          impact: "minor"
+        });
+      }
+      if (implicitRole && implicitRole !== role && this.hasStrongNativeSemantics(tagName)) {
+        violations.push({
+          id: "aria-conflicting-semantics",
+          description: `Conflicting semantics: <${tagName}> has implicit role "${implicitRole}" but role="${role}" is specified`,
+          element: el,
+          impact: "serious"
+        });
+      }
+      if (!roleDef.allowedOn.includes("*") && !roleDef.allowedOn.includes(tagName)) {
+        violations.push({
+          id: "aria-role-on-wrong-element",
+          description: `Role "${role}" is not appropriate for <${tagName}>`,
+          element: el,
+          impact: "serious"
+        });
+      }
+      if (roleDef.requiredContext) {
+        const parent = el.parentElement;
+        const parentRole = parent?.getAttribute("role");
+        const contexts = Array.isArray(roleDef.requiredContext) ? roleDef.requiredContext : [roleDef.requiredContext];
+        if (!parentRole || !contexts.includes(parentRole)) {
+          violations.push({
+            id: "aria-missing-context-role",
+            description: `Role "${role}" must be in context of ${contexts.join(" or ")}`,
+            element: el,
+            impact: "serious"
+          });
+        }
+      }
+      if (roleDef.requiredProperties.length > 0) {
+        const hasRequired = roleDef.requiredProperties.some((prop) => el.hasAttribute(prop));
+        if (!hasRequired) {
+          violations.push({
+            id: "aria-missing-required-property",
+            description: `Role "${role}" requires one of: ${roleDef.requiredProperties.join(", ")}`,
+            element: el,
+            impact: "critical"
+          });
+        }
+      }
+    }
+    return violations;
+  }
+  static hasStrongNativeSemantics(tagName) {
+    const strongSemanticElements = ["button", "a", "input", "select", "textarea", "img", "h1", "h2", "h3", "h4", "h5", "h6"];
+    return strongSemanticElements.includes(tagName);
+  }
+  /**
+   * Check ARIA properties for validity, appropriateness, and values
+   */
+  static checkAriaProperties(element) {
+    const violations = [];
+    const allElements = Array.from(element.querySelectorAll("*")).filter((el) => {
+      return Array.from(el.attributes).some((attr) => attr.name.startsWith("aria-"));
+    });
+    for (const el of Array.from(allElements)) {
+      const attributes = Array.from(el.attributes).filter((attr) => attr.name.startsWith("aria-"));
+      for (const attr of attributes) {
+        const propName = attr.name;
+        const propValue = attr.value;
+        const tagName = el.tagName.toLowerCase();
+        const inputType = el.getAttribute("type");
+        const elementKey = inputType ? `${tagName}[type="${inputType}"]` : tagName;
+        if (!ARIA_PROPERTIES[propName]) {
+          violations.push({
+            id: "aria-invalid-property",
+            description: `Invalid ARIA property: ${propName}`,
+            element: el,
+            impact: "serious"
+          });
+          continue;
+        }
+        const propDef = ARIA_PROPERTIES[propName];
+        if (propDef.deprecated || DEPRECATED_ARIA.properties.includes(propName)) {
+          violations.push({
+            id: "aria-deprecated-property",
+            description: `ARIA property "${propName}" is deprecated`,
+            element: el,
+            impact: "moderate"
+          });
+        }
+        const discouraged = ARIA_IN_HTML.discouraged[elementKey] || ARIA_IN_HTML.discouraged[tagName];
+        if (discouraged && discouraged.includes(propName)) {
+          violations.push({
+            id: "aria-property-discouraged",
+            description: `${propName} is discouraged on <${tagName}> (use native HTML instead)`,
+            element: el,
+            impact: "moderate"
+          });
+        }
+        if (!this.validateAriaPropertyValue(propValue, propDef.type, propDef.enumValues)) {
+          violations.push({
+            id: "aria-invalid-property-value",
+            description: `Invalid value for ${propName}: ${propValue}. Expected ${propDef.type}${propDef.enumValues ? ` (${propDef.enumValues.join(", ")})` : ""}`,
+            element: el,
+            impact: "serious"
+          });
+        }
+        if (propName === "aria-label" && propValue.trim() === "") {
+          violations.push({
+            id: "aria-label-empty",
+            description: "aria-label must not be empty",
+            element: el,
+            impact: "serious"
+          });
+        }
+        if (!propDef.allowedOn.includes("*") && !propDef.allowedOn.includes(tagName)) {
+          violations.push({
+            id: "aria-property-on-wrong-element",
+            description: `${propName} is not appropriate for <${tagName}>`,
+            element: el,
+            impact: "moderate"
+          });
+        }
+      }
+    }
+    return violations;
+  }
+  /**
+   * Validate ARIA property value based on type
+   */
+  static validateAriaPropertyValue(value, type, enumValues) {
+    switch (type) {
+      case "boolean": {
+        return value === "true" || value === "false";
+      }
+      case "tristate": {
+        return value === "true" || value === "false" || value === "mixed";
+      }
+      case "idref": {
+        return value.length > 0 && /^[a-zA-Z][\w-]*$/.test(value);
+      }
+      case "idrefs": {
+        if (value.trim() === "")
+          return false;
+        const ids = value.trim().split(/\s+/);
+        return ids.every((id) => /^[a-zA-Z][\w-]*$/.test(id));
+      }
+      case "string": {
+        return true;
+      }
+      case "enum": {
+        if (!enumValues)
+          return true;
+        return enumValues.includes(value);
+      }
+      case "integer": {
+        const intValue = parseInt(value, 10);
+        return !isNaN(intValue) && intValue.toString() === value;
+      }
+      case "number": {
+        const numValue = parseFloat(value);
+        return !isNaN(numValue) && isFinite(numValue);
+      }
+      default: {
+        return true;
+      }
+    }
+  }
+  /**
+   * Check ARIA relationships (ID references) with enhanced validation
+   */
+  static checkAriaRelationships(element) {
+    const violations = [];
+    const checkIdReferences = (elements, attribute, violationId) => {
+      for (const el of Array.from(elements)) {
+        const ids = el.getAttribute(attribute)?.split(/\s+/) || [];
+        const elementId = el.id || el.getAttribute("id");
+        if (ids.includes(elementId || "self")) {
+          violations.push({
+            id: `${violationId}-self-reference`,
+            description: `${attribute} should not reference itself`,
+            element: el,
+            impact: "serious"
+          });
+        }
+        for (const id of ids) {
+          if (!id)
+            continue;
+          const referencedEl = element.querySelector(`#${id}`);
+          if (!referencedEl) {
+            violations.push({
+              id: `${violationId}-reference-missing`,
+              description: `${attribute} references non-existent ID: ${id}`,
+              element: el,
+              impact: "serious"
+            });
+            continue;
+          }
+          if (referencedEl.getAttribute("aria-hidden") === "true") {
+            violations.push({
+              id: `${violationId}-reference-hidden`,
+              description: `${attribute} references element with aria-hidden="true" (name/description will be hidden from AT)`,
+              element: el,
+              impact: "serious"
+            });
+          }
+          const allWithId = element.querySelectorAll(`#${id}`);
+          if (allWithId.length > 1) {
+            violations.push({
+              id: `${violationId}-duplicate-id`,
+              description: `ID "${id}" is not unique in document (referenced by ${attribute})`,
+              element: el,
+              impact: "serious"
+            });
+          }
+        }
+      }
+    };
+    checkIdReferences(
+      element.querySelectorAll("[aria-labelledby]"),
+      "aria-labelledby",
+      "aria-labelledby"
+    );
+    checkIdReferences(
+      element.querySelectorAll("[aria-describedby]"),
+      "aria-describedby",
+      "aria-describedby"
+    );
+    checkIdReferences(
+      element.querySelectorAll("[aria-controls]"),
+      "aria-controls",
+      "aria-controls"
+    );
+    checkIdReferences(
+      element.querySelectorAll("[aria-owns]"),
+      "aria-owns",
+      "aria-owns"
+    );
+    const ownsElements = element.querySelectorAll("[aria-owns]");
+    for (const el of Array.from(ownsElements)) {
+      const ids = el.getAttribute("aria-owns")?.split(/\s+/) || [];
+      const elementId = el.id || el.getAttribute("id");
+      for (const id of ids) {
+        if (!id)
+          continue;
+        const referencedEl = element.querySelector(`#${id}`);
+        if (referencedEl && referencedEl.getAttribute("aria-owns")?.includes(elementId || "")) {
+          violations.push({
+            id: "aria-owns-circular-reference",
+            description: "Circular aria-owns reference detected",
+            element: el,
+            impact: "serious"
+          });
+        }
+      }
+    }
+    const activedescendantElements = element.querySelectorAll("[aria-activedescendant]");
+    for (const el of Array.from(activedescendantElements)) {
+      const id = el.getAttribute("aria-activedescendant");
+      if (!id)
+        continue;
+      const referencedEl = element.querySelector(`#${id}`);
+      if (!referencedEl) {
+        violations.push({
+          id: "aria-activedescendant-reference-missing",
+          description: `aria-activedescendant references non-existent ID: ${id}`,
+          element: el,
+          impact: "serious"
+        });
+        continue;
+      }
+      const isFocusable = this.isFocusable(el);
+      if (!isFocusable) {
+        violations.push({
+          id: "aria-activedescendant-owner-not-focusable",
+          description: "Element with aria-activedescendant should be focusable",
+          element: el,
+          impact: "serious"
+        });
+      }
+    }
+    return violations;
+  }
+  /**
+   * Check if element is focusable
+   */
+  static isFocusable(element) {
+    const tagName = element.tagName.toLowerCase();
+    const tabindex = element.getAttribute("tabindex");
+    if (["a", "button", "input", "select", "textarea"].includes(tagName)) {
+      return !element.hasAttribute("disabled");
+    }
+    if (tabindex !== null) {
+      return tabindex !== "-1";
+    }
+    return false;
+  }
+  /**
+   * Check accessible name computation
+   */
+  static checkAccessibleName(element) {
+    const violations = [];
+    const elementsRequiringName = element.querySelectorAll(
+      'button, a, input, select, textarea, dialog, [role="button"], [role="link"], [role="dialog"], [role="alertdialog"]'
+    );
+    for (const el of Array.from(elementsRequiringName)) {
+      const ariaLabel = el.getAttribute("aria-label");
+      const ariaLabelledBy = el.getAttribute("aria-labelledby");
+      const textContent = el.textContent?.trim() || "";
+      const tagName = el.tagName.toLowerCase();
+      if (ariaLabel === "") {
+        violations.push({
+          id: "aria-label-empty",
+          description: "aria-label must not be empty",
+          element: el,
+          impact: "serious"
+        });
+      }
+      if (ariaLabelledBy) {
+        const ids = ariaLabelledBy.split(/\s+/);
+        for (const id of ids) {
+          if (!id)
+            continue;
+          const labelEl = element.querySelector(`#${id}`);
+          if (labelEl) {
+            const labelText = labelEl.textContent?.trim() || "";
+            const labelAriaLabel = labelEl.getAttribute("aria-label");
+            if (!labelText && !labelAriaLabel) {
+              violations.push({
+                id: "aria-labelledby-empty-reference",
+                description: `aria-labelledby references element with no accessible text: ${id}`,
+                element: el,
+                impact: "serious"
+              });
+            }
+          }
+        }
+      }
+      if (textContent && ariaLabel && textContent !== ariaLabel) {
+        if (tagName === "button" && textContent.length > 0 && ariaLabel.length > 0) {
+          violations.push({
+            id: "aria-label-content-mismatch",
+            description: `Button has visible text "${textContent}" but aria-label is "${ariaLabel}" - ensure they match or use aria-label only when text is not descriptive`,
+            element: el,
+            impact: "moderate"
+          });
+        }
+      }
+      if (ariaLabel && tagName === "input" && el.getAttribute("type") !== "hidden") {
+        const hasLabel = element.querySelector(`label[for="${el.id}"]`) || el.closest("label");
+        if (hasLabel) {
+          violations.push({
+            id: "aria-label-with-visible-label",
+            description: "aria-label should only be used when visible label is not available. Consider using <label> instead.",
+            element: el,
+            impact: "moderate"
+          });
+        }
+      }
+      const role = el.getAttribute("role");
+      if (role === "dialog" || role === "alertdialog" || tagName === "dialog") {
+        const hasHeading = el.querySelector("h1, h2, h3, h4, h5, h6");
+        const hasAriaLabel = ariaLabel && ariaLabel.trim() !== "";
+        const hasAriaLabelledBy = ariaLabelledBy && ariaLabelledBy.trim() !== "";
+        if (hasHeading && !hasAriaLabelledBy) {
+          violations.push({
+            id: "dialog-prefer-labelledby",
+            description: "Dialog with visible heading should use aria-labelledby instead of aria-label",
+            element: el,
+            impact: "moderate"
+          });
+        }
+        if (!hasAriaLabel && !hasAriaLabelledBy && !hasHeading) {
+          violations.push({
+            id: "dialog-missing-name",
+            description: "Dialog must have accessible name (aria-label, aria-labelledby, or heading)",
+            element: el,
+            impact: "critical"
+          });
+        }
+      }
+    }
+    return violations;
+  }
+  /**
+   * Check composite patterns (tab/listbox/menu/tree)
+   */
+  static checkCompositePatterns(element) {
+    const violations = [];
+    const tabs = element.querySelectorAll('[role="tab"]');
+    for (const tab of Array.from(tabs)) {
+      const tablist = tab.closest('[role="tablist"]');
+      if (!tablist) {
+        violations.push({
+          id: "tab-missing-tablist",
+          description: "Tab must be inside a tablist",
+          element: tab,
+          impact: "serious"
+        });
+      }
+      const controls = tab.getAttribute("aria-controls");
+      if (controls) {
+        const tabpanel = element.querySelector(`#${controls}`);
+        if (!tabpanel || tabpanel.getAttribute("role") !== "tabpanel") {
+          violations.push({
+            id: "tab-invalid-controls",
+            description: "Tab aria-controls must reference a tabpanel",
+            element: tab,
+            impact: "serious"
+          });
+        }
+      }
+    }
+    const listboxes = element.querySelectorAll('[role="listbox"]');
+    for (const listbox of Array.from(listboxes)) {
+      const options = listbox.querySelectorAll('[role="option"]');
+      if (options.length === 0) {
+        violations.push({
+          id: "listbox-missing-options",
+          description: "Listbox must contain option elements",
+          element: listbox,
+          impact: "serious"
+        });
+      }
+    }
+    const menus = element.querySelectorAll('[role="menu"], [role="menubar"]');
+    for (const menu of Array.from(menus)) {
+      const menuitems = menu.querySelectorAll('[role="menuitem"], [role="menuitemcheckbox"], [role="menuitemradio"]');
+      if (menuitems.length === 0) {
+        violations.push({
+          id: "menu-missing-menuitems",
+          description: "Menu must contain menuitem elements",
+          element: menu,
+          impact: "serious"
+        });
+      }
+    }
+    const trees = element.querySelectorAll('[role="tree"]');
+    for (const tree of Array.from(trees)) {
+      const treeitems = tree.querySelectorAll('[role="treeitem"]');
+      if (treeitems.length === 0) {
+        violations.push({
+          id: "tree-missing-treeitems",
+          description: "Tree must contain treeitem elements",
+          element: tree,
+          impact: "serious"
+        });
+      }
+    }
+    const interactiveRoles = ["button", "link", "menuitem", "tab", "option"];
+    for (const role of interactiveRoles) {
+      const elements = element.querySelectorAll(`[role="${role}"]`);
+      for (const el of Array.from(elements)) {
+        const tagName = el.tagName.toLowerCase();
+        if (!["button", "a", "input"].includes(tagName)) {
+          const tabindex = el.getAttribute("tabindex");
+          if (tabindex === null || tabindex === "-1") {
+            violations.push({
+              id: "interactive-role-not-focusable",
+              description: `Element with role="${role}" should be focusable (add tabindex="0" or use native element)`,
+              element: el,
+              impact: "serious"
+            });
+          }
+        }
+      }
+    }
+    return violations;
+  }
+  /**
+   * Check semantic HTML usage and structure
+   */
+  static checkSemanticHTML(element) {
+    const violations = [];
+    const divsWithRole = element.querySelectorAll("div[role], span[role]");
+    for (const el of Array.from(divsWithRole)) {
+      const role = el.getAttribute("role");
+      const tagName = el.tagName.toLowerCase();
+      const roleToElement = {
+        "button": "button",
+        "link": "a",
+        "heading": "h1-h6",
+        "list": "ul or ol",
+        "listitem": "li",
+        "navigation": "nav",
+        "main": "main",
+        "article": "article",
+        "section": "section",
+        "banner": "header",
+        "contentinfo": "footer",
+        "complementary": "aside",
+        "form": "form",
+        "dialog": "dialog"
+      };
+      if (role && roleToElement[role]) {
+        violations.push({
+          id: "semantic-element-preferred",
+          description: `Use <${roleToElement[role]}> instead of <${tagName} role="${role}">`,
+          element: el,
+          impact: "moderate"
+        });
+      }
+    }
+    const interactiveSelectors = 'button, a[href], input[type="button"], input[type="submit"], input[type="reset"], [role="button"], [role="link"]';
+    const interactiveElements = element.querySelectorAll(interactiveSelectors);
+    for (const el of Array.from(interactiveElements)) {
+      const parent = el.parentElement;
+      if (parent && parent.matches(interactiveSelectors)) {
+        violations.push({
+          id: "nested-interactive",
+          description: "Interactive element cannot be nested inside another interactive element",
+          element: el,
+          impact: "serious"
+        });
+      }
+    }
+    const anchors = element.querySelectorAll("a");
+    for (const anchor of Array.from(anchors)) {
+      if (!anchor.hasAttribute("href")) {
+        violations.push({
+          id: "anchor-without-href",
+          description: "<a> without href should be <button> or have href attribute",
+          element: anchor,
+          impact: "moderate"
+        });
+      }
+    }
+    const forms = element.querySelectorAll("form");
+    for (const form of Array.from(forms)) {
+      const buttons = form.querySelectorAll("button");
+      for (const button of Array.from(buttons)) {
+        if (!button.hasAttribute("type")) {
+          violations.push({
+            id: "button-missing-type",
+            description: '<button> in form should have type="button" to prevent accidental submit',
+            element: button,
+            impact: "moderate"
+          });
+        }
+      }
+    }
+    const listItems = element.querySelectorAll("li");
+    for (const li of Array.from(listItems)) {
+      const parent = li.parentElement;
+      const parentTag = parent?.tagName.toLowerCase();
+      if (parent && parentTag !== "ul" && parentTag !== "ol" && parentTag !== "menu") {
+        violations.push({
+          id: "list-item-outside-list",
+          description: "<li> must be a child of <ul>, <ol>, or <menu>",
+          element: li,
+          impact: "serious"
+        });
+      }
+    }
+    const dts = element.querySelectorAll("dt, dd");
+    for (const el of Array.from(dts)) {
+      const dl = el.closest("dl");
+      if (!dl) {
+        violations.push({
+          id: "dt-dd-outside-dl",
+          description: `<${el.tagName.toLowerCase()}> must appear under a <dl>`,
+          element: el,
+          impact: "serious"
+        });
+      }
+    }
+    const figcaptions = element.querySelectorAll("figcaption");
+    for (const figcaption of Array.from(figcaptions)) {
+      const figure = figcaption.closest("figure");
+      if (!figure) {
+        violations.push({
+          id: "figcaption-outside-figure",
+          description: "<figcaption> must be inside <figure>",
+          element: figcaption,
+          impact: "serious"
+        });
+      }
+    }
+    const figures = element.querySelectorAll("figure");
+    for (const figure of Array.from(figures)) {
+      const figcaptions2 = figure.querySelectorAll("figcaption");
+      if (figcaptions2.length > 1) {
+        violations.push({
+          id: "figure-multiple-figcaptions",
+          description: "<figure> should not have multiple <figcaption> elements",
+          element: figure,
+          impact: "serious"
+        });
+      }
+    }
+    const mains = element.querySelectorAll("main");
+    if (mains.length > 1) {
+      for (const main of Array.from(mains)) {
+        violations.push({
+          id: "multiple-main",
+          description: "Document should have only one <main> element",
+          element: main,
+          impact: "serious"
+        });
+      }
+    }
+    const navs = element.querySelectorAll("nav");
+    if (navs.length > 1) {
+      for (const nav of Array.from(navs)) {
+        const hasLabel = nav.hasAttribute("aria-label") || nav.hasAttribute("aria-labelledby");
+        if (!hasLabel) {
+          violations.push({
+            id: "multiple-nav-without-label",
+            description: "Multiple <nav> elements require accessible names (aria-label or aria-labelledby)",
+            element: nav,
+            impact: "moderate"
+          });
+        }
+      }
+    }
+    const formControls = element.querySelectorAll("input, select, textarea");
+    for (const control of Array.from(formControls)) {
+      if (control.getAttribute("type") === "hidden")
+        continue;
+      const id = control.id;
+      const hasAriaLabel = control.hasAttribute("aria-label");
+      const hasAriaLabelledBy = control.hasAttribute("aria-labelledby");
+      const isWrappedInLabel = control.closest("label");
+      const hasLabelFor = id && element.querySelector(`label[for="${id}"]`);
+      if (!hasAriaLabel && !hasAriaLabelledBy && !isWrappedInLabel && !hasLabelFor) {
+        violations.push({
+          id: "form-control-missing-label",
+          description: "Form control must have associated label",
+          element: control,
+          impact: "serious"
+        });
+      }
+    }
+    const ids = /* @__PURE__ */ new Map();
+    const elementsWithIds = element.querySelectorAll("[id]");
+    for (const el of Array.from(elementsWithIds)) {
+      const id = el.id;
+      if (id) {
+        if (!ids.has(id)) {
+          ids.set(id, []);
+        }
+        const elements = ids.get(id);
+        if (elements) {
+          elements.push(el);
+        }
+      }
+    }
+    for (const [id, elements] of ids.entries()) {
+      if (elements.length > 1) {
+        for (const el of elements) {
+          violations.push({
+            id: "duplicate-id",
+            description: `Duplicate ID "${id}" found - IDs must be unique`,
+            element: el,
+            impact: "serious"
+          });
+        }
+      }
+    }
+    return violations;
+  }
+  /**
+   * Check form validation messages
+   */
+  static checkFormValidationMessages(element) {
+    const violations = [];
+    const invalidElements = element.querySelectorAll("[aria-invalid]");
+    for (const el of Array.from(invalidElements)) {
+      const ariaInvalid = el.getAttribute("aria-invalid");
+      if (ariaInvalid === "true") {
+        const describedBy = el.getAttribute("aria-describedby");
+        if (describedBy) {
+          const ids = describedBy.split(/\s+/);
+          let hasErrorMessage = false;
+          for (const id of ids) {
+            const errorEl = element.querySelector(`#${id}`);
+            if (errorEl) {
+              const errorText = errorEl.textContent?.trim() || "";
+              const errorAriaLabel = errorEl.getAttribute("aria-label");
+              if (errorText || errorAriaLabel) {
+                hasErrorMessage = true;
+                break;
+              }
+            }
+          }
+          if (!hasErrorMessage) {
+            violations.push({
+              id: "aria-invalid-without-message",
+              description: 'Element with aria-invalid="true" should have associated error message via aria-describedby',
+              element: el,
+              impact: "serious"
+            });
+          }
+        } else {
+          violations.push({
+            id: "aria-invalid-without-describedby",
+            description: 'Element with aria-invalid="true" should have aria-describedby pointing to error message',
+            element: el,
+            impact: "serious"
+          });
+        }
+      }
+    }
+    const requiredFields = element.querySelectorAll('[required], [aria-required="true"]');
+    for (const field of Array.from(requiredFields)) {
+      const label = element.querySelector(`label[for="${field.id}"]`) || field.closest("label");
+      if (label) {
+        const labelText = label.textContent || "";
+        const hasRequiredIndicator = labelText.includes("*") || labelText.toLowerCase().includes("required") || field.hasAttribute("aria-required");
+        if (!hasRequiredIndicator && !field.hasAttribute("aria-required")) {
+          violations.push({
+            id: "required-field-indicator",
+            description: "Required field should have visual indicator (e.g., *) or aria-required attribute",
+            element: field,
+            impact: "moderate"
+          });
+        }
+      }
+    }
+    return violations;
+  }
+};
+export {
+  A11yChecker
+};