@surea11y/core 1.3.0 → 1.4.1

package/src/checks/manual/bypass-blocks-present-manual.js

@@ -0,0 +1,279 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
+'use strict';
+
+/**
+ * @check bypass-blocks-present
+ * @atomic true
+ * @summary The page must provide at least one mechanism to bypass repeated blocks of content
+ * @standard WCAG 2.2
+ * @sc 2.4.1
+ * @applicability
+ *   Always applicable to any HTML document with a <body> element —
+ *   "bypass blocks" is a whole-page concern, matching
+ *   aria-hidden-body / page-title-present's pattern of
+ *   evaluating the document directly rather than a scoped root.
+ * @expectation
+ *   At least one of the following recognized WCAG 2.4.1 techniques is
+ *   present:
+ *   (a) a main landmark (<main> or [role="main"]) — technique ARIA11: a
+ *       screen reader user can jump straight to it, bypassing everything
+ *       before it (nav, header, repeated blocks) in one step;
+ *   (b) a working same-page anchor link — technique G1/G123: an
+ *       <a href="#id"> (or legacy <a name="id">) whose target resolves to
+ *       a real element in the link's own tree (light DOM or the same shadow
+ *       root). Deliberately NOT required to be positioned before a <nav> or
+ *       be keyboard-focus-order-first — see implementation notes;
+ *   (c) at least one heading (<h1>-<h6> or [role="heading"]) — technique
+ *       H69: heading navigation is itself a standards-recognized bypass
+ *       mechanism (e.g. a screen reader's "jump by heading" command).
+ * @implementation-notes
+ * - Outcome model: this rule is `type: 'manual'` (cantTell-capped, never
+ *   `fail`). When a recognized mechanism is found the page has nothing to
+ *   review here → `notApplicable` (matching page-has-heading-one-manual /
+ *   skip-link-manual's "nothing to flag" convention). When none is found we
+ *   return `cantTell` — "we could not detect a bypass mechanism, please
+ *   verify" — rather than a hard `fail`. The absence of a *detectable*
+ *   mechanism is NOT high-confidence evidence that 2.4.1 is violated, for
+ *   several reasons the engine cannot resolve from a single static snapshot:
+ *     • Applicability itself is undecidable in-page. 2.4.1 governs blocks of
+ *       content "repeated on multiple Web pages"; whether any block is
+ *       actually repeated across the site is not knowable from one document,
+ *       so a page that legitimately needs no bypass mechanism would be
+ *       indistinguishable from one that omits a required one.
+ *     • Transient accessibility-tree state. When a modal dialog is open the
+ *       rest of the page is routinely made `inert` or `aria-hidden="true"`,
+ *       so the page's real <main>/headings are (correctly) filtered out by
+ *       isAccTreeEligible for the duration of that state and only the dialog
+ *       is exposed — a snapshot taken then would see "no mechanism" though
+ *       the page has one once the dialog closes. The same applies to content
+ *       that is display:none until revealed by script (tabs, accordions, an
+ *       unmounted SPA view).
+ *   Both cases would produce false positives under a hard `fail`, which this
+ *   engine reserves for high-confidence violations; `cantTell` routes them to
+ *   human review instead. This mirrors how other tools treat 2.4.1 (e.g. axe
+ *   marks the no-mechanism case "needs review" via reviewOnFail rather than
+ *   failing it), and why no ACT rule hard-fails 2.4.1 by presence alone.
+ * - This rule intentionally checks presence, not position, for the
+ *   same-page-anchor condition (b): a full bypass algorithm is heuristic
+ *   (see ROADMAP.md's Tier 1a note on why this rule was
+ *   deferred from the rest of that batch), and getting DOM-order /
+ *   keyboard-focus-order positioning exactly right without introducing
+ *   false positives is materially harder than the rest of Tier 1a. Being
+ *   lenient about condition (b) can only make us *miss* a review prompt
+ *   (a page whose only anchor link isn't a real skip mechanism, e.g. a
+ *   "back to top" link) — never raise a spurious one.
+ * - Shadow DOM: all three conditions use `helpers.queryAllSmart`, which is
+ *   shadow-DOM-aware (when the run enables includeShadowDom) and applies the
+ *   engine's hidden-content policy. The same-page-anchor target is resolved
+ *   in the link's own root (`getRootNode()` — the document, or the shadow
+ *   root the link lives in) before falling back to the document, so a skip
+ *   link encapsulated in a web component is credited the same as one in the
+ *   light DOM. (Previously the anchor path used raw
+ *   `document.querySelectorAll`/`getElementById`, which never pierced shadow
+ *   roots — a genuine gap now closed.)
+ */
+
+const id = 'bypass-blocks-present';
+
+const meta = {
+  title: 'Page must provide a way to bypass repeated blocks',
+  description:
+    'Checks that the page has at least one recognized WCAG 2.4.1 bypass-blocks mechanism: a main landmark, a working same-page anchor link, or a heading.',
+  i18n: {
+    titleKey: 'bypassBlocksPresent_title',
+    descriptionKey: 'bypassBlocksPresent_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag241', 'navigation', 'atomic', 'manual'],
+  wcagSc: ['2.4.1'],
+  normativeMappings: [
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '2.4.1',
+      title: 'Bypass Blocks',
+      conformanceLevel: 'A'
+    }
+  ],
+  defaultSeverity: 'moderate',
+  category: 'operable',
+  type: 'manual',
+  defaultConfidence: 'medium',
+  coverage: { facetsBySc: { '2.4.1': ['bypass-blocks-present'] } }
+};
+
+// This check is inherently whole-document (does the PAGE have this
+// property?), not evaluable per-subtree -- notApplicable when contextSelector
+// scoped this run narrower than the whole document, or when
+// engineOptions.fragment:true was set (see helpers.isWholeDocumentScope).
+function applicability(ctx) {
+  return ctx.helpers.isWholeDocumentScope ? ctx.helpers.isWholeDocumentScope() : true;
+}
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+
+  const body = document && document.body ? document.body : null;
+  if (!body) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const isAccTreeEligible =
+    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  function isExposedToAt(el) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  function queryAll(selector) {
+    try {
+      return helpers && typeof helpers.queryAllSmart === 'function'
+        ? helpers.queryAllSmart(selector)
+        : document.querySelectorAll(selector);
+    } catch {
+      return [];
+    }
+  }
+
+  // Filters through isAccTreeEligible (hidden/aria-hidden/display:none/inert
+  // don't count as "a bypass mechanism is present") -- see
+  // page-has-heading-one-manual.js for the identical real-world trigger
+  // (e.g. a page whose only <h1> sits inside a display:none ancestor,
+  // unreachable by sighted and screen reader users alike). A fully
+  // non-rendered <main>/heading must not be credited here, since that would
+  // wrongly treat a page with zero currently-exposed bypass mechanisms as
+  // having one.
+  function hasMainLandmark() {
+    for (const el of queryAll('main, [role="main"]')) {
+      if (el && isExposedToAt(el)) return true;
+    }
+    return false;
+  }
+
+  // Resolve a fragment id (or legacy <a name>) inside a specific root node
+  // (a Document or a ShadowRoot). Both expose getElementById; querySelector
+  // is used for the legacy anchor-name fallback.
+  function resolveInRoot(root, fragment) {
+    if (!root) return null;
+    let target;
+    try {
+      target = typeof root.getElementById === 'function' ? root.getElementById(fragment) : null;
+    } catch {
+      target = null;
+    }
+    if (target) return target;
+    try {
+      target =
+        typeof root.querySelector === 'function'
+          ? root.querySelector('a[name="' + fragment.replace(/"/g, '\\"') + '"]')
+          : null;
+    } catch {
+      target = null;
+    }
+    return target;
+  }
+
+  // Shadow-DOM-aware: gather anchors via queryAllSmart (pierces shadow roots
+  // when includeShadowDom is enabled, and drops hard-hidden links), and
+  // resolve each fragment in the link's own root before falling back to the
+  // document. This credits a skip link encapsulated in a web component the
+  // same way as one authored in the light DOM.
+  function hasWorkingAnchorLink() {
+    let links;
+    try {
+      links =
+        helpers && typeof helpers.queryAllSmart === 'function'
+          ? helpers.queryAllSmart('a[href]')
+          : document.querySelectorAll('a[href]');
+    } catch {
+      links = [];
+    }
+    for (const a of links) {
+      if (!a || !a.getAttribute) continue;
+      const href = String(a.getAttribute('href') || '').trim();
+      if (href.length < 2 || href.charAt(0) !== '#') continue;
+      let fragment = href.slice(1);
+      try {
+        fragment = decodeURIComponent(fragment);
+      } catch {
+        // keep raw fragment if it isn't a valid percent-encoded string
+      }
+      fragment = fragment.trim();
+      if (!fragment) continue;
+
+      let root = document;
+      try {
+        if (typeof a.getRootNode === 'function') {
+          const r = a.getRootNode();
+          if (r) root = r;
+        }
+      } catch {
+        root = document;
+      }
+
+      let target = resolveInRoot(root, fragment);
+      if (!target && root !== document) {
+        target = resolveInRoot(document, fragment);
+      }
+      if (target) return true;
+    }
+    return false;
+  }
+
+  function hasHeading() {
+    for (const el of queryAll('h1, h2, h3, h4, h5, h6, [role="heading"]')) {
+      if (el && isExposedToAt(el)) return true;
+    }
+    return false;
+  }
+
+  const mainLandmark = hasMainLandmark();
+  const anchorLink = mainLandmark ? false : hasWorkingAnchorLink();
+  const heading = mainLandmark || anchorLink ? false : hasHeading();
+
+  // A recognized mechanism is present -> nothing to review on this page.
+  if (mainLandmark || anchorLink || heading) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const stableSelector = helpers.buildSelector ? helpers.buildSelector(body) : 'body';
+  const html = helpers.getOuterHtmlSnippet
+    ? helpers.getOuterHtmlSnippet(body)
+    : (body.outerHTML || '').slice(0, 200);
+
+  const occurrences = [
+    {
+      selector: stableSelector,
+      html,
+      summary:
+        'No recognized way to bypass repeated blocks of content was detected on this page — verify a bypass mechanism exists.',
+      hint: 'Confirm the page offers a bypass mechanism: a main landmark (<main> or role="main"), a working "skip to content" link, or heading elements that assistive technology can use to jump past repeated content. (A mechanism may be temporarily hidden — e.g. while a modal dialog makes the page inert — or provided on a per-site basis; this needs human confirmation.)',
+      i18n: {
+        summaryKey: 'bypassBlocksPresent_summary_cantTell',
+        hintKey: 'bypassBlocksPresent_hint_cantTell',
+        params: {}
+      },
+      data: {
+        details: { reasonCode: 'BYPASS_MECHANISM_ABSENT' },
+        visibilityFilter: { targetSet: 'acc', accEligible: null, reasons: [] }
+      }
+    }
+  ];
+
+  return {
+    ruleId: rule.ruleId,
+    outcome: 'cantTell',
+    severity: rule.defaultSeverity || 'moderate',
+    occurrences
+  };
+}
+
+module.exports = { id, meta, runInPage, applicability };

package/src/checks/manual/canvas-text-alternative-quality-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**

package/src/checks/manual/css-hidden-focus.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -194,6 +196,163 @@ function runInPage(ctx) {
     }
   }
 
