rawsql-ts 0.11.37-beta → 0.11.38-beta

package/dist/esm/src/parsers/SqlPrintTokenParser.js

@@ -118,10 +118,31 @@ export const PRESETS = {
     },
 };
 export class SqlPrintTokenParser {
+    static getSelfHandlingComponentTypes() {
+        if (!this._selfHandlingComponentTypes) {
+            this._selfHandlingComponentTypes = new Set([
+                SimpleSelectQuery.kind,
+                SelectItem.kind,
+                CaseKeyValuePair.kind,
+                SwitchCaseArgument.kind,
+                ColumnReference.kind,
+                LiteralValue.kind,
+                ParameterExpression.kind,
+                TableSource.kind,
+                SourceAliasExpression.kind,
+                TypeValue.kind,
+                FunctionCall.kind,
+                IdentifierString.kind,
+                QualifiedName.kind
+            ]);
+        }
+        return this._selfHandlingComponentTypes;
+    }
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this.handlers = new Map();
         this.index = 1;
+        this.commentStyle = 'block';
         if (options === null || options === void 0 ? void 0 : options.preset) {
             const preset = options.preset;
             options = Object.assign(Object.assign({}, preset), options);
@@ -135,6 +156,7 @@ export class SqlPrintTokenParser {
             start: (_e = (_d = options === null || options === void 0 ? void 0 : options.identifierEscape) === null || _d === void 0 ? void 0 : _d.start) !== null && _e !== void 0 ? _e : '"',
             end: (_g = (_f = options === null || options === void 0 ? void 0 : options.identifierEscape) === null || _f === void 0 ? void 0 : _f.end) !== null && _g !== void 0 ? _g : '"'
         });
+        this.commentStyle = (_h = options === null || options === void 0 ? void 0 : options.commentStyle) !== null && _h !== void 0 ? _h : 'block';
         this.handlers.set(ValueList.kind, (expr) => this.visitValueList(expr));
         this.handlers.set(ColumnReference.kind, (expr) => this.visitColumnReference(expr));
         this.handlers.set(QualifiedName.kind, (expr) => this.visitQualifiedName(expr));
@@ -218,10 +240,23 @@ export class SqlPrintTokenParser {
      */
     visitBinarySelectQuery(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '');
-        // Add headerComments at the very beginning (before the first query)
-        if (arg.headerComments && arg.headerComments.length > 0) {
-            const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
-            token.innerTokens.push(...headerCommentBlocks);
+        // Handle positioned comments for BinarySelectQuery (unified spec)
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
+        else if (arg.headerComments && arg.headerComments.length > 0) {
+            // Fallback to legacy headerComments if no positioned comments
+            // For smart comment style, treat headerComments as a single multi-line block
+            if (this.commentStyle === 'smart' && arg.headerComments.length > 1) {
+                const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
+                token.innerTokens.push(mergedHeaderComment);
+            }
+            else {
+                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
+                token.innerTokens.push(...headerCommentBlocks);
+            }
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         }
         token.innerTokens.push(this.visit(arg.left));
@@ -249,7 +284,25 @@ export class SqlPrintTokenParser {
                 token.innerTokens.push(SqlPrintTokenParser.DOT_TOKEN);
             }
         }
-        token.innerTokens.push(arg.name.accept(this));
+        // Handle name and its comments carefully
+        // We need to prevent double processing by temporarily clearing the name's comments,
+        // then process them at the QualifiedName level
+        const originalNameComments = arg.name.positionedComments;
+        const originalNameLegacyComments = arg.name.comments;
+        // Temporarily clear name's comments to prevent double processing
+        arg.name.positionedComments = null;
+        arg.name.comments = null;
+        const nameToken = arg.name.accept(this);
+        token.innerTokens.push(nameToken);
+        // Restore original comments
+        arg.name.positionedComments = originalNameComments;
+        arg.name.comments = originalNameLegacyComments;
+        // Apply the name's comments to the qualified name token
+        if (this.hasPositionedComments(arg.name) || this.hasLegacyComments(arg.name)) {
+            this.addComponentComments(token, arg.name);
+        }
+        // Also handle any comments directly on the QualifiedName itself
+        this.addComponentComments(token, arg);
         return token;
     }
     visitPartitionByClause(arg) {
@@ -328,49 +381,312 @@ export class SqlPrintTokenParser {
         // Fallback (just in case)
         return { token, params: [] };
     }
+    /**
+     * Check if a component handles its own comments
+     */
+    componentHandlesOwnComments(component) {
+        // First check if component has a handlesOwnComments method
+        if ('handlesOwnComments' in component && typeof component.handlesOwnComments === 'function') {
+            return component.handlesOwnComments();
+        }
+        return SqlPrintTokenParser.getSelfHandlingComponentTypes().has(component.getKind());
+    }
     visit(arg) {
         const handler = this.handlers.get(arg.getKind());
         if (handler) {
             const token = handler(arg);
-            // Check if component handles its own comments to avoid double processing
-            const handlesOwnComments = 'handlesOwnComments' in arg && typeof arg.handlesOwnComments === 'function'
-                ? arg.handlesOwnComments()
-                : arg.getKind() === SimpleSelectQuery.kind; // Fallback for existing SimpleSelectQuery
-            if (!handlesOwnComments) {
-                this.addCommentsToToken(token, arg.comments);
+            if (!this.componentHandlesOwnComments(arg)) {
+                this.addComponentComments(token, arg);
             }
             return token;
         }
         throw new Error(`[SqlPrintTokenParser] No handler for kind: ${arg.getKind().toString()}`);
     }
+    /**
+     * Check if a component has positioned comments
+     */
+    hasPositionedComments(component) {
+        var _a, _b;
+        return ((_b = (_a = component.positionedComments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
+    }
+    /**
+     * Check if a component has legacy comments
+     */
+    hasLegacyComments(component) {
+        var _a, _b;
+        return ((_b = (_a = component.comments) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
+    }
+    /**
+     * Centralized comment handling - checks positioned comments first, falls back to legacy
+     */
+    addComponentComments(token, component) {
+        if (this.hasPositionedComments(component)) {
+            this.addPositionedCommentsToToken(token, component);
+        }
+        else if (this.hasLegacyComments(component)) {
+            this.addCommentsToToken(token, component.comments);
+        }
+    }
+    /**
+     * Adds positioned comment tokens to a SqlPrintToken for inline formatting
+     */
+    addPositionedCommentsToToken(token, component) {
+        if (!this.hasPositionedComments(component)) {
+            return;
+        }
+        // Handle 'before' comments - add inline at the beginning with spaces
+        const beforeComments = component.getPositionedComments('before');
+        if (beforeComments.length > 0) {
+            const commentBlocks = this.createCommentBlocks(beforeComments);
+            // Create a single inline sequence: /* comment */ content
+            const beforeTokens = [];
+            for (const commentBlock of commentBlocks) {
+                beforeTokens.push(commentBlock);
+                beforeTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+            }
+            // Insert before the existing content
+            token.innerTokens.unshift(...beforeTokens);
+        }
+        // Handle 'after' comments - add inline after the main content
+        const afterComments = component.getPositionedComments('after');
+        if (afterComments.length > 0) {
+            const commentBlocks = this.createCommentBlocks(afterComments);
+            // Append after comments with spaces for inline formatting
+            for (const commentBlock of commentBlocks) {
+                token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+                token.innerTokens.push(commentBlock);
+            }
+        }
+        // Clear positioned comments to prevent duplicate processing (unified spec)
+        // Only clear for specific component types that are known to have duplication issues
+        const componentsWithDuplicationIssues = [
+            SqlPrintTokenContainerType.CaseExpression,
+            SqlPrintTokenContainerType.SwitchCaseArgument,
+            SqlPrintTokenContainerType.CaseKeyValuePair,
+            SqlPrintTokenContainerType.SelectClause, // SELECT clauses have manual + automatic processing
+            SqlPrintTokenContainerType.LiteralValue,
+            SqlPrintTokenContainerType.IdentifierString,
+            SqlPrintTokenContainerType.DistinctOn,
+            SqlPrintTokenContainerType.SourceAliasExpression,
+            SqlPrintTokenContainerType.SimpleSelectQuery,
+            SqlPrintTokenContainerType.WhereClause // WHERE clauses also have duplication issues
+        ];
+        if (token.containerType && componentsWithDuplicationIssues.includes(token.containerType)) {
+            component.positionedComments = null;
+        }
+    }
     /**
      * Adds comment tokens to a SqlPrintToken based on the comments array
      */
     addCommentsToToken(token, comments) {
-        if (!comments || comments.length === 0) {
+        if (!(comments === null || comments === void 0 ? void 0 : comments.length)) {
             return;
         }
-        // Create CommentBlock containers for each comment
-        const commentBlocks = this.createCommentBlocks(comments);
-        // Insert comment blocks and handle spacing
-        if (commentBlocks.length > 0) {
+        // For multiple comments, create inline comment sequence instead of separate blocks
+        if (comments.length > 1) {
+            const inlineComments = this.createInlineCommentSequence(comments);
+            this.insertCommentBlocksWithSpacing(token, inlineComments);
+        }
+        else {
+            // Create CommentBlock containers for single comment
+            const commentBlocks = this.createCommentBlocks(comments);
             this.insertCommentBlocksWithSpacing(token, commentBlocks);
         }
     }
+    /**
+     * Creates inline comment sequence for multiple comments without newlines
+     */
+    createInlineCommentSequence(comments) {
+        const commentTokens = [];
+        for (let i = 0; i < comments.length; i++) {
+            const comment = comments[i];
+            if (comment.trim()) {
+                // Add comment token directly
+                const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatBlockComment(comment));
+                commentTokens.push(commentToken);
+                // Add space between comments (except after last comment)
+                if (i < comments.length - 1) {
+                    const spaceToken = new SqlPrintToken(SqlPrintTokenType.space, ' ');
+                    commentTokens.push(spaceToken);
+                }
+            }
+        }
+        return commentTokens;
+    }
     /**
      * Creates CommentBlock containers for the given comments.
      * Each CommentBlock contains: Comment -> CommentNewline -> Space
      * This structure supports both oneliner and multiline formatting modes.
      */
     createCommentBlocks(comments) {
+        if (this.commentStyle === 'smart') {
+            return this.createSmartCommentBlocks(comments);
+        }
+        // Block style (default) - each comment gets its own block
         const commentBlocks = [];
         for (const comment of comments) {
-            if (comment.trim()) {
+            // Accept comments that have content after trim OR are separator lines OR are empty (for structure preservation)
+            const trimmed = comment.trim();
+            const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
+            if (trimmed || isSeparatorLine || comment === '') {
                 commentBlocks.push(this.createSingleCommentBlock(comment));
             }
         }
         return commentBlocks;
     }
+    /**
+     * Creates smart comment blocks by merging consecutive block comments into multi-line format
+     */
+    createSmartCommentBlocks(comments) {
+        const commentBlocks = [];
+        const blockComments = [];
+        const flushBlockComments = () => {
+            if (blockComments.length > 0) {
+                if (blockComments.length === 1) {
+                    // Single comment - keep as-is
+                    commentBlocks.push(this.createSingleCommentBlock(blockComments[0]));
+                }
+                else {
+                    // Multiple consecutive comments - create multi-line block
+                    commentBlocks.push(this.createMultiLineCommentBlock(blockComments));
+                }
+                blockComments.length = 0;
+            }
+        };
+        for (const comment of comments) {
+            const trimmed = comment.trim();
+            const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
+            if (!trimmed && !isSeparatorLine && comment !== '') {
+                continue;
+            }
+            // Check if this is a block comment that should be merged
+            if (this.shouldMergeComment(trimmed)) {
+                blockComments.push(comment);
+            }
+            else {
+                // Flush any accumulated block comments first
+                flushBlockComments();
+                // Add this comment as-is
+                commentBlocks.push(this.createSingleCommentBlock(comment));
+            }
+        }
+        // Flush any remaining block comments
+        flushBlockComments();
+        return commentBlocks;
+    }
+    /**
+     * Determines if a comment should be merged with consecutive comments
+     */
+    shouldMergeComment(trimmed) {
+        const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
+        // Don't merge line comments unless they are separator-only lines
+        if (!isSeparatorLine && trimmed.startsWith('--')) {
+            return false;
+        }
+        // Don't merge if it's already a proper multi-line block comment
+        if (trimmed.startsWith('/*') && trimmed.endsWith('*/') && trimmed.includes('\n')) {
+            return false;
+        }
+        // Merge all other content including separator lines, plain text, and single-line block comments
+        // Separator lines within comment blocks should be merged together
+        return true;
+    }
+    /**
+     * Creates a multi-line block comment structure from consecutive comments
+     * Returns a CommentBlock containing multiple comment lines for proper LinePrinter integration
+     */
+    createMultiLineCommentBlock(comments) {
+        const lines = [];
+        for (const comment of comments) {
+            const trimmed = comment.trim();
+            // Remove existing /* */ markers if present and extract content
+            if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+                const content = trimmed.slice(2, -2);
+                if (content.trim()) {
+                    // Sanitize the content (only remove /* and */)
+                    const sanitized = content
+                        .replace(/\*\//g, '*') // Remove */ sequences
+                        .replace(/\/\*/g, '*'); // Remove /* sequences
+                    // Split multi-line content and add each line
+                    const contentLines = sanitized.split('\n').map(line => line.trim()).filter(line => line);
+                    lines.push(...contentLines);
+                }
+            }
+            else if (trimmed) {
+                // Sanitize plain text content
+                const sanitized = trimmed
+                    .replace(/\*\//g, '*') // Remove */ sequences
+                    .replace(/\/\*/g, '*'); // Remove /* sequences
+                // Split plain text content by lines
+                const contentLines = sanitized.split('\n').map(line => line.trim()).filter(line => line);
+                lines.push(...contentLines);
+            }
+        }
+        // Create multi-line comment block structure
+        const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
+        if (lines.length === 0) {
+            // Empty comment
+            const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, '/* */');
+            commentBlock.innerTokens.push(commentToken);
+        }
+        else {
+            // Opening /*
+            const openToken = new SqlPrintToken(SqlPrintTokenType.comment, '/*');
+            commentBlock.innerTokens.push(openToken);
+            commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            // Content lines (each as separate comment token)
+            for (const line of lines) {
+                const lineToken = new SqlPrintToken(SqlPrintTokenType.comment, `  ${line}`);
+                commentBlock.innerTokens.push(lineToken);
+                commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            }
+            // Closing */
+            const closeToken = new SqlPrintToken(SqlPrintTokenType.comment, '*/');
+            commentBlock.innerTokens.push(closeToken);
+        }
+        // Add final newline and space for standard structure
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+        return commentBlock;
+    }
+    /**
+     * Creates a multi-line comment block specifically for headerComments
+     * headerComments come as pre-split lines, so we handle them differently
+     */
+    createHeaderMultiLineCommentBlock(headerComments) {
+        // Keep all lines including empty ones to preserve structure
+        const lines = headerComments;
+        // Create multi-line comment block structure
+        const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
+        if (lines.length === 0) {
+            // Empty comment
+            const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, '/* */');
+            commentBlock.innerTokens.push(commentToken);
+        }
+        else {
+            // Opening /*
+            const openToken = new SqlPrintToken(SqlPrintTokenType.comment, '/*');
+            commentBlock.innerTokens.push(openToken);
+            commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            // Content lines (each as separate comment token)
+            for (const line of lines) {
+                // Sanitize the line content
+                const sanitized = line
+                    .replace(/\*\//g, '*') // Remove */ sequences
+                    .replace(/\/\*/g, '*'); // Remove /* sequences
+                const lineToken = new SqlPrintToken(SqlPrintTokenType.comment, `  ${sanitized}`);
+                commentBlock.innerTokens.push(lineToken);
+                commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            }
+            // Closing */
+            const closeToken = new SqlPrintToken(SqlPrintTokenType.comment, '*/');
+            commentBlock.innerTokens.push(closeToken);
+        }
+        // Add final newline and space for standard structure
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+        return commentBlock;
+    }
     /**
      * Creates a single CommentBlock with the standard structure:
      * Comment -> CommentNewline -> Space
@@ -381,8 +697,8 @@ export class SqlPrintTokenParser {
      */
     createSingleCommentBlock(comment) {
         const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
-        // Add comment token
-        const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatBlockComment(comment));
+        // Add comment token - preserve original format for line comments
+        const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatComment(comment));
         commentBlock.innerTokens.push(commentToken);
         // Add conditional newline token for multiline mode
         const commentNewlineToken = new SqlPrintToken(SqlPrintTokenType.commentNewline, '');
@@ -392,6 +708,40 @@ export class SqlPrintTokenParser {
         commentBlock.innerTokens.push(spaceToken);
         return commentBlock;
     }
+    /**
+     * Formats a comment, preserving line comment format for -- comments
+     * and converting others to block format for safety
+     */
+    formatComment(comment) {
+        const trimmed = comment.trim();
+        // Smart style processing
+        if (this.commentStyle === 'smart') {
+            return this.formatCommentSmart(trimmed);
+        }
+        // Default block style processing
+        // If it's already a line comment, preserve it
+        // But exclude separator lines (lines with only dashes, equals, etc.)
+        if (trimmed.startsWith('--') && !/^--[-=_+*#]*$/.test(trimmed)) {
+            return trimmed;
+        }
+        // If it's already a block comment, preserve it (but sanitize)
+        if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+            // Pass the entire comment including /* and */ for proper sanitization
+            return this.formatBlockComment(trimmed);
+        }
+        // For plain text comments, convert to block format
+        return this.formatBlockComment(trimmed);
+    }
+    /**
+     * Formats comments using smart style rules:
+     * - Only multi-line block comment merging is supported
+     * - Single-line comments remain as block comments (no dash conversion)
+     */
+    formatCommentSmart(comment) {
+        // Smart style only affects multi-line comment merging at createSmartCommentBlocks level
+        // Individual comment formatting remains the same as block style
+        return this.formatBlockComment(comment);
+    }
     /**
      * Inserts comment blocks into a token and handles spacing logic.
      * Adds separator spaces for clause-level containers and manages duplicate space removal.
@@ -417,6 +767,18 @@ export class SqlPrintTokenParser {
             token.innerTokens.unshift(SqlPrintTokenParser.SPACE_TOKEN, ...commentBlocks);
             return;
         }
+        // Special handling for IdentifierString to add space before comment
+        if (token.containerType === SqlPrintTokenContainerType.IdentifierString) {
+            // Add space before comment if not already present
+            if (token.innerTokens.length > 0) {
+                const lastToken = token.innerTokens[token.innerTokens.length - 1];
+                if (lastToken.type !== SqlPrintTokenType.space) {
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                }
+            }
+            token.innerTokens.push(...commentBlocks);
+            return;
+        }
         token.innerTokens.unshift(...commentBlocks);
         // Add a separator space after comments only for certain container types
         // where comments need to be separated from main content
@@ -439,6 +801,38 @@ export class SqlPrintTokenParser {
             }
         }
     }
+    /**
+     * Handles positioned comments for ParenExpression with special spacing rules.
+     * ParenExpression comments should be adjacent to parentheses without separator spaces.
+     */
+    addPositionedCommentsToParenExpression(token, component) {
+        if (!component.positionedComments) {
+            return;
+        }
+        // For ParenExpression: (/* comment */ content /* comment */)
+        // Comments should be placed immediately after opening paren and before closing paren
+        // Handle 'before' comments - place after opening parenthesis without space
+        const beforeComments = component.getPositionedComments('before');
+        if (beforeComments.length > 0) {
+            const commentBlocks = this.createCommentBlocks(beforeComments);
+            // Insert after opening paren (index 1) without separator space
+            let insertIndex = 1;
+            for (const commentBlock of commentBlocks) {
+                token.innerTokens.splice(insertIndex, 0, commentBlock);
+                insertIndex++;
+            }
+        }
+        // Handle 'after' comments - place before closing parenthesis without space
+        const afterComments = component.getPositionedComments('after');
+        if (afterComments.length > 0) {
+            const commentBlocks = this.createCommentBlocks(afterComments);
+            // Insert before closing paren (last position) without separator space
+            const insertIndex = token.innerTokens.length;
+            for (const commentBlock of commentBlocks) {
+                token.innerTokens.splice(insertIndex - 1, 0, commentBlock);
+            }
+        }
+    }
     /**
      * Determines whether a separator space should be added after comments for the given container type.
      *
@@ -478,11 +872,21 @@ export class SqlPrintTokenParser {
      * Prevents SQL injection by removing dangerous comment sequences.
      */
     formatBlockComment(comment) {
-        // Remove dangerous comment termination sequences to prevent SQL injection
-        const sanitizedComment = comment
+        // Sanitize dangerous comment sequences to prevent SQL injection
+        let sanitizedComment = comment
             .replace(/\*\//g, '*') // Remove comment close sequences
-            .replace(/\/\*/g, '*') // Remove comment open sequences
-            .replace(/\r?\n/g, ' ') // Replace newlines with spaces for single-line comments
+            .replace(/\/\*/g, '*'); // Remove comment open sequences
+        // Check if this is a separator line (like ----------) before processing
+        const trimmed = sanitizedComment.trim();
+        const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
+        if (isSeparatorLine) {
+            // For separator lines, preserve as-is (already sanitized above)
+            return `/* ${trimmed} */`;
+        }
+        // For multiline comments: convert newlines to spaces (security requirement)
+        sanitizedComment = sanitizedComment
+            .replace(/\r?\n/g, ' ') // Replace newlines with spaces
+            .replace(/\s+/g, ' ') // Collapse multiple spaces into single space
             .trim(); // Remove leading/trailing whitespace
         // Return empty string if comment becomes empty after sanitization
         if (!sanitizedComment) {
@@ -503,10 +907,12 @@ export class SqlPrintTokenParser {
     visitColumnReference(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ColumnReference);
         token.innerTokens.push(arg.qualifiedName.accept(this));
+        this.addComponentComments(token, arg);
         return token;
     }
     visitFunctionCall(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.FunctionCall);
+        this.addComponentComments(token, arg);
         token.innerTokens.push(arg.qualifiedName.accept(this));
         token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
         if (arg.argument) {
@@ -557,7 +963,13 @@ export class SqlPrintTokenParser {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.BinaryExpression);
         token.innerTokens.push(this.visit(arg.left));
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.operator, arg.operator.value));
+        // Visit the operator to handle its comments properly
+        const operatorToken = this.visit(arg.operator);
+        const operatorLower = operatorToken.text.toLowerCase();
+        if (operatorLower === 'and' || operatorLower === 'or') {
+            operatorToken.type = SqlPrintTokenType.operator;
+        }
+        token.innerTokens.push(operatorToken);
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(this.visit(arg.right));
         return token;
@@ -578,18 +990,30 @@ export class SqlPrintTokenParser {
         else {
             text = arg.value.toString();
         }
-        return new SqlPrintToken(SqlPrintTokenType.value, text, SqlPrintTokenContainerType.LiteralValue);
+        const token = new SqlPrintToken(SqlPrintTokenType.value, text, SqlPrintTokenContainerType.LiteralValue);
+        // Handle positioned comments for LiteralValue
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
+        else if (arg.comments && arg.comments.length > 0) {
+            this.addCommentsToToken(token, arg.comments);
+        }
+        return token;
     }
     visitParameterExpression(arg) {
         // Create a parameter token and decorate it using the parameterDecorator
         arg.index = this.index;
         const text = this.parameterDecorator.decorate(arg.name.value, arg.index);
         const token = new SqlPrintToken(SqlPrintTokenType.parameter, text);
+        this.addComponentComments(token, arg);
         this.index++;
         return token;
     }
     visitSwitchCaseArgument(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.SwitchCaseArgument);
+        this.addComponentComments(token, arg);
         // Add each WHEN/THEN clause
         for (const kv of arg.cases) {
             // Create a new line for each WHEN clause
@@ -599,14 +1023,27 @@ export class SqlPrintTokenParser {
         // Add ELSE clause if present
         if (arg.elseValue) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-            token.innerTokens.push(this.createElseToken(arg.elseValue));
+            token.innerTokens.push(this.createElseToken(arg.elseValue, arg.comments));
+        }
+        // Add SwitchCaseArgument comments (END keyword) if present and no elseValue
+        else if (arg.comments && arg.comments.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(arg.comments);
+            token.innerTokens.push(...commentTokens);
         }
         return token;
     }
-    createElseToken(elseValue) {
+    createElseToken(elseValue, switchCaseComments) {
         // Creates a token for the ELSE clause in a CASE expression.
         const elseToken = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ElseClause); // Add the ELSE keyword
         elseToken.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'else'));
+        // Add ELSE and END keyword comments if present
+        // The switchCaseComments contains both ELSE and END comments in order ['e1', 'end']
+        if (switchCaseComments && switchCaseComments.length > 0) {
+            elseToken.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(switchCaseComments);
+            elseToken.innerTokens.push(...commentTokens);
+        }
         // Create a container for the ELSE value to enable proper indentation
         elseToken.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         const elseValueContainer = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CaseElseValue);
@@ -616,12 +1053,24 @@ export class SqlPrintTokenParser {
     }
     visitCaseKeyValuePair(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CaseKeyValuePair);
+        // Handle positioned comments for CaseKeyValuePair
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
         // Create WHEN clause
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'when'));
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(this.visit(arg.key)); // Create THEN clause
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'then'));
+        // Add THEN keyword comments if present
+        if (arg.comments && arg.comments.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(arg.comments);
+            token.innerTokens.push(...commentTokens);
+        }
         // Create a container for the THEN value to enable proper indentation
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         const thenValueContainer = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CaseThenValue);
@@ -636,14 +1085,71 @@ export class SqlPrintTokenParser {
     visitIdentifierString(arg) {
         // Create an identifier token and decorate it using the identifierDecorator
         const text = arg.name === "*" ? arg.name : this.identifierDecorator.decorate(arg.name);
+        // Handle positioned comments for IdentifierString
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.IdentifierString);
+            // Add positioned comments
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+            // Add the identifier text as the main token
+            const valueToken = new SqlPrintToken(SqlPrintTokenType.value, text);
+            token.innerTokens.push(valueToken);
+            return token;
+        }
+        // If there are legacy comments, create a container instead of a simple value token
+        if (arg.comments && arg.comments.length > 0) {
+            const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.IdentifierString);
+            // Add the identifier text as the main token
+            const valueToken = new SqlPrintToken(SqlPrintTokenType.value, text);
+            token.innerTokens.push(valueToken);
+            // Add legacy comments to the token
+            this.addComponentComments(token, arg);
+            return token;
+        }
         const token = new SqlPrintToken(SqlPrintTokenType.value, text, SqlPrintTokenContainerType.IdentifierString);
         return token;
     }
     visitParenExpression(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ParenExpression);
+        // Handle positioned comments for ParenExpression - check both self and inner expression
+        const hasOwnComments = arg.positionedComments && arg.positionedComments.length > 0;
+        const hasInnerComments = arg.expression.positionedComments && arg.expression.positionedComments.length > 0;
+        // Store inner comments for later processing and clear to prevent duplicate processing
+        let innerBeforeComments = [];
+        let innerAfterComments = [];
+        if (hasInnerComments) {
+            innerBeforeComments = arg.expression.getPositionedComments('before');
+            innerAfterComments = arg.expression.getPositionedComments('after');
+            arg.expression.positionedComments = null;
+        }
+        // Build basic structure first
         token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
         token.innerTokens.push(this.visit(arg.expression));
         token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        // Now add positioned comments in the correct positions manually
+        if (innerBeforeComments.length > 0) {
+            const commentBlocks = this.createCommentBlocks(innerBeforeComments);
+            // Insert after opening paren (index 1) without separator space
+            let insertIndex = 1;
+            for (const commentBlock of commentBlocks) {
+                token.innerTokens.splice(insertIndex, 0, commentBlock);
+                insertIndex++;
+            }
+        }
+        if (innerAfterComments.length > 0) {
+            const commentBlocks = this.createCommentBlocks(innerAfterComments);
+            // Insert before closing paren (last position) without separator space
+            const insertIndex = token.innerTokens.length;
+            for (const commentBlock of commentBlocks) {
+                token.innerTokens.splice(insertIndex - 1, 0, commentBlock);
+            }
+        }
+        if (hasOwnComments) {
+            this.addPositionedCommentsToParenExpression(token, arg);
+            // Clear positioned comments to prevent duplicate processing in parent containers
+            arg.positionedComments = null;
+        }
         return token;
     }
     visitCastExpression(arg) {
@@ -655,6 +1161,12 @@ export class SqlPrintTokenParser {
     }
     visitCaseExpression(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CaseExpression);
+        // Handle positioned comments for CaseExpression (unified spec: positioned comments only)
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
         // Add the CASE keyword
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'case'));
         // Add the condition if exists
