@markuplint/rules 5.2.0 → 5.4.0

package/lib/helpers.d.ts

@@ -1,5 +1,5 @@
 import type { FixToken, IRuleFixer, PlainData, TextEdit } from '@markuplint/ml-config';
-import type { Element, RuleConfigValue, Document } from '@markuplint/ml-core';
+import type { Attr, Element, RuleConfigValue, Document } from '@markuplint/ml-core';
 import type { Attribute } from '@markuplint/ml-spec';
 import type { WritableDeep } from 'type-fest';
 /** A `null`/`undefined` condition means the attribute applies unconditionally. */
@@ -10,6 +10,94 @@ export declare function attrMatches<T extends RuleConfigValue, O extends PlainDa
  * indeterminate and must not be used to report a violation.
  */
 export declare function conditionDependsOnDynamicAttr<T extends RuleConfigValue, O extends PlainData>(node: Element<T, O>, condition: NonNullable<Attribute['condition']>): boolean;
+/**
+ * Memoizes `fn` by the identity of its argument. Use it for an object that is one object for every
+ * caller, such as the array `getAttrSpecs` hands out for an element name. The options of the
+ * elements a `nodeRule` selects are not: each element gets a copy, so use {@link memoizeByContent} for them.
+ *
+ * @param fn - The function to memoize
+ * @returns The function that computes `fn` once per object
+ */
+export declare function memoizeByObject<K extends object, V>(fn: (key: K) => V): (key: K) => V;
+/**
+ * Memoizes `fn` by the content of its argument, which must be JSON data (a rule option is). The
+ * options of the elements a `nodeRule` selects arrive as a copy for each element, so keying by
+ * identity alone would rebuild the table for every element; identity stays as the first, cheap
+ * lookup, and the content is serialised only for an object not seen before. The cache lives as long
+ * as the memoized function, which a rule creates once per `verify` call, so it is bounded by the
+ * options of one document. Two contents that differ only in key order are two entries, which is
+ * harmless for a table read by name. JSON keeps `['a', 'b']` and `['a\0b']` apart, which a joined
+ * string would not.
+ *
+ * @param fn - The function to memoize
+ * @returns The function that computes `fn` once per content
+ */
+export declare function memoizeByContent<K extends object, V>(fn: (key: K) => V): (key: K) => V;
+/**
+ * Finds the spec of an attribute: the spec named as the attribute is written, and otherwise the
+ * first one that the attribute says it is (`MLAttr#isNamedBy`). The case of a name is decided by
+ * the attribute, so the rules that look an attribute up share one answer.
+ *
+ * `getAttrSpecs` hands out the same array for every element of a name, so the exact names are
+ * indexed once per array and the scan runs only for a name that is not written as the spec spells it.
+ *
+ * @param attrSpecs - The specs of the attributes of the element
+ * @param attr - The attribute
+ * @returns The spec, or `undefined` if the attribute has none
+ */
+export declare function findAttrSpec<T extends RuleConfigValue, O extends PlainData>(attrSpecs: readonly Attribute[], attr: Attr<T, O>): Attribute | undefined;
+/**
+ * The name that a namespace of names (`data-*`, `aria-*`, the predefined groups of `attr-order`)
+ * is told by: the name that the DOM gives the attribute (`nameKey`). For the prop of a component it
+ * is the name as written in ASCII lower case instead, because
+ * `nameKey` camelizes it in Vue (`data-x` is `dataX`) and a prefix cannot be told then.
+ *
+ * @param attr - The attribute, with the element type of its owner
+ * @returns The name to test against a namespace
+ */
+export declare function namespaceKeyOf(attr: Pick<Attr<RuleConfigValue, PlainData>, 'name' | 'nameKey'> & {
+    readonly ownerElement: {
+        readonly elementType: string;
+    };
+}): string;
+/**
+ * Whether the attribute is an `aria-*` one, told by {@link namespaceKeyOf}.
+ *
+ * @param attr - The attribute
+ * @returns `true` if the attribute is an `aria-*` one
+ */
+export declare function isAriaAttr<T extends RuleConfigValue, O extends PlainData>(attr: Attr<T, O>): boolean;
+/**
+ * The shape of an option that lists attributes (`allowAttrs`, `disallowAttrs`): bare names, which
+ * carry no value of their own, `{ name, value }` pairs, or a record of name to value.
+ */
+type NameValueOption<V> = (string | {
+    readonly name: string;
+    readonly value: V;
+})[] | Record<string, V>;
+/**
+ * Creates a lookup of an attribute in a `NameValueOption`.
+ *
+ * A name of an option is compared as the DOM compares attribute names (`MLAttr#isNamedBy`): ASCII
+ * case-insensitive in the HTML syntax and for an HTML element that code sets through the DOM API
+ * (JSX, MDX, Vue), exact for an SVG or MathML element there, and the props of a component are not
+ * folded. The README of `no-unknown-attr` states it for users.
+ *
+ * Among the entries, one spelled as the attribute is written wins over any other, and the last of
+ * the same spelling wins. With no such entry, the last entry that the attribute accepts wins.
+ * The table of an option is built once per content (`memoizeByContent`).
+ *
+ * @param stringValue - The value of a bare name
+ * @returns The lookup, which gives the value for the attribute, or `undefined` if no entry names it
+ */
+export declare function createNameOptionLookup<V>(stringValue: V): <T extends RuleConfigValue, O extends PlainData>(option: NameValueOption<V> | undefined, attr: Attr<T, O>) => V | undefined;
+/**
+ * Creates a test of whether an attribute has one of the prefixes of an option
+ * (`ignoreAttrNamePrefix`), which `MLAttr#isPrefixedBy` decides.
+ *
+ * @returns The test, which takes the prefixes of the option and the attribute
+ */
+export declare function createPrefixMatcher(): <T extends RuleConfigValue, O extends PlainData>(prefixes: string | readonly string[] | undefined, attr: Attr<T, O>) => boolean;
 /** `pattern` is a regex literal of the form `/pattern/flags` if it matches that shape, otherwise an exact string. */
 export declare function match(needle: string, pattern: string): boolean;
 /**
@@ -72,3 +160,25 @@ export declare function removeAttrValue(fixer: IRuleFixer, attr: {
     readonly valueNode: FixToken | null;
     readonly endQuote: FixToken | null;
 }): TextEdit | TextEdit[];
+/**
+ * Creates the lookup of `ignoreFeatures`, whose keys are an element (`dialog`) or an attribute of
+ * an element (`img[loading]`). The element part of a key is compared as the document compares tag
+ * names (`tagNameCaseSensitive`), so `DIALOG` is not `<dialog>` in Svelte. The attribute part is
+ * compared by the attribute that is checked (`MLAttr#isNamedBy`). An element key does not ignore
+ * the attributes of the element.
+ *
+ * The option of an element replaces the option of the rule for that element. The options of the
+ * elements a `nodeRule` selects arrive as a copy for each element, so the table of an option is built
+ * once per content (`memoizeByContent`).
+ *
+ * @param tagNameCaseSensitive - `MLDocument#tagNameCaseSensitive`
+ * @param ruleOption - `ignoreFeatures` of the rule
+ * @returns The lookup for an element and for an attribute of an element
+ */
+export declare function createIgnoreFeaturesLookup(tagNameCaseSensitive: boolean, ruleOption: readonly string[] | undefined): {
+    /** Whether the element is ignored. */
+    isElementIgnored(elementOption: readonly string[] | undefined, elementName: string): 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 {};

package/lib/helpers.js

@@ -1,4 +1,5 @@
 import { escapeCSS } from '@markuplint/ml-spec';
+import { asciiLowerCase } from '@markuplint/shared';
 /** A `null`/`undefined` condition means the attribute applies unconditionally. */
 export function attrMatches(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -25,11 +26,163 @@ node, condition) {
         for (const matched of selector.matchAll(/\[\s*([^\s\]=~|^$*]+)/g)) {
             const name = matched[1];
             if (name) {
-                referencedNames.add(name.toLowerCase());
+                referencedNames.add(name);
             }
         }
     }
-    return node.attributes.some(attr => attr.isDynamicValue && referencedNames.has(attr.localName.toLowerCase()));
+    // Whether the attribute is the one that the selector names is up to the attribute (`isNamedBy`)
+    const names = [...referencedNames];
+    return node.attributes.some(attr => attr.isDynamicValue && names.some(name => attr.isNamedBy(name)));
+}
+/**
+ * Memoizes `fn` by the identity of its argument. Use it for an object that is one object for every
+ * caller, such as the array `getAttrSpecs` hands out for an element name. The options of the
+ * elements a `nodeRule` selects are not: each element gets a copy, so use {@link memoizeByContent} for them.
+ *
+ * @param fn - The function to memoize
+ * @returns The function that computes `fn` once per object
+ */
+export function memoizeByObject(fn) {
+    const cache = new WeakMap();
+    return key => {
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const value = fn(key);
+        cache.set(key, value);
+        return value;
+    };
+}
+/**
+ * Memoizes `fn` by the content of its argument, which must be JSON data (a rule option is). The
+ * options of the elements a `nodeRule` selects arrive as a copy for each element, so keying by
+ * identity alone would rebuild the table for every element; identity stays as the first, cheap
+ * lookup, and the content is serialised only for an object not seen before. The cache lives as long
+ * as the memoized function, which a rule creates once per `verify` call, so it is bounded by the
+ * options of one document. Two contents that differ only in key order are two entries, which is
+ * harmless for a table read by name. JSON keeps `['a', 'b']` and `['a\0b']` apart, which a joined
+ * string would not.
+ *
+ * @param fn - The function to memoize
+ * @returns The function that computes `fn` once per content
+ */
+export function memoizeByContent(fn) {
+    const byContent = new Map();
+    return memoizeByObject((key) => {
+        const content = JSON.stringify(key);
+        if (byContent.has(content)) {
+            return byContent.get(content);
+        }
+        const value = fn(key);
+        byContent.set(content, value);
+        return value;
+    });
+}
+const exactSpecsOf = memoizeByObject((attrSpecs) => {
+    const exact = new Map();
+    for (const spec of attrSpecs) {
+        if (!exact.has(spec.name)) {
+            exact.set(spec.name, spec);
+        }
+    }
+    return exact;
+});
+/**
+ * Finds the spec of an attribute: the spec named as the attribute is written, and otherwise the
+ * first one that the attribute says it is (`MLAttr#isNamedBy`). The case of a name is decided by
+ * the attribute, so the rules that look an attribute up share one answer.
+ *
+ * `getAttrSpecs` hands out the same array for every element of a name, so the exact names are
+ * indexed once per array and the scan runs only for a name that is not written as the spec spells it.
+ *
+ * @param attrSpecs - The specs of the attributes of the element
+ * @param attr - The attribute
+ * @returns The spec, or `undefined` if the attribute has none
+ */
+export function findAttrSpec(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+attrSpecs, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+attr) {
+    return exactSpecsOf(attrSpecs).get(attr.name) ?? attrSpecs.find(spec => attr.isNamedBy(spec.name));
+}
+/**
+ * The name that a namespace of names (`data-*`, `aria-*`, the predefined groups of `attr-order`)
+ * is told by: the name that the DOM gives the attribute (`nameKey`). For the prop of a component it
+ * is the name as written in ASCII lower case instead, because
+ * `nameKey` camelizes it in Vue (`data-x` is `dataX`) and a prefix cannot be told then.
+ *
+ * @param attr - The attribute, with the element type of its owner
+ * @returns The name to test against a namespace
+ */
+export function namespaceKeyOf(attr) {
+    return attr.ownerElement.elementType === 'authored' ? asciiLowerCase(attr.name) : attr.nameKey;
+}
+/**
+ * Whether the attribute is an `aria-*` one, told by {@link namespaceKeyOf}.
+ *
+ * @param attr - The attribute
+ * @returns `true` if the attribute is an `aria-*` one
+ */
+export function isAriaAttr(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+attr) {
+    return namespaceKeyOf(attr).startsWith('aria-');
+}
+/**
+ * Creates a lookup of an attribute in a `NameValueOption`.
+ *
+ * A name of an option is compared as the DOM compares attribute names (`MLAttr#isNamedBy`): ASCII
+ * case-insensitive in the HTML syntax and for an HTML element that code sets through the DOM API
+ * (JSX, MDX, Vue), exact for an SVG or MathML element there, and the props of a component are not
+ * folded. The README of `no-unknown-attr` states it for users.
+ *
+ * Among the entries, one spelled as the attribute is written wins over any other, and the last of
+ * the same spelling wins. With no such entry, the last entry that the attribute accepts wins.
+ * The table of an option is built once per content (`memoizeByContent`).
+ *
+ * @param stringValue - The value of a bare name
+ * @returns The lookup, which gives the value for the attribute, or `undefined` if no entry names it
+ */
+export function createNameOptionLookup(stringValue) {
+    const tableOf = memoizeByContent((option) => {
+        const entries = Array.isArray(option)
+            ? option.map(entry => (typeof entry === 'string' ? [entry, stringValue] : [entry.name, entry.value]))
+            : Object.entries(option);
+        // `new Map` keeps the later of two entries of one spelling. Across spellings, the exact
+        // spelling is looked up first and the scan below keeps the last that the attribute accepts.
+        return { entries, exact: new Map(entries) };
+    });
+    return (option, attr) => {
+        if (!option) {
+            return;
+        }
+        const { entries, exact } = tableOf(option);
+        if (exact.has(attr.name)) {
+            return exact.get(attr.name);
+        }
+        let found;
+        for (const [name, value] of entries) {
+            if (attr.isNamedBy(name)) {
+                found = value;
+            }
+        }
+        return found;
+    };
+}
+/**
+ * Creates a test of whether an attribute has one of the prefixes of an option
+ * (`ignoreAttrNamePrefix`), which `MLAttr#isPrefixedBy` decides.
+ *
+ * @returns The test, which takes the prefixes of the option and the attribute
+ */
+export function createPrefixMatcher() {
+    return (prefixes, attr) => {
+        if (prefixes == null) {
+            return false;
+        }
+        return (typeof prefixes === 'string' ? [prefixes] : prefixes).some(prefix => attr.isPrefixedBy(prefix));
+    };
 }
 /** `pattern` is a regex literal of the form `/pattern/flags` if it matches that shape, otherwise an exact string. */
 export function match(needle, pattern) {
@@ -259,3 +412,60 @@ fixer, attr) {
     }
     return fixer.removeRange(range);
 }
