@markuplint/ml-core 5.0.0-alpha.1 → 5.0.0-alpha.3

package/lib/ml-core.js

@@ -1,5 +1,6 @@
 import { ParserError } from '@markuplint/parser-utils';
 import { log, enableDebug } from './debug.js';
+import { applyFixes } from './fix-applier.js';
 import { Document } from './ml-dom/index.js';
 import { expandNamedNodeRules, expandNamedRules } from './virtual-rule.js';
 const resultLog = log.extend('result');
@@ -69,8 +70,8 @@ export class MLCore {
         };
         this.#disabledNamespaces = extractDisabledNamespaces(resolvedRules);
         this.#configErrors.push(...namedRulesResult.errors, ...nodeRuleResult.errors, ...childNodeRuleResult.errors);
-        this._parse();
-        this._createDocument();
+        this.#parse();
+        this.#createDocument();
     }
     /**
      * The parsed document, or a {@link ParserError} if parsing failed.
@@ -85,8 +86,8 @@ export class MLCore {
      */
     setCode(sourceCode) {
         this.#sourceCode = sourceCode;
-        this._parse();
-        this._createDocument();
+        this.#parse();
+        this.#createDocument();
     }
     /**
      * Updates the linting configuration and re-creates the document.
@@ -128,30 +129,23 @@ export class MLCore {
         if (parserOptions &&
             (parserOptions.ignoreFrontMatter !== this.#parserOptions.ignoreFrontMatter ||
                 parserOptions.authoredElementName !== this.#parserOptions.authoredElementName)) {
-            this._parse();
+            this.#parse();
         }
-        this._createDocument();
+        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) {
+    async verify(fixOrOptions) {
+        const options = typeof fixOrOptions === 'boolean' ? { fix: fixOrOptions } : (fixOrOptions ?? {});
+        const fix = options.fix ?? false;
         log('verify: start');
         const violations = [];
         if (this.#document instanceof ParserError) {
-            const parseError = this._createParseError(this.#document.message, this.#document.line, this.#document.col, this.#document.raw);
+            const parseError = this.#createParseError(this.#document.message, this.#document.line, this.#document.col, this.#document.raw);
             if (!parseError) {
-                return [];
+                return { violations: [], fixedCode: fix ? this.#sourceCode : undefined };
             }
             violations.push(parseError);
             log('verify: error %o', this.#document.message);
-            return violations;
+            return { violations, fixedCode: fix ? this.#sourceCode : undefined };
         }
         const definedRuleName = new Set(this.#rules.map(rule => rule.name));
         const setRuleNames = new Set([
@@ -185,42 +179,8 @@ export class MLCore {
                 raw: '',
             });
         }
-        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(this.#document, this.#locale, fix).catch(error => {
-                if (error instanceof ParserError) {
-                    return error;
-                }
-                throw error;
-            });
-            if (results instanceof ParserError) {
-                const parseError = this._createParseError(results.message, results.line, results.col, results.raw);
-                if (parseError) {
-                    log('%s Rule: verify error %o', rule.name, results.message);
-                    violations.push(parseError);
-                }
-            }
-            else {
-                violations.push(...results);
-            }
-            log('%s Rule: verify end', rule.name);
-        }
+        const ruleViolations = await this.#runAllRules(fix);
+        violations.push(...ruleViolations);
         if (resultLog.enabled) {
             // eslint-disable-next-line unicorn/no-array-reduce
             const { e, w, i } = violations.reduce((c, v) => {
@@ -236,10 +196,42 @@ export class MLCore {
             resultLog('Warning: %d', w);
             resultLog('Info: %d', i);
         }
+        // Apply fixes if enabled
+        let fixedCode;
+        let fixSummary;
+        if (fix) {
+            const hasFixes = violations.some(v => v.fix);
+            if (hasFixes) {
+                const originalSourceCode = this.#sourceCode;
+                const originalAst = this.#ast;
+                const originalDocument = this.#document;
+                try {
+                    const fixResult = await this.#multiPassFix(violations);
+                    fixedCode = fixResult.code;
+                    fixSummary = fixResult.summary;
+                }
+                finally {
+                    // Restore original state - verify() must be non-mutating
+                    this.#sourceCode = originalSourceCode;
+                    this.#ast = originalAst;
+                    this.#document = originalDocument;
+                }
+            }
+            else {
+                fixedCode = this.#sourceCode;
+                fixSummary = {
+                    passCount: 0,
+                    totalApplied: 0,
+                    totalSkipped: 0,
+                    reachedMaxPasses: false,
+                    firstPassEdits: [],
+                };
+            }
+        }
         log('verify: end');
-        return violations;
+        return { violations, fixedCode, fixSummary };
     }
-    _createDocument() {
+    #createDocument() {
         if (!this.#ast) {
             return;
         }
@@ -261,7 +253,7 @@ export class MLCore {
             }
         }
     }
-    _createParseError(message, line, col, raw) {
+    #createParseError(message, line, col, raw) {
         if (this.#severity.parseError === false || this.#severity.parseError === 'off') {
             return null;
         }
@@ -278,7 +270,138 @@ export class MLCore {
             raw,
         };
     }
-    _parse() {
+    /**
+     * Iteratively applies fixes, re-parses, and re-verifies until no overlapping
+     * fixes remain or the maximum pass count is reached (ESLint-style multi-pass loop).
+     *
+     * **Callers must save/restore `#sourceCode`, `#ast`, and `#document`** because
+     * this method mutates them during intermediate re-parse steps.
+     *
+     * @param initialViolations - Violations from the first verification pass
+     * @returns The final fixed source code and a summary of the fix process
+     */
+    async #multiPassFix(initialViolations) {
+        const MAX_FIX_PASSES = 10;
+        let currentCode = this.#sourceCode;
+        let previousCode;
+        let fixes = extractFixes(initialViolations);
+        let totalApplied = 0;
+        let totalSkipped = 0;
+        let firstPassEdits = [];
+        let pass = 0;
+        for (; pass < MAX_FIX_PASSES; pass++) {
+            log('fix pass %d: %d fixes', pass, fixes.length);
+            const result = applyFixes(currentCode, fixes);
+            totalApplied += result.applied.length;
+            totalSkipped += result.skipped.length;
+            if (pass === 0) {
+                firstPassEdits = result.appliedEdits;
+            }
+            if (result.applied.length === 0) {
+                log('fix pass %d: no fixes applied, stopping', pass);
+                break;
+            }
+            if (result.output === currentCode) {
+                log('fix pass %d: output unchanged, stopping', pass);
+                break;
+            }
+            // Cycle detection: if the output matches the code from two passes ago,
+            // fixes are oscillating (A → B → A) and will never converge.
+            if (previousCode !== undefined && result.output === previousCode) {
+                log('fix pass %d: cycle detected (output matches pass %d), stopping', pass, pass - 2);
+                currentCode = result.output;
+                break;
+            }
+            previousCode = currentCode;
+            currentCode = result.output;
+            if (result.skipped.length === 0) {
+                log('fix pass %d: all fixes applied, stopping', pass);
+                break;
+            }
+            // --- Multi-pass path (only when overlapping fixes exist) ---
+            log('fix pass %d: %d skipped, re-parsing for next pass', pass, result.skipped.length);
+            const previousGoodCode = currentCode;
+            this.#sourceCode = currentCode;
+            this.#parse();
+            this.#createDocument();
+            if (this.#document instanceof ParserError) {
+                log('fix pass %d: produced unparsable code, reverting to previous state', pass);
+                currentCode = previousGoodCode;
+                break;
+            }
+            const newViolations = await this.#runAllRules(true);
+            fixes = extractFixes(newViolations);
+            if (fixes.length === 0) {
+                log('fix pass %d: no more fixable violations, stopping', pass);
+                break;
+            }
+        }
+        const reachedMaxPasses = pass === MAX_FIX_PASSES;
+        if (reachedMaxPasses) {
+            log('fix: reached maximum number of passes (%d), some fixes may not have been applied', MAX_FIX_PASSES);
+        }
+        return {
+            code: currentCode,
+            summary: {
+                passCount: Math.min(pass + 1, MAX_FIX_PASSES),
+                totalApplied,
+                totalSkipped,
+                reachedMaxPasses,
+                firstPassEdits,
+            },
+        };
+    }
+    /**
+     * Executes all configured rules against the current document and collects violations.
+     * Skips disabled rules and handles virtual rule disable conditions.
+     *
+     * @param fix - Whether to execute fix callbacks on violations
+     * @returns All violations produced by the rule set
+     */
+    async #runAllRules(fix) {
+        const violations = [];
+        if (this.#document instanceof ParserError) {
+            return violations;
+        }
+        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(this.#document, this.#locale, fix).catch(error => {
+                if (error instanceof ParserError) {
+                    return error;
+                }
+                throw error;
+            });
+            if (results instanceof ParserError) {
+                const parseError = this.#createParseError(results.message, results.line, results.col, results.raw);
+                if (parseError) {
+                    log('%s Rule: verify error %o', rule.name, results.message);
+                    violations.push(parseError);
+                }
+            }
+            else {
+                violations.push(...results);
+            }
+            log('%s Rule: verify end', rule.name);
+        }
+        return violations;
+    }
+    #parse() {
         try {
             this.#ast = this.#parser.parse(this.#sourceCode, this.#parserOptions);
         }
