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

package/lib/ml-core.js

@@ -1,18 +1,7 @@
-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.
@@ -21,38 +10,65 @@ const resultLog = log.extend('result');
  * 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();
     }
@@ -60,7 +76,7 @@ export class MLCore {
      * 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.
@@ -68,7 +84,7 @@ export class MLCore {
      * @param sourceCode - The new markup source code
      */
     setCode(sourceCode) {
-        __classPrivateFieldSet(this, _MLCore_sourceCode, sourceCode, "f");
+        this.#sourceCode = sourceCode;
         this._parse();
         this._createDocument();
     }
@@ -79,19 +95,39 @@ export class MLCore {
      * @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();
@@ -108,22 +144,26 @@ export class MLCore {
     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',
@@ -135,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',
@@ -145,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;
                 }
@@ -188,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;
@@ -210,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,
@@ -228,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;
@@ -242,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.js

@@ -1,15 +1,3 @@
-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 _MLDOMIndentation_fixed, _MLDOMIndentation_node, _MLDOMIndentation_parent;
 /**
  * Computes the indentation preceding the given node by analyzing
  * the whitespace in adjacent text nodes.
@@ -62,52 +50,52 @@ node) {
     return null;
 }
 class MLDOMIndentation {
+    #fixed;
+    line;
+    #node;
+    #parent;
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originTextNode, raw, line, 
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     parentNode) {
-        _MLDOMIndentation_fixed.set(this, void 0);
-        _MLDOMIndentation_node.set(this, void 0);
-        _MLDOMIndentation_parent.set(this, void 0);
         this.line = line;
-        __classPrivateFieldSet(this, _MLDOMIndentation_node, originTextNode, "f");
-        __classPrivateFieldSet(this, _MLDOMIndentation_parent, parentNode, "f");
-        __classPrivateFieldSet(this, _MLDOMIndentation_fixed, raw, "f");
+        this.#node = originTextNode;
+        this.#parent = parentNode;
+        this.#fixed = raw;
     }
     get raw() {
-        if (!__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").is(__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").TEXT_NODE) && this.line !== __classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
+        if (!this.#parent.is(this.#parent.TEXT_NODE) && this.line !== this.#node.endLine) {
             return '';
         }
-        return __classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
+        return this.#fixed;
     }
     get type() {
-        if (!__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").is(__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").TEXT_NODE) && this.line !== __classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
+        if (!this.#parent.is(this.#parent.TEXT_NODE) && this.line !== this.#node.endLine) {
             return 'none';
         }
-        const raw = __classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
+        const raw = this.#fixed;
         return raw === '' ? 'none' : /^\t+$/.test(raw) ? 'tab' : /^[^\t]+$/.test(raw) ? 'space' : 'mixed';
     }
     get width() {
-        if (!__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").is(__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").TEXT_NODE) && this.line !== __classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
+        if (!this.#parent.is(this.#parent.TEXT_NODE) && this.line !== this.#node.endLine) {
             return 0;
         }
-        return __classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f").length;
+        return this.#fixed.length;
     }
     fix(raw) {
-        const current = __classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
-        __classPrivateFieldSet(this, _MLDOMIndentation_fixed, raw, "f");
-        const node = __classPrivateFieldGet(this, _MLDOMIndentation_node, "f");
+        const current = this.#fixed;
+        this.#fixed = raw;
+        const node = this.#node;
         const line = node.startLine;
         const lines = node.raw.split(/\r?\n/);
         const index = this.line - line;
         if (lines[index] != null) {
-            lines[index] = lines[index].replace(current, __classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f"));
+            lines[index] = lines[index].replace(current, this.#fixed);
         }
         node.fix(lines.join('\n'));
     }
 }
-_MLDOMIndentation_fixed = new WeakMap(), _MLDOMIndentation_node = new WeakMap(), _MLDOMIndentation_parent = new WeakMap();
 function isFirstToken(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 node) {