@surea11y/core 1.6.0 → 1.8.0

package/src/checks/automatic/aria-hidden-focus.js

@@ -17,6 +17,10 @@
  * Notes:
  * - Focusability is computed via ctx.helpers.getFocusableInfo (native + tabindex + contenteditable).
  * - Elements that are not rendered (e.g., display:none, visibility:hidden, [hidden]) are excluded.
+ * - Disabled controls are not focusable, including those disabled by an ancestor
+ *   <fieldset disabled> (matched with :disabled).
+ * - <area href> has no box of its own, so it is judged by the <img usemap> that uses its
+ *   <map>: it counts as focusable when such an image is rendered and not inert.
  * - Elements hidden via CSS in ways that still allow keyboard focus (e.g., opacity:0, off-screen, clip)
  *   remain in-scope and will be flagged when focusable.
  */
@@ -525,9 +529,69 @@ function runInPage(ctx) {
   // DOM-visibility gate to avoid false positives:
   // Exclude structural/CSS hidden cases that prevent focus (display:none, visibility:hidden, hidden attr, etc.).
   // IMPORTANT: Do NOT exclude opacity-based invisibility; opacity:0 remains in-scope.
+  // Style-only visibility gate. opacity:0 does not count as hidden: the
+  // element can still take focus.
+  function isRenderedForFocus(el) {
+    if (!isDomVisibleEligible) return true;
+    try {
+      const vis = isDomVisibleEligible(el, ctx, {
+        visibilityMode: 'styleOnly',
+        disableGeometry: true
+      });
+      if (vis && vis.eligible === false) {
+        const rs = Array.isArray(vis.reasons) ? vis.reasons : [];
+        const nonOpacity = rs.filter((r) => String(r) !== 'opacityZero');
+        if (nonOpacity.length) return false;
+      }
+    } catch {
+      // ignore
+    }
+    return true;
+  }
+
+  // <area href> generates no box of its own (browsers give it display:none),
+  // so the visibility gate cannot be applied to it. It takes focus when its
+  // <map> is used by an <img usemap> that is rendered and not inert; judge it
+  // by that image instead.
+  function isFocusableArea(el) {
+    if (!trim(el.getAttribute('href'))) return false;
+    let map;
+    try {
+      map = el.closest ? el.closest('map') : null;
+    } catch {
+      map = null;
+    }
+    if (!map) return false;
+    const name = trim(map.getAttribute('name') || map.getAttribute('id'));
+    if (!name) return false;
+    const scope = el.getRootNode ? el.getRootNode() : document;
+    if (!scope || typeof scope.querySelectorAll !== 'function') return false;
+    let imgs;
+    try {
+      imgs = Array.from(scope.querySelectorAll('img[usemap]'));
+    } catch {
+      imgs = [];
+    }
+    const want = name.toLowerCase();
+    for (const img of imgs) {
+      const usemap = lower(img.getAttribute('usemap')).replace(/^#/, '');
+      if (usemap !== want) continue;
+      if (hasInertAncestor(img)) continue;
+      if (isRenderedForFocus(img)) return true;
+    }
+    return false;
+  }
+
   function isActuallyFocusable(el) {
     if (!el || !el.getAttribute) return false;
 
+    // An explicit negative tabindex takes the area out of the tab order too.
+    if (lower(el.tagName || '') === 'area') {
+      const ti = trim(el.getAttribute('tabindex'));
+      if (ti !== '' && !Number.isNaN(Number(ti)) && Number(ti) < 0) return false;
+      return isFocusableArea(el);
+    }
+
     // Hard blockers that should always win (even if fallback logic would say "focusable")
     if (hasInertAncestor(el)) return false;
     if (isDisabledFormControl(el)) return false;
@@ -564,7 +628,7 @@ function runInPage(ctx) {
     const tag = lower(el.tagName || '');
     let fallbackFocusable = false;
 
-    if (tag === 'a' || tag === 'area') {
+    if (tag === 'a') {
       const href = trim(el.getAttribute('href'));
       fallbackFocusable = !!href;
     } else if (tag === 'button' || tag === 'select' || tag === 'textarea' || tag === 'summary') {
@@ -601,23 +665,7 @@ function runInPage(ctx) {
 
     // 2) exclude non-rendered / non-visible-by-style blockers
     // IMPORTANT: Do NOT exclude opacity-based invisibility; opacity:0 remains in-scope.
-    if (isDomVisibleEligible) {
-      try {
-        const vis = isDomVisibleEligible(el, ctx, {
-          visibilityMode: 'styleOnly',
-          disableGeometry: true
-        });
-        if (vis && vis.eligible === false) {
-          const rs = Array.isArray(vis.reasons) ? vis.reasons : [];
-          const nonOpacity = rs.filter((r) => String(r) !== 'opacityZero');
-          if (nonOpacity.length) return false;
-        }
-      } catch {
-        // ignore
-      }
-    }
-
-    return true;
+    return isRenderedForFocus(el);
   }
 
   function hasInertAncestor(el) {
@@ -635,6 +683,14 @@ function runInPage(ctx) {
   }
 
   function isDisabledFormControl(el) {
+    try {
+      // :disabled also covers a control disabled by an ancestor
+      // <fieldset disabled> (outside its first <legend>), which the
+      // `disabled` IDL attribute does not reflect.
+      if (typeof el.matches === 'function' && el.matches(':disabled')) return true;
+    } catch {
+      // ignore
+    }
     try {
       // Covers button/input/select/textarea/option/optgroup/fieldset etc.
       if (typeof el.disabled === 'boolean' && el.disabled) return true;

package/src/checks/automatic/aria-prohibited-attr.js

@@ -14,7 +14,9 @@
  *   list for naming attributes (pure text-semantics / non-naming
  *   structural roles: caption, code, deletion, emphasis, generic,
  *   insertion, mark, none, paragraph, presentation, strong, subscript,
- *   suggestion, superscript, time), and (b) elements with no role at all:
+ *   suggestion, superscript, time), plus a native <caption> with no valid
+ *   explicit role, whose implicit role is caption, and (b) elements with no
+ *   role at all:
  *   a curated set of native HTML tags verified to carry no implicit role
  *   (see ROLELESS_NATIVE_TAGS below), or any autonomous custom element (a
  *   hyphenated, author-defined tag per the Custom Elements spec; see
@@ -147,14 +149,25 @@ function runInPage(ctx) {
 
   // --- Tier 1: explicit, valid role from the naming-prohibited set ---
 
+  // A native <caption> has the caption role without saying so, and is judged
+  // the same way as role="caption"; only one that carries a naming attribute
+  // needs visiting.
+  const tier1Selector = '[role], caption[aria-label], caption[aria-labelledby]';
   const roleNodes = helpers.queryAllSmart
-    ? helpers.queryAllSmart('[role]')
-    : helpers.queryAll('[role]');
+    ? helpers.queryAllSmart(tier1Selector)
+    : helpers.queryAll(tier1Selector);
 
   for (const el of roleNodes) {
     if (!el || !el.getAttribute) continue;
 
-    const role = ariaHelpers.getExplicitRole(el);
+    const explicitRole = ariaHelpers.getExplicitRole(el);
+    let role = explicitRole;
+    if (
+      (!explicitRole || !ariaHelpers.isValidConcreteRole(explicitRole)) &&
+      String(el.localName || '').toLowerCase() === 'caption'
+    ) {
+      role = 'caption';
+    }
     if (!role || !ROLES_PROHIBITING_NAME.has(role)) continue;
 
     applicableCount += 1;
@@ -370,6 +383,11 @@ function runInPage(ctx) {
               hintKey: 'ariaProhibitedAttr_hint_cantTell_roleless',
               params: { attr, element: tag }
             },
+            uncertainty: {
+              code: 'judgement-required',
+              needed: 'Whether the element’s own content already serves as its label.',
+              evidence: { attribute: attr, element: tag, role: null, hasOwnContent: true }
+            },
             data: {
               details: {
                 reasonCode: 'ARIA_ATTR_PROHIBITED_ROLELESS_NEEDS_REVIEW',

package/src/checks/automatic/aria-prohibited-children.js

@@ -7,7 +7,7 @@
  * @atomic true
  * @summary Container roles must not own an accessible-tree child with a disallowed role
  * @standard WCAG 2.2
- * @sc 4.1.2
+ * @sc 1.3.1
  * @applicability
  *   Applies to elements with an explicit, valid role that is one of the
  *   container roles with a documented "required owned elements" entry
@@ -126,14 +126,14 @@ const meta = {
     descriptionKey: 'ariaProhibitedChildren_description'
   },
   helpUrl: null,
-  tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'atomic', 'automatic'],
-  wcagSc: ['4.1.2'],
+  tags: ['wcag2a', 'wcag131', 'aria', 'structure', 'atomic', 'automatic'],
+  wcagSc: ['1.3.1'],
   normativeMappings: [
     {
       standard: 'WCAG',
       version: '2.2',
-      requirement: '4.1.2',
-      title: 'Name, Role, Value',
+      requirement: '1.3.1',
+      title: 'Info and Relationships',
       conformanceLevel: 'A'
     }
   ],
@@ -141,7 +141,7 @@ const meta = {
   category: 'robust',
   type: 'automatic',
   defaultConfidence: 'medium',
-  coverage: { facetsBySc: { '4.1.2': ['aria-role-owned-children-allowed'] } }
+  coverage: { facetsBySc: { '1.3.1': ['aria-role-owned-children-allowed'] } }
 };
 
 function runInPage(ctx) {

package/src/checks/automatic/aria-required-attr.js

@@ -18,9 +18,28 @@
  *   <input type="checkbox" role="checkbox">, which is exempt because the
  *   native control's own state exposure already covers it; no aria-checked
  *   is required. helpers.aria.getNativeRoleForElement resolves this).
+ *   A native <input type="checkbox"> or <input type="radio"> with another
+ *   checkable role (switch, menuitemcheckbox, menuitemradio, or checkbox on
+ *   a radio and the reverse) is in scope, but its aria-checked counts as
+ *   supplied: the browser exposes the input's own checked state (HTML-AAM),
+ *   so it passes without the attribute.
  * @expectation
- *   Every required aria-* attribute for that role is present (and non-empty).
+ *   Every required state/property for that role is present and non-empty.
+ *   Graded by whether ARIA supplies a stand-in for the missing attribute:
+ *   - FAIL where it does not, so the state is simply not exposed
+ *     (aria-checked on checkbox/radio/switch/menuitemcheckbox/menuitemradio,
+ *     aria-valuenow on slider/scrollbar/meter and on a focusable separator).
+ *   - CANTTELL where ARIA defines an implicit value the role falls back to
+ *     (aria-expanded on combobox, aria-level on heading), so the role still
+ *     exposes a value and only the author knows whether it is the right one.
  * @implementation-notes
+ * - The implicit-value table is generated from aria-query's requiredProps by
+ *   scripts/generate-aria-tables.js (REQUIRED_PROP_IMPLICIT_VALUES in
+ *   src/core/aria-helpers.js), so the two tiers cannot drift apart from the
+ *   spec by hand. ACT 4e8ab6 maps this rule's requirement to WAI-ARIA rather
+ *   than to WCAG, and names 1.3.1/4.1.2 as "less strict" precisely because
+ *   they "allow for fallback default values"; the cantTell tier is that
+ *   carve-out, not a softening of the fail tier.
  * - Scoped to REQUIRED_PROPS_BY_ROLE in src/core/aria-helpers.js,
  *   which only lists a required property when the spec is unambiguous and
  *   context-independent, see that file's header for the rationale.
@@ -122,6 +141,23 @@ function runInPage(ctx) {
     }
   }
 
+  const CHECKABLE_ROLES = new Set([
+    'checkbox',
+    'switch',
+    'radio',
+    'menuitemcheckbox',
+    'menuitemradio'
+  ]);
+
+  function isNativeCheckable(el) {
+    if (String(el.localName || '').toLowerCase() !== 'input') return false;
+    if (el.namespaceURI && el.namespaceURI !== 'http://www.w3.org/1999/xhtml') return false;
+    const type = String(el.getAttribute('type') || '')
+      .trim()
+      .toLowerCase();
+    return type === 'checkbox' || type === 'radio';
+  }
+
   function isMarkedBusy(el) {
     const v = el.getAttribute('aria-busy');
     return v != null && String(v).trim().toLowerCase() === 'true';
@@ -131,7 +167,8 @@ function runInPage(ctx) {
     ? helpers.queryAllSmart('[role]')
     : helpers.queryAll('[role]');
 
-  const occurrences = [];
+  const failOccurrences = [];
+  const cantTellOccurrences = [];
   let applicableCount = 0;
 
   for (const el of nodes) {
@@ -150,6 +187,12 @@ function runInPage(ctx) {
 
     const required = ariaHelpers.getRequiredAttrsForRole(role).slice();
 
+    // A native checkbox or radio exposes its own checked state whatever
+    // checkable role it carries (HTML-AAM maps the checkedness; ARIA in HTML
+    // tells authors not to set aria-checked on it), so aria-checked is
+    // supplied on <input type="checkbox" role="switch"> and the like.
+    const nativeChecked = isNativeCheckable(el) && CHECKABLE_ROLES.has(role);
+
     // combobox's aria-controls is required only once the popup is actually
     // displayed (aria-expanded="true") -- see this file's header comment.
     if (role === 'combobox' && String(el.getAttribute('aria-expanded') || '').trim() === 'true') {
@@ -172,14 +215,50 @@ function runInPage(ctx) {
     const missing = [];
     for (const attr of required) {
       const v = el.getAttribute(attr);
+      if (attr === 'aria-checked' && nativeChecked) continue;
       if (v == null || String(v).trim() === '') missing.push(attr);
     }
 
     if (!missing.length) continue;
 
     for (const attr of missing) {
-      occurrences.push(
+      const implicit =
+        typeof ariaHelpers.getRequiredAttrImplicitValue === 'function'
+          ? ariaHelpers.getRequiredAttrImplicitValue(role, attr)
+          : null;
+
+      if (implicit) {
+        cantTellOccurrences.push(
+          helpers.reportOccurrence(el, {
+            occurrenceOutcome: 'cantTell',
+            summary: `This attribute is required for this element’s role and is missing, but ARIA falls back to "${implicit}".`,
+            hint: 'Set the attribute explicitly if the implicit value is not the state you mean.',
+            i18n: {
+              summaryKey: 'ariaRequiredAttr_summary_cantTell',
+              hintKey: 'ariaRequiredAttr_hint_cantTell',
+              params: { attr, role, implicit }
+            },
+            uncertainty: {
+              code: 'spec-only',
+              needed: 'Whether the implicit fallback is the state the author meant.',
+              evidence: { attribute: attr, role, implicitValue: implicit }
+            },
+            data: {
+              details: {
+                reasonCode: 'ARIA_ATTR_REQUIRED_MISSING_IMPLICIT',
+                attr,
+                role,
+                implicitValue: implicit
+              }
+            }
+          })
+        );
+        continue;
+      }
+
+      failOccurrences.push(
         helpers.reportOccurrence(el, {
+          occurrenceOutcome: 'fail',
           summary: 'This attribute is required for this element’s role, but is missing.',
           hint: 'Add this attribute with a valid value for this role.',
           i18n: {
@@ -198,15 +277,12 @@ 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 || 'serious',
-      occurrences
-    };
-  }
-  return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
+  const resolved = helpers.resolveTieredOutcome(
+    failOccurrences,
+    cantTellOccurrences,
+    rule.defaultSeverity || 'serious'
+  );
+  return { ruleId: rule.ruleId, ...resolved };
 }
 
 module.exports = { id, meta, runInPage };

package/src/checks/automatic/aria-required-children.js

@@ -7,7 +7,7 @@
  * @atomic true
  * @summary Container roles that require specific owned elements must contain at least one
  * @standard WCAG 2.2
- * @sc 4.1.2
+ * @sc 1.3.1
  * @applicability
  *   Applies to elements with an explicit, valid, non-abstract role that is
  *   also one of the container roles with a documented "required owned
@@ -15,7 +15,17 @@
  *   table, grid, treegrid, tablist, tree, row).
  * @expectation
  *   At least one descendant, or one aria-owns-referenced element, has one
- *   of the acceptable owned roles for that container role.
+ *   of the acceptable owned roles for that container role. Reported at
+ *   CANTTELL, never FAIL: this rule asks only whether the required content
+ *   is PRESENT, and a container that owns nothing conveys nothing false --
+ *   an empty role="list" is announced as a list with no items, which is what
+ *   it is. Whether the content a container does own is VALID is
+ *   aria-prohibited-children's decision, and that rule still fails, so a
+ *   genuinely misdescribed structure (a role="button" among list items, a
+ *   tablist of plain buttons) is caught with the same strength as before.
+ *   The native-HTML equivalents already work this way: nothing in this
+ *   ruleset fails an empty <ul>, and list-children-valid judges only the
+ *   children that exist.
  * @implementation-notes
  * - Scoped to REQUIRED_OWNED_ROLES in src/core/aria-helpers.js
  *   (see that file's header for the conservative-scope rationale).
@@ -75,14 +85,14 @@ const meta = {
     descriptionKey: 'ariaRequiredChildren_description'
   },
   helpUrl: null,
-  tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'atomic', 'automatic'],
-  wcagSc: ['4.1.2'],
+  tags: ['wcag2a', 'wcag131', 'aria', 'structure', 'atomic', 'automatic'],
+  wcagSc: ['1.3.1'],
   normativeMappings: [
     {
       standard: 'WCAG',
       version: '2.2',
-      requirement: '4.1.2',
-      title: 'Name, Role, Value',
+      requirement: '1.3.1',
+      title: 'Info and Relationships',
       conformanceLevel: 'A'
     }
   ],
@@ -90,7 +100,7 @@ const meta = {
   category: 'robust',
   type: 'automatic',
   defaultConfidence: 'medium',
-  coverage: { facetsBySc: { '4.1.2': ['aria-role-required-owned-children'] } }
+  coverage: { facetsBySc: { '1.3.1': ['aria-role-required-owned-children'] } }
 };
 
 function runInPage(ctx) {
@@ -269,6 +279,16 @@ function runInPage(ctx) {
           hintKey: 'ariaRequiredChildren_hint_fail',
           params: { role, requiredRoles: requiredOwned.join(', ') }
         },
+        uncertainty: {
+          code: 'spec-only',
+          needed:
+            'Whether this container is legitimately empty, or holds items that never got their role.',
+          evidence: {
+            role,
+            requiredOwnedRoles: requiredOwned,
+            childElementCount: el.children ? el.children.length : null
+          }
+        },
         data: {
           details: {
             reasonCode: 'ARIA_REQUIRED_CHILD_MISSING',
@@ -283,15 +303,12 @@ 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: [] };
+  const resolved = helpers.resolveTieredOutcome(
+    [],
+    occurrences,
+    rule.defaultSeverity || 'moderate'
+  );
+  return { ruleId: rule.ruleId, ...resolved };
 }
 
 module.exports = { id, meta, runInPage };

package/src/checks/automatic/aria-required-parent.js

@@ -7,7 +7,7 @@
  * @atomic true
  * @summary Roles that require a specific ancestor/owner context role must have one
  * @standard WCAG 2.2
- * @sc 4.1.2
+ * @sc 1.3.1
  * @applicability
  *   Applies to elements with an explicit, valid, non-abstract role that is
  *   also one of the roles with a documented, non-empty "required context
@@ -43,6 +43,16 @@
  *   aria-required-children/aria-prohibited-children, applied for
  *   consistency; an element that isn't currently exposed to the
  *   accessibility tree is skipped (notApplicable), not failed.
+ * - Also honors WAI-ARIA's escape hatch for a widget script has not
+ *   finished assembling: "When a widget is missing required owned elements due to
+ *   script execution or loading, authors MUST mark a containing element
+ *   with aria-busy equal to true." aria-required-children reads that from
+ *   the container it is checking; read from the item's side it is an
+ *   ancestor, so the walk looks up rather than at the element itself, and
+ *   only the exact string "true" counts. It also outranks the
+ *   roleless-generic-parent rule below, since aria-busy is itself a global
+ *   ARIA attribute and would otherwise block the context search and fail
+ *   the very markup the spec says to mark.
  */
 
 const id = 'aria-required-parent';
@@ -56,14 +66,14 @@ const meta = {
     descriptionKey: 'ariaRequiredParent_description'
   },
   helpUrl: null,
-  tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'atomic', 'automatic'],
-  wcagSc: ['4.1.2'],
+  tags: ['wcag2a', 'wcag131', 'aria', 'structure', 'atomic', 'automatic'],
+  wcagSc: ['1.3.1'],
   normativeMappings: [
     {
       standard: 'WCAG',
       version: '2.2',
-      requirement: '4.1.2',
-      title: 'Name, Role, Value',
+      requirement: '1.3.1',
+      title: 'Info and Relationships',
       conformanceLevel: 'A'
     }
   ],
@@ -71,7 +81,7 @@ const meta = {
   category: 'robust',
   type: 'automatic',
   defaultConfidence: 'medium',
-  coverage: { facetsBySc: { '4.1.2': ['aria-role-required-context-parent'] } }
+  coverage: { facetsBySc: { '1.3.1': ['aria-role-required-context-parent'] } }
 };
 
 function runInPage(ctx) {
@@ -183,6 +193,21 @@ function runInPage(ctx) {
           return n && n.parentElement ? n.parentElement : null;
         };
 
+  // The escape hatch marks the container being assembled, not the item inside
+  // it, so this walks up instead of reading the element's own attribute.
+  function hasBusyAncestor(el) {
+    let cur = getComposedParent(el);
+    let guard = 0;
+    while (cur && guard++ < 200) {
+      if (cur.nodeType === 1 && cur.getAttribute) {
+        const v = cur.getAttribute('aria-busy');
+        if (v != null && String(v).trim().toLowerCase() === 'true') return true;
+      }
+      cur = getComposedParent(cur);
+    }
+    return false;
+  }
+
   function hasAcceptableAncestorContext(el, acceptableRoles, ownRole) {
     const allowsGroup = acceptableRoles.has('group');
     let cur = getComposedParent(el);
@@ -252,6 +277,7 @@ function runInPage(ctx) {
     if (!requiredContext || !requiredContext.length) continue; // no entry, or explicitly unconstrained
 
     if (!isEligibleAcc(el)) continue; // not currently exposed to the accessibility tree
+    if (hasBusyAncestor(el)) continue; // author has signaled transient incompleteness per WAI-ARIA
 
     applicableCount += 1;
 

package/src/checks/automatic/aria-role-name-present.js

@@ -31,7 +31,11 @@
  *   to non-empty text, or a non-empty title. Every role in the set is
  *   name-from-author-only, so descendant text is not accepted:
  *   a labelled child inside a composite widget would otherwise pass the
- *   container that has no name of its own.
+ *   container that has no name of its own. The name the HTML host element
+ *   gives itself counts too, since the browser still computes it under the
+ *   role: the first child <legend> of a <fieldset>, the first child
+ *   <caption> of a <table>, and an associated <label> on a labelable
+ *   element such as <progress> or <meter>.
  */
 
 const id = 'aria-role-name-present';
@@ -45,7 +49,7 @@ const meta = {
     descriptionKey: 'ariaRoleNamePresent_description'
   },
   helpUrl: null,
-  tags: ['wcag2a', 'wcag412', 'navigation', 'atomic', 'automatic', 'name'],
+  tags: ['wcag2a', 'wcag412', 'aria', 'navigation', 'atomic', 'automatic', 'name'],
   wcagSc: ['4.1.2'],
   normativeMappings: [
     {
@@ -186,7 +190,20 @@ function runInPage(ctx) {
 
     const title = ariaLabel || labelled ? '' : getAttr(el, 'title');
 
-    const ok = !!(ariaLabel || labelled || title);
+    // The host's own HTML naming still applies under the role: the first
+    // <legend> of <fieldset role="radiogroup">, the <caption> of
+    // <table role="grid">, a <label> of <progress role="progressbar">.
+    let hostName = '';
+    if (!(ariaLabel || labelled || title) && helpers.getNativeHostNameInfo) {
+      try {
+        const host = helpers.getNativeHostNameInfo(el, ctx);
+        hostName = host && host.present ? host.value : '';
+      } catch {
+        hostName = '';
+      }
+    }
+
+    const ok = !!(ariaLabel || labelled || title || hostName);
     if (ok) continue;
 
     const eligInfo = getEligibilityInfo