@@ -303,3 +426,18 @@ function extractDisabledNamespaces(rules) {
         .filter(([key, value]) => key.endsWith('/*') && value === false)
         .map(([key]) => key.slice(0, -1)); // "a11y/*" → "a11y/"
 }
+/**
+ * Collects all `FixData` from violations that have a fix callback result.
+ *
+ * @param violations - The violations to extract fixes from
+ * @returns An array of `FixData` objects ready for `applyFixes()`
+ */
+function extractFixes(violations) {
+    const fixes = [];
+    for (const v of violations) {
+        if (v.fix) {
+            fixes.push(v.fix);
+        }
+    }
+    return fixes;
+}

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

@@ -16,6 +16,5 @@ declare class MLDOMIndentation {
     get raw(): string;
     get type(): 'tab' | 'space' | 'mixed' | 'none';
     get width(): number;
-    fix(raw: string): void;
 }
 export {};

package/lib/ml-dom/helper/get-indent.js

@@ -39,7 +39,6 @@ node) {
     const matched = isFirstToken(prevToken)
         ? prevToken.raw.match(/^(?:[\t ]*\r?\n)*([\t ]*)$/)
         : prevToken.raw.match(/\r?\n([\t ]*)$/);
-    // console.log({ [`${this}`]: matched, _: prevToken.raw, f: prevToken._isFirstToken() });
     if (matched) {
         // Spaces will include empty string.
         const spaces = matched[1];
@@ -50,7 +49,7 @@ node) {
     return null;
 }
 class MLDOMIndentation {
-    #fixed;
+    #raw;
     line;
     #node;
     #parent;
@@ -62,38 +61,26 @@ class MLDOMIndentation {
         this.line = line;
         this.#node = originTextNode;
         this.#parent = parentNode;
-        this.#fixed = raw;
+        this.#raw = raw;
     }
     get raw() {
         if (!this.#parent.is(this.#parent.TEXT_NODE) && this.line !== this.#node.endLine) {
             return '';
         }
-        return this.#fixed;
+        return this.#raw;
     }
     get type() {
         if (!this.#parent.is(this.#parent.TEXT_NODE) && this.line !== this.#node.endLine) {
             return 'none';
         }
-        const raw = this.#fixed;
+        const raw = this.#raw;
         return raw === '' ? 'none' : /^\t+$/.test(raw) ? 'tab' : /^[^\t]+$/.test(raw) ? 'space' : 'mixed';
     }
     get width() {
         if (!this.#parent.is(this.#parent.TEXT_NODE) && this.line !== this.#node.endLine) {
             return 0;
         }
-        return this.#fixed.length;
-    }
-    fix(raw) {
-        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, this.#fixed);
-        }
-        node.fix(lines.join('\n'));
+        return this.#raw.length;
     }
 }
 function isFirstToken(

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

@@ -152,15 +152,6 @@ export declare class MLAttr<T extends RuleConfigValue, O extends PlainData = und
      * @see https://dom.spec.whatwg.org/#dom-attr-value
      */
     get value(): string;
-    /**
-     * Fixes the attribute value.
-     * If the attribute is not a spread attribute, it calls the `fix` method of the `valueNode`.
-     *
-     * @implements `@markuplint/ml-core` API: `MLAttr`
-     *
-     * @param raw - The raw attribute value.
-     */
-    fix(raw: string): void;
     /**
      * Returns a normalized string representation of the attribute,
      * stripping extraneous whitespace around the name, equal sign, and value tokens.
@@ -171,12 +162,10 @@ export declare class MLAttr<T extends RuleConfigValue, O extends PlainData = und
      */
     toNormalizeString(): string;
     /**
-     * Returns a string representation of the attribute.
+     * Returns the raw string representation of the attribute.
      *
      * @implements DOM API: `Attr`
-     *
-     * @param includesSpacesBeforeName - Whether to include spaces before the attribute name.
      * @returns The string representation of the attribute.
      */
-    toString(fixed?: boolean): string;
+    toString(): string;
 }

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

