test-a11y-js 0.5.5 → 0.6.2

package/dist/index.js

@@ -11069,9 +11069,9 @@ var require_CSSStyleRule = __commonJS({
         return text;
       },
       set: function(cssText) {
-        var rule7 = CSSOM.CSSStyleRule.parse(cssText);
-        this.style = rule7.style;
-        this.selectorText = rule7.selectorText;
+        var rule14 = CSSOM.CSSStyleRule.parse(cssText);
+        this.style = rule14.style;
+        this.selectorText = rule14.selectorText;
       }
     });
     CSSOM.CSSStyleRule.parse = function(ruleText) {
@@ -11209,11 +11209,11 @@ var require_CSSStyleSheet = __commonJS({
     };
     CSSOM.CSSStyleSheet.prototype = new CSSOM.StyleSheet();
     CSSOM.CSSStyleSheet.prototype.constructor = CSSOM.CSSStyleSheet;
-    CSSOM.CSSStyleSheet.prototype.insertRule = function(rule7, index) {
+    CSSOM.CSSStyleSheet.prototype.insertRule = function(rule14, index) {
       if (index < 0 || index > this.cssRules.length) {
         throw new RangeError("INDEX_SIZE_ERR");
       }
-      var cssRule = CSSOM.parse(rule7).cssRules[0];
+      var cssRule = CSSOM.parse(rule14).cssRules[0];
       cssRule.parentStyleSheet = this;
       this.cssRules.splice(index, 0, cssRule);
       return index;
@@ -11408,11 +11408,11 @@ var require_CSSGroupingRule = __commonJS({
     };
     CSSOM.CSSGroupingRule.prototype = new CSSOM.CSSRule();
     CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
-    CSSOM.CSSGroupingRule.prototype.insertRule = function insertRule(rule7, index) {
+    CSSOM.CSSGroupingRule.prototype.insertRule = function insertRule(rule14, index) {
       if (index < 0 || index > this.cssRules.length) {
         throw new RangeError("INDEX_SIZE_ERR");
       }
-      var cssRule = CSSOM.parse(rule7).cssRules[0];
+      var cssRule = CSSOM.parse(rule14).cssRules[0];
       cssRule.parentRule = this;
       this.cssRules.splice(index, 0, cssRule);
       return index;
@@ -12612,9 +12612,9 @@ var require_clone = __commonJS({
         return cloned;
       }
       for (var i = 0, rulesLength = rules.length; i < rulesLength; i++) {
-        var rule7 = rules[i];
-        var ruleClone = cloned.cssRules[i] = new rule7.constructor();
-        var style = rule7.style;
+        var rule14 = rules[i];
+        var ruleClone = cloned.cssRules[i] = new rule14.constructor();
+        var style = rule14.style;
         if (style) {
           var styleClone = ruleClone.style = new CSSOM.CSSStyleDeclaration();
           for (var j = 0, styleLength = style.length; j < styleLength; j++) {
@@ -12624,23 +12624,23 @@ var require_clone = __commonJS({
           }
           styleClone.length = style.length;
         }
-        if (rule7.hasOwnProperty("keyText")) {
-          ruleClone.keyText = rule7.keyText;
+        if (rule14.hasOwnProperty("keyText")) {
+          ruleClone.keyText = rule14.keyText;
         }
-        if (rule7.hasOwnProperty("selectorText")) {
-          ruleClone.selectorText = rule7.selectorText;
+        if (rule14.hasOwnProperty("selectorText")) {
+          ruleClone.selectorText = rule14.selectorText;
         }
-        if (rule7.hasOwnProperty("mediaText")) {
-          ruleClone.mediaText = rule7.mediaText;
+        if (rule14.hasOwnProperty("mediaText")) {
+          ruleClone.mediaText = rule14.mediaText;
         }
-        if (rule7.hasOwnProperty("conditionText")) {
-          ruleClone.conditionText = rule7.conditionText;
+        if (rule14.hasOwnProperty("conditionText")) {
+          ruleClone.conditionText = rule14.conditionText;
         }
-        if (rule7.hasOwnProperty("layerName")) {
-          ruleClone.layerName = rule7.layerName;
+        if (rule14.hasOwnProperty("layerName")) {
+          ruleClone.layerName = rule14.layerName;
         }
-        if (rule7.hasOwnProperty("cssRules")) {
-          ruleClone.cssRules = clone(rule7).cssRules;
+        if (rule14.hasOwnProperty("cssRules")) {
+          ruleClone.cssRules = clone(rule14).cssRules;
         }
       }
       return cloned;
@@ -28126,9 +28126,9 @@ var require_CSSStyleRule2 = __commonJS({
         return text;
       },
       set: function(cssText) {
-        var rule7 = CSSOM.CSSStyleRule.parse(cssText);
-        this.style = rule7.style;
-        this.selectorText = rule7.selectorText;
+        var rule14 = CSSOM.CSSStyleRule.parse(cssText);
+        this.style = rule14.style;
+        this.selectorText = rule14.selectorText;
       }
     });
     CSSOM.CSSStyleRule.parse = function(ruleText) {
@@ -28266,11 +28266,11 @@ var require_CSSStyleSheet2 = __commonJS({
     };
     CSSOM.CSSStyleSheet.prototype = new CSSOM.StyleSheet();
     CSSOM.CSSStyleSheet.prototype.constructor = CSSOM.CSSStyleSheet;
-    CSSOM.CSSStyleSheet.prototype.insertRule = function(rule7, index) {
+    CSSOM.CSSStyleSheet.prototype.insertRule = function(rule14, index) {
       if (index < 0 || index > this.cssRules.length) {
         throw new RangeError("INDEX_SIZE_ERR");
       }
-      var cssRule = CSSOM.parse(rule7).cssRules[0];
+      var cssRule = CSSOM.parse(rule14).cssRules[0];
       cssRule.parentStyleSheet = this;
       this.cssRules.splice(index, 0, cssRule);
       return index;
@@ -28465,11 +28465,11 @@ var require_CSSGroupingRule2 = __commonJS({
     };
     CSSOM.CSSGroupingRule.prototype = new CSSOM.CSSRule();
     CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
-    CSSOM.CSSGroupingRule.prototype.insertRule = function insertRule(rule7, index) {
+    CSSOM.CSSGroupingRule.prototype.insertRule = function insertRule(rule14, index) {
       if (index < 0 || index > this.cssRules.length) {
         throw new RangeError("INDEX_SIZE_ERR");
       }
-      var cssRule = CSSOM.parse(rule7).cssRules[0];
+      var cssRule = CSSOM.parse(rule14).cssRules[0];
       cssRule.parentRule = this;
       this.cssRules.splice(index, 0, cssRule);
       return index;
@@ -29503,9 +29503,9 @@ var require_clone2 = __commonJS({
         return cloned;
       }
       for (var i = 0, rulesLength = rules.length; i < rulesLength; i++) {
-        var rule7 = rules[i];
-        var ruleClone = cloned.cssRules[i] = new rule7.constructor();
-        var style = rule7.style;
+        var rule14 = rules[i];
+        var ruleClone = cloned.cssRules[i] = new rule14.constructor();
+        var style = rule14.style;
         if (style) {
           var styleClone = ruleClone.style = new CSSOM.CSSStyleDeclaration();
           for (var j = 0, styleLength = style.length; j < styleLength; j++) {
@@ -29515,20 +29515,20 @@ var require_clone2 = __commonJS({
           }
           styleClone.length = style.length;
         }
-        if (rule7.hasOwnProperty("keyText")) {
-          ruleClone.keyText = rule7.keyText;
+        if (rule14.hasOwnProperty("keyText")) {
+          ruleClone.keyText = rule14.keyText;
         }
-        if (rule7.hasOwnProperty("selectorText")) {
-          ruleClone.selectorText = rule7.selectorText;
+        if (rule14.hasOwnProperty("selectorText")) {
+          ruleClone.selectorText = rule14.selectorText;
         }
-        if (rule7.hasOwnProperty("mediaText")) {
-          ruleClone.mediaText = rule7.mediaText;
+        if (rule14.hasOwnProperty("mediaText")) {
+          ruleClone.mediaText = rule14.mediaText;
         }
-        if (rule7.hasOwnProperty("conditionText")) {
-          ruleClone.conditionText = rule7.conditionText;
+        if (rule14.hasOwnProperty("conditionText")) {
+          ruleClone.conditionText = rule14.conditionText;
         }
-        if (rule7.hasOwnProperty("cssRules")) {
-          ruleClone.cssRules = clone(rule7).cssRules;
+        if (rule14.hasOwnProperty("cssRules")) {
+          ruleClone.cssRules = clone(rule14).cssRules;
         }
       }
       return cloned;
@@ -64262,17 +64262,17 @@ var require_style_rules = __commonJS({
     };
     function forEachMatchingSheetRuleOfElement(elementImpl, handleRule) {
       function handleSheet(sheet) {
-        forEach.call(sheet.cssRules, (rule7) => {
-          if (rule7.media) {
-            if (indexOf.call(rule7.media, "screen") !== -1) {
-              forEach.call(rule7.cssRules, (innerRule) => {
+        forEach.call(sheet.cssRules, (rule14) => {
+          if (rule14.media) {
+            if (indexOf.call(rule14.media, "screen") !== -1) {
+              forEach.call(rule14.cssRules, (innerRule) => {
                 if (matches2(innerRule, elementImpl)) {
                   handleRule(innerRule);
                 }
               });
             }
-          } else if (matches2(rule7, elementImpl)) {
-            handleRule(rule7);
+          } else if (matches2(rule14, elementImpl)) {
+            handleRule(rule14);
           }
         });
       }
@@ -64309,9 +64309,9 @@ var require_style_rules = __commonJS({
           );
         }
       }
-      forEachMatchingSheetRuleOfElement(elementImpl, (rule7) => {
-        forEach.call(rule7.style, (property) => {
-          handleProperty(rule7.style, property);
+      forEachMatchingSheetRuleOfElement(elementImpl, (rule14) => {
+        forEach.call(rule14.style, (property) => {
+          handleProperty(rule14.style, property);
         });
       });
       forEach.call(elementImpl.style, (property) => {
@@ -64320,8 +64320,8 @@ var require_style_rules = __commonJS({
       styleCache.set(elementImpl, declaration);
       return declaration;
     };
-    function matches2(rule7, elementImpl) {
-      return matchesDontThrow(rule7.selectorText, elementImpl);
+    function matches2(rule14, elementImpl) {
+      return matchesDontThrow(rule14.selectorText, elementImpl);
     }
     function getCascadedPropertyValue(element, property) {
       return exports.getDeclarationForElement(element).getPropertyValue(property);
@@ -170845,6 +170845,254 @@ var A11yChecker = class {
     }
     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),
@@ -170852,7 +171100,14 @@ var A11yChecker = class {
       ...this.checkButtonLabel(element),
       ...this.checkFormLabels(element),
       ...this.checkHeadingOrder(element),
-      ...this.checkIframeTitle(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)
     ];
     if (violations.length > 0) {
       console.warn("\nAccessibility Violations Found:");
@@ -170875,6 +171130,13 @@ var recommended = {
   "test-a11y-js/button-label": "error",
   "test-a11y-js/form-label": "error",
   "test-a11y-js/iframe-title": "error",
+  "test-a11y-js/fieldset-legend": "error",
+  "test-a11y-js/table-structure": "error",
+  "test-a11y-js/details-summary": "error",
+  "test-a11y-js/video-captions": "error",
+  "test-a11y-js/audio-captions": "error",
+  "test-a11y-js/landmark-roles": "warn",
+  "test-a11y-js/dialog-modal": "error",
   // Moderate/Minor violations - set to warn
   "test-a11y-js/link-text": "warn",
   "test-a11y-js/heading-order": "warn"
@@ -170889,7 +171151,14 @@ var strict = {
   "test-a11y-js/link-text": "error",
   "test-a11y-js/form-label": "error",
   "test-a11y-js/heading-order": "error",
-  "test-a11y-js/iframe-title": "error"
+  "test-a11y-js/iframe-title": "error",
+  "test-a11y-js/fieldset-legend": "error",
+  "test-a11y-js/table-structure": "error",
+  "test-a11y-js/details-summary": "error",
+  "test-a11y-js/video-captions": "error",
+  "test-a11y-js/audio-captions": "error",
+  "test-a11y-js/landmark-roles": "error",
+  "test-a11y-js/dialog-modal": "error"
 };
 var strict_default = strict;
 
@@ -171847,11 +172116,863 @@ var rule6 = {
 };
 var iframe_title_default = rule6;
 
+// src/linter/eslint-plugin/rules/fieldset-legend.ts
+var rule7 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce fieldset elements have a legend element as a direct child",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      missingLegend: "fieldset must have a legend element as a direct child",
+      emptyLegend: "fieldset legend must have non-empty text content"
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX fieldset elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        if (jsxNode.name?.name === "fieldset") {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkFieldsetLegend(element);
+            for (const violation of violations) {
+              if (violation.id === "fieldset-legend") {
+                context.report({
+                  node,
+                  messageId: "missingLegend"
+                });
+              } else if (violation.id === "fieldset-legend-empty") {
+                context.report({
+                  node,
+                  messageId: "emptyLegend"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkFieldsetLegend(element);
+            for (const violation of violations) {
+              if (violation.id === "fieldset-legend") {
+                context.report({
+                  node,
+                  messageId: "missingLegend"
+                });
+              } else if (violation.id === "fieldset-legend-empty") {
+                context.report({
+                  node,
+                  messageId: "emptyLegend"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkFieldsetLegend(element);
+            for (const violation of violations) {
+              if (violation.id === "fieldset-legend") {
+                context.report({
+                  node,
+                  messageId: "missingLegend"
+                });
+              } else if (violation.id === "fieldset-legend-empty") {
+                context.report({
+                  node,
+                  messageId: "emptyLegend"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template fieldset elements
+      VElement(node) {
+        const vueNode = node;
+        if (vueNode.name === "fieldset") {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkFieldsetLegend(element);
+              for (const violation of violations) {
+                if (violation.id === "fieldset-legend") {
+                  context.report({
+                    node,
+                    messageId: "missingLegend"
+                  });
+                } else if (violation.id === "fieldset-legend-empty") {
+                  context.report({
+                    node,
+                    messageId: "emptyLegend"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var fieldset_legend_default = rule7;
+
+// src/linter/eslint-plugin/rules/table-structure.ts
+var rule8 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce table elements have proper accessibility structure (caption, headers, scope)",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      missingCaption: "Table must have a caption or aria-label/aria-labelledby",
+      missingHeaders: "Table must have header cells (th elements) when it has data cells",
+      missingScope: "Table header cells (th) should have a scope attribute"
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX table elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        if (jsxNode.name?.name === "table") {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkTableStructure(element);
+            for (const violation of violations) {
+              if (violation.id === "table-caption") {
+                context.report({
+                  node,
+                  messageId: "missingCaption"
+                });
+              } else if (violation.id === "table-headers") {
+                context.report({
+                  node,
+                  messageId: "missingHeaders"
+                });
+              } else if (violation.id === "table-header-scope") {
+                context.report({
+                  node: violation.element,
+                  messageId: "missingScope"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkTableStructure(element);
+            for (const violation of violations) {
+              if (violation.id === "table-caption") {
+                context.report({
+                  node,
+                  messageId: "missingCaption"
+                });
+              } else if (violation.id === "table-headers") {
+                context.report({
+                  node,
+                  messageId: "missingHeaders"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkTableStructure(element);
+            for (const violation of violations) {
+              if (violation.id === "table-caption") {
+                context.report({
+                  node,
+                  messageId: "missingCaption"
+                });
+              } else if (violation.id === "table-headers") {
+                context.report({
+                  node,
+                  messageId: "missingHeaders"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template table elements
+      VElement(node) {
+        const vueNode = node;
+        if (vueNode.name === "table") {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkTableStructure(element);
+              for (const violation of violations) {
+                if (violation.id === "table-caption") {
+                  context.report({
+                    node,
+                    messageId: "missingCaption"
+                  });
+                } else if (violation.id === "table-headers") {
+                  context.report({
+                    node,
+                    messageId: "missingHeaders"
+                  });
+                } else if (violation.id === "table-header-scope") {
+                  context.report({
+                    node: violation.element,
+                    messageId: "missingScope"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var table_structure_default = rule8;
+
+// src/linter/eslint-plugin/rules/details-summary.ts
+var rule9 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce details elements have a summary element as first child",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      missingSummary: "details element must have a summary element as its first child",
+      emptySummary: "details summary element must have non-empty text content"
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX details elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        if (jsxNode.name?.name === "details") {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkDetailsSummary(element);
+            for (const violation of violations) {
+              if (violation.id === "details-summary") {
+                context.report({
+                  node,
+                  messageId: "missingSummary"
+                });
+              } else if (violation.id === "details-summary-empty") {
+                context.report({
+                  node,
+                  messageId: "emptySummary"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkDetailsSummary(element);
+            for (const violation of violations) {
+              if (violation.id === "details-summary") {
+                context.report({
+                  node,
+                  messageId: "missingSummary"
+                });
+              } else if (violation.id === "details-summary-empty") {
+                context.report({
+                  node,
+                  messageId: "emptySummary"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkDetailsSummary(element);
+            for (const violation of violations) {
+              if (violation.id === "details-summary") {
+                context.report({
+                  node,
+                  messageId: "missingSummary"
+                });
+              } else if (violation.id === "details-summary-empty") {
+                context.report({
+                  node,
+                  messageId: "emptySummary"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template details elements
+      VElement(node) {
+        const vueNode = node;
+        if (vueNode.name === "details") {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkDetailsSummary(element);
+              for (const violation of violations) {
+                if (violation.id === "details-summary") {
+                  context.report({
+                    node,
+                    messageId: "missingSummary"
+                  });
+                } else if (violation.id === "details-summary-empty") {
+                  context.report({
+                    node,
+                    messageId: "emptySummary"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var details_summary_default = rule9;
+
+// src/linter/eslint-plugin/rules/video-captions.ts
+var rule10 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce video elements have caption tracks",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      missingCaptions: 'Video element must have at least one track element with kind="captions"',
+      missingSrclang: "Video caption track must have a srclang attribute",
+      missingLabel: "Video caption track should have a label attribute"
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX video elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        if (jsxNode.name?.name === "video") {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkVideoCaptions(element);
+            for (const violation of violations) {
+              if (violation.id === "video-captions") {
+                context.report({
+                  node,
+                  messageId: "missingCaptions"
+                });
+              } else if (violation.id === "video-track-srclang") {
+                context.report({
+                  node: violation.element,
+                  messageId: "missingSrclang"
+                });
+              } else if (violation.id === "video-track-label") {
+                context.report({
+                  node: violation.element,
+                  messageId: "missingLabel"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkVideoCaptions(element);
+            for (const violation of violations) {
+              if (violation.id === "video-captions") {
+                context.report({
+                  node,
+                  messageId: "missingCaptions"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkVideoCaptions(element);
+            for (const violation of violations) {
+              if (violation.id === "video-captions") {
+                context.report({
+                  node,
+                  messageId: "missingCaptions"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template video elements
+      VElement(node) {
+        const vueNode = node;
+        if (vueNode.name === "video") {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkVideoCaptions(element);
+              for (const violation of violations) {
+                if (violation.id === "video-captions") {
+                  context.report({
+                    node,
+                    messageId: "missingCaptions"
+                  });
+                } else if (violation.id === "video-track-srclang") {
+                  context.report({
+                    node: violation.element,
+                    messageId: "missingSrclang"
+                  });
+                } else if (violation.id === "video-track-label") {
+                  context.report({
+                    node: violation.element,
+                    messageId: "missingLabel"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var video_captions_default = rule10;
+
+// src/linter/eslint-plugin/rules/audio-captions.ts
+var rule11 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce audio elements have caption tracks or transcripts",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      missingCaptions: "Audio element must have track elements or a transcript link",
+      missingSrclang: "Audio track must have a srclang attribute",
+      missingLabel: "Audio track should have a label attribute"
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX audio elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        if (jsxNode.name?.name === "audio") {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkAudioCaptions(element);
+            for (const violation of violations) {
+              if (violation.id === "audio-captions") {
+                context.report({
+                  node,
+                  messageId: "missingCaptions"
+                });
+              } else if (violation.id === "audio-track-srclang") {
+                context.report({
+                  node: violation.element,
+                  messageId: "missingSrclang"
+                });
+              } else if (violation.id === "audio-track-label") {
+                context.report({
+                  node: violation.element,
+                  messageId: "missingLabel"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkAudioCaptions(element);
+            for (const violation of violations) {
+              if (violation.id === "audio-captions") {
+                context.report({
+                  node,
+                  messageId: "missingCaptions"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkAudioCaptions(element);
+            for (const violation of violations) {
+              if (violation.id === "audio-captions") {
+                context.report({
+                  node,
+                  messageId: "missingCaptions"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template audio elements
+      VElement(node) {
+        const vueNode = node;
+        if (vueNode.name === "audio") {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkAudioCaptions(element);
+              for (const violation of violations) {
+                if (violation.id === "audio-captions") {
+                  context.report({
+                    node,
+                    messageId: "missingCaptions"
+                  });
+                } else if (violation.id === "audio-track-srclang") {
+                  context.report({
+                    node: violation.element,
+                    messageId: "missingSrclang"
+                  });
+                } else if (violation.id === "audio-track-label") {
+                  context.report({
+                    node: violation.element,
+                    messageId: "missingLabel"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var audio_captions_default = rule11;
+
+// src/linter/eslint-plugin/rules/landmark-roles.ts
+var rule12 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce proper use of landmark elements (nav, main, header, footer, aside, section, article)",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      multipleMain: "Page should have only one main element",
+      missingName: "Landmark element should have an accessible name (heading, aria-label, or aria-labelledby)",
+      duplicateUnnamed: "Multiple landmark elements found. Each should have an accessible name (aria-label or aria-labelledby)"
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX landmark elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        const tagName = jsxNode.name?.name?.toLowerCase();
+        const landmarkTags = ["nav", "main", "header", "footer", "aside", "section", "article"];
+        if (landmarkTags.includes(tagName)) {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkLandmarks(element);
+            for (const violation of violations) {
+              if (violation.id === "landmark-multiple-main") {
+                context.report({
+                  node,
+                  messageId: "multipleMain"
+                });
+              } else if (violation.id === "landmark-missing-name") {
+                context.report({
+                  node,
+                  messageId: "missingName"
+                });
+              } else if (violation.id === "landmark-duplicate-unnamed") {
+                context.report({
+                  node,
+                  messageId: "duplicateUnnamed"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkLandmarks(element);
+            for (const violation of violations) {
+              if (violation.id === "landmark-multiple-main") {
+                context.report({
+                  node,
+                  messageId: "multipleMain"
+                });
+              } else if (violation.id === "landmark-missing-name") {
+                context.report({
+                  node,
+                  messageId: "missingName"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkLandmarks(element);
+            for (const violation of violations) {
+              if (violation.id === "landmark-multiple-main") {
+                context.report({
+                  node,
+                  messageId: "multipleMain"
+                });
+              } else if (violation.id === "landmark-missing-name") {
+                context.report({
+                  node,
+                  messageId: "missingName"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template landmark elements
+      VElement(node) {
+        const vueNode = node;
+        const tagName = vueNode.name?.toLowerCase();
+        const landmarkTags = ["nav", "main", "header", "footer", "aside", "section", "article"];
+        if (landmarkTags.includes(tagName)) {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkLandmarks(element);
+              for (const violation of violations) {
+                if (violation.id === "landmark-multiple-main") {
+                  context.report({
+                    node,
+                    messageId: "multipleMain"
+                  });
+                } else if (violation.id === "landmark-missing-name") {
+                  context.report({
+                    node,
+                    messageId: "missingName"
+                  });
+                } else if (violation.id === "landmark-duplicate-unnamed") {
+                  context.report({
+                    node,
+                    messageId: "duplicateUnnamed"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var landmark_roles_default = rule12;
+
+// src/linter/eslint-plugin/rules/dialog-modal.ts
+var rule13 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce dialog elements have proper accessibility attributes",
+      category: "Accessibility",
+      recommended: true,
+      url: "https://github.com/nolrm/test-a11y-js"
+    },
+    messages: {
+      missingName: "Dialog element must have an accessible name (aria-label, aria-labelledby, or heading)",
+      missingModal: 'Modal dialog should have aria-modal="true" attribute',
+      invalidRole: 'Dialog element should have role="dialog" or role="alertdialog"'
+    },
+    fixable: void 0,
+    schema: []
+  },
+  create(context) {
+    return {
+      // Check JSX dialog elements
+      JSXOpeningElement(node) {
+        const jsxNode = node;
+        if (jsxNode.name?.name === "dialog" || jsxNode.name?.name && jsxNode.attributes?.some(
+          (attr) => attr.name?.name === "role" && (attr.value?.value === "dialog" || attr.value?.value === "alertdialog")
+        )) {
+          try {
+            const element = jsxToElement(node, context);
+            const violations = A11yChecker.checkDialogModal(element);
+            for (const violation of violations) {
+              if (violation.id === "dialog-missing-name") {
+                context.report({
+                  node,
+                  messageId: "missingName"
+                });
+              } else if (violation.id === "dialog-missing-modal") {
+                context.report({
+                  node,
+                  messageId: "missingModal"
+                });
+              } else if (violation.id === "dialog-invalid-role") {
+                context.report({
+                  node,
+                  messageId: "invalidRole"
+                });
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      },
+      // Check HTML strings
+      Literal(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkDialogModal(element);
+            for (const violation of violations) {
+              if (violation.id === "dialog-missing-name") {
+                context.report({
+                  node,
+                  messageId: "missingName"
+                });
+              }
+            }
+          }
+        }
+      },
+      TemplateLiteral(node) {
+        if (isHTMLLiteral(node)) {
+          const element = htmlNodeToElement(node, context);
+          if (element) {
+            const violations = A11yChecker.checkDialogModal(element);
+            for (const violation of violations) {
+              if (violation.id === "dialog-missing-name") {
+                context.report({
+                  node,
+                  messageId: "missingName"
+                });
+              }
+            }
+          }
+        }
+      },
+      // Check Vue template dialog elements
+      VElement(node) {
+        const vueNode = node;
+        if (vueNode.name === "dialog" || vueNode.startTag?.attributes?.some(
+          (attr) => attr.key?.name === "role" && (attr.value?.value === "dialog" || attr.value?.value === "alertdialog")
+        )) {
+          try {
+            const element = vueElementToDOM(node, context);
+            if (element) {
+              const violations = A11yChecker.checkDialogModal(element);
+              for (const violation of violations) {
+                if (violation.id === "dialog-missing-name") {
+                  context.report({
+                    node,
+                    messageId: "missingName"
+                  });
+                } else if (violation.id === "dialog-missing-modal") {
+                  context.report({
+                    node,
+                    messageId: "missingModal"
+                  });
+                } else if (violation.id === "dialog-invalid-role") {
+                  context.report({
+                    node,
+                    messageId: "invalidRole"
+                  });
+                }
+              }
+            }
+          } catch (error2) {
+          }
+        }
+      }
+    };
+  }
+};
+var dialog_modal_default = rule13;
+
 // src/linter/eslint-plugin/index.ts
 var plugin = {
   meta: {
     name: "test-a11y-js",
-    version: "0.2.0"
+    version: "0.6.2"
   },
   rules: {
     "image-alt": image_alt_default,
@@ -171859,7 +172980,14 @@ var plugin = {
     "link-text": link_text_default,
     "form-label": form_label_default,
     "heading-order": heading_order_default,
-    "iframe-title": iframe_title_default
+    "iframe-title": iframe_title_default,
+    "fieldset-legend": fieldset_legend_default,
+    "table-structure": table_structure_default,
+    "details-summary": details_summary_default,
+    "video-captions": video_captions_default,
+    "audio-captions": audio_captions_default,
+    "landmark-roles": landmark_roles_default,
+    "dialog-modal": dialog_modal_default
   },
   configs: {
     recommended: {