+function parseIgnoreFeatures(features) {
+    const elements = { exact: new Set(), folded: new Set() };
+    const attrs = { exact: new Map(), folded: new Map() };
+    const push = (map, element, attrName) => {
+        const names = map.get(element);
+        if (names) {
+            names.push(attrName);
+        }
+        else {
+            map.set(element, [attrName]);
+        }
+    };
+    for (const feature of features) {
+        const open = feature.indexOf('[');
+        if (open === -1 || !feature.endsWith(']')) {
+            elements.exact.add(feature);
+            elements.folded.add(asciiLowerCase(feature));
+            continue;
+        }
+        const element = feature.slice(0, open);
+        const attrName = feature.slice(open + 1, -1);
+        push(attrs.exact, element, attrName);
+        push(attrs.folded, asciiLowerCase(element), attrName);
+    }
+    return { elements, attrs };
+}
+/**
+ * Creates the lookup of `ignoreFeatures`, whose keys are an element (`dialog`) or an attribute of
+ * an element (`img[loading]`). The element part of a key is compared as the document compares tag
+ * names (`tagNameCaseSensitive`), so `DIALOG` is not `<dialog>` in Svelte. The attribute part is
+ * compared by the attribute that is checked (`MLAttr#isNamedBy`). An element key does not ignore
+ * the attributes of the element.
+ *
+ * The option of an element replaces the option of the rule for that element. The options of the
+ * elements a `nodeRule` selects arrive as a copy for each element, so the table of an option is built
+ * once per content (`memoizeByContent`).
+ *
+ * @param tagNameCaseSensitive - `MLDocument#tagNameCaseSensitive`
+ * @param ruleOption - `ignoreFeatures` of the rule
+ * @returns The lookup for an element and for an attribute of an element
+ */
+export function createIgnoreFeaturesLookup(tagNameCaseSensitive, ruleOption) {
+    const tableOf = memoizeByContent(parseIgnoreFeatures);
+    const ruleTable = tableOf(ruleOption ?? []);
+    const pick = (elementOption) => (elementOption ? tableOf(elementOption) : ruleTable);
+    return {
+        isElementIgnored(elementOption, elementName) {
+            const { exact, folded } = pick(elementOption).elements;
+            return tagNameCaseSensitive ? exact.has(elementName) : folded.has(asciiLowerCase(elementName));
+        },
+        isAttrIgnored(elementOption, elementName, attr) {
+            const { exact, folded } = pick(elementOption).attrs;
+            const names = tagNameCaseSensitive ? exact.get(elementName) : folded.get(asciiLowerCase(elementName));
+            return names?.some(name => attr.isNamedBy(name)) ?? false;
+        },
+    };
+}

