@markuplint/ml-core 5.5.0 → 5.6.0

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.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

package/lib/ml-core.js

@@ -346,6 +346,7 @@ export class MLCore {
                 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

@@ -34,10 +34,13 @@ export declare function getHostLanguageLabelSource(el: MLElement<any, any>, vers
  * 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. Assigned nodes are not computed
- * (`MLElement#assignedNodes` returns none), so a slot contributes its own children.
+ * 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.
  *
- * A pretended component is unchanged: `as.childNodes` is empty when it never
+ * 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.
  *

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

@@ -115,10 +115,13 @@ el, error) {
  * 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. Assigned nodes are not computed
- * (`MLElement#assignedNodes` returns none), so a slot contributes its own children.
+ * 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.
  *
- * A pretended component is unchanged: `as.childNodes` is empty when it never
+ * 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.
  *
@@ -140,15 +143,19 @@ el, error) {
 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;
     }
-    const shadowRoot = el.declarativeShadowRoot;
-    if (shadowRoot) {
-        return shadowRoot.childNodes;
-    }
     if (el.isHTMLTemplateElement) {
         return [];
     }

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>[];

package/lib/ml-dom/helper/slot-assignment.js

@@ -0,0 +1,292 @@
+import { isShadowRoot } from '@markuplint/ml-spec';
+import { getDOMValue, getShadowHost, getShadowRootTemplate, HTML_NAMESPACE, isTransparent } from './tree-scope.js';
+const cache = new WeakMap();
+/**
+ * Whether the element is the HTML `slot` element: not the placeholder of a framework's component
+ * (`MLParser#slotElement`, and what the parser of a framework turns into a fragment).
+ *
+ * @param el - An element
+ * @returns `true` for the HTML `slot` element
+ */
+function isHTMLSlot(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    return (el.localName === 'slot' &&
+        el.namespaceURI === HTML_NAMESPACE &&
+        !el.isFragment &&
+        el.ownerMLDocument.slotElement === 'html');
+}
+/**
+ * The string that the DOM has for an attribute that names a slot: `''` when it is missing, `null`
+ * when it is written as code.
+ *
+ * @param el - The element
+ * @param name - The attribute name (`name` of a `slot`, `slot` of a slottable)
+ * @returns The name, or `null` when it is not known
+ */
+function getSlotName(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, name) {
+    // An attribute that has no name node is a spread (`{...props}`), which may set it
+    if (el.attributes.some(attr => !attr.nameNode)) {
+        return null;
+    }
+    const attr = el.getAttributeNode(name);
+    if (!attr || attr.isAbsent) {
+        return '';
+    }
+    return getDOMValue(attr);
+}
+/**
+ * Collects the HTML `slot` elements of the shadow root in tree order, without entering the content of a
+ * `template` element, which is a tree of its own.
+ *
+ * @param parent - The shadow root, or an element in it
+ * @param slots - The slots found so far, which the walk appends to
+ * @param inBlock - Whether the walk went through a node that the engine renders away (a block or a
+ *   fragment), under which a slot may not be rendered
+ * @returns `false` when which slot is the first of its name is not known: a slot in such a node, or
+ *   one whose `name` is not known
+ */
+function collectSlots(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+parent, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+slots, inBlock) {
+    for (const child of parent.getPureChildNodes()) {
+        if (!child.is(child.ELEMENT_NODE) && !child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            continue;
+        }
+        if (isTransparent(child)) {
+            if (!collectSlots(child, slots, true)) {
+                return false;
+            }
+            continue;
+        }
+        if (!child.is(child.ELEMENT_NODE)) {
+            continue;
+        }
+        if (isHTMLSlot(child)) {
+            // Whether it is rendered, and its `name`, are not known
+            if (inBlock || getSlotName(child, 'name') === null) {
+                return false;
+            }
+            slots.push(child);
+        }
+        // The content of a `template` element is a tree of its own, which has its own slots
+        if (!child.isHTMLTemplateElement && !collectSlots(child, slots, inBlock)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * The nodes that are the children of the host in the output, seen through what the engine renders away,
+ * the nodes in every branch of a conditional block included.
+ *
+ * @param parent - The host, or a node that the engine renders away in it
+ * @param nodes - The nodes found so far
+ * @param declaring - The `template` element that declares the shadow root, which is not a child of the host in the tree
+ * @returns `false` when the nodes are not known
+ */
+function collectSlottables(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+parent, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodes, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+declaring) {
+    for (const child of parent.getPureChildNodes()) {
+        if (child === declaring) {
+            continue;
+        }
+        if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            // A block that has no behavior may be a marker of a language whose blocks the syntax tree does not nest
+            if (!child.blockBehavior || !collectSlottables(child, nodes, declaring)) {
+                return false;
+            }
+            continue;
+        }
+        if (child.is(child.ELEMENT_NODE)) {
+            if (isTransparent(child)) {
+                if (!collectSlottables(child, nodes, declaring)) {
+                    return false;
+                }
+                continue;
+            }
+            // What it renders may carry any `slot` attribute
+            if (child.isUnresolvedComponent()) {
+                return false;
+            }
+            nodes.push(child);
+            continue;
+        }
+        if (child.is(child.TEXT_NODE)) {
+            nodes.push(child);
+        }
+    }
+    return true;
+}
+/**
+ * Computes the assignment of the shadow root of a host.
+ *
+ * @param host - A shadow host
+ * @returns The assignment, or `null` when the host has no shadow root or any of the causes in the module
+ *   comment leaves the assignment unknown
+ */
+function compute(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+host) {
+    const root = host.declarativeShadowRoot;
+    const template = getShadowRootTemplate(host);
+    if (!root || !template) {
+        return null;
+    }
+    if (host.ownerMLDocument.slotElement !== 'html' || root.slotAssignment === 'manual') {
+        return null;
+    }
+    // A shadow root that a conditional wrapper may not render has no known slots
+    if (template.syntacticalParentNode !== host) {
+        return null;
+    }
+    const slotList = [];
+    if (!collectSlots(root, slotList, false)) {
+        return null;
+    }
+    const slottables = [];
+    if (!collectSlottables(host, slottables, template)) {
+        return null;
+    }
+    const names = new Map();
+    for (const slot of slotList) {
+        const name = getSlotName(slot, 'name');
+        if (name === null) {
+            return null;
+        }
+        names.set(slot, name);
+    }
+    const slots = new Map(slotList.map(slot => [slot, []]));
+    // The first slot of the shadow root, in tree order, that has each name
+    const firstSlotOfName = new Map();
+    for (const slot of slotList) {
+        const name = names.get(slot);
+        if (name !== undefined && !firstSlotOfName.has(name)) {
+            firstSlotOfName.set(name, slot);
+        }
+    }
+    const assigned = new Map();
+    for (const node of slottables) {
+        const name = node.is(node.ELEMENT_NODE) ? getSlotName(node, 'slot') : '';
+        if (name === null) {
+            return null;
+        }
+        const slot = firstSlotOfName.get(name) ?? null;
+        assigned.set(node, slot);
+        if (slot) {
+            slots.get(slot)?.push(node);
+        }
+    }
+    return { slots, assigned };
+}
+/**
+ * The assignment of a host, computed once: the document does not change after it is built, as the other
+ * getters about trees (`MLElement#declarativeShadowRoot`) assume, so the answer never goes stale.
+ *
+ * @param host - A shadow host
+ * @returns The assignment, or `null` when it is not known
+ */
+function getSlotAssignment(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+host) {
+    if (cache.has(host)) {
+        return cache.get(host) ?? null;
+    }
+    // The document does not change once it is built, as the other getters about trees assume
+    const assignment = compute(host);
+    cache.set(host, assignment);
+    return assignment;
+}
+/**
+ * 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 function getAssignedNodes(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+slot) {
+    if (!isHTMLSlot(slot)) {
+        return null;
+    }
+    const root = slot.getRootNode();
+    if (!isShadowRoot(root)) {
+        return null;
+    }
+    return getSlotAssignment(root.host)?.slots.get(slot) ?? 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 function getFlatTreeSlot(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node) {
+    // The parent in the output: a block or a fragment that the engine renders away is not the parent
+    const host = getShadowHost(node);
+    if (!host?.declarativeShadowRoot) {
+        return undefined;
+    }
+    return getSlotAssignment(host)?.assigned.get(node);
+}
+/**
+ * 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 function getAssignedSlot(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node) {
+    const slot = getFlatTreeSlot(node);
+    if (!slot) {
+        return null;
+    }
+    const root = slot.getRootNode();
+    return 'mode' in root && root.mode === 'open' ? slot : 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 function getFlattenedSlottables(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+slot) {
+    const assigned = getAssignedNodes(slot);
+    if (!assigned) {
+        return [];
+    }
+    const slottables = assigned.length > 0
+        ? assigned
+        : [...slot.childNodes].filter(node => node.is(node.ELEMENT_NODE) || node.is(node.TEXT_NODE));
+    return slottables.flatMap(node => node.is(node.ELEMENT_NODE) && getAssignedNodes(node) !== null ? getFlattenedSlottables(node) : [node]);
+}

package/lib/ml-dom/helper/tree-scope.d.ts

@@ -1,17 +1,53 @@
 import type { MLAttr } from '../node/attr.js';
 import type { MLElement } from '../node/element.js';
+import type { MLNode } from '../node/node.js';
 import type { PlainData, RuleConfigValue } from '@markuplint/ml-config';
+/**
+ * @module
+ *
+ * The tree of a node is what its `getRootNode()` returns: the document, the content of an
+ * HTML `template` element, or a declarative shadow root. An id is unique in a tree, and an id
+ * reference is resolved in a tree, as the specification says of "the element's tree".
+ *
+ * markuplint keeps the content of a `template` element as the children of the element (the
+ * syntax tree has no other place for it), so the boundary is made here and not by the shape of
+ * the tree: the queries of `MLParentNode`, `getRootNode()`, `treeParentElement`, the selector
+ * engine and `contains()` stop at it. `parentNode` / `parentElement` do not: the content
+ * model of a `template` element is validated against the elements that the syntax tree puts
+ * in it, so they go on to the `template` element. The algorithms of `@markuplint/ml-spec` walk up
+ * with `getTreeParentElement` / `getComposedParentElement`, which read `getRootNode()`, so the
+ * boundary made here is the boundary they stop at.
+ *
+ * @see https://dom.spec.whatwg.org/#concept-tree
+ * @see https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
+ */
+export declare const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
 /**
  * Whether a declarative shadow root is attached to the parent element of a `template` element.
  *
  * - `attached`: it is. The `template` element is in no tree, and its content is the shadow root.
  * - `not-attached`: it is not. The `template` element is an ordinary one of the tree it is in.
  * - `unknown`: the markup alone does not tell. The parent element is not in the file (the template is at
- *   the top of a partial), is a component, or `shadowrootmode` is a dynamic value. markuplint does not
+ *   the top of a partial), is a component, is a pretended component that drops its children or puts
+ *   them in a slot wrapper, or `shadowrootmode` is a dynamic value. markuplint does not
  *   decide what it cannot decide, as it does with a dynamic value elsewhere: the element is treated as
  *   in no tree, so its own id is not counted and the references of it are not reported.
  */
 export type DeclarativeShadowRootAttachment = 'attached' | 'not-attached' | 'unknown';
+/**
+ * Whether `node` is skipped when the parent of a `template` element is looked for: what the
+ * template engine or the framework renders away (a block of a template language, a fragment of
+ * JSX, a `template` with a directive such as `v-if`) leaves its children to the next element
+ * above.
+ *
+ * `isRenderedAway` of `@markuplint/rules` (`src/helpers.ts`) decides the same of an element for the
+ * rules that walk up the ancestors: a kind added here belongs to it too.
+ *
+ * @param node - A node of the syntax tree
+ * @returns `true` if the node is not an element of the output
+ */
+export declare function isTransparent<T extends RuleConfigValue, O extends PlainData>(node: MLNode<T, O>): boolean;
 /**
  * Whether the element is an HTML `template` element, which holds its children in `content`, a tree
  * of its own.
@@ -37,14 +73,15 @@ export declare function isHTMLTemplateElement<T extends RuleConfigValue, O exten
 export declare function getDeclarativeShadowRootMode<T extends RuleConfigValue, O extends PlainData>(template: MLElement<T, O>): 'open' | 'closed' | null;
 /**
  * The element that the HTML parser makes the shadow host of a `template` element: its parent in
- * the output, where what the engine renders away (see {@link isTransparent}) is skipped.
+ * the output, where what the engine renders away (see {@link isTransparent}) is skipped. It is the
+ * parent in the output of any node, so it is the host a light child is a child of.
  *
  * @template T - The rule configuration value type
  * @template O - The rule options type
- * @param template - A `template` element
- * @returns The element, or `null` when the file has none above the template
+ * @param template - A `template` element, or any node whose parent in the output is wanted
+ * @returns The element, or `null` when the file has none above the node
  */
-export declare function getShadowHost<T extends RuleConfigValue, O extends PlainData>(template: MLElement<T, O>): MLElement<T, O> | null;
+export declare function getShadowHost<T extends RuleConfigValue, O extends PlainData>(template: MLNode<T, O>): MLElement<T, O> | null;
 /**
  * Whether a declarative shadow root is attached to the parent of a `template` element, by what
  * the HTML parser does with the start tag of `template` and what the DOM does to attach a shadow

package/lib/ml-dom/helper/tree-scope.js

@@ -12,7 +12,7 @@ import { decodeEntities } from '@markuplint/shared';
  * the tree: the queries of `MLParentNode`, `getRootNode()`, `treeParentElement`, the selector
  * engine and `contains()` stop at it. `parentNode` / `parentElement` do not: the content
  * model of a `template` element is validated against the elements that the syntax tree puts
- * in it, so they stay the syntactical ones. The algorithms of `@markuplint/ml-spec` walk up
+ * in it, so they go on to the `template` element. The algorithms of `@markuplint/ml-spec` walk up
  * with `getTreeParentElement` / `getComposedParentElement`, which read `getRootNode()`, so the
  * boundary made here is the boundary they stop at.
  *
@@ -20,7 +20,7 @@ import { decodeEntities } from '@markuplint/shared';
  * @see https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute
  * @see https://html.spec.whatwg.org/multipage/scripting.html#the-template-element
  */
-const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+export const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
 /**
  * The names that the DOM accepts as a shadow host, besides a valid custom element name.
  *
@@ -52,10 +52,13 @@ const SHADOW_HOST_NAMES = new Set([
  * JSX, a `template` with a directive such as `v-if`) leaves its children to the next element
  * above.
  *
+ * `isRenderedAway` of `@markuplint/rules` (`src/helpers.ts`) decides the same of an element for the
+ * rules that walk up the ancestors: a kind added here belongs to it too.
+ *
  * @param node - A node of the syntax tree
  * @returns `true` if the node is not an element of the output
  */
-function isTransparent(
+export function isTransparent(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 node) {
     if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
@@ -81,7 +84,8 @@ el) {
         return false;
     }
     for (const attr of el.attributes) {
-        if (attr.isDirective) {
+        // A spread attribute (`{...props}`) sets attributes of the element, which stays
+        if (attr.isDirective && attr.localName !== '#spread') {
             return true;
         }
     }
@@ -152,12 +156,13 @@ template) {
 }
 /**
  * The element that the HTML parser makes the shadow host of a `template` element: its parent in
- * the output, where what the engine renders away (see {@link isTransparent}) is skipped.
+ * the output, where what the engine renders away (see {@link isTransparent}) is skipped. It is the
+ * parent in the output of any node, so it is the host a light child is a child of.
  *
  * @template T - The rule configuration value type
  * @template O - The rule options type
- * @param template - A `template` element
- * @returns The element, or `null` when the file has none above the template
+ * @param template - A `template` element, or any node whose parent in the output is wanted
+ * @returns The element, or `null` when the file has none above the node
  */
 export function getShadowHost(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -194,6 +199,28 @@ host) {
     const name = host.localName;
     return SHADOW_HOST_NAMES.has(name) || isPotentialCustomElementName(name);
 }
+/**
+ * Whether the children written in `host` are its children in the output, so that a `template`
+ * among them is parsed in it. A pretended component renders them in the element it pretends to
+ * be only when it neither drops them (`slots: null`) nor puts them in a slot wrapper; a custom
+ * element keeps them in its light DOM. This is the same placement as the rendered parent
+ * `MLElement` gives a child for its namespace.
+ *
+ * @param host - The parent element of a `template` element
+ * @returns `false` when the component places the children elsewhere or not at all
+ */
+function rendersChildrenInItself(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+host) {
+    const context = host.pretenderContext;
+    if (context?.type !== 'pretender' || host.elementType === 'web-component') {
+        return true;
+    }
+    if (context.as.childNodes.length === 0) {
+        return false;
+    }
+    return !context.slotContent || context.slotContent.wrapper === context.as;
+}
 /**
  * The `template` elements that sit in the output under the host, in the order of the markup,
  * seen through what the engine renders away.
@@ -248,7 +275,7 @@ template) {
         return 'not-attached';
     }
     const host = getShadowHost(template);
-    if (!host) {
+    if (!host || !rendersChildrenInItself(host)) {
         return 'unknown';
     }
     const hostCheck = canBeShadowHost(host);

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

@@ -50,6 +50,11 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
      * this.
      */
     readonly literalValues?: LiteralValueDeclaration;
+    /**
+     * What the `slot` element is in the language of the document (`MLParser#slotElement`): the HTML
+     * element, or the placeholder of a framework's component, whose slot assignment is not computed.
+     */
+    readonly slotElement: 'html' | 'framework';
     /**
      * The rule currently being evaluated during a lint pass.
      * Set by the linting engine before rule evaluation begins and used by nodes
@@ -151,6 +156,7 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
         readonly booleanish?: boolean;
         readonly attrExpressionLanguage?: ExpressionLanguage;
         readonly literalValues?: LiteralValueDeclaration;
+        readonly slotElement?: 'html' | 'framework';
         readonly tagNameCaseSensitive?: boolean;
         readonly componentNameVariants?: boolean;
         readonly isComponentName?: (name: string) => boolean;
@@ -1784,12 +1790,16 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
     /**
      * Searches for a node at the given source location (line and column).
      *
+     * The node is the innermost one whose source range, from its start, included,
+     * to its end, excluded, holds the position; a position in an end tag is its
+     * element. The rule is `searchNodeAtLocation`'s.
+     *
      * @implements `@markuplint/ml-core` API: `MLDocument`
      * @param line - The 1-based line number to search at
      * @param col - The 1-based column number to search at
      * @returns The node at the given location, or null if not found
      */
-    searchNodeByLocation(line: number, col: number): MLNode<T, O, import("@markuplint/ml-ast").MLASTNode> | null;
+    searchNodeByLocation(line: number, col: number): MLNode<T, O> | null;
     /**
      * Sets the currently active rule for this document. Called by the linting engine
      * before each rule evaluation pass.