+  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(docRef, fn) {
+    const w =
+      docRef && docRef.defaultView
+        ? docRef.defaultView
+        : typeof window !== 'undefined'
+          ? window
+          : null;
+    if (!w || typeof fn !== 'function') return;
+
+    const originalSetTimeout = typeof w.setTimeout === 'function' ? w.setTimeout.bind(w) : null;
+    const originalRequestAnimationFrame =
+      typeof w.requestAnimationFrame === 'function' ? w.requestAnimationFrame.bind(w) : null;
+    const originalQueueMicrotask =
+      typeof w.queueMicrotask === 'function' ? w.queueMicrotask.bind(w) : 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(w, args) });
+        return fakeTimerId++;
+      }
+      if (originalSetTimeout) return originalSetTimeout.apply(w, arguments);
+      return fakeTimerId++;
+    };
+
+    const patchedRaf = function (cb) {
+      if (typeof cb === 'function') {
+        queuedRaf.push(cb);
+        return fakeTimerId++;
+      }
+      if (originalRequestAnimationFrame) return originalRequestAnimationFrame.apply(w, arguments);
+      return fakeTimerId++;
+    };
+
+    const patchedQueueMicrotask = function (cb) {
+      if (typeof cb === 'function') queuedMicrotasks.push(cb);
+    };
+
+    try {
+      if (originalSetTimeout) w.setTimeout = patchedSetTimeout;
+      if (originalRequestAnimationFrame) w.requestAnimationFrame = patchedRaf;
+      if (originalQueueMicrotask) w.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) w.setTimeout = originalSetTimeout;
+      if (originalRequestAnimationFrame) w.requestAnimationFrame = originalRequestAnimationFrame;
+      if (originalQueueMicrotask) w.queueMicrotask = originalQueueMicrotask;
+    }
+  }
+
+  function probeImmediateFocusRedirect(candidate) {
+    if (!candidate || typeof candidate.addEventListener !== 'function') return null;
+
+    let focusedByEvent = false;
+    const onFocusCapture = () => {
+      focusedByEvent = true;
+    };
+    try {
+      candidate.addEventListener('focus', onFocusCapture, true);
+    } catch {}
+
+    const before = getDeepActiveElement(document);
+    let focused = false;
+    runFocusObservationWindow(document, () => {
+      focused = focusElementSafe(candidate);
+    });
+
+    try {
+      candidate.removeEventListener('focus', onFocusCapture, true);
+    } catch {}
+    if (!focused || !focusedByEvent) return null;
+
+    const after = getDeepActiveElement(document);
+
+    if (before && before !== after) {
+      focusElementSafe(before);
+    }
+
+    if (!after || after === candidate) return null;
+    const redirectedTag = (() => {
+      try {
+        return lower(after.tagName || '');
+      } catch {
+        return '';
+      }
+    })();
+    const redirectedId = (() => {
+      try {
+        return trim(after.getAttribute && after.getAttribute('id'));
+      } catch {
+        return '';
+      }
+    })();
+    return {
+      redirected: true,
+      redirectedToTag: redirectedTag || null,
+      redirectedToId: redirectedId || null
+    };
+  }
+
   function isTabbable(el, info) {
     const f = info || getFocusableInfoSafe(el);
     return !!(f && f.focusable && f.tabbable);
@@ -226,6 +385,8 @@ function runInPage(ctx) {
   }
 
   const occurrences = [];
+  const maxRuntimeProbeCount = 3;
+  let runtimeProbeCount = 0;
 
   for (const el of candidates) {
     if (!el || !el.getAttribute) continue;
@@ -251,18 +412,32 @@ function runInPage(ctx) {
     const hintsArr = [];
     for (const k of hintOrder) if (hints.includes(k)) hintsArr.push(k);
 
+    const runtimeProbe =
+      runtimeProbeCount < maxRuntimeProbeCount ? probeImmediateFocusRedirect(el) : null;
+    if (runtimeProbeCount < maxRuntimeProbeCount) runtimeProbeCount += 1;
+    const downgradedToRedirectReview = !!(runtimeProbe && runtimeProbe.redirected);
+
     const baseOccurrence = {
-      summary: `Focusable ${tagName} appears visually hidden (${hintsArr.join(',')}). Verify it becomes visible on keyboard focus.`,
-      hint: 'Manually tab to the element and confirm a visible focus indicator and that the element is visible when focused. If it remains hidden while focused, fix CSS/JS so it becomes visible or is removed from the tab order until visible.',
-      i18n: {
-        summaryKey: 'cssHidden_focus_summary_cantTell',
-        hintKey: 'cssHidden_focus_hint_cantTell',
-        params: { element: tagName, visibilityHints: hintsArr.join(',') }
-      },
+      summary: downgradedToRedirectReview
+        ? `Focusable ${tagName} appears visually hidden but focus moved immediately to another element. Verify sentinel/focus-trap behavior.`
+        : `Focusable ${tagName} appears visually hidden (${hintsArr.join(',')}). Verify it becomes visible on keyboard focus.`,
+      hint: downgradedToRedirectReview
+        ? 'Verify this is an intentional focus sentinel/focus-trap handoff and that keyboard users never remain on visually hidden focus targets.'
+        : 'Manually tab to the element and confirm a visible focus indicator and that the element is visible when focused. If it remains hidden while focused, fix CSS/JS so it becomes visible or is removed from the tab order until visible.',
+      i18n: downgradedToRedirectReview
+        ? null
+        : {
+            summaryKey: 'cssHidden_focus_summary_cantTell',
+            hintKey: 'cssHidden_focus_hint_cantTell',
+            params: { element: tagName, visibilityHints: hintsArr.join(',') }
+          },
       data: {
         details: {
-          reasonCode: 'cssHiddenTabbable_needsFocusStateVerification',
-          metrics: { visibilityHints: hintsArr.slice(0) }
+          reasonCode: downgradedToRedirectReview
+            ? 'cssHiddenTabbable_runtimeRedirect_needsReview'
+            : 'cssHiddenTabbable_needsFocusStateVerification',
+          metrics: { visibilityHints: hintsArr.slice(0) },
+          runtimeProbe: runtimeProbe || null
         }
       }
     };

package/src/checks/manual/embed-text-alternative-quality-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -154,23 +156,26 @@ function runInPage(ctx) {
 
     // Only resolve IDREF text if aria-labelledby is present and aria-label is not already sufficient
     let labelledByText = '';
-    let hasLabelledByMechanism = false;
-
-    if (!ariaLabel && ariaLabelledBy) {
-      hasLabelledByMechanism = true;
 
-      if (getTextFromIdRefs) {
-        try {
-          const t = getTextFromIdRefs(ariaLabelledBy, ctx);
-          labelledByText = trim(t && t.text);
-          // If it resolves to empty, still treat as a mechanism present for manual review.
-        } catch {
-          labelledByText = '';
-        }
+    if (!ariaLabel && ariaLabelledBy && getTextFromIdRefs) {
+      try {
+        const t = getTextFromIdRefs(ariaLabelledBy, ctx);
+        labelledByText = trim(t && t.text);
+      } catch {
+        labelledByText = '';
       }
     }
 
-    const hasNameMechanism = !!(ariaLabel || title || hasLabelledByMechanism);
+    // A broken/empty-resolving aria-labelledby (e.g. pointing at a
+    // nonexistent id) is not a "detected" text alternative to review the
+    // QUALITY of -- there's no text here at all, and this element's
+    // sibling automatic rule (embed-text-alternative-present) already
+    // reports it as a fail (no accessible name). Like object-/svg-/
+    // canvas-text-alternative-quality-manual, require aria-labelledby to
+    // actually resolve to non-empty text rather than merely being present
+    // as an attribute; a present-but-broken aria-labelledby has no text
+    // alternative to review.
+    const hasNameMechanism = !!(ariaLabel || title || labelledByText);
     if (!hasNameMechanism) continue;
 
     const details = {

package/src/checks/manual/empty-heading-manual.js

@@ -1,10 +1,12 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check empty-heading
  * @atomic true
  * @summary Heading elements must not be empty
- * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @standard Best Practices (no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
  * @applicability
  *   Applies to elements with a heading role: native <h1>-<h6>, or any
  *   element with explicit role="heading" (unless overridden by another
@@ -19,23 +21,21 @@
  * - Not WCAG-normative — authored as an advisory, cantTell-capped
  *   `type: 'manual'` rule; see landmark-banner-is-top-level's
  *   header comment for the shared rationale/precedent.
- * - This is also the reconciliation point for the "heading-name-present"
- *   gap surfaced by the 2026-07-19 ACT-rules research pass (see
- *   ROADMAP.md "Tier 5 candidates"): that gap was already closed by this
- *   pre-existing rule under a different name, not a real gap. Fixed two
- *   real false-positive bugs found while confirming that (2026-07-19):
- *   `title` wasn't accepted as a naming fallback, and hidden/aria-hidden/
- *   display:none headings weren't excluded (not gated on
- *   `isAccTreeEligible`), so an empty heading no AT user could ever
- *   reach was still flagged.
- * - 2026-07-21: the subtree-text walker's own hand-rolled descendant
- *   handling (aria-label/aria-labelledby only) never checked an `<img>`
- *   descendant's `alt` text — found via Party City's
- *   `<h1><a><div><img alt="..."></div></a></h1>` logo header, a false
- *   "empty heading" cantTell. Replaced with the shared, accname-aligned
+ * - This is also the reconciliation point for the ACT-rules
+ *   "heading-name-present" requirement (see ROADMAP.md "Tier 5
+ *   candidates"): already covered by this pre-existing rule under a
+ *   different name, not a separate gap. `title` is accepted as a naming
+ *   fallback, and hidden/aria-hidden/display:none headings are excluded
+ *   (gated on `isAccTreeEligible`), so an empty heading no AT user could
+ *   ever reach is not flagged.
+ * - Descendant name resolution uses the shared, accname-aligned
  *   `helpers.getContentNameInfo` (see dom-helpers.js) — the same "name
- *   from content" implementation the 19 `-name-present` rules already use
- *   — instead of maintaining a third, narrower copy of this logic here.
+ *   from content" implementation the 19 `-name-present` rules already
+ *   use — rather than a narrower hand-rolled walker, so an `<img alt="...">`
+ *   descendant's alt text (e.g. a
+ *   `<h1><a><div><img alt="..."></div></a></h1>` logo header) is correctly
+ *   picked up as the heading's name instead of producing a false "empty
+ *   heading" cantTell.
  */
 
 const id = 'empty-heading';