@markuplint/ml-core 5.4.0 → 5.6.0

package/CHANGELOG.md

@@ -3,6 +3,35 @@
 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
+
+* **ml-core:** compute the slot assignment of a declarative shadow root ([381ce83](https://github.com/markuplint/markuplint/commit/381ce8308c9f3e5602654bbbdec6a5a3f8597941))
+* **ml-core:** do not take a spread attribute for a directive of a template element ([9af419e](https://github.com/markuplint/markuplint/commit/9af419ec690df40448f4afa3a5c37933f35e4830))
+* **ml-core:** find the innermost node whose range holds a location ([d45b662](https://github.com/markuplint/markuplint/commit/d45b6623a7fe85b675263a74ad85e3d86fa7a422))
+* **ml-core:** read the declarative shadow root of a pretended host first ([905cbf6](https://github.com/markuplint/markuplint/commit/905cbf6f541c2dd8475ec4c4a3d2383b2a95341c)), closes [#4527](https://github.com/markuplint/markuplint/issues/4527)
+* **ml-core:** report an invalid selector of a pretender as an error of the configuration ([3af8221](https://github.com/markuplint/markuplint/commit/3af8221583b0d16805c250cfa0a84baa8733fdc4))
+
+### Features
+
+* **ml-core:** add MLElement#isUnresolvedComponent ([9da55f2](https://github.com/markuplint/markuplint/commit/9da55f206aeeed4285cf094f9f033b3e92650365))
+
+
+# [5.5.0](https://github.com/markuplint/markuplint/compare/v5.4.0...v5.5.0) (2026-11-10)
+
+### Bug Fixes
+
+* **ml-core:** cite the DOM, CSSOM View and DOM Parsing members at their current anchors ([809f9f0](https://github.com/markuplint/markuplint/commit/809f9f0ae61adca02c9b51beaf7660706f1eaf02))
+* **ml-core:** omit unrendered template content from accessible names ([55688bc](https://github.com/markuplint/markuplint/commit/55688bc6a7b5860de775760fae1fdf9ba6bd94e6))
+* **ml-core:** return the last element child from lastElementChild ([f58cc9f](https://github.com/markuplint/markuplint/commit/f58cc9f2ae9d438ae2235ff6745c00d8a4be517f)), closes [#4503](https://github.com/markuplint/markuplint/issues/4503)
+
+### Features
+
+* **ml-core:** make the DOM tree-aware: template content and declarative shadow roots are trees ([651852d](https://github.com/markuplint/markuplint/commit/651852da83052f7a51aab5f2dd06a4f18d19d36a))
+* **ml-core:** render a literal in an attribute value as the framework renders it ([f6ff61d](https://github.com/markuplint/markuplint/commit/f6ff61d91d180937db972f908e81d796ca9a4774))
+
+
 # [5.4.0](https://github.com/markuplint/markuplint/compare/v5.3.0...v5.4.0) (2026-10-29)
 
 ### Features

package/lib/ml-core.js

@@ -344,6 +344,9 @@ export class MLCore {
                 filename: this.#filename,
                 endTag: this.#parser.endTag,
                 booleanish: this.#parser.booleanish,
+                attrExpressionLanguage: this.#parser.attrExpressionLanguage,
+                literalValues: this.#parser.literalValues,
+                slotElement: this.#parser.slotElement,
                 tagNameCaseSensitive: this.#parser.tagNameCaseSensitive,
                 componentNameVariants: this.#parser.componentNameVariants,
                 // The parser's own rule, called on the parser: a method of a class that reads its own state

package/lib/ml-dom/helper/accname.d.ts

@@ -1,4 +1,6 @@
 import type { MLElement } from '../node/element.js';
+import type { MLNode } from '../node/node.js';
+import type { PlainData, RuleConfigValue } from '@markuplint/ml-config';
 import type { AccnameSource, AccnameVisit, ARIAVersion } from '@markuplint/ml-spec';
 export declare function getAccname(el: MLElement<any, any>, version: ARIAVersion): string;
 /**
@@ -25,3 +27,36 @@ export declare function getReferencedTextAlternative(el: MLElement<any, any>, ve
  * handled as in {@link getAccname}: the element is taken to have none.
  */
 export declare function getHostLanguageLabelSource(el: MLElement<any, any>, version: ARIAVersion): AccnameSource | null;
+/**
+ * The children the accessible-name computation renders for `el`.
+ *
+ * An ordinary `template` element contributes none: its content is another tree
+ * and is not rendered where the element is written. A host renders the child
+ * nodes of its declarative shadow root, of either mode. A `template` whose
+ * shadow root is only maybe attached contributes none too, because that root
+ * is not there to read. A slot whose assignment is not known contributes its own children, so a rule that
+ * must not report on what it cannot know asks `MLElement#getAssignedNodes` itself.
+ *
+ * The shadow root comes first, for a pretended component too: it is attached to a
+ * pretended host only when the component renders the children written in it in
+ * itself, and then it is rendered in place of what the component renders.
+ * Otherwise a pretended component is unchanged: `as.childNodes` is empty when it never
+ * renders its children (`slots: null`), so text written inside `<Img>Save</Img>`
+ * does not become its name. `contents` may wrap the children given at the usage site.
+ *
+ * > The template contents of a template element are not children of the element itself.
+ *
+ * > If the current node has an attached shadow root, set the rendered child nodes to be the child nodes of the shadow root.
+ *
+ * > Otherwise, if the current node is a slot with assigned nodes, set the rendered child nodes to be the assigned nodes of the current node.
+ *
+ * > Otherwise, set the rendered child nodes to be the child nodes of the current node.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param el - The element whose rendered children are asked for
+ * @returns The nodes the computation walks
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
+ * @see https://w3c.github.io/accname/#comp_name_from_content
+ */
+export declare function getRenderedChildNodes<T extends RuleConfigValue, O extends PlainData>(el: MLElement<T, O>): Iterable<MLNode<T, O>>;

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

@@ -1,5 +1,7 @@
-import { computeAccessibleName, computeHostLanguageLabel, computeReferencedTextAlternative, escapeCSS, getComputedRole, EMBEDDED_CONTROL_ROLES, isExposedAsPresentational, isNativeEmbeddedControl, } from '@markuplint/ml-spec';
+import { computeAccessibleName, computeHostLanguageLabel, computeReferencedTextAlternative, getComputedRole, EMBEDDED_CONTROL_ROLES, isExposedAsPresentational, isNativeEmbeddedControl, } from '@markuplint/ml-spec';
+import { decodeEntities } from '@markuplint/shared';
 import { log } from '../../debug.js';
+import { getDOMValue } from './tree-scope.js';
 const accnameLog = log.extend('accname');
 export function getAccname(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -106,18 +108,79 @@ el, error) {
         accnameLog('Error: %O', error);
     }
 }
+/**
+ * The children the accessible-name computation renders for `el`.
+ *
+ * An ordinary `template` element contributes none: its content is another tree
+ * and is not rendered where the element is written. A host renders the child
+ * nodes of its declarative shadow root, of either mode. A `template` whose
+ * shadow root is only maybe attached contributes none too, because that root
+ * is not there to read. A slot whose assignment is not known contributes its own children, so a rule that
+ * must not report on what it cannot know asks `MLElement#getAssignedNodes` itself.
+ *
+ * The shadow root comes first, for a pretended component too: it is attached to a
+ * pretended host only when the component renders the children written in it in
+ * itself, and then it is rendered in place of what the component renders.
+ * Otherwise a pretended component is unchanged: `as.childNodes` is empty when it never
+ * renders its children (`slots: null`), so text written inside `<Img>Save</Img>`
+ * does not become its name. `contents` may wrap the children given at the usage site.
+ *
+ * > The template contents of a template element are not children of the element itself.
+ *
+ * > If the current node has an attached shadow root, set the rendered child nodes to be the child nodes of the shadow root.
+ *
+ * > Otherwise, if the current node is a slot with assigned nodes, set the rendered child nodes to be the assigned nodes of the current node.
+ *
+ * > Otherwise, set the rendered child nodes to be the child nodes of the current node.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param el - The element whose rendered children are asked for
+ * @returns The nodes the computation walks
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
+ * @see https://w3c.github.io/accname/#comp_name_from_content
+ */
+export function getRenderedChildNodes(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    const shadowRoot = el.declarativeShadowRoot;
+    if (shadowRoot) {
+        return shadowRoot.childNodes;
+    }
+    const assigned = el.getAssignedNodes();
+    if (assigned && assigned.length > 0) {
+        return assigned;
+    }
+    const context = el.pretenderContext;
+    if (context?.type === 'pretender') {
+        const given = [...context.as.childNodes];
+        return context.slotContent ? context.slotContent.fill(given) : given;
+    }
+    if (el.isHTMLTemplateElement) {
+        return [];
+    }
+    return el.childNodes;
+}
 function createMLCoreResolver(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, version) {
     const doc = el.ownerMLDocument;
+    // An id is resolved in the tree of the element: not in the content of a `template` outside of it.
+    // An element that is in no tree (a `template` that a declarative shadow root is attached to) is its
+    // own root and resolves nothing.
+    const node = el.getRootNode();
+    const root = node.is(node.DOCUMENT_NODE) || node.is(node.DOCUMENT_FRAGMENT_NODE) ? node : null;
+    // The ids the algorithm hands over are the ones written in the markup (`MLElement#id` and a token of
+    // `aria-labelledby`), so the character references are resolved on both sides, as the DOM has them
     return {
         getElementById(id) {
-            const found = doc.querySelector(`#${escapeCSS(id)}`);
-            return found ?? null;
+            return root?.getElementById(decodeEntities(id)) ?? null;
         },
         getLabelsForId(id) {
-            const labels = doc.querySelectorAll(`label[for="${escapeCSS(id)}"]`);
-            return [...labels];
+            const domId = decodeEntities(id);
+            return root
+                ? [...root.querySelectorAll('label[for]')].filter(label => getDOMValue(label.getAttributeNode('for')) === domId)
+                : [];
         },
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
         allowsNameFromContent(target) {
@@ -164,18 +227,7 @@ el, version) {
         // 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;
+            return getRenderedChildNodes(target);
         },
     };
 }

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

@@ -64,7 +64,7 @@ attributes) {
         if (n.spacesBeforeName) {
             r.push(
             //
-            `  isDirective: ${!!n.isDirective}`, `  isDynamicValue: ${!!n.isDynamicValue}`);
+            `  isDirective: ${!!n.isDirective}`, `  isExpressionValue: ${!!n.isExpressionValue}`, `  isDynamicValue: ${!!n.isDynamicValue}`, `  isAbsent: ${!!n.isAbsent}`);
         }
         if (n.candidate) {
             r.push(`  candidate: ${visibleWhiteSpace(n.candidate)}`);

package/lib/ml-dom/helper/literal-values.d.ts

@@ -0,0 +1,102 @@
+import type { LiteralValueDeclaration } from '@markuplint/ml-ast';
+import type { MLMLSpec } from '@markuplint/ml-spec';
+import type { LiteralExpression } from '@markuplint/parser-utils';
+/**
+ * How a literal in an attribute value that is written as code is rendered as an attribute of the DOM.
+ *
+ * - `value`: the attribute has this value (`""` for `disabled={true}`)
+ * - `absent`: the attribute is not output (`disabled={false}`), as `getAttribute()` returns `null`
+ * - `unknown`: the frameworks differ and the attribute has a value that is not known (`disabled={""}`
+ *   is `""` in Vue and Svelte, and absent in React and Astro)
+ */
+export type RenderedLiteral = {
+    readonly kind: 'value';
+    readonly value: string;
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'unknown';
+};
+/**
+ * What decides the rendering of a literal besides the literal itself.
+ */
+export type LiteralRenderingContext = {
+    /**
+     * The name of the attribute as the DOM names it, in lower case.
+     */
+    readonly name: string;
+    /**
+     * Whether the attribute is a boolean attribute: a name whose type is `Boolean` in the spec
+     * ({@link getBooleanAttrNames}). The frameworks decide it by the name, not by the element.
+     */
+    readonly isBoolean: boolean;
+    /**
+     * Whether the element is a custom element (`elementType: "web-component"`), which React and Astro
+     * render differently from an element of HTML.
+     */
+    readonly isCustomElement: boolean;
+    /**
+     * `literalValues` of the merged spec (`MLMLSpec#literalValues`).
+     */
+    readonly specLiteralValues?: LiteralValueDeclaration;
+    /**
+     * `literalValues` that the parser declares (`MLParser#literalValues`), which a parser without a spec
+     * package has. A spec wins over it on a key that both say.
+     */
+    readonly parserLiteralValues?: LiteralValueDeclaration;
+};
+/**
+ * Renders a literal in an attribute value that is written as code, as the framework renders it as
+ * an attribute of the DOM.
+ *
+ * The tables are looked up by the key of the literal (the normal form in `LiteralExpression#key`),
+ * and the first table that has the key decides, in this order. A spec is read before a parser at each step.
+ *
+ * 1. On a custom element, `customElements`: the table of the attribute by name (`attrs`), then that of
+ *    its kind
+ * 2. `attrs`: the table of the attribute by name
+ * 3. The table of `@markuplint/ml-core` by name ({@link NAME_DEFAULTS})
+ * 4. The table of the kind of the attribute (`ariaAttrs` for `aria-`, `dataAttrs` for `data-`,
+ *    `booleanAttrs` for a boolean attribute, `otherAttrs` for the rest). The kinds are independent: an
+ *    attribute is of one kind and does not fall back to another
+ * 5. The default of `@markuplint/ml-core` ({@link renderByDefault})
+ *
+ * A table lists only what differs from the default, so most attributes are rendered by 5.
+ *
+ * @param literal - The literal that is written
+ * @param context - What decides the rendering besides the literal
+ * @returns How the attribute is rendered
+ */
+export declare function renderLiteral(literal: LiteralExpression, context: LiteralRenderingContext): RenderedLiteral;
+/**
+ * The string of a literal as it is written, which is what a component receives as a prop of the
+ * literal. A component does not render it: where it ends up is decided by the element that the
+ * prop is forwarded to.
+ *
+ * @param literal - The literal that is written
+ * @returns The string form: a string as it is, a number by `String(n)`, a boolean as `"true"` or
+ * `"false"`, and `null` or `undefined` as the empty string
+ */
+export declare function literalToString(literal: LiteralExpression): string;
+/**
+ * The code that reads as the literal again: the key of the literal, except for a number that is not
+ * finite, whose key (`Infinity`) is a name and not a literal, so it is written as the number that overflows.
+ *
+ * @param literal - The literal that is written
+ * @returns The code that `parseLiteralExpression` reads as the same literal
+ */
+export declare function literalToExpression(literal: LiteralExpression): string;
+/**
+ * The names of the boolean attributes of a spec: those whose type is `Boolean` somewhere in it, in
+ * the global attributes or in an element, so `open` is one though it is another type on `<mfenced>`.
+ * An attribute with several types, or a conditional type, counts when any of them is `Boolean`.
+ * Names are in lower case.
+ *
+ * The frameworks decide a boolean attribute by its name alone (React, Vue, Svelte, Astro and Alpine
+ * each have a list of names), so the element does not matter. `hidden` is not in the set: its type is
+ * enumerated in the HTML Standard.
+ *
+ * @param spec - The merged spec
+ * @returns The set of names, computed once for a spec
+ */
+export declare function getBooleanAttrNames(spec: MLMLSpec): ReadonlySet<string>;

package/lib/ml-dom/helper/literal-values.js

@@ -0,0 +1,193 @@
+import { asciiLowerCase } from '@markuplint/shared';
+/**
+ * The tables of `@markuplint/ml-core` by attribute name, for an attribute whose rendering the
+ * frameworks agree on and the spec cannot say: `hidden` is an enumerated attribute (`""`, `hidden`,
+ * `until-found`) in the HTML Standard, but React, Vue, Svelte and Astro all render a boolean as
+ * present or absent. What differs among them is said by `literalValues` of the spec or the parser.
+ *
+ * It lists what the frameworks agree on. A number other than `0` is a string by the default (`hidden={1}` is
+ * `hidden="1"`, which React, Vue and Svelte render as `hidden=""`): the attribute is output either way. The
+ * empty string is present by the default; React does not output it, which its spec says.
+ *
+ * It is read after `attrs` of a spec or a parser, so that a framework that renders `hidden` differently
+ * can say so there, and before the table of its kind (`otherAttrs`, as `hidden` is not `Boolean` in the
+ * spec), so that what a framework says for the other attributes does not change it.
+ */
+const NAME_DEFAULTS = {
+    hidden: { true: '', false: null, '0': null },
+};
+/**
+ * Renders a literal in an attribute value that is written as code, as the framework renders it as
+ * an attribute of the DOM.
+ *
+ * The tables are looked up by the key of the literal (the normal form in `LiteralExpression#key`),
+ * and the first table that has the key decides, in this order. A spec is read before a parser at each step.
+ *
+ * 1. On a custom element, `customElements`: the table of the attribute by name (`attrs`), then that of
+ *    its kind
+ * 2. `attrs`: the table of the attribute by name
+ * 3. The table of `@markuplint/ml-core` by name ({@link NAME_DEFAULTS})
+ * 4. The table of the kind of the attribute (`ariaAttrs` for `aria-`, `dataAttrs` for `data-`,
+ *    `booleanAttrs` for a boolean attribute, `otherAttrs` for the rest). The kinds are independent: an
+ *    attribute is of one kind and does not fall back to another
+ * 5. The default of `@markuplint/ml-core` ({@link renderByDefault})
+ *
+ * A table lists only what differs from the default, so most attributes are rendered by 5.
+ *
+ * @param literal - The literal that is written
+ * @param context - What decides the rendering besides the literal
+ * @returns How the attribute is rendered
+ */
+export function renderLiteral(literal, context) {
+    const { key } = literal;
+    const { name, specLiteralValues: spec, parserLiteralValues: parser } = context;
+    const kind = kindOf(name, context.isBoolean);
+    const tables = [];
+    if (context.isCustomElement) {
+        tables.push(spec?.customElements?.attrs?.[name], parser?.customElements?.attrs?.[name], spec?.customElements?.[kind], parser?.customElements?.[kind]);
+    }
+    tables.push(spec?.attrs?.[name], parser?.attrs?.[name], NAME_DEFAULTS[name], spec?.[kind], parser?.[kind]);
+    for (const table of tables) {
+        if (table && Object.hasOwn(table, key)) {
+            const rendered = table[key];
+            return rendered == null ? { kind: 'absent' } : { kind: 'value', value: rendered };
+        }
+    }
+    return renderByDefault(literal, kind);
+}
+function kindOf(name, isBoolean) {
+    if (name.startsWith('aria-')) {
+        return 'ariaAttrs';
+    }
+    if (name.startsWith('data-')) {
+        return 'dataAttrs';
+    }
+    return isBoolean ? 'booleanAttrs' : 'otherAttrs';
+}
+/**
+ * The rendering that React, Vue, Svelte and Astro share, which a table of a spec or a parser
+ * overrides on the keys it lists.
+ *
+ * | literal            | boolean attribute         | others          |
+ * | ------------------ | ------------------------- | --------------- |
+ * | `true`             | `""`                      | `"true"`        |
+ * | `false`            | not output                | `"false"`       |
+ * | `null`/`undefined` | not output                | not output      |
+ * | a number except 0  | `""`                      | `String(n)`     |
+ * | `0`                | not output                | `"0"`           |
+ * | `""`               | unknown                   | `""`            |
+ * | any other string   | `""`                      | the string      |
+ *
+ * `aria-` and `data-` attributes are rendered as the others. The empty string on a boolean attribute is
+ * the one that the frameworks disagree on (present in Vue and Svelte, absent in React and Astro), so it is
+ * unknown unless the spec or the parser says. Svelte renders any other string on a boolean attribute
+ * as it is when it is rendered on the server, which is not told from `""` here: both mean that the
+ * attribute is present.
+ */
+function renderByDefault(literal, kind) {
+    const { type, value } = literal;
+    if (type === 'null' || type === 'undefined') {
+        return { kind: 'absent' };
+    }
+    if (kind === 'booleanAttrs') {
+        switch (type) {
+            case 'boolean': {
+                return value ? { kind: 'value', value: '' } : { kind: 'absent' };
+            }
+            case 'number': {
+                return value === 0 ? { kind: 'absent' } : { kind: 'value', value: '' };
+            }
+            default: {
+                return value === '' ? { kind: 'unknown' } : { kind: 'value', value: '' };
+            }
+        }
+    }
+    // The key of a number is its digits: a BigInt keeps all of them
+    return { kind: 'value', value: type === 'number' ? literal.key : String(value) };
+}
+/**
+ * The string of a literal as it is written, which is what a component receives as a prop of the
+ * literal. A component does not render it: where it ends up is decided by the element that the
+ * prop is forwarded to.
+ *
+ * @param literal - The literal that is written
+ * @returns The string form: a string as it is, a number by `String(n)`, a boolean as `"true"` or
+ * `"false"`, and `null` or `undefined` as the empty string
+ */
+export function literalToString(literal) {
+    switch (literal.type) {
+        case 'null':
+        case 'undefined': {
+            return '';
+        }
+        case 'number': {
+            return literal.key;
+        }
+        default: {
+            return String(literal.value);
+        }
+    }
+}
+/**
+ * The code that reads as the literal again: the key of the literal, except for a number that is not
+ * finite, whose key (`Infinity`) is a name and not a literal, so it is written as the number that overflows.
+ *
+ * @param literal - The literal that is written
+ * @returns The code that `parseLiteralExpression` reads as the same literal
+ */
+export function literalToExpression(literal) {
+    if (literal.type === 'number' && !Number.isFinite(literal.value)) {
+        return literal.value > 0 ? '1e999' : '-1e999';
+    }
+    return literal.key;
+}
+const booleanAttrNamesCache = new WeakMap();
+/**
+ * The names of the boolean attributes of a spec: those whose type is `Boolean` somewhere in it, in
+ * the global attributes or in an element, so `open` is one though it is another type on `<mfenced>`.
+ * An attribute with several types, or a conditional type, counts when any of them is `Boolean`.
+ * Names are in lower case.
+ *
+ * The frameworks decide a boolean attribute by its name alone (React, Vue, Svelte, Astro and Alpine
+ * each have a list of names), so the element does not matter. `hidden` is not in the set: its type is
+ * enumerated in the HTML Standard.
+ *
+ * @param spec - The merged spec
+ * @returns The set of names, computed once for a spec
+ */
+export function getBooleanAttrNames(spec) {
+    let names = booleanAttrNamesCache.get(spec);
+    if (names) {
+        return names;
+    }
+    const found = new Set();
+    const collect = (attrs) => {
+        for (const [name, attr] of Object.entries(attrs ?? {})) {
+            if (hasBooleanType(attr?.type)) {
+                found.add(asciiLowerCase(name));
+            }
+        }
+    };
+    for (const attrs of Object.values(spec.def?.['#globalAttrs'] ?? {})) {
+        collect(attrs);
+    }
+    for (const elSpec of spec.specs ?? []) {
+        collect(elSpec.attributes);
+    }
+    names = found;
+    booleanAttrNamesCache.set(spec, names);
+    return names;
+}
+function hasBooleanType(type) {
+    if (type === 'Boolean') {
+        return true;
+    }
+    if (Array.isArray(type)) {
+        return type.some(hasBooleanType);
+    }
+    // A conditional type: `{ condition, type }`
+    if (type != null && typeof type === 'object' && 'condition' in type && 'type' in type) {
+        return hasBooleanType(type.type);
+    }
+    return false;
+}

package/lib/ml-dom/helper/pretended-attrs.d.ts

@@ -0,0 +1,16 @@
+import type { MLASTAttr } from '@markuplint/ml-ast';
+/**
+ * Marks an AST attribute as made by a pretender. The AST contract of `@markuplint/ml-ast` is that of
+ * what a parser reads, so a fact of the core is kept here and not in a field of the node.
+ *
+ * @param attr - The AST attribute that `MLElement` makes from an attribute of a pretender
+ * @returns The same attribute
+ */
+export declare function markPretendedAttr<T extends MLASTAttr>(attr: T): T;
+/**
+ * Whether an AST attribute was made by a pretender ({@link markPretendedAttr}).
+ *
+ * @param attr - An AST attribute
+ * @returns `true` if the attribute was made by a pretender
+ */
+export declare function isPretendedAttr(attr: MLASTAttr): boolean;

package/lib/ml-dom/helper/pretended-attrs.js

@@ -0,0 +1,21 @@
+const pretendedAttrs = new WeakSet();
+/**
+ * Marks an AST attribute as made by a pretender. The AST contract of `@markuplint/ml-ast` is that of
+ * what a parser reads, so a fact of the core is kept here and not in a field of the node.
+ *
+ * @param attr - The AST attribute that `MLElement` makes from an attribute of a pretender
+ * @returns The same attribute
+ */
+export function markPretendedAttr(attr) {
+    pretendedAttrs.add(attr);
+    return attr;
+}
+/**
+ * Whether an AST attribute was made by a pretender ({@link markPretendedAttr}).
+ *
+ * @param attr - An AST attribute
+ * @returns `true` if the attribute was made by a pretender
+ */
+export function isPretendedAttr(attr) {
+    return pretendedAttrs.has(attr);
+}

package/lib/ml-dom/helper/slot-assignment.d.ts

@@ -0,0 +1,48 @@
+import type { MLChildNode } from '../node/child-node.js';
+import type { MLElement } from '../node/element.js';
+import type { MLNode } from '../node/node.js';
+import type { PlainData, RuleConfigValue } from '@markuplint/ml-config';
+/**
+ * The nodes a `slot` places.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param slot - An element
+ * @returns The assigned nodes in tree order (`[]` when it takes none), or `null` when the element is not an
+ *   HTML `slot` of a declarative shadow root whose assignment is known (see the module comment)
+ * @see https://dom.spec.whatwg.org/#dom-slot-assignednodes
+ */
+export declare function getAssignedNodes<T extends RuleConfigValue, O extends PlainData>(slot: MLElement<T, O>): readonly MLChildNode<T, O>[] | null;
+/**
+ * The slot that places a node, as the flat tree has it.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param node - An element or a text node
+ * @returns The slot; `null` when the node is a child of a shadow host that no slot of its shadow root
+ *   takes, so that it is not rendered; `undefined` when the node is not a child of a shadow host, or the
+ *   assignment is not known
+ * @see https://dom.spec.whatwg.org/#find-a-slot
+ */
+export declare function getFlatTreeSlot<T extends RuleConfigValue, O extends PlainData>(node: MLNode<T, O>): MLElement<T, O> | null | undefined;
+/**
+ * The slot of an open shadow root that a node is assigned to.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param node - An element or a text node
+ * @returns The slot, or `null` when none takes the node, its shadow root is closed, or the assignment is not known
+ * @see https://dom.spec.whatwg.org/#dom-slotable-assignedslot
+ */
+export declare function getAssignedSlot<T extends RuleConfigValue, O extends PlainData>(node: MLNode<T, O>): MLElement<T, O> | null;
+/**
+ * The nodes a `slot` renders, with each assigned slot replaced by what that slot renders in turn, and the
+ * children of a slot that takes none in its place.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ * @param slot - An element
+ * @returns The nodes, or `[]` when the assignment is not known
+ * @see https://dom.spec.whatwg.org/#find-flattened-slotables
+ */
+export declare function getFlattenedSlottables<T extends RuleConfigValue, O extends PlainData>(slot: MLElement<T, O>): readonly MLChildNode<T, O>[];