@markuplint/rules 5.5.0 → 5.6.0

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 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

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

@@ -13,7 +13,7 @@ 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`);
+            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;
             }

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/form-attr-references-form/index.js

@@ -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,5 +1,5 @@
 import type { FixToken, IRuleFixer, PlainData, TextEdit } from '@markuplint/ml-config';
-import type { Attr, Element, RuleConfigValue } 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';
@@ -21,6 +21,38 @@ export { getDOMValue };
  * @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}).
  *
@@ -156,6 +188,27 @@ export declare function match(needle: string, pattern: string): boolean;
  */
 export declare const rePCENChar: string;
 export declare function toNormalizedValue(value: string, spec: Attribute): string;
+/**
+ * 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

package/lib/helpers.js

@@ -26,6 +26,57 @@ el, reference, isExpression = false) {
     }
     return 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 function isRenderedAway(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    if (el.isFragment) {
+        return true;
+    }
+    if (el.localName !== 'template') {
+        return false;
+    }
+    for (const attr of el.attributes) {
+        if (attr.isDirective && attr.localName !== '#spread') {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 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 function isUnknownOutput(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    return !isRenderedAway(el) && el.isUnresolvedComponent();
+}
 /**
  * The elements that match the selector in the tree `el` is in (see {@link getElementByIdInTree}).
  *
@@ -319,18 +370,60 @@ export function toNormalizedValue(value, spec) {
     }
     return normalized;
 }
+/**
+ * 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 function mayRenderUnknownChildren(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node, components = true) {
+    if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+        return !node.blockBehavior;
+    }
+    return node.is(node.ELEMENT_NODE) && (node.localName === 'slot' || (components && node.isUnresolvedComponent()));
+}
 export function accnameMayBeMutable(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el) {
-    if (el.hasMutableAttributes() || el.hasMutableChildren(true)) {
+    if (el.hasMutableAttributes() || el.hasMutableChildren(true, isSlotOfUnknownAssignment)) {
         return true;
     }
     const ownedLabel = getOwnedLabel(el);
-    if (ownedLabel && (ownedLabel.hasMutableAttributes() || ownedLabel.hasMutableChildren(true))) {
+    if (ownedLabel &&
+        (ownedLabel.hasMutableAttributes() || ownedLabel.hasMutableChildren(true, isSlotOfUnknownAssignment))) {
         return true;
     }
     return false;
 }
+/**
+ * Whether a `slot` renders what the markup does not tell: the nodes assigned to it, or its children, are
+ * not known (`MLElement#getAssignedNodes` is `null`). A slot whose assignment is known renders them, which
+ * the rule reads itself.
+ *
+ * @param slot - A `slot` element
+ * @returns `true` if what the slot renders is not known
+ */
+function isSlotOfUnknownAssignment(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+slot) {
+    return slot.getAssignedNodes() === null;
+}
 /**
  * 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
@@ -371,12 +464,15 @@ el) {
  * whose computed name is empty is not reported: the rule calls this only after
  * the computed name is empty. Light DOM text that remains in the computed name
  * is still a name, and the rule does not reach this function.
+ *
+ * Unknown `contents` of a pretended component count only when no declarative
+ * shadow root is attached to it: the shadow root is rendered in their place.
  */
 function hasUnknownContent(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el) {
     const context = el.pretenderContext;
-    if (context?.type === 'pretender' && context.slotContent?.mutable) {
+    if (context?.type === 'pretender' && context.slotContent?.mutable && !el.declarativeShadowRoot) {
         return true;
     }
     if (context?.type !== 'pretender' && el.isHTMLTemplateElement && el.declarativeShadowRootAttachment === 'unknown') {

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

@@ -40,7 +40,7 @@ export default createRule({
                     line: listAttr.valueNode?.startLine,
                     col: listAttr.valueNode?.startCol,
                     raw: listAttr.valueNode?.raw,
-                    message: t('The "{0}" attribute of the "{1}" element must reference a "{2}" element', 'list', 'input', 'datalist'),
+                    message: t('The "{0*}" attribute of the "{1*}" element must reference a "{2*}" element', 'list', 'input', 'datalist'),
                 });
             }
         });

package/lib/itemprop-requires-itemscope/index.js

@@ -62,7 +62,7 @@ export default createRule({
             if (!hasAncestorScope && !isItemrefTarget && !treesWithDynamicItemref.has(el.getRootNode())) {
                 report({
                     scope: el,
-                    message: t('{0} must {1}', t('the {0}', 'element'), 'belong to an item via an ancestor `itemscope` or be referenced by an `itemref`'),
+                    message: t('{0} must belong to an item via an ancestor `itemscope` or be referenced by an `itemref`', t('the {0}', 'element')),
                 });
             }
         }

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

@@ -63,7 +63,7 @@ export default createRule({
                     line: forAttr.valueNode?.startLine,
                     col: forAttr.valueNode?.startCol,
                     raw: forAttr.valueNode?.raw,
-                    message: t('The "{0}" attribute of the "{1}" element must reference a labelable element', 'for', 'label'),
+                    message: t('The "{0*}" attribute of the "{1*}" element must reference a labelable element', 'for', 'label'),
                 });
             }
         });

package/lib/label-no-multiple-controls/index.js

