@surea11y/core 1.2.0 → 1.4.0

package/src/checks/automatic/form-control-single-label.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -17,17 +19,21 @@
  *   are ambiguous: many screen readers only announce one of them, and it
  *   is not deterministic which.
  * @implementation-notes
- * - Matches a widely-used reference engine's form-field-multiple-labels. Distinct, atomic
- *   decision from form-control-programmatic-label-present (that
- *   rule checks a label exists at all; this one checks there is at most
- *   one).
+ * - Distinct, atomic decision from form-control-programmatic-label-present
+ *   (that rule checks a label exists at all; this one checks there is at
+ *   most one).
+ * - A label that isn't accessibility-tree-eligible (display:none,
+ *   aria-hidden, etc.) is excluded before counting: it can't contribute to
+ *   the control's accessible name, so it can't create the ambiguity this
+ *   rule exists to catch.
  */
 
 const id = 'form-control-single-label';
 
 const meta = {
   title: 'Form controls must not have multiple labels',
-  description: 'Checks that a form control is associated with at most one <label> (by wrapping or by label[for]).',
+  description:
+    'Checks that a form control is associated with at most one <label> (by wrapping or by label[for]).',
   i18n: {
     titleKey: 'formControlSingleLabel_title',
     descriptionKey: 'formControlSingleLabel_description'
@@ -36,7 +42,13 @@ const meta = {
   tags: ['wcag2a', 'wcag332', 'forms', 'atomic', 'automatic'],
   wcagSc: ['3.3.2'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '3.3.2', title: 'Labels or Instructions', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '3.3.2',
+      title: 'Labels or Instructions',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'moderate',
   category: 'understandable',
@@ -48,8 +60,14 @@ const meta = {
 function runInPage(ctx) {
   const { document, helpers, rule } = ctx;
 
-  const selector = 'input:not([type="hidden"]):not([type="submit"]):not([type="reset"]):not([type="button"]):not([type="image"]),select,textarea';
-  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart(selector) : helpers.queryAll(selector);
+  const isAccTreeEligible =
+    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  const selector =
+    'input:not([type="hidden"]):not([type="submit"]):not([type="reset"]):not([type="button"]):not([type="image"]),select,textarea';
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart(selector)
+    : helpers.queryAll(selector);
 
   // Build a for-value -> label[] map once (avoids per-control dynamic
   // attribute-selector construction / CSS.escape, which is not guaranteed
@@ -82,11 +100,20 @@ function runInPage(ctx) {
       for (const lab of labelsByFor.get(controlId)) labels.add(lab);
     }
 
-    if (labels.size <= 1) continue;
+    const eligibleLabels = isAccTreeEligible
+      ? new Set(
+          [...labels].filter((lab) => {
+            const elig = isAccTreeEligible(lab);
+            return !elig || elig.eligible !== false;
+          })
+        )
+      : labels;
+
+    if (eligibleLabels.size <= 1) continue;
 
     const tag = el.tagName.toLowerCase();
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
 
     occurrences.push({
       selector: stableSelector,
@@ -96,10 +123,14 @@ function runInPage(ctx) {
       i18n: {
         summaryKey: 'formControlSingleLabel_summary_fail',
         hintKey: 'formControlSingleLabel_hint_fail',
-        params: { element: tag, labelCount: String(labels.size) }
+        params: { element: tag, labelCount: String(eligibleLabels.size) }
       },
       data: {
-        details: { reasonCode: 'FORM_FIELD_MULTIPLE_LABELS', element: tag, labelCount: labels.size }
+        details: {
+          reasonCode: 'FORM_FIELD_MULTIPLE_LABELS',
+          element: tag,
+          labelCount: eligibleLabels.size
+        }
       }
     });
   }
@@ -108,9 +139,14 @@ function runInPage(ctx) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
   if (occurrences.length) {
-    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'moderate', occurrences };
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'fail',
+      severity: rule.defaultSeverity || 'moderate',
+      occurrences
+    };
   }
   return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
 }
 
-module.exports = { id, meta, runInPage };
+module.exports = { id, meta, runInPage };

package/src/checks/automatic/html-xml-lang-mismatch.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -27,7 +29,8 @@ const id = 'html-xml-lang-mismatch';
 
 const meta = {
   title: 'lang and xml:lang must not disagree',
-  description: 'Checks that the <html> element\'s lang and xml:lang attributes declare the same primary language, when both are present.',
+  description:
+    "Checks that the <html> element's lang and xml:lang attributes declare the same primary language, when both are present.",
   i18n: {
     titleKey: 'htmlXmlLangMismatch_title',
     descriptionKey: 'htmlXmlLangMismatch_description'
@@ -36,7 +39,13 @@ const meta = {
   tags: ['wcag2a', 'wcag311', 'structure', 'language', 'atomic', 'automatic'],
   wcagSc: ['3.1.1'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '3.1.1', title: 'Language of Page', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '3.1.1',
+      title: 'Language of Page',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'serious',
   category: 'understandable',
@@ -57,7 +66,7 @@ function runInPage(ctx) {
   const { document, helpers, rule } = ctx;
 
   const html = document && document.documentElement;
-  const tag = (html && html.tagName) ? String(html.tagName).toLowerCase() : '';
+  const tag = html && html.tagName ? String(html.tagName).toLowerCase() : '';
   if (!html || tag !== 'html') {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
@@ -76,24 +85,33 @@ function runInPage(ctx) {
   }
 
   const stableSelector = helpers.buildSelector ? helpers.buildSelector(html) : 'html';
-  const htmlSnippet = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(html) : (html.outerHTML || '').slice(0, 200);
+  const htmlSnippet = helpers.getOuterHtmlSnippet
+    ? helpers.getOuterHtmlSnippet(html)
+    : (html.outerHTML || '').slice(0, 200);
 
-  const occurrences = [{
-    selector: stableSelector,
-    html: htmlSnippet,
-    summary: `The lang ("${lang}") and xml:lang ("${xmlLang}") attributes declare different languages.`,
-    hint: 'Make lang and xml:lang declare the same primary language, or remove the deprecated xml:lang attribute.',
-    i18n: {
-      summaryKey: 'htmlXmlLangMismatch_summary_fail',
-      hintKey: 'htmlXmlLangMismatch_hint_fail',
-      params: { lang, xmlLang }
-    },
-    data: {
-      details: { reasonCode: 'HTML_XML_LANG_MISMATCH', lang, xmlLang }
+  const occurrences = [
+    {
+      selector: stableSelector,
+      html: htmlSnippet,
+      summary: `The lang ("${lang}") and xml:lang ("${xmlLang}") attributes declare different languages.`,
+      hint: 'Make lang and xml:lang declare the same primary language, or remove the deprecated xml:lang attribute.',
+      i18n: {
+        summaryKey: 'htmlXmlLangMismatch_summary_fail',
+        hintKey: 'htmlXmlLangMismatch_hint_fail',
+        params: { lang, xmlLang }
+      },
+      data: {
+        details: { reasonCode: 'HTML_XML_LANG_MISMATCH', lang, xmlLang }
+      }
     }
-  }];
+  ];
 
-  return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'serious', occurrences };
+  return {
+    ruleId: rule.ruleId,
+    outcome: 'fail',
+    severity: rule.defaultSeverity || 'serious',
+    occurrences
+  };
 }
 
 module.exports = { id, meta, runInPage, applicability };

package/src/checks/automatic/iframe-focusable-content.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -36,7 +38,8 @@ const id = 'iframe-focusable-content';
 
 const meta = {
   title: 'Frames with tabindex="-1" must not contain focusable content',
-  description: 'Checks that same-origin <iframe>/<frame> elements with tabindex="-1" do not contain focusable content, since browsers do not propagate that restriction into the frame’s embedded document.',
+  description:
+    'Checks that same-origin <iframe>/<frame> elements with tabindex="-1" do not contain focusable content, since browsers do not propagate that restriction into the frame’s embedded document.',
   i18n: {
     titleKey: 'iframeFocusableContent_title',
     descriptionKey: 'iframeFocusableContent_description'
@@ -45,7 +48,13 @@ const meta = {
   tags: ['wcag2a', 'wcag211', 'structure', 'atomic', 'automatic', 'keyboard', 'iframe'],
   wcagSc: ['2.1.1'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '2.1.1', title: 'Keyboard', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '2.1.1',
+      title: 'Keyboard',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'moderate',
   category: 'operable',
@@ -55,19 +64,151 @@ const meta = {
 };
 
 function runInPage(ctx) {
-  const { document, helpers, rule } = ctx;
+  const { helpers, rule, document } = ctx;
+
+  // Self-contained rendering check for the embedded document (a distinct
+  // realm — see this rule's own header comment on why the outer
+  // document's shared eligibility helpers can't be reused here).
+  // Deliberately checks only genuine non-rendering (display:none,
+  // visibility:hidden, the hidden attribute) via the ancestor chain, NOT
+  // aria-hidden: aria-hidden alone does not remove an element from a real
+  // browser's native tab order (the same anti-pattern this engine's own
+  // aria-hidden-focus rule exists to catch), so an aria-hidden-but-
+  // visually-rendered focusable element inside the frame is still
+  // genuinely reachable by keyboard and must stay flagged.
+  function isRenderedInDoc(doc, el) {
+    try {
+      const view = doc.defaultView;
+      if (!view || typeof view.getComputedStyle !== 'function') return true;
+      let node = el;
+      while (node && node.nodeType === 1) {
+        if (node.hasAttribute && node.hasAttribute('hidden')) return false;
+        const cs = view.getComputedStyle(node);
+        if (cs) {
+          if (cs.display === 'none') return false;
+          if (cs.visibility === 'hidden' || cs.visibility === 'collapse') return false;
+        }
+        node = node.parentElement;
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+
+  function getDeepActiveElement(docRef) {
+    let cur = docRef && docRef.activeElement ? docRef.activeElement : null;
+    let guard = 0;
+    while (cur && cur.shadowRoot && cur.shadowRoot.activeElement && guard++ < 20) {
+      cur = cur.shadowRoot.activeElement;
+    }
+    return cur;
+  }
+
+  function focusElementSafe(el) {
+    if (!el || typeof el.focus !== 'function') return false;
+    try {
+      el.focus({ preventScroll: true });
+      return true;
+    } catch {
+      try {
+        el.focus();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  function runFocusObservationWindow(win, fn) {
+    if (!win || typeof fn !== 'function') return;
+    const originalSetTimeout =
+      typeof win.setTimeout === 'function' ? win.setTimeout.bind(win) : null;
+    const originalRequestAnimationFrame =
+      typeof win.requestAnimationFrame === 'function' ? win.requestAnimationFrame.bind(win) : null;
+    const originalQueueMicrotask =
+      typeof win.queueMicrotask === 'function' ? win.queueMicrotask.bind(win) : null;
+
+    const queuedMicrotasks = [];
+    const queuedRaf = [];
+    const queuedTimers = [];
+    let fakeTimerId = 1;
+
+    const patchedSetTimeout = function (cb, delay) {
+      const d = Number.isFinite(Number(delay)) ? Number(delay) : 0;
+      if (typeof cb === 'function' && d <= 200) {
+        const args = [];
+        for (let i = 2; i < arguments.length; i++) args.push(arguments[i]);
+        queuedTimers.push({ delay: d, cb: () => cb.apply(win, args) });
+        return fakeTimerId++;
+      }
+      if (originalSetTimeout) return originalSetTimeout.apply(win, arguments);
+      return fakeTimerId++;
+    };
+
+    const patchedRaf = function (cb) {
+      if (typeof cb === 'function') {
+        queuedRaf.push(cb);
+        return fakeTimerId++;
+      }
+      if (originalRequestAnimationFrame) return originalRequestAnimationFrame.apply(win, arguments);
+      return fakeTimerId++;
+    };
 
-  function hasFocusableCandidate(doc) {
-    if (!doc || !doc.querySelectorAll) return false;
-    let els = [];
+    const patchedQueueMicrotask = function (cb) {
+      if (typeof cb === 'function') queuedMicrotasks.push(cb);
+    };
+
+    try {
+      if (originalSetTimeout) win.setTimeout = patchedSetTimeout;
+      if (originalRequestAnimationFrame) win.requestAnimationFrame = patchedRaf;
+      if (originalQueueMicrotask) win.queueMicrotask = patchedQueueMicrotask;
+      fn();
+
+      let guard = 0;
+      while (
+        (queuedMicrotasks.length || queuedRaf.length || queuedTimers.length) &&
+        guard++ < 100
+      ) {
+        while (queuedMicrotasks.length) {
+          const mt = queuedMicrotasks.shift();
+          try {
+            mt();
+          } catch {}
+        }
+        while (queuedRaf.length) {
+          const rf = queuedRaf.shift();
+          try {
+            rf(16);
+          } catch {}
+        }
+        if (queuedTimers.length) {
+          queuedTimers.sort((a, b) => a.delay - b.delay);
+          const tt = queuedTimers.shift();
+          try {
+            tt.cb();
+          } catch {}
+        }
+      }
+    } finally {
+      if (originalSetTimeout) win.setTimeout = originalSetTimeout;
+      if (originalRequestAnimationFrame) win.requestAnimationFrame = originalRequestAnimationFrame;
+      if (originalQueueMicrotask) win.queueMicrotask = originalQueueMicrotask;
+    }
+  }
+
+  function getFocusableCandidates(doc) {
+    if (!doc || !doc.querySelectorAll) return [];
+    let els;
     try {
       els = doc.querySelectorAll(
         'a[href], area[href], button:not([disabled]), input:not([disabled]):not([type="hidden"]), ' +
-        'select:not([disabled]), textarea:not([disabled]), iframe, [contenteditable="true"], [tabindex]'
+          'select:not([disabled]), textarea:not([disabled]), iframe, [contenteditable="true"], [tabindex]'
       );
     } catch {
-      return false;
+      return [];
     }
+    const candidates = [];
     for (const el of els) {
       if (!el || !el.getAttribute) continue;
       const raw = el.getAttribute('tabindex');
@@ -75,9 +216,77 @@ function runInPage(ctx) {
         const n = Number(String(raw).trim());
         if (!Number.isNaN(n) && n < 0) continue; // explicitly removed from tab order
       }
-      return true;
+      if (!isRenderedInDoc(doc, el)) continue; // display:none/visibility:hidden/[hidden]: never reachable at all
+      candidates.push(el);
     }
-    return false;
+    return candidates;
+  }
+
+  function probeImmediateFocusRedirect(frameEl, embeddedDoc, candidate) {
+    if (!frameEl || !embeddedDoc || !candidate) return null;
+    const embeddedWindow = embeddedDoc.defaultView;
+    if (!embeddedWindow) return null;
+
+    let focusedByEvent = false;
+    const onFocusCapture = () => {
+      focusedByEvent = true;
+    };
+    try {
+      candidate.addEventListener('focus', onFocusCapture, true);
+    } catch {}
+
+    const innerFocusTrace = [];
+    const outerFocusTrace = [];
+    const onInnerFocusIn = (ev) => {
+      if (ev && ev.target) innerFocusTrace.push(ev.target);
+    };
+    const onOuterFocusIn = (ev) => {
+      if (ev && ev.target) outerFocusTrace.push(ev.target);
+    };
+    try {
+      embeddedDoc.addEventListener('focusin', onInnerFocusIn, true);
+      document.addEventListener('focusin', onOuterFocusIn, true);
+    } catch {}
+
+    const beforeInner = getDeepActiveElement(embeddedDoc);
+    const beforeOuter = getDeepActiveElement(document);
+    let focused = false;
+    runFocusObservationWindow(embeddedWindow, () => {
+      focused = focusElementSafe(candidate);
+    });
+    try {
+      embeddedDoc.removeEventListener('focusin', onInnerFocusIn, true);
+      document.removeEventListener('focusin', onOuterFocusIn, true);
+    } catch {}
+    try {
+      candidate.removeEventListener('focus', onFocusCapture, true);
+    } catch {}
+
+    if (!focused) return null;
+
+    const afterInner = getDeepActiveElement(embeddedDoc);
+    const afterOuter = getDeepActiveElement(document);
+    const sawRedirectedInnerTrace = innerFocusTrace.some((n) => n && n !== candidate);
+    const sawRedirectedOuterTrace = outerFocusTrace.some(
+      (n) => n && n !== frameEl && n !== candidate
+    );
+    const redirectedWithinFrame =
+      !!(afterInner && afterInner !== candidate) || sawRedirectedInnerTrace;
+    const redirectedOutOfFrame =
+      !!(afterOuter && afterOuter !== frameEl) || sawRedirectedOuterTrace;
+    const sawCandidateFocus = focusedByEvent || innerFocusTrace.some((n) => n === candidate);
+
+    if (beforeInner && beforeInner !== afterInner) focusElementSafe(beforeInner);
+    if (beforeOuter && beforeOuter !== afterOuter) focusElementSafe(beforeOuter);
+
+    if (!sawCandidateFocus) return null;
+    if (!redirectedWithinFrame && !redirectedOutOfFrame) return null;
+
+    return {
+      redirected: true,
+      redirectedWithinFrame,
+      redirectedOutOfFrame
+    };
   }
 
   function getNegativeTabIndex(el) {
@@ -87,16 +296,19 @@ function runInPage(ctx) {
     return !Number.isNaN(n) && n < 0;
   }
 
-  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('iframe, frame') : helpers.queryAll('iframe, frame');
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart('iframe, frame')
+    : helpers.queryAll('iframe, frame');
 
-  const occurrences = [];
+  const failOccurrences = [];
+  const cantTellOccurrences = [];
   let applicableCount = 0;
 
   for (const el of nodes) {
     if (!el || !el.getAttribute) continue;
     if (!getNegativeTabIndex(el)) continue;
 
-    let contentDoc = null;
+    let contentDoc;
     try {
       contentDoc = el.contentDocument || null;
     } catch {
@@ -106,16 +318,41 @@ function runInPage(ctx) {
 
     applicableCount += 1;
 
-    if (!hasFocusableCandidate(contentDoc)) continue;
+    const candidates = getFocusableCandidates(contentDoc);
+    if (!candidates.length) continue;
 
     const tag = el.tagName.toLowerCase();
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
+    const shouldProbe = candidates.length === 1;
+    const runtimeProbe = shouldProbe
+      ? probeImmediateFocusRedirect(el, contentDoc, candidates[0])
+      : null;
 
-    occurrences.push({
+    if (runtimeProbe && runtimeProbe.redirected) {
+      cantTellOccurrences.push({
+        selector: stableSelector,
+        html,
+        summary:
+          'This frame has tabindex="-1" and a focusable candidate, but focus moves immediately to another target. Verify keyboard reachability in a real browser.',
+        hint: 'If this is an intentional focus handoff, ensure keyboard users cannot remain on hidden/intermediate frame content.',
+        i18n: null,
+        data: {
+          details: {
+            reasonCode: 'IFRAME_TABINDEX_NEGATIVE_CONTENT_RUNTIME_REDIRECT',
+            element: tag,
+            runtimeProbe
+          }
+        }
+      });
+      continue;
+    }
+
+    failOccurrences.push({
       selector: stableSelector,
       html,
-      summary: 'This frame has tabindex="-1" but its content contains focusable elements, which remain reachable by keyboard.',
+      summary:
+        'This frame has tabindex="-1" but its content contains focusable elements, which remain reachable by keyboard.',
       hint: 'Remove focusable content from the frame, or remove tabindex="-1" if the frame is meant to be reachable.',
       i18n: {
         summaryKey: 'iframeFocusableContent_summary_fail',
@@ -131,10 +368,16 @@ function runInPage(ctx) {
   if (applicableCount === 0) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
-  if (occurrences.length) {
-    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'moderate', occurrences };
-  }
-  return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
+  // helpers.resolveTieredOutcome is unconditionally provided by dom-helpers.js
+  // (see its own header comment) -- no fallback needed, matching the same
+  // cleanup already applied to aria-hidden-focus.js/aria-prohibited-attr.js/
+  // target-size-minimum.js.
+  const resolved = helpers.resolveTieredOutcome(
+    failOccurrences,
+    cantTellOccurrences,
+    rule.defaultSeverity || 'moderate'
+  );
+  return { ruleId: rule.ruleId, ...resolved };
 }
 
-module.exports = { id, meta, runInPage };
+module.exports = { id, meta, runInPage };

package/src/checks/automatic/iframe-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -25,7 +27,8 @@ const id = 'iframe-name-present';
 
 const meta = {
   title: 'Frames have an accessible name',
-  description: 'Checks that <iframe>/<frame> elements expose a non-empty accessible name via aria-label, aria-labelledby, or the title attribute.',
+  description:
+    'Checks that <iframe>/<frame> elements expose a non-empty accessible name via aria-label, aria-labelledby, or the title attribute.',
   i18n: {
     titleKey: 'iframeNamePresent_title',
     descriptionKey: 'iframeNamePresent_description'
@@ -34,7 +37,13 @@ const meta = {
   tags: ['wcag2a', 'wcag412', 'structure', 'atomic', 'automatic', 'name', 'iframe'],
   wcagSc: ['4.1.2'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '4.1.2', title: 'Name, Role, Value', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '4.1.2',
+      title: 'Name, Role, Value',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'serious',
   category: 'robust',
@@ -44,9 +53,11 @@ const meta = {
 };
 
 function runInPage(ctx) {
-  const { document, helpers, rule } = ctx;
+  const { helpers, rule } = ctx;
 
-  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('iframe, frame') : helpers.queryAll('iframe, frame');
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart('iframe, frame')
+    : helpers.queryAll('iframe, frame');
 
   const occurrences = [];
   let applicableCount = 0;
@@ -62,15 +73,23 @@ function runInPage(ctx) {
 
     applicableCount += 1;
 
-    const nameInfo = helpers.getAccessibleNameInfo ? helpers.getAccessibleNameInfo(el, ctx, { maxRefs: 8 }) : null;
+    const nameInfo = helpers.getAccessibleNameInfo
+      ? helpers.getAccessibleNameInfo(el, ctx, { maxRefs: 8 })
+      : null;
     if (nameInfo && nameInfo.present && nameInfo.value) continue;
 
     const eligInfo = helpers.getEligibilityInfo
-      ? (() => { try { return helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' }); } catch { return null; } })()
+      ? (() => {
+          try {
+            return helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' });
+          } catch {
+            return null;
+          }
+        })()
       : null;
     const tag = el.tagName.toLowerCase();
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
 
     occurrences.push({
       selector: stableSelector,
@@ -93,9 +112,14 @@ function runInPage(ctx) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
   if (occurrences.length) {
-    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'serious', occurrences };
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'fail',
+      severity: rule.defaultSeverity || 'serious',
+      occurrences
+    };
   }
   return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
 }
 
-module.exports = { id, meta, runInPage };
+module.exports = { id, meta, runInPage };