@surea11y/core 1.7.0 → 1.8.0

package/src/checks/automatic/link-in-text-block.js

@@ -9,22 +9,26 @@
  * @standard WCAG 2.2
  * @sc 1.4.1
  * @applicability
- *   Applies to <a href> elements whose immediate parent element also has
- *   at least one direct-child text node with non-whitespace content
- *   (i.e. the link sits inline within a run of plain text, not as a
- *   standalone item, e.g. not the sole content of a <li> nav item).
+ *   Applies to links (`<a href>` and elements with `role="link"`) whose
+ *   immediate parent element also has at least one direct-child text node
+ *   with non-whitespace content (i.e. the link sits inline within a run of
+ *   plain text, not as a standalone item, e.g. not the sole content of a
+ *   <li> nav item).
  * @expectation
  *   A link inside a text block must be visually distinguishable from the
  *   surrounding text by at least one non-color means:
  *     - text-decoration: underline, OR
- *     - a different font-weight than the surrounding text, OR
- *     - a different font-style than the surrounding text, OR
- *     - a contrast ratio of at least 3:1 between the link's text color and
- *       the surrounding text's color (WCAG technique G183's threshold,
- *       sufficient contrast alone is an accepted alternative to underline).
- *   Fails only when none of the above hold AND the color contrast between
- *   link and surrounding text is confidently computable and below 3:1,
- *   i.e. color is demonstrably the only cue.
+ *     - a different font-weight or font-style than the surrounding text, OR
+ *     - another visible mark on the link itself: a border, box-shadow or
+ *       outline, a background color different from the surrounding one, a
+ *       background image, an image or svg inside it, or ::before/::after
+ *       content.
+ *   A link with none of these is distinguished by color alone. When its
+ *   color contrasts with the surrounding text by at least 3:1, technique
+ *   G183 is met only if hover and focus also bring a non-color cue, which
+ *   a static scan cannot see, so the link is reported as cantTell. Below
+ *   3:1, with contrast confidently computable, color is demonstrably the
+ *   only cue and the link fails.
  * @implementation-notes
  * - "Surrounding text style" is approximated as the link's immediate
  *   parent element's own computed style, not a full inline-context walk
@@ -42,8 +46,11 @@
  *   computeEffectiveForeground/Background, getComputabilityBlocker,
  *   contrastRatio helpers as `contrast-minimum`), rather than re-deriving
  *   color math independently.
- * - Scoped to `a[href]` only (not `area[href]` or `[role="link"]`),
- *   matches the common real-world shape of this issue (prose links).
+ * - ::before/::after content is read from the CSSOM only (a DOM emulator
+ *   does not compute pseudo-element styles), so content declared in a
+ *   cross-origin stylesheet is not seen.
+ * - Only the resting state is evaluated. The :hover, :focus and :visited
+ *   states are not.
  */
 
 const id = 'link-in-text-block';