package/lib/input-list-references-datalist/index.d.ts

@@ -1,11 +1,13 @@
 /**
  * Require the `list` attribute on an `<input>` element to reference an
- * actual `<datalist>` element by ID. Per HTML LS §4.10.5.2: "The `list`
- * content attribute is used to identify an element that lists predefined
- * options to suggest to the user. If present, its value must be the ID of
- * a `datalist` element in the same tree." Existence of the ID itself is
- * the responsibility of `no-refer-to-non-existent-id`; this rule only
- * checks the element type when the ID resolves.
+ * actual `<datalist>` element by ID. Per HTML LS §4.10.5.3.9:
+ *
+ * > The list attribute is used to identify an element that lists predefined options suggested to the user. If present,
+ * > its value must be the ID of a datalist element in the same tree.
+ *
+ * Existence of the ID itself is the responsibility of
+ * `no-refer-to-non-existent-id`; this rule only checks the element type
+ * when the ID resolves.
  *
  * @see https://html.spec.whatwg.org/multipage/input.html#the-list-attribute
  */

package/lib/input-list-references-datalist/index.js

@@ -2,12 +2,14 @@ import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
  * Require the `list` attribute on an `<input>` element to reference an
- * actual `<datalist>` element by ID. Per HTML LS §4.10.5.2: "The `list`
- * content attribute is used to identify an element that lists predefined
- * options to suggest to the user. If present, its value must be the ID of
- * a `datalist` element in the same tree." Existence of the ID itself is
- * the responsibility of `no-refer-to-non-existent-id`; this rule only
- * checks the element type when the ID resolves.
+ * actual `<datalist>` element by ID. Per HTML LS §4.10.5.3.9:
+ *
+ * > The list attribute is used to identify an element that lists predefined options suggested to the user. If present,
+ * > its value must be the ID of a datalist element in the same tree.
+ *
+ * Existence of the ID itself is the responsibility of
+ * `no-refer-to-non-existent-id`; this rule only checks the element type
+ * when the ID resolves.
  *
  * @see https://html.spec.whatwg.org/multipage/input.html#the-list-attribute
  */

