@surea11y/core 1.6.0 → 1.8.0

package/src/checks/manual/input-image-alt-quality-manual.js

@@ -10,20 +10,25 @@
  * @sc 1.1.1
  * @type manual
  * @applicability
- *   Applies to <input type="image"> elements whose alt attribute is present
- *   and non-empty: an image button whose alt is its label. The element must
- *   be included in the accessibility tree, and role="presentation"/"none"
- *   takes it out of scope unless it is focusable, which restores its role.
+ *   Applies to <input type="image"> elements that get a non-empty text
+ *   alternative from any source: aria-labelledby (resolving to text),
+ *   aria-label, alt or title. An element whose alt is present but empty is
+ *   left to input-image-alt-decorative, which asks about that case. The
+ *   element must be included in the accessibility tree, and
+ *   role="presentation"/"none" takes it out of scope unless it is
+ *   focusable, which restores its role.
  * @expectation
- *   Human review is required to confirm that the provided text alternative is accurate and appropriate.
+ *   Human review is required to confirm that the provided text alternative is
+ *   accurate and appropriate. Each occurrence lists every source present
+ *   (data.details.sources), so the reviewer checks each one.
  */
 
 const id = 'input-image-alt-quality';
 
 const meta = {
-  title: '<input type="image"> alt text must be appropriate (manual review)',
+  title: '<input type="image"> text alternative must be appropriate (manual review)',
   description:
-    'Flags <input type="image"> elements with non-empty alt text for human review of appropriateness.',
+    'Flags <input type="image"> elements with a non-empty text alternative (alt, aria-label, aria-labelledby or title) for human review of appropriateness.',
   i18n: {
     titleKey: 'inputImage_altQuality_title',
     descriptionKey: 'inputImage_altQuality_description'
@@ -112,6 +117,53 @@ function runInPage(ctx) {
     return !focusable;
   }
 
+  const getAriaNameInfo =
+    helpers && typeof helpers.getAriaNameInfo === 'function' ? helpers.getAriaNameInfo : null;
+
+  // Every non-empty text-alternative source on the element, in accessible-name
+  // order: aria-labelledby (when it resolves to text), aria-label, alt, title.
+  // aria-labelledby wins over aria-label in the name, but a present aria-label
+  // is still listed, so each attribute present is asked about.
+  function collectTextAlternativeSources(el) {
+    const attr = (name) => {
+      try {
+        const v = el.getAttribute(name);
+        return v == null ? '' : String(v).trim();
+      } catch {
+        return '';
+      }
+    };
+    const sources = [];
+    let name = '';
+    let aria = null;
+    if (getAriaNameInfo) {
+      try {
+        aria = getAriaNameInfo(el, ctx);
+      } catch {
+        aria = null;
+      }
+    }
+    if (aria && aria.present && aria.value) {
+      name = String(aria.value).trim();
+      sources.push(aria.mechanism);
+      if (aria.mechanism === 'aria-labelledby' && attr('aria-label')) sources.push('aria-label');
+    } else if (!getAriaNameInfo && attr('aria-label')) {
+      name = attr('aria-label');
+      sources.push('aria-label');
+    }
+    const altText = attr('alt');
+    if (altText) {
+      sources.push('alt');
+      if (!name) name = altText;
+    }
+    const titleText = attr('title');
+    if (titleText) {
+      sources.push('title');
+      if (!name) name = titleText;
+    }
+    return { sources, name, alt: altText };
+  }
+
   const els = (() => {
     try {
       return Array.from(
@@ -146,24 +198,40 @@ function runInPage(ctx) {
 
     if (isRolePresentationExcluded(el)) continue;
 
-    // Rule-specific applicability (only elements that already have a text alternative mechanism)
-    if (!(el.getAttribute('alt') != null && String(el.getAttribute('alt')).trim() !== '')) continue;
+    // alt="" with another name is input-image-alt-decorative's question, so
+    // it is left there rather than asked twice.
+    let altRaw;
+    try {
+      altRaw = el.getAttribute('alt');
+    } catch {
+      altRaw = null;
+    }
+    if (altRaw != null && String(altRaw).trim() === '') continue;
+
+    // Applies when any text-alternative source gives the control a non-empty
+    // name; each present source is listed so the reviewer checks all of them.
+    const alt = collectTextAlternativeSources(el);
+    if (!alt.sources.length) continue;
 
     applicableCount += 1;
 
     const eligInfo = getEligibilityInfo ? getEligibilityInfo(el, ctx, { targetSet: 'acc' }) : null;
+    const sourcesText = alt.sources.join(', ');
+
+    const details = { name: alt.name, sources: alt.sources.slice() };
+    if (alt.alt) details.alt = alt.alt;
 
     const baseOccurrence = {
-      summary: 'Review alt text on <input type="image"> for accuracy and appropriateness.',
-      hint: 'Ensure the alt text describes the control’s action (e.g., “Search”, “Submit order”) in context.',
+      summary: `Review the text alternative of this <input type="image"> (${sourcesText}) for accuracy and appropriateness.`,
+      hint: 'Ensure each listed text alternative describes the control’s action (e.g., “Search”, “Submit order”) in context.',
       i18n: {
         summaryKey: 'inputImage_altQuality_summary_cantTell',
         hintKey: 'inputImage_altQuality_hint_cantTell',
-        params: { element: 'input[type=image]' }
+        params: { element: 'input[type=image]', sources: sourcesText }
       },
       data: {
         visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] },
-        details: { alt: String(el.getAttribute('alt') || '') } // optional but useful
+        details
       }
     };
 

package/src/checks/manual/landmark-complementary-is-top-level-manual.js

@@ -0,0 +1,231 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
+'use strict';
+
+/**
+ * @check landmark-complementary-is-top-level
+ * @atomic true
+ * @summary The complementary landmark must not be nested inside another landmark
+ * @standard Best Practices (no formal WCAG Success Criterion)
+ * @applicability
+ *   Applies whenever the page contains at least one element carrying the
+ *   complementary role: explicit role="complementary", or an <aside> that
+ *   keeps its implicit role (see implementation notes on when it does not).
+ * @expectation
+ *   No complementary candidate has an ancestor that is itself a landmark
+ *   region. Complementary content supports the main content of the page and
+ *   sits beside it; nested inside another landmark it is a section of that
+ *   landmark instead, which is not what landmark navigation announces.
+ * @implementation-notes
+ * - Not WCAG-normative, authored as an advisory, cantTell-capped
+ *   `type: 'manual'` rule, matching its three siblings
+ *   (`landmark-banner-is-top-level`, `landmark-contentinfo-is-top-level`,
+ *   `landmark-main-is-top-level`). Landmark detection and the
+ *   ancestor walk are identical to theirs; only the role being looked for
+ *   differs.
+ * - An unnamed <aside> inside sectioning content has no complementary role
+ *   per HTML-AAM, so it is not a candidate at all: reporting it would name a
+ *   landmark that does not exist. A *named* one keeps the role wherever it
+ *   sits, which is exactly the case worth review -- an <aside aria-label>
+ *   inside <main> really is a complementary landmark nested in another
+ *   landmark. `landmark-unique` and the sibling top-level rules already
+ *   resolve <aside> this way, through the same shared helper.
+ */
+
+const id = 'landmark-complementary-is-top-level';
+
+const meta = {
+  title: 'Complementary landmark must be top-level',
+  description:
+    'Checks that the complementary landmark (role="complementary" or an <aside> that keeps its implicit role) is not nested inside another landmark region.',
+  i18n: {
+    titleKey: 'landmarkComplementaryIsTopLevel_title',
+    descriptionKey: 'landmarkComplementaryIsTopLevel_description'
+  },
+  helpUrl: null,
+  tags: ['best-practice', 'landmarks', 'structure', 'atomic', 'manual'],
+  wcagSc: [],
+  normativeMappings: [],
+  defaultSeverity: 'minor',
+  category: 'operable',
+  type: 'manual',
+  defaultConfidence: 'medium',
+  coverage: {}
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+
+  // Declared inside runInPage; see scripts/build-core.js header
+  // ("runInPage MUST be self-contained").
+  function normalizeWs(s) {
+    return String(s || '')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  // Delegates to the shared helpers.getLandmarkNameInfo (aria-label -> aria-labelledby, via the
+  // target's own accessible name, not raw textContent -> title attribute fallback) rather than a
+  // local copy -- see that function's header comment in src/core/dom-helpers.js. Sharing it keeps
+  // the title-attribute fallback consistent across the landmark rules.
+  function getAccessibleLandmarkName(el) {
+    try {
+      if (helpers && typeof helpers.getLandmarkNameInfo === 'function') {
+        const info = helpers.getLandmarkNameInfo(el, ctx);
+        if (info && info.present && info.value) return normalizeWs(info.value);
+      }
+    } catch {}
+    return '';
+  }
+
+  function getExplicitRoleToken(el) {
+    const raw = normalizeWs(el.getAttribute && el.getAttribute('role'));
+    if (!raw) return '';
+    return raw.split(/\s+/)[0].toLowerCase();
+  }
+
+  // Delegates to the shared helpers.hasLandmarkScopingAncestor for the
+  // question "does this element sit inside a sectioning-content/<main>
+  // ancestor that suppresses its conditional implicit role": role-aware
+  // (an ancestor's bare TAG only counts when it carries no role attribute
+  // at all; an explicit role="dialog"-style override no longer suppresses)
+  // rather than a local tag-only copy. See that function's header comment
+  // in src/core/aria-helpers.js for the full algorithm.
+  function hasSectioningAncestor(el, includeMain) {
+    return helpers && typeof helpers.hasLandmarkScopingAncestor === 'function'
+      ? helpers.hasLandmarkScopingAncestor(el, { includeMain })
+      : false;
+  }
+
+  function getImplicitLandmarkRole(el) {
+    const tag = el.tagName ? el.tagName.toLowerCase() : '';
+    if (tag === 'header') return hasSectioningAncestor(el, true) ? '' : 'banner';
+    if (tag === 'footer') return hasSectioningAncestor(el, true) ? '' : 'contentinfo';
+    if (tag === 'main') return 'main';
+    if (tag === 'nav') return 'navigation';
+    if (tag === 'aside') {
+      // A named <aside> is never suppressed, even when nested. It keeps
+      // "complementary" when it has an accessible name, even inside
+      // sectioning content. Matches landmark-unique's precedent.
+      if (!hasSectioningAncestor(el, false)) return 'complementary';
+      return getAccessibleLandmarkName(el) ? 'complementary' : '';
+    }
+    if (tag === 'section') return getAccessibleLandmarkName(el) ? 'region' : '';
+    if (tag === 'form') return getAccessibleLandmarkName(el) ? 'form' : '';
+    return '';
+  }
+
+  const LANDMARK_ROLES = new Set([
+    'banner',
+    'contentinfo',
+    'main',
+    'navigation',
+    'complementary',
+    'region',
+    'form',
+    'search'
+  ]);
+
+  function getLandmarkRole(el) {
+    if (!el || !el.getAttribute) return '';
+    const explicit = getExplicitRoleToken(el);
+    if (explicit) return LANDMARK_ROLES.has(explicit) ? explicit : '';
+    return getImplicitLandmarkRole(el);
+  }
+
+  // A candidate must actually carry the complementary role. An <aside> that
+  // HTML-AAM strips the role from is not a complementary landmark at all, so
+  // flagging it would report a landmark that does not exist.
+  function isComplementaryCandidate(el) {
+    return getLandmarkRole(el) === 'complementary';
+  }
+
+  function hasLandmarkAncestor(el) {
+    const scopeRoots = Array.isArray(root) ? root : root ? [root] : [];
+    let p = el.parentElement;
+    while (p) {
+      if (getLandmarkRole(p)) return true;
+      // Don't climb past the scanned scope -- see aria-helpers.js's
+      // hasLandmarkScopingAncestor for the same fix and rationale.
+      if (scopeRoots.includes(p)) break;
+      p = p.parentElement;
+    }
+    return false;
+  }
+
+  // queryAllSmart (shadow-DOM-aware) instead of plain document.querySelectorAll -- see
+  // landmark-unique-manual.js's header comment. A third-party shadow-DOM-hosted
+  // widget's own landmark is invisible to a light-DOM-only query.
+  let nodes;
+  try {
+    nodes =
+      helpers && typeof helpers.queryAllSmart === 'function'
+        ? helpers.queryAllSmart('header, footer, main, nav, aside, section, form, [role]')
+        : document.querySelectorAll('header, footer, main, nav, aside, section, form, [role]');
+  } catch {
+    nodes = [];
+  }
+
+  const complementaries = [];
+  const seen = new Set();
+  for (const el of nodes) {
+    if (!el || seen.has(el)) continue;
+    seen.add(el);
+    if (!isComplementaryCandidate(el)) continue;
+
+    // An aria-hidden candidate is removed from the accessibility tree
+    // entirely, so it is not part of the landmark structure assistive
+    // technology users navigate and there is no real landmark to call
+    // nested. queryAllSmart's default hidden-content policy only excludes
+    // "hard" CSS-based hiding (display:none, etc.), not the softer
+    // aria-hidden exclusion, so this needs its own check.
+    if (helpers && typeof helpers.isAccTreeEligible === 'function') {
+      const elig = (() => {
+        try {
+          return helpers.isAccTreeEligible(el, ctx);
+        } catch {
+          return { eligible: true, reasons: [] };
+        }
+      })();
+      if (elig && elig.eligible === false) continue;
+    }
+
+    complementaries.push(el);
+  }
+
+  if (complementaries.length === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const occurrences = [];
+  for (const el of complementaries) {
+    if (!hasLandmarkAncestor(el)) continue;
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This complementary landmark is nested inside another landmark region.',
+        hint: 'Move the complementary landmark (<aside>/role="complementary") so it is not contained by another landmark; complementary content belongs beside the main content, not inside another region.',
+        i18n: {
+          summaryKey: 'landmarkComplementaryIsTopLevel_summary_cantTell',
+          hintKey: 'landmarkComplementaryIsTopLevel_hint_cantTell',
+          params: {}
+        },
+        data: {
+          details: { reasonCode: 'LANDMARK_COMPLEMENTARY_NOT_TOP_LEVEL' }
+        }
+      })
+    );
+  }
+
+  if (occurrences.length) {
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'cantTell',
+      severity: rule.defaultSeverity || 'minor',
+      occurrences
+    };
+  }
+  return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/manual/link-name-quality-manual.js

@@ -24,6 +24,11 @@
  *   enclosing list item/table cell/paragraph's own text, or (format
  *   names only) a table's first-row header) naming what it belongs to.
  * @implementation-notes
+ * - Phrase lists exist for en, de, es, fr and ja. English is always
+ *   checked; the list for the element's own language (nearest lang
+ *   attribute, across shadow roots) is added on top. Matching every list
+ *   everywhere would flag words that are generic in one language and a
+ *   real name in another ("Suite", "Plus" on an English page).
  * - EXACT match only, on purpose, against small, well-established
  *   phrase lists, not a substring/contains check. "Read more about our
  *   privacy policy" does not match "read more"; only the bare phrase
@@ -52,7 +57,7 @@ const id = 'link-name-quality';
 const meta = {
   title: 'Link text should be descriptive, not generic',
   description:
-    'Flags links whose full accessible name is a known non-descriptive phrase (e.g. "click here", "read more", "more") or a bare file-format name (e.g. "HTML", "PDF") with no adjacent context naming what it leads to, for manual review of whether the purpose is clear.',
+    'Flags links whose full accessible name is a known non-descriptive phrase (e.g. "click here", "read more", "more") or a bare file-format name (e.g. "HTML", "PDF") with no adjacent context naming what it leads to, for manual review of whether the purpose is clear. English phrases are always recognized, and German, Spanish, French or Japanese ones when the link is in that language.',
   i18n: {
     titleKey: 'linkNameQuality_title',
     descriptionKey: 'linkNameQuality_description'
@@ -79,7 +84,7 @@ const meta = {
 function runInPage(ctx) {
   const { helpers, rule } = ctx;
 
-  const GENERIC_LINK_TEXT = new Set([
+  const GENERIC_LINK_TEXT_EN = new Set([
     'click here',
     'here',
     'click',
@@ -101,6 +106,100 @@ function runInPage(ctx) {
     'info'
   ]);
 
+  const GENERIC_LINK_TEXT = {
+    en: GENERIC_LINK_TEXT_EN,
+    de: new Set([
+      'hier klicken',
+      'klicken sie hier',
+      'hier',
+      'klicken',
+      'mehr',
+      'mehr info',
+      'mehr infos',
+      'mehr informationen',
+      'weiterlesen',
+      'mehr lesen',
+      'mehr erfahren',
+      'weiter',
+      'details',
+      'mehr details',
+      'link',
+      'dieser link',
+      'los',
+      'herunterladen',
+      'mehr anzeigen',
+      'info'
+    ]),
+    es: new Set([
+      'haga clic aquí',
+      'haz clic aquí',
+      'clic aquí',
+      'pulse aquí',
+      'pincha aquí',
+      'aquí',
+      'clic',
+      'más',
+      'más info',
+      'más información',
+      'leer más',
+      'saber más',
+      'seguir leyendo',
+      'continuar leyendo',
+      'continuar',
+      'detalles',
+      'más detalles',
+      'enlace',
+      'este enlace',
+      'ir',
+      'descargar',
+      'ver más',
+      'info'
+    ]),
+    fr: new Set([
+      'cliquez ici',
+      'cliquer ici',
+      'ici',
+      'cliquez',
+      'plus',
+      "plus d'infos",
+      "plus d'informations",
+      'en savoir plus',
+      'lire la suite',
+      'la suite',
+      'suite',
+      'continuer',
+      'détails',
+      'plus de détails',
+      'lien',
+      'ce lien',
+      'télécharger',
+      'voir plus',
+      'info'
+    ]),
+    ja: new Set([
+      'こちら',
+      'ここ',
+      'こちらをクリック',
+      'ここをクリック',
+      'クリック',
+      '詳しく',
+      '詳しくは',
+      '詳しくはこちら',
+      '詳細',
+      '詳細はこちら',
+      '詳細を見る',
+      'もっと見る',
+      'もっと読む',
+      'さらに詳しく',
+      '続きを読む',
+      '続き',
+      'リンク',
+      'このリンク',
+      'ダウンロード',
+      '情報'
+    ])
+  };
+
   const FORMAT_NAME_LINK_TEXT = new Set([
     'html',
     'pdf',
@@ -124,15 +223,42 @@ function runInPage(ctx) {
 
   const CONTEXT_BLOCK_TAGS = new Set(['td', 'th', 'p', 'dd', 'blockquote', 'figcaption', 'dt']);
 
+  // NFKC folds full-width letters and punctuation (！, ＞) into their ASCII
+  // forms, and the curly apostrophe is folded so "plus d’infos" matches.
+  // Trailing arrows ("Read more »", 「詳しくはこちら→」) are decoration, not
+  // part of the phrase.
   function normalize(s) {
     return (s == null ? '' : String(s))
+      .normalize('NFKC')
+      .replace(/[\u2018\u2019]/g, "'")
       .replace(/\s+/g, ' ')
       .trim()
       .toLowerCase()
-      .replace(/[.,;:!?]+$/g, '')
+      .replace(/[\s.,;:!?。、>»›→]+$/g, '')
       .trim();
   }
 
+  // Primary language subtag of the nearest lang attribute, crossing shadow
+  // roots; '' when none is declared. Phrase lists are matched in English
+  // plus this language, so a word that is generic in one language ("plus"
+  // in French) is not flagged when it is a real name in another.
+  function primaryLangOf(node) {
+    let n = node;
+    while (n) {
+      if (n.nodeType === 1 && n.getAttribute) {
+        const v = n.getAttribute('lang');
+        if (v != null) return v.trim().split('-')[0].toLowerCase();
+      }
+      n = n.parentNode || n.host || null;
+    }
+    return '';
+  }
+
+  function inPhraseList(byLang, normalized, lang) {
+    if (byLang.en.has(normalized)) return true;
+    return !!(lang && lang !== 'en' && byLang[lang] && byLang[lang].has(normalized));
+  }
+
   function ownDirectText(el) {
     let out = '';
     const kids = el.childNodes || [];
@@ -240,7 +366,7 @@ function runInPage(ctx) {
 
     applicableCount += 1;
 
-    const isGeneric = GENERIC_LINK_TEXT.has(normalized);
+    const isGeneric = inPhraseList(GENERIC_LINK_TEXT, normalized, primaryLangOf(el));
     const isFormatName = !isGeneric && FORMAT_NAME_LINK_TEXT.has(normalized);
     if (!isGeneric && !isFormatName) continue;
 

package/src/checks/manual/media-transcript-present-manual.js

@@ -13,6 +13,16 @@
  * @expectation If a strong transcript/text-alternative signal is present (e.g., aria-describedby binding to
  *              a visible transcript block, or a nearby clearly labeled Transcript section/link), no occurrence is reported.
  *              Otherwise, the rule reports cantTell (insufficient evidence) for that media element.
+ * @implementation-notes
+ * - An <audio> without `controls` is hidden by the browser's own stylesheet
+ *   (`display: none`), not by the author, and it still plays. So the rule
+ *   does not use queryAllSmart, whose hidden-content filter would drop it in
+ *   a real browser. It queries <audio>/<video> directly (scope,
+ *   excludeSelectors and open shadow roots honoured) and applies the
+ *   eligibility check to the element itself, except for an <audio> without
+ *   `controls`: there it applies the check to the parent (or shadow host)
+ *   and to the element's own `hidden` and `aria-hidden="true"`, since its
+ *   computed style cannot tell the browser's hiding from the author's.
  */
 
 const id = 'media-alternative-transcript-evidence';
@@ -48,14 +58,24 @@ function runInPage(ctx) {
   const { document, root, helpers, rule } = ctx;
   const safeRoot = root || document;
 
-  // Conservative keyword set (deterministic). Includes common EN/FR terms.
-  // Keep this list strict to avoid false positives.
+  // Conservative keyword set (deterministic), matched in every language at
+  // once: a Japanese page may well link an English transcript. Keep this
+  // list strict to avoid false positives.
   const TRANSCRIPT_TOKENS = [
     'transcript',
     'transcription',
     'texte intégral',
     'compte rendu',
-    'verbatim'
+    'verbatim',
+    'transkript',
+    'transkription',
+    'abschrift',
+    'textfassung',
+    'transcripción',
+    'transcripcion',
+    'トランスクリプト',
+    '文字起こし',
+    '書き起こし'
   ];
 
   // Minimum transcript body length to be considered "substantial" when used as evidence.
@@ -88,7 +108,7 @@ function runInPage(ctx) {
     try {
       if (!el) return '';
       return el.textContent || '';
-    } catch (e) {
+    } catch {
       return '';
     }
   }
@@ -284,12 +304,49 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
-  const nodes = helpers.queryAllSmart
-    ? helpers.queryAllSmart('audio,video')
-    : helpers.queryAll('audio,video');
+  // Every match in scope, hidden or not (see @implementation-notes).
+  function queryAllUnfiltered(sel) {
+    const engineOptions = ctx.engineOptions || {};
+    const deep =
+      engineOptions.includeShadowDom !== false && typeof helpers.queryAllDeep === 'function';
+    const list = Array.from((deep ? helpers.queryAllDeep(sel) : helpers.queryAll(sel)) || []);
+    return typeof helpers.isExcluded === 'function'
+      ? list.filter((el) => !helpers.isExcluded(el))
+      : list;
+  }
+
+  function hiddenByBrowserStylesheet(el) {
+    return (
+      String(el.tagName || '').toLowerCase() === 'audio' &&
+      !(el.hasAttribute && el.hasAttribute('controls'))
+    );
+  }
+
+  // The eligibility that decides whether the media element is in scope.
+  function getMediaEligibility(el) {
+    if (!hiddenByBrowserStylesheet(el)) return getEligibility(el);
+    if (el.hasAttribute('hidden')) {
+      return { eligible: false, reasons: ['hiddenAttr'], targetSet: 'acc', accEligible: false };
+    }
+    if (
+      String(el.getAttribute('aria-hidden') || '')
+        .trim()
+        .toLowerCase() === 'true'
+    ) {
+      return { eligible: false, reasons: ['ariaHidden'], targetSet: 'acc', accEligible: false };
+    }
+    let parent = el.parentElement;
+    if (!parent) {
+      const rootNode = el.getRootNode ? el.getRootNode() : null;
+      parent = rootNode && rootNode.host ? rootNode.host : null;
+    }
+    return parent ? getEligibility(parent) : getEligibility(el);
+  }
+
+  const nodes = queryAllUnfiltered('audio,video');
 
   for (const el of nodes) {
-    const eligInfo = getEligibility(el);
+    const eligInfo = getMediaEligibility(el);
     if (!eligInfo || !eligInfo.eligible) continue;
 
     applicableCount += 1;