@markuplint/rules 5.4.0 → 5.6.0

package/CHANGELOG.md

@@ -3,6 +3,40 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.6.0](https://github.com/markuplint/markuplint/compare/v5.5.0...v5.6.0) (2026-11-12)
+
+### Bug Fixes
+
+* do not report an area element that has no parent node in the file ([916a166](https://github.com/markuplint/markuplint/commit/916a166916e4efd5292402abcd293927605ff799)), closes [#4528](https://github.com/markuplint/markuplint/issues/4528)
+* **rules:** do not report an area that a component of unknown output may enclose in a map ([91f796a](https://github.com/markuplint/markuplint/commit/91f796acd865c4815c66bf733a80c838b6f43be3)), closes [#4575](https://github.com/markuplint/markuplint/issues/4575)
+* **rules:** do not report what a component that no pretender resolved may render ([ecf810c](https://github.com/markuplint/markuplint/commit/ecf810c021b8fde9a6053b43293c5261f3911a46)), closes [#4572](https://github.com/markuplint/markuplint/issues/4572) [#4064](https://github.com/markuplint/markuplint/issues/4064)
+* **rules:** read the declarative shadow root as owned by its host ([2324117](https://github.com/markuplint/markuplint/commit/2324117dc83627db98f1f2f2b2f6d26d6886708f)), closes [#4527](https://github.com/markuplint/markuplint/issues/4527)
+* **rules:** read what a slot of a shadow root renders ([d3a5c76](https://github.com/markuplint/markuplint/commit/d3a5c76f5293322986ad0a122f13884f971735c5))
+* **rules:** show every message in Japanese and the names in it as written ([9145904](https://github.com/markuplint/markuplint/commit/9145904e5b43fbeb51b5d5efa6e4735eddef7921))
+* **rules:** write "an ambiguous" in the message of no-ambiguous-navigable-target-names ([9be22b3](https://github.com/markuplint/markuplint/commit/9be22b3949e114f08308d068c238666206384a45)), closes [#4585](https://github.com/markuplint/markuplint/issues/4585)
+
+
+# [5.5.0](https://github.com/markuplint/markuplint/compare/v5.4.0...v5.5.0) (2026-11-10)
+
+### Bug Fixes
+
+* **html-spec:** allow script-supporting elements in table sections, colgroup and dl ([197176a](https://github.com/markuplint/markuplint/commit/197176a7aae805e2949f9b96c6a27f39d478d261)), closes [#3591](https://github.com/markuplint/markuplint/issues/3591) [#4492](https://github.com/markuplint/markuplint/issues/4492)
+* report a main element that is not hierarchically correct ([b44c936](https://github.com/markuplint/markuplint/commit/b44c936cf2e40c8142f88fe6b503af6f437cd341))
+* **rules:** accept style as the first child in permitted-contents ([0523872](https://github.com/markuplint/markuplint/commit/05238722e9501b7758035d55293a178ab766001a)), closes [#x20](https://github.com/markuplint/markuplint/issues/x20)
+* **rules:** accept the interactive content that canvas allows ([095eb3a](https://github.com/markuplint/markuplint/commit/095eb3aeb16186b0f5cb3f4a3bd342360dae1c2c)), closes [#4491](https://github.com/markuplint/markuplint/issues/4491)
+* **rules:** count an element inside a conditional block as a label's descendant ([6ca1da5](https://github.com/markuplint/markuplint/commit/6ca1da545a903bec024f4418c3595f16d72365bc))
+* **rules:** do not judge an element that the framework moves to the head by its parent ([db28a20](https://github.com/markuplint/markuplint/commit/db28a20bc562233f0c55594077a15276ec9c113a)), closes [#4484](https://github.com/markuplint/markuplint/issues/4484) [#4484](https://github.com/markuplint/markuplint/issues/4484)
+* **rules:** do not look for an ancestor across the boundary of template content ([b660c8b](https://github.com/markuplint/markuplint/commit/b660c8bc5d2b4cbcc16f592ad536db9a2b8bdaaa))
+* **rules:** do not treat template content as an accessible name ([0d004ef](https://github.com/markuplint/markuplint/commit/0d004efd84e6cd201cdcdc66163b89c4b0a714d2))
+* **rules:** ignore comment nodes in permitted-contents ([38881eb](https://github.com/markuplint/markuplint/commit/38881eb71e80bfef45832a8f2378d336e5bfbe09)), closes [#4488](https://github.com/markuplint/markuplint/issues/4488)
+* **rules:** judge an id and a structure in the tree that it is in ([#4489](https://github.com/markuplint/markuplint/issues/4489)) ([b17db6d](https://github.com/markuplint/markuplint/commit/b17db6d813012e127beb2c2b9e3fc21a393e2d4d))
+* **rules:** require as to satisfy every matched link destination ([b4dbea2](https://github.com/markuplint/markuplint/commit/b4dbea2a08d761c90c98098102d7af40cf485849))
+
+### Features
+
+* **rules:** judge an attribute by what the framework renders ([3beee5a](https://github.com/markuplint/markuplint/commit/3beee5ad51e96fc3033b7930fec2889ea5bf18e6))
+
+
 # [5.4.0](https://github.com/markuplint/markuplint/compare/v5.3.0...v5.4.0) (2026-10-29)
 
 ### Bug Fixes

package/CLAUDE.md

@@ -65,10 +65,11 @@ broken description and detonate in someone else's PR. Run `yarn site:build` befo
 
 ## Citing a specification
 
-A README, a source comment, `meta.ts` and `schema.json` cite the passage that justifies a rule. `yarn spec-citations` checks every citation against the live specification (what it checks and why: the module comment of `scripts/spec-citations/cli.ts`), and `scripts/spec-citations/citations-policy.spec.ts` holds the conventions below offline. After editing a citation, run `yarn spec-citations` (read-only) and fix what it reports. Its lock file is refreshed by the scheduled workflow's PR, never by hand.
+A README, a source comment, `meta.ts` and `schema.json` cite the passage that justifies a rule; so do the comments in the `src` of every package (the algorithms of `ml-spec`, the value grammars of `types`, the DOM of `ml-core`, the declarations of how a framework renders a literal in `*-spec` and `*-parser`), the `html-spec` data and the website's pages. The monitor reads the whole `src` of each package, so a citation that moves with its code to another package stays watched. `yarn spec-citations` checks every citation against the live specification, the documentation or the source of a framework (what it checks and why: the module comment of `scripts/spec-citations/cli.ts`), and `scripts/spec-citations/citations-policy.spec.ts` holds the conventions below offline. After editing a citation, run `yarn spec-citations` (read-only) and fix what it reports. Its lock file is refreshed by the scheduled workflow's PR, never by hand.
 
-- Quote a spec sentence verbatim, as a blockquote in a README or as `>` lines in a source comment, and name its source: in a README the `Cite: [..](url)` line after the quote (`[..](url)より引用` in Japanese), in a comment an `@see` URL in the same comment. Never quote inline in double quotes: the monitor cannot check it. `[…]` marks what the quote leaves out.
-- Cite a section by its fragment. A `§4.10.7` beside the link is compared with the section the fragment is in; the number of an ancestor section is accepted.
+- Quote a spec sentence verbatim, as a blockquote in a README or as `>` lines in a source comment, and name its source: in a README the `Cite: [..](url)` line after the quote (`[..](url)より引用` in Japanese), in a comment an `@see` URL in the same comment. A `>` is read only at the start of a comment line (not after a list marker), and each quote is a paragraph of its own. Never quote inline in double quotes: the monitor cannot check it. `[…]` marks what the quote leaves out, and a quote is looked up in the sections the comment cites, in the order that it writes it in.
+- Cite a section by its fragment. A `§4.10.7` beside the link is compared with the section the fragment is in (one before the link belongs to the link that follows it, one after a link on the same line, as in `@see <url> — Name §4.3.2`, to that link); the number of an ancestor section is accepted. Prefer the id of a heading to a text fragment (`#:~:text=`) alone: a text fragment with no `#fragment` is searched in the whole page, and stops matching when the passage is reworded (HTML-AAM's tables were rebuilt into one section per element, and `#:~:text=Comments-,article,-aside` went with them).
+- A source file of a framework is cited by `https://github.com/<owner>/<repo>/blob/<default branch>/<path>#<name>`, where `<name>` is a top-level declaration of the file (a function, a variable, a class, a type, or `exports.<name> =`). It is compared as the declaration alone, so an edit elsewhere in the file reports nothing and a renamed declaration is `anchor-missing`. Only the repositories listed in `scripts/spec-citations/collect.ts` are monitored, and a link without a name or with a line range (`#L11-L52`) is not checked.
 - `README.ja.md` cites the HTML Living Standard through its translation (`https://momdo.github.io/html/…`, the same page and anchor as the English README) and quotes the translation's own text. That text stays English where the translation is behind the original, and the monitor reports it once the translation catches up. For WCAG, the translation is waic.jp's.
 - Cite W3C specs at an edition-less URL (`https://w3c.github.io/accname/`, `https://w3c.github.io/aria/`, `https://www.w3.org/TR/WCAG/`, `https://www.w3.org/TR/html-aria/`). WCAG's Techniques and Understanding pages have no edition-less URL; cite the latest edition (`https://www.w3.org/WAI/WCAG22/…`). Not `w3c.github.io/html-aria/`: that is unrendered ReSpec source whose anchors exist only after a browser builds them.
 

package/lib/aria-prop-requires-role/index.js

@@ -2,7 +2,7 @@ import { createRule, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingNoGlobalProp } from '../wai-aria/checkings/no-global-prop.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
-import { isAriaAttr } from '../helpers.js';
+import { getAriaAttrs } from '../helpers.js';
 import meta from './meta.js';
 export default createRule({
     meta,
@@ -14,7 +14,7 @@ export default createRule({
                 return;
             if (!elSpec.globalAttrs['#ARIAAttrs'])
                 return;
-            const propAttrs = el.attributes.filter(attr => isAriaAttr(attr));
+            const propAttrs = getAriaAttrs(el);
             if (propAttrs.length === 0)
                 return;
             const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;

package/lib/attr-eligibility.d.ts

@@ -41,8 +41,29 @@ export type AttrEligibility = {
  * @param attr - The attribute that is being resolved
  */
 export declare function resolveAttrEligibility<T extends RuleConfigValue, O extends PlainData>(name: string, node: Element<T, O>, attrSpecs: readonly Attribute[], attr?: Attr<T, O>): AttrEligibility;
+type PlainEnum = {
+    readonly enum: readonly [string, ...string[]];
+    readonly caseInsensitive?: boolean;
+    readonly disallowToSurroundBySpaces?: boolean;
+    readonly invalidValueDefault?: string;
+};
+/**
+ * `invalidValueDefault` is not carried over: a fallback of one set may be a
+ * value another set forbids. A case-sensitive spelling is kept when an earlier
+ * entry only has another case. Case and surrounding spaces follow the stricter
+ * side, because the value has to satisfy every entry.
+ *
+ * An empty intersection cannot be an enum (`enum` has at least one token).
+ * A pattern that matches nothing keeps every value invalid. That pattern is
+ * not a keyword list an author is meant to satisfy.
+ *
+ * @param enums - The enum entries that matched, in spec order. At least two
+ * @returns The intersection, or a pattern that matches nothing when the sets are disjoint
+ */
+export declare function intersectEnums(enums: readonly PlainEnum[]): Attribute['type'];
 /**
  * Formats the "did you mean" suffix shared by `no-unknown-attr`'s two typo
  * paths (spec-driven candidate, case-sensitivity mismatch).
  */
 export declare function suggestionSuffix(t: Translator, candidate: string | undefined): string;
+export {};

package/lib/attr-eligibility.js

@@ -1,5 +1,5 @@
 import { isConditionalAttributeTypeArray } from '@markuplint/ml-spec';
-import { getCandidate } from '@markuplint/types';
+import { check, getCandidate } from '@markuplint/types';
 import { attrMatches, conditionDependsOnDynamicAttr, findAttrSpec, namespaceKeyOf } from './helpers.js';
 /**
  * Attribute namespaces that are exempt from spec-based name/eligibility
@@ -43,14 +43,11 @@ attr) {
     }
     // Resolve ConditionalAttributeType[] to a concrete type based on element matching (#3598).
     if (isConditionalAttributeTypeArray(spec.type)) {
-        const matched = spec.type.find(entry => {
+        const matched = spec.type.filter(entry => {
             const cond = typeof entry.condition === 'string' ? entry.condition : entry.condition.join(',');
             return node.matches(cond);
         });
-        // Fallback to 'Any' when no condition matches: input types without an explicit
-        // entry (text, search, tel, password, hidden, checkbox, radio, file, submit,
-        // image, reset, button) have no value constraints per the HTML spec.
-        spec = { ...spec, type: matched ? matched.type : 'Any' };
+        spec = { ...spec, type: combineMatchedConditionalTypes(matched) };
     }
     if (spec.condition != null &&
         !node.hasSpreadAttr &&
@@ -60,6 +57,89 @@ attr) {
     }
     return { status: 'ok', spec };
 }
+/**
+ * Enum entries that match together are simultaneous constraints: `link[as]`
+ * has to be a preload destination and a module preload destination when `rel`
+ * contains both keywords. The message names that intersection and does not
+ * offer a keyword another entry forbids. Token order follows the entries:
+ * a spelling is kept from the earliest entry whose own token satisfies every
+ * entry, which is the first entry's order when that spelling is valid there.
+ *
+ * A non-enum overlap stays on the first match. Those entries are ordered
+ * alternatives: an empty `input[value]` other than `type=range` is
+ * unconstrained even though a later type-specific entry also matches, and
+ * `email` with `multiple` matches both the address-list type and the
+ * single-address type, of which the list is the requirement.
+ */
+function combineMatchedConditionalTypes(matched) {
+    const first = matched[0];
+    // No condition matched. Input types without an explicit entry (text, search,
+    // tel, password, hidden, checkbox, radio, file, submit, image, reset, button)
+    // have no value constraints per the HTML spec.
+    if (!first) {
+        return 'Any';
+    }
+    const enums = [];
+    for (const entry of matched) {
+        if (!isPlainEnum(entry.type)) {
+            return first.type;
+        }
+        enums.push(entry.type);
+    }
+    if (enums.length === 1) {
+        return first.type;
+    }
+    return intersectEnums(enums);
+}
+function isPlainEnum(type) {
+    if (typeof type === 'string' || Array.isArray(type)) {
+        return false;
+    }
+    return 'enum' in type && Array.isArray(type.enum) && type.enum.length > 0;
+}
+/**
+ * `invalidValueDefault` is not carried over: a fallback of one set may be a
+ * value another set forbids. A case-sensitive spelling is kept when an earlier
+ * entry only has another case. Case and surrounding spaces follow the stricter
+ * side, because the value has to satisfy every entry.
+ *
+ * An empty intersection cannot be an enum (`enum` has at least one token).
+ * A pattern that matches nothing keeps every value invalid. That pattern is
+ * not a keyword list an author is meant to satisfy.
+ *
+ * @param enums - The enum entries that matched, in spec order. At least two
+ * @returns The intersection, or a pattern that matches nothing when the sets are disjoint
+ */
+export function intersectEnums(enums) {
+    const caseInsensitive = enums.every(item => item.caseInsensitive !== false);
+    const tokens = [];
+    for (const item of enums) {
+        for (const token of item.enum) {
+            if (!enums.every(other => check(token, other).matched)) {
+                continue;
+            }
+            if (tokens.some(existing => sameToken(existing, token, caseInsensitive))) {
+                continue;
+            }
+            tokens.push(token);
+        }
+    }
+    const [head, ...rest] = tokens;
+    if (head === undefined) {
+        return { pattern: '/(?!)/' };
+    }
+    const result = {
+        enum: [head, ...rest],
+        ...(caseInsensitive ? {} : { caseInsensitive: false }),
+        ...(enums.every(item => item.disallowToSurroundBySpaces === false)
+            ? { disallowToSurroundBySpaces: false }
+            : {}),
+    };
+    return result;
+}
+function sameToken(a, b, caseInsensitive) {
+    return caseInsensitive ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
 /**
  * Formats the "did you mean" suffix shared by `no-unknown-attr`'s two typo
  * paths (spec-driven candidate, case-sensitivity mismatch).

package/lib/attr-order/index.js

@@ -229,7 +229,8 @@ export default createRule({
         let cachedValue;
         let cachedCompiled;
         await document.walkOn('Element', node => {
-            const attrs = node.getAttributeTokens();
+            // An attribute that a pretender made is not in the source, so it has no place in the order of it
+            const attrs = node.getAttributeTokens().filter(attr => !attr.isPretended);
             if (attrs.length <= 1) {
                 return;
             }

package/lib/attr-value-quotes/index.js

@@ -13,8 +13,8 @@ export default createRule({
     defaultValue: 'double',
     async verify({ document, report, t }) {
         await document.walkOn('Attr', attr => {
-            const message = t('{0} is must {1} on {2}', 'Attribute value', 'quote', `${attr.rule.value} quotation mark`);
-            if (attr.isDynamicValue || attr.isDirective || !attr.equal || attr.equal?.raw === '') {
+            const message = t('{0} must be quoted with {1}', 'Attribute value', attr.rule.value === 'double' ? 'double quotation marks' : 'single quotation marks');
+            if (attr.isExpressionValue || attr.isDirective || !attr.equal || attr.equal?.raw === '') {
                 return;
             }
             const quote = attr.startQuote?.raw;

package/lib/consistent-table-row-length/index.js

@@ -18,7 +18,7 @@ export default createRule({
     meta,
     defaultSeverity: 'warning',
     verify({ document, report, t }) {
-        const tables = document.querySelectorAll('table');
+        const tables = document.deepQuerySelectorAll('table');
         for (const table of tables) {
             const grid = new Grid(table);
             if (grid.hasOverlapped()) {

package/lib/create-message.js

@@ -1,4 +1,5 @@
 import { isList, isKeyword, isEnum, isNumber, isDirective, isPattern } from '@markuplint/types';
+import { noTranslate } from './no-translate.js';
 export function createMessageValueExpected(t, baseTarget, type, matches) {
     let target = baseTarget;
     let listDescriptionPart;
@@ -53,7 +54,7 @@ export function __createMessageValueExpected(t, baseTarget, expected, matches) {
         }
         case 'extra-token': {
             const token = matches.partName ?? 'token';
-            reasonPart = t('Found {0}', t('extra {0}', token)) + ' ' + t([matches.raw]);
+            reasonPart = t('Found {0}', t('extra {0}', token)) + ' ' + t([noTranslate(matches.raw)]);
             if (matches.extra) {
                 const extra = expectValueToWord(t, matches.extra, 'Any');
                 unnecessaryPart = t("It doesn't need {0}", extra);
@@ -212,11 +213,11 @@ function createExpectedObject(type, matches, t) {
     }
     else if (isKeyword(type)) {
         if (type[0] === '<') {
-            expectedObject.push(t('the CSS Syntax "{0}"', type));
+            expectedObject.push(t('the CSS Syntax "{0*}"', type));
         }
     }
     else if (isEnum(type)) {
-        expectedObject.push(...type.enum);
+        expectedObject.push(...type.enum.map(noTranslate));
     }
     else if (isNumber(type)) {
         expectedObject.push(createExpectedNumber(t, type));
@@ -240,7 +241,7 @@ function expectValueToWord(t, expect, type) {
             return expect.value;
         }
         case 'const': {
-            return expect.value ? `%${expect.value}%` : '';
+            return noTranslate(expect.value);
         }
         case 'format': {
             return t('the {0} format', expect.value);
@@ -250,7 +251,7 @@ function expectValueToWord(t, expect, type) {
         }
         case 'syntax': {
             if (isKeyword(type) && type[0] === '<') {
-                return t('the CSS Syntax "{0}"', expect.value);
+                return t('the CSS Syntax "{0*}"', expect.value);
             }
             return t('{0} syntax', expect.value);
         }

package/lib/element-supports-aria-prop/index.js

@@ -2,7 +2,7 @@ import { createRule, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingElementSupportsAriaProp } from '../wai-aria/checkings/element-supports-aria-prop.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
-import { isAriaAttr } from '../helpers.js';
+import { getAriaAttrs } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Split from the former `wai-aria-disallowed-props` rule (#3989): the ARIA in
@@ -25,7 +25,7 @@ export default createRule({
                 return;
             if (!elSpec.globalAttrs['#ARIAAttrs'])
                 return;
-            const propAttrs = el.attributes.filter(attr => isAriaAttr(attr));
+            const propAttrs = getAriaAttrs(el);
             if (propAttrs.length === 0)
                 return;
             const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;

package/lib/form-attr-references-form/index.js

@@ -1,4 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
+import { getElementByIdInTree } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Form-associated elements (HTML LS §4.10.2). Listed elements may carry
@@ -47,8 +48,7 @@ export default createRule({
                 return;
             if (formAttr.isDynamicValue)
                 return;
-            const targetId = formAttr.value;
-            const target = [...document.querySelectorAll('[id]')].find(candidate => candidate.getAttribute('id') === targetId);
+            const target = getElementByIdInTree(el, formAttr.value, formAttr.isExpressionValue);
             // Existence is checked by `no-refer-to-non-existent-id`. If the ID does not resolve
             // here, leave that diagnostic to the dedicated rule and stay silent.
             if (!target)
@@ -59,7 +59,7 @@ export default createRule({
                     line: formAttr.valueNode?.startLine,
                     col: formAttr.valueNode?.startCol,
                     raw: formAttr.valueNode?.raw,
-                    message: t('The "{0}" attribute on a form-associated element must reference a "{1}" element', 'form', 'form'),
+                    message: t('The "{0*}" attribute on a form-associated element must reference a "{1*}" element', 'form', 'form'),
                 });
             }
         });

package/lib/helpers.d.ts

@@ -1,7 +1,68 @@
 import type { FixToken, IRuleFixer, PlainData, TextEdit } from '@markuplint/ml-config';
-import type { Attr, Element, RuleConfigValue, Document } from '@markuplint/ml-core';
+import type { Attr, ChildNode, Element, RuleConfigValue } from '@markuplint/ml-core';
 import type { Attribute } from '@markuplint/ml-spec';
 import type { WritableDeep } from 'type-fest';
+import { getDOMValue } from '@markuplint/ml-core';
+export { getDOMValue };
+/**
+ * The element that an id reference written in an attribute of `el` resolves to: the first element
+ * of the tree `el` is in whose id is the reference. The content of a `template` element and a
+ * declarative shadow root are trees of their own, so a reference there does not reach an id of the
+ * document, nor the other way around.
+ *
+ * The reference is compared with the character references in the markup resolved, as the id is.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param el - The element that has the attribute
+ * @param reference - The value of the attribute, or one token of it, as written in the markup
+ * @param isExpression - Whether the value is written as code, which has no character reference in it
+ * @returns The element, or `null` when the tree has none, or `el` is in no tree
+ * @see https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute
+ */
+export declare function getElementByIdInTree<T extends RuleConfigValue, O extends PlainData>(el: Element<T, O>, reference: string, isExpression?: boolean): Element<T, O> | null;
+/**
+ * Whether the element is not an element of the output, so that what is written in it is rendered in
+ * place of it:
+ *
+ * - a fragment (`<>` of JSX), which `childNodes` already flattens;
+ * - a `template` element with a directive attribute (Vue's `<template v-if>`, `v-for`, `v-slot`).
+ *   It is not an HTML `template` element: the template engine renders its children in place of it
+ *   and drops it. A spread attribute (`{...props}`) is not such a directive: it sets attributes of
+ *   the element, which stays.
+ *
+ * `isTransparent` of `@markuplint/ml-core` (`src/ml-dom/helper/tree-scope.ts`), which is not exported,
+ * decides the same of an element for the tree boundaries (`getRootNode()`, the shadow host): a kind
+ * added here belongs to it too.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param el - An element
+ * @returns `true` if the output has no element for it
+ */
+export declare function isRenderedAway<T extends RuleConfigValue, O extends PlainData>(el: Element<T, O>): boolean;
+/**
+ * Whether the element is a component whose output is not known, so that it may render an element that
+ * a rule looks for among the ancestors (`MLElement#isUnresolvedComponent`). What the parser sees as a
+ * component but renders its children in place is not one: what {@link isRenderedAway} says (a
+ * fragment such as `React.Fragment` or Astro's `Fragment`, a `template` with a directive).
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param el - An ancestor of the element
+ * @returns `true` if the element may render what is not known
+ */
+export declare function isUnknownOutput<T extends RuleConfigValue, O extends PlainData>(el: Element<T, O>): boolean;
+/**
+ * The elements that match the selector in the tree `el` is in (see {@link getElementByIdInTree}).
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param el - An element of the tree
+ * @param selectors - A selector
+ * @returns The elements in the order of the markup, none when `el` is in no tree
+ */
+export declare function querySelectorAllInTree<T extends RuleConfigValue, O extends PlainData>(el: Element<T, O>, selectors: string): readonly Element<T, O>[];
 /** A `null`/`undefined` condition means the attribute applies unconditionally. */
 export declare function attrMatches<T extends RuleConfigValue, O extends PlainData>(node: Element<T, O>, condition: Attribute['condition']): boolean;
 /**
@@ -60,6 +121,16 @@ export declare function namespaceKeyOf(attr: Pick<Attr<RuleConfigValue, PlainDat
         readonly elementType: string;
     };
 }): string;
+/**
+ * The `aria-*` attributes that the element has. An attribute that the framework does not output
+ * (`aria-label={null}`, `MLAttr#isAbsent`) is not one of them: the DOM does not have it, so what a rule
+ * says of an attribute of the element (it is unsupported, deprecated, redundant, or its value is
+ * invalid) is not said of it.
+ *
+ * @param el - The element
+ * @returns The `aria-*` attributes that are output
+ */
+export declare function getAriaAttrs<T extends RuleConfigValue, O extends PlainData>(el: Element<T, O>): Attr<T, O>[];
 /**
  * Whether the attribute is an `aria-*` one, told by {@link namespaceKeyOf}.
  *
@@ -117,7 +188,28 @@ export declare function match(needle: string, pattern: string): boolean;
  */
 export declare const rePCENChar: string;
 export declare function toNormalizedValue(value: string, spec: Attribute): string;
-export declare function accnameMayBeMutable(el: Element<any, any>, document: Document<any, any>): boolean;
+/**
+ * Whether a child of an element may stand for children that are not known: a block of a preprocessor
+ * that has no `blockBehavior` (an output such as `{value}` or an `include`), a `slot`, or a component
+ * whose output is not known (`MLElement#isUnresolvedComponent`).
+ *
+ * It is for a rule that asks which children an element has (the required children, the elements that
+ * satisfy a query). It looks at the child alone: a descendant of the child is not a child of the
+ * element, so what it renders cannot become the child that the rule asks for, and the attributes of
+ * a child do not decide whether the child exists. `MLElement#hasMutableChildren` looks at every
+ * descendant, which is the question for a rule that asks what the descendants are or have.
+ * `require-datetime` asks about the text, which any descendant may change, and looks at every
+ * descendant for an unresolved component itself.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param node - A child node of the element
+ * @param components - Whether a component whose output is not known counts. It does not when the
+ * rule evaluates the components by the name that they are written with
+ * @returns True if the node may stand for children that are not known
+ */
+export declare function mayRenderUnknownChildren<T extends RuleConfigValue, O extends PlainData>(node: ChildNode<T, O>, components?: boolean): boolean;
+export declare function accnameMayBeMutable(el: Element<any, any>): boolean;
 /**
  * Whether the accessible name of `el` may be rendered by content the pretender
  * does not know: an unknown entry (`{ dynamic: true }`) in the `contents` of
@@ -129,9 +221,9 @@ export declare function accnameMayBeMutable(el: Element<any, any>, document: Doc
  * must stay checked (and reported as redundant by `no-redundant-accessible-name`).
  * Call it only once the static name has been computed and found empty.
  */
-export declare function accnameMayComeFromUnknownContent(el: Element<any, any>, document: Document<any, any>): boolean;
+export declare function accnameMayComeFromUnknownContent(el: Element<any, any>): boolean;
 export declare const labelable: string[];
-export declare function getOwnedLabel<V extends RuleConfigValue, O extends PlainData>(el: Element<V, O>, document: Document<V, O>): Element<V, O> | null;
+export declare function getOwnedLabel<V extends RuleConfigValue, O extends PlainData>(el: Element<V, O>): Element<V, O> | null;
 /** `null`/`undefined` items are silently dropped on add. */
 export declare class Collection<T> {
     #private;
@@ -181,4 +273,3 @@ export declare function createIgnoreFeaturesLookup(tagNameCaseSensitive: boolean
     /** Whether the attribute of the element is ignored. */
     isAttrIgnored<T extends RuleConfigValue, O extends PlainData>(elementOption: readonly string[] | undefined, elementName: string, attr: Attr<T, O>): boolean;
 };
-export {};