@@ -86,7 +86,7 @@ export default createRule({
                 for (const control of controls) {
                     report({
                         scope: control,
-                        message: t('The "{0}" element must not contain a form-control descendant when the "{1}" attribute references an external labelable element', 'label', 'for'),
+                        message: t('The "{0*}" element must not contain a form-control descendant when the "{1*}" attribute references an external labelable element', 'label', 'for'),
                     });
                 }
                 return;
@@ -96,7 +96,7 @@ export default createRule({
             for (const control of controls.slice(1)) {
                 report({
                     scope: control,
-                    message: t('The "{0}" element may contain at most one form-control descendant ({1})', 'label', 'button, input, meter, output, progress, select, or textarea'),
+                    message: t('The "{0*}" element may contain at most one form-control descendant ({1})', 'label', 'button, input, meter, output, progress, select, or textarea'),
                 });
             }
         });

package/lib/link-types/index.js

@@ -122,28 +122,28 @@ function validateWhatwgKeyword(def, context, t) {
     switch (context) {
         case 'link': {
             if (def.link === 'not allowed') {
-                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+                return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'link', 'element'));
             }
             return null;
         }
         case 'body-link': {
             if (def.link === 'not allowed') {
-                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+                return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'link', 'element'));
             }
             if (def.bodyOk !== 'Yes') {
-                return t('The "{0*}" {1} is not allowed on the {2} inside the {3}', def.keyword, 'keyword', '"link" element', '"body" element');
+                return t('The "{0*}" {1} is not allowed on {2} inside {3}', def.keyword, 'keyword', t('the "{0*}" {1}', 'link', 'element'), t('the "{0*}" {1}', 'body', 'element'));
             }
             return null;
         }
         case 'a-area': {
             if (def.a === 'not allowed') {
-                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"a" element');
+                return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'a', 'element'));
             }
             return null;
         }
         case 'form': {
             if (def.form === 'not allowed') {
-                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"form" element');
+                return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'form', 'element'));
             }
             return null;
         }
@@ -161,19 +161,19 @@ function validateMicroformatContext(def, context, t) {
         case 'link':
         case 'body-link': {
             if (!def.link) {
-                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+                return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'link', 'element'));
             }
             return null;
         }
         case 'a-area': {
             if (!def.a) {
-                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"a" element');
+                return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'a', 'element'));
             }
             return null;
         }
         case 'form': {
             // Microformats don't define form context; reject
-            return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"form" element');
+            return t('The "{0*}" {1} is not allowed on {2}', def.keyword, 'keyword', t('the "{0*}" {1}', 'form', 'element'));
         }
     }
 }

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

@@ -39,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-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-disallowed-ancestor/index.js

@@ -1,5 +1,6 @@
 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
@@ -40,7 +41,7 @@ export default createRule({
                     (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;
                 }
@@ -58,12 +59,8 @@ export default createRule({
  *   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, which the walk skips as if it
- *   were not there and does not judge:
- *   - 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.
+ * - `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
@@ -71,17 +68,9 @@ export default createRule({
 function getAncestorKind(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 ancestor) {
-    if (ancestor.isFragment) {
+    if (isRenderedAway(ancestor)) {
         return 'transparent';
     }
-    if (ancestor.localName !== 'template') {
-        return 'element';
-    }
-    for (const attr of ancestor.attributes) {
-        if (attr.isDirective) {
-            return 'transparent';
-        }
-    }
     return ancestor.isHTMLTemplateElement ? 'template-content' : 'element';
 }
 /**

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

@@ -29,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-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-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-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-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),
             });
         }
     },

package/lib/no-redundant-accessible-name/index.js

@@ -2,6 +2,12 @@ import { createRule, getComputedRole } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION, isExposed } from '@markuplint/ml-spec';
 import { accnameMayBeMutable, getElementByIdInTree, getOwnedLabel } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * Labels are names (shown as written, `{n*}`) except `content`, which is a word and is translated.
+ */
+function showLabel(t, label) {
+    return label === 'content' ? t('content') : label;
+}
 export default createRule({
     meta,
     defaultSeverity: 'warning',
@@ -32,7 +38,7 @@ export default createRule({
                 for (const loser of overridden) {
                     report({
                         scope: el,
-                        message: t('The accessible name from "{0*}" overrides "{1*}"', winner.label, loser.label),
+                        message: t('The accessible name from "{0*}" overrides "{1*}"', showLabel(t, winner.label), showLabel(t, loser.label)),
                     });
                 }
             }

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

@@ -2,6 +2,7 @@ import { createRule } from '@markuplint/ml-core';
 import { check, isEnum, isPattern } from '@markuplint/types';
 import { attrCheck } from '../attr-check.js';
 import { createNameOptionLookup } from '../helpers.js';
+import { noTranslate } from '../no-translate.js';
 import meta from './meta.js';
 export default createRule({
     meta: meta,
@@ -73,7 +74,7 @@ type) {
         return t('{0} is matched with the below disallowed patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), type.pattern);
     }
     if (typeof type !== 'string' && isEnum(type)) {
-        return t('{0} is disallowed to accept the following values: {1}', t('the "{0*}" {1}', name, 'attribute'), t(type.enum));
+        return t('{0} is disallowed to accept the following values: {1}', t('the "{0*}" {1}', name, 'attribute'), t(type.enum.map(noTranslate)));
     }
     return t('{0} is disallowed', t('{0} of {1}', t('the {0}', 'type'), t('the "{0*}" {1}', name, 'attribute')));
 }