rawsql-ts 0.11.42-beta → 0.11.43-beta

package/dist/esm/src/parsers/SqlPrintTokenParser.d.ts

@@ -39,7 +39,6 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
     parameterDecorator: ParameterDecorator;
     identifierDecorator: IdentifierDecorator;
     index: number;
-    private commentStyle;
     constructor(options?: {
         preset?: FormatterConfig;
         identifierEscape?: {
@@ -51,7 +50,6 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
             end: string;
         };
         parameterStyle?: 'anonymous' | 'indexed' | 'named';
-        commentStyle?: 'block' | 'smart';
     });
     /**
      * Pretty-prints a BinarySelectQuery (e.g., UNION, INTERSECT, EXCEPT).
@@ -111,10 +109,6 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
      * This structure supports both oneliner and multiline formatting modes.
      */
     private createCommentBlocks;
-    /**
-     * Creates smart comment blocks by merging consecutive block comments into multi-line format
-     */
-    private createSmartCommentBlocks;
     /**
      * Determines if a comment should be merged with consecutive comments
      */
@@ -123,12 +117,6 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
      * Creates a multi-line block comment structure from consecutive comments
      * Returns a CommentBlock containing multiple comment lines for proper LinePrinter integration
      */
-    private createMultiLineCommentBlock;
-    /**
-     * Creates a multi-line comment block specifically for headerComments
-     * headerComments come as pre-split lines, so we handle them differently
-     */
-    private createHeaderMultiLineCommentBlock;
     /**
      * Creates a single CommentBlock with the standard structure:
      * Comment -> CommentNewline -> Space
@@ -143,12 +131,6 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
      * and converting others to block format for safety
      */
     private formatComment;
-    /**
-     * Formats comments using smart style rules:
-     * - Only multi-line block comment merging is supported
-     * - Single-line comments remain as block comments (no dash conversion)
-     */
-    private formatCommentSmart;
     /**
      * Inserts comment blocks into a token and handles spacing logic.
      * Adds separator spaces for clause-level containers and manages duplicate space removal.
@@ -180,6 +162,17 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
      * Prevents SQL injection by removing dangerous comment sequences.
      */
     private formatBlockComment;
+    private shouldMergeHeaderComments;
+    private createHeaderMultiLineCommentBlock;
+    /**
+     * Formats text as a single-line comment while sanitizing unsafe sequences.
+     */
+    private formatLineComment;
+    /**
+     * Sanitizes content intended for a single-line comment.
+     */
+    private sanitizeLineCommentContent;
+    private escapeCommentDelimiters;
     private visitValueList;
     private visitColumnReference;
     private visitFunctionCall;

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

@@ -139,10 +139,9 @@ export class SqlPrintTokenParser {
         return this._selfHandlingComponentTypes;
     }
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g;
         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);
@@ -156,7 +155,6 @@ 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));
@@ -247,9 +245,7 @@ export class SqlPrintTokenParser {
             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) {
+            if (this.shouldMergeHeaderComments(arg.headerComments)) {
                 const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
                 token.innerTokens.push(mergedHeaderComment);
             }
@@ -438,14 +434,9 @@ export class SqlPrintTokenParser {
         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, ' '));
+            for (let i = commentBlocks.length - 1; i >= 0; i--) {
+                token.innerTokens.unshift(commentBlocks[i]);
             }
-            // Insert before the existing content
-            token.innerTokens.unshift(...beforeTokens);
         }
         // Handle 'after' comments - add inline after the main content
         const afterComments = component.getPositionedComments('after');
@@ -453,7 +444,7 @@ export class SqlPrintTokenParser {
             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(SqlPrintTokenParser.SPACE_TOKEN);
                 token.innerTokens.push(commentBlock);
             }
         }
@@ -482,16 +473,8 @@ export class SqlPrintTokenParser {
         if (!(comments === null || comments === void 0 ? void 0 : comments.length)) {
             return;
         }
-        // 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);
-        }
+        const commentBlocks = this.createCommentBlocks(comments);
+        this.insertCommentBlocksWithSpacing(token, commentBlocks);
     }
     /**
      * Creates inline comment sequence for multiple comments without newlines
@@ -502,7 +485,7 @@ export class SqlPrintTokenParser {
             const comment = comments[i];
             if (comment.trim()) {
                 // Add comment token directly
-                const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatBlockComment(comment));
+                const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatComment(comment));
                 commentTokens.push(commentToken);
                 // Add space between comments (except after last comment)
                 if (i < comments.length - 1) {
@@ -519,10 +502,7 @@ export class SqlPrintTokenParser {
      * 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
+        // Create individual comment blocks for each comment entry
         const commentBlocks = [];
         for (const comment of comments) {
             // Accept comments that have content after trim OR are separator lines OR are empty (for structure preservation)
@@ -534,46 +514,6 @@ export class SqlPrintTokenParser {
         }
         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
      */