package/lib/label-for-references-labelable/index.d.ts

@@ -1,10 +1,13 @@
 /**
  * Require the `for` attribute on a `<label>` element to reference an
- * actual labelable element by ID. Per HTML LS §4.10.4: "If the attribute
- * is specified, the attribute's value must be the ID of a labelable
- * element in the same tree as the label element." Existence of the ID
- * itself is the responsibility of `no-refer-to-non-existent-id`; this
- * rule only checks the element type when the ID resolves.
+ * actual labelable element by ID. Per HTML LS §4.10.4:
+ *
+ * > If the attribute is specified, the attribute's value must be the ID of a labelable element in the same tree as the
+ * > label element.
+ *
+ * Existence of the ID itself is the responsibility of
+ * `no-refer-to-non-existent-id`; this rule only checks the element type
+ * when the ID resolves.
  *
  * @see https://html.spec.whatwg.org/multipage/forms.html#attr-label-for
  */

package/lib/label-for-references-labelable/index.js

@@ -25,11 +25,14 @@ const LABELABLE_SELECTOR = [
 ].join(',');
 /**
  * Require the `for` attribute on a `<label>` element to reference an
- * actual labelable element by ID. Per HTML LS §4.10.4: "If the attribute
- * is specified, the attribute's value must be the ID of a labelable
- * element in the same tree as the label element." Existence of the ID
- * itself is the responsibility of `no-refer-to-non-existent-id`; this
- * rule only checks the element type when the ID resolves.
+ * actual labelable element by ID. Per HTML LS §4.10.4:
+ *
+ * > If the attribute is specified, the attribute's value must be the ID of a labelable element in the same tree as the
+ * > label element.
+ *
+ * Existence of the ID itself is the responsibility of
+ * `no-refer-to-non-existent-id`; this rule only checks the element type
+ * when the ID resolves.
  *
  * @see https://html.spec.whatwg.org/multipage/forms.html#attr-label-for
  */

