@out-of-order/core 0.1.0

package/dist/index.js

@@ -0,0 +1,761 @@
+// src/audit.ts
+import { tabbable, getTabIndex } from "tabbable";
+
+// src/overlay-classes.ts
+var OVERLAY_CLASS_PREFIX = "ooo-";
+
+// src/dom.ts
+function closestAncestor(start, test) {
+  for (let node = start; node; node = node.parentElement) {
+    if (test(node)) {
+      return node;
+    }
+  }
+  return null;
+}
+function selectorFor(element) {
+  const parts = [];
+  let node = element;
+  let depth = 0;
+  while (node && depth < 4) {
+    let part = node.tagName.toLowerCase();
+    if (node.id) {
+      part += `#${node.id}`;
+      parts.unshift(part);
+      break;
+    }
+    const cls = (node.getAttribute("class") || "").trim().split(/\s+/).filter((c) => c && !c.startsWith(OVERLAY_CLASS_PREFIX));
+    if (cls.length) {
+      part += `.${cls[0]}`;
+    }
+    parts.unshift(part);
+    node = node.parentElement;
+    depth++;
+  }
+  return parts.join(" > ");
+}
+var NATIVE_FOR_ROLE = {
+  button: "<button>",
+  link: "<a href>",
+  checkbox: '<input type="checkbox">',
+  radio: '<input type="radio">',
+  switch: '<input type="checkbox" role="switch">',
+  slider: '<input type="range">',
+  spinbutton: '<input type="number">',
+  searchbox: '<input type="search">',
+  textbox: "<input> or <textarea>",
+  combobox: "<select>",
+  option: "<option>"
+};
+var COMPOSITE_ROLES_NO_NATIVE = [
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "tab",
+  "treeitem"
+];
+var INTERACTIVE_ROLES = [...Object.keys(NATIVE_FOR_ROLE), ...COMPOSITE_ROLES_NO_NATIVE];
+function isInteractive(element) {
+  const tag = element.tagName.toLowerCase();
+  if (tag === "a" && element.hasAttribute("href")) {
+    return true;
+  }
+  if (["button", "select", "textarea", "summary"].includes(tag)) {
+    return true;
+  }
+  if (tag === "input") {
+    const type = (element.getAttribute("type") || "text").toLowerCase();
+    return type !== "hidden";
+  }
+  const role = element.getAttribute("role");
+  return !!role && INTERACTIVE_ROLES.includes(role);
+}
+function hasExplicitName(element) {
+  return (element.getAttribute("aria-label") || "").trim() !== "" || (element.getAttribute("title") || "").trim() !== "";
+}
+function inAriaHidden(element) {
+  return element.closest('[aria-hidden="true"]') !== null;
+}
+function isInert(element) {
+  return element.closest("[inert]") !== null;
+}
+var IGNORE_ATTRIBUTE = "data-ooo-ignore";
+function isRuleIgnored(element, ruleId) {
+  const value = element.getAttribute(IGNORE_ATTRIBUTE);
+  if (value === null) {
+    return false;
+  }
+  const ids = value.trim().split(/\s+/).filter(Boolean);
+  return ids.length === 0 || ids.includes(ruleId);
+}
+function isTransparent(element) {
+  const check = element.checkVisibility;
+  if (typeof check === "function") {
+    return !check.call(element, { opacityProperty: true });
+  }
+  return closestAncestor(element, (node) => parseFloat(getComputedStyle(node).opacity || "1") === 0) !== null;
+}
+function isScreenReaderOnly(element, rect = element.getBoundingClientRect()) {
+  if (rect.width > 2 || rect.height > 2) {
+    return false;
+  }
+  const style = getComputedStyle(element);
+  return style.clip !== "" && style.clip !== "auto" || style.clipPath !== "" && style.clipPath !== "none" || style.overflow === "hidden";
+}
+function isClipped(element, rect) {
+  for (let node = element.parentElement; node; node = node.parentElement) {
+    const containerRect = node.getBoundingClientRect();
+    if (containerRect.width === 0 && containerRect.height === 0) {
+      continue;
+    }
+    const style = getComputedStyle(node);
+    const outX = rect.right <= containerRect.left || rect.left >= containerRect.right;
+    const outY = rect.bottom <= containerRect.top || rect.top >= containerRect.bottom;
+    const clipX = style.overflowX === "clip";
+    const clipY = style.overflowY === "clip";
+    if (outX && clipX || outY && clipY) {
+      return true;
+    }
+  }
+  return false;
+}
+function isOffPage(element, rect) {
+  const win = element.ownerDocument?.defaultView;
+  if (!win) {
+    return false;
+  }
+  const pageRight = rect.right + win.scrollX;
+  const pageBottom = rect.bottom + win.scrollY;
+  return pageRight <= 0 || pageBottom <= 0;
+}
+function staticHiddenReason(element, rect) {
+  if (isScreenReaderOnly(element, rect)) {
+    return null;
+  }
+  if (element.tagName.toLowerCase() === "area") {
+    return null;
+  }
+  if (isTransparent(element)) {
+    return "opacity:0, invisible but still tabbable";
+  }
+  if (rect.width < 1 || rect.height < 1) {
+    return "zero size, no visible target";
+  }
+  if (isOffPage(element, rect)) {
+    return "positioned off-screen (e.g. left:-9999px), invisible but still tabbable";
+  }
+  if (isClipped(element, rect)) {
+    return "clipped by an overflow:clip ancestor";
+  }
+  return null;
+}
+var REVEALING_PROPS = [
+  "opacity",
+  "visibility",
+  "display",
+  "position",
+  "left",
+  "right",
+  "top",
+  "bottom",
+  "inset",
+  "clip",
+  "clip-path",
+  "transform",
+  "translate",
+  "scale",
+  "width",
+  "height",
+  "max-width",
+  "max-height",
+  "overflow"
+];
+function revealSelectors(rules) {
+  return Array.from(rules).flatMap((rule) => {
+    if (rule instanceof CSSStyleRule) {
+      if (!/:focus/i.test(rule.selectorText) || !REVEALING_PROPS.some((p) => rule.style.getPropertyValue(p) !== "")) {
+        return [];
+      }
+      const resting = rule.selectorText.replace(/:focus(?:-visible|-within)?/gi, "").trim();
+      return resting ? [resting] : [];
+    }
+    return "cssRules" in rule ? revealSelectors(rule.cssRules) : [];
+  });
+}
+function focusRevealSelectors(doc) {
+  const sheets = [...Array.from(doc.styleSheets), ...doc.adoptedStyleSheets ?? []];
+  return sheets.flatMap((sheet) => {
+    try {
+      return revealSelectors(sheet.cssRules);
+    } catch {
+      return [];
+    }
+  });
+}
+function hiddenReason(element, rect, revealOnFocus = []) {
+  const reason = staticHiddenReason(element, rect);
+  if (!reason) {
+    return null;
+  }
+  const revealed = revealOnFocus.some((selector) => {
+    try {
+      return element.matches(selector);
+    } catch {
+      return false;
+    }
+  });
+  return revealed ? null : reason;
+}
+var NATIVE_INTERACTIVE_TAGS = ["a", "button", "input", "select", "textarea", "summary", "option"];
+function looksClickable(element) {
+  const tag = element.tagName.toLowerCase();
+  if (NATIVE_INTERACTIVE_TAGS.includes(tag)) {
+    return false;
+  }
+  const role = element.getAttribute("role");
+  if (role && INTERACTIVE_ROLES.includes(role)) {
+    return true;
+  }
+  return element.hasAttribute("onclick");
+}
+function nativeReplacement(element) {
+  if (NATIVE_INTERACTIVE_TAGS.includes(element.tagName.toLowerCase())) {
+    return null;
+  }
+  const role = element.getAttribute("role");
+  if (!role) {
+    return null;
+  }
+  return NATIVE_FOR_ROLE[role] ?? null;
+}
+function isNativelyFocusable(element) {
+  const tag = element.tagName.toLowerCase();
+  if (tag === "a" || tag === "area") {
+    return element.hasAttribute("href");
+  }
+  if (["button", "select", "textarea", "iframe"].includes(tag)) {
+    return true;
+  }
+  if (tag === "input") {
+    return (element.getAttribute("type") || "text").toLowerCase() !== "hidden";
+  }
+  if (tag === "audio" || tag === "video") {
+    return element.hasAttribute("controls");
+  }
+  if (tag === "summary") {
+    const parent = element.parentElement;
+    return parent?.tagName.toLowerCase() === "details" && parent.querySelector("summary") === element;
+  }
+  return false;
+}
+var COMPOSITE_ROLES = [
+  "toolbar",
+  "tablist",
+  "menu",
+  "menubar",
+  "radiogroup",
+  "listbox",
+  "tree",
+  "grid"
+];
+function compositeAncestor(element) {
+  return closestAncestor(element.parentElement, (node) => {
+    const role = node.getAttribute("role");
+    return !!role && COMPOSITE_ROLES.includes(role);
+  });
+}
+function isFocusManaged(element) {
+  const tabindex = element.getAttribute("tabindex");
+  if (tabindex !== null && Number(tabindex) < 0) {
+    return true;
+  }
+  if (compositeAncestor(element)) {
+    return true;
+  }
+  return element.closest("[aria-activedescendant]") !== null;
+}
+function floatingAncestor(element) {
+  return closestAncestor(element, (node) => {
+    const pos = getComputedStyle(node).position;
+    return pos === "fixed" || pos === "sticky";
+  });
+}
+function isScrollContainer(element) {
+  const scrollable = (value) => value === "auto" || value === "scroll" || value === "overlay";
+  const style = getComputedStyle(element);
+  return scrollable(style.overflowX) || scrollable(style.overflowY);
+}
+function scrollAncestor(element) {
+  return closestAncestor(element.parentElement, isScrollContainer);
+}
+function isDisplayed(element) {
+  const check = element.checkVisibility;
+  if (typeof check === "function") {
+    return check.call(element, { visibilityProperty: true });
+  }
+  return closestAncestor(element, (node) => getComputedStyle(node).display === "none") === null;
+}
+function openModal(root) {
+  for (const element of root.querySelectorAll('dialog:modal, [aria-modal="true"]')) {
+    if (isDisplayed(element)) {
+      return element;
+    }
+  }
+  return null;
+}
+
+// src/rules.ts
+import { computeAccessibleName } from "dom-accessibility-api";
+import { isFocusable } from "tabbable";
+var ROW_TOLERANCE_PX = 8;
+var flagEntries = (sequence, message) => sequence.flatMap((entry) => {
+  const msg = message(entry);
+  return msg ? [{ message: msg, target: entry }] : [];
+});
+var noPositiveTabIndex = (sequence) => flagEntries(
+  sequence,
+  (entry) => entry.tabIndex > 0 ? `Element has tabindex="${entry.tabIndex}". Positive tabindex overrides the natural DOM order and is fragile; use 0 or restructure the DOM.` : null
+);
+var visualOrderMismatch = (sequence) => {
+  const floats = sequence.map((entry) => floatingAncestor(entry.element));
+  const scrollers = sequence.map((entry) => scrollAncestor(entry.element));
+  const out = [];
+  for (let idx = 1; idx < sequence.length; idx++) {
+    const prev = sequence[idx - 1];
+    const cur = sequence[idx];
+    if (floats[idx - 1] !== floats[idx] || scrollers[idx - 1] !== scrollers[idx]) {
+      continue;
+    }
+    const prevX = prev.rect.left + prev.rect.width / 2;
+    const curX = cur.rect.left + cur.rect.width / 2;
+    const nextColumn = cur.rect.left >= prev.rect.right;
+    const earlierRow = cur.rect.bottom <= prev.rect.top + ROW_TOLERANCE_PX;
+    const sameRow = !earlierRow && cur.rect.top < prev.rect.bottom - ROW_TOLERANCE_PX;
+    const backwardHop = !nextColumn && (earlierRow || sameRow && curX < prevX - 1);
+    if (!backwardHop) {
+      continue;
+    }
+    out.push({
+      message: `"${cur.selector}" comes after "${prev.selector}" in the tab order, but sits visually before it (reading order is top\u2192bottom, left\u2192right). Tab makes a backward hop here.`,
+      target: cur
+    });
+  }
+  return out;
+};
+var missingAccessibleName = (sequence) => flagEntries(sequence, (entry) => {
+  if (!isInteractive(entry.element)) {
+    return null;
+  }
+  if (hasExplicitName(entry.element)) {
+    return null;
+  }
+  if (computeAccessibleName(entry.element).trim() !== "") {
+    return null;
+  }
+  return `Focusable element "${entry.selector}" has no accessible name (no text, aria-label, aria-labelledby, associated label, alt, or title).`;
+});
+var ariaHiddenFocusable = (sequence) => flagEntries(
+  sequence,
+  (entry) => inAriaHidden(entry.element) ? `"${entry.selector}" is tabbable but inside aria-hidden="true", so a screen-reader user lands on a control the SR won't announce. Add tabindex="-1"/inert, or remove aria-hidden.` : null
+);
+var hiddenWhileFocusable = (sequence, { container }) => {
+  const revealOnFocus = focusRevealSelectors(container.ownerDocument);
+  return flagEntries(sequence, (entry) => {
+    const reason = hiddenReason(entry.element, entry.rect, revealOnFocus);
+    return reason ? `"${entry.selector}" is tabbable but ${reason}. Hide it from the tab order too (display:none, the hidden attribute, or tabindex="-1").` : null;
+  });
+};
+var clickableNotFocusable = (_sequence, { container, inSequence }) => {
+  const wrapsFocusable = /* @__PURE__ */ new Set();
+  for (const stop of inSequence) {
+    for (let node = stop; node; node = node.parentElement) {
+      if (wrapsFocusable.has(node)) {
+        break;
+      }
+      wrapsFocusable.add(node);
+    }
+  }
+  const out = [];
+  for (const element of container.querySelectorAll("*")) {
+    if (inSequence.has(element)) {
+      continue;
+    }
+    if (wrapsFocusable.has(element)) {
+      continue;
+    }
+    if (!looksClickable(element)) {
+      continue;
+    }
+    if (isFocusManaged(element)) {
+      continue;
+    }
+    if (isInert(element)) {
+      continue;
+    }
+    const rect = element.getBoundingClientRect();
+    if (rect.width < 1 || rect.height < 1) {
+      continue;
+    }
+    const selector = selectorFor(element);
+    out.push({
+      message: `"${selector}" looks interactive (role or onclick) but is not in the tab order, so keyboard users can't reach it. Use a <button>/<a>, or add tabindex="0" plus Enter/Space handlers.`,
+      target: element
+    });
+  }
+  return out;
+};
+var compositeRovingTabindex = (sequence) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of sequence) {
+    const container = compositeAncestor(entry.element);
+    if (!container) {
+      continue;
+    }
+    const list = groups.get(container) ?? [];
+    list.push(entry);
+    groups.set(container, list);
+  }
+  const out = [];
+  for (const [container, members] of groups) {
+    if (members.length < 2) {
+      continue;
+    }
+    const role = container.getAttribute("role");
+    for (const member of members) {
+      out.push({
+        message: `${members.length} items inside role="${role}" are separate tab stops. A ${role} should expose one tab stop and move between items with the arrow keys (roving tabindex).`,
+        target: member
+      });
+    }
+  }
+  return out;
+};
+var focusEscapesModal = (sequence, { container }) => {
+  const modal = openModal(container);
+  if (!modal) {
+    return [];
+  }
+  const leaked = sequence.filter(
+    (entry) => !modal.contains(entry.element) && !isInert(entry.element)
+  );
+  if (leaked.length === 0) {
+    return [];
+  }
+  const first = leaked[0];
+  const subject = leaked.length === 1 ? `"${first.selector}" outside it is still tabbable` : `${leaked.length} controls outside it are still tabbable (e.g. "${first.selector}")`;
+  return [
+    {
+      message: `A modal dialog is open, but ${subject}, so focus can leak behind the dialog. Mark background content inert (or aria-hidden + remove it from the tab order).`,
+      target: first,
+      // One finding, anchored on the first leaked control, but every other leaked
+      // control shares the root cause (background not inert) and is ringed too.
+      relatedElements: leaked.slice(1).map((entry) => entry.element)
+    }
+  ];
+};
+var tabindexOnNoninteractive = (sequence) => flagEntries(sequence, (entry) => {
+  if (entry.tabIndex !== 0) {
+    return null;
+  }
+  if (entry.element.getAttribute("tabindex") === null) {
+    return null;
+  }
+  const element = entry.element;
+  if (isNativelyFocusable(element)) {
+    return null;
+  }
+  if (isInteractive(element)) {
+    return null;
+  }
+  if (element.isContentEditable) {
+    return null;
+  }
+  const role = element.getAttribute("role");
+  if (role && role !== "presentation" && role !== "none") {
+    return null;
+  }
+  if (isScrollContainer(element)) {
+    return null;
+  }
+  return `"${entry.selector}" has tabindex="0" but is non-interactive (no role, not a control). If it's decorative, remove the tabindex, since it adds a dead stop to the tab order; if it's meant to be a control, give it a real role (or use a <button>).`;
+});
+var preferNativeElement = (sequence) => flagEntries(sequence, (entry) => {
+  const native = nativeReplacement(entry.element);
+  if (!native) {
+    return null;
+  }
+  const tag = entry.element.tagName.toLowerCase();
+  const role = entry.element.getAttribute("role");
+  return `"${entry.selector}" is a <${tag}> with role="${role}". Prefer a native ${native}: focus, keyboard activation (Enter/Space), and screen-reader semantics come for free, instead of being reimplemented with ARIA + JS.`;
+});
+var duplicateAutofocus = (_sequence, { container }) => {
+  const focusableAutofocus = Array.from(container.querySelectorAll("[autofocus]")).filter(
+    (element) => isFocusable(element, { getShadowRoot: true })
+  );
+  if (focusableAutofocus.length < 2) {
+    return [];
+  }
+  return focusableAutofocus.slice(1).map((element) => {
+    const selector = selectorFor(element);
+    return {
+      message: `"${selector}" also has autofocus, but a page can autofocus only one element; the first focusable one in document order wins, so this one is silently ignored. Remove the extra autofocus.`,
+      target: element
+    };
+  });
+};
+var autofocusNotFocusable = (_sequence, { container }) => {
+  const out = [];
+  for (const element of container.querySelectorAll("[autofocus]")) {
+    if (isFocusable(element, { getShadowRoot: true })) {
+      continue;
+    }
+    const selector = selectorFor(element);
+    out.push({
+      message: `"${selector}" has autofocus but isn't focusable (no tabindex, not a form control), so it's ignored on load. Remove the autofocus, or make the element focusable (e.g. tabindex="-1").`,
+      target: element
+    });
+  }
+  return out;
+};
+var nestedInteractive = (sequence, { container, inSequence }) => {
+  const stop = container.parentElement;
+  const out = [];
+  for (const entry of sequence) {
+    for (let node = entry.element.parentElement; node && node !== stop; node = node.parentElement) {
+      if (!inSequence.has(node) && !isInteractive(node)) {
+        continue;
+      }
+      out.push({
+        message: `"${entry.selector}" is focusable but nested inside another focusable element ("${selectorFor(node)}"). Nesting interactive controls stacks two tab stops in one place and can hide the inner control's role/name from screen readers; don't put a focusable element inside another.`,
+        target: entry
+      });
+      break;
+    }
+  }
+  return out;
+};
+var redundantTabindex = (sequence) => flagEntries(sequence, (entry) => {
+  if (entry.tabIndex !== 0) {
+    return null;
+  }
+  if (entry.element.getAttribute("tabindex") === null) {
+    return null;
+  }
+  if (!isNativelyFocusable(entry.element)) {
+    return null;
+  }
+  return `"${entry.selector}" is already focusable, so its tabindex="0" is redundant. Remove the attribute; the element stays in the tab order on its own.`;
+});
+var ALL_RULES = {
+  "no-positive-tabindex": {
+    docs: "https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html",
+    defaultSeverity: "error",
+    run: noPositiveTabIndex
+  },
+  "visual-order-mismatch": {
+    docs: "https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html",
+    defaultSeverity: "warning",
+    run: visualOrderMismatch
+  },
+  "missing-accessible-name": {
+    docs: "https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html",
+    defaultSeverity: "error",
+    run: missingAccessibleName
+  },
+  "aria-hidden-focusable": {
+    docs: "https://www.w3.org/TR/wai-aria-1.2/#aria-hidden",
+    defaultSeverity: "error",
+    run: ariaHiddenFocusable
+  },
+  "hidden-while-focusable": {
+    docs: "https://www.w3.org/WAI/WCAG22/Understanding/focus-visible.html",
+    defaultSeverity: "error",
+    run: hiddenWhileFocusable
+  },
+  "clickable-not-focusable": {
+    docs: "https://www.w3.org/WAI/WCAG22/Understanding/keyboard.html",
+    defaultSeverity: "error",
+    run: clickableNotFocusable
+  },
+  "composite-roving-tabindex": {
+    docs: "https://www.w3.org/WAI/ARIA/apg/patterns/toolbar/",
+    defaultSeverity: "warning",
+    run: compositeRovingTabindex
+  },
+  "focus-escapes-modal": {
+    docs: "https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/",
+    defaultSeverity: "error",
+    run: focusEscapesModal
+  },
+  "tabindex-on-noninteractive": {
+    docs: "https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/",
+    defaultSeverity: "error",
+    run: tabindexOnNoninteractive
+  },
+  "prefer-native-element": {
+    docs: "https://www.w3.org/TR/using-aria/#firstrule",
+    defaultSeverity: "warning",
+    run: preferNativeElement
+  },
+  "duplicate-autofocus": {
+    docs: "https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute",
+    defaultSeverity: "warning",
+    run: duplicateAutofocus
+  },
+  "autofocus-not-focusable": {
+    docs: "https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute",
+    defaultSeverity: "warning",
+    run: autofocusNotFocusable
+  },
+  "nested-interactive": {
+    docs: "https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html",
+    defaultSeverity: "error",
+    run: nestedInteractive
+  },
+  "redundant-tabindex": {
+    docs: "https://html.spec.whatwg.org/multipage/interaction.html#attr-tabindex",
+    defaultSeverity: "warning",
+    run: redundantTabindex
+  }
+};
+var DEFAULT_SEVERITY = Object.fromEntries(
+  Object.entries(ALL_RULES).map(([id, rule]) => [id, rule.defaultSeverity])
+);
+
+// src/audit.ts
+function resolveRule(options, rule) {
+  const setting = options.rules?.[rule.id];
+  if (setting === void 0) {
+    return { enabled: true, severity: rule.defaultSeverity };
+  }
+  if (setting === "off") {
+    return { enabled: false, severity: rule.defaultSeverity };
+  }
+  return { enabled: true, severity: setting };
+}
+function toIssue(finding, rule, severity) {
+  return {
+    rule: rule.id,
+    severity,
+    message: finding.message,
+    docs: rule.docs,
+    relatedElements: finding.relatedElements
+  };
+}
+function locate(finding) {
+  const { target } = finding;
+  return "orderIndex" in target ? {
+    element: target.element,
+    selector: target.selector,
+    orderIndex: target.orderIndex
+  } : { element: target, selector: selectorFor(target) };
+}
+function audit(root = document, options = {}, customRules = []) {
+  const container = root.nodeType === 9 ? root.documentElement : root;
+  if (!container) {
+    return finalize({ valid: true, sequence: [], violations: [] }, options.format);
+  }
+  const elements = tabbable(container, {
+    getShadowRoot: true
+  });
+  const sequence = elements.map((element, orderIndex) => ({
+    element,
+    orderIndex,
+    selector: selectorFor(element),
+    tabIndex: getTabIndex(element),
+    rect: element.getBoundingClientRect()
+  }));
+  const ctx = {
+    container,
+    inSequence: new Set(sequence.map((entry) => entry.element))
+  };
+  const builtins = Object.entries(ALL_RULES).map(([id, def]) => ({
+    id,
+    ...def
+  }));
+  const byElement2 = /* @__PURE__ */ new Map();
+  for (const rule of [...builtins, ...customRules]) {
+    const { enabled, severity } = resolveRule(options, rule);
+    if (!enabled) {
+      continue;
+    }
+    for (const finding of rule.run(sequence, ctx)) {
+      const { element, selector, orderIndex } = locate(finding);
+      let violation = byElement2.get(element);
+      if (!violation) {
+        violation = { element, selector, orderIndex, issues: [] };
+        byElement2.set(element, violation);
+      }
+      const issue = toIssue(finding, rule, severity);
+      if (isRuleIgnored(element, rule.id)) {
+        issue.ignored = true;
+      }
+      violation.issues.push(issue);
+    }
+  }
+  const violations = [...byElement2.values()].sort(
+    (a, b) => (a.orderIndex ?? Infinity) - (b.orderIndex ?? Infinity)
+  );
+  for (const violation of violations) {
+    violation.issues.sort(
+      (a, b) => a.severity === b.severity ? 0 : a.severity === "error" ? -1 : 1
+    );
+  }
+  const hasErrors = violations.some(
+    (violation) => violation.issues.some((issue) => issue.severity === "error" && !issue.ignored)
+  );
+  return finalize({ valid: !hasErrors, sequence, violations }, options.format);
+}
+function finalize(result, format) {
+  if (!format) {
+    return result;
+  }
+  return { ...result, violations: reshape(result.violations, format) };
+}
+function reshape(violations, format) {
+  switch (format) {
+    case "text":
+      return renderText(violations);
+    case "by-element":
+      return byElement(violations);
+  }
+}
+var related = (issue) => issue.relatedElements?.map(selectorFor);
+function byElement(violations) {
+  return violations.map((violation) => ({
+    selector: violation.selector,
+    orderIndex: violation.orderIndex,
+    issueCount: violation.issues.length,
+    issues: violation.issues.map((issue) => ({
+      rule: issue.rule,
+      severity: issue.severity,
+      message: issue.message,
+      docs: issue.docs,
+      related: related(issue),
+      ignored: issue.ignored
+    }))
+  }));
+}
+function renderText(violations) {
+  if (!violations.length) {
+    return "No tab-order issues.";
+  }
+  return violations.map((violation) => {
+    const pos = violation.orderIndex !== void 0 ? `#${violation.orderIndex + 1} ` : "";
+    const issues = violation.issues.map((issue) => {
+      const rel = related(issue);
+      return `  - ${issue.severity.toUpperCase()} [${issue.rule}] ${issue.message}` + (rel?.length ? ` (related: ${rel.join(", ")})` : "") + (issue.ignored ? " (ignored via data-ooo-ignore)" : "");
+    }).join("\n");
+    return `${pos}${violation.selector}
+${issues}`;
+  }).join("\n\n");
+}
+export {
+  DEFAULT_SEVERITY,
+  OVERLAY_CLASS_PREFIX,
+  audit,
+  isInteractive,
+  isRuleIgnored,
+  isScreenReaderOnly,
+  selectorFor
+};