@@ -743,6 +1255,7 @@ export class SqlPrintTokenParser {
     }
     visitTypeValue(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.TypeValue);
+        this.addComponentComments(token, arg);
         token.innerTokens.push(arg.qualifiedName.accept(this));
         if (arg.argument) {
             token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
@@ -836,7 +1349,32 @@ export class SqlPrintTokenParser {
     }
     visitSelectItem(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.SelectItem);
+        // Preserve original positioned comments to avoid mutating the source object
+        const originalSelectItemPositionedComments = arg.positionedComments;
+        const originalValuePositionedComments = arg.value.positionedComments;
+        // Clear positioned comments from the value to avoid duplication since SelectItem handles them
+        arg.value.positionedComments = null;
+        // Add 'before' positioned comments
+        const beforeComments = arg.getPositionedComments('before');
+        if (beforeComments.length > 0) {
+            const commentTokens = this.createInlineCommentSequence(beforeComments);
+            token.innerTokens.push(...commentTokens);
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        }
+        // Add the value (column name)
         token.innerTokens.push(this.visit(arg.value));
+        // Add 'after' positioned comments for the value
+        // Skip after comments if the value is ParenExpression (already handled in ParenExpression processing)
+        const afterComments = arg.getPositionedComments('after');
+        const isParenExpression = arg.value.constructor.name === 'ParenExpression';
+        if (afterComments.length > 0 && !isParenExpression) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(afterComments);
+            token.innerTokens.push(...commentTokens);
+        }
+        // Restore original positioned comments to avoid side effects
+        arg.positionedComments = originalSelectItemPositionedComments;
+        arg.value.positionedComments = originalValuePositionedComments;
         if (!arg.identifier) {
             return token;
         }
