@surea11y/core 1.5.0 → 1.6.0

package/src/checks/automatic/presentational-children-focusable-absent.js

@@ -0,0 +1,330 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
+'use strict';
+
+/**
+ * @check presentational-children-focusable-absent
+ * @atomic true
+ * @summary A role whose children are presentational must not contain content in sequential focus navigation
+ * @standard WCAG 2.2
+ * @sc 4.1.2
+ * @applicability
+ *   Applies to elements whose semantic role is one of the WAI-ARIA roles
+ *   defined as having presentational children (button, checkbox, img,
+ *   menuitemcheckbox, menuitemradio, meter, option, progressbar, radio,
+ *   scrollbar, separator, slider, switch, tab, plus doc-pagebreak and
+ *   graphics-symbol from the DPUB-ARIA/Graphics-ARIA modules, which
+ *   inherit the same trait). The role can be explicit (role="tab") or
+ *   native (<button>, <meter>, <progress>, <option>).
+ * @expectation
+ *   No descendant of the element is part of sequential focus navigation.
+ *   The presentational-children mechanism removes every descendant from
+ *   the accessibility tree, so a descendant that still takes a tab stop
+ *   receives focus with no role and no name to announce.
+ * @implementation-notes
+ * - "Presentational children" is the implicit, role-driven mechanism from
+ *   WAI-ARIA §5.2.7, NOT an explicit role="presentation"/"none" attribute.
+ *   An element carrying that attribute has a semantic role of
+ *   presentation/none, which is not in the list above, so it is out of
+ *   scope here (presentation-role-conflict covers that case).
+ * - Only tab stops count, not everything focusable: a descendant with
+ *   tabindex="-1" is programmatically focusable but is not part of
+ *   sequential focus navigation, so it takes no tab stop and is not
+ *   reported. helpers.getFocusableInfo's `tabbable` flag is exactly this
+ *   distinction, and also accounts for :disabled, inert and invalid
+ *   tabindex values.
+ * - Native tags are mapped only where the element can actually have
+ *   descendants: <input type="checkbox">, <img> and <hr> also carry a
+ *   presentational-children role, but they are void, so no descendant can
+ *   ever exist to report. Including them would only inflate the applicable
+ *   count.
+ * - The walk stops at each reported tab stop, and at a nested element that
+ *   has a presentational-children role of its own without being a tab stop,
+ *   that one owns whatever is inside it, and is examined as its own
+ *   container. A tab stop therefore lands on the nearest role that dropped
+ *   it from the accessibility tree, the element an author would fix, rather
+ *   than on every enclosing one. A nested role that IS a tab stop
+ *   (role="button" tabindex="0" inside a <button>) is reported here: focus
+ *   lands inside this element.
+ * - Anything inside an aria-hidden="true" subtree is left to
+ *   aria-hidden-focus, which reports that exact defect (a tab stop with no
+ *   accessibility-tree node) as its own normative decision. Non-rendered
+ *   descendants (display:none, hidden, visibility:hidden) take no tab stop
+ *   at all and are skipped.
+ * - Browsers implement presentational children inconsistently, some
+ *   expose the descendants anyway, especially when they are focusable, so
+ *   the announced result varies by browser. The markup contradiction is
+ *   the same in every one of them, which is what this rule reports.
+ */
+
+const id = 'presentational-children-focusable-absent';
+
+const meta = {
+  title: 'Roles with presentational children must not contain focusable content',
+  description:
+    'Checks that an element whose role makes its children presentational (button, checkbox, img, option, radio, slider, switch, tab, ...) contains no descendant that takes a tab stop.',
+  i18n: {
+    titleKey: 'presentationalChildrenFocusableAbsent_title',
+    descriptionKey: 'presentationalChildrenFocusableAbsent_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'focus', 'atomic', 'automatic'],
+  wcagSc: ['4.1.2'],
+  normativeMappings: [
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '4.1.2',
+      title: 'Name, Role, Value',
+      conformanceLevel: 'A'
+    }
+  ],
+  defaultSeverity: 'serious',
+  category: 'robust',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '4.1.2': ['presentational-children-focusable-absent'] } }
+};
+
+function runInPage(ctx) {
+  const { helpers, rule } = ctx;
+
+  // Declared inside runInPage, see scripts/build-core.js header
+  // ("runInPage MUST be self-contained").
+  //
+  // WAI-ARIA roles with "Children Presentational: True", plus the two
+  // module roles that inherit the trait (doc-pagebreak from DPUB-ARIA,
+  // graphics-symbol from Graphics-ARIA).
+  const PRESENTATIONAL_CHILDREN_ROLES = [
+    'button',
+    'checkbox',
+    'doc-pagebreak',
+    'graphics-symbol',
+    'img',
+    'menuitemcheckbox',
+    'menuitemradio',
+    'meter',
+    'option',
+    'progressbar',
+    'radio',
+    'scrollbar',
+    'separator',
+    'slider',
+    'switch',
+    'tab'
+  ];
+
+  // Native tags whose implicit role is in the set above and that can hold
+  // descendants, see the void-element note in the header comment.
+  const NATIVE_ROLE_BY_TAG = {
+    button: 'button',
+    meter: 'meter',
+    option: 'option',
+    progress: 'progressbar'
+  };
+
+  const ariaHelpers = helpers && helpers.aria ? helpers.aria : null;
+
+  const getFocusableInfo =
+    helpers && typeof helpers.getFocusableInfo === 'function' ? helpers.getFocusableInfo : null;
+
+  const isDomVisibleEligible =
+    helpers && typeof helpers.isDomVisibleEligible === 'function'
+      ? helpers.isDomVisibleEligible
+      : null;
+
+  const getEligibilityInfo =
+    helpers && typeof helpers.getEligibilityInfo === 'function' ? helpers.getEligibilityInfo : null;
+
+  const isAccTreeEligible =
+    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  const roleSet = new Set(PRESENTATIONAL_CHILDREN_ROLES);
+
+  function lower(v) {
+    return (v == null ? '' : String(v)).trim().toLowerCase();
+  }
+
+  // The role attribute holds a fallback list; the first token that names a
+  // real role wins. A role="tab" resolves here, a role="figure tab" does
+  // not (figure wins and has no presentational children), and a list of
+  // nothing but unknown tokens falls back to the native role.
+  function getPresentationalChildrenRole(el) {
+    const raw = el.getAttribute ? el.getAttribute('role') : null;
+    if (raw) {
+      const tokens = lower(raw).split(/\s+/);
+      for (const token of tokens) {
+        if (!token) continue;
+        if (roleSet.has(token)) return token;
+        const known = ariaHelpers ? ariaHelpers.isValidConcreteRole(token) : true;
+        if (known) return '';
+      }
+    }
+    const tag = lower(el.tagName);
+    return Object.prototype.hasOwnProperty.call(NATIVE_ROLE_BY_TAG, tag)
+      ? NATIVE_ROLE_BY_TAG[tag]
+      : '';
+  }
+
+  function isExposed(node) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(node, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  // Flat-tree ancestor walk, shared with every other rule via
+  // ctx.helpers.composedParent so a shadow host is crossed the same way here
+  // as elsewhere.
+  const composedParent =
+    helpers && typeof helpers.composedParent === 'function'
+      ? helpers.composedParent
+      : function (n) {
+          return n && n.parentElement ? n.parentElement : null;
+        };
+
+  // isAccTreeEligible keeps an aria-hidden element that holds
+  // tabbable content in the accessibility tree (reason
+  // "ariaHiddenOverriddenTabbable", modelling the browsers that expose it
+  // anyway), which is precisely the shape aria-hidden-focus owns, so the
+  // attribute is checked on its own here rather than read off eligibility.
+  function inAriaHiddenSubtree(node) {
+    let cur = node;
+    let guard = 0;
+    while (cur && guard++ < 200) {
+      if (lower(cur.getAttribute && cur.getAttribute('aria-hidden')) === 'true') return true;
+      cur = composedParent(cur);
+    }
+    return false;
+  }
+
+  function isRendered(node) {
+    if (!isDomVisibleEligible) return true;
+    try {
+      const vis = isDomVisibleEligible(node, ctx, {
+        visibilityMode: 'styleOnly',
+        disableGeometry: true
+      });
+      return !(vis && vis.eligible === false);
+    } catch {
+      return true;
+    }
+  }
+
+  function isTabStop(node) {
+    if (!getFocusableInfo) return false;
+    try {
+      const info = getFocusableInfo(node, ctx);
+      return !!(info && info.tabbable);
+    } catch {
+      return false;
+    }
+  }
+
+  // Shallowest tab stops inside `root`, stopping at each one and at any
+  // nested presentational-children role, so every tab stop is attributed to
+  // the nearest role that removes it from the accessibility tree.
+  function collectTabStops(root) {
+    const out = [];
+    const top = root && root.children;
+    if (!top || !top.length) return out;
+    const stack = [];
+    for (let i = top.length - 1; i >= 0; i--) stack.push(top[i]);
+    while (stack.length) {
+      const node = stack.pop();
+      if (!node || node.nodeType !== 1) continue;
+      if (lower(node.getAttribute && node.getAttribute('aria-hidden')) === 'true') continue;
+      if (!isRendered(node)) continue;
+      if (isTabStop(node)) {
+        out.push(node);
+        continue;
+      }
+      // A nested role with presentational children owns whatever tab stops
+      // are inside it (it is examined as its own container in the main
+      // loop). It is only a boundary when it is not itself a tab stop,
+      // a focusable one lands focus inside THIS element and belongs here.
+      if (getPresentationalChildrenRole(node)) continue;
+      const kids = node.children;
+      if (kids && kids.length) {
+        for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+      }
+    }
+    return out;
+  }
+
+  const SELECTOR = '[role], button, meter, option, progress';
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart(SELECTOR)
+    : helpers.queryAll(SELECTOR);
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || el.nodeType !== 1) continue;
+
+    const role = getPresentationalChildrenRole(el);
+    if (!role) continue;
+    // A container that is hidden, or sits in an aria-hidden subtree, is
+    // aria-hidden-focus's concern, see the note on inAriaHiddenSubtree.
+    if (!isExposed(el) || inAriaHiddenSubtree(el)) continue;
+
+    applicableCount += 1;
+
+    const tabStops = collectTabStops(el);
+    if (!tabStops.length) continue;
+
+    const tabStopTags = tabStops.map((n) => (n && n.tagName ? lower(n.tagName) : 'unknown'));
+    const dedupedTabStopTags = [...new Set(tabStopTags)];
+
+    const eligInfo = getEligibilityInfo
+      ? (() => {
+          try {
+            return getEligibilityInfo(el, ctx, { targetSet: 'acc' });
+          } catch {
+            return null;
+          }
+        })()
+      : null;
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: `This role="${role}" element makes its children presentational, but it contains content that is still part of sequential focus navigation (${dedupedTabStopTags.join(', ')}).`,
+        hint: 'Move the focusable content outside this element, or remove the role that makes the children presentational, since focus landing inside it has no role or name to announce.',
+        i18n: {
+          summaryKey: 'presentationalChildrenFocusableAbsent_summary_fail',
+          hintKey: 'presentationalChildrenFocusableAbsent_hint_fail',
+          params: { role, focusableElements: dedupedTabStopTags.join(', ') }
+        },
+        data: {
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] },
+          details: {
+            reasonCode: 'PRESENTATIONAL_CHILDREN_FOCUSABLE_CONTENT',
+            role,
+            element: lower(el.tagName),
+            focusableElements: tabStopTags
+          }
+        }
+      })
+    );
+  }
+
+  if (applicableCount === 0) {
+    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: 'pass', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };

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

