@kodalabs-io/eqo 1.0.0

package/dist/index.js

@@ -0,0 +1,941 @@
+import {
+  ALL_CRITERIA,
+  AXE_TEST_ID_PREFIX,
+  AXE_TO_RGAA,
+  AnalysisError,
+  CRITERIA_BY_ID,
+  ConfigError,
+  KodaRGAAConfigSchema,
+  THEMES,
+  TOTAL_CRITERIA,
+  TimeoutError,
+  analyze,
+  buildReport,
+  createStaticIssue,
+  defineRule,
+  generateDefaultConfig,
+  getAttr,
+  getAttrMap,
+  getAttrStringValue,
+  getAxeRulesForCriterion,
+  getRGAACriteria,
+  getSupportedLocales,
+  getTagName,
+  getTextContent,
+  getTranslations,
+  interpolate,
+  isAttrDynamic,
+  issueId,
+  loadConfig,
+  loadTranslations,
+  printReport,
+  resolveConfigPath,
+  runRuntimeAnalysis,
+  runStaticAnalysis,
+  walk,
+  writeHtmlReport,
+  writeJsonReport,
+  writeJunitReport,
+  writeMarkdownReport,
+  writeReports,
+  writeSarifReport
+} from "./chunk-WKI3N5NX.js";
+
+// src/analyzer/static/rules/01-images.ts
+var imagesNeedAlt = defineRule({ id: "images/alt-present", criteria: ["1.1"] }, (context) => {
+  const { filePath, ast } = context;
+  const issues = [];
+  walk(ast, {
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: covers img, input[type=image], svg[role=img], and generic role=img elements
+    JSXOpeningElement(rawNode) {
+      const node = rawNode;
+      const tag = getTagName(node);
+      const attrs = getAttrMap(node);
+      if (tag === "img") {
+        if (!attrs.has("alt") && !attrs.has("aria-label") && !attrs.has("aria-labelledby")) {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "1.1",
+              testId: "1.1.1",
+              messageKey: "img.missing-alt",
+              wcag: "1.1.1"
+            })
+          );
+        }
+        return;
+      }
+      if (tag === "input") {
+        const typeVal = getAttrStringValue(attrs.get("type"));
+        if (typeVal === "image") {
+          if (!attrs.has("alt") && !attrs.has("aria-label") && !attrs.has("aria-labelledby")) {
+            issues.push(
+              createStaticIssue({
+                node,
+                filePath,
+                criterionId: "1.1",
+                testId: "1.1.3",
+                messageKey: "img.input-image-missing-alt",
+                wcag: "1.1.1"
+              })
+            );
+          }
+        }
+        return;
+      }
+      if (tag === "svg") {
+        const roleVal2 = getAttrStringValue(attrs.get("role"));
+        if (roleVal2 === "img") {
+          if (!attrs.has("aria-label") && !attrs.has("aria-labelledby")) {
+            issues.push(
+              createStaticIssue({
+                node,
+                filePath,
+                criterionId: "1.1",
+                testId: "1.1.5",
+                messageKey: "img.svg-missing-accessible-name",
+                wcag: "1.1.1"
+              })
+            );
+          }
+        }
+        return;
+      }
+      const roleVal = getAttrStringValue(attrs.get("role"));
+      if (roleVal === "img") {
+        if (!attrs.has("aria-label") && !attrs.has("aria-labelledby")) {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "1.1",
+              testId: "1.1.1",
+              messageKey: "img.missing-alt-on-role-img",
+              wcag: "1.1.1"
+            })
+          );
+        }
+      }
+    }
+  });
+  return issues;
+});
+var decorativeSvgMustBeHidden = defineRule(
+  { id: "images/decorative-svg-hidden", criteria: ["1.2"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        if (getTagName(node) !== "svg") return;
+        const role = getAttrStringValue(getAttr(node, "role"));
+        const ariaHidden = getAttrStringValue(getAttr(node, "aria-hidden"));
+        const ariaLabel = getAttr(node, "aria-label");
+        const ariaLabelledby = getAttr(node, "aria-labelledby");
+        if (role !== "img" && ariaHidden !== "true" && !ariaLabel && !ariaLabelledby) {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "1.2",
+              testId: "1.2.4",
+              severity: "notice",
+              messageKey: "img.decorative-svg-not-hidden",
+              wcag: "1.1.1"
+            })
+          );
+        }
+      }
+    });
+    return issues;
+  }
+);
+var figcaptionInFigure = defineRule(
+  { id: "images/figcaption-in-figure", criteria: ["1.9"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXElement(rawNode) {
+        const node = rawNode;
+        const opening = node.openingElement;
+        if (getTagName(opening) !== "figure") return;
+        let hasFigcaption = false;
+        let hasImage = false;
+        for (const child of node.children) {
+          if (child.type !== "JSXElement") continue;
+          const childTag = getTagName(child.openingElement);
+          if (childTag === "figcaption") hasFigcaption = true;
+          if (childTag === "img" || childTag === "picture" || childTag === "svg" || childTag === "canvas") {
+            hasImage = true;
+          }
+        }
+        if (hasFigcaption && !hasImage) {
+          issues.push(
+            createStaticIssue({
+              node: opening,
+              filePath,
+              criterionId: "1.9",
+              testId: "1.9.1",
+              severity: "warning",
+              messageKey: "img.figure-missing-img",
+              remediationKey: "img.missing-alt",
+              wcag: "1.1.1"
+            })
+          );
+        }
+      }
+    });
+    return issues;
+  }
+);
+var imageRules = [imagesNeedAlt, decorativeSvgMustBeHidden, figcaptionInFigure];
+
+// src/analyzer/static/rules/02-frames.ts
+var framesNeedTitle = defineRule(
+  { id: "frames/title-present", criteria: ["2.1", "2.2"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        if (getTagName(node) !== "iframe") return;
+        const titleAttr = getAttr(node, "title");
+        if (!titleAttr) {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "2.1",
+              testId: "2.1.1",
+              messageKey: "frame.missing-title",
+              wcag: "4.1.2"
+            })
+          );
+          return;
+        }
+        if (isAttrDynamic(titleAttr)) return;
+        const titleValue = getAttrStringValue(titleAttr);
+        if (titleValue !== null && titleValue.trim() === "") {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "2.2",
+              testId: "2.2.1",
+              messageKey: "frame.empty-title",
+              wcag: "4.1.2"
+            })
+          );
+        }
+      }
+    });
+    return issues;
+  }
+);
+var frameRules = [framesNeedTitle];
+
+// src/analyzer/static/rules/05-tables.ts
+var tablesNeedCaption = defineRule(
+  { id: "tables/caption-present", criteria: ["5.4"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXElement(rawNode) {
+        const node = rawNode;
+        const opening = node.openingElement;
+        if (getTagName(opening) !== "table") return;
+        const role = getAttrStringValue(getAttr(opening, "role"));
+        if (role === "presentation" || role === "none") return;
+        if (getAttr(opening, "aria-label") || getAttr(opening, "aria-labelledby")) return;
+        const hasCaption = node.children.some(
+          (child) => child.type === "JSXElement" && getTagName(child.openingElement) === "caption"
+        );
+        if (!hasCaption) {
+          issues.push(
+            createStaticIssue({
+              node: opening,
+              filePath,
+              criterionId: "5.4",
+              testId: "5.4.1",
+              severity: "warning",
+              messageKey: "table.missing-caption",
+              wcag: "1.3.1"
+            })
+          );
+        }
+      }
+    });
+    return issues;
+  }
+);
+var thNeedsScope = defineRule({ id: "tables/th-scope", criteria: ["5.6"] }, (context) => {
+  const { filePath, ast } = context;
+  const issues = [];
+  walk(ast, {
+    JSXOpeningElement(rawNode) {
+      const node = rawNode;
+      if (getTagName(node) !== "th") return;
+      const scope = getAttr(node, "scope");
+      const id = getAttr(node, "id");
+      if (!scope && !id) {
+        issues.push(
+          createStaticIssue({
+            node,
+            filePath,
+            criterionId: "5.6",
+            testId: "5.6.1",
+            severity: "warning",
+            messageKey: "table.th-missing-scope",
+            wcag: "1.3.1"
+          })
+        );
+      }
+    }
+  });
+  return issues;
+});
+var layoutTableNoStructure = defineRule(
+  { id: "tables/layout-no-structural-elements", criteria: ["5.8"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXElement(rawNode) {
+        const node = rawNode;
+        const opening = node.openingElement;
+        if (getTagName(opening) !== "table") return;
+        const role = getAttrStringValue(getAttr(opening, "role"));
+        if (role !== "presentation" && role !== "none") return;
+        for (const child of node.children) {
+          if (child.type !== "JSXElement") continue;
+          const childTag = getTagName(child.openingElement);
+          if (childTag === "th") {
+            issues.push(
+              createStaticIssue({
+                node: child.openingElement,
+                filePath,
+                criterionId: "5.8",
+                testId: "5.8.1",
+                messageKey: "table.layout-has-th",
+                wcag: "1.3.1"
+              })
+            );
+          }
+          if (childTag === "caption") {
+            issues.push(
+              createStaticIssue({
+                node: child.openingElement,
+                filePath,
+                criterionId: "5.8",
+                testId: "5.8.1",
+                messageKey: "table.layout-has-caption",
+                remediationKey: "table.missing-caption",
+                wcag: "1.3.1"
+              })
+            );
+          }
+        }
+      }
+    });
+    return issues;
+  }
+);
+var tableRules = [tablesNeedCaption, thNeedsScope, layoutTableNoStructure];
+
+// src/analyzer/static/rules/06-links.ts
+var linksNeedLabel = defineRule({ id: "links/label-present", criteria: ["6.2"] }, (context) => {
+  const { filePath, ast } = context;
+  const issues = [];
+  walk(ast, {
+    JSXElement(rawNode) {
+      const node = rawNode;
+      const opening = node.openingElement;
+      if (getTagName(opening) !== "a") return;
+      const ariaLabel = getAttr(opening, "aria-label");
+      const ariaLabelledby = getAttr(opening, "aria-labelledby");
+      if (ariaLabel) {
+        const val = getAttrStringValue(ariaLabel);
+        if (val !== null && val.trim() === "") {
+          issues.push(
+            createStaticIssue({
+              node: opening,
+              filePath,
+              criterionId: "6.2",
+              testId: "6.2.1",
+              messageKey: "link.empty-label",
+              remediationKey: "link.missing-label",
+              wcag: "4.1.2"
+            })
+          );
+        }
+        return;
+      }
+      if (ariaLabelledby || isAttrDynamic(ariaLabel)) return;
+      const text = getTextContent(node);
+      if (text === null) return;
+      if (text.trim() === "") {
+        issues.push(
+          createStaticIssue({
+            node: opening,
+            filePath,
+            criterionId: "6.2",
+            testId: "6.2.1",
+            messageKey: "link.missing-label",
+            wcag: "4.1.2"
+          })
+        );
+      }
+    }
+  });
+  return issues;
+});
+var linkRules = [linksNeedLabel];
+
+// src/analyzer/static/rules/08-mandatory.ts
+import path from "path";
+var VALID_LANG_RE = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/;
+var LAYOUT_FILE_NAMES = /* @__PURE__ */ new Set(["layout", "_document", "RootLayout", "Head"]);
+function isLayoutFile(filePath) {
+  return LAYOUT_FILE_NAMES.has(path.basename(filePath, path.extname(filePath)));
+}
+var htmlNeedsLang = defineRule(
+  { id: "mandatory/html-lang", criteria: ["8.3", "8.4"] },
+  (context) => {
+    const { filePath, ast } = context;
+    if (!isLayoutFile(filePath) || path.basename(filePath, path.extname(filePath)) === "Head")
+      return [];
+    const issues = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        if (getTagName(node) !== "html") return;
+        const langAttr = getAttr(node, "lang");
+        if (!langAttr) {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "8.3",
+              testId: "8.3.1",
+              messageKey: "html.missing-lang",
+              wcag: "3.1.1"
+            })
+          );
+          return;
+        }
+        if (isAttrDynamic(langAttr)) return;
+        const langValue = getAttrStringValue(langAttr);
+        if (langValue !== null && langValue.trim() === "") {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "8.3",
+              testId: "8.3.1",
+              messageKey: "html.empty-lang",
+              remediationKey: "html.missing-lang",
+              wcag: "3.1.1"
+            })
+          );
+          return;
+        }
+        if (langValue !== null && !VALID_LANG_RE.test(langValue)) {
+          issues.push(
+            createStaticIssue({
+              node,
+              filePath,
+              criterionId: "8.4",
+              testId: "8.4.1",
+              messageKey: "html.invalid-lang",
+              wcag: "3.1.1",
+              messageContext: { lang: langValue }
+            })
+          );
+        }
+      }
+    });
+    return issues;
+  }
+);
+var pageNeedsTitle = defineRule(
+  { id: "mandatory/page-title", criteria: ["8.5", "8.6"] },
+  (context) => {
+    const { filePath, ast } = context;
+    if (!isLayoutFile(filePath)) return [];
+    const issues = [];
+    let foundTitle = false;
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        if (getTagName(node) !== "title") return;
+        foundTitle = true;
+      }
+    });
+    if (!foundTitle) {
+      issues.push({
+        id: issueId(),
+        criterionId: "8.5",
+        testId: "8.5.1",
+        phase: "static",
+        severity: "error",
+        file: filePath,
+        messageKey: "html.missing-title",
+        remediationKey: "html.missing-title",
+        wcag: "2.4.2"
+      });
+    }
+    return issues;
+  }
+);
+var PRESENTATIONAL_TAGS = /* @__PURE__ */ new Set(["b", "i", "u", "s", "blink", "marquee", "font", "center"]);
+var noPresentationalTags = defineRule(
+  { id: "mandatory/no-presentational-tags", criteria: ["8.9"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        const tag = getTagName(node);
+        if (!tag || !PRESENTATIONAL_TAGS.has(tag)) return;
+        const severity = tag === "b" || tag === "i" || tag === "s" ? "warning" : "error";
+        issues.push(
+          createStaticIssue({
+            node,
+            filePath,
+            criterionId: "8.9",
+            testId: "8.9.1",
+            severity,
+            messageKey: "html.presentational-tag",
+            wcag: "1.3.1",
+            messageContext: { tag }
+          })
+        );
+      }
+    });
+    return issues;
+  }
+);
+var mandatoryRules = [htmlNeedsLang, pageNeedsTitle, noPresentationalTags];
+
+// src/analyzer/static/rules/09-structure.ts
+var HEADING_TAGS = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+var HEADING_LEVEL = {
+  h1: 1,
+  h2: 2,
+  h3: 3,
+  h4: 4,
+  h5: 5,
+  h6: 6
+};
+function headingLevel(tag) {
+  return HEADING_LEVEL[tag] ?? 0;
+}
+var headingHierarchy = defineRule(
+  { id: "structure/heading-hierarchy", criteria: ["9.1"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    const headings = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        const tag = getTagName(node);
+        if (tag && HEADING_TAGS.has(tag)) {
+          headings.push({ tag, node });
+        }
+      }
+    });
+    if (headings.length === 0) return issues;
+    let h1Count = 0;
+    for (const { tag, node } of headings) {
+      if (tag === "h1" && ++h1Count > 1) {
+        issues.push(
+          createStaticIssue({
+            node,
+            filePath,
+            criterionId: "9.1",
+            testId: "9.1.3",
+            messageKey: "heading.multiple-h1",
+            wcag: "1.3.1"
+          })
+        );
+      }
+    }
+    for (let i = 1; i < headings.length; i++) {
+      const prev = headings[i - 1];
+      const curr = headings[i];
+      if (!prev || !curr) continue;
+      const prevLevel = headingLevel(prev.tag);
+      const currLevel = headingLevel(curr.tag);
+      if (currLevel > prevLevel + 1) {
+        issues.push(
+          createStaticIssue({
+            node: curr.node,
+            filePath,
+            criterionId: "9.1",
+            testId: "9.1.2",
+            messageKey: "heading.skipped-level",
+            wcag: "1.3.1",
+            messageContext: { from: String(prevLevel), to: String(currLevel) }
+          })
+        );
+      }
+    }
+    return issues;
+  }
+);
+var ORDERED_LIST_TAGS = /* @__PURE__ */ new Set(["ul", "ol"]);
+var listsProperlyStructured = defineRule(
+  { id: "structure/lists-structure", criteria: ["9.3"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXElement(rawNode) {
+        const node = rawNode;
+        const opening = node.openingElement;
+        const tag = getTagName(opening);
+        if (!tag || !ORDERED_LIST_TAGS.has(tag)) return;
+        const role = getAttrStringValue(getAttr(opening, "role"));
+        if (role === "none" || role === "presentation") return;
+        for (const child of node.children) {
+          if (child.type === "JSXText" && child.value.trim() === "") continue;
+          if (child.type !== "JSXElement") continue;
+          const childTag = getTagName(child.openingElement);
+          if (childTag !== null && childTag !== "li" && !/^[A-Z]/.test(childTag) && !childTag.includes("-")) {
+            issues.push(
+              createStaticIssue({
+                node: child.openingElement,
+                filePath,
+                criterionId: "9.3",
+                testId: "9.3.1",
+                messageKey: "list.invalid-child",
+                wcag: "1.3.1",
+                messageContext: { parent: tag, child: childTag }
+              })
+            );
+          }
+        }
+      }
+    });
+    return issues;
+  }
+);
+var structureRules = [headingHierarchy, listsProperlyStructured];
+
+// src/analyzer/static/rules/11-forms.ts
+var LABELABLE_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "email",
+  "password",
+  "number",
+  "tel",
+  "url",
+  "search",
+  "date",
+  "time",
+  "datetime-local",
+  "month",
+  "week",
+  "color",
+  "range",
+  "file",
+  "checkbox",
+  "radio"
+]);
+var PERSONAL_DATA_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "email",
+  "tel",
+  "name",
+  "given-name",
+  "family-name",
+  "additional-name",
+  "organization",
+  "organization-title",
+  "street-address",
+  "address-line1",
+  "address-line2",
+  "postal-code",
+  "country-name",
+  "bday",
+  "sex",
+  "url",
+  "username",
+  "new-password",
+  "current-password",
+  "one-time-code",
+  "cc-name",
+  "cc-number"
+]);
+function isLabelableInput(node) {
+  const typeAttr = getAttr(node, "type");
+  if (!typeAttr) return true;
+  const typeVal = getAttrStringValue(typeAttr);
+  if (!typeVal) return true;
+  return LABELABLE_INPUT_TYPES.has(typeVal);
+}
+var formFieldsNeedLabel = defineRule(
+  { id: "forms/label-present", criteria: ["11.1"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        const tag = getTagName(node);
+        if (!tag) return;
+        const isLabelable = tag === "textarea" || tag === "select" || tag === "input" && isLabelableInput(node);
+        if (!isLabelable) return;
+        const idAttr = getAttr(node, "id");
+        if (idAttr) return;
+        const ariaLabel = getAttr(node, "aria-label");
+        const ariaLabelledby = getAttr(node, "aria-labelledby");
+        const placeholder = getAttr(node, "placeholder");
+        if (isAttrDynamic(ariaLabel) || isAttrDynamic(ariaLabelledby)) return;
+        const hasStaticAriaLabel = ariaLabel && getAttrStringValue(ariaLabel)?.trim() !== "";
+        const hasAriaLabelledby = !!ariaLabelledby;
+        if (hasStaticAriaLabel || hasAriaLabelledby) return;
+        const severity = placeholder ? "warning" : "error";
+        const testId = tag === "textarea" ? "11.1.2" : tag === "select" ? "11.1.3" : "11.1.1";
+        issues.push(
+          createStaticIssue({
+            node,
+            filePath,
+            criterionId: "11.1",
+            testId,
+            severity,
+            messageKey: "form.missing-label",
+            remediationKey: "form.missing-label",
+            wcag: "1.3.1",
+            messageContext: { tag }
+          })
+        );
+      }
+    });
+    return issues;
+  }
+);
+var fieldsetNeedsLegend = defineRule(
+  { id: "forms/fieldset-legend", criteria: ["11.6"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXElement(rawNode) {
+        const node = rawNode;
+        const opening = node.openingElement;
+        const tag = getTagName(opening);
+        if (tag === "fieldset") {
+          const hasLegend = node.children.some(
+            (child) => child.type === "JSXElement" && getTagName(child.openingElement) === "legend"
+          );
+          if (!hasLegend) {
+            issues.push(
+              createStaticIssue({
+                node: opening,
+                filePath,
+                criterionId: "11.6",
+                testId: "11.6.1",
+                messageKey: "form.fieldset-missing-legend",
+                wcag: "1.3.1"
+              })
+            );
+          }
+          return;
+        }
+        const role = getAttrStringValue(getAttr(opening, "role"));
+        if (role === "group" || role === "radiogroup") {
+          const hasLabel = getAttr(opening, "aria-labelledby") || getAttr(opening, "aria-label");
+          if (!hasLabel) {
+            issues.push(
+              createStaticIssue({
+                node: opening,
+                filePath,
+                criterionId: "11.6",
+                testId: "11.6.2",
+                messageKey: "form.group-missing-label",
+                remediationKey: "form.fieldset-missing-legend",
+                wcag: "1.3.1",
+                messageContext: { role }
+              })
+            );
+          }
+        }
+      }
+    });
+    return issues;
+  }
+);
+var buttonsNeedLabel = defineRule({ id: "forms/button-label", criteria: ["11.9"] }, (context) => {
+  const { filePath, ast } = context;
+  const issues = [];
+  walk(ast, {
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: button/input label detection spans multiple element types
+    JSXElement(rawNode) {
+      const node = rawNode;
+      const opening = node.openingElement;
+      const tag = getTagName(opening);
+      if (tag === "button") {
+        const ariaLabel = getAttr(opening, "aria-label");
+        const ariaLabelledby = getAttr(opening, "aria-labelledby");
+        if (isAttrDynamic(ariaLabel) || isAttrDynamic(ariaLabelledby)) return;
+        const hasAriaLabel = ariaLabel && getAttrStringValue(ariaLabel)?.trim() !== "";
+        if (hasAriaLabel || ariaLabelledby) return;
+        const text = getTextContent(node);
+        if (text === null) return;
+        if (text.trim() === "") {
+          issues.push(
+            createStaticIssue({
+              node: opening,
+              filePath,
+              criterionId: "11.9",
+              testId: "11.9.1",
+              messageKey: "form.button-missing-label",
+              wcag: "1.3.1"
+            })
+          );
+        }
+        return;
+      }
+      if (tag === "input") {
+        const typeVal = getAttrStringValue(getAttr(opening, "type"));
+        if (typeVal !== "submit" && typeVal !== "button" && typeVal !== "reset") return;
+        const valueAttr = getAttr(opening, "value");
+        const ariaLabel = getAttr(opening, "aria-label");
+        if (ariaLabel || isAttrDynamic(valueAttr)) return;
+        const value = getAttrStringValue(valueAttr);
+        if (value === null || value.trim() !== "") return;
+        issues.push(
+          createStaticIssue({
+            node: opening,
+            filePath,
+            criterionId: "11.9",
+            testId: "11.9.2",
+            messageKey: "form.submit-empty-value",
+            remediationKey: "form.button-missing-label",
+            wcag: "1.3.1",
+            messageContext: { type: typeVal ?? "submit" }
+          })
+        );
+      }
+    }
+  });
+  return issues;
+});
+var PERSONAL_DATA_TYPES = /* @__PURE__ */ new Map([
+  ["email", "email"],
+  ["tel", "tel"]
+]);
+var PERSONAL_DATA_NAME_PATTERNS = Array.from(
+  PERSONAL_DATA_FIELD_NAMES
+).map((name) => {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/-/g, "[-_]");
+  return [new RegExp(`(?:^|[-_])${escaped}(?:$|[-_])`), name];
+});
+var autocompleteForPersonalData = defineRule(
+  { id: "forms/autocomplete-personal-data", criteria: ["11.13"] },
+  (context) => {
+    const { filePath, ast } = context;
+    const issues = [];
+    walk(ast, {
+      JSXOpeningElement(rawNode) {
+        const node = rawNode;
+        if (getTagName(node) !== "input") return;
+        const typeAttr = getAttr(node, "type");
+        const nameAttr = getAttr(node, "name");
+        const autocompleteAttr = getAttr(node, "autocomplete");
+        if (autocompleteAttr) return;
+        const typeVal = getAttrStringValue(typeAttr);
+        const nameVal = getAttrStringValue(nameAttr)?.toLowerCase() ?? "";
+        let purpose;
+        if (typeVal && PERSONAL_DATA_TYPES.has(typeVal)) {
+          purpose = PERSONAL_DATA_TYPES.get(typeVal);
+        } else {
+          for (const [re, token] of PERSONAL_DATA_NAME_PATTERNS) {
+            if (re.test(nameVal)) {
+              purpose = token;
+              break;
+            }
+          }
+        }
+        if (!purpose) return;
+        issues.push(
+          createStaticIssue({
+            node,
+            filePath,
+            criterionId: "11.13",
+            testId: "11.13.1",
+            severity: "warning",
+            messageKey: "form.missing-autocomplete",
+            wcag: "1.3.5",
+            messageContext: { purpose }
+          })
+        );
+      }
+    });
+    return issues;
+  }
+);
+var formRules = [
+  formFieldsNeedLabel,
+  fieldsetNeedsLegend,
+  buttonsNeedLabel,
+  autocompleteForPersonalData
+];
+
+// src/analyzer/static/rules/index.ts
+var ALL_STATIC_RULES = [
+  ...imageRules,
+  ...frameRules,
+  ...tableRules,
+  ...linkRules,
+  ...mandatoryRules,
+  ...structureRules,
+  ...formRules
+];
+
+// src/index.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  ALL_CRITERIA,
+  ALL_STATIC_RULES,
+  AXE_TEST_ID_PREFIX,
+  AXE_TO_RGAA,
+  AnalysisError,
+  CRITERIA_BY_ID,
+  ConfigError,
+  KodaRGAAConfigSchema,
+  THEMES,
+  TOTAL_CRITERIA,
+  TimeoutError,
+  analyze,
+  buildReport,
+  defineConfig,
+  generateDefaultConfig,
+  getAxeRulesForCriterion,
+  getRGAACriteria,
+  getSupportedLocales,
+  getTranslations,
+  interpolate,
+  loadConfig,
+  loadTranslations,
+  printReport,
+  resolveConfigPath,
+  runRuntimeAnalysis,
+  runStaticAnalysis,
+  writeHtmlReport,
+  writeJsonReport,
+  writeJunitReport,
+  writeMarkdownReport,
+  writeReports,
+  writeSarifReport
+};
+//# sourceMappingURL=index.js.map