@markuplint/ml-core 4.13.2 → 5.0.0-alpha.0

package/lib/ml-core.d.ts

@@ -2,17 +2,53 @@ import type { MLFabric } from './types.js';
 import type { PlainData, RuleConfigValue, Violation } from '@markuplint/ml-config';
 import { ParserError } from '@markuplint/parser-utils';
 import { Document } from './ml-dom/index.js';
+/**
+ * Parameters for constructing an {@link MLCore} instance.
+ * Extends {@link MLFabric} with the source code, filename, and debug flag.
+ */
 export type MLCoreParams = {
+    /** The markup source code to lint */
     readonly sourceCode: string;
+    /** The filename associated with the source code */
     readonly filename: string;
+    /** Whether to enable debug logging */
     readonly debug?: boolean;
 } & MLFabric;
+/**
+ * The core linting engine for markuplint.
+ *
+ * Parses markup source code into an AST, constructs a DOM document,
+ * and verifies it against configured rules to produce violations.
+ */
 export declare class MLCore {
     #private;
-    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, severity, pretenders, filename, debug, configErrors, }: MLCoreParams);
+    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, ruleCommonSettings, parserOptions, severity, pretenders, filename, debug, configErrors, }: MLCoreParams);
+    /**
+     * The parsed document, or a {@link ParserError} if parsing failed.
+     */
     get document(): ParserError | Document<RuleConfigValue, PlainData>;
+    /**
+     * Replaces the source code and re-parses the document.
+     *
+     * @param sourceCode - The new markup source code
+     */
     setCode(sourceCode: string): void;
+    /**
+     * Updates the linting configuration and re-creates the document.
+     * Only re-parses if parser options have changed.
+     *
+     * @param fabric - Partial fabric with the properties to update
+     */
     update({ parser, ruleset, rules, locale, schemas, parserOptions, configErrors }: Partial<MLFabric>): void;
+    /**
+     * Runs all configured rules against the parsed document and returns violations.
+     *
+     * If the document failed to parse, a single parse-error violation is returned
+     * (unless parse errors are suppressed via severity options).
+     *
+     * @param fix - Whether to attempt auto-fixing violations
+     * @returns An array of violations found during verification
+     */
     verify(fix?: boolean): Promise<Violation[]>;
     private _createDocument;
     private _createParseError;

package/lib/ml-core.js

@@ -1,100 +1,169 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MLCore_ast, _MLCore_document, _MLCore_filename, _MLCore_locale, _MLCore_parser, _MLCore_parserOptions, _MLCore_severity, _MLCore_pretenders, _MLCore_rules, _MLCore_ruleset, _MLCore_schemas, _MLCore_sourceCode, _MLCore_configErrors;
 import { ParserError } from '@markuplint/parser-utils';
 import { log, enableDebug } from './debug.js';
 import { Document } from './ml-dom/index.js';
+import { expandNamedNodeRules, expandNamedRules } from './virtual-rule.js';
 const resultLog = log.extend('result');
