@surea11y/core 1.3.0 → 1.4.1

package/src/checks/automatic/avoid-inline-spacing.js

@@ -1,34 +1,40 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check avoid-inline-spacing
  * @atomic true
- * @summary Inline style must not force text-spacing properties with !important
+ * @summary Inline style must not force text spacing below the WCAG metric
  * @standard WCAG 2.2
  * @sc 1.4.12
  * @applicability
- *   Applies to elements with an inline style attribute that sets
- *   line-height, letter-spacing, or word-spacing.
+ *   Applies to a rendered element with visible text of its own whose style
+ *   attribute declares line-height, letter-spacing or word-spacing as
+ *   `!important` with a real value. A CSS-wide keyword (inherit, initial,
+ *   unset, revert) specifies no spacing of its own and is out of scope.
  * @expectation
- *   None of those three properties are declared with `!important` in the
- *   inline style. WCAG 1.4.12 (Text Spacing) requires that users be able
- *   to override these properties via a user stylesheet without losing
- *   content or functionality; `!important` on an inline declaration
- *   defeats that override (inline `!important` wins over nearly every
- *   other origin, including user stylesheets applied the normal way).
+ *   Each such declaration already meets WCAG 1.4.12's own metric for that
+ *   property, as a multiple of the font size: line-height at least 1.5,
+ *   letter-spacing at least 0.12, word-spacing at least 0.16. A forced value
+ *   that already satisfies the criterion leaves the user nothing to override.
  * @implementation-notes
