@markuplint/ml-core 5.0.0 → 5.1.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.1.0](https://github.com/markuplint/markuplint/compare/v5.0.1...v5.1.0) (2026-10-08)
+
+### Bug Fixes
+
+- **ml-core:** compute the accessible name of a pretender from what it renders ([22ea8f9](https://github.com/markuplint/markuplint/commit/22ea8f9da831a06084e5748ec5db44c6e1e66e24)), closes [#4056](https://github.com/markuplint/markuplint/issues/4056)
+- **ml-core:** ignore the children of a component that never renders them in its name ([9867097](https://github.com/markuplint/markuplint/commit/986709732e69ed2bc63d7261efbaeb1567ab6505)), closes [#4056](https://github.com/markuplint/markuplint/issues/4056)
+- **ml-core:** mark the slot content mutable when any of several slots has unknown content ([b657ab9](https://github.com/markuplint/markuplint/commit/b657ab97de39242ba3d26d5484693230d89400aa))
+- **ml-core:** narrow getNodeStoreFor()'s parameter to MLDocument ([bbdbc44](https://github.com/markuplint/markuplint/commit/bbdbc444a2e5267418ef8adedb9e3e40aa42b6e6)), closes [#4081](https://github.com/markuplint/markuplint/issues/4081) [/github.com/markuplint/markuplint/pull/4081#discussion_r4162890932](https://github.com//github.com/markuplint/markuplint/pull/4081/issues/discussion_r4162890932)
+- **ml-core:** omit a forwarded attribute the usage site does not write ([7be4d86](https://github.com/markuplint/markuplint/commit/7be4d867ed95f6e50f68a7bd267bf693a18e7c4c))
+- **ml-core:** scope NodeStore per document instead of a process-wide singleton ([71e2042](https://github.com/markuplint/markuplint/commit/71e204262261ca4317bb1fbe8967e998dd24628f))
+
+### Features
+
+- **ml-core:** build slot wrappers and static contents for pretenders ([7770c19](https://github.com/markuplint/markuplint/commit/7770c197e76f6cc6f1f8380c4b8221d9e878e058)), closes [#4054](https://github.com/markuplint/markuplint/issues/4054)
+- **ml-core:** let setCode swap in pretenders within the same re-parse ([0b8a3c5](https://github.com/markuplint/markuplint/commit/0b8a3c5e8b9ce048dedae43e8ba1cc91f9ec5e31)), closes [#4064](https://github.com/markuplint/markuplint/issues/4064)
+
+## [5.0.1](https://github.com/markuplint/markuplint/compare/v5.0.0...v5.0.1) (2026-09-22)
+
+**Note:** Version bump only for package @markuplint/ml-core
+
 # [5.0.0](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.7...v5.0.0) (2026-09-11)
 
 **Note:** Version bump only for package @markuplint/ml-core

package/lib/index.d.ts

@@ -15,4 +15,4 @@ export type * from './types.js';
 export * from './utils/index.js';
 export * from './violation-collector.js';
 export * from './virtual-rule.js';
-export type { AccessibilityProperties } from './ml-dom/node/types.js';
+export type { AccessibilityProperties, PretenderSlotContent } from './ml-dom/node/types.js';

package/lib/ml-core.d.ts

@@ -1,5 +1,5 @@
 import type { MLFabric } from './types.js';
-import type { PlainData, RuleConfigValue, TextEdit, Violation } from '@markuplint/ml-config';
+import type { PlainData, Pretender, RuleConfigValue, TextEdit, Violation } from '@markuplint/ml-config';
 import { ParserError } from '@markuplint/parser-utils';
 import { Document } from './ml-dom/index.js';
 /**
@@ -96,9 +96,19 @@ export declare class MLCore {
     /**
      * Replaces the source code and re-parses the document.
      *
+     * `options.pretenders` is for a host that re-resolves pretenders from the
+     * new source (`pretenders.auto` and selector disambiguation both read the
+     * file's own imports, see #4064): they take effect in this same re-parse.
+     * Routing them through {@link update} instead would also reset
+     * `configErrors` / `ruleDeprecations` to whatever that call carries — and
+     * those are config-time values an edit of the source does not change.
+     *
      * @param sourceCode - The new markup source code
+     * @param options - `pretenders` replaces the current pretenders; omitted, they are kept
      */
-    setCode(sourceCode: string): void;
+    setCode(sourceCode: string, options?: {
+        readonly pretenders?: readonly Pretender[];
+    }): void;
     /**
      * Updates the linting configuration and re-creates the document.
      * Only re-parses if parser options have changed.

package/lib/ml-core.js

@@ -115,10 +115,21 @@ export class MLCore {
     /**
      * Replaces the source code and re-parses the document.
      *
+     * `options.pretenders` is for a host that re-resolves pretenders from the
+     * new source (`pretenders.auto` and selector disambiguation both read the
+     * file's own imports, see #4064): they take effect in this same re-parse.
+     * Routing them through {@link update} instead would also reset
+     * `configErrors` / `ruleDeprecations` to whatever that call carries — and
+     * those are config-time values an edit of the source does not change.
+     *
      * @param sourceCode - The new markup source code
+     * @param options - `pretenders` replaces the current pretenders; omitted, they are kept
      */
-    setCode(sourceCode) {
+    setCode(sourceCode, options) {
         this.#sourceCode = sourceCode;
+        if (options?.pretenders) {
+            this.#pretenders = [...options.pretenders];
+        }
         this.#parse();
         this.#createDocument();
     }

package/lib/ml-dom/helper/accname.js

@@ -78,5 +78,21 @@ el, version) {
             const attrValue = targetEl.getAttributePretended(attrName);
             return attrValue || null;
         },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        getChildNodes(target) {
+            // TODO: Remove cast when AccnameResolver is generic (#3178)
+            const targetEl = target;
+            const context = targetEl.pretenderContext;
+            if (context?.type !== 'pretender') {
+                return targetEl.childNodes;
+            }
+            // The children the component renders: `as.childNodes` is empty when it never
+            // renders its children (`slots: null`), so text written inside `<Img>Save</Img>`
+            // does not become its name.
+            const given = [...context.as.childNodes];
+            // A pretended component renders its own elements (`contents`) around the
+            // children given at the usage site; the name can come from either.
+            return context.slotContent ? context.slotContent.fill(given) : given;
+        },
     };
 }

package/lib/ml-dom/node/element.d.ts

@@ -57,6 +57,12 @@ export declare class MLElement<T extends RuleConfigValue, O extends PlainData =
      * The virtual element created by `pretending()` is not registered in the
      * document's `nodeList`; walkers visit only the original element, which
      * delegates its name and attribute getters to the virtual element.
+     *
+     * The children a rule should validate are not `as.childNodes` (which mirrors
+     * only whether the component accepts children). They are
+     * `slotContent.fill(childNodes)` when the pretender describes `slots` /
+     * `contents`, because the component renders its own elements around the
+     * children given at the usage site.
      */
     pretenderContext: PretenderContext<MLElement<T, O>, T, O> | null;
     /**

package/lib/ml-dom/node/element.js

@@ -1,4 +1,5 @@
 /* global StylePropertyMap, StylePropertyMapReadOnly */
+var _a;
 import { getSpecByTagName, resolveNamespace } from '@markuplint/ml-spec';
 import { matchSelector } from '@markuplint/selector';
 import { getAccname } from '../helper/accname.js';
@@ -85,6 +86,12 @@ export class MLElement extends MLParentNode {
      * The virtual element created by `pretending()` is not registered in the
      * document's `nodeList`; walkers visit only the original element, which
      * delegates its name and attribute getters to the virtual element.
+     *
+     * The children a rule should validate are not `as.childNodes` (which mirrors
+     * only whether the component accepts children). They are
+     * `slotContent.fill(childNodes)` when the pretender describes `slots` /
+     * `contents`, because the component renders its own elements around the
+     * children given at the usage site.
      */
     pretenderContext = null;
     /**
@@ -2902,62 +2909,12 @@ export class MLElement extends MLParentNode {
                 attributes.push(...this._astToken.attributes);
             }
             if (pretenderElement.attrs) {
-                attributes.push(...pretenderElement.attrs.map(({ name, value }, i) => {
-                    const _value = value == null
-                        ? ''
-                        : typeof value === 'string'
-                            ? value
-                            : (this.getAttribute(value.fromAttr) ?? '');
-                    return {
-                        ...this._astToken,
-                        uuid: `${this.uuid}_attr_${i}`,
-                        type: 'attr',
-                        nodeName: name,
-                        spacesBeforeName: {
-                            ...this._astToken,
-                            raw: '',
-                        },
-                        name: {
-                            ...this._astToken,
-                            raw: name,
-                        },
-                        spacesBeforeEqual: {
-                            ...this._astToken,
-                            raw: '',
-                        },
-                        equal: {
-                            ...this._astToken,
-                            raw: '',
-                        },
-                        spacesAfterEqual: {
-                            ...this._astToken,
-                            raw: '',
-                        },
-                        startQuote: {
-                            ...this._astToken,
-                            raw: '',
-                        },
-                        value: {
-                            ...this._astToken,
-                            raw: _value,
-                        },
-                        endQuote: {
-                            ...this._astToken,
-                            raw: '',
-                        },
-                        isDuplicatable: true,
-                        parentNode: null,
-                        nextNode: null,
-                        prevNode: null,
-                        isFragment: false,
-                        isGhost: false,
-                    };
-                }));
+                attributes.push(...this.#createPretenderAttrs(pretenderElement.attrs, this.uuid));
             }
             aria = pretenderElement.aria;
         }
         const slots = typeof pretenderElement === 'string' ? undefined : pretenderElement.slots;
-        const as = new MLElement({
+        const as = new _a({
             ...this._astToken,
             uuid: this.uuid + '_pretender',
             raw: `<${nodeName}>`,
@@ -2978,10 +2935,179 @@ export class MLElement extends MLParentNode {
             type: 'origin',
             origin: this,
         };
+        const slotContent = typeof pretenderElement === 'string' ? undefined : this.#createSlotContent(pretenderElement, as, namespace);
         this.pretenderContext = {
             type: 'pretender',
             as,
             aria,
+            ...(slotContent ? { slotContent } : {}),
+        };
+    }
+    /**
+     * Converts pretender attributes to AST attributes for a virtual element.
+     *
+     * `{ fromAttr }` reads this (the origin) element's attribute. When that attribute is an
+     * expression (`kind={kind}`), the result is dynamic as well: the value the component
+     * receives is unknown, and the source text of the expression is not a value to validate.
+     * When the attribute is not written and `omitIfMissing` is set, the virtual element gets
+     * no such attribute, as a component that forwards an `undefined` prop renders none.
+     * Without `omitIfMissing`, it is an empty attribute.
+     *
+     * `{ dynamic: true }` yields an attribute flagged `isDynamicValue`, which rules do not
+     * validate.
+     */
+    #createPretenderAttrs(attrs, uuidBase) {
+        return attrs.flatMap(({ name, value }, i) => {
+            let isDynamic = value != null && typeof value === 'object' && 'dynamic' in value;
+            let _value = '';
+            if (typeof value === 'string') {
+                _value = value;
+            }
+            else if (value != null && 'fromAttr' in value) {
+                const fromAttr = value.fromAttr.toLowerCase();
+                const origin = this.#attributes.find(attr => attr.name.toLowerCase() === fromAttr);
+                if (!origin && value.omitIfMissing) {
+                    return [];
+                }
+                if (origin?.isDynamicValue) {
+                    isDynamic = true;
+                }
+                else {
+                    _value = origin?.value ?? '';
+                }
+            }
+            return [
+                {
+                    ...this._astToken,
+                    uuid: `${uuidBase}_attr_${i}`,
+                    type: 'attr',
+                    nodeName: name,
+                    spacesBeforeName: {
+                        ...this._astToken,
+                        raw: '',
+                    },
+                    name: {
+                        ...this._astToken,
+                        raw: name,
+                    },
+                    spacesBeforeEqual: {
+                        ...this._astToken,
+                        raw: '',
+                    },
+                    equal: {
+                        ...this._astToken,
+                        raw: '',
+                    },
+                    spacesAfterEqual: {
+                        ...this._astToken,
+                        raw: '',
+                    },
+                    startQuote: {
+                        ...this._astToken,
+                        raw: '',
+                    },
+                    value: {
+                        ...this._astToken,
+                        raw: _value,
+                    },
+                    endQuote: {
+                        ...this._astToken,
+                        raw: '',
+                    },
+                    isDuplicatable: true,
+                    ...(isDynamic ? { isDynamicValue: true } : {}),
+                    parentNode: null,
+                    nextNode: null,
+                    prevNode: null,
+                    isFragment: false,
+                    isGhost: false,
+                },
+            ];
+        });
+    }
+    /**
+     * Creates a childless virtual element that is not registered in the document's
+     * `nodeList`, used for a slot wrapper or a static entry of `contents`.
+     * Its close tag is deliberately dropped (`pairNodeUuid: null`): the MLElement
+     * constructor would otherwise re-register the origin's real close tag under
+     * the virtual element.
+     */
+    #createVirtualElement(spec, uuid, parentNodeUuid, fallbackNamespace) {
+        const attributes = [];
+        if (spec.inheritAttrs) {
+            attributes.push(...this._astToken.attributes);
+        }
+        if (spec.attrs) {
+            attributes.push(...this.#createPretenderAttrs(spec.attrs, uuid));
+        }
+        const virtual = new _a({
+            ...this._astToken,
+            uuid,
+            raw: `<${spec.element}>`,
+            nodeName: spec.element,
+            namespace: getVirtualNamespace(spec, fallbackNamespace),
+            elementType: spec.element.includes('-') ? 'web-component' : 'html',
+            attributes,
+            childNodes: [],
+            pairNodeUuid: null,
+            parentNodeUuid,
+        }, this.ownerMLDocument);
+        virtual.resetChildren(toNodeList([]));
+        // Like the pretender element `as`, it stands for this element, so that a report
+        // on it can be moved to where the user wrote the component.
+        virtual.pretenderContext = { type: 'origin', origin: this };
+        return virtual;
+    }
+    /**
+     * Builds {@link PretenderSlotContent} from the pretender definition.
+     * Returns `undefined` when the definition says nothing about what surrounds
+     * the children, so that the children given at the usage site stay the whole
+     * content of the outermost element (the bare-string pretender behavior).
+     */
+    #createSlotContent(node, as, namespace) {
+        const { slots } = node;
+        let wrapper = as;
+        let contents = node.contents;
+        if (slots != null && slots !== true && slots.length > 0) {
+            const [slot] = slots;
+            if (slots.length > 1 || !slot) {
+                // The wrapper of each child is unknown, so the children are not validated,
+                // but a slot may still render unknown content (which may be a name).
+                return {
+                    wrapper: null,
+                    mutable: slots.some(s => s.contents?.some(entry => 'dynamic' in entry) ?? false),
+                    fill: (given) => given,
+                };
+            }
+            wrapper = this.#createVirtualElement(slot, `${this.uuid}_pretender_slot`, this.uuid, namespace);
+            contents = slot.contents ?? [{ slot: true }];
+        }
+        if (!contents) {
+            return undefined;
+        }
+        const entries = contents.map((entry, i) => 'element' in entry
+            ? this.#createVirtualElement(entry, `${this.uuid}_pretender_content_${i}`, wrapper === as ? this.uuid : wrapper.uuid, namespace)
+            : entry);
+        return {
+            wrapper,
+            mutable: entries.some(entry => !(entry instanceof _a) && 'dynamic' in entry),
+            fill: (given) => {
+                const filled = [];
+                let placed = false;
+                for (const entry of entries) {
+                    if (entry instanceof _a) {
+                        filled.push(entry);
+                    }
+                    else if ('slot' in entry && !placed) {
+                        filled.push(...given);
+                        placed = true;
+                    }
+                }
+                if (!placed) {
+                    filled.push(...given);
+                }
+                return filled;
+            },
         };
     }
     /**
@@ -3245,3 +3371,18 @@ export class MLElement extends MLParentNode {
         throw new UnexpectedCallError('Not supported "webkitMatchesSelector" method');
     }
 }
+_a = MLElement;
+/**
+ * The namespace of a virtual element made from a pretender definition.
+ * `svg` and `math` are foreign elements wherever they are written, and a
+ * definition can only state `namespace: 'svg'`, so the name decides.
+ */
+function getVirtualNamespace(spec, fallback) {
+    if (spec.namespace === 'svg' || spec.element === 'svg') {
+        return 'http://www.w3.org/2000/svg';
+    }
+    if (spec.element === 'math') {
+        return 'http://www.w3.org/1998/Math/MathML';
+    }
+    return fallback;
+}

package/lib/ml-dom/node/node-store.d.ts

@@ -2,11 +2,20 @@ import type { MLNode } from './node.js';
 import type { MappedNode } from './types.js';
 import type { MLASTNode } from '@markuplint/ml-ast';
 import type { PlainData, RuleConfigValue } from '@markuplint/ml-config';
-declare class NodeStore {
+/**
+ * Maps the AST nodes of one document to the `MLNode`s built from them.
+ *
+ * Owned by a single `MLDocument` and shared with its nodes through `MLNode`'s
+ * constructor. A node is only ever looked up through its own document
+ * (`syntacticalParentNode` resolves `parentNodeUuid`, `getPureChildNodes`
+ * resolves child AST nodes), so the store must not be held anywhere that
+ * outlives that document: a longer-lived holder keeps every node — and through
+ * `ownerMLDocument` the whole tree — reachable, which an engine that calls
+ * `setCode()` / `exec()` repeatedly accumulates without bound (see #4074).
+ */
+export declare class NodeStore {
     #private;
     getNode<N extends MLASTNode, T extends RuleConfigValue, O extends PlainData = undefined>(astNode: N): MappedNode<N, T, O>;
     getNodeByUuid<T extends RuleConfigValue, O extends PlainData = undefined>(uuid: string): MLNode<T, O, any>;
     setNode<A extends MLASTNode, T extends RuleConfigValue, O extends PlainData = undefined>(astNode: A, node: MLNode<T, O, A>): void;
 }
-export declare const nodeStore: NodeStore;
-export {};

package/lib/ml-dom/node/node-store.js

@@ -2,7 +2,18 @@ import { TargetParserError } from '@markuplint/parser-utils';
 import { log } from '../../debug.js';
 const nodeStoreLog = log.extend('node-store');
 const nodeStoreError = nodeStoreLog.extend('error');
-class NodeStore {
+/**
+ * Maps the AST nodes of one document to the `MLNode`s built from them.
+ *
+ * Owned by a single `MLDocument` and shared with its nodes through `MLNode`'s
+ * constructor. A node is only ever looked up through its own document
+ * (`syntacticalParentNode` resolves `parentNodeUuid`, `getPureChildNodes`
+ * resolves child AST nodes), so the store must not be held anywhere that
+ * outlives that document: a longer-lived holder keeps every node — and through
+ * `ownerMLDocument` the whole tree — reachable, which an engine that calls
+ * `setCode()` / `exec()` repeatedly accumulates without bound (see #4074).
+ */
+export class NodeStore {
     #store = new Map();
     getNode(astNode) {
         // console.log(`Get: ${astNode.uuid} -> ${astNode.raw.trim()}(${astNode.type})`);
@@ -35,9 +46,6 @@ class NodeStore {
     setNode(astNode, 
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     node) {
-        if (node.is(node.DOCUMENT_NODE)) {
-            return;
-        }
         if (!astNode.uuid) {
             nodeStoreError('UUID is invalid: %s (%s: "%s")', astNode.uuid, astNode.nodeName, astNode.raw);
             nodeStoreError('Invalid node: %O', node);
@@ -46,4 +54,3 @@ class NodeStore {
         this.#store.set(astNode.uuid, node);
     }
 }
-export const nodeStore = new NodeStore();

package/lib/ml-dom/node/node.js

@@ -2,7 +2,7 @@ import { branchesToPatterns, UnexpectedCallError } from '@markuplint/shared';
 import { MLToken } from '../token/token.js';
 import { isChildNode } from './child-node.js';
 import { toNodeList } from './node-list.js';
-import { nodeStore } from './node-store.js';
+import { NodeStore } from './node-store.js';
 /**
  * Abstract base class for all markuplint DOM node wrappers.
  * Extends `MLToken` with DOM `Node` interface compliance, tree traversal,
@@ -128,6 +128,12 @@ export class MLNode extends MLToken {
      */
     isFragment;
     #ownerDocument;
+    /**
+     * Scoped to the owning document so the mapping is reclaimed together with
+     * it, and held directly on each node so the hot `syntacticalParentNode` /
+     * `getPureChildNodes` paths reach it without a lookup.
+     */
+    #nodeStore;
     #prevToken;
     #conditionalChildNodes;
     /**
@@ -144,7 +150,18 @@ export class MLNode extends MLToken {
         this._astToken = astNode;
         this.#ownerDocument = document;
         this.isFragment = !!isFragment;
-        nodeStore.setNode(astNode, this);
+        // `document` is `null` only for the `MLDocument` being constructed (see
+        // its `super(ast, null)` call), which creates the store its nodes share.
+        // The document node is deliberately not registered: its AST node has no
+        // `uuid`, and nothing resolves it through the store (see
+        // `syntacticalParentNode`, which returns `ownerMLDocument` directly).
+        if (document) {
+            this.#nodeStore = document.#nodeStore;
+            this.#nodeStore.setNode(astNode, this);
+        }
+        else {
+            this.#nodeStore = new NodeStore();
+        }
     }
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
@@ -493,7 +510,7 @@ export class MLNode extends MLToken {
         if (!this._astToken.parentNodeUuid) {
             return this.ownerMLDocument;
         }
-        return nodeStore.getNodeByUuid(this._astToken.parentNodeUuid);
+        return this.#nodeStore.getNodeByUuid(this._astToken.parentNodeUuid);
     }
     /**
      * Return the text content.
@@ -722,7 +739,7 @@ export class MLNode extends MLToken {
                 return node;
             }) ?? [];
             const childNodes = astChildren
-                .map(node => nodeStore.getNode(node))
+                .map(node => this.#nodeStore.getNode(node))
                 .filter(node => isChildNode(node));
             // Cache
             this.#pureChildNodesCache = toNodeList(childNodes);

package/lib/ml-dom/node/types.d.ts

@@ -72,6 +72,43 @@ export type PretenderContextPretender<N extends MLElement<T, O>, T extends RuleC
     readonly type: 'pretender';
     readonly as: N;
     readonly aria?: PretenderARIA;
+    /**
+     * Present only when the pretender describes what the component renders around
+     * its children (`contents`, or exactly-one/multiple `slots` wrappers).
+     * Absent means the children given at the usage site are the whole content of
+     * the outermost element, which is the behavior of a bare-string pretender.
+     */
+    readonly slotContent?: PretenderSlotContent<N, T, O>;
+};
+/**
+ * What a rule needs to evaluate the children given to a pretended component
+ * the way the component actually renders them.
+ *
+ * @template N - The element type
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
+export type PretenderSlotContent<N extends MLElement<T, O>, T extends RuleConfigValue, O extends PlainData = undefined> = {
+    /**
+     * The element whose content model governs the evaluated children:
+     * the pretender itself, or the virtual element for the single slot wrapper.
+     * `null` when the wrapper is unknown (several slot wrappers), in which case
+     * the children must not be validated.
+     */
+    readonly wrapper: N | null;
+    /**
+     * `true` when `contents` (of any slot when there are several) has an entry
+     * whose content is unknown at scan time, so a required child, or a name,
+     * may be rendered there.
+     */
+    readonly mutable: boolean;
+    /**
+     * Builds the children of {@link wrapper} from the nodes given at the usage
+     * site: the static entries of `contents` as virtual elements, with the given
+     * nodes placed at the slot position (appended when there is no slot entry).
+     * Virtual elements are created once and reused on each call.
+     */
+    readonly fill: <C>(given: readonly C[]) => readonly (C | N)[];
 };
 /**
  * Context for the original element that has been pretended by another element.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "5.0.0",
+	"version": "5.1.0",
 	"description": "The core module of markuplint",
 	"repository": {
 		"type": "git",
@@ -34,20 +34,20 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "5.0.0",
-		"@markuplint/html-parser": "5.0.0",
-		"@markuplint/html-spec": "5.0.0",
-		"@markuplint/i18n": "5.0.0",
-		"@markuplint/ml-ast": "5.0.0",
-		"@markuplint/ml-config": "5.0.0",
-		"@markuplint/ml-spec": "5.0.0",
-		"@markuplint/parser-utils": "5.0.0",
-		"@markuplint/selector": "5.0.0",
-		"@markuplint/shared": "5.0.0",
+		"@markuplint/config-presets": "5.1.0",
+		"@markuplint/html-parser": "5.1.0",
+		"@markuplint/html-spec": "5.1.0",
+		"@markuplint/i18n": "5.1.0",
+		"@markuplint/ml-ast": "5.1.0",
+		"@markuplint/ml-config": "5.1.0",
+		"@markuplint/ml-spec": "5.1.0",
+		"@markuplint/parser-utils": "5.1.0",
+		"@markuplint/selector": "5.1.0",
+		"@markuplint/shared": "5.1.0",
 		"@types/debug": "4.1.13",
 		"debug": "4.4.3",
 		"is-plain-object": "5.0.0",
 		"type-fest": "5.6.0"
 	},
-	"gitHead": "c99706fda4c186aeb87b521eaabc5208ac144bbd"
+	"gitHead": "3a061784a8211034ad0c1cbd64798c0213414f65"
 }