package/lib/landmark-roles/roles.js

@@ -39,7 +39,7 @@ document) {
      * > - section
      */
     const headers = [...document.querySelectorAll('header')].filter(header => {
-        return !header.closest('article, aside, main, nav, section');
+        return !header.closest('article, aside, main, nav, section') && !hasElement(roles.banner, header);
     });
     roles.banner.push(...headers);
     /**
@@ -55,11 +55,23 @@ document) {
      * > - section
      */
     const footers = [...document.querySelectorAll('footer')].filter(footer => {
-        return !footer.closest('article, aside, main, nav, section');
+        return !footer.closest('article, aside, main, nav, section') && !hasElement(roles.contentinfo, footer);
     });
     roles.contentinfo.push(...footers);
     return roles;
 }
+/**
+ * An element already collected through its explicit `role` attribute (e.g.
+ * `<header role="banner">`) must not be added a second time by the implicit
+ * `<header>` / `<footer>` lookup, or a lone landmark would count as a duplicate (#4180).
+ */
+function hasElement(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+elements, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+target) {
+    return elements.some(element => element.uuid === target.uuid);
+}
 /**
  * Collects all UUIDs of elements that have landmark roles.
  *

package/lib/map-id-name-match/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Require that a `<map>` element's `id` attribute, when present, has
- * the same value as its `name` attribute. Per HTML LS §4.8.13:
- * "If the id attribute is also specified, both attributes must have
- * the same value."
+ * the same value as its `name` attribute. Per HTML LS §4.8.12:
+ *
+ * > If the id attribute is also specified, both attributes must have the same value.
  *
  * @see https://html.spec.whatwg.org/multipage/image-maps.html#the-map-element
  */

