@openrewrite/rewrite 8.69.0-20251212-132620 → 8.69.0-20251212-152027

package/dist/javascript/tree-debug.js

@@ -0,0 +1,892 @@
+"use strict";
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LstDebugVisitor = exports.LstDebugPrinter = void 0;
+exports.formatWhitespace = formatWhitespace;
+exports.formatSpace = formatSpace;
+exports.formatCursorMessages = formatCursorMessages;
+exports.findPropertyPath = findPropertyPath;
+exports.debugPrint = debugPrint;
+exports.debugPrintCursorPath = debugPrintCursorPath;
+const java_1 = require("../java");
+const visitor_1 = require("./visitor");
+const fs = __importStar(require("fs"));
+const DEFAULT_OPTIONS = {
+    includeCursorMessages: true,
+    includeMarkers: false,
+    includeIds: false,
+    maxDepth: -1,
+    excludeProperties: [],
+    output: 'console',
+    indent: '  ',
+};
+/**
+ * Properties to always exclude from debug output (noisy/large).
+ */
+const EXCLUDED_PROPERTIES = new Set([
+    'type', // JavaType - very verbose
+    'methodType', // JavaType.Method
+    'variableType', // JavaType.Variable
+    'fieldType', // JavaType.Variable
+    'constructorType', // JavaType.Method
+]);
+/**
+ * Subscript digits for counts (index 0-9 maps to ₀-₉).
+ */
+const SUBSCRIPTS = ['₀', '₁', '₂', '₃', '₄', '₅', '₆', '₇', '₈', '₉'];
+/**
+ * Format a count as subscript. Count of 1 is implicit (empty string).
+ */
+function subscript(count) {
+    if (count <= 1)
+        return '';
+    if (count < 10)
+        return SUBSCRIPTS[count];
+    // For counts >= 10, build from individual digits
+    return String(count).split('').map(d => SUBSCRIPTS[parseInt(d)]).join('');
+}
+/**
+ * Format whitespace string for readable debug output.
+ * Uses compact notation with subscript counts:
+ * - '\n' = 1 newline (implicit ₁)
+ * - '\n₂' = 2 newlines
+ * - '·₄' = 4 spaces
+ * - '-₂' = 2 tabs
+ * - '\n·₄' = newline + 4 spaces
+ * - '\n·₄-₂' = newline + 4 spaces + 2 tabs
+ */
+function formatWhitespace(whitespace) {
+    if (whitespace === undefined || whitespace === '') {
+        return "''";
+    }
+    let result = '';
+    let newlineCount = 0;
+    let spaceCount = 0;
+    let tabCount = 0;
+    const flushCounts = () => {
+        if (newlineCount > 0) {
+            result += '\\n' + subscript(newlineCount);
+            newlineCount = 0;
+        }
+        if (spaceCount > 0) {
+            result += '·' + subscript(spaceCount);
+            spaceCount = 0;
+        }
+        if (tabCount > 0) {
+            result += '-' + subscript(tabCount);
+            tabCount = 0;
+        }
+    };
+    for (let i = 0; i < whitespace.length; i++) {
+        const c = whitespace[i];
+        if (c === '\n') {
+            // Flush spaces/tabs before starting newline count
+            if (spaceCount > 0 || tabCount > 0) {
+                flushCounts();
+            }
+            newlineCount++;
+        }
+        else if (c === '\r') {
+            flushCounts();
+            result += '\\r';
+        }
+        else if (c === ' ') {
+            // Flush newlines and tabs before counting spaces
+            if (newlineCount > 0) {
+                result += '\\n' + subscript(newlineCount);
+                newlineCount = 0;
+            }
+            if (tabCount > 0) {
+                result += '-' + subscript(tabCount);
+                tabCount = 0;
+            }
+            spaceCount++;
+        }
+        else if (c === '\t') {
+            // Flush newlines and spaces before counting tabs
+            if (newlineCount > 0) {
+                result += '\\n' + subscript(newlineCount);
+                newlineCount = 0;
+            }
+            if (spaceCount > 0) {
+                result += '·' + subscript(spaceCount);
+                spaceCount = 0;
+            }
+            tabCount++;
+        }
+        else {
+            flushCounts();
+            // Unexpected character (probably a bug in the parser)
+            result += c;
+        }
+    }
+    flushCounts();
+    return `'${result}'`;
+}
+/**
+ * Format a single comment for debug output.
+ */
+function formatComment(comment) {
+    var _a;
+    const textComment = comment;
+    const text = (_a = textComment.text) !== null && _a !== void 0 ? _a : '';
+    // Truncate long comments
+    const truncated = text.length > 20 ? text.substring(0, 17) + '...' : text;
+    if (textComment.multiline) {
+        return `/*${truncated}*/`;
+    }
+    else {
+        return `//${truncated}`;
+    }
+}
+/**
+ * Format a J.Space for debug output.
+ *
+ * Compact format:
+ * - Empty space: `''`
+ * - Whitespace only: `'\n·₄'`
+ * - Comment only: `//comment`
+ * - Comment with suffix: `//comment'\n'`
+ * - Multiple comments: `//c1'\n' + //c2'\n·₄'`
+ */
+function formatSpace(space) {
+    if (space === undefined) {
+        return '<undefined>';
+    }
+    const hasComments = space.comments.length > 0;
+    const hasWhitespace = space.whitespace !== undefined && space.whitespace !== '';
+    // Completely empty
+    if (!hasComments && !hasWhitespace) {
+        return "''";
+    }
+    // Whitespace only (common case) - just show the formatted whitespace
+    if (!hasComments) {
+        return formatWhitespace(space.whitespace);
+    }
+    // Format comments with their suffixes
+    const parts = [];
+    for (const comment of space.comments) {
+        let part = formatComment(comment);
+        // Add suffix if present
+        if (comment.suffix && comment.suffix !== '') {
+            part += formatWhitespace(comment.suffix);
+        }
+        parts.push(part);
+    }
+    // Add trailing whitespace if present
+    if (hasWhitespace) {
+        parts.push(formatWhitespace(space.whitespace));
+    }
+    return parts.join(' + ');
+}
+/**
+ * Format cursor messages for debug output.
+ * Returns '<no messages>' if no messages, otherwise returns '⟨key=value, ...⟩'
+ */
+function formatCursorMessages(cursor) {
+    if (!cursor || cursor.messages.size === 0) {
+        return '<no messages>';
+    }
+    const entries = [];
+    cursor.messages.forEach((value, key) => {
+        let valueStr;
+        if (Array.isArray(value)) {
+            valueStr = `[${value.map(v => JSON.stringify(v)).join(', ')}]`;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            valueStr = JSON.stringify(value);
+        }
+        else {
+            valueStr = String(value);
+        }
+        const keyStr = typeof key === 'symbol' ? key.toString() : String(key);
+        entries.push(`${keyStr}=${valueStr}`);
+    });
+    return `⟨${entries.join(', ')}⟩`;
+}
+/**
+ * Get a short type name from a kind string.
+ */
+function shortTypeName(kind) {
+    if (!kind)
+        return 'Unknown';
+    // Extract the last part after the last dot
+    const lastDot = kind.lastIndexOf('.');
+    return lastDot >= 0 ? kind.substring(lastDot + 1) : kind;
+}
+/**
+ * Find which property of the parent contains the given child element.
+ * Returns the property name, or property name with array index if in an array.
+ * Returns undefined if the relationship cannot be determined.
+ *
+ * @param cursor - The cursor at the current position
+ * @param child - Optional: the actual child node being visited (for RightPadded/LeftPadded/Container visits where cursor.value is the parent)
+ */
+function findPropertyPath(cursor, child) {
+    var _a, _b, _c, _d;
+    if (!cursor) {
+        return undefined;
+    }
+    // If child is provided, use cursor.value as parent; otherwise use cursor.parent.value
+    const actualChild = child !== null && child !== void 0 ? child : cursor.value;
+    const parent = child ? cursor.value : (_a = cursor.parent) === null || _a === void 0 ? void 0 : _a.value;
+    if (!parent || typeof parent !== 'object') {
+        return undefined;
+    }
+    // Properties to skip when searching
+    const skipProps = new Set(['kind', 'id', 'prefix', 'markers', 'type', 'methodType', 'variableType', 'fieldType', 'constructorType']);
+    // Special case: if parent is a Container, we need to look at grandparent to find the property name
+    if (parent.kind === java_1.J.Kind.Container) {
+        const container = parent;
+        const grandparent = child ? (_b = cursor.parent) === null || _b === void 0 ? void 0 : _b.value : (_d = (_c = cursor.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.value;
+        // Find the index of actualChild in container.elements
+        let childIndex = -1;
+        if (container.elements) {
+            for (let i = 0; i < container.elements.length; i++) {
+                if (container.elements[i] === actualChild) {
+                    childIndex = i;
+                    break;
+                }
+            }
+        }
+        // Find which property of grandparent holds this container
+        if (grandparent && typeof grandparent === 'object') {
+            for (const [key, value] of Object.entries(grandparent)) {
+                if (skipProps.has(key))
+                    continue;
+                if (value === parent) {
+                    if (childIndex >= 0) {
+                        return `${key}[${childIndex}]`;
+                    }
+                    return key;
+                }
+            }
+        }
+        // Fallback: just show the index
+        if (childIndex >= 0) {
+            return `[${childIndex}]`;
+        }
+    }
+    for (const [key, value] of Object.entries(parent)) {
+        if (skipProps.has(key))
+            continue;
+        // Direct match
+        if (value === actualChild) {
+            return key;
+        }
+        // Check if child is in an array
+        if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                if (value[i] === actualChild) {
+                    return `${key}[${i}]`;
+                }
+                // Check inside RightPadded/LeftPadded wrappers
+                if (value[i] && typeof value[i] === 'object') {
+                    if (value[i].element === actualChild) {
+                        return `${key}[${i}].element`;
+                    }
+                }
+            }
+        }
+        // Check inside Container
+        if (value && typeof value === 'object' && value.kind === java_1.J.Kind.Container) {
+            const container = value;
+            if (container.elements) {
+                for (let i = 0; i < container.elements.length; i++) {
+                    const rp = container.elements[i];
+                    if (rp === actualChild) {
+                        return `${key}[${i}]`;
+                    }
+                    if (rp.element === actualChild) {
+                        return `${key}[${i}].element`;
+                    }
+                }
+            }
+        }
+        // Check inside LeftPadded/RightPadded
+        if (value && typeof value === 'object') {
+            if (value.kind === java_1.J.Kind.LeftPadded || value.kind === java_1.J.Kind.RightPadded) {
+                if (value.element === actualChild) {
+                    return `${key}.element`;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Format a literal value for inline display.
+ */
+function formatLiteralValue(lit) {
+    if (lit.valueSource !== undefined) {
+        // Truncate long literals
+        return lit.valueSource.length > 20
+            ? lit.valueSource.substring(0, 17) + '...'
+            : lit.valueSource;
+    }
+    return String(lit.value);
+}
+/**
+ * Get a compact inline summary for certain node types.
+ * - For Identifier: shows "simpleName"
+ * - For Literal: shows the value
+ * - For other nodes: shows all Identifier/Literal properties inline
+ */
+function getNodeSummary(node) {
+    if ((0, java_1.isIdentifier)(node)) {
+        return `"${node.simpleName}"`;
+    }
+    if ((0, java_1.isLiteral)(node)) {
+        return formatLiteralValue(node);
+    }
+    // For other nodes, find all Identifier and Literal properties
+    const parts = [];
+    const skipProps = new Set(['kind', 'id', 'prefix', 'markers', 'type', 'methodType', 'variableType', 'fieldType', 'constructorType']);
+    for (const [key, value] of Object.entries(node)) {
+        if (skipProps.has(key))
+            continue;
+        if (value === null || value === undefined)
+            continue;
+        if ((0, java_1.isIdentifier)(value)) {
+            parts.push(`${key}='${value.simpleName}'`);
+        }
+        else if ((0, java_1.isLiteral)(value)) {
+            parts.push(`${key}=${formatLiteralValue(value)}`);
+        }
+    }
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+/**
+ * LST Debug Printer - prints LST nodes in a readable format.
+ *
+ * Usage from within a visitor:
+ * ```typescript
+ * class MyVisitor extends JavaScriptVisitor<P> {
+ *     private debug = new LstDebugPrinter({ includeCursorMessages: true });
+ *
+ *     async visitMethodInvocation(mi: J.MethodInvocation, p: P) {
+ *         this.debug.print(mi, this.cursor);
+ *         return super.visitMethodInvocation(mi, p);
+ *     }
+ * }
+ * ```
+ */
+class LstDebugPrinter {
+    constructor(options = {}) {
+        this.outputLines = [];
+        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+    }
+    /**
+     * Print a tree node with optional cursor context.
+     * @param tree The tree node to print
+     * @param cursor Optional cursor for context
+     * @param label Optional label to identify this debug output (shown as comment before output)
+     */
+    print(tree, cursor, label) {
+        this.outputLines = [];
+        if (label) {
+            this.outputLines.push(`// ${label}`);
+        }
+        this.printNode(tree, cursor, 0);
+        this.flush();
+    }
+    /**
+     * Print the cursor path from root to current position.
+     */
+    printCursorPath(cursor) {
+        var _a;
+        this.outputLines = [];
+        this.outputLines.push('=== Cursor Path ===');
+        const path = [];
+        for (let c = cursor; c; c = c.parent) {
+            path.unshift(c);
+        }
+        for (let i = 0; i < path.length; i++) {
+            const c = path[i];
+            const indent = this.options.indent.repeat(i);
+            const kind = (_a = c.value) === null || _a === void 0 ? void 0 : _a.kind;
+            const typeName = shortTypeName(kind);
+            let line = `${indent}${typeName}`;
+            if (this.options.includeCursorMessages && c.messages.size > 0) {
+                line += ` [${formatCursorMessages(c)}]`;
+            }
+            this.outputLines.push(line);
+        }
+        this.flush();
+    }
+    printNode(node, cursor, depth) {
+        if (this.options.maxDepth >= 0 && depth > this.options.maxDepth) {
+            this.outputLines.push(`${this.indent(depth)}...`);
+            return;
+        }
+        if (node === null || node === undefined) {
+            this.outputLines.push(`${this.indent(depth)}null`);
+            return;
+        }
+        // Handle special types
+        if (this.isSpace(node)) {
+            this.outputLines.push(`${this.indent(depth)}${formatSpace(node)}`);
+            return;
+        }
+        if (this.isContainer(node)) {
+            this.printContainer(node, cursor, depth);
+            return;
+        }
+        if (this.isLeftPadded(node)) {
+            this.printLeftPadded(node, cursor, depth);
+            return;
+        }
+        if (this.isRightPadded(node)) {
+            this.printRightPadded(node, cursor, depth);
+            return;
+        }
+        if ((0, java_1.isJava)(node)) {
+            this.printJavaNode(node, cursor, depth);
+            return;
+        }
+        // Primitive or unknown type
+        if (typeof node !== 'object') {
+            this.outputLines.push(`${this.indent(depth)}${JSON.stringify(node)}`);
+            return;
+        }
+        // Generic object - print as JSON-like
+        this.printGenericObject(node, depth);
+    }
+    printJavaNode(node, cursor, depth) {
+        var _a, _b;
+        const typeName = shortTypeName(node.kind);
+        let header = `${this.indent(depth)}${typeName}`;
+        // Add inline summary for certain types (Identifier, Literal)
+        const summary = getNodeSummary(node);
+        if (summary) {
+            header += ` ${summary}`;
+        }
+        // Add cursor messages if available
+        if (this.options.includeCursorMessages && cursor) {
+            const messages = formatCursorMessages(cursor);
+            if (messages !== '<no messages>') {
+                header += ` [${messages}]`;
+            }
+        }
+        // Add ID if requested
+        if (this.options.includeIds && node.id) {
+            header += ` (id=${node.id.substring(0, 8)}...)`;
+        }
+        this.outputLines.push(header);
+        // Print prefix
+        if (node.prefix) {
+            this.outputLines.push(`${this.indent(depth + 1)}prefix: ${formatSpace(node.prefix)}`);
+        }
+        // Print markers if requested
+        if (this.options.includeMarkers && ((_b = (_a = node.markers) === null || _a === void 0 ? void 0 : _a.markers) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            this.outputLines.push(`${this.indent(depth + 1)}markers: [${node.markers.markers.map((m) => shortTypeName(m.kind)).join(', ')}]`);
+        }
+        // Print other properties
+        this.printNodeProperties(node, cursor, depth + 1);
+    }
+    printNodeProperties(node, cursor, depth) {
+        const excludedProps = new Set([
+            ...EXCLUDED_PROPERTIES,
+            ...this.options.excludeProperties,
+            'kind',
+            'id',
+            'prefix',
+            'markers',
+        ]);
+        for (const [key, value] of Object.entries(node)) {
+            if (excludedProps.has(key))
+                continue;
+            if (value === undefined || value === null)
+                continue;
+            if (this.isSpace(value)) {
+                this.outputLines.push(`${this.indent(depth)}${key}: ${formatSpace(value)}`);
+            }
+            else if (this.isContainer(value)) {
+                this.outputLines.push(`${this.indent(depth)}${key}:`);
+                this.printContainer(value, undefined, depth + 1);
+            }
+            else if (this.isLeftPadded(value)) {
+                this.outputLines.push(`${this.indent(depth)}${key}:`);
+                this.printLeftPadded(value, undefined, depth + 1);
+            }
+            else if (this.isRightPadded(value)) {
+                this.outputLines.push(`${this.indent(depth)}${key}:`);
+                this.printRightPadded(value, undefined, depth + 1);
+            }
+            else if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    this.outputLines.push(`${this.indent(depth)}${key}: []`);
+                }
+                else if (value.every(v => this.isRightPadded(v))) {
+                    this.outputLines.push(`${this.indent(depth)}${key}: [${value.length} RightPadded elements]`);
+                    for (let i = 0; i < value.length; i++) {
+                        this.outputLines.push(`${this.indent(depth + 1)}[${i}]:`);
+                        this.printRightPadded(value[i], undefined, depth + 2);
+                    }
+                }
+                else if (value.every(v => (0, java_1.isJava)(v))) {
+                    this.outputLines.push(`${this.indent(depth)}${key}: [${value.length} elements]`);
+                    for (let i = 0; i < value.length; i++) {
+                        this.outputLines.push(`${this.indent(depth + 1)}[${i}]:`);
+                        this.printNode(value[i], undefined, depth + 2);
+                    }
+                }
+                else {
+                    this.outputLines.push(`${this.indent(depth)}${key}: [${value.length} items]`);
+                }
+            }
+            else if ((0, java_1.isJava)(value)) {
+                this.outputLines.push(`${this.indent(depth)}${key}:`);
+                this.printNode(value, undefined, depth + 1);
+            }
+            else if (typeof value === 'object') {
+                // Skip complex objects that aren't J nodes
+                this.outputLines.push(`${this.indent(depth)}${key}: <object>`);
+            }
+            else {
+                this.outputLines.push(`${this.indent(depth)}${key}: ${JSON.stringify(value)}`);
+            }
+        }
+    }
+    printContainer(container, cursor, depth) {
+        var _a, _b;
+        const elemCount = (_b = (_a = container.elements) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        let header = `${this.indent(depth)}Container<${elemCount} elements>`;
+        if (this.options.includeCursorMessages && cursor) {
+            const messages = formatCursorMessages(cursor);
+            if (messages !== '<no messages>') {
+                header += ` [${messages}]`;
+            }
+        }
+        this.outputLines.push(header);
+        this.outputLines.push(`${this.indent(depth + 1)}before: ${formatSpace(container.before)}`);
+        if (container.elements && container.elements.length > 0) {
+            this.outputLines.push(`${this.indent(depth + 1)}elements:`);
+            for (let i = 0; i < container.elements.length; i++) {
+                this.outputLines.push(`${this.indent(depth + 2)}[${i}]:`);
+                this.printRightPadded(container.elements[i], undefined, depth + 3);
+            }
+        }
+    }
+    printLeftPadded(lp, cursor, depth) {
+        let header = `${this.indent(depth)}LeftPadded`;
+        if (this.options.includeCursorMessages && cursor) {
+            const messages = formatCursorMessages(cursor);
+            if (messages !== '<no messages>') {
+                header += ` [${messages}]`;
+            }
+        }
+        this.outputLines.push(header);
+        this.outputLines.push(`${this.indent(depth + 1)}before: ${formatSpace(lp.before)}`);
+        if (lp.element !== undefined) {
+            if ((0, java_1.isJava)(lp.element)) {
+                this.outputLines.push(`${this.indent(depth + 1)}element:`);
+                this.printNode(lp.element, undefined, depth + 2);
+            }
+            else if (this.isSpace(lp.element)) {
+                this.outputLines.push(`${this.indent(depth + 1)}element: ${formatSpace(lp.element)}`);
+            }
+            else {
+                this.outputLines.push(`${this.indent(depth + 1)}element: ${JSON.stringify(lp.element)}`);
+            }
+        }
+    }
+    printRightPadded(rp, cursor, depth) {
+        let header = `${this.indent(depth)}RightPadded`;
+        if (this.options.includeCursorMessages && cursor) {
+            const messages = formatCursorMessages(cursor);
+            if (messages !== '<no messages>') {
+                header += ` [${messages}]`;
+            }
+        }
+        this.outputLines.push(header);
+        if (rp.element !== undefined) {
+            if ((0, java_1.isJava)(rp.element)) {
+                this.outputLines.push(`${this.indent(depth + 1)}element:`);
+                this.printNode(rp.element, undefined, depth + 2);
+            }
+            else {
+                this.outputLines.push(`${this.indent(depth + 1)}element: ${JSON.stringify(rp.element)}`);
+            }
+        }
+        this.outputLines.push(`${this.indent(depth + 1)}after: ${formatSpace(rp.after)}`);
+    }
+    printGenericObject(obj, depth) {
+        this.outputLines.push(`${this.indent(depth)}{`);
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'object' && value !== null) {
+                this.outputLines.push(`${this.indent(depth + 1)}${key}: <object>`);
+            }
+            else {
+                this.outputLines.push(`${this.indent(depth + 1)}${key}: ${JSON.stringify(value)}`);
+            }
+        }
+        this.outputLines.push(`${this.indent(depth)}}`);
+    }
+    isSpace(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            'whitespace' in value &&
+            'comments' in value &&
+            !('kind' in value);
+    }
+    isContainer(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            value.kind === java_1.J.Kind.Container;
+    }
+    isLeftPadded(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            value.kind === java_1.J.Kind.LeftPadded;
+    }
+    isRightPadded(value) {
+        return value !== null &&
+            typeof value === 'object' &&
+            value.kind === java_1.J.Kind.RightPadded;
+    }
+    indent(depth) {
+        return this.options.indent.repeat(depth);
+    }
+    flush() {
+        const output = this.outputLines.join('\n');
+        if (this.options.output === 'console') {
+            console.info(output);
+        }
+        else {
+            fs.appendFileSync(this.options.output, output + '\n\n');
+        }
+        this.outputLines = [];
+    }
+}
+exports.LstDebugPrinter = LstDebugPrinter;
+/**
+ * A visitor that prints the LST structure as it traverses.
+ * Useful for debugging the entire tree or a subtree.
+ *
+ * Usage:
+ * ```typescript
+ * const debugVisitor = new LstDebugVisitor({ maxDepth: 3 });
+ * await debugVisitor.visit(tree, ctx);
+ * ```
+ */
+class LstDebugVisitor extends visitor_1.JavaScriptVisitor {
+    constructor(options = {}, config = {}) {
+        var _a, _b;
+        super();
+        this.depth = 0;
+        this.printer = new LstDebugPrinter(options);
+        this.printPreVisit = (_a = config.printPreVisit) !== null && _a !== void 0 ? _a : true;
+        this.printPostVisit = (_b = config.printPostVisit) !== null && _b !== void 0 ? _b : false;
+    }
+    preVisit(tree, _p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.printPreVisit) {
+                const typeName = shortTypeName(tree.kind);
+                const indent = '  '.repeat(this.depth);
+                const messages = formatCursorMessages(this.cursor);
+                const prefix = formatSpace(tree.prefix);
+                const summary = getNodeSummary(tree);
+                const propPath = findPropertyPath(this.cursor);
+                let line = indent;
+                if (propPath) {
+                    line += `${propPath}: `;
+                }
+                line += `${typeName}{`;
+                if (summary) {
+                    line += `${summary} `;
+                }
+                line += `prefix=${prefix}}`;
+                console.info(line);
+                // Show cursor messages on a separate indented line
+                if (messages !== '<no messages>') {
+                    console.info(`${indent}  ⤷ ${messages}`);
+                }
+            }
+            this.depth++;
+            return tree;
+        });
+    }
+    postVisit(tree, _p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.depth--;
+            if (this.printPostVisit) {
+                const typeName = shortTypeName(tree.kind);
+                const indent = '  '.repeat(this.depth);
+                console.info(`${indent}← ${typeName}`);
+            }
+            return tree;
+        });
+    }
+    visitContainer(container, p) {
+        const _super = Object.create(null, {
+            visitContainer: { get: () => super.visitContainer }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.printPreVisit) {
+                const indent = '  '.repeat(this.depth);
+                const messages = formatCursorMessages(this.cursor);
+                const before = formatSpace(container.before);
+                // Pass container as the child since cursor.value is the parent node
+                const propPath = findPropertyPath(this.cursor, container);
+                let line = indent;
+                if (propPath) {
+                    line += `${propPath}: `;
+                }
+                line += `Container<${container.elements.length}>{before=${before}}`;
+                console.info(line);
+                if (messages !== '<no messages>') {
+                    console.info(`${indent}  ⤷ ${messages}`);
+                }
+            }
+            this.depth++;
+            const result = yield _super.visitContainer.call(this, container, p);
+            this.depth--;
+            return result;
+        });
+    }
+    visitLeftPadded(left, p) {
+        const _super = Object.create(null, {
+            visitLeftPadded: { get: () => super.visitLeftPadded }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.printPreVisit) {
+                const indent = '  '.repeat(this.depth);
+                const messages = formatCursorMessages(this.cursor);
+                const before = formatSpace(left.before);
+                // Pass left as the child since cursor.value is the parent node
+                const propPath = findPropertyPath(this.cursor, left);
+                let line = indent;
+                if (propPath) {
+                    line += `${propPath}: `;
+                }
+                line += `LeftPadded{before=${before}`;
+                // Show element value if it's a primitive (string, number, boolean)
+                if (left.element !== null && left.element !== undefined) {
+                    const elemType = typeof left.element;
+                    if (elemType === 'string' || elemType === 'number' || elemType === 'boolean') {
+                        line += ` element=${JSON.stringify(left.element)}`;
+                    }
+                }
+                line += '}';
+                console.info(line);
+                if (messages !== '<no messages>') {
+                    console.info(`${indent}  ⤷ ${messages}`);
+                }
+            }
+            this.depth++;
+            const result = yield _super.visitLeftPadded.call(this, left, p);
+            this.depth--;
+            return result;
+        });
+    }
+    visitRightPadded(right, p) {
+        const _super = Object.create(null, {
+            visitRightPadded: { get: () => super.visitRightPadded }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.printPreVisit) {
+                const indent = '  '.repeat(this.depth);
+                const messages = formatCursorMessages(this.cursor);
+                const after = formatSpace(right.after);
+                // Pass right as the child since cursor.value is the parent node
+                const propPath = findPropertyPath(this.cursor, right);
+                let line = indent;
+                if (propPath) {
+                    line += `${propPath}: `;
+                }
+                line += `RightPadded{after=${after}`;
+                // Show element value if it's a primitive (string, number, boolean)
+                if (right.element !== null && right.element !== undefined) {
+                    const elemType = typeof right.element;
+                    if (elemType === 'string' || elemType === 'number' || elemType === 'boolean') {
+                        line += ` element=${JSON.stringify(right.element)}`;
+                    }
+                }
+                line += '}';
+                console.info(line);
+                if (messages !== '<no messages>') {
+                    console.info(`${indent}  ⤷ ${messages}`);
+                }
+            }
+            this.depth++;
+            const result = yield _super.visitRightPadded.call(this, right, p);
+            this.depth--;
+            return result;
+        });
+    }
+}
+exports.LstDebugVisitor = LstDebugVisitor;
+/**
+ * Convenience function to print a tree node.
+ * @param tree The tree node to print
+ * @param cursor Optional cursor for context
+ * @param label Optional label to identify this debug output
+ * @param options Optional debug options
+ */
+function debugPrint(tree, cursor, label, options) {
+    new LstDebugPrinter(options).print(tree, cursor, label);
+}
+/**
+ * Convenience function to print cursor path.
+ */
+function debugPrintCursorPath(cursor, options) {
+    new LstDebugPrinter(options).printCursorPath(cursor);
+}
+//# sourceMappingURL=tree-debug.js.map