@@ -849,13 +1387,70 @@ export class SqlPrintTokenParser {
         }
         // Add alias if it is different from the default name
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        // Handle AS keyword positioned comments (before AS)
+        const asKeywordPositionedComments = 'asKeywordPositionedComments' in arg ? arg.asKeywordPositionedComments : null;
+        if (asKeywordPositionedComments) {
+            const beforeComments = asKeywordPositionedComments.filter((pc) => pc.position === 'before');
+            if (beforeComments.length > 0) {
+                for (const posComment of beforeComments) {
+                    const commentTokens = this.createInlineCommentSequence(posComment.comments);
+                    token.innerTokens.push(...commentTokens);
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                }
+            }
+        }
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'as'));
+        // Handle AS keyword positioned comments (after AS)
+        if (asKeywordPositionedComments) {
+            const afterComments = asKeywordPositionedComments.filter((pc) => pc.position === 'after');
+            if (afterComments.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                for (const posComment of afterComments) {
+                    const commentTokens = this.createInlineCommentSequence(posComment.comments);
+                    token.innerTokens.push(...commentTokens);
+                }
+            }
+        }
+        // Fallback: Add AS keyword legacy comments if present
+        const asKeywordComments = 'asKeywordComments' in arg ? arg.asKeywordComments : null;
+        if (asKeywordComments && asKeywordComments.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(asKeywordComments);
+            token.innerTokens.push(...commentTokens);
+        }
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-        token.innerTokens.push(this.visit(arg.identifier));
+        // Visit identifier to get alias with proper spacing
+        const identifierToken = this.visit(arg.identifier);
+        token.innerTokens.push(identifierToken);
+        // Handle alias positioned comments (after alias)
+        const aliasPositionedComments = 'aliasPositionedComments' in arg ? arg.aliasPositionedComments : null;
+        if (aliasPositionedComments) {
+            const afterComments = aliasPositionedComments.filter((pc) => pc.position === 'after');
+            if (afterComments.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                for (const posComment of afterComments) {
+                    const commentTokens = this.createInlineCommentSequence(posComment.comments);
+                    token.innerTokens.push(...commentTokens);
+                }
+            }
+        }
+        // Fallback: Add alias legacy comments if present
+        const aliasComments = arg.aliasComments;
+        if (aliasComments && aliasComments.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(aliasComments);
+            token.innerTokens.push(...commentTokens);
+        }
         return token;
     }
     visitSelectClause(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'select', SqlPrintTokenContainerType.SelectClause);