@@ -52,7 +59,7 @@ const meta = {
   title:
     'Links in text blocks must be distinguishable from surrounding text without relying on color alone',
   description:
-    'Checks that a link inside a run of text is visually distinguishable from the surrounding text by underline, a font-weight/style difference, or a sufficient (>=3:1) color-contrast difference, not by color alone.',
+    'Checks that a link inside a run of text is visually distinguishable from the surrounding text by a non-color cue (underline, font-weight or style, border, background, icon), and asks about links distinguished only by a >=3:1 color difference, which also need a hover and focus cue.',
   i18n: {
     titleKey: 'linkInTextBlock_title',
     descriptionKey: 'linkInTextBlock_description'
@@ -194,6 +201,16 @@ function runInPage(ctx) {
     return null;
   }
 
+  // The user agent underlines `a[href]`; an element with role="link" has no
+  // default decoration.
+  function uaUnderlines(el) {
+    return (
+      String(el.localName || '').toLowerCase() === 'a' &&
+      typeof el.hasAttribute === 'function' &&
+      el.hasAttribute('href')
+    );
+  }
+
   function resolveUnderlineFromCssom(el) {
     const doc = el && el.ownerDocument ? el.ownerDocument : null;
     if (!doc || typeof el.matches !== 'function') return { underlined: false, resolved: false };
@@ -272,7 +289,145 @@ function runInPage(ctx) {
     // unreadable, one of them might have, so the answer is unknown; otherwise
     // the UA default stands, and for a link that means underlined.
     if (unreadableSheet || unparsableSelector) return { underlined: false, resolved: false };
-    return { underlined: true, resolved: true };
+    return { underlined: uaUnderlines(el), resolved: true };
+  }
+
+  // ---- Non-color cues on the link itself ----
+  const LINE_STYLES = /^(solid|dashed|dotted|double|groove|ridge|inset|outset|auto)$/;
+
+  function isZeroWidth(v) {
+    return /^0(\.0+)?[a-z%]*$/i.test(String(v || '').trim());
+  }
+
+  function hasBorder(cs) {
+    for (const side of ['Top', 'Right', 'Bottom', 'Left']) {
+      const style = String(cs['border' + side + 'Style'] || '')
+        .trim()
+        .toLowerCase();
+      if (!style || style === 'none' || style === 'hidden') continue;
+      if (!isZeroWidth(cs['border' + side + 'Width'])) return true;
+    }
+    return false;
+  }
+
+  // Some environments do not expand the `outline` shorthand into its
+  // longhands, so it is read too.
+  function hasOutline(cs) {
+    const style = String(cs.outlineStyle || '')
+      .trim()
+      .toLowerCase();
+    if (style && style !== 'none' && style !== 'hidden') return !isZeroWidth(cs.outlineWidth);
+    const tokens = String((cs.getPropertyValue && cs.getPropertyValue('outline')) || '')
+      .trim()
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(Boolean);
+    return tokens.some((t) => LINE_STYLES.test(t)) && !tokens.some((t) => isZeroWidth(t));
+  }
+
+  function hasBoxShadow(cs) {
+    const v = String(cs.boxShadow || '')
+      .trim()
+      .toLowerCase();
+    return !!v && v !== 'none';
+  }
+
+  function hasBackgroundImage(cs) {
+    const v = String(cs.backgroundImage || '')
+      .trim()
+      .toLowerCase();
+    return !!v && v !== 'none';
+  }
+
+  function hasVisibleImageChild(el) {
+    let imgs;
+    try {
+      imgs = Array.from(el.querySelectorAll('img, svg, picture, canvas, [role="img"]'));
+    } catch {
+      return false;
+    }
+    return imgs.some((img) => {
+      if (!helpers.isDomVisibleEligible) return true;
+      try {
+        const vis = helpers.isDomVisibleEligible(img, ctx, {
+          visibilityMode: 'styleOnly',
+          disableGeometry: true
+        });
+        return !(vis && vis.eligible === false);
+      } catch {
+        return true;
+      }
+    });
+  }
+
+  const EMPTY_CONTENT = ['', 'none', 'normal', '""', "''"];
+  let pseudoContentRules = null;
+  // Style rules that put content in a ::before/::after box, by the selector
+  // of the element that box belongs to.
+  function getPseudoContentRules(doc) {
+    if (pseudoContentRules) return pseudoContentRules;
+    pseudoContentRules = [];
+    function consider(cssRule) {
+      const style = cssRule.style;
+      if (!style || typeof style.getPropertyValue !== 'function') return;
+      const content = String(style.getPropertyValue('content') || '').trim();
+      if (EMPTY_CONTENT.indexOf(content.toLowerCase()) !== -1) return;
+      for (const part of splitSelectorList(cssRule.selectorText)) {
+        if (!/::?(before|after)\s*$/i.test(part)) continue;
+        if (/:(hover|focus|focus-visible|focus-within|active|target|visited)\b/i.test(part)) {
+          continue;
+        }
+        pseudoContentRules.push(part.replace(/::?(before|after)\s*$/i, '').trim() || '*');
+      }
+    }
+    function walk(rules, depth) {
+      if (!rules || depth > MAX_NESTED_DEPTH) return;
+      for (const cssRule of rules) {
+        if (!cssRule) continue;
+        if (cssRule.type === CSS_STYLE_RULE && cssRule.selectorText) {
+          consider(cssRule);
+          continue;
+        }
+        let nested;
+        try {
+          nested = cssRule.cssRules || null;
+        } catch {
+          nested = null;
+        }
+        if (nested) walk(nested, depth + 1);
+      }
+    }
+    try {
+      for (const sheet of (doc && doc.styleSheets) || []) {
+        let rules = null;
+        try {
+          rules = sheet && sheet.cssRules ? sheet.cssRules : null;
+        } catch {
+          continue; // cross-origin, not inspectable
+        }
+        if (rules) walk(rules, 0);
+      }
+    } catch {
+      // no readable stylesheets
+    }
+    return pseudoContentRules;
+  }
+
+  function hasPseudoContent(el) {
+    return getPseudoContentRules(el.ownerDocument).some((base) => {
+      try {
+        return el.matches(base);
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  function hasNonColorMark(el, cs) {
+    if (cs && (hasBorder(cs) || hasOutline(cs) || hasBoxShadow(cs) || hasBackgroundImage(cs))) {
+      return true;
+    }
+    return hasVisibleImageChild(el) || hasPseudoContent(el);
   }
 
   function hasSurroundingText(el, parent) {
@@ -297,13 +452,14 @@ function runInPage(ctx) {
 
   const c = helpers && helpers.contrast ? helpers.contrast : null;
 
-  const selector = 'a[href]';
+  const selector = 'a[href], [role="link"]';
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart(selector)
     : helpers.queryAll(selector);
 
   const occurrences = [];
   const undecided = [];
+  const contrastOnly = [];
   let applicableCount = 0;
   let decidedCount = 0;
 
@@ -345,6 +501,13 @@ function runInPage(ctx) {
       continue;
     }
 
+    // A border, box-shadow, outline, background image, icon or generated
+    // content marks the link without relying on color.
+    if (hasNonColorMark(el, linkCs)) {
+      decidedCount += 1;
+      continue;
+    }
+
     if (!c) {
       markUndecided(el, 'CONTRAST_HELPERS_UNAVAILABLE');
       continue;
@@ -352,6 +515,7 @@ function runInPage(ctx) {
 
     let flagged = false;
     let computed = false;
+    let backgroundDiffers = false;
     let ratio = null;
     let fgLinkHex = '';
     let fgParentHex = '';
@@ -387,6 +551,21 @@ function runInPage(ctx) {
 
           computed = true;
           if (!(ratio >= 3)) flagged = true;
+
+          // A background color of the link's own, different from the one
+          // behind the surrounding text, marks it like a highlight.
+          const ownBg = String((linkCs && linkCs.backgroundColor) || '').replace(/\s+/g, '');
+          const transparentBg =
+            !ownBg || ownBg === 'transparent' || /^rgba\(\d+,\d+,\d+,0(\.0+)?\)$/.test(ownBg);
+          if (!transparentBg && c.rgbToHex) {
+            const parentBg = c.computeEffectiveBackground(parent, {
+              contrast: { mode, rootCanvasFallback },
+              collectStack: false
+            });
+            if (parentBg && parentBg.ok && parentBg.rgba) {
+              backgroundDiffers = c.rgbToHex(parentBg.rgba) !== c.rgbToHex(bg.rgba);
+            }
+          }
         }
         // else: not confidently computable, recorded below.
       }
@@ -400,14 +579,12 @@ function runInPage(ctx) {
       continue;
     }
 
-    // Contrast alone is an accepted alternative to an underline (G183), so a
-    // link clearing 3:1 is distinguishable regardless of decoration.
-    if (!flagged) {
+    if (backgroundDiffers) {
       decidedCount += 1;
       continue;
     }
 
-    // Below 3:1, an underline is the last remaining cue -- and only now does
+    // An underline is the last remaining non-color cue -- and only now does
     // it matter whether this environment can actually report one.
     const decoration = decorationInfo(linkCs);
     let underlined;
@@ -427,6 +604,13 @@ function runInPage(ctx) {
       continue;
     }
 
+    // Color is the only cue at rest. At 3:1 or more, G183 also needs a
+    // non-color cue on hover and focus, which a static scan cannot see.
+    if (!flagged) {
+      contrastOnly.push({ el, ratio, fgLinkHex, fgParentHex });
+      continue;
+    }
+
     decidedCount += 1;
 
     const eligInfo = helpers.getEligibilityInfo
@@ -439,7 +623,7 @@ function runInPage(ctx) {
       helpers.reportOccurrence(el, {
         summary:
           'This link in a block of text relies on color alone to be distinguished from the surrounding text.',
-        hint: 'Add an underline, a font-weight/style difference, or increase the color contrast between the link and surrounding text to at least 3:1.',
+        hint: 'Add an underline or another non-color cue (a font-weight or style difference, a border, an icon). Raising the color contrast with the surrounding text to 3:1 is enough only if hovering and focusing the link also add a non-color cue.',
         i18n: {
           summaryKey: 'linkInTextBlock_summary_fail',
           hintKey: 'linkInTextBlock_hint_fail',
@@ -461,46 +645,74 @@ function runInPage(ctx) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
 
-  // A proven violation outranks an undecided candidate, which outranks a clean
-  // one. The middle step keeps an unevaluable link out of `pass`.
-  if (occurrences.length) {
-    return {
-      ruleId: rule.ruleId,
-      outcome: 'fail',
-      severity: rule.defaultSeverity || 'serious',
-      occurrences
-    };
-  }
-
-  if (undecided.length) {
+  const cantTellOccurrences = undecided.map(({ el, reasonCode }) =>
+    helpers.reportOccurrence(el, {
+      occurrenceOutcome: 'cantTell',
+      summary:
+        'Whether this link is distinguishable from the surrounding text by non-color means could not be determined.',
+      hint: 'Confirm by eye that the link carries an underline, a font-weight or font-style difference or another non-color mark, or at least 3:1 contrast against the surrounding text together with a non-color cue on hover and focus. Running the engine in a real browser rather than a DOM emulator resolves most cases automatically.',
+      i18n: {
+        summaryKey: 'linkInTextBlock_summary_cantTell',
+        hintKey: 'linkInTextBlock_hint_cantTell'
+      },
+      uncertainty: {
+        code: 'not-computable',
+        needed:
+          'Whether the link carries an underline, weight or style difference, or 3:1 contrast against its surrounding text.',
+        evidence: { reasonCode }
+      },
+      data: {
+        visibilityFilter: helpers.getEligibilityInfo
+          ? helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' })
+          : { targetSet: 'acc', accEligible: null, reasons: [] },
+        details: { reasonCode }
+      }
+    })
+  );
+
+  const contrastOnlyOccurrences = contrastOnly.map(({ el, ratio, fgLinkHex, fgParentHex }) => {
+    const ratioStr = c && c.round2 ? c.round2(ratio) : String(ratio);
+    return helpers.reportOccurrence(el, {
+      occurrenceOutcome: 'cantTell',
+      summary: `This link in a block of text is distinguished from the surrounding text only by its color (contrast ${ratioStr}:1). That is enough only if hovering and focusing it also show a non-color cue, such as an underline.`,
+      hint: 'Hover over the link and move keyboard focus to it: confirm that each state adds a non-color cue (an underline, a border, a weight change). Otherwise underline the link at rest.',
+      i18n: {
+        summaryKey: 'linkInTextBlock_summary_cantTell_contrastOnly',
+        hintKey: 'linkInTextBlock_hint_cantTell_contrastOnly',
+        params: { ratio: String(ratioStr), threshold: '3' }
+      },
+      uncertainty: {
+        code: 'runtime-dependent',
+        needed: 'Whether hovering and focusing the link add a non-color cue.',
+        evidence: { reasonCode: 'LINK_COLOR_CONTRAST_ONLY', ratio }
+      },
+      data: {
+        visibilityFilter: helpers.getEligibilityInfo
+          ? helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' })
+          : { targetSet: 'acc', accEligible: null, reasons: [] },
+        details: {
+          reasonCode: 'LINK_COLOR_CONTRAST_ONLY',
+          metrics: { ratio, threshold: 3 },
+          colors: { linkForegroundHex: fgLinkHex, surroundingTextForegroundHex: fgParentHex }
+        }
+      }
+    });
+  });
+
+  // See helpers.resolveTieredOutcome (src/core/dom-helpers.js): a proven
+  // violation outranks an undecided candidate for the rule's own outcome, but
+  // never discards it, so an unevaluable link survives a failure elsewhere in
+  // the same run.
+  if (occurrences.length || cantTellOccurrences.length || contrastOnlyOccurrences.length) {
+    const resolved = helpers.resolveTieredOutcome(
+      occurrences,
+      contrastOnlyOccurrences.concat(cantTellOccurrences),
+      rule.defaultSeverity || 'serious'
+    );
     return {
       ruleId: rule.ruleId,
-      outcome: 'cantTell',
-      severity: rule.defaultSeverity || 'serious',
-      confidence: 'low',
-      occurrences: undecided.map(({ el, reasonCode }) =>
-        helpers.reportOccurrence(el, {
-          summary:
-            'Whether this link is distinguishable from the surrounding text by non-color means could not be determined.',
-          hint: 'Confirm by eye that the link carries an underline, a font-weight or font-style difference, or at least 3:1 contrast against the surrounding text. Running the engine in a real browser rather than a DOM emulator resolves most cases automatically.',
-          i18n: {
-            summaryKey: 'linkInTextBlock_summary_cantTell',
-            hintKey: 'linkInTextBlock_hint_cantTell'
-          },
-          uncertainty: {
-            code: 'not-computable',
-            needed:
-              'Whether the link carries an underline, weight or style difference, or 3:1 contrast against its surrounding text.',
-            evidence: { reasonCode }
-          },
-          data: {
-            visibilityFilter: helpers.getEligibilityInfo
-              ? helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' })
-              : { targetSet: 'acc', accEligible: null, reasons: [] },
-            details: { reasonCode }
-          }
-        })
-      )
+      ...resolved,
+      ...(resolved.outcome === 'cantTell' ? { confidence: 'low' } : null)
     };
   }
 

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

@@ -7,7 +7,7 @@
  * @atomic true
  * @summary Links must have an accessible name
  * @standard WCAG 2.2
- * @sc 4.1.2
+ * @sc 2.4.4, 4.1.2
  * @applicability
  *   Applies to <a href>, <area href> and elements with role="link" that are
  *   included in the accessibility tree. An <a> without an href is not a link
@@ -33,9 +33,18 @@ const meta = {
     descriptionKey: 'linkNamePresent_description'
   },
   helpUrl: null,
-  tags: ['wcag2a', 'wcag412', 'navigation', 'atomic', 'automatic', 'links', 'name'],
-  wcagSc: ['4.1.2'],
+  tags: ['wcag2a', 'wcag244', 'wcag412', 'navigation', 'atomic', 'automatic', 'links', 'name'],
+  wcagSc: ['2.4.4', '4.1.2'],
+  // 2.4.4 as well as 4.1.2, as ACT rule c487ae maps it: a link with no name
+  // has no purpose to determine, in context or otherwise.
   normativeMappings: [
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '2.4.4',
+      title: 'Link Purpose (In Context)',
+      conformanceLevel: 'A'
+    },
     {
       standard: 'WCAG',
       version: '2.2',
@@ -48,8 +57,7 @@ const meta = {
   category: 'robust',
   type: 'automatic',
   defaultConfidence: 'high',
-  // IMPORTANT: update your facets registry to include "link-name-present" under 4.1.2
-  coverage: { facetsBySc: { '4.1.2': ['link-name-present'] } }
+  coverage: { facetsBySc: { '2.4.4': ['link-name-present'], '4.1.2': ['link-name-present'] } }
 };
 
 function runInPage(ctx) {

package/src/checks/automatic/list-children-valid.js

@@ -10,7 +10,10 @@
  * @sc 1.3.1
  * @applicability
  *   Applies to <ul>/<ol> elements that have at least one direct element
- *   child.
+ *   child and whose role is list: no role attribute, role="list", or a role
+ *   attribute naming no concrete ARIA role. A <ul>/<ol> given another role
+ *   (listbox, menubar, tablist, none, ...) is not a list, so its children
+ *   follow that role's rules instead.
  * @expectation
  *   Every direct element child is <li>, <script>, or <template>. UNLESS it
  *   has an explicit `role` attribute, in which case the explicit role wins
@@ -96,9 +99,23 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
+  // The first role token that names a concrete ARIA role, or '' when none
+  // does (the element keeps its native list role).
+  const aria = helpers && helpers.aria;
+  function resolvedExplicitRole(el) {
+    const tokens = String((el.getAttribute && el.getAttribute('role')) || '')
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(Boolean);
+    if (!aria || typeof aria.isValidConcreteRole !== 'function') return tokens[0] || '';
+    return tokens.find((t) => aria.isValidConcreteRole(t)) || '';
+  }
+
   for (const el of nodes) {
     if (!el || !el.children) continue;
     if (!el.children.length) continue;
+    const listRole = resolvedExplicitRole(el);
+    if (listRole && listRole !== 'list') continue;
 
     applicableCount += 1;
 

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

@@ -149,21 +149,6 @@ function runInPage(ctx) {
     }
   }
 
-  function buildLabelForMap(doc) {
-    const map = new Map(); // id -> label element (first)
-    try {
-      const labels = doc && doc.getElementsByTagName ? doc.getElementsByTagName('label') : [];
-      for (let i = 0; i < labels.length; i += 1) {
-        const lab = labels[i];
-        if (!lab || !lab.getAttribute) continue;
-        const f = normalizeWs(lab.getAttribute('for'));
-        if (!f) continue;
-        if (!map.has(f)) map.set(f, lab);
-      }
-    } catch {}
-    return map;
-  }
-
   const occurrences = [];
   let applicableCount = 0;
 
@@ -172,42 +157,27 @@ function runInPage(ctx) {
     ? helpers.queryAllSmart(selector)
     : helpers.queryAll(selector);
 
-  // Precompute label[for] map for listbox elements that are labelable
-  // native form controls (e.g. <select multiple role="listbox">).
-  const labelForMap = buildLabelForMap(document);
-
+  // Delegates to the shared, spec-guarded lookup (dom-helpers.js's
+  // getAssociatedLabelElements): a <label> -- wrapping or via `for` --
+  // only ever associates with a genuinely labelable element, so this
+  // correctly returns nothing for role-only widgets a <label> merely sits
+  // next to, and the real thing for a labelable element like
+  // <select multiple role="listbox">.
   function getNativeLabelText(el) {
+    if (!helpers || typeof helpers.getAssociatedLabelElements !== 'function') return '';
+    let labels;
     try {
-      if ('labels' in el && el.labels && el.labels.length) {
-        const parts = [];
-        const max = Math.min(4, el.labels.length);
-        for (let i = 0; i < max; i += 1) {
-          const lab = el.labels[i];
-          const t = lab ? getLabelText(lab) : '';
-          if (t) parts.push(t);
-        }
-        const joined = normalizeWs(parts.join(' '));
-        if (joined) return joined;
-      }
-    } catch {}
-    try {
-      if (el.closest) {
-        const wrap = el.closest('label');
-        if (wrap) {
-          const t = getLabelText(wrap);
-          if (t) return t;
-        }
-      }
-    } catch {}
-    try {
-      const idAttr = getAttr(el, 'id');
-      if (idAttr && labelForMap.has(idAttr)) {
-        const lab = labelForMap.get(idAttr);
-        const t = lab ? getLabelText(lab) : '';
-        if (t) return t;
-      }
-    } catch {}
-    return '';
+      labels = helpers.getAssociatedLabelElements(el) || [];
+    } catch {
+      labels = [];
+    }
+    const parts = [];
+    const max = Math.min(4, labels.length);
+    for (let i = 0; i < max; i += 1) {
+      const t = getLabelText(labels[i]);
+      if (t) parts.push(t);
+    }
+    return normalizeWs(parts.join(' '));
   }
 
   function hasName(el) {

package/src/checks/automatic/listitem-parent-valid.js

@@ -11,7 +11,8 @@
  * @applicability
  *   Applies to <li> elements that have a parent element.
  * @expectation
- *   The parent is <ul>/<ol> with no role override, or an element with an
+ *   The parent is <ul>/<ol>/<menu> with no role override (all three have
+ *   the implicit role list), or an element with an
  *   explicit role of "list", "presentation", or "none". An <li> used
  *   outside a real list container (e.g. as a generic flex/grid item under
  *   a <div>) is not exposed as a list item to assistive technologies.
@@ -47,7 +48,7 @@ const id = 'listitem-parent-valid';
 const meta = {
   title: 'List items must be inside a list container',
   description:
-    'Checks that <li> elements are contained by <ul>, <ol>, or an element with role="list".',
+    'Checks that <li> elements are contained by <ul>, <ol>, <menu>, or an element with role="list".',
   i18n: {
     titleKey: 'listitemParentValid_title',
     descriptionKey: 'listitemParentValid_description'
@@ -111,7 +112,7 @@ function runInPage(ctx) {
       // direction, see the header comment.
       valid = explicitRole === 'list' || explicitRole === 'presentation' || explicitRole === 'none';
     } else {
-      valid = parentTag === 'ul' || parentTag === 'ol';
+      valid = parentTag === 'ul' || parentTag === 'ol' || parentTag === 'menu';
     }
 
     if (valid) continue;

package/src/checks/automatic/meta-refresh-no-exceptions.js

@@ -5,7 +5,7 @@
 /**
  * @check meta-refresh-no-exceptions
  * @atomic true
- * @summary At the AAA level, a meta refresh must not be used at all
+ * @summary At the AAA level, a meta refresh must not use a positive delay, however long
  * @standard WCAG 2.2
  * @sc 2.2.4, 3.2.5
  * @applicability
@@ -37,9 +37,9 @@
 const id = 'meta-refresh-no-exceptions';
 
 const meta = {
-  title: 'Page must not use a meta refresh at all (AAA)',
+  title: 'Page must not use a timed meta refresh (AAA)',
   description:
-    'Checks that <meta http-equiv="refresh"> is not present at all, regardless of delay. This is the stricter AAA-level counterpart of the A-level positive-delay-only check.',
+    'Checks that <meta http-equiv="refresh"> does not set a positive delay, however long; an immediate redirect (delay 0) passes. This is the stricter AAA-level counterpart of the A-level check, which exempts delays over 20 hours.',
   i18n: {
     titleKey: 'metaRefreshNoExceptions_title',
     descriptionKey: 'metaRefreshNoExceptions_description'