+/**
+ * The core linting engine for markuplint.
+ *
+ * Parses markup source code into an AST, constructs a DOM document,
+ * and verifies it against configured rules to produce violations.
+ */
 export class MLCore {
-    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, severity, pretenders, filename, debug, configErrors, }) {
-        _MLCore_ast.set(this, null);
-        _MLCore_document.set(this, void 0);
-        _MLCore_filename.set(this, void 0);
-        _MLCore_locale.set(this, void 0);
-        _MLCore_parser.set(this, void 0);
-        _MLCore_parserOptions.set(this, void 0);
-        _MLCore_severity.set(this, void 0);
-        _MLCore_pretenders.set(this, void 0);
-        _MLCore_rules.set(this, void 0);
-        _MLCore_ruleset.set(this, void 0);
-        _MLCore_schemas.set(this, void 0);
-        _MLCore_sourceCode.set(this, void 0);
-        _MLCore_configErrors.set(this, void 0);
+    #ast = null;
+    #document;
+    #filename;
+    #locale;
+    #parser;
+    #parserOptions;
+    #severity;
+    #pretenders;
+    #rules;
+    #ruleset;
+    #schemas;
+    #ruleCommonSettings;
+    #sourceCode;
+    #configErrors;
+    /**
+     * Pre-expansion nodeRules preserved for hot-reload.
+     * When `update()` is called without a new ruleset, these are used as the
+     * source for `expandNamedNodeRules()` instead of the already-transformed
+     * `#ruleset.nodeRules` (which has alias keys and no `name` property).
+     */
+    #originalNodeRules;
+    #originalChildNodeRules;
+    /**
+     * Pre-computed namespace prefixes from wildcard disable entries.
+     * e.g., `rules["a11y/*"]: false` yields `"a11y/"`.
+     */
+    #disabledNamespaces;
+    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, ruleCommonSettings, parserOptions, severity, pretenders, filename, debug, configErrors, }) {
         if (debug) {
             enableDebug();
         }
-        __classPrivateFieldSet(this, _MLCore_parser, parser, "f");
-        __classPrivateFieldSet(this, _MLCore_sourceCode, sourceCode, "f");
-        __classPrivateFieldSet(this, _MLCore_parserOptions, parserOptions, "f");
-        __classPrivateFieldSet(this, _MLCore_ruleset, {
-            rules: ruleset.rules ?? {},
-            nodeRules: ruleset.nodeRules ?? [],
-            childNodeRules: ruleset.childNodeRules ?? [],
-        }, "f");
-        __classPrivateFieldSet(this, _MLCore_locale, locale, "f");
-        __classPrivateFieldSet(this, _MLCore_schemas, schemas, "f");
-        __classPrivateFieldSet(this, _MLCore_filename, filename, "f");
-        __classPrivateFieldSet(this, _MLCore_rules, [...rules], "f");
-        __classPrivateFieldSet(this, _MLCore_severity, severity, "f");
-        __classPrivateFieldSet(this, _MLCore_pretenders, [...pretenders], "f");
-        __classPrivateFieldSet(this, _MLCore_configErrors, [...(configErrors ?? [])], "f");
+        this.#parser = parser;
+        this.#sourceCode = sourceCode;
+        this.#parserOptions = parserOptions;
+        this.#locale = locale;
+        this.#schemas = schemas;
+        this.#ruleCommonSettings = ruleCommonSettings;
+        this.#filename = filename;
+        this.#severity = severity;
+        this.#pretenders = [...pretenders];
+        this.#configErrors = [...(configErrors ?? [])];
+        // Preserve pre-expansion nodeRules for hot-reload
+        this.#originalNodeRules = ruleset.nodeRules ?? [];
+        this.#originalChildNodeRules = ruleset.childNodeRules ?? [];
+        // Expand named rule groups in the rules section
+        const namedRulesResult = expandNamedRules(ruleset.rules ?? {}, rules);
+        // Expand named nodeRules into virtual rules (using expanded rules as base)
+        const allRulesForExpansion = [...rules, ...namedRulesResult.virtualRules];
+        const nodeRuleResult = expandNamedNodeRules(this.#originalNodeRules, allRulesForExpansion);
+        const childNodeRuleResult = expandNamedNodeRules(this.#originalChildNodeRules, allRulesForExpansion);
+        const resolvedRules = namedRulesResult.resolvedRules;
+        this.#rules = [...allRulesForExpansion, ...nodeRuleResult.virtualRules, ...childNodeRuleResult.virtualRules];
+        this.#ruleset = {
+            rules: resolvedRules,
+            nodeRules: nodeRuleResult.transformedNodeRules,
+            childNodeRules: childNodeRuleResult.transformedNodeRules,
+        };
+        this.#disabledNamespaces = extractDisabledNamespaces(resolvedRules);
+        this.#configErrors.push(...namedRulesResult.errors, ...nodeRuleResult.errors, ...childNodeRuleResult.errors);
         this._parse();
         this._createDocument();
     }
+    /**
+     * The parsed document, or a {@link ParserError} if parsing failed.
+     */
     get document() {
-        return __classPrivateFieldGet(this, _MLCore_document, "f");
+        return this.#document;
     }
+    /**
+     * Replaces the source code and re-parses the document.
+     *
+     * @param sourceCode - The new markup source code
+     */
     setCode(sourceCode) {
-        __classPrivateFieldSet(this, _MLCore_sourceCode, sourceCode, "f");
+        this.#sourceCode = sourceCode;
         this._parse();
         this._createDocument();
     }
+    /**
+     * Updates the linting configuration and re-creates the document.
+     * Only re-parses if parser options have changed.
+     *
+     * @param fabric - Partial fabric with the properties to update
+     */
     update({ parser, ruleset, rules, locale, schemas, parserOptions, configErrors }) {
-        __classPrivateFieldSet(this, _MLCore_parser, parser ?? __classPrivateFieldGet(this, _MLCore_parser, "f"), "f");
-        __classPrivateFieldSet(this, _MLCore_ruleset, {
-            rules: ruleset?.rules ?? __classPrivateFieldGet(this, _MLCore_ruleset, "f").rules,
-            nodeRules: ruleset?.nodeRules ?? __classPrivateFieldGet(this, _MLCore_ruleset, "f").nodeRules,
-            childNodeRules: ruleset?.childNodeRules ?? __classPrivateFieldGet(this, _MLCore_ruleset, "f").childNodeRules,
-        }, "f");
-        __classPrivateFieldSet(this, _MLCore_rules, rules?.slice() ?? __classPrivateFieldGet(this, _MLCore_rules, "f"), "f");
-        __classPrivateFieldSet(this, _MLCore_locale, locale ?? __classPrivateFieldGet(this, _MLCore_locale, "f"), "f");
-        __classPrivateFieldSet(this, _MLCore_schemas, schemas ?? __classPrivateFieldGet(this, _MLCore_schemas, "f"), "f");
-        __classPrivateFieldSet(this, _MLCore_configErrors, [...(configErrors ?? [])], "f");
+        this.#parser = parser ?? this.#parser;
+        this.#locale = locale ?? this.#locale;
+        this.#schemas = schemas ?? this.#schemas;
+        this.#configErrors = [...(configErrors ?? [])];
+        const baseRules = rules?.slice() ?? this.#rules.filter(r => !r.baseRuleId);
+        // Use pre-expansion originals as fallback when ruleset is not provided
+        const incomingNodeRules = ruleset?.nodeRules ?? this.#originalNodeRules;
+        const incomingChildNodeRules = ruleset?.childNodeRules ?? this.#originalChildNodeRules;
+        // Expand named rule groups in the rules section
+        const incomingRules = ruleset?.rules ?? this.#ruleset.rules;
+        const namedRulesResult = expandNamedRules(incomingRules, baseRules);
+        const allRulesForExpansion = [...baseRules, ...namedRulesResult.virtualRules];
+        const nodeRuleResult = expandNamedNodeRules(incomingNodeRules, allRulesForExpansion);
+        const childNodeRuleResult = expandNamedNodeRules(incomingChildNodeRules, allRulesForExpansion);
+        // Update originals if new data was provided
+        if (ruleset?.nodeRules) {
+            this.#originalNodeRules = ruleset.nodeRules;
+        }
+        if (ruleset?.childNodeRules) {
+            this.#originalChildNodeRules = ruleset.childNodeRules;
+        }
+        const resolvedRules = namedRulesResult.resolvedRules;
+        this.#rules = [...allRulesForExpansion, ...nodeRuleResult.virtualRules, ...childNodeRuleResult.virtualRules];
+        this.#ruleset = {
+            rules: resolvedRules,
+            nodeRules: nodeRuleResult.transformedNodeRules,
+            childNodeRules: childNodeRuleResult.transformedNodeRules,
+        };
+        this.#disabledNamespaces = extractDisabledNamespaces(resolvedRules);
+        this.#configErrors.push(...namedRulesResult.errors, ...nodeRuleResult.errors, ...childNodeRuleResult.errors);
         if (parserOptions &&
-            (parserOptions.ignoreFrontMatter !== __classPrivateFieldGet(this, _MLCore_parserOptions, "f").ignoreFrontMatter ||
-                parserOptions.authoredElementName !== __classPrivateFieldGet(this, _MLCore_parserOptions, "f").authoredElementName)) {
+            (parserOptions.ignoreFrontMatter !== this.#parserOptions.ignoreFrontMatter ||
+                parserOptions.authoredElementName !== this.#parserOptions.authoredElementName)) {
             this._parse();
         }
         this._createDocument();
     }
+    /**
+     * Runs all configured rules against the parsed document and returns violations.
+     *
+     * If the document failed to parse, a single parse-error violation is returned
+     * (unless parse errors are suppressed via severity options).
+     *
+     * @param fix - Whether to attempt auto-fixing violations
+     * @returns An array of violations found during verification
+     */
     async verify(fix = false) {
         log('verify: start');
         const violations = [];
-        if (__classPrivateFieldGet(this, _MLCore_document, "f") instanceof ParserError) {
-            const parseError = this._createParseError(__classPrivateFieldGet(this, _MLCore_document, "f").message, __classPrivateFieldGet(this, _MLCore_document, "f").line, __classPrivateFieldGet(this, _MLCore_document, "f").col, __classPrivateFieldGet(this, _MLCore_document, "f").raw);
+        if (this.#document instanceof ParserError) {
+            const parseError = this._createParseError(this.#document.message, this.#document.line, this.#document.col, this.#document.raw);
             if (!parseError) {
                 return [];
             }
             violations.push(parseError);
-            log('verify: error %o', __classPrivateFieldGet(this, _MLCore_document, "f").message);
+            log('verify: error %o', this.#document.message);
             return violations;
         }
-        const definedRuleName = new Set(__classPrivateFieldGet(this, _MLCore_rules, "f").map(rule => rule.name));
+        const definedRuleName = new Set(this.#rules.map(rule => rule.name));
         const setRuleNames = new Set([
-            ...Object.keys(__classPrivateFieldGet(this, _MLCore_ruleset, "f").rules),
-            ...__classPrivateFieldGet(this, _MLCore_ruleset, "f").nodeRules.flatMap(nodeRule => Object.keys(nodeRule.rules ?? {})),
-            ...__classPrivateFieldGet(this, _MLCore_ruleset, "f").childNodeRules.flatMap(childNodeRule => Object.keys(childNodeRule.rules ?? {})),
+            ...Object.keys(this.#ruleset.rules),
+            ...this.#ruleset.nodeRules.flatMap(nodeRule => Object.keys(nodeRule.rules ?? {})),
+            ...this.#ruleset.childNodeRules.flatMap(childNodeRule => Object.keys(childNodeRule.rules ?? {})),
         ]);
         for (const setRuleName of setRuleNames) {
+            // Skip wildcard patterns (e.g., "a11y/*") — they are namespace disable entries, not rule references
+            if (setRuleName.endsWith('/*')) {
+                continue;
+            }
             if (!definedRuleName.has(setRuleName)) {
                 violations.push({
                     ruleId: 'config-error',
@@ -106,7 +175,7 @@ export class MLCore {
                 });
             }
         }
-        for (const error of __classPrivateFieldGet(this, _MLCore_configErrors, "f")) {
+        for (const error of this.#configErrors) {
             violations.push({
                 ruleId: 'config-error',
                 severity: 'warning',
@@ -116,13 +185,25 @@ export class MLCore {
                 raw: '',
             });
         }
-        for (const rule of __classPrivateFieldGet(this, _MLCore_rules, "f")) {
-            const ruleInfo = rule.getRuleInfo(__classPrivateFieldGet(this, _MLCore_ruleset, "f"), rule.name);
+        for (const rule of this.#rules) {
+            // For virtual rules, check disable conditions:
+            // 1. Exact name match: rules["alias/name"]: false
+            // 2. Group disable: rules["groupName"]: false (multi-entry named nodeRules)
+            // 3. Namespace wildcard: rules["scope/*"]: false
+            // Note: base rule name disable (rules["baseRuleName"]: false) is handled
+            // during expandNamedRules for named rule groups in the rules section.
+            if (rule.baseRuleId &&
+                (this.#ruleset.rules[rule.name] === false ||
+                    (rule.groupName && this.#ruleset.rules[rule.groupName] === false) ||
+                    this.#disabledNamespaces.some(ns => rule.name.startsWith(ns)))) {
+                continue;
+            }
+            const ruleInfo = rule.getRuleInfo(this.#ruleset, rule.name);
             if (ruleInfo.disabled && ruleInfo.nodeRules.length === 0 && ruleInfo.childNodeRules.length === 0) {
                 continue;
             }
             log('%s Rule: verify', rule.name);
-            const results = await rule.verify(__classPrivateFieldGet(this, _MLCore_document, "f"), __classPrivateFieldGet(this, _MLCore_locale, "f"), fix).catch(error => {
+            const results = await rule.verify(this.#document, this.#locale, fix).catch(error => {
                 if (error instanceof ParserError) {
                     return error;
                 }
@@ -159,21 +240,21 @@ export class MLCore {
         return violations;
     }
     _createDocument() {
-        if (!__classPrivateFieldGet(this, _MLCore_ast, "f")) {
+        if (!this.#ast) {
             return;
         }
         try {
-            __classPrivateFieldSet(this, _MLCore_document, new Document(__classPrivateFieldGet(this, _MLCore_ast, "f"), __classPrivateFieldGet(this, _MLCore_ruleset, "f"), __classPrivateFieldGet(this, _MLCore_schemas, "f"), {
-                filename: __classPrivateFieldGet(this, _MLCore_filename, "f"),
-                endTag: __classPrivateFieldGet(this, _MLCore_parser, "f").endTag,
-                booleanish: __classPrivateFieldGet(this, _MLCore_parser, "f").booleanish,
-                tagNameCaseSensitive: __classPrivateFieldGet(this, _MLCore_parser, "f").tagNameCaseSensitive,
-                pretenders: __classPrivateFieldGet(this, _MLCore_pretenders, "f"),
-            }), "f");
+            this.#document = new Document(this.#ast, this.#ruleset, this.#schemas, this.#ruleCommonSettings, {
+                filename: this.#filename,
+                endTag: this.#parser.endTag,
+                booleanish: this.#parser.booleanish,
+                tagNameCaseSensitive: this.#parser.tagNameCaseSensitive,
+                pretenders: this.#pretenders,
+            });
         }
         catch (error) {
             if (error instanceof ParserError) {
-                __classPrivateFieldSet(this, _MLCore_document, error, "f");
+                this.#document = error;
             }
             else {
                 throw error;
@@ -181,13 +262,13 @@ export class MLCore {
         }
     }
     _createParseError(message, line, col, raw) {
-        if (__classPrivateFieldGet(this, _MLCore_severity, "f").parseError === false || __classPrivateFieldGet(this, _MLCore_severity, "f").parseError === 'off') {
+        if (this.#severity.parseError === false || this.#severity.parseError === 'off') {
             return null;
         }
         // Default severity is 'error'
-        const severity = __classPrivateFieldGet(this, _MLCore_severity, "f").parseError === true || __classPrivateFieldGet(this, _MLCore_severity, "f").parseError == null
+        const severity = this.#severity.parseError === true || this.#severity.parseError == null
             ? 'error'
-            : __classPrivateFieldGet(this, _MLCore_severity, "f").parseError;
+            : this.#severity.parseError;
         return {
             ruleId: 'parse-error',
             severity,
@@ -199,13 +280,13 @@ export class MLCore {
     }
     _parse() {
         try {
-            __classPrivateFieldSet(this, _MLCore_ast, __classPrivateFieldGet(this, _MLCore_parser, "f").parse(__classPrivateFieldGet(this, _MLCore_sourceCode, "f"), __classPrivateFieldGet(this, _MLCore_parserOptions, "f")), "f");
+            this.#ast = this.#parser.parse(this.#sourceCode, this.#parserOptions);
         }
         catch (error) {
             log('Caught the parse error: %O', error);
-            __classPrivateFieldSet(this, _MLCore_ast, null, "f");
+            this.#ast = null;
             if (error instanceof ParserError) {
-                __classPrivateFieldSet(this, _MLCore_document, error, "f");
+                this.#document = error;
             }
             else {
                 throw error;
@@ -213,4 +294,12 @@ export class MLCore {
         }
     }
 }
-_MLCore_ast = new WeakMap(), _MLCore_document = new WeakMap(), _MLCore_filename = new WeakMap(), _MLCore_locale = new WeakMap(), _MLCore_parser = new WeakMap(), _MLCore_parserOptions = new WeakMap(), _MLCore_severity = new WeakMap(), _MLCore_pretenders = new WeakMap(), _MLCore_rules = new WeakMap(), _MLCore_ruleset = new WeakMap(), _MLCore_schemas = new WeakMap(), _MLCore_sourceCode = new WeakMap(), _MLCore_configErrors = new WeakMap();
+/**
+ * Extracts namespace prefixes from wildcard disable entries in rules.
+ * e.g., `{ "a11y/*": false }` yields `["a11y/"]`.
+ */
+function extractDisabledNamespaces(rules) {
+    return Object.entries(rules)
+        .filter(([key, value]) => key.endsWith('/*') && value === false)
+        .map(([key]) => key.slice(0, -1)); // "a11y/*" → "a11y/"
+}

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

@@ -1,3 +1,11 @@
 import type { MLElement } from '../node/element.js';
 import type { ARIAVersion } from '@markuplint/ml-spec';
+/**
+ * Computes the accessible name for an MLElement using the HTML-AAM algorithm.
+ * Creates an MLCore-specific resolver that bridges MLElement to the AccnameResolver interface.
+ *
+ * @param el - The MLElement to compute the accessible name for
+ * @param version - The ARIA specification version to use for role resolution
+ * @returns The computed accessible name string, or an empty string on error
+ */
 export declare function getAccname(el: MLElement<any, any>, version: ARIAVersion): string;

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

@@ -1,71 +1,87 @@
-import { getAccname as get, getComputedRole } from '@markuplint/ml-spec';
+import { computeAccessibleName, escapeCSS, getComputedRole, EMBEDDED_CONTROL_ROLES, isNativeEmbeddedControl, } from '@markuplint/ml-spec';
 import { log } from '../../debug.js';
 const accnameLog = log.extend('accname');
+/**
+ * Computes the accessible name for an MLElement using the HTML-AAM algorithm.
+ * Creates an MLCore-specific resolver that bridges MLElement to the AccnameResolver interface.
+ *
+ * @param el - The MLElement to compute the accessible name for
+ * @param version - The ARIA specification version to use for role resolution
+ * @returns The computed accessible name string, or an empty string on error
+ */
 export function getAccname(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, version) {
-    let accname = safeGet(el);
-    if (accname) {
-        return accname;
-    }
-    accname = getAccnameFromPretender(el);
-    if (accname) {
-        return accname;
-    }
-    if (isHidden(el)) {
-        return '';
-    }
-    if (isFromContent(el, version)) {
-        return [...el.childNodes]
-            .map(child => {
-            if (child.is(child.ELEMENT_NODE)) {
-                return getAccname(child, version);
-            }
-            if (child.is(child.TEXT_NODE)) {
-                return child.textContent ?? '';
-            }
-            return '';
-        })
-            .join('');
-    }
-    return '';
-}
-function safeGet(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el) {
+    // AccName computation involves DOM traversal, role resolution, and label
+    // lookup via querySelector. These may fail on unexpected DOM states (e.g.,
+    // detached nodes, malformed attributes) or incomplete spec data.
+    // A single element's failure must not abort the entire linting process,
+    // so we catch operational errors and return an empty name (= "unnamed").
+    // Programmer errors (TypeError, ReferenceError) are rethrown to avoid
+    // masking implementation bugs.
     try {
-        const name = get(el);
-        return name;
+        const resolver = createMLCoreResolver(el, version);
+        const result = computeAccessibleName(el, resolver);
+        return result.name;
     }
     catch (error) {
+        if (error instanceof TypeError || error instanceof ReferenceError) {
+            throw error;
+        }
         accnameLog('Raw: %s', el.raw);
         accnameLog('Error: %O', error);
         return '';
     }
 }
-function getAccnameFromPretender(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el) {
-    if (el.pretenderContext?.type === 'pretender' && el.pretenderContext.aria?.name != null) {
-        if (typeof el.pretenderContext.aria.name === 'boolean') {
-            return 'some-name(Pretender Options)';
-        }
-        const attrName = el.pretenderContext.aria.name.fromAttr;
-        const attrValue = el.getAttributePretended(attrName);
-        if (attrValue) {
-            return attrValue;
-        }
-    }
-    return '';
-}
-function isHidden(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el) {
-    return el.getAttribute('aria-hidden') === 'true' || el.hasAttribute('hidden');
-}
-function isFromContent(
+function createMLCoreResolver(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, version) {
-    const role = getComputedRole(el.ownerMLDocument.specs, el, version);
-    return !!role.role?.accessibleNameFromContent;
+    const doc = el.ownerMLDocument;
+    return {
+        getElementById(id) {
+            const found = doc.querySelector(`#${escapeCSS(id)}`);
+            return found ?? null;
+        },
+        getLabelsForId(id) {
+            const labels = doc.querySelectorAll(`label[for="${escapeCSS(id)}"]`);
+            return [...labels];
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        allowsNameFromContent(target) {
+            // TODO: Remove cast when getComputedRole accepts AccnameElement (#3178)
+            const role = getComputedRole(doc.specs, target, version);
+            return !!role.role?.accessibleNameFromContent;
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        isHidden(target) {
+            return target.getAttribute('aria-hidden') === 'true' || target.hasAttribute('hidden');
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        isEmbeddedControl(target) {
+            // TODO: Remove cast when getComputedRole accepts AccnameElement (#3178)
+            const role = getComputedRole(doc.specs, target, version);
+            if (role.role?.name) {
+                return EMBEDDED_CONTROL_ROLES.has(role.role.name);
+            }
+            return isNativeEmbeddedControl(target);
+        },
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        getPrecomputedName(target) {
+            // TODO: Remove cast when AccnameResolver is generic (#3178)
+            const targetEl = target;
+            if (!targetEl.pretenderContext || targetEl.pretenderContext.type !== 'pretender') {
+                return null;
+            }
+            const ariaName = targetEl.pretenderContext.aria?.name;
+            if (ariaName == null) {
+                return null;
+            }
+            if (typeof ariaName === 'boolean') {
+                return 'some-name(Pretender Options)';
+            }
+            const attrName = ariaName.fromAttr;
+            const attrValue = targetEl.getAttributePretended(attrName);
+            return attrValue || null;
+        },
+    };
 }

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

@@ -33,6 +33,7 @@ document) {
                         elementType: 'web-component',
                         attributes: [],
                         childNodes: [],
+                        blockBehavior: null,
                         pairNode: null,
                         tagOpenChar: '',
                         tagCloseChar: '',

package/lib/ml-dom/helper/get-indent.d.ts

@@ -1,9 +1,12 @@
 import type { MLNode } from '../node/node.js';
 import type { MLText } from '../node/text.js';
 /**
+ * Computes the indentation preceding the given node by analyzing
+ * the whitespace in adjacent text nodes.
  *
  * @deprecated
- * @param node
+ * @param node - The node whose indentation to determine
+ * @returns An indentation object describing the whitespace, or null if no indentation is found
  */
 export declare function getIndent(node: MLNode<any, any>): MLDOMIndentation | null;
 declare class MLDOMIndentation {