@markuplint/rules 5.4.0 → 5.6.0

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

@@ -32,7 +32,7 @@ export default createRule({
                 line: idAttr.valueNode?.startLine,
                 col: idAttr.valueNode?.startCol,
                 raw: idAttr.valueNode?.raw,
-                message: t('The "{0}" attribute on a "{1}" element must have the same value as the "{2}" attribute', 'id', 'map', 'name'),
+                message: t('The "{0*}" attribute on a "{1*}" element must have the same value as the "{2*}" attribute', 'id', 'map', 'name'),
             });
         });
     },

package/lib/meter-value-bounds/index.js

@@ -65,9 +65,9 @@ export default createRule({
             const valueValue = valueNum ?? minValue;
             const reportLE = (lowerName, lowerAttr, upperName, upperAttr, upperDefault) => {
                 const upperDesc = upperAttr
-                    ? t('the value of the "{0}" attribute', upperName)
-                    : t('{0} when the "{1}" attribute is absent', upperDefault === 1 ? 'one' : String(upperDefault), upperName);
-                const message = t('The value of the "{0}" attribute must be less than or equal to {1}', lowerName, upperDesc);
+                    ? t('the value of the "{0*}" attribute', upperName)
+                    : t('{0} when the "{1*}" attribute is absent', upperDefault === 1 ? 'one' : String(upperDefault), upperName);
+                const message = t('The value of the "{0*}" attribute must be less than or equal to {1}', lowerName, upperDesc);
                 const scope = lowerAttr ?? upperAttr;
                 if (scope) {
                     report({

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

@@ -10,6 +10,10 @@ export default createRule({
             if (!attr.valueNode) {
                 return;
             }
+            // The value of an attribute that is not known, or that is not output, is not a name to judge
+            if (attr.isDynamicValue) {
+                return;
+            }
             const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
             if (!attrSpecs) {
                 return;
@@ -35,7 +39,7 @@ export default createRule({
                 raw: attr.valueNode.raw,
                 message: 
                 //
-                t("don't use {0}", t('a {0}', t('ambiguous {0}', 'navigable target name'))) +
+                t("don't use {0}", t('an {0}', t('ambiguous {0}', 'navigable target name'))) +
                     (attrSpec.type === 'NavigableTargetNameOrKeyword'
                         ? t('. ') + t('Did you mean "{0}"?', valueWithUnderscore)
                         : ''),

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

@@ -31,7 +31,7 @@ export default createRule({
             }
             report({
                 scope: ariaHidden,
-                message: t('"aria-hidden" must not be "{0}" on an element with "hidden" value "{1}"', 'true', 'until-found'),
+                message: t('"aria-hidden" must not be "{0*}" on an element with "hidden" value "{1*}"', 'true', 'until-found'),
             });
         });
     },

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

@@ -14,6 +14,10 @@ export default createRule({
             if (!elSpec.globalAttrs['#ARIAAttrs'])
                 return;
             for (const attr of el.attributes) {
+                // An attribute that the framework does not output is not an attribute of the element
+                if (attr.isAbsent) {
+                    continue;
+                }
                 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, isAriaAttr } from '../helpers.js';
+import { Collection, getAriaAttrs } 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 => isAriaAttr(attr));
+            const propAttrs = getAriaAttrs(el);
             const ariaAttrs = new Collection(roleAttr, ...propAttrs);
             for (const ariaAttr of ariaAttrs) {
                 report({

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

@@ -10,7 +10,8 @@ export default createRule({
             if (!attrSpec) {
                 return;
             }
-            if (attr.isDynamicValue) {
+            // The value of an expression is not written as the value of an HTML attribute
+            if (attr.isExpressionValue) {
                 return;
             }
             const name = attr.name;

package/lib/no-broken-fragment-link/index.d.ts

@@ -1,4 +1,9 @@
 /**
+ * The target of a fragment link is an element of the document tree: the content of a `template`
+ * element and a shadow root are not where the navigation scrolls to. So the ids and names are the ones
+ * of the document (`document.querySelectorAll`, not the other trees), and a link in any tree is checked
+ * against them. A dynamic id in the document, not in another tree, stops the check.
+ *
  * Split out of the former `no-refer-to-non-existent-id` rule. Unlike the
  * `DOMID`-typed attributes and ARIA ID references that rule covers, HTML LS
  * does not treat a broken hyperlink fragment as a conformance violation —

package/lib/no-broken-fragment-link/index.js

@@ -4,6 +4,11 @@ import meta from './meta.js';
 /** CSS selector matching hyperlink elements that have an `href` attribute. */
 const HYPERLINK_SELECTOR = 'a[href], area[href]';
 /**
+ * The target of a fragment link is an element of the document tree: the content of a `template`
+ * element and a shadow root are not where the navigation scrolls to. So the ids and names are the ones
+ * of the document (`document.querySelectorAll`, not the other trees), and a link in any tree is checked
+ * against them. A dynamic id in the document, not in another tree, stops the check.
+ *
  * Split out of the former `no-refer-to-non-existent-id` rule. Unlike the
  * `DOMID`-typed attributes and ARIA ID references that rule covers, HTML LS
  * does not treat a broken hyperlink fragment as a conformance violation —
@@ -38,7 +43,8 @@ export default createRule({
                 hasDynamicId = true;
             }
             if (attr.valueType !== 'code') {
-                idList.add(decodeEntities(attr.value));
+                // An expression is code, not markup: its string has no character reference to decode
+                idList.add(attr.isExpressionValue ? attr.value : decodeEntities(attr.value));
             }
         }
         if (hasDynamicId) {
@@ -53,7 +59,7 @@ export default createRule({
                 hasDynamicName = true;
             }
             if (attr.valueType !== 'code') {
-                nameList.add(decodeEntities(attr.value));
+                nameList.add(attr.isExpressionValue ? attr.value : decodeEntities(attr.value));
             }
         }
         await document.walkOn('Element', el => {

package/lib/no-consecutive-br/index.js

@@ -4,7 +4,7 @@ export default createRule({
     meta: meta,
     defaultSeverity: 'warning',
     verify({ document, report, t }) {
-        const brList = [...document.querySelectorAll('br')];
+        const brList = [...document.deepQuerySelectorAll('br')];
         for (const br of brList) {
             let next = br.nextSibling;
             while (next && next.is(next.TEXT_NODE) && !next.nodeValue?.trim()) {

package/lib/no-content-after-body/index.js

@@ -36,14 +36,14 @@ export default createRule({
             if (child.is(child.ELEMENT_NODE)) {
                 report({
                     scope: child,
-                    message: t('Content after the end tag of the "{0}" element is not allowed', 'body'),
+                    message: t('Content after the end tag of the "{0*}" element is not allowed', 'body'),
                 });
                 continue;
             }
             if (child.is(child.TEXT_NODE) && child.raw.trim() !== '') {
                 report({
                     scope: child,
-                    message: t('Content after the end tag of the "{0}" element is not allowed', 'body'),
+                    message: t('Content after the end tag of the "{0*}" element is not allowed', 'body'),
                 });
             }
         }

package/lib/no-contradictory-aria-prop/index.js

@@ -2,7 +2,7 @@ import { createRule, ariaSpecs, getAttrSpecs, getSpec } from '@markuplint/ml-cor
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingContradictoryAriaProp } from '../wai-aria/checkings/contradictory-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-implicit-props` rule (#3989): the
@@ -21,7 +21,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/no-default-aria-value/index.js

@@ -2,7 +2,7 @@ import { createRule, ariaSpecs, getSpec } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingDefaultValue } from '../wai-aria/checkings/default-value.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,
@@ -15,7 +15,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/no-default-value/index.js

@@ -10,6 +10,10 @@ export default createRule({
             if (!attrSpec) {
                 return;
             }
+            // The value of an attribute that is not known, or that is not output, is not the default value
+            if (attr.isDynamicValue) {
+                return;
+            }
             const spec = findAttrSpec(attrSpec, attr);
             if (!spec) {
                 return;

package/lib/no-deprecated-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 { checkingDeprecatedProps } from '../wai-aria/checkings/deprecated-props.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,
@@ -15,7 +15,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/no-disallowed-ancestor/index.d.ts

@@ -1,2 +1,17 @@
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+import type { RuleConfigValue } from '@markuplint/ml-core';
+/**
+ * Checks the ancestors of an element against its content model, which holds them in two forms
+ * that this rule reads together: `forbiddenAncestors` (a deny list, any one match is a violation)
+ * and `permittedAncestors` (an allow list, an ancestor that matches none is a violation).
+ * The walk goes up from the parent and reports the nearest ancestor that violates, once.
+ *
+ * It does not enter the content of a `template` element, and it does not judge a node that is not
+ * an element of the document (a fragment, a `template` that a template engine drops): see
+ * {@link getAncestorKind}.
+ *
+ * Known limitation: `:aria(has no name)` in an entry reads a dynamic value of `aria-label` or
+ * `title` as a name, as the accessible name computation does, so `<form aria-label={x}><main>`
+ * is reported although `x` may be empty at runtime and the form then has no name.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RuleConfigValue, undefined>>;
 export default _default;

package/lib/no-disallowed-ancestor/index.js

@@ -1,20 +1,47 @@
 import { createRule } from '@markuplint/ml-core';
+import { getSpecByTagName } from '@markuplint/ml-spec';
+import { isRenderedAway } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * Checks the ancestors of an element against its content model, which holds them in two forms
+ * that this rule reads together: `forbiddenAncestors` (a deny list, any one match is a violation)
+ * and `permittedAncestors` (an allow list, an ancestor that matches none is a violation).
+ * The walk goes up from the parent and reports the nearest ancestor that violates, once.
+ *
+ * It does not enter the content of a `template` element, and it does not judge a node that is not
+ * an element of the document (a fragment, a `template` that a template engine drops): see
+ * {@link getAncestorKind}.
+ *
+ * Known limitation: `:aria(has no name)` in an entry reads a dynamic value of `aria-label` or
+ * `title` as a name, as the accessible name computation does, so `<form aria-label={x}><main>`
+ * is reported although `x` may be empty at runtime and the form then has no name.
+ */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
-            const elSpec = document.specs.specs.find(s => s.name === el.localName);
-            const forbiddenAncestors = elSpec?.contentModel?.forbiddenAncestors;
-            if (!forbiddenAncestors || forbiddenAncestors.length === 0) {
+            const contentModel = getSpecByTagName(document.specs.specs, el.localName, el.namespaceURI)?.contentModel;
+            const forbiddenAncestors = contentModel?.forbiddenAncestors ?? [];
+            const permittedAncestors = contentModel?.permittedAncestors;
+            if (forbiddenAncestors.length === 0 && !permittedAncestors) {
                 return;
             }
             let ancestor = el.parentElement;
             while (ancestor) {
-                if (forbiddenAncestors.some(selector => ancestor.matches(selector))) {
+                const kind = getAncestorKind(ancestor);
+                if (kind === 'template-content') {
+                    break;
+                }
+                if (kind === 'transparent') {
+                    ancestor = ancestor.parentElement;
+                    continue;
+                }
+                const current = ancestor;
+                if (forbiddenAncestors.some(selector => current.matches(selector)) ||
+                    (permittedAncestors && !matchesPermitted(current, permittedAncestors))) {
                     report({
                         scope: el,
-                        message: t('{0} must not appear as a descendant of {1}', t('the "{0}" {1}', el.localName, 'element'), t('the "{0}" {1}', ancestor.localName, 'element')),
+                        message: t('{0} must not appear as a descendant of {1}', t('the "{0*}" {1}', el.localName, 'element'), t('the "{0*}" {1}', ancestor.localName, 'element')),
                     });
                     break;
                 }
@@ -23,3 +50,39 @@ export default createRule({
         });
     },
 });
+/**
+ * What `ancestor` is for the walk up the tree.
+ *
+ * - `template-content`: an HTML `template` element (`isHTMLTemplateElement`). The elements in its
+ *   content belong to a separate `DocumentFragment`, so they have no ancestors in the document:
+ *   `<section><template><main></main></template></section>` has a `main` element with none.
+ *   markuplint holds the content as children of the `template` element, so the walk stops here.
+ *   A `template` of a framework that puts the children in the element itself (React, Vue: the
+ *   `templateContent` of its spec) is an `element` below: the children are in the document.
+ * - `transparent`: a node that is not an element of the document ({@link isRenderedAway}), which
+ *   the walk skips as if it were not there and does not judge.
+ * - `element`: any other element.
+ *
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
+ */
+function getAncestorKind(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+ancestor) {
+    if (isRenderedAway(ancestor)) {
+        return 'transparent';
+    }
+    return ancestor.isHTMLTemplateElement ? 'template-content' : 'element';
+}
+/**
+ * Whether `ancestor` matches an entry of `permittedAncestors`.
+ *
+ * `#custom` is not a selector: the element decides it, as the `:model()` pseudo-class does
+ * for the `#custom` of a content model category (`isCustomElement` follows the pretender).
+ * It is read only here: in `forbiddenAncestors` every entry is a selector, so `#custom` there
+ * is an id selector.
+ */
+function matchesPermitted(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+ancestor, selectors) {
+    return selectors.some(selector => (selector === '#custom' ? ancestor.isCustomElement : ancestor.matches(selector)));
+}

package/lib/no-disallowed-attr/index.js

@@ -14,6 +14,10 @@ export default createRule({
             if (attr.isDirective) {
                 return;
             }
+            // An attribute that the framework does not output (`async={false}`) is not an attribute of the element
+            if (attr.isAbsent) {
+                return;
+            }
             const name = attr.name;
             const attrName = attr.nameNode;
             // https://html.spec.whatwg.org/multipage/custom-elements.html#attr-is
@@ -25,7 +29,7 @@ export default createRule({
                     line: attrName?.startLine,
                     col: attrName?.startCol,
                     raw: attrName?.raw,
-                    message: t('The "{0}" attribute must not be specified on an autonomous custom element', 'is'),
+                    message: t('The "{0*}" attribute must not be specified on an autonomous custom element', 'is'),
                 });
                 return;
             }

package/lib/no-duplicate-autofocus/index.js

@@ -31,7 +31,7 @@ export default createRule({
             if (seenScopingRoots.has(scopingRoot)) {
                 report({
                     scope: el,
-                    message: t('The "{0}" attribute must be unique in the document', 'autofocus'),
+                    message: t('The "{0*}" attribute must be unique in the document', 'autofocus'),
                 });
                 continue;
             }

package/lib/no-duplicate-dt/index.js

@@ -4,7 +4,7 @@ export default createRule({
     meta: meta,
     defaultSeverity: 'warning',
     verify({ document, report, t }) {
-        const dlList = [...document.querySelectorAll('dl')];
+        const dlList = [...document.deepQuerySelectorAll('dl')];
         for (const dl of dlList) {
             const dtList = [...dl.querySelectorAll(':scope > dt, :scope > div > dt')];
             const names = new Set();

package/lib/no-duplicate-h1/index.js

@@ -15,27 +15,31 @@ export default createRule({
     defaultOptions: {
         'in-document-fragment': false,
     },
-    async verify({ document, report, t }) {
-        const h1Stack = [];
+    verify({ document, report, t }) {
         if (document.nodeList.length === 0) {
             return;
         }
         if (!document.rule.options['in-document-fragment'] && document.isFragment) {
             return;
         }
-        await document.walkOn('Element', node => {
-            if (node.nodeName.toLowerCase() === 'h1') {
-                h1Stack.push(node);
+        // The h1 elements are counted by tree: the content of a `template` element and a declarative
+        // shadow root are trees of their own, where it is not known from the markup where they are inserted
+        const h1sOfTree = new Map();
+        for (const h1 of document.deepQuerySelectorAll('h1')) {
+            const root = h1.getRootNode();
+            h1sOfTree.set(root, [...(h1sOfTree.get(root) ?? []), h1]);
+        }
+        for (const h1Stack of h1sOfTree.values()) {
+            const duplicated = h1Stack[1];
+            if (duplicated) {
+                const message = t('{0} is {1:c}', t('the "{0*}" {1}', 'h1', 'element'), 'duplicated');
+                report({
+                    message,
+                    line: duplicated.startLine,
+                    col: duplicated.startCol,
+                    raw: duplicated.raw,
+                });
             }
-        });
-        if (h1Stack.length > 1 && h1Stack[1]) {
-            const message = t('{0} is {1:c}', t('the "{0*}" {1}', 'h1', 'element'), 'duplicated');
-            report({
-                message,
-                line: h1Stack[1].startLine,
-                col: h1Stack[1].startCol,
-                raw: h1Stack[1].raw,
-            });
         }
     },
 });

package/lib/no-duplicate-id/index.d.ts

@@ -1,2 +1,11 @@
+/**
+ * An id is unique in its tree, not in the file: the content of a `template` element and a
+ * declarative shadow root are trees of their own, where an id may repeat one of another tree.
+ * The ids are grouped by `getRootNode()`, and compared after the character references are
+ * resolved (`ab` is `ab`), as the DOM has them.
+ *
+ * @see https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute
+ * @see https://dom.spec.whatwg.org/#concept-tree
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/no-duplicate-id/index.js

@@ -1,18 +1,37 @@
 import { createRule } from '@markuplint/ml-core';
+import { getDOMValue } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * An id is unique in its tree, not in the file: the content of a `template` element and a
+ * declarative shadow root are trees of their own, where an id may repeat one of another tree.
+ * The ids are grouped by `getRootNode()`, and compared after the character references are
+ * resolved (`ab` is `ab`), as the DOM has them.
+ *
+ * @see https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute
+ * @see https://dom.spec.whatwg.org/#concept-tree
+ */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {
         const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'value'), t('the "{0*}" {1}', 'id', 'attribute')), 'duplicated');
-        const idStack = [];
+        const idsOfTree = new Map();
         await document.walkOn('Element', node => {
             const idAttrs = node.getAttributeToken('id');
             for (const idAttr of idAttrs) {
                 if (idAttr.isDynamicValue || idAttr.isDirective) {
                     continue;
                 }
-                const id = idAttr.value;
-                if (idStack.includes(id)) {
+                const id = getDOMValue(idAttr);
+                if (id == null) {
+                    continue;
+                }
+                const root = node.getRootNode();
+                let ids = idsOfTree.get(root);
+                if (!ids) {
+                    ids = new Set();
+                    idsOfTree.set(root, ids);
+                }
+                if (ids.has(id)) {
                     report({
                         scope: node,
                         message,
@@ -21,7 +40,7 @@ export default createRule({
                         raw: idAttr.raw,
                     });
                 }
-                idStack.push(id);
+                ids.add(id);
             }
         });
     },

package/lib/no-duplicate-sibling-attr/index.js

@@ -26,7 +26,7 @@ export default createRule({
                 if (hasPrecedingDuplicate) {
                     report({
                         scope: el,
-                        message: t('The "{0}" attribute must not appear on more than one "{1}" element within the same parent', attrName, el.localName),
+                        message: t('The "{0*}" attribute must not appear on more than one "{1*}" element within the same parent', attrName, el.localName),
                     });
                 }
             }

package/lib/no-duplicate-visible-main/index.js

@@ -20,7 +20,7 @@ export default createRule({
         for (const el of visibleMains.slice(1)) {
             report({
                 scope: el,
-                message: t('There must not be more than one visible "{0}" element in a document', 'main'),
+                message: t('There must not be more than one visible "{0*}" element in a document', 'main'),
             });
         }
     },

package/lib/no-empty-table-track/index.js

@@ -18,7 +18,7 @@ import meta from './meta.js';
 export default createRule({
     meta,
     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/no-extra-selected-options/index.js

@@ -29,7 +29,7 @@ export default createRule({
             for (const opt of selected.slice(1)) {
                 report({
                     scope: opt,
-                    message: t('The "{0}" element cannot have more than one selected "{1}" descendant unless the "{2}" attribute is specified', 'select', 'option', 'multiple'),
+                    message: t('The "{0*}" element cannot have more than one selected "{1*}" descendant unless the "{2*}" attribute is specified', 'select', 'option', 'multiple'),
                 });
             }
         });

package/lib/no-ineffective-attr/index.js

@@ -7,6 +7,10 @@ export default createRule({
     defaultSeverity: 'warning',
     async verify({ document, report, t }) {
         await document.walkOn('Attr', attr => {
+            // An attribute that the framework does not output (`defer={false}`) is not an attribute of the element
+            if (attr.isAbsent) {
+                return;
+            }
             const attrSpec = getAttrSpecs(attr.ownerElement, document.specs);
             if (!attrSpec) {
                 return;

package/lib/no-input-file-value/index.js

@@ -40,7 +40,7 @@ export default createRule({
                 line: valueAttr.valueNode?.startLine,
                 col: valueAttr.valueNode?.startCol,
                 raw: valueAttr.valueNode?.raw,
-                message: t('The "{0}" attribute on a "{1}" element with "{2}={3}" must be the empty string', 'value', 'input', 'type', 'file'),
+                message: t('The "{0*}" attribute on a "{1*}" element with "{2*}={3*}" must be the empty string', 'value', 'input', 'type', 'file'),
             });
         });
     },

package/lib/no-invalid-aria-prop-value/index.js

@@ -2,7 +2,7 @@ import { createRule, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingValue } from '../wai-aria/checkings/value.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,14 +14,14 @@ 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;
             const computed = getComputedRole(document.specs, el, ariaVersion);
             const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
             for (const attr of propAttrs) {
-                report(checkingValue({ attr, role: computed.role, propSpecs, booleanish: document.booleanish }));
+                report(checkingValue({ attr, role: computed.role, propSpecs }));
             }
         });
     },

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

@@ -53,6 +53,18 @@ export default createRule({
                 if (one === false || one.invalidType !== 'invalid-value') {
                     continue;
                 }
+                // The value of an expression is what the code results in, so a position in it is not a position
+                // in the source (an escape, a quote): the whole value that is written is reported
+                if (attr.isExpressionValue && valueNode) {
+                    report({
+                        scope: attr,
+                        message: one.message,
+                        line: valueNode.startLine,
+                        col: valueNode.startCol,
+                        raw: valueNode.raw,
+                    });
+                    continue;
+                }
                 report({
                     scope: attr,
                     message: one.message,

package/lib/no-malformed-character-reference/index.js

@@ -31,7 +31,7 @@ export default createRule({
                 line: pe.startLine,
                 col: pe.startCol,
                 raw: pe.raw,
-                message: t('{0} is {1:c}', t('the {0}', 'character reference'), pe.code),
+                message: t('{0} is {1*}', t('the {0}', 'character reference'), pe.code),
             });
         }
     },