- * - Static text-based parsing of the style attribute string (regex for
- *   the three property names followed by `!important`), not computed
- *   style — matches the property list a widely-used reference engine's avoid-inline-spacing
- *   rule checks.
+ * - Computed style resolves the cascade and the units; the declared value is
+ *   only a fallback for environments that do not lay the document out. Spacing
+ *   that resolves to neither is left unreported rather than failed.
+ * - Within one declaration block, importance outranks order, so the effective
+ *   declaration is the last `!important` one for that property.
+ * - ACT 78fd32/24afc2/9e45ec additionally require the text to contain a soft
+ *   wrap break, which cannot be determined without layout. Not implemented, so
+ *   a forced value on text that never wraps is still reported.
  */
 
 const id = 'avoid-inline-spacing';
 
 const meta = {
-  title: 'Inline style must not force text spacing with !important',
+  title: 'Inline style must not force text spacing below the WCAG metric',
   description:
-    'Checks that inline style does not set line-height, letter-spacing, or word-spacing with !important, which blocks user text-spacing overrides.',
+    'Checks that where inline style forces line-height, letter-spacing or word-spacing with !important, the value already meets WCAG 1.4.12, so the user has nothing left to override.',
   i18n: {
     titleKey: 'avoidInlineSpacing_title',
     descriptionKey: 'avoidInlineSpacing_description'
@@ -56,6 +62,20 @@ function runInPage(ctx) {
   const { helpers, rule } = ctx;
 
   const SPACING_PROPS = ['line-height', 'letter-spacing', 'word-spacing'];
+  // WCAG 1.4.12's own metrics, as multiples of the font size.
+  const MIN_RATIO = { 'line-height': 1.5, 'letter-spacing': 0.12, 'word-spacing': 0.16 };
+  // Only these two take the value from the parent, leaving this declaration
+  // specifying no spacing of its own. `initial` and `revert` resolve to a
+  // concrete value (`normal` for all three properties), so they stay in scope.
+  const INHERITED_KEYWORDS = ['inherit', 'unset'];
+  // No user agent's `normal` line height reaches 1.5, so a forced `normal`
+  // always falls short of the metric.
+  const NORMAL_LINE_HEIGHT_RATIO = 1.2;
+  const CAMEL = {
+    'line-height': 'lineHeight',
+    'letter-spacing': 'letterSpacing',
+    'word-spacing': 'wordSpacing'
+  };
 
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart('[style]')
@@ -64,6 +84,136 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
+  // Within one declaration block, importance wins over order, so the last
+  // important declaration is the one that takes effect. Passed Example 5 of ACT
+  // 78fd32 turns on this and Passed Example 6 on the non-important half.
+  function effectiveDeclaration(raw, prop) {
+    const re = new RegExp('(?:^|;)\\s*' + prop + '\\s*:\\s*([^;]*)', 'gi');
+    let chosen = null;
+    let m;
+    while ((m = re.exec(raw))) {
+      const value = String(m[1] || '').trim();
+      const important = /!\s*important\s*$/i.test(value);
+      const clean = value.replace(/!\s*important\s*$/i, '').trim();
+      if (!clean) continue;
+      if (!chosen || important || !chosen.important) {
+        if (chosen && chosen.important && !important) continue;
+        chosen = { value: clean, important };
+      }
+    }
+    return chosen;
+  }
+
+  function hasVisibleTextChild(el) {
+    let kids;
+    try {
+      kids = el.childNodes ? Array.from(el.childNodes) : [];
+    } catch {
+      return false;
+    }
+    return kids.some((n) => n && n.nodeType === 3 && String(n.nodeValue || '').trim() !== '');
+  }
+
+  function isRendered(el) {
+    if (helpers.isDomVisibleEligible) {
+      try {
+        return !!helpers.isDomVisibleEligible(el, ctx, { targetSet: 'dom' }).eligible;
+      } catch {
+        return true;
+      }
+    }
+    return true;
+  }
+
+  const px = (v) => {
+    const n = parseFloat(v);
+    return Number.isFinite(n) && /px\s*$/.test(String(v)) ? n : null;
+  };
+
+  function computedStyleOf(el) {
+    if (helpers && typeof helpers.computedStyle === 'function') {
+      try {
+        const cs = helpers.computedStyle(el);
+        if (cs) return cs;
+      } catch {
+        // fall through to the realm's own view
+      }
+    }
+    try {
+      const view = el.ownerDocument && el.ownerDocument.defaultView;
+      if (view && typeof view.getComputedStyle === 'function') return view.getComputedStyle(el);
+    } catch {
+      // no computed style available
+    }
+    return null;
+  }
+
+  // ACT scopes these rules to text visible on screen, and text pushed far off
+  // canvas is the one hidden shape the shared eligibility check keeps eligible.
+  function isOffScreen(el) {
+    if (!helpers.getVisibilityHintsInfo) return false;
+    try {
+      const info = helpers.getVisibilityHintsInfo(el, ctx, {});
+      return !!(info && Array.isArray(info.hints) && info.hints.indexOf('offscreen') !== -1);
+    } catch {
+      return false;
+    }
+  }
+
+  // A realm that does not lay the document out reports font-size as the CSS
+  // absolute-size keyword rather than a length. Resolving those keeps px-valued
+  // spacing checkable there, and cannot manufacture a failure: a font size
+  // larger than assumed only makes a px ratio smaller.
+  const ABSOLUTE_FONT_SIZES = {
+    'xx-small': 9,
+    'x-small': 10,
+    small: 13,
+    medium: 16,
+    large: 18,
+    'x-large': 24,
+    'xx-large': 32
+  };
+
+  function fontSizeOf(cs) {
+    if (!cs) return null;
+    const direct = px(cs.fontSize);
+    if (direct !== null) return direct;
+    const keyword = String(cs.fontSize || '')
+      .trim()
+      .toLowerCase();
+    return ABSOLUTE_FONT_SIZES[keyword] || null;
+  }
+
+  /**
+   * The spacing as a multiple of the font size, or null when it cannot be
+   * resolved. Computed style is preferred because it already applies the
+   * cascade and unit resolution; the declared value is only a fallback for
+   * environments that do not lay the document out.
+   */
+  function spacingRatio(el, prop, declared) {
+    const cs = computedStyleOf(el);
+    const fontSize = fontSizeOf(cs);
+    if (cs && fontSize) {
+      const used = px(cs[CAMEL[prop]]);
+      if (used !== null) return used / fontSize;
+    }
+
+    const v = String(declared || '')
+      .trim()
+      .toLowerCase();
+    // `normal`, and the keywords that resolve to it, add nothing for the two
+    // spacing properties and stay under the metric for line height.
+    if (v === 'normal' || v === 'initial' || v === 'revert' || v === 'revert-layer') {
+      return prop === 'line-height' ? NORMAL_LINE_HEIGHT_RATIO : 0;
+    }
+    if (/^[0-9.]+$/.test(v)) return parseFloat(v);
+    if (/em$/.test(v)) return parseFloat(v);
+    if (/%$/.test(v)) return parseFloat(v) / 100;
+    const asPx = px(v);
+    if (asPx !== null && fontSize) return asPx / fontSize;
+    return null;
+  }
+
   for (const el of nodes) {
     if (!el || !el.getAttribute) continue;
     const raw = String(el.getAttribute('style') || '');
@@ -73,14 +223,25 @@ function runInPage(ctx) {
     const hasAnySpacingProp = SPACING_PROPS.some((p) => lower.includes(p));
     if (!hasAnySpacingProp) continue;
 
-    applicableCount += 1;
+    // The rule is about text the user needs to re-space, so an element with no
+    // text of its own, or none that renders, is not a target.
+    if (!hasVisibleTextChild(el) || !isRendered(el) || isOffScreen(el)) continue;
 
     const flagged = [];
+    let inScope = false;
     for (const prop of SPACING_PROPS) {
-      const re = new RegExp(prop.replace('-', '\\-') + '\\s*:[^;]*!important', 'i');
-      if (re.test(raw)) flagged.push(prop);
+      const decl = effectiveDeclaration(raw, prop);
+      if (!decl || !decl.important) continue;
+      if (INHERITED_KEYWORDS.indexOf(decl.value.toLowerCase()) !== -1) continue;
+      inScope = true;
+      const ratio = spacingRatio(el, prop, decl.value);
+      // Unresolvable spacing is left alone: this engine reserves fail for
+      // high-confidence violations.
+      if (ratio === null) continue;
+      if (ratio < MIN_RATIO[prop]) flagged.push(prop);
     }
 
+    if (inScope) applicableCount += 1;
     if (!flagged.length) continue;
 
     const tag = el.tagName.toLowerCase();
@@ -90,8 +251,8 @@ function runInPage(ctx) {
     occurrences.push({
       selector: stableSelector,
       html,
-      summary: `This element's inline style forces ${flagged.join(', ')} with !important, blocking user text-spacing overrides.`,
-      hint: 'Remove !important from line-height/letter-spacing/word-spacing in inline styles so users can override text spacing.',
+      summary: `This element's inline style forces ${flagged.join(', ')} with !important below the WCAG text-spacing metric, so the user cannot raise it.`,
+      hint: 'Remove !important from line-height/letter-spacing/word-spacing in inline styles, or set a value that already meets the metric (line-height 1.5, letter-spacing 0.12em, word-spacing 0.16em).',
       i18n: {
         summaryKey: 'avoidInlineSpacing_summary_fail',
         hintKey: 'avoidInlineSpacing_hint_fail',

package/src/checks/automatic/binary-control-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'binary-control-name-present';
@@ -135,9 +137,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -151,8 +160,9 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
-  const selector =
-    'input[type="checkbox"], input[type="radio"], [role="checkbox"], [role="radio"], [role="switch"]';
+  // Native checkbox/radio without an explicit role belongs to
+  // form-control-programmatic-label-present.
+  const selector = '[role="checkbox"], [role="radio"], [role="switch"]';
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart(selector)
     : helpers.queryAll(selector);

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

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 // NOTE: Repo ruleId contract requires ENGINE_TAG prefix in the rule id.
@@ -47,9 +49,8 @@ function runInPage(ctx) {
     // 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
-    // (this replaced a text-node-only TreeWalker that missed the common
-    // "<a><img alt='...'></a>" logo-link / "<button><img alt='...'></button>"
-    // icon-button pattern).
+    // (covers the common "<a><img alt='...'></a>" logo-link /
+    // "<button><img alt='...'></button>" icon-button pattern).
     if (helpers.getContentNameInfo) {
       const info = helpers.getContentNameInfo(container, ctx);
       return info && info.present ? info.value : '';
@@ -77,7 +78,14 @@ function runInPage(ctx) {
 
   for (const el of nodes) {
     // isAccTreeEligible returns { eligible, reasons }, not a boolean.
-    const eligResult = helpers.isAccTreeEligible ? helpers.isAccTreeEligible(el, ctx) : true;
+    // Naming rules apply only to elements included in the accessibility tree
+    // (ACT c487ae), which excludes focusable aria-hidden content;
+    // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
+    const eligResult = helpers.isIncludedInAccessibilityTree
+      ? helpers.isIncludedInAccessibilityTree(el, ctx)
+      : helpers.isAccTreeEligible
+        ? helpers.isAccTreeEligible(el, ctx)
+        : true;
     const eligible =
       typeof eligResult === 'boolean' ? eligResult : !!(eligResult && eligResult.eligible);
     if (!eligible) continue;
@@ -103,25 +111,50 @@ function runInPage(ctx) {
       inputValueName = getInputButtonValueName(el);
     }
 
-    // A native <button> (or [role="button"]) whose role has been overridden to
-    // one of these roles is no longer semantically a button — per the WAI-ARIA
-    // Accessible Name and Description Computation spec these roles are
-    // name-from-author-only, and their rendered content represents a VALUE,
-    // not a NAME. Found on a real page (Spotify's "sort by" control): a
-    // <button role="combobox">List</button> where "List" is the combobox's
-    // currently selected value, not a label for what the combobox is —
-    // crediting it as the accessible name masked a real missing-name bug.
-    const VALUE_ROLES = [
-      'textbox',
-      'progressbar',
-      'scrollbar',
-      'slider',
-      'spinbutton',
-      'combobox',
-      'listbox'
+    // ARIA 1.2 "Name From: author, contents". Every other known role is
+    // name-from-author-only: <button role="combobox">List</button> exposes a
+    // value, not a label. An unknown role falls back to the implicit role.
+    // <generated:aria-name-from-content>
+    const NAME_FROM_CONTENT_ROLES = [
+      'button',
+      'cell',
+      'checkbox',
+      'columnheader',
+      'doc-backlink',
+      'doc-biblioref',
+      'doc-glossref',
+      'doc-noteref',
+      'graphics-object',
+      'gridcell',
+      'heading',
+      'link',
+      'menuitem',
+      'menuitemcheckbox',
+      'menuitemradio',
+      'option',
+      'radio',
+      'row',
+      'rowgroup',
+      'rowheader',
+      'switch',
+      'tab',
+      'tooltip',
+      'treeitem'
     ];
+    // </generated:aria-name-from-content>
+    const isKnownRoleToken =
+      helpers && helpers.aria && typeof helpers.aria.isKnownRole === 'function'
+        ? (() => {
+            try {
+              return !!helpers.aria.isKnownRole(roleNorm);
+            } catch {
+              return false;
+            }
+          })()
+        : false;
     const isContentNameCandidate =
-      (tag === 'button' || role === 'button') && !VALUE_ROLES.includes(roleNorm);
+      (tag === 'button' || role === 'button') &&
+      (!roleNorm || !isKnownRoleToken || NAME_FROM_CONTENT_ROLES.includes(roleNorm));
     const contentName =
       !trustedProgrammaticName && !inputValueName && isContentNameCandidate
         ? getConservativeSubtreeText(el)

package/src/checks/automatic/canvas-text-alternative-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -7,9 +9,8 @@
  * @standard WCAG 2.2
  * @sc 1.1.1
  * @applicability
- *   Applies to <canvas> elements that are exposed to assistive technologies.
- *   Elements otherwise hidden from the accessibility tree remain applicable
- *   if they are focusable (tabbable) or referenced by IDREF relationships (per engine eligibility checks).
+ *   Applies to <canvas> elements included in the accessibility tree.
+ *   Hidden elements are excluded whether or not they are focusable.
  * @expectation
  *   Each applicable <canvas> provides a text alternative via fallback content or an accessible name.
  */
@@ -69,8 +70,15 @@ function runInPage(ctx) {
   const getEligibilityInfo =
     helpers && typeof helpers.getEligibilityInfo === 'function' ? helpers.getEligibilityInfo : null;
 
-  const isAccTreeEligible =
-    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  // aria-hidden removes the canvas from the accessibility tree, so a text
+  // alternative on it cannot reach anyone; aria-hidden-focus reports a
+  // focusable one. Matches the other non-text-content rules.
+  const isEligibleHelper =
+    helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+      ? helpers.isIncludedInAccessibilityTree
+      : helpers && typeof helpers.isAccTreeEligible === 'function'
+        ? helpers.isAccTreeEligible
+        : null;
 
   const getTextAlternativeInfo =
     helpers && typeof helpers.getTextAlternativeInfo === 'function'
@@ -95,15 +103,16 @@ function runInPage(ctx) {
   for (const el of canvases) {
     if (!el) continue;
 
-    // Applicability: eligible in the accessibility tree (with focusable/IDREF exceptions handled by helper).
-    if (isAccTreeEligible) {
+    // Applicability: included in the accessibility tree.
+    if (isEligibleHelper) {
       const elig = (() => {
         try {
-          return isAccTreeEligible(el, ctx);
+          return isEligibleHelper(el, ctx);
         } catch {
           return { eligible: true, reasons: [] };
         }
       })();
+      if (elig === false) continue;
       if (elig && elig.eligible === false) continue;
     }
 

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

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'combobox-name-present';
@@ -122,9 +124,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);

package/src/checks/automatic/contrast-computable.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'contrast-computable';

package/src/checks/automatic/contrast-enhanced.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'contrast-enhanced';

package/src/checks/automatic/contrast-minimum.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'contrast-minimum';

package/src/checks/automatic/css-orientation-lock.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -20,25 +22,17 @@
  *   display orientation unless that orientation is essential.
  * @implementation-notes
  * - The rotation DEGREE is what makes this the exploit signature, not
- *   merely the presence of a `rotate()` function — verified against a
- *   widely-used reference engine's own `css-orientation-lock` check
- *   (`cssOrientationLockEvaluate`), which computes the actual rotation angle and only
- *   flags ~90/~270 degrees, explicitly excluding ~0/~180 (a no-op or a
- *   flip, neither of which changes portrait<->landscape). A prior
- *   version of this rule flagged the bare presence of "rotate(" in an
- *   orientation-media-query rule regardless of angle — a real, confirmed
- *   false positive found via the live-DOM cross-engine corpus 2026-07-23
- *   on a real page (Times of India) whose `@media (orientation:portrait)`
- *   block only rotated a small decorative arrow icon 45 degrees, nothing
- *   resembling a page-orientation lock.
+ *   merely the presence of a `rotate()` function: a small decorative icon
+ *   rotated 45 degrees inside an orientation media query is not a page
+ *   lock. Compute the actual rotation angle and only flag ~90/~270 degrees,
+ *   excluding ~0/~180 (a no-op or a flip, neither of which changes
+ *   portrait<->landscape).
  * - Only `rotate`/`rotateZ` (transform functions) and the standalone CSS
- *   `rotate` property are parsed for degrees — matches that reference engine's
- *   own two sources (`style.transform`/`style.rotate`) but, like that engine,
- *   does not attempt to decompose `matrix()`/`matrix3d()`/`rotate3d()` into an
- *   equivalent angle (that engine does handle those; deliberately deferred here
- *   as the same class of "genuinely more complex, lower real-world
- *   value" work already deferred elsewhere in this engine, e.g.
- *   `table-th-has-data-cells`'s narrower positional-header algorithm).
+ *   `rotate` property are parsed for degrees, from the two sources
+ *   `style.transform`/`style.rotate`; `matrix()`/`matrix3d()`/`rotate3d()`
+ *   are not decomposed into an equivalent angle (deliberately deferred as
+ *   the same class of higher-complexity/lower-value work deferred elsewhere,
+ *   e.g. `table-th-has-data-cells`'s narrower positional-header algorithm).
  * - Cross-origin stylesheets throw on `.cssRules` access (browser
  *   security model) and are skipped — same class of limitation as any
  *   check that can only see same-origin/inspectable content (compare
@@ -98,9 +92,9 @@ function runInPage(ctx) {
   }
 
   // Converts a rotate()/rotateZ() angle argument (with unit) to degrees.
-  // Matches a widely-used reference engine's own getAngleInDegrees: only deg/grad/rad/turn are
-  // recognized; a unitless or unrecognized value contributes 0 (ignored,
-  // not treated as a lock -- an unparseable angle isn't a confirmed exploit).
+  // Only deg/grad/rad/turn are recognized; a unitless or unrecognized value
+  // contributes 0 (ignored, not treated as a lock -- an unparseable angle
+  // isn't a confirmed exploit).
   function angleToDegrees(raw) {
     const m = /(-?[\d.]+)\s*(deg|grad|rad|turn)/i.exec(raw);
     if (!m) return 0;
@@ -127,17 +121,17 @@ function runInPage(ctx) {
     return total;
   }
 
-  // Whole-page-orientation-lock detection, matching a widely-used reference engine's own degree
-  // math exactly (see @implementation-notes): a rotation near 0 or 180
-  // degrees (mod 180) is a no-op or a flip, neither of which changes
-  // portrait<->landscape, so it's explicitly NOT a lock; only a rotation
-  // near 90 or 270 degrees (mod 90, once the 0/180 case is excluded) is.
+  // Whole-page-orientation-lock detection (see @implementation-notes): a
+  // rotation near 0 or 180 degrees (mod 180) is a no-op or a flip, neither
+  // of which changes portrait<->landscape, so it's NOT a lock; only a
+  // rotation near 90 or 270 degrees (mod 90, once the 0/180 case is
+  // excluded) is.
   function isLockingRotation(styleDecl) {
     if (!styleDecl) return false;
     const transformVal =
       trim(styleDecl.transform) ||
       trim(styleDecl.getPropertyValue ? styleDecl.getPropertyValue('-webkit-transform') : '');
-    // The standalone CSS `rotate` property (distinct from `transform: rotate()`) -- that reference engine checks this too.
+    // The standalone CSS `rotate` property (distinct from `transform: rotate()`).
     const rotatePropVal = trim(
       styleDecl.getPropertyValue ? styleDecl.getPropertyValue('rotate') : ''
     );

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

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -18,12 +20,11 @@
  *   violation (see implementation-notes). Any other direct or wrapped child
  *   breaks the description-list semantics assistive technologies rely on.
  * @implementation-notes
- * - Only one level of <div> wrapping is flattened, matching a widely-used
- *   reference engine's definition-list algorithm — a <div> nested inside
+ * - Only one level of <div> wrapping is flattened — a <div> nested inside
  *   another wrapping <div> is not flattened further and its contents are
  *   reported invalid.
- * - Verified 2026-07-20 against a widely-used reference engine: the dt/dd pairing is
- *   only required "when not empty". A flattened set with NEITHER dt nor dd
+ * - The dt/dd pairing is only required "when not empty". A flattened set
+ *   with NEITHER dt nor dd
  *   — whether from an empty wrapping <div>, only <script>/<template>/
  *   <style> content, or a genuinely childless <dl> — is not flagged; only
  *   an unbalanced dt/dd pairing is a real structural problem.
@@ -108,8 +109,7 @@ function runInPage(ctx) {
     }
     const dedupedInvalidTags = [...new Set(invalidTags)];
 
-    // Verified 2026-07-20 against a widely-used reference engine's definition-list check:
-    // the dt/dd pairing is only required "when not empty" — a <dl> with
+    // The dt/dd pairing is only required "when not empty" — a <dl> with
     // NEITHER dt nor dd (whether genuinely childless after flattening, only
     // passthrough script/template/style content, or an empty wrapping div)
     // is vacuously fine, not a violation. Only an UNBALANCED pairing (dt

package/src/checks/automatic/deprecated-elements-not-used.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -14,8 +16,8 @@
  * @expectation
  *   Neither element is present. Since their movement can never be paused,
  *   stopped, or hidden by the user, presence is itself the violation — this
- *   rule has no partial-pass case, matching a widely-used reference engine's `blink`/`marquee`
- *   rules (which report only when the element is found).
+ *   rule has no partial-pass case (it reports only when the element is
+ *   found).
  * @implementation-notes
  * - Not rule-gated on isAccTreeEligible: presence in markup is itself the
  *   violation, independent of visibility (moving/blinking content inside a