+        // Handle positioned comments for SelectClause (unified spec)
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
         // Handle hints and DISTINCT as part of the keyword line
         let selectKeywordText = 'select';
         // Add hint clauses immediately after SELECT (before DISTINCT)
@@ -903,6 +1498,12 @@ export class SqlPrintTokenParser {
     }
     visitDistinct(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'distinct');
+        // Handle positioned comments for Distinct (unified spec)
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
         return token;
     }
     visitDistinctOn(arg) {
@@ -921,6 +1522,7 @@ export class SqlPrintTokenParser {
         }
         fullName += arg.table.accept(this).text;
         const token = new SqlPrintToken(SqlPrintTokenType.value, fullName);
+        this.addComponentComments(token, arg);
         // alias (if present and different from table name)
         if (arg.identifier && arg.identifier.name !== arg.table.name) {
         }
@@ -971,8 +1573,38 @@ export class SqlPrintTokenParser {
     visitJoinClause(arg) {
         // Print join clause: [joinType] [lateral] [source] [on/using ...]
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.JoinClause);
+        // Handle JOIN keyword positioned comments (before JOIN)
+        const joinKeywordPositionedComments = arg.joinKeywordPositionedComments;
+        if (joinKeywordPositionedComments) {
+            const beforeComments = joinKeywordPositionedComments.filter((pc) => pc.position === 'before');
+            if (beforeComments.length > 0) {
+                for (const posComment of beforeComments) {
+                    const commentTokens = this.createInlineCommentSequence(posComment.comments);
+                    token.innerTokens.push(...commentTokens);
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                }
+            }
+        }
         // join type (e.g. inner join, left join, etc)
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.joinType.value));
+        // Handle JOIN keyword positioned comments (after JOIN)
+        if (joinKeywordPositionedComments) {
+            const afterComments = joinKeywordPositionedComments.filter((pc) => pc.position === 'after');
+            if (afterComments.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                for (const posComment of afterComments) {
+                    const commentTokens = this.createInlineCommentSequence(posComment.comments);
+                    token.innerTokens.push(...commentTokens);
+                }
+            }
+        }
+        // Fallback: Add JOIN keyword legacy comments if present
+        const joinKeywordComments = arg.joinKeywordComments;
+        if (joinKeywordComments && joinKeywordComments.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentTokens = this.createInlineCommentSequence(joinKeywordComments);
+            token.innerTokens.push(...commentTokens);
+        }
         if (arg.lateral) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'lateral'));
