@markuplint/ml-spec 5.5.0 → 5.6.1

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.6.1](https://github.com/markuplint/markuplint/compare/v5.6.0...v5.6.1) (2026-11-13)
+
+### Bug Fixes
+
+* **ml-spec:** let a directive pattern declare the key of its repeat ([df95b4c](https://github.com/markuplint/markuplint/commit/df95b4cd56753fa4c665991f6bc091e4c0620225))
+
+
+# [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)
+* **ml-spec:** follow a light child to the slot that takes it ([5269f1f](https://github.com/markuplint/markuplint/commit/5269f1f3892df6e383a9f08de6ccb07f71b5cfb9))
+
+
 # [5.5.0](https://github.com/markuplint/markuplint/compare/v5.4.0...v5.5.0) (2026-11-10)
 
 ### Bug Fixes

package/lib/algorithm/aria/get-computed-role.js

@@ -3,7 +3,7 @@ import { isPresentational } from './is-presentational.js';
 import { SVG_NAMESPACE } from '../../const/index.js';
 import { hasSvgAccessibleNameSource } from './accname/svg-helpers.js';
 import { getAttrSpecs } from '../../utils/get-attr-specs.js';
-import { getComposedParentElement } from '../dom/tree-boundary.js';
+import { getAccessibilityParentElement, getComposedParentElement } from '../dom/tree-boundary.js';
 import { getExplicitRole } from './get-explicit-role.js';
 import { getImplicitRole } from './get-implicit-role.js';
 import { getNonPresentationalAncestor } from './get-non-presentational-ancestor.js';
@@ -325,7 +325,7 @@ el, specs, version) {
     if (!computedRole.role?.isImplicit) {
         return false;
     }
-    const parent = getComposedParentElement(el);
+    const parent = getAccessibilityParentElement(el);
     if (!parent) {
         return false;
     }

package/lib/algorithm/aria/get-non-presentational-ancestor.d.ts

@@ -3,7 +3,7 @@ import type { ARIAVersion, MLMLSpec } from '../../types/index.js';
  * In ARIA 1.3, `generic` role elements are additionally transparent for
  * ownership traversal.
  *
- * The ancestors are those of the accessibility tree: see {@link getComposedParentElement}.
+ * The ancestors are those of the accessibility tree: see {@link getAccessibilityParentElement}.
  */
 export declare function getNonPresentationalAncestor(el: Element, specs: MLMLSpec, version: ARIAVersion): import("../../types/index.js").ComputedRole | {
     el: null;

package/lib/algorithm/aria/get-non-presentational-ancestor.js

@@ -1,16 +1,16 @@
-import { getComposedParentElement } from '../dom/tree-boundary.js';
+import { getAccessibilityParentElement } from '../dom/tree-boundary.js';
 import { isTransparentForOwnership } from './is-presentational.js';
 import { getComputedRole } from './get-computed-role.js';
 /**
  * In ARIA 1.3, `generic` role elements are additionally transparent for
  * ownership traversal.
  *
- * The ancestors are those of the accessibility tree: see {@link getComposedParentElement}.
+ * The ancestors are those of the accessibility tree: see {@link getAccessibilityParentElement}.
  */
 export function getNonPresentationalAncestor(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, specs, version) {
-    let ancestor = getComposedParentElement(el);
+    let ancestor = getAccessibilityParentElement(el);
     /**
      * In ARIA 1.1 and 1.2, the role of an element is not affected by the role of its ancestor elements.
      *
@@ -22,7 +22,7 @@ el, specs, version) {
         if (!isTransparentForOwnership(ancestorRole.role?.name, version)) {
             return ancestorRole;
         }
-        ancestor = getComposedParentElement(ancestor);
+        ancestor = getAccessibilityParentElement(ancestor);
     }
     return {
         el: ancestor,

package/lib/algorithm/aria/is-exposed.js

@@ -1,5 +1,5 @@
 import { ariaSpecs } from './aria-specs.js';
-import { getComposedParentElement } from '../dom/tree-boundary.js';
+import { getComposedParentElement, isNotRendered } from '../dom/tree-boundary.js';
 import { getSpecByTagName } from '../../utils/get-spec-by-tag-name.js';
 import { isPresentational } from './is-presentational.js';
 import { resolveNamespace } from '../../utils/resolve-namespace.js';
@@ -66,11 +66,16 @@ el, specs, version) {
      *   that have host language semantics specifying
      *   that the element is not displayed, such as CSS display:none,
      *   visibility:hidden, or the HTML hidden attribute.
+     *
+     * An element that is not in the flat tree is not displayed either: a light child of a shadow host
+     * that no slot takes.
      */
     {
         let currentEl = el;
         while (currentEl) {
-            if (hasDisplayNodeOrVisibilityHidden(currentEl) || currentEl.hasAttribute('hidden')) {
+            if (isNotRendered(currentEl) ||
+                hasDisplayNodeOrVisibilityHidden(currentEl) ||
+                currentEl.hasAttribute('hidden')) {
                 return true;
             }
             currentEl = getComposedParentElement(currentEl);

package/lib/algorithm/aria/matches-context-role.d.ts

@@ -11,6 +11,7 @@ import type { ARIAVersion, MLMLSpec } from '../../types/index.js';
  * `aria-owns` attributes, which is a separate architectural concern.
  * See also: `has-required-owned-elements.ts` has a similar limitation.
  *
- * The chain is the one the accessibility tree is built from ({@link getComposedParentElement}).
+ * The chain is the one the accessibility tree is built from ({@link getAccessibilityParentElement}), which
+ * does not have a `slot`.
  */
 export declare function matchesContextRole(conditions: readonly string[], ownedEl: Element, specs: MLMLSpec, version: ARIAVersion): boolean;

package/lib/algorithm/aria/matches-context-role.js

@@ -1,4 +1,4 @@
-import { getComposedParentElement } from '../dom/tree-boundary.js';
+import { getAccessibilityParentElement } from '../dom/tree-boundary.js';
 import { isTransparentForOwnership } from './is-presentational.js';
 import { getComputedRole } from './get-computed-role.js';
 /**
@@ -13,12 +13,13 @@ import { getComputedRole } from './get-computed-role.js';
  * `aria-owns` attributes, which is a separate architectural concern.
  * See also: `has-required-owned-elements.ts` has a similar limitation.
  *
- * The chain is the one the accessibility tree is built from ({@link getComposedParentElement}).
+ * The chain is the one the accessibility tree is built from ({@link getAccessibilityParentElement}), which
+ * does not have a `slot`.
  */
 export function matchesContextRole(conditions, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 ownedEl, specs, version) {
-    return conditions.some(condition => matchesCondition(condition, getComposedParentElement(ownedEl), specs, version));
+    return conditions.some(condition => matchesCondition(condition, getAccessibilityParentElement(ownedEl), specs, version));
 }
 function matchesCondition(condition, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -50,14 +51,14 @@ parentEl, specs, version) {
          * @see https://w3c.github.io/aria/#scope
          */
         if (isTransparentForOwnership(parentRole?.name, version)) {
-            parentEl = getComposedParentElement(parentEl);
+            parentEl = getAccessibilityParentElement(parentEl);
             continue;
         }
         const condition = conditions.shift();
         if (condition !== parentRole?.name) {
             return false;
         }
-        parentEl = getComposedParentElement(parentEl);
+        parentEl = getAccessibilityParentElement(parentEl);
     }
     return true;
 }

package/lib/algorithm/dom/tree-boundary.d.ts

@@ -1,47 +1,3 @@
-/**
- * @module
- *
- * The parent of an element as the DOM sees it, for the algorithms that walk up from an element.
- *
- * The algorithms of this package are written against the DOM `Element`, where `parentElement`
- * stops at the boundary of a tree: the parent element of a node whose parent is not an element
- * (a document fragment, such as the content of a `template` element or a shadow root) is `null`.
- * `@markuplint/ml-core` hands them its own elements, whose `parentElement` is the syntactical
- * parent: the syntax tree has no other place for the content of a `template` element than its
- * children, so the top of the content has the `template` element as its parent element. A walk
- * that reads `parentElement` there leaves the content and enters the tree that holds the
- * `template`. `getRootNode()` is where `@markuplint/ml-core` puts the boundary, and in a real DOM
- * a parent is always in the tree of its child, so comparing the two roots gives the DOM's answer
- * to both.
- *
- * This package cannot use `MLNode#treeParentElement` of `@markuplint/ml-core`, which depends on it,
- * so the helpers derive the same answer from `getRootNode()`. The two are pinned to agree by
- * `tree-scope.spec.ts` of `@markuplint/ml-core`: a change to the boundary in one belongs to both.
- *
- * Which of the two helpers a walk takes depends on what it follows:
- *
- * - {@link getTreeParentElement} follows a relation that the DOM defines in the tree, such as
- *   the ancestor `label` element of a labelable element (`findAncestorLabel`, the one walk of
- *   this package that does not follow the accessibility tree).
- * - {@link getComposedParentElement} follows what the accessibility tree is built from. Its
- *   content is the flat tree: the content of a shadow root is rendered in its host, so the
- *   elements above it are the host and the ancestors of the host. The content of an ordinary
- *   `template` element is not rendered, and where it is inserted is not known from the markup,
- *   so a walk ends at its top.
- *
- * A `template` element that may have a declarative shadow root but whose attachment is not known
- * from the markup (a host that is not in the file, a component, or a dynamic `shadowrootmode`),
- * or that fails to attach one, is treated as an ordinary `template` element: a walk ends at the
- * top of its content.
- *
- * Known limitation: the flat tree places the content of a shadow root where the `slot` element
- * is, between the host and the nodes the host has as children. A walk goes from the top of the
- * shadow root to the host and does not model the position of the `slot`.
- *
- * @see https://dom.spec.whatwg.org/#parent-element
- * @see https://dom.spec.whatwg.org/#concept-shadow-including-ancestor
- * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
- */
 /**
  * What the helpers read of an element: the DOM `Element`, and `MLElement` of `@markuplint/ml-core`.
  * An element without `getRootNode` (an adapter that has no notion of a tree boundary) is in one
@@ -51,6 +7,18 @@ type TreeElement = {
     readonly parentElement: unknown;
     getRootNode?(): unknown;
 };
+/**
+ * What {@link getComposedParentElement} reads besides {@link TreeElement}: the slot that places the
+ * element in the flat tree. `null` is an element of a shadow host that no slot takes (not rendered),
+ * `undefined` an element that is not one or whose assignment is not known.
+ *
+ * @template P - The type of the parent element the element reads
+ */
+type FlatTreeElement<P extends TreeElement> = {
+    readonly parentElement: P | null;
+    getRootNode?(): unknown;
+    getFlatTreeSlot?(): P | null | undefined;
+};
 /**
  * The parent element of an element in its own tree, which is what the DOM calls `parentElement`:
  * `null` at the top of the content of a `template` element or of a shadow root, even where the
@@ -68,16 +36,13 @@ export declare function getTreeParentElement<P extends TreeElement>(el: {
  * The parent element of an element as the accessibility tree is built: the parent element in its own
  * tree, or, at the top of a shadow root, the host of the shadow root. `null` at the top of the content
  * of an ordinary `template` element, and at the top of a document or of any other root that is not a
- * shadow root.
+ * shadow root. For a light child of a shadow host, the slot that takes it, or `null` when none does.
  *
  * @template P - The type of the parent element the element reads
  * @param el - The element to start from
  * @returns The parent element or the shadow host, or `null` when the walk ends
  */
-export declare function getComposedParentElement<P extends TreeElement>(el: {
-    readonly parentElement: P | null;
-    getRootNode?(): unknown;
-}): P | null;
+export declare function getComposedParentElement<P extends TreeElement>(el: FlatTreeElement<P>): P | null;
 /**
  * Whether a root is a shadow root: a document fragment that has a host.
  * The shadow root of `@markuplint/ml-core` is not a `ShadowRoot` of the DOM by class, and the
@@ -90,4 +55,54 @@ export declare function getComposedParentElement<P extends TreeElement>(el: {
 export declare function isShadowRoot<P = unknown>(root: unknown): root is {
     readonly host: P;
 };
+/**
+ * Whether an element is a `slot` element of the HTML namespace, which the accessibility tree does not
+ * map: it has no role of its own, and what it renders (the nodes assigned to it, or its children)
+ * belongs to the parent of the `slot`. A walk up the ancestors of the accessibility tree that reads
+ * roles passes through it. The walks that read an attribute of the ancestors (`hidden`, `aria-hidden`)
+ * do not skip it: what a `slot` that has them renders is hidden as well.
+ *
+ * It does not look at `MLParser#slotElement` on purpose: the `slot` of a framework (Vue, Svelte, Astro)
+ * is replaced with what it is given, so it is no element of the accessibility tree either, and the
+ * pass-through is right for it too. Which `slot` has an assignment is `MLElement#getAssignedNodes` of
+ * `@markuplint/ml-core`, which does look at it.
+ *
+ * > No corresponding role
+ *
+ * @param el - An element
+ * @returns `true` for the `slot` element of the HTML namespace
+ * @see https://w3c.github.io/html-aam/#el-slot
+ * @see https://dom.spec.whatwg.org/#find-flattened-slotables
+ */
+export declare function isSlotElement(el: {
+    readonly localName: string;
+    readonly namespaceURI?: string | null;
+}): boolean;
+/**
+ * Whether an element is not rendered: it is a light child of a shadow host, and no slot of the shadow
+ * root takes it (`getFlatTreeSlot()` is `null`). The flat tree has no place for it, so it is not in the
+ * accessibility tree either, whatever its host is.
+ *
+ * @param el - An element
+ * @returns `true` for an element that is known not to be rendered
+ * @see https://dom.spec.whatwg.org/#find-flattened-slotables
+ */
+export declare function isNotRendered(el: object): boolean;
+/**
+ * The parent element of an element in the accessibility tree: the composed parent element
+ * ({@link getComposedParentElement}) with the `slot` elements passed through ({@link isSlotElement}). The walks
+ * that read the roles of the ancestors take it; the walks that read an attribute of the ancestors take
+ * {@link getComposedParentElement}, as what a `slot` that has `hidden` renders is hidden.
+ *
+ * @template E - The type of the element
+ * @param el - The element to start from
+ * @returns The parent element, or `null` when the walk ends
+ */
+export declare function getAccessibilityParentElement<E extends {
+    readonly parentElement: E | null;
+    readonly localName: string;
+    readonly namespaceURI?: string | null;
+    getRootNode?(): unknown;
+    getFlatTreeSlot?(): E | null | undefined;
+}>(el: E): E | null;
 export {};

package/lib/algorithm/dom/tree-boundary.js

@@ -1,3 +1,4 @@
+import { XHTML_NAMESPACE } from '../../const/dom.js';
 /**
  * @module
  *
@@ -34,10 +35,22 @@
  * or that fails to attach one, is treated as an ordinary `template` element: a walk ends at the
  * top of its content.
  *
- * Known limitation: the flat tree places the content of a shadow root where the `slot` element
- * is, between the host and the nodes the host has as children. A walk goes from the top of the
- * shadow root to the host and does not model the position of the `slot`.
+ * The flat tree renders a light child of a shadow host where the `slot` element that takes it is,
+ * so the parent of the child is that `slot`: `getFlatTreeSlot()` of `@markuplint/ml-core` tells it
+ * (the named slot assignment of the shadow root). A child that no slot takes is not rendered, so a
+ * walk ends there as it does at the top of the content of an ordinary `template` element. Where the
+ * assignment is not known (`undefined`: manual assignment, a name written as code, a slot of a
+ * framework), the walk goes to the host as it does for any other child. The `slot` element itself
+ * is an element that is not mapped to the accessibility tree, which the algorithms of this package
+ * pass through (`isSlotElement`).
  *
+ * Known limitation: a walk from the top of the shadow root goes to the host and does not model where
+ * the `slot` sits in the shadow root, so the elements of the shadow root that are above the `slot` are
+ * not between the host and a light child the `slot` takes. The fallback content of a slot that takes
+ * nodes is not rendered either, and a walk from it still goes through the `slot`.
+ *
+ * @see https://dom.spec.whatwg.org/#find-a-slot
+ * @see https://dom.spec.whatwg.org/#find-flattened-slotables
  * @see https://dom.spec.whatwg.org/#parent-element
  * @see https://dom.spec.whatwg.org/#concept-shadow-including-ancestor
  * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
@@ -68,13 +81,17 @@ export function getTreeParentElement(el) {
  * The parent element of an element as the accessibility tree is built: the parent element in its own
  * tree, or, at the top of a shadow root, the host of the shadow root. `null` at the top of the content
  * of an ordinary `template` element, and at the top of a document or of any other root that is not a
- * shadow root.
+ * shadow root. For a light child of a shadow host, the slot that takes it, or `null` when none does.
  *
  * @template P - The type of the parent element the element reads
  * @param el - The element to start from
  * @returns The parent element or the shadow host, or `null` when the walk ends
  */
 export function getComposedParentElement(el) {
+    const slot = el.getFlatTreeSlot?.();
+    if (slot !== undefined) {
+        return slot;
+    }
     const parent = getTreeParentElement(el);
     if (parent) {
         return parent;
@@ -101,3 +118,55 @@ export function isShadowRoot(root) {
         root.nodeType === DOCUMENT_FRAGMENT_NODE &&
         'host' in root);
 }
+/**
+ * Whether an element is a `slot` element of the HTML namespace, which the accessibility tree does not
+ * map: it has no role of its own, and what it renders (the nodes assigned to it, or its children)
+ * belongs to the parent of the `slot`. A walk up the ancestors of the accessibility tree that reads
+ * roles passes through it. The walks that read an attribute of the ancestors (`hidden`, `aria-hidden`)
+ * do not skip it: what a `slot` that has them renders is hidden as well.
+ *
+ * It does not look at `MLParser#slotElement` on purpose: the `slot` of a framework (Vue, Svelte, Astro)
+ * is replaced with what it is given, so it is no element of the accessibility tree either, and the
+ * pass-through is right for it too. Which `slot` has an assignment is `MLElement#getAssignedNodes` of
+ * `@markuplint/ml-core`, which does look at it.
+ *
+ * > No corresponding role
+ *
+ * @param el - An element
+ * @returns `true` for the `slot` element of the HTML namespace
+ * @see https://w3c.github.io/html-aam/#el-slot
+ * @see https://dom.spec.whatwg.org/#find-flattened-slotables
+ */
+export function isSlotElement(el) {
+    return el.localName === 'slot' && el.namespaceURI === XHTML_NAMESPACE;
+}
+/**
+ * Whether an element is not rendered: it is a light child of a shadow host, and no slot of the shadow
+ * root takes it (`getFlatTreeSlot()` is `null`). The flat tree has no place for it, so it is not in the
+ * accessibility tree either, whatever its host is.
+ *
+ * @param el - An element
+ * @returns `true` for an element that is known not to be rendered
+ * @see https://dom.spec.whatwg.org/#find-flattened-slotables
+ */
+export function isNotRendered(el) {
+    // The DOM `Element` has no `getFlatTreeSlot`: only the element of `@markuplint/ml-core` knows it
+    return el.getFlatTreeSlot?.() === null;
+}
+/**
+ * The parent element of an element in the accessibility tree: the composed parent element
+ * ({@link getComposedParentElement}) with the `slot` elements passed through ({@link isSlotElement}). The walks
+ * that read the roles of the ancestors take it; the walks that read an attribute of the ancestors take
+ * {@link getComposedParentElement}, as what a `slot` that has `hidden` renders is hidden.
+ *
+ * @template E - The type of the element
+ * @param el - The element to start from
+ * @returns The parent element, or `null` when the walk ends
+ */
+export function getAccessibilityParentElement(el) {
+    let parent = getComposedParentElement(el);
+    while (parent && isSlotElement(parent)) {
+        parent = getComposedParentElement(parent);
+    }
+    return parent;
+}

package/lib/types/index.d.ts

@@ -155,11 +155,58 @@ export type DirectivePattern = {
      */
     readonly valueType?: 'string' | 'number' | 'boolean' | 'code';
     /**
-     * If true, the attribute can appear multiple times on the same element.
-     * Can also be a string array of potentialName values for which
-     * duplication is allowed (e.g., ['class', 'style']).
+     * If true, the attribute is not a repeat of an attribute of the same name (`:class` beside `class`,
+     * which Vue merges). Can also be a string array of potentialName values for which this holds
+     * (e.g., ['class', 'style']).
+     *
+     * It is not whether the attribute may be written twice: that is told by {@link DirectivePattern.duplicateKey}
+     * (without it, the same spelling of a name that is not `true` is a repeat, and `true` is never one).
      */
     readonly isDuplicatable?: true | readonly string[];
+    /**
+     * The key under which the framework counts this directive as written twice, as a template that takes the
+     * captures of `pattern` (`$1`, `$2`, …) as they are spelled. Two attributes of an element with the same key
+     * are a repeat, whatever name the directive resolves to (`potentialName`): a framework tells a repeat by
+     * what it keeps of the name, and a directive is not an attribute of the DOM.
+     *
+     * Without it, a pattern is keyed by the name as it is written (how a framework that rejects only the
+     * same spelling of a directive tells a repeat), except a pattern with `isDuplicatable: true`, which is
+     * never a repeat (a framework that takes any number of the same directive).
+     *
+     * @example "$1" -- the key of `:view-box.camel` is its argument, `view-box` (with `duplicateKeyModifiers`, `viewBox`)
+     */
+    readonly duplicateKey?: string;
+    /**
+     * Modifiers of the directive that change {@link DirectivePattern.duplicateKey}: the modifiers are those
+     * written after the name, and a framework gives two spellings of a name that differ in them the same key
+     * (the order of them, a modifier that it does not know) or a different one (a modifier that changes the
+     * name that is bound). Only the modifiers listed here count, and a modifier is matched as it is spelled.
+     */
+    readonly duplicateKeyModifiers?: {
+        /**
+         * The capture group of `pattern` that holds the modifiers, joined with `.` and starting with it (`.prop.camel`).
+         */
+        readonly group: number;
+        /**
+         * The modifiers that turn the template into camelCase before the prefixes are put in front of it.
+         */
+        readonly camelize?: readonly string[];
+        /**
+         * The prefix that a modifier puts in front of the key. They are put in the order listed, so that
+         * the first of the listed modifiers that is written is the outermost.
+         */
+        readonly prefixes?: readonly {
+            readonly modifier: string;
+            readonly prefix: string;
+        }[];
+        /**
+         * When no prefix is put in front of the key, it is the name of an attribute (`:id.foo` binds `id`), so
+         * the element folds its case as it does for any attribute and it is a repeat of that attribute
+         * written as such (`:id`). A key with a prefix is a property or a namespaced name, which
+         * keeps its case (`.id` and `.ID` are two).
+         */
+        readonly foldedWithoutPrefix?: true;
+    };
 };
 /**
  * Reference URLs

package/lib/types/permitted-structures.d.ts

@@ -12,7 +12,14 @@ export interface ContentModelsSchema {
 }
 export interface ContentModel {
     contents: PermittedContentPattern[] | boolean;
+    /**
+     * A CSS selector of the ancestor that this element must have. The ancestor is looked for in the tree of the element: the walk up the tree stops at the content of a `template` element.
+     */
     descendantOf?: string;
+    /**
+     * Whether `descendantOf` is required only of an element that has a parent node, as the HTML Standard says of the `area` element ("An area element with a parent node must have a map element ancestor"). The top of a partial or of a component has none in the file, so the element there is not reported.
+     */
+    descendantOfWithParentNode?: boolean;
     /**
      * Elements that this element must NOT appear as a descendant of. Each entry is a CSS selector matching forbidden ancestor elements. The walk up the tree stops at the content of a `template` element, which has no ancestors.
      */

package/lib/utils/directive-resolver.d.ts

@@ -22,6 +22,17 @@ export type DirectiveResolution = {
     readonly expressionLanguage?: ExpressionLanguage;
     readonly valueType?: 'string' | 'number' | 'boolean' | 'code';
     readonly isDuplicatable?: boolean;
+    /**
+     * Present only when the matched pattern decides it ({@link DirectivePattern.duplicateKey}): the key
+     * under which the directive counts as written twice, or `null` when it never does (a pattern that is
+     * `isDuplicatable: true` and declares no key). Absent, the key is the name as it is written.
+     */
+    readonly duplicateKey?: string | null;
+    /**
+     * Present only when the key is the name of an attribute that the element folds
+     * ({@link DirectivePattern.duplicateKeyModifiers}'s `foldedWithoutPrefix`) and no prefix is in front of it.
+     */
+    readonly duplicateKeyFolds?: true;
 };
 /**
  * Resolves an attribute name against a list of compiled directive patterns.

package/lib/utils/directive-resolver.js

@@ -1,3 +1,4 @@
+import { camelize } from '@markuplint/shared';
 const cache = new WeakMap();
 /**
  * Compiles directive patterns into RegExp objects, caching them
@@ -14,6 +15,33 @@ export function compileDirectivePatterns(patterns) {
     }
     return compiled;
 }
+/**
+ * The key of an attribute that a pattern gives, as {@link DirectivePattern.duplicateKey} says.
+ */
+function resolveDuplicateKey(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+pattern, match) {
+    if (pattern.duplicateKey == null) {
+        return { key: pattern.isDuplicatable === true ? null : undefined, folds: false };
+    }
+    const modifiers = pattern.duplicateKeyModifiers;
+    const written = new Set((modifiers ? (match[modifiers.group] ?? '') : '').split('.').filter(Boolean));
+    // Only what the directive writes is camelized (`transformBind` of Vue does so to the argument), not the
+    // text that the template puts around it
+    const camelized = modifiers?.camelize?.some(modifier => written.has(modifier)) === true;
+    const key = pattern.duplicateKey.replaceAll(/\$(\d+)/g, (_, idx) => {
+        const capture = match[Number(idx)] ?? '';
+        return camelized ? camelize(capture) : capture;
+    });
+    if (!modifiers) {
+        return { key, folds: false };
+    }
+    const prefix = (modifiers.prefixes ?? [])
+        .filter(({ modifier }) => written.has(modifier))
+        .map(({ prefix }) => prefix)
+        .join('');
+    return { key: prefix + key, folds: modifiers.foldedWithoutPrefix === true && prefix === '' };
+}
 /**
  * Resolves an attribute name against a list of compiled directive patterns.
  * Returns the first match's resolution, or null if no pattern matches.
@@ -38,6 +66,7 @@ compiledPatterns) {
         else if (Array.isArray(pattern.isDuplicatable) && potentialName) {
             isDuplicatable = pattern.isDuplicatable.includes(potentialName);
         }
+        const duplicateKey = resolveDuplicateKey(pattern, match);
         return {
             potentialName,
             isDirective: pattern.isDirective,
@@ -45,6 +74,8 @@ compiledPatterns) {
             valueType: pattern.valueType,
             isDuplicatable,
             ...(pattern.expressionLanguage ? { expressionLanguage: pattern.expressionLanguage } : {}),
+            ...(duplicateKey.key === undefined ? {} : { duplicateKey: duplicateKey.key }),
+            ...(duplicateKey.folds ? { duplicateKeyFolds: true } : {}),
         };
     }
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-spec",
-	"version": "5.5.0",
+	"version": "5.6.1",
 	"description": "Types and schema that specs of the Markup languages for markuplint",
 	"repository": {
 		"type": "git",
@@ -22,9 +22,6 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"typedoc": {
-		"entryPoint": "./src/index.ts"
-	},
 	"scripts": {
 		"build": "tsc --project tsconfig.build.json",
 		"dev": "tsc --watch --project tsconfig.build.json",
@@ -36,15 +33,15 @@
 		"schema:aria": "npx json2ts ./schemas/aria.schema.json --cwd ./schemas > ./src/types/aria.ts"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "5.5.0",
-		"@markuplint/shared": "5.5.0",
-		"@markuplint/types": "5.5.0",
+		"@markuplint/ml-ast": "5.6.0",
+		"@markuplint/shared": "5.6.0",
+		"@markuplint/types": "5.6.0",
 		"is-plain-object": "^5.1.0",
 		"type-fest": "^5.10.0"
 	},
 	"devDependencies": {
-		"@markuplint/test-tools": "5.5.0",
+		"@markuplint/test-tools": "5.6.1",
 		"json-schema-to-typescript": "16.0.0"
 	},
-	"gitHead": "fedebcfd56eaec4642e68643b2f9e10750d810e1"
+	"gitHead": "a9245162df3699c4880469f493aaaf6103343d83"
 }