@@ -584,8 +524,14 @@ export class SqlPrintTokenParser {
             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;
+        if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+            const inner = trimmed.slice(2, -2).trim();
+            if (!inner) {
+                return false;
+            }
+            if (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
@@ -595,98 +541,6 @@ export class SqlPrintTokenParser {
      * 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
@@ -714,42 +568,28 @@ export class SqlPrintTokenParser {
      */
     formatComment(comment) {
         const trimmed = comment.trim();
-        // Smart style processing
-        if (this.commentStyle === 'smart') {
-            return this.formatCommentSmart(trimmed);
+        if (!trimmed) {
+            return '/* */';
+        }
+        const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
+        if (isSeparatorLine) {
+            return this.formatBlockComment(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 (trimmed.startsWith('--')) {
+            return this.formatLineComment(trimmed.slice(2));
         }
-        // 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.
      */
     insertCommentBlocksWithSpacing(token, commentBlocks) {
-        // For SelectItem, append comments at the end with proper spacing
+        // For SelectItem, append comment blocks after ensuring spacing
         if (token.containerType === SqlPrintTokenContainerType.SelectItem) {
-            // 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) {
@@ -769,7 +609,6 @@ export class SqlPrintTokenParser {
         }
         // 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) {
@@ -872,27 +711,94 @@ export class SqlPrintTokenParser {
      * Prevents SQL injection by removing dangerous comment sequences.
      */
     formatBlockComment(comment) {
-        // Sanitize dangerous comment sequences to prevent SQL injection
-        let sanitizedComment = comment
-            .replace(/\*\//g, '*') // Remove comment close sequences
-            .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} */`;
+        const hasDelimiters = comment.startsWith('/*') && comment.endsWith('*/');
+        const rawContent = hasDelimiters ? comment.slice(2, -2) : comment;
+        const escapedContent = this.escapeCommentDelimiters(rawContent);
+        const normalized = escapedContent.replace(/\r?\n/g, '\n');
+        const lines = normalized
+            .split('\n')
+            .map(line => line.replace(/\s+/g, ' ').trim())
+            .filter(line => line.length > 0);
+        if (lines.length === 0) {
+            return '/* */';
+        }
+        const isSeparatorLine = lines.length === 1 && /^[-=_+*#]+$/.test(lines[0]);
+        if (!hasDelimiters) {
+            // Flatten free-form comments to a single block to avoid leaking multi-line structures.
+            if (isSeparatorLine) {
+                return `/* ${lines[0]} */`;
+            }
+            const flattened = lines.join(' ');
+            return `/* ${flattened} */`;
+        }
+        if (isSeparatorLine || lines.length === 1) {
+            return `/* ${lines[0]} */`;
+        }
+        const body = lines.map(line => `  ${line}`).join('\n');
+        return `/*\n${body}\n*/`;
+    }
+    shouldMergeHeaderComments(comments) {
+        if (comments.length <= 1) {
+            return false;
+        }
+        return comments.some(comment => {
+            const trimmed = comment.trim();
+            return /^[-=_+*#]{3,}$/.test(trimmed) || trimmed.startsWith('- ') || trimmed.startsWith('* ');
+        });
+    }
+    createHeaderMultiLineCommentBlock(headerComments) {
+        const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
+        if (headerComments.length === 0) {
+            const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, '/* */');
+            commentBlock.innerTokens.push(commentToken);
         }
-        // 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) {
-            return '';
+        else {
+            const openToken = new SqlPrintToken(SqlPrintTokenType.comment, '/*');
+            commentBlock.innerTokens.push(openToken);
+            commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            for (const line of headerComments) {
+                const sanitized = this.escapeCommentDelimiters(line);
+                const lineToken = new SqlPrintToken(SqlPrintTokenType.comment, `  ${sanitized}`);
+                commentBlock.innerTokens.push(lineToken);
+                commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            }
+            const closeToken = new SqlPrintToken(SqlPrintTokenType.comment, '*/');
+            commentBlock.innerTokens.push(closeToken);
         }
-        return `/* ${sanitizedComment} */`;
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+        return commentBlock;
+    }
+    /**
+     * Formats text as a single-line comment while sanitizing unsafe sequences.
+     */
+    formatLineComment(content) {
+        // Normalize content to a single line and remove dangerous sequences
+        const sanitized = this.sanitizeLineCommentContent(content);
+        if (!sanitized) {
+            return '--';
+        }
+        return `-- ${sanitized}`;
+    }
+    /**
+     * Sanitizes content intended for a single-line comment.
+     */
+    sanitizeLineCommentContent(content) {
+        // Replace comment delimiters to avoid nested comment injection
+        let sanitized = this.escapeCommentDelimiters(content)
+            .replace(/\r?\n/g, ' ')
+            .replace(/\u2028|\u2029/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (sanitized.startsWith('--')) {
+            sanitized = sanitized.slice(2).trimStart();
+        }
+        return sanitized;
+    }
+    escapeCommentDelimiters(content) {
+        return content
+            .replace(/\/\*/g, '\\/\\*')
+            .replace(/\*\//g, '*\\/');
     }
     visitValueList(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
@@ -1355,19 +1261,16 @@ export class SqlPrintTokenParser {
         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
+        // Add positioned comments in recorded order
         const beforeComments = arg.getPositionedComments('before');
+        const afterComments = arg.getPositionedComments('after');
+        const isParenExpression = arg.value.constructor.name === 'ParenExpression';
         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);
@@ -1803,9 +1706,7 @@ export class SqlPrintTokenParser {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.SimpleSelectQuery);
         // Handle positioned comments for SimpleSelectQuery (unified spec)
         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) {
+            if (this.shouldMergeHeaderComments(arg.headerComments)) {
                 const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
                 token.innerTokens.push(mergedHeaderComment);
             }
@@ -1891,11 +1792,18 @@ export class SqlPrintTokenParser {
         const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'values', SqlPrintTokenContainerType.ValuesQuery);
         // Add headerComments before VALUES keyword
         if (arg.headerComments && arg.headerComments.length > 0) {
-            const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
-            for (const commentBlock of headerCommentBlocks) {
-                token.innerTokens.push(commentBlock);
+            if (this.shouldMergeHeaderComments(arg.headerComments)) {
+                const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
+                token.innerTokens.push(mergedHeaderComment);
                 token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             }
+            else {
+                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
+                for (const commentBlock of headerCommentBlocks) {
+                    token.innerTokens.push(commentBlock);
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                }
+            }
         }
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         const values = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.Values);