@@ -1025,10 +1657,20 @@ export class SqlPrintTokenParser {
             }
             token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
         }
+        // Handle positioned comments for SourceAliasExpression (alias name comments)
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
+        else if (arg.comments && arg.comments.length > 0) {
+            this.addCommentsToToken(token, arg.comments);
+        }
         return token;
     }
     visitWhereClause(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'where', SqlPrintTokenContainerType.WhereClause);
+        this.addComponentComments(token, arg);
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(this.visit(arg.condition));
         return token;
@@ -1121,10 +1763,20 @@ export class SqlPrintTokenParser {
             token.innerTokens.push(arg.tables[i].accept(this));
         }
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        this.addComponentComments(token, arg);
         return token;
     }
     visitCommonTable(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommonTable);
+        // Handle positioned comments for CommonTable (avoid duplication)
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
+        else if (arg.comments && arg.comments.length > 0) {
+            this.addCommentsToToken(token, arg.comments);
+        }
         token.innerTokens.push(arg.aliasExpression.accept(this));
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'as'));
@@ -1148,14 +1800,27 @@ export class SqlPrintTokenParser {
     // query
     visitSimpleQuery(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.SimpleSelectQuery);
-        // Add headerComments at the very beginning (before WITH clause)
+        // Handle positioned comments for SimpleSelectQuery (unified spec)
         if (arg.headerComments && arg.headerComments.length > 0) {
-            const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
-            token.innerTokens.push(...headerCommentBlocks);
+            // Fallback to legacy headerComments if no positioned comments
+            // For smart comment style, treat headerComments as a single multi-line block
+            if (this.commentStyle === 'smart' && arg.headerComments.length > 1) {
+                const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
+                token.innerTokens.push(mergedHeaderComment);
+            }
+            else {
+                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
+                token.innerTokens.push(...headerCommentBlocks);
+            }
             if (arg.withClause) {
                 token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             }
         }
+        if (arg.positionedComments && arg.positionedComments.length > 0) {
+            this.addPositionedCommentsToToken(token, arg);
+            // Clear positioned comments to prevent duplicate processing
+            arg.positionedComments = null;
+        }
         if (arg.withClause) {
             token.innerTokens.push(arg.withClause.accept(this));
         }
@@ -1371,4 +2036,7 @@ SqlPrintTokenParser.ARGUMENT_SPLIT_COMMA_TOKEN = new SqlPrintToken(SqlPrintToken
 SqlPrintTokenParser.PAREN_OPEN_TOKEN = new SqlPrintToken(SqlPrintTokenType.parenthesis, '(');
 SqlPrintTokenParser.PAREN_CLOSE_TOKEN = new SqlPrintToken(SqlPrintTokenType.parenthesis, ')');
 SqlPrintTokenParser.DOT_TOKEN = new SqlPrintToken(SqlPrintTokenType.dot, '.');
+// Set of component kinds that handle their own positioned comments
+// Note: Cannot use static readonly due to circular dependency issues with class initialization
+SqlPrintTokenParser._selfHandlingComponentTypes = null;
 //# sourceMappingURL=SqlPrintTokenParser.js.map