@@ -251,21 +251,6 @@ export class MLAttr extends MLNode {
     get value() {
         return this.#potentialValue;
     }
-    /**
-     * Fixes the attribute value.
-     * If the attribute is not a spread attribute, it calls the `fix` method of the `valueNode`.
-     *
-     * @implements `@markuplint/ml-core` API: `MLAttr`
-     *
-     * @param raw - The raw attribute value.
-     */
-    fix(raw) {
-        if (this.localName === '#spread') {
-            return;
-        }
-        // `valueNode` is not null when it is no spread.
-        this.valueNode?.fix(raw);
-    }
     /**
      * Returns a normalized string representation of the attribute,
      * stripping extraneous whitespace around the name, equal sign, and value tokens.
@@ -281,29 +266,12 @@ export class MLAttr extends MLNode {
         return this.raw;
     }
     /**
-     * Returns a string representation of the attribute.
+     * Returns the raw string representation of the attribute.
      *
      * @implements DOM API: `Attr`
-     *
-     * @param includesSpacesBeforeName - Whether to include spaces before the attribute name.
      * @returns The string representation of the attribute.
      */
-    toString(fixed = false) {
-        if (!fixed) {
-            return this.raw;
-        }
-        if (this.localName === '#spread') {
-            return this.raw;
-        }
-        const tokens = [this.nameNode?.toString(true) ?? ''];
-        if (this.equal && this.equal.toString(true) !== '') {
-            tokens.push(this.spacesBeforeEqual?.toString(true) ?? '', this.equal?.toString(true) ?? '', this.spacesAfterEqual?.toString(true) ?? '', this.startQuote?.toString(true) ?? '', this.valueNode?.toString(true) ?? '', this.endQuote?.toString(true) ?? '');
-        }
-        else if (this.valueNode && this.valueNode.toString(true) !== '') {
-            tokens.push(
-            //
-            '=', this.startQuote?.toString(true) || '"', this.valueNode.toString(true), this.endQuote?.toString(true) || '"');
-        }
-        return tokens.join('');
+    toString() {
+        return this.raw;
     }
 }

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

@@ -28,7 +28,8 @@ export class MLBlock extends MLNode {
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     document) {
         super(astNode, document, astNode.isFragment);
-        // TODO:
+        // Always transparent: blockBehavior may restrict child treatment in the future,
+        // but currently all preprocessor blocks are transparent for tree traversal.
         this.isTransparent = true;
         this.blockBehavior = astNode.blockBehavior;
     }

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

@@ -42,21 +42,56 @@ export declare abstract class MLCharacterData<T extends RuleConfigValue, O exten
      * @implements DOM API: `CharacterData`
      */
     after(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-appenddata
+     */
     appendData(data: string): void;
     /**
      * @implements DOM API: `CharacterData`
      */
     before(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-deletedata
+     */
     deleteData(offset: number, count: number): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-insertdata
+     */
     insertData(offset: number, data: string): void;
     /**
      * @implements DOM API: `CharacterData`
      */
     remove(): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-replacedata
+     */
     replaceData(offset: number, count: number, data: string): void;
     /**
      * @implements DOM API: `CharacterData`
      */
     replaceWith(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-substringdata
+     */
     substringData(offset: number, count: number): string;
 }

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

@@ -7,7 +7,6 @@ export class MLCharacterData extends MLNode {
      * @see https://dom.spec.whatwg.org/#dom-characterdata-data
      */
     get data() {
-        // TODO:
         return this.raw;
     }
     /**
@@ -58,7 +57,13 @@ export class MLCharacterData extends MLNode {
     ...nodes) {
         after(this, ...nodes);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-appenddata
+     */
     appendData(data) { }
     /**
      * @implements DOM API: `CharacterData`
@@ -68,9 +73,21 @@ export class MLCharacterData extends MLNode {
     ...nodes) {
         before(this, ...nodes);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-deletedata
+     */
     deleteData(offset, count) { }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-insertdata
+     */
     insertData(offset, data) { }
     /**
      * @implements DOM API: `CharacterData`
@@ -78,7 +95,13 @@ export class MLCharacterData extends MLNode {
     remove() {
         remove(this);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-replacedata
+     */
     replaceData(offset, count, data) { }
     /**
      * @implements DOM API: `CharacterData`
@@ -88,7 +111,13 @@ export class MLCharacterData extends MLNode {
     ...nodes) {
         replaceWith(this, ...nodes);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-substringdata
+     */
     substringData(offset, count) {
         return '';
     }

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

@@ -1577,14 +1577,6 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
      * @implements DOM API: `Document`
      */
     getSelection(): Selection | null;
-    /**
-     * Returns a flat, offset-sorted list of all tokens in the document,
-     * including element close tags. The result is cached after the first call.
-     *
-     * @implements `@markuplint/ml-core` API: `MLDocument`
-     * @returns A frozen array of tokens sorted by their starting offset
-     */
-    getTokenList(): readonly MLToken<import("@markuplint/ml-ast").MLASTToken>[];
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
      *
@@ -1693,15 +1685,12 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
      */
     startViewTransition(callbackOptions?: ViewTransitionUpdateCallback): ViewTransition;
     /**
-     * Returns a string representation of the entire document. When `fixed` is true,
-     * returns the document with all lint fixes applied by substituting
-     * fixed token content at the appropriate offsets.
+     * Returns the raw string representation of the document.
      *
      * @implements `@markuplint/ml-core` API: `MLDocument`
-     * @param fixed - When true, returns the fixed content; otherwise returns the original raw content
      * @returns The string content of the document
      */
-    toString(fixed?: boolean): string;
+    toString(): string;
     /**
      * Walks the document tree, visiting nodes of the specified type and invoking
      * the walker callback for each one. Supports walking Element, Text, Comment,
@@ -1732,18 +1721,4 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
      * @implements DOM API: `Document`
      */
     writeln(...text: readonly string[]): void;
-    /**
-     * Initializes pretender contexts for all element nodes in the document.
-     *
-     * @param pretenders - Optional pretender configurations from the document options
-     */
-    private _pretending;
-    /**
-     * Maps the ruleset configuration to each node in the document.
-     * Applies global rules, node-specific rules (by selector), and
-     * child-node rules to build the per-node rule configuration.
-     *
-     * @param ruleset - The ruleset containing rules, nodeRules, and childNodeRules
-     */
-    private _ruleMapping;
 }