@@ -2,6 +2,25 @@
 
 'use strict';
 
+/**
+ * @check progressbar-name-present
+ * @atomic true
+ * @summary Elements with role="progressbar" must have an accessible name
+ * @standard WCAG 2.2
+ * @sc 1.1.1
+ * @applicability
+ *   Applies to elements carrying role="progressbar" (the attribute must name
+ *   that role alone, not a fallback list) that are included in the
+ *   accessibility tree. An element with the matching implicit role but no
+ *   role attribute is out of scope.
+ * @expectation
+ *   The element has a non-empty accessible name from aria-label, from an
+ *   aria-labelledby that resolves to non-empty text, or from title.
+ *   role="progressbar" is name-from-author-only, so subtree text is never
+ *   accepted: text sitting inside a custom progressbar widget is not
+ *   reliably exposed as its name.
+ */
+
 const id = 'progressbar-name-present';
 
 const meta = {
@@ -54,7 +73,7 @@ function runInPage(ctx) {
     const raw = getAttr(el, 'aria-labelledby');
     if (!raw) return '';
     // Delegates to the shared getTextFromIdRefs helper instead of computing
-    // name-from-content of the referenced element — see dialog-name-
+    // name-from-content of the referenced element, see dialog-name-
     // present.js's identical fix for the full rationale (an <iframe>
     // aria-labelledby target's only name source is its title attribute,
     // which name-from-content alone can never see).
@@ -106,10 +125,10 @@ function runInPage(ctx) {
     if (title) return { ok: true, method: 'title' };
 
     // role="progressbar" is name-from-author-only per WAI-ARIA: aria-label,
-    // aria-labelledby, or title — no content-based naming method at all. It
+    // aria-labelledby, or title, no content-based naming method at all. It
     // must NOT fall back to subtree content: e.g. a <ul role="progressbar">
     // loading skeleton with no name of its own, whose nested descendants
-    // carry their own aria-label for a different purpose — falling back to
+    // carry their own aria-label for a different purpose, falling back to
     // subtree content would wrongly treat that as the progressbar's name.
     return { ok: false, method: 'none' };
   }
@@ -139,7 +158,7 @@ function runInPage(ctx) {
     occurrences.push(
       helpers.reportOccurrence(el, {
         summary: 'This progress bar has no accessible name.',
-        hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this progress bar's accessible name.",
+        hint: "Provide aria-label, aria-labelledby, or a title attribute. Visible text content is not exposed as this progress bar's accessible name.",
         i18n: {
           summaryKey: 'progressbarNamePresent_summary_fail',
           hintKey: 'progressbarNamePresent_hint_fail',

package/src/checks/automatic/role-img-alt-present.js

@@ -5,26 +5,36 @@
 /**
  * @check role-img-text-alternative-present
  * @atomic true
- * @summary Accessible elements with role="img" must have an alternative text via aria-label or aria-labelledby
+ * @summary Accessible elements with role="img"/"graphics-symbol"/"graphics-document" must have a text alternative
  * @standard WCAG 2.2
  * @sc 1.1.1
  * @applicability
- *   Applies to elements with role="img" that are exposed to assistive technologies.
- *   Elements otherwise hidden from the accessibility tree remain applicable
- *   if they are focusable or referenced by IDREF relationships (per engine eligibility checks).
+ *   Applies to elements with role="img", role="graphics-symbol" or
+ *   role="graphics-document" that are included in the accessibility tree
+ *   (ACT 23a2a8's "programmatically hidden" exemption:
+ *   display:none/visibility:hidden/aria-hidden="true" on the element or an
+ *   ancestor, with no carve-out for focusable or IDREF-referenced elements,
+ *   aria-hidden-focus and duplicate-id-aria own those separately). Per ACT
+ *   7d6734, this reaches any element carrying one of these roles, not only
+ *   the <svg> root, e.g. a <circle role="graphics-symbol"> nested inside a
+ *   plain <svg>. The <svg> root itself is left to svg-text-alternative-present's
+ *   own (already ACT-clean) title/aria-name handling; the <img> tag is
+ *   excluded here since it has its own dedicated rule.
  * @expectation
- *   Each applicable element with role="img" has an accessible text alternative:
+ *   Each applicable element has an accessible text alternative:
  *    - aria-label with a non-empty value; OR
  *    - aria-labelledby referencing at least one existing element that contributes non-empty text; OR
- *    - a non-empty title attribute (last-resort accessible-name source per HTML-AAM).
+ *    - a non-empty title attribute (last-resort accessible-name source per HTML-AAM); OR
+ *    - for an SVG-namespace element, a non-empty first-child <title> (SVG-AAM's own naming mechanism, not only for the <svg> root).
  */
 
 const id = 'role-img-text-alternative-present';
 
 const meta = {
-  title: '[role="img"] must have an accessible text alternative',
+  title:
+    '[role="img"/"graphics-symbol"/"graphics-document"] must have an accessible text alternative',
   description:
-    'Checks that elements with role="img" provide an accessible text alternative via aria-label, aria-labelledby, or a title attribute.',
+    'Checks that elements with role="img", "graphics-symbol" or "graphics-document" provide an accessible text alternative using aria-label, aria-labelledby, a title attribute, or (for SVG elements) a first-child <title>.',
   i18n: {
     titleKey: 'roleImg_textAlternativePresent_title',
     descriptionKey: 'roleImg_textAlternativePresent_description'
@@ -86,7 +96,7 @@ function runInPage(ctx) {
 
   const imgElements = (() => {
     // do not consider element "img" because it has its own rule
-    const sel = '[role="img" i]:not(img)';
+    const sel = '[role="img" i]:not(img), [role="graphics-symbol" i], [role="graphics-document" i]';
     try {
       return Array.from((queryAllSmart ? queryAllSmart(sel) : queryAll(sel)) || []);
     } catch {
@@ -101,8 +111,16 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
+  // ACT 23a2a8 (same rule as native img-alt-present) exempts programmatically
+  // hidden images and that glossary term has no focusability carve-out, so a
+  // tabbable/IDREF-referenced role="img" inside aria-hidden stays out of
+  // scope here too; aria-hidden-focus reports that markup instead.
   const isAccTreeEligible =
-    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+    helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+      ? helpers.isIncludedInAccessibilityTree
+      : helpers && typeof helpers.isAccTreeEligible === 'function'
+        ? helpers.isAccTreeEligible
+        : null;
 
   const getAccessibleNameInfo =
     helpers && typeof helpers.getAccessibleNameInfo === 'function'
@@ -122,10 +140,21 @@ function runInPage(ctx) {
         }
       })();
       if (elig && elig.eligible === false) continue;
+      // isIncludedInAccessibilityTree returns a plain boolean, not an
+      // {eligible, reasons} object like isAccTreeEligible's fallback shape.
+      if (typeof elig === 'boolean' && elig === false) continue;
     }
 
     applicableCount += 1;
 
+    const matchedRole = (() => {
+      try {
+        return trim(el.getAttribute('role')).split(/\s+/)[0].toLowerCase();
+      } catch {
+        return 'img';
+      }
+    })();
+
     // Expectation: aria-label OR aria-labelledby. We use helper name-info when available,
     // but we also validate the source to keep this rule scoped/deterministic.
 
@@ -163,6 +192,25 @@ function runInPage(ctx) {
     })();
     const hasValidTitle = titleRaw !== null && trim(titleRaw).length > 0;
 
+    // SVG-AAM's own accessible-name mechanism: a first-child <title>
+    // element (not the HTML title attribute) is the standard way to name
+    // any element in the SVG namespace, not only the <svg> root -- a
+    // role="graphics-symbol" <circle> named only this way still has a real
+    // text alternative, same as a role="img" <svg>.
+    const svgTitleChildText = (() => {
+      try {
+        const isSvgNamespace = el.namespaceURI === 'http://www.w3.org/2000/svg';
+        if (!isSvgNamespace) return '';
+        const first = el.firstElementChild;
+        const firstTag = first ? (first.localName || first.tagName || '').toLowerCase() : '';
+        if (firstTag !== 'title') return '';
+        return trim(first.textContent);
+      } catch {
+        return '';
+      }
+    })();
+    const hasValidTitleSource = hasValidTitle || !!svgTitleChildText;
+
     let nameInfo = null;
 
     // Fast outcomes first (no helper needed)
@@ -170,19 +218,19 @@ function runInPage(ctx) {
     let hasName = false;
 
     if (!hasAriaLabelAttr && !hasAriaLabelledbyAttr) {
-      if (hasValidTitle) {
+      if (hasValidTitleSource) {
         hasName = true;
       } else {
         reasonCode = 'missingTextAlternative';
       }
     } else if (hasAriaLabelAttr && !hasValidAriaLabel) {
-      if (hasValidTitle) {
+      if (hasValidTitleSource) {
         hasName = true;
       } else {
         reasonCode = 'emptyAriaLabel';
       }
     } else if (hasAriaLabelledbyAttr && !hasValidAriaLabelledbyAttr) {
-      if (hasValidTitle) {
+      if (hasValidTitleSource) {
         hasName = true;
       } else {
         reasonCode = 'emptyAriaLabelledby';
@@ -214,12 +262,12 @@ function runInPage(ctx) {
     const eligInfo = getEligibilityInfo ? getEligibilityInfo(el, ctx, { targetSet: 'acc' }) : null;
 
     const baseOccurrence = {
-      summary: 'Missing text alternative on element with role="img".',
-      hint: 'Provide aria-label or aria-labelledby (referencing non-empty text) to give this image a text alternative.',
+      summary: `Missing text alternative on element with role="${matchedRole}".`,
+      hint: 'Provide aria-label or aria-labelledby (referencing non-empty text) to give this element a text alternative.',
       i18n: {
         summaryKey: 'roleImg_textAlternativePresent_summary_fail',
         hintKey: 'roleImg_textAlternativePresent_hint_fail',
-        params: { role: 'img' }
+        params: { role: matchedRole }
       },
       data: {
         details: {

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

@@ -2,11 +2,31 @@
 
 'use strict';
 
+/**
+ * @check searchbox-name-present
+ * @atomic true
+ * @summary Elements with role="searchbox" must have an accessible name
+ * @standard WCAG 2.2
+ * @sc 4.1.2
+ * @applicability
+ *   Applies to elements carrying role="searchbox" (the attribute must name
+ *   that role alone, not a fallback list) that are included in the
+ *   accessibility tree. An element with the matching implicit role but no
+ *   role attribute is out of scope.
+ * @expectation
+ *   The element has a non-empty accessible name from aria-label, from an
+ *   aria-labelledby that resolves to non-empty text, or from title.
+ *   role="searchbox" is name-from-author-only, so subtree text is never
+ *   accepted: text sitting inside a custom searchbox widget is not reliably
+ *   exposed as its name. On a labelable element (<input role="searchbox">)
+ *   an associated <label> counts as well.
+ */
+
 const id = 'searchbox-name-present';
 
 const meta = {
-  title: 'Accessible name is present',
-  description: 'Checks that elements expose a non-empty accessible name.',
+  title: 'Searchboxes have an accessible name',
+  description: 'Checks that elements with role="searchbox" expose a non-empty accessible name.',
   i18n: {
     titleKey: 'searchboxNamePresent_title',
     descriptionKey: 'searchboxNamePresent_description'
@@ -51,7 +71,7 @@ function runInPage(ctx) {
   }
 
   function getConservativeSubtreeText(document, container) {
-    // "Name from content" — recurses into descendants and uses each one's
+    // "Name from content", recurses into descendants and uses each one's
     // own accessible name (img alt, aria-label/aria-labelledby, title) when
     // it has one, not just literal text nodes. See getContentNameInfo's
     // header comment in src/core/dom-helpers.js for the full rationale
@@ -68,7 +88,7 @@ function runInPage(ctx) {
 
   // A <label> contributes a name via its own aria-label/aria-labelledby
   // (checked first, same ARIA-over-content precedence any element's
-  // accessible name gives — e.g. <label aria-label="Search"><svg
+  // accessible name gives, e.g. <label aria-label="Search"><svg
   // aria-hidden="true">...</svg></label> names its control "Search" even
   // though the label's only child content is aria-hidden) or, failing
   // that, its rendered content (getConservativeSubtreeText).
@@ -83,10 +103,10 @@ function runInPage(ctx) {
     if (content) return content;
     // Final fallback per the general accname text-alternative algorithm,
     // which applies to any element being asked for its name regardless of
-    // why (own aria-label, an aria-labelledby reference, or — here — native
+    // why (own aria-label, an aria-labelledby reference, or, here, native
     // <label for> association): title, when nothing else yields a name.
     // Purely additive (only fills in a name where there was none before),
-    // so it carries no false-positive risk — see dialog-name-present.js's
+    // so it carries no false-positive risk, see dialog-name-present.js's
     // identical <iframe>-title-fallback fix for the concrete real-world
     // trigger this same accname step covers elsewhere.
     return getAttr(lab, 'title');
@@ -96,7 +116,7 @@ function runInPage(ctx) {
     const raw = getAttr(el, 'aria-labelledby');
     if (!raw) return '';
     // Delegates to the shared getTextFromIdRefs helper instead of computing
-    // name-from-content of the referenced element — see dialog-name-
+    // name-from-content of the referenced element, see dialog-name-
     // present.js's identical fix for the full rationale (an <iframe>
     // aria-labelledby target's only name source is its title attribute,
     // which name-from-content alone can never see).
@@ -231,7 +251,7 @@ function runInPage(ctx) {
     occurrences.push(
       helpers.reportOccurrence(el, {
         summary: 'This element has no accessible name.',
-        hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this searchbox's accessible name.",
+        hint: "Provide aria-label, aria-labelledby, or a title attribute. Visible text content is not exposed as this searchbox's accessible name.",
         i18n: {
           summaryKey: 'searchboxNamePresent_summary_fail',
           hintKey: 'searchboxNamePresent_hint_fail',

package/src/checks/automatic/server-side-image-map-absent.js

@@ -13,7 +13,7 @@
  * @expectation
  *   The image does not use ismap at all. Server-side image maps depend on
  *   the browser sending click coordinates to the server, which has no
- *   keyboard-operable equivalent — there is no way to determine or expose
+ *   keyboard-operable equivalent, there is no way to determine or expose
  *   individual clickable regions to assistive technology or keyboard
  *   users. Client-side image maps (<map>/<area>, each with real href/alt)
  *   are the accessible alternative and are not flagged by this rule.