@markuplint/ml-core 5.5.0 → 5.6.0

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

@@ -1,8 +1,9 @@
 import { exchangeValueOnRule, mergeRule } from '@markuplint/ml-config';
-import { schemaToSpec, getComputedRole, mayBeFocusable, getComputedAriaProps, isExposed, getSpecByTagName, ARIA_RECOMMENDED_VERSION, } from '@markuplint/ml-spec';
+import { schemaToSpec, getComputedRole, mayBeFocusable, getComputedAriaProps, isExposed, isShadowRoot, getSpecByTagName, ARIA_RECOMMENDED_VERSION, } from '@markuplint/ml-spec';
 import { ConfigParserError, isComponentName } from '@markuplint/parser-utils';
 import { InvalidSelectorError } from '@markuplint/selector';
 import { log as coreLog } from '../../debug.js';
+import { searchNodeAtLocation } from '../../utils/search-node-at-location.js';
 import { createNode } from '../helper/create-node.js';
 import { nodeListToDebugMaps } from '../helper/debug.js';
 import { sequentialWalker, syncWalk } from '../helper/walkers.js';
@@ -48,6 +49,11 @@ export class MLDocument extends MLParentNode {
      * this.
      */
     literalValues;
+    /**
+     * 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.
+     */
+    slotElement;
     /**
      * The rule currently being evaluated during a lint pass.
      * Set by the linting engine before rule evaluation begins and used by nodes
@@ -159,6 +165,7 @@ export class MLDocument extends MLParentNode {
         this.booleanish = options?.booleanish ?? false;
         this.attrExpressionLanguage = options?.attrExpressionLanguage;
         this.literalValues = options?.literalValues;
+        this.slotElement = options?.slotElement ?? 'html';
         this.endTag = options?.endTag ?? 'omittable';
         this.#filename = options?.filename;
         this.tagNameCaseSensitive = options?.tagNameCaseSensitive ?? false;
@@ -179,8 +186,10 @@ export class MLDocument extends MLParentNode {
             return createNode(astNode, this);
         })
             .filter((n) => !!n));
-        this.#pretending(options?.pretenders);
+        // A selector of the configuration is matched here, by a pretender and by a rule, so an
+        // invalid one is the fault of the configuration in both.
         try {
+            this.#pretending(options?.pretenders);
             this.#ruleMapping(ruleset);
         }
         catch (error) {
@@ -2133,7 +2142,16 @@ export class MLDocument extends MLParentNode {
         const focusable = mayBeFocusable(node, node.ownerMLDocument.specs);
         const nameRequired = role.role?.accessibleNameRequired ?? false;
         const nameProhibited = role.role?.accessibleNameProhibited ?? false;
-        const hasSlot = !!node.querySelector('slot');
+        // A slot whose assignment is known is read by `getAccessibleName` above. The slot of a shadow root is in
+        // a tree of its own, so every tree is searched, except the content of an ordinary `template` element,
+        // which is not rendered where it is written.
+        const hasSlot = node.deepQuerySelectorAll('slot').some(slot => {
+            if (slot.getAssignedNodes() !== null) {
+                return false;
+            }
+            const root = slot.getRootNode();
+            return isShadowRoot(root) || !root.is(root.DOCUMENT_FRAGMENT_NODE);
+        });
         aria.role = role.role?.name;
         aria.nameRequired = nameRequired;
         aria.nameProhibited = nameProhibited;
@@ -2338,18 +2356,17 @@ export class MLDocument extends MLParentNode {
     /**
      * 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, col) {
-        for (const node of this.nodeList) {
-            if (node.startLine <= line && line <= node.endLine && node.startCol <= col && col <= node.endCol) {
-                return node;
-            }
-        }
-        return null;
+        return searchNodeAtLocation(this.nodeList, line, col);
     }
     /**
      * Sets the currently active rule for this document. Called by the linting engine

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

@@ -1,4 +1,5 @@
 import type { DeclarativeShadowRootAttachment } from '../helper/tree-scope.js';
+import type { MLChildNode } from './child-node.js';
 import type { MLDocument } from './document.js';
 import type { MLNamedNodeMap } from './named-node-map.js';
 import type { MLNode } from './node.js';
@@ -604,9 +605,10 @@ export declare class MLElement<T extends RuleConfigValue, O extends PlainData =
      */
     get ariaValueText(): string | null;
     /**
-     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     * The slot of an open declarative shadow root that this element is assigned to, or `null` when no
+     * slot takes it, the root is closed (the DOM does not expose it), or the assignment is not known
+     * (see {@link MLElement.getFlatTreeSlot}).
      *
-     * @unsupported
      * @implements DOM API: `Element`
      * @see https://dom.spec.whatwg.org/#dom-slotable-assignedslot
      */
@@ -1938,9 +1940,35 @@ export declare class MLElement<T extends RuleConfigValue, O extends PlainData =
      */
     animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
     /**
+     * The nodes this `slot` places, in tree order, or with `flatten` what it renders in the flat tree. It
+     * is empty when the assignment is not known; use {@link MLElement.getAssignedNodes} to tell the two apart.
+     *
+     * @implements DOM API: `HTMLSlotElement`
      * @see https://html.spec.whatwg.org/multipage/scripting.html#dom-slot-assignednodes
      */
-    assignedNodes(): never[];
+    assignedNodes(options?: AssignedNodesOptions): MLChildNode<T, O>[];
+    /**
+     * The nodes this `slot` places, by the named slot assignment of the declarative shadow root it is in.
+     * A slot that takes none has `[]`, and renders its own children. `null` when the assignment is not
+     * known; what makes it so is in the module comment of `helper/slot-assignment.ts`.
+     *
+     * @implements `@markuplint/ml-core` API: `MLElement`
+     * @see https://dom.spec.whatwg.org/#find-slotables
+     */
+    getAssignedNodes(): readonly MLChildNode<T, O>[] | null;
+    /**
+     * The slot that places this element in the flat tree: the slot of the shadow root of its parent that
+     * takes it. `null` when its parent is a shadow host and no slot takes it, so that it is not rendered;
+     * `undefined` when its parent is not a shadow host, or the assignment is not known
+     * (see {@link MLElement.getAssignedNodes}).
+     *
+     * `getComposedParentElement` of `@markuplint/ml-spec` reads it as the parent that the accessibility
+     * tree has for the element.
+     *
+     * @implements `@markuplint/ml-core` API: `MLElement`
+     * @see https://dom.spec.whatwg.org/#find-a-slot
+     */
+    getFlatTreeSlot(): MLElement<T, O> | null | undefined;
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
      *
@@ -2229,6 +2257,21 @@ export declare class MLElement<T extends RuleConfigValue, O extends PlainData =
      * @returns True if any attribute is dynamic or lacks a name node (spread)
      */
     hasMutableAttributes(): boolean;
+    /**
+     * Checks whether this element is a component whose rendered output is not known: the
+     * parser sees it as a component (`elementType` is `'authored'`) and no pretender stands
+     * for an element of HTML, which includes a pretender whose own target is a component
+     * (the chain of `pretenders.auto` stopped at `Tabs.Root`).
+     *
+     * A web component is not one: it is the element that it is written as. The criterion of
+     * `isTreatedAsCustom` in `@markuplint/rules` (`permitted-contents`) includes it, because
+     * a content model accepts a custom element wherever it accepts flow content; change them
+     * together.
+     *
+     * @implements `@markuplint/ml-core` API: `MLElement`
+     * @returns True if what this element renders is not known
+     */
+    isUnresolvedComponent(): boolean;
     /**
      * Checks whether this element has children that are potentially mutable,
      * such as preprocessor-specific blocks, slot elements, or (optionally) elements
@@ -2243,15 +2286,26 @@ export declare class MLElement<T extends RuleConfigValue, O extends PlainData =
      * A component that no pretender resolved renders something that is not known, however its
      * attributes are written (`size={size}`, `size={16}` and `size="16"` tell the same): a rule that
      * asks about what the descendants are or have (the accessible name, the owned elements) cannot decide
-     * on it, so it is mutable when `attr` is true. A component that a pretender resolved is the element
-     * that it renders, which the rules read themselves.
+     * on it, so it is mutable when `attr` is true ({@link MLElement.isUnresolvedComponent}). A component
+     * that a pretender resolved is the element that it renders, which the rules read themselves.
+     *
+     * A rule that asks which children an element has (the required children, the elements that
+     * satisfy a query) does not pass `attr`: an attribute that cannot be known does not decide whether
+     * a child exists. It looks for the unresolved components among the children itself.
+     *
+     * Every `slot` is mutable by default, as a `slot` that is not in a declarative shadow root renders what
+     * is given to it, and a rule that reads the children as they are written (`require-datetime`) cannot
+     * know it. A rule that reads what a slot of a shadow root renders by `MLElement#getAssignedNodes` says
+     * which slots are with `isMutableSlot`.
+     *
      *
      * @implements `@markuplint/ml-core` API: `MLElement`
      * @param attr - When true, also considers children with mutable attributes, and components that no
      * pretender resolved, as mutable
+     * @param isMutableSlot - Whether a `slot` among the descendants may render what is not known
      * @returns True if this element has potentially mutable children
      */
-    hasMutableChildren(attr?: boolean): boolean;
+    hasMutableChildren(attr?: boolean, isMutableSlot?: (slot: MLElement<T, O>) => boolean): boolean;
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
      *

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

@@ -2,11 +2,12 @@
 var _a;
 import { getSpecByTagName, resolveNamespace } from '@markuplint/ml-spec';
 import { pretenderNamespaceToURI } from '@markuplint/ml-config';
-import { getChildNamespace } from '@markuplint/parser-utils';
-import { matchSelector, typeNameMatches } from '@markuplint/selector';
+import { ConfigParserError, getChildNamespace } from '@markuplint/parser-utils';
+import { InvalidSelectorError, matchSelector, typeNameMatches } from '@markuplint/selector';
 import { getAccname, getAccnameVisits, getHostLanguageLabelSource, getReferencedTextAlternative, } from '../helper/accname.js';
 import { literalToExpression } from '../helper/literal-values.js';
 import { markPretendedAttr } from '../helper/pretended-attrs.js';
+import { getAssignedNodes, getAssignedSlot, getFlatTreeSlot, getFlattenedSlottables, } from '../helper/slot-assignment.js';
 import { getDeclarativeShadowRootAttachment, getDeclarativeShadowRootMode, getShadowRootTemplate, isHTMLTemplateElement, } from '../helper/tree-scope.js';
 import { after, before, nextElementSibling, previousElementSibling, remove, replaceWith, } from '../manipulations/child-node-methods.js';
 import { MLAttr } from './attr.js';
@@ -17,7 +18,7 @@ import { toNamedNodeMap } from './named-node-map.js';
 import { toHTMLCollection, toNodeList } from './node-list.js';
 import { MLParentNode } from './parent-node.js';
 import { MLShadowRoot } from './shadow-root.js';
-import { UnexpectedCallError, asciiLowerCase, vuePropKey } from '@markuplint/shared';
+import { UnexpectedCallError, asciiLowerCase, isFatalError, vuePropKey } from '@markuplint/shared';
 const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
 /**
  * Represents a DOM Element node wrapper in the markuplint DOM tree.
@@ -835,14 +836,15 @@ export class MLElement extends MLParentNode {
         throw new UnexpectedCallError('Not supported "ariaValueText" property');
     }
     /**
-     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     * The slot of an open declarative shadow root that this element is assigned to, or `null` when no
+     * slot takes it, the root is closed (the DOM does not expose it), or the assignment is not known
+     * (see {@link MLElement.getFlatTreeSlot}).
      *
-     * @unsupported
      * @implements DOM API: `Element`
      * @see https://dom.spec.whatwg.org/#dom-slotable-assignedslot
      */
     get assignedSlot() {
-        throw new UnexpectedCallError('Not supported "assignedSlot" property');
+        return getAssignedSlot(this);
     }
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
@@ -2566,13 +2568,43 @@ export class MLElement extends MLParentNode {
         throw new UnexpectedCallError('Not supported "animate" method');
     }
     /**
+     * The nodes this `slot` places, in tree order, or with `flatten` what it renders in the flat tree. It
+     * is empty when the assignment is not known; use {@link MLElement.getAssignedNodes} to tell the two apart.
+     *
+     * @implements DOM API: `HTMLSlotElement`
      * @see https://html.spec.whatwg.org/multipage/scripting.html#dom-slot-assignednodes
      */
-    assignedNodes() {
+    assignedNodes(options) {
         if (this.localName !== 'slot') {
             throw new TypeError('assignedNodes is not a function');
         }
-        return [];
+        return [...(options?.flatten ? getFlattenedSlottables(this) : (this.getAssignedNodes() ?? []))];
+    }
+    /**
+     * The nodes this `slot` places, by the named slot assignment of the declarative shadow root it is in.
+     * A slot that takes none has `[]`, and renders its own children. `null` when the assignment is not
+     * known; what makes it so is in the module comment of `helper/slot-assignment.ts`.
+     *
+     * @implements `@markuplint/ml-core` API: `MLElement`
+     * @see https://dom.spec.whatwg.org/#find-slotables
+     */
+    getAssignedNodes() {
+        return getAssignedNodes(this);
+    }
+    /**
+     * The slot that places this element in the flat tree: the slot of the shadow root of its parent that
+     * takes it. `null` when its parent is a shadow host and no slot takes it, so that it is not rendered;
+     * `undefined` when its parent is not a shadow host, or the assignment is not known
+     * (see {@link MLElement.getAssignedNodes}).
+     *
+     * `getComposedParentElement` of `@markuplint/ml-spec` reads it as the parent that the accessibility
+     * tree has for the element.
+     *
+     * @implements `@markuplint/ml-core` API: `MLElement`
+     * @see https://dom.spec.whatwg.org/#find-a-slot
+     */
+    getFlatTreeSlot() {
+        return getFlatTreeSlot(this);
     }
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
@@ -3036,6 +3068,26 @@ export class MLElement extends MLParentNode {
         }
         return false;
     }
+    /**
+     * Checks whether this element is a component whose rendered output is not known: the
+     * parser sees it as a component (`elementType` is `'authored'`) and no pretender stands
+     * for an element of HTML, which includes a pretender whose own target is a component
+     * (the chain of `pretenders.auto` stopped at `Tabs.Root`).
+     *
+     * A web component is not one: it is the element that it is written as. The criterion of
+     * `isTreatedAsCustom` in `@markuplint/rules` (`permitted-contents`) includes it, because
+     * a content model accepts a custom element wherever it accepts flow content; change them
+     * together.
+     *
+     * @implements `@markuplint/ml-core` API: `MLElement`
+     * @returns True if what this element renders is not known
+     */
+    isUnresolvedComponent() {
+        if (this.pretenderContext?.type === 'pretender') {
+            return this.pretenderContext.as.elementType === 'authored';
+        }
+        return this.elementType === 'authored';
+    }
     /**
      * Checks whether this element has children that are potentially mutable,
      * such as preprocessor-specific blocks, slot elements, or (optionally) elements
@@ -3050,15 +3102,26 @@ export class MLElement extends MLParentNode {
      * A component that no pretender resolved renders something that is not known, however its
      * attributes are written (`size={size}`, `size={16}` and `size="16"` tell the same): a rule that
      * asks about what the descendants are or have (the accessible name, the owned elements) cannot decide
-     * on it, so it is mutable when `attr` is true. A component that a pretender resolved is the element
-     * that it renders, which the rules read themselves.
+     * on it, so it is mutable when `attr` is true ({@link MLElement.isUnresolvedComponent}). A component
+     * that a pretender resolved is the element that it renders, which the rules read themselves.
+     *
+     * A rule that asks which children an element has (the required children, the elements that
+     * satisfy a query) does not pass `attr`: an attribute that cannot be known does not decide whether
+     * a child exists. It looks for the unresolved components among the children itself.
+     *
+     * Every `slot` is mutable by default, as a `slot` that is not in a declarative shadow root renders what
+     * is given to it, and a rule that reads the children as they are written (`require-datetime`) cannot
+     * know it. A rule that reads what a slot of a shadow root renders by `MLElement#getAssignedNodes` says
+     * which slots are with `isMutableSlot`.
+     *
      *
      * @implements `@markuplint/ml-core` API: `MLElement`
      * @param attr - When true, also considers children with mutable attributes, and components that no
      * pretender resolved, as mutable
+     * @param isMutableSlot - Whether a `slot` among the descendants may render what is not known
      * @returns True if this element has potentially mutable children
      */
-    hasMutableChildren(attr = false) {
+    hasMutableChildren(attr = false, isMutableSlot = () => true) {
         for (const child of this.getPureChildNodes()) {
             if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
                 if (child.blockBehavior) {
@@ -3070,13 +3133,13 @@ export class MLElement extends MLParentNode {
                 if (attr && child.hasMutableAttributes()) {
                     return true;
                 }
-                if (attr && child.elementType === 'authored' && child.pretenderContext?.type !== 'pretender') {
+                if (attr && child.isUnresolvedComponent()) {
                     return true;
                 }
-                if (child.hasMutableChildren(attr)) {
+                if (child.hasMutableChildren(attr, isMutableSlot)) {
                     return true;
                 }
-                if (child.localName === 'slot') {
+                if (child.localName === 'slot' && isMutableSlot(child)) {
                     return true;
                 }
             }
@@ -3335,7 +3398,19 @@ export class MLElement extends MLParentNode {
         if (this.elementType === 'html' && this.ownerMLDocument.isNativeTag(this.localName, this.namespaceURI)) {
             return;
         }
-        const pretenderConfig = pretenders?.find(option => this.matches(option.selector));
+        const pretenderConfig = pretenders?.find(option => {
+            try {
+                return this.matches(option.selector);
+            }
+            catch (error) {
+                // An entry that a scan or a file made names the file that declares its component, which is
+                // where the user fixes it. `MLDocument` names the configuration for any other.
+                if (!isFatalError(error) && error instanceof InvalidSelectorError && option.filePath) {
+                    throw new ConfigParserError(error.message, { filePath: option.filePath, raw: option.selector });
+                }
+                throw error;
+            }
+        });
         const asAttrValue = this.getAttribute('as');
         const pretenderElement = pretenderConfig?.as ??
             (this.elementType === 'html' || !asAttrValue

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

@@ -256,8 +256,8 @@ export declare abstract class MLNode<T extends RuleConfigValue, O extends PlainD
      * A `template` element that is in no tree has none either.
      *
      * The selector engine and `closest()` read it, so that `section p` does not match a `p` in the
-     * content of a `template` in a `section`. {@link MLNode.parentElement} stays the syntactical one
-     * because the content model of a `template` element is validated against what is in it.
+     * content of a `template` in a `section`. {@link MLNode.parentElement} does not stop at that
+     * boundary because the content model of a `template` element is validated against what is in it.
      *
      * `getTreeParentElement` of `@markuplint/ml-spec`, which cannot use this getter, derives the same
      * answer from `getRootNode()` for the algorithms of that package: a change of the boundary here
@@ -269,6 +269,10 @@ export declare abstract class MLNode<T extends RuleConfigValue, O extends PlainD
     /**
      * The parent node that may be `Element`, `Document`, `DocumentFragment`, and `null`.
      *
+     * A block of a template language is walked through (`MLBlock#isTransparent`): a node in a block
+     * has the node that contains the block as its parent. A node at the top of a fragment document
+     * has none.
+     *
      * ## HTML:
      *
      * ```html
@@ -289,10 +293,10 @@ export declare abstract class MLNode<T extends RuleConfigValue, O extends PlainD
      *
      * ```jsx
      * <> // => null
-     *   <div> // => #document-fragment
+     *   <div> // => <>
      *     {items.map(item => {
      *       return (
-     *         <span /> // => null
+     *         <span /> // => <div>
      *       )
      *     })}
      *   </div>
@@ -356,7 +360,7 @@ export declare abstract class MLNode<T extends RuleConfigValue, O extends PlainD
      *
      * ```jsx
      * <> // => #document
-     *   <div> // => #document-fragment
+     *   <div> // => <>
      *     {items.map(item => {
      *       return (
      *         <span /> // => #ml-block
@@ -540,6 +544,9 @@ export declare abstract class MLNode<T extends RuleConfigValue, O extends PlainD
      */
     isEqualNode(otherNode: Node | null): boolean;
     /**
+     * Whether the document of this node is a fragment of a document (a partial, a component) and
+     * not a whole one. The parser of the document decides it (`MLDocument#isFragment`).
+     *
      * @implements `@markuplint/ml-core` API: `MLNode`
      */
     isInFragmentDocument(): boolean;

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

@@ -333,8 +333,8 @@ export class MLNode extends MLToken {
      * A `template` element that is in no tree has none either.
      *
      * The selector engine and `closest()` read it, so that `section p` does not match a `p` in the
-     * content of a `template` in a `section`. {@link MLNode.parentElement} stays the syntactical one
-     * because the content model of a `template` element is validated against what is in it.
+     * content of a `template` in a `section`. {@link MLNode.parentElement} does not stop at that
+     * boundary because the content model of a `template` element is validated against what is in it.
      *
      * `getTreeParentElement` of `@markuplint/ml-spec`, which cannot use this getter, derives the same
      * answer from `getRootNode()` for the algorithms of that package: a change of the boundary here
@@ -355,6 +355,10 @@ export class MLNode extends MLToken {
     /**
      * The parent node that may be `Element`, `Document`, `DocumentFragment`, and `null`.
      *
+     * A block of a template language is walked through (`MLBlock#isTransparent`): a node in a block
+     * has the node that contains the block as its parent. A node at the top of a fragment document
+     * has none.
+     *
      * ## HTML:
      *
      * ```html
@@ -375,10 +379,10 @@ export class MLNode extends MLToken {
      *
      * ```jsx
      * <> // => null
-     *   <div> // => #document-fragment
+     *   <div> // => <>
      *     {items.map(item => {
      *       return (
-     *         <span /> // => null
+     *         <span /> // => <div>
      *       )
      *     })}
      *   </div>
@@ -511,7 +515,7 @@ export class MLNode extends MLToken {
      *
      * ```jsx
      * <> // => #document
-     *   <div> // => #document-fragment
+     *   <div> // => <>
      *     {items.map(item => {
      *       return (
      *         <span /> // => #ml-block
@@ -907,6 +911,9 @@ export class MLNode extends MLToken {
         throw new UnexpectedCallError('Not supported "isEqualNode" method');
     }
     /**
+     * Whether the document of this node is a fragment of a document (a partial, a component) and
+     * not a whole one. The parser of the document decides it (`MLDocument#isFragment`).
+     *
      * @implements `@markuplint/ml-core` API: `MLNode`
      */
     isInFragmentDocument() {

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

@@ -1,3 +1,4 @@
+import type { MLElement } from './element.js';
 import type { TextNodeType } from './types.js';
 import type { MLASTText } from '@markuplint/ml-ast';
 import type { PlainData, RuleConfigValue } from '@markuplint/ml-config';
@@ -12,12 +13,20 @@ import { MLCharacterData } from './character-data.js';
  */
 export declare class MLText<T extends RuleConfigValue, O extends PlainData = undefined> extends MLCharacterData<T, O, MLASTText> implements Text {
     /**
-     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     * The slot of an open declarative shadow root that this text is assigned to, or `null` when no
+     * slot takes it, the root is closed (the DOM does not expose it), or the assignment is not known.
      *
-     * @unsupported
      * @implements DOM API: `Text`
+     * @see https://dom.spec.whatwg.org/#dom-slotable-assignedslot
+     */
+    get assignedSlot(): HTMLSlotElement | null;
+    /**
+     * The slot that places this text in the flat tree. See {@link MLElement.getFlatTreeSlot}.
+     *
+     * @implements `@markuplint/ml-core` API: `MLText`
+     * @see https://dom.spec.whatwg.org/#find-a-slot
      */
-    get assignedSlot(): HTMLSlotElement;
+    getFlatTreeSlot(): MLElement<T, O> | null | undefined;
     /**
      * Returns `true` if this text node originated from an invalid (bogus) AST
      * node, such as an orphaned end tag.

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

@@ -1,3 +1,4 @@
+import { getAssignedSlot, getFlatTreeSlot } from '../helper/slot-assignment.js';
 import { MLCharacterData } from './character-data.js';
 import { UnexpectedCallError } from '@markuplint/shared';
 /**
@@ -16,13 +17,23 @@ const rawTextElements = new Set(['script', 'style']);
  */
 export class MLText extends MLCharacterData {
     /**
-     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     * The slot of an open declarative shadow root that this text is assigned to, or `null` when no
+     * slot takes it, the root is closed (the DOM does not expose it), or the assignment is not known.
      *
-     * @unsupported
      * @implements DOM API: `Text`
+     * @see https://dom.spec.whatwg.org/#dom-slotable-assignedslot
      */
     get assignedSlot() {
-        throw new UnexpectedCallError('Not supported  "assignedSlot" property');
+        return getAssignedSlot(this);
+    }
+    /**
+     * The slot that places this text in the flat tree. See {@link MLElement.getFlatTreeSlot}.
+     *
+     * @implements `@markuplint/ml-core` API: `MLText`
+     * @see https://dom.spec.whatwg.org/#find-a-slot
+     */
+    getFlatTreeSlot() {
+        return getFlatTreeSlot(this);
     }
     /**
      * Returns `true` if this text node originated from an invalid (bogus) AST

package/lib/test/index.js

@@ -22,6 +22,7 @@ export function createTestDocument(sourceCode, options) {
         booleanish: usedParser.booleanish,
         attrExpressionLanguage: usedParser.attrExpressionLanguage,
         literalValues: usedParser.literalValues,
+        slotElement: usedParser.slotElement,
         tagNameCaseSensitive: usedParser.tagNameCaseSensitive,
         componentNameVariants: usedParser.componentNameVariants,
         isComponentName: usedParser.isComponentName?.bind(usedParser),

package/lib/utils/index.d.ts

@@ -1 +1,3 @@
 export { getLocationFromChars } from './get-location-from-chars.js';
+export type { LocatedNode, LocatedToken } from './search-node-at-location.js';
+export { searchNodeAtLocation } from './search-node-at-location.js';

package/lib/utils/index.js

@@ -1 +1,2 @@
 export { getLocationFromChars } from './get-location-from-chars.js';
+export { searchNodeAtLocation } from './search-node-at-location.js';

package/lib/utils/search-node-at-location.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A source range: from its start, included, to its end, excluded (the end is
+ * where the next token starts). Without an end, it holds only its start.
+ */
+export interface LocatedToken {
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly endLine?: number;
+    readonly endCol?: number;
+}
+/**
+ * A node with its source range. The range of an element is its start tag; its
+ * end tag, which is not in a document's node list, is `closeTag`.
+ */
+export interface LocatedNode extends LocatedToken {
+    readonly closeTag?: LocatedToken | null;
+}
+/**
+ * Finds the node of `nodeList` at the source location `line`:`col` (both 1-based).
+ *
+ * The node is the one whose range holds the position, or whose end tag does: a
+ * document's node list has no attribute nodes and no end tags, so a position at
+ * an attribute, inside its value or in an end tag is the element that has it. Of
+ * several such nodes the last in the list is taken: the innermost. A block
+ * (`#ml-block`) holds the elements nested in it, and an omitted element
+ * (`<tbody>` with an empty source) starts where its first child does.
+ *
+ * The list is in document order, as the parser sorts its nodes by offset, so the
+ * search stops at the first node that starts after the position. It works on the
+ * structural `LocatedNode` so that it reads the node list of any version of the
+ * engine: the language server searches the document of the markuplint the user
+ * installed, and the suppressions search a node list cast to their own type.
+ *
+ * @param nodeList - The nodes of a document, in document order.
+ * @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 location, or `null` if there is none.
+ */
+export declare function searchNodeAtLocation<N extends LocatedNode>(nodeList: Iterable<N>, line: number, col: number): N | null;

package/lib/utils/search-node-at-location.js

@@ -0,0 +1,53 @@
+/**
+ * Finds the node of `nodeList` at the source location `line`:`col` (both 1-based).
+ *
+ * The node is the one whose range holds the position, or whose end tag does: a
+ * document's node list has no attribute nodes and no end tags, so a position at
+ * an attribute, inside its value or in an end tag is the element that has it. Of
+ * several such nodes the last in the list is taken: the innermost. A block
+ * (`#ml-block`) holds the elements nested in it, and an omitted element
+ * (`<tbody>` with an empty source) starts where its first child does.
+ *
+ * The list is in document order, as the parser sorts its nodes by offset, so the
+ * search stops at the first node that starts after the position. It works on the
+ * structural `LocatedNode` so that it reads the node list of any version of the
+ * engine: the language server searches the document of the markuplint the user
+ * installed, and the suppressions search a node list cast to their own type.
+ *
+ * @param nodeList - The nodes of a document, in document order.
+ * @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 location, or `null` if there is none.
+ */
+export function searchNodeAtLocation(nodeList, line, col) {
+    let found = null;
+    for (const node of nodeList) {
+        if (isBefore(line, col, node)) {
+            break;
+        }
+        if (holdsLocation(node, line, col) || (node.closeTag != null && holdsLocation(node.closeTag, line, col))) {
+            found = node;
+        }
+    }
+    return found;
+}
+/** Whether `line`:`col` comes before the start of `token`. */
+function isBefore(line, col, token) {
+    return line < token.startLine || (line === token.startLine && col < token.startCol);
+}
+/**
+ * Whether `line`:`col` is the start of `token` or in its range. The start is
+ * compared first: the end of an `MLNode` is computed from its source on every read.
+ */
+function holdsLocation(token, line, col) {
+    if (isBefore(line, col, token)) {
+        return false;
+    }
+    if (line === token.startLine && col === token.startCol) {
+        return true;
+    }
+    if (token.endLine === undefined || token.endCol === undefined) {
+        return false;
+    }
+    return line < token.endLine || (line === token.endLine && col < token.endCol);
+}