package/lib/map-id-name-match/index.js

@@ -2,9 +2,9 @@ import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
  * Require that a `<map>` element's `id` attribute, when present, has
- * the same value as its `name` attribute. Per HTML LS §4.8.13:
- * "If the id attribute is also specified, both attributes must have
- * the same value."
+ * the same value as its `name` attribute. Per HTML LS §4.8.12:
+ *
+ * > If the id attribute is also specified, both attributes must have the same value.
  *
  * @see https://html.spec.whatwg.org/multipage/image-maps.html#the-map-element
  */

package/lib/no-ambiguous-navigable-target-names/index.js

@@ -1,5 +1,6 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { valueCheck } from '../attr-check.js';
+import { findAttrSpec } from '../helpers.js';
 import meta from './meta.js';
 export default createRule({
     meta: meta,
@@ -13,7 +14,7 @@ export default createRule({
             if (!attrSpecs) {
                 return;
             }
-            const attrSpec = attrSpecs.find(spec => spec.name === attr.name);
+            const attrSpec = findAttrSpec(attrSpecs, attr);
             if (attrSpec?.type !== 'NavigableTargetNameOrKeyword' && attrSpec?.type !== 'NavigableTargetName') {
                 return;
             }

package/lib/no-aria-hidden-on-hidden-until-found/index.d.ts

@@ -1,12 +1,15 @@
 import type { Options } from '../wai-aria/types.js';
 /**
- * ARIA in HTML §"Rules of ARIA attribute usage by HTML feature", the `hidden` row:
- * "authors MUST NOT use `aria-hidden="true"` on any element which also has the
- * `hidden` attribute specified in the Hidden Until Found state." Content revealed
- * by the browser's find-in-page feature would otherwise stay excluded from the
- * accessibility tree, silently breaking that reveal for assistive technology users.
+ * ARIA in HTML, section Rules of ARIA attribute usage by HTML feature, the `hidden` row:
  *
- * @see https://w3c.github.io/html-aria/#att-hidden
+ * > Authors MUST NOT use `aria-hidden="true"` on any element which also has the `hidden` attribute specified in the
+ * > Hidden Until Found state.
+ *
+ * Content revealed by the browser's find-in-page feature would otherwise stay
+ * excluded from the accessibility tree, silently breaking that reveal for
+ * assistive technology users.
+ *
+ * @see https://www.w3.org/TR/html-aria/#att-hidden
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/no-aria-hidden-on-hidden-until-found/index.js

@@ -2,13 +2,16 @@ import { createRule } from '@markuplint/ml-core';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
 /**
- * ARIA in HTML §"Rules of ARIA attribute usage by HTML feature", the `hidden` row:
- * "authors MUST NOT use `aria-hidden="true"` on any element which also has the
- * `hidden` attribute specified in the Hidden Until Found state." Content revealed
- * by the browser's find-in-page feature would otherwise stay excluded from the
- * accessibility tree, silently breaking that reveal for assistive technology users.
+ * ARIA in HTML, section Rules of ARIA attribute usage by HTML feature, the `hidden` row:
  *
- * @see https://w3c.github.io/html-aria/#att-hidden
+ * > Authors MUST NOT use `aria-hidden="true"` on any element which also has the `hidden` attribute specified in the
+ * > Hidden Until Found state.
+ *
+ * Content revealed by the browser's find-in-page feature would otherwise stay
+ * excluded from the accessibility tree, silently breaking that reveal for
+ * assistive technology users.
+ *
+ * @see https://www.w3.org/TR/html-aria/#att-hidden
  */
 export default createRule({
     meta,

package/lib/no-aria-hidden-on-hidden-until-found/meta.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     readonly specConformance: {
         readonly sources: readonly ["aria-in-html"];
         readonly level: "must";
-        readonly cites: readonly ["https://w3c.github.io/html-aria/#att-hidden"];
+        readonly cites: readonly ["https://www.w3.org/TR/html-aria/#att-hidden"];
     };
 };
 export default _default;

package/lib/no-aria-hidden-on-hidden-until-found/meta.js

@@ -3,6 +3,6 @@ export default {
     specConformance: {
         sources: ['aria-in-html'],
         level: 'must',
-        cites: ['https://w3c.github.io/html-aria/#att-hidden'],
+        cites: ['https://www.w3.org/TR/html-aria/#att-hidden'],
     },
 };

package/lib/no-aria-on-presentational-children/index.js

@@ -13,7 +13,9 @@ export default createRule({
                 return;
             if (!elSpec.globalAttrs['#ARIAAttrs'])
                 return;
-            report(checkingPresentationalChildren({ el }));
+            for (const attr of el.attributes) {
+                report(checkingPresentationalChildren({ attr, el }));
+            }
         });
     },
 });

package/lib/no-aria-on-unsupported-element/index.js

@@ -1,5 +1,5 @@
 import { createRule, getSpec } from '@markuplint/ml-core';
-import { Collection } from '../helpers.js';
+import { Collection, isAriaAttr } from '../helpers.js';
 import meta from './meta.js';
 /**
  * Extracted from the former `wai-aria` umbrella rule (#3989), which always
@@ -22,7 +22,7 @@ export default createRule({
                 return;
             }
             const roleAttr = el.getAttributeNode('role');
-            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            const propAttrs = el.attributes.filter(attr => isAriaAttr(attr));
             const ariaAttrs = new Collection(roleAttr, ...propAttrs);
             for (const ariaAttr of ariaAttrs) {
                 report({

package/lib/no-aria-on-unsupported-element/meta.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     readonly specConformance: {
         readonly sources: readonly ["aria-in-html"];
         readonly level: "must";
-        readonly cites: readonly ["https://w3c.github.io/html-aria/#docconformance"];
+        readonly cites: readonly ["https://www.w3.org/TR/html-aria/#docconformance"];
     };
 };
 export default _default;

package/lib/no-aria-on-unsupported-element/meta.js

@@ -3,6 +3,6 @@ export default {
     specConformance: {
         sources: ['aria-in-html'],
         level: 'must',
-        cites: ['https://w3c.github.io/html-aria/#docconformance'],
+        cites: ['https://www.w3.org/TR/html-aria/#docconformance'],
     },
 };

package/lib/no-boolean-attr-value/index.js

@@ -1,5 +1,5 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
-import { removeAttrValue } from '../helpers.js';
+import { findAttrSpec, removeAttrValue } from '../helpers.js';
 import meta from './meta.js';
 export default createRule({
     meta: meta,
@@ -14,7 +14,7 @@ export default createRule({
                 return;
             }
             const name = attr.name;
-            const spec = attrSpec.find(s => s.name === name);
+            const spec = findAttrSpec(attrSpec, attr);
             if (!spec) {
                 return;
             }