rawsql-ts 0.11.41-beta → 0.11.43-beta

package/dist/esm/src/transformers/SqlPrinter.js

@@ -26,9 +26,13 @@ export class SqlPrinter {
      * @param options Optional style settings for pretty printing
      */
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
         /** Track whether we are currently inside a WITH clause for full-oneline formatting */
         this.insideWithClause = false;
+        /** Pending line comment that needs a forced newline before next token */
+        this.pendingLineCommentBreak = null;
+        /** Accumulates lines when reconstructing multi-line block comments inside CommentBlocks */
+        this.smartCommentBlockBuilder = null;
         // Resolve logical options to their control character representations before applying defaults.
         const resolvedIndentChar = resolveIndentCharOption(options === null || options === void 0 ? void 0 : options.indentChar);
         const resolvedNewline = resolveNewlineOption(options === null || options === void 0 ? void 0 : options.newline);
@@ -41,9 +45,9 @@ export class SqlPrinter {
         this.cteCommaBreak = (_c = options === null || options === void 0 ? void 0 : options.cteCommaBreak) !== null && _c !== void 0 ? _c : this.commaBreak;
         this.valuesCommaBreak = (_d = options === null || options === void 0 ? void 0 : options.valuesCommaBreak) !== null && _d !== void 0 ? _d : this.commaBreak;
         this.andBreak = (_e = options === null || options === void 0 ? void 0 : options.andBreak) !== null && _e !== void 0 ? _e : 'none';
-        this.keywordCase = (_f = options === null || options === void 0 ? void 0 : options.keywordCase) !== null && _f !== void 0 ? _f : 'none';
-        this.exportComment = (_g = options === null || options === void 0 ? void 0 : options.exportComment) !== null && _g !== void 0 ? _g : false;
-        this.strictCommentPlacement = (_h = options === null || options === void 0 ? void 0 : options.strictCommentPlacement) !== null && _h !== void 0 ? _h : false;
+        this.orBreak = (_f = options === null || options === void 0 ? void 0 : options.orBreak) !== null && _f !== void 0 ? _f : 'none';
+        this.keywordCase = (_g = options === null || options === void 0 ? void 0 : options.keywordCase) !== null && _g !== void 0 ? _g : 'none';
+        this.exportComment = (_h = options === null || options === void 0 ? void 0 : options.exportComment) !== null && _h !== void 0 ? _h : false;
         this.withClauseStyle = (_j = options === null || options === void 0 ? void 0 : options.withClauseStyle) !== null && _j !== void 0 ? _j : 'standard';
         this.commentStyle = (_k = options === null || options === void 0 ? void 0 : options.commentStyle) !== null && _k !== void 0 ? _k : 'block';
         this.parenthesesOneLine = (_l = options === null || options === void 0 ? void 0 : options.parenthesesOneLine) !== null && _l !== void 0 ? _l : false;
@@ -52,9 +56,10 @@ export class SqlPrinter {
         this.joinOneLine = (_p = options === null || options === void 0 ? void 0 : options.joinOneLine) !== null && _p !== void 0 ? _p : false;
         this.caseOneLine = (_q = options === null || options === void 0 ? void 0 : options.caseOneLine) !== null && _q !== void 0 ? _q : false;
         this.subqueryOneLine = (_r = options === null || options === void 0 ? void 0 : options.subqueryOneLine) !== null && _r !== void 0 ? _r : false;
+        this.indentNestedParentheses = (_s = options === null || options === void 0 ? void 0 : options.indentNestedParentheses) !== null && _s !== void 0 ? _s : false;
         this.linePrinter = new LinePrinter(this.indentChar, this.indentSize, this.newline, this.commaBreak);
         // Initialize
-        this.indentIncrementContainers = new Set((_s = options === null || options === void 0 ? void 0 : options.indentIncrementContainerTypes) !== null && _s !== void 0 ? _s : [
+        this.indentIncrementContainers = new Set((_t = options === null || options === void 0 ? void 0 : options.indentIncrementContainerTypes) !== null && _t !== void 0 ? _t : [
             SqlPrintTokenContainerType.SelectClause,
             SqlPrintTokenContainerType.FromClause,
             SqlPrintTokenContainerType.WhereClause,
@@ -95,13 +100,15 @@ export class SqlPrinter {
         // initialize
         this.linePrinter = new LinePrinter(this.indentChar, this.indentSize, this.newline, this.commaBreak);
         this.insideWithClause = false; // Reset WITH clause context
+        this.pendingLineCommentBreak = null;
+        this.smartCommentBlockBuilder = null;
         if (this.linePrinter.lines.length > 0 && level !== this.linePrinter.lines[0].level) {
             this.linePrinter.lines[0].level = level;
         }
-        this.appendToken(token, level, undefined, 0);
+        this.appendToken(token, level, undefined, 0, false);
         return this.linePrinter.print();
     }
-    appendToken(token, level, parentContainerType, caseContextDepth = 0) {
+    appendToken(token, level, parentContainerType, caseContextDepth = 0, indentParentActive = false) {
         // Track WITH clause context for full-oneline formatting
         const wasInsideWithClause = this.insideWithClause;
         if (token.containerType === SqlPrintTokenContainerType.WithClause && this.withClauseStyle === 'full-oneline') {
@@ -110,9 +117,27 @@ export class SqlPrinter {
         if (this.shouldSkipToken(token)) {
             return;
         }
+        if (this.smartCommentBlockBuilder && token.containerType !== SqlPrintTokenContainerType.CommentBlock && token.type !== SqlPrintTokenType.commentNewline) {
+            this.flushSmartCommentBlockBuilder();
+        }
+        if (this.pendingLineCommentBreak !== null) {
+            if (!this.isOnelineMode()) {
+                this.linePrinter.appendNewline(this.pendingLineCommentBreak);
+            }
+            const shouldSkipToken = token.type === SqlPrintTokenType.commentNewline;
+            this.pendingLineCommentBreak = null;
+            if (shouldSkipToken) {
+                return;
+            }
+        }
+        if (token.containerType === SqlPrintTokenContainerType.CommentBlock) {
+            this.handleCommentBlockContainer(token, level);
+            return;
+        }
         const current = this.linePrinter.getCurrentLine();
         const isCaseContext = this.isCaseContext(token.containerType);
         const nextCaseContextDepth = isCaseContext ? caseContextDepth + 1 : caseContextDepth;
+        const shouldIndentNested = this.shouldIndentNestedParentheses(token);
         // Handle different token types
         if (token.type === SqlPrintTokenType.keyword) {
             this.handleKeywordToken(token, level, parentContainerType, caseContextDepth);
@@ -120,18 +145,21 @@ export class SqlPrinter {
         else if (token.type === SqlPrintTokenType.comma) {
             this.handleCommaToken(token, level, parentContainerType);
         }
+        else if (token.type === SqlPrintTokenType.parenthesis) {
+            this.handleParenthesisToken(token, level, indentParentActive);
+        }
         else if (token.type === SqlPrintTokenType.operator && token.text.toLowerCase() === 'and') {
             this.handleAndOperatorToken(token, level, parentContainerType, caseContextDepth);
         }
+        else if (token.type === SqlPrintTokenType.operator && token.text.toLowerCase() === 'or') {
+            this.handleOrOperatorToken(token, level, parentContainerType, caseContextDepth);
+        }
         else if (token.containerType === "JoinClause") {
             this.handleJoinClauseToken(token, level);
         }
         else if (token.type === SqlPrintTokenType.comment) {
-            // Handle comments as regular tokens - let the standard processing handle everything
             if (this.exportComment) {
-                // Note: Smart comment processing is handled at SqlPrintTokenParser level
-                // via positioned comments system, so we don't need additional processing here
-                this.linePrinter.appendText(token.text);
+                this.printCommentToken(token.text, level, parentContainerType);
             }
         }
         else if (token.type === SqlPrintTokenType.space) {
@@ -144,7 +172,7 @@ export class SqlPrinter {
             this.handleCteOnelineToken(token, level);
             return; // Return early to avoid processing innerTokens
         }
-        else if ((token.containerType === SqlPrintTokenContainerType.ParenExpression && this.parenthesesOneLine) ||
+        else if ((token.containerType === SqlPrintTokenContainerType.ParenExpression && this.parenthesesOneLine && !shouldIndentNested) ||
             (token.containerType === SqlPrintTokenContainerType.BetweenExpression && this.betweenOneLine) ||
             (token.containerType === SqlPrintTokenContainerType.Values && this.valuesOneLine) ||
             (token.containerType === SqlPrintTokenContainerType.JoinOnClause && this.joinOneLine) ||
@@ -160,21 +188,34 @@ export class SqlPrinter {
         if (token.keywordTokens && token.keywordTokens.length > 0) {
             for (let i = 0; i < token.keywordTokens.length; i++) {
                 const keywordToken = token.keywordTokens[i];
-                this.appendToken(keywordToken, level, token.containerType, nextCaseContextDepth);
+                this.appendToken(keywordToken, level, token.containerType, nextCaseContextDepth, indentParentActive);
             }
         }
         let innerLevel = level;
-        // indent level up
-        if (!this.isOnelineMode() && current.text !== '' && this.indentIncrementContainers.has(token.containerType)) {
-            // Skip newline for any container when inside WITH clause with full-oneline style
-            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
-                innerLevel++;
+        let increasedIndent = false;
+        const shouldIncreaseIndent = this.indentIncrementContainers.has(token.containerType) || shouldIndentNested;
+        const delayIndentNewline = shouldIndentNested && token.containerType === SqlPrintTokenContainerType.ParenExpression;
+        if (!this.isOnelineMode() && shouldIncreaseIndent) {
+            if (this.insideWithClause && this.withClauseStyle === 'full-oneline') {
+                // Keep everything on one line for full-oneline WITH clauses.
+            }
+            else if (delayIndentNewline) {
+                innerLevel = level + 1;
+                increasedIndent = true;
+            }
+            else if (current.text !== '') {
+                innerLevel = level + 1;
+                increasedIndent = true;
                 this.linePrinter.appendNewline(innerLevel);
             }
         }
         for (let i = 0; i < token.innerTokens.length; i++) {
             const child = token.innerTokens[i];
-            this.appendToken(child, innerLevel, token.containerType, nextCaseContextDepth);
+            const childIndentParentActive = token.containerType === SqlPrintTokenContainerType.ParenExpression ? shouldIndentNested : indentParentActive;
+            this.appendToken(child, innerLevel, token.containerType, nextCaseContextDepth, childIndentParentActive);
+        }
+        if (this.smartCommentBlockBuilder && this.smartCommentBlockBuilder.mode === 'line') {
+            this.flushSmartCommentBlockBuilder();
         }
         // Exit WITH clause context when we finish processing WithClause container
         if (token.containerType === SqlPrintTokenContainerType.WithClause && this.withClauseStyle === 'full-oneline') {
@@ -184,11 +225,8 @@ export class SqlPrinter {
             return; // Return early to avoid additional newline below
         }
         // indent level down
-        if (innerLevel !== level) {
-            // Skip newline for any container when inside WITH clause with full-oneline style
-            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
-                this.linePrinter.appendNewline(level);
-            }
+        if (increasedIndent && shouldIncreaseIndent && !(this.insideWithClause && this.withClauseStyle === 'full-oneline') && !delayIndentNewline) {
+            this.linePrinter.appendNewline(level);
         }
     }
     isCaseContext(containerType) {
@@ -231,6 +269,10 @@ export class SqlPrinter {
             this.handleAndOperatorToken(token, level, parentContainerType, caseContextDepth);
             return;
         }
+        else if (lower === 'or' && this.orBreak !== 'none') {
+            this.handleOrOperatorToken(token, level, parentContainerType, caseContextDepth);
+            return;
+        }
         const text = this.applyKeywordCase(token.text);
         if (caseContextDepth > 0) {
             this.linePrinter.appendText(text);
@@ -276,6 +318,9 @@ export class SqlPrinter {
             if (previousCommaBreak !== 'after') {
                 this.linePrinter.commaBreak = 'after';
             }
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(level);
+            }
             this.linePrinter.appendText(text);
             if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
                 this.linePrinter.appendNewline(level);
@@ -322,6 +367,79 @@ export class SqlPrinter {
             this.linePrinter.appendText(text);
         }
     }
+    handleParenthesisToken(token, level, indentParentActive) {
+        if (token.text === '(') {
+            this.linePrinter.appendText(token.text);
+            if (indentParentActive && !this.isOnelineMode()) {
+                if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                    this.linePrinter.appendNewline(level);
+                }
+            }
+            return;
+        }
+        if (token.text === ')' && indentParentActive && !this.isOnelineMode()) {
+            // Align closing parenthesis with the outer indentation level when nested groups expand.
+            const closingLevel = Math.max(level - 1, 0);
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(closingLevel);
+            }
+        }
+        this.linePrinter.appendText(token.text);
+    }
+    handleOrOperatorToken(token, level, parentContainerType, caseContextDepth = 0) {
+        const text = this.applyKeywordCase(token.text);
+        // Leave OR untouched inside CASE branches to preserve inline evaluation order.
+        if (caseContextDepth > 0) {
+            this.linePrinter.appendText(text);
+            return;
+        }
+        if (this.orBreak === 'before') {
+            // Insert a newline before OR unless WITH full-oneline mode suppresses breaks.
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(level);
+            }
+            this.linePrinter.appendText(text);
+        }
+        else if (this.orBreak === 'after') {
+            this.linePrinter.appendText(text);
+            // Break after OR when multi-line formatting is active.
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(level);
+            }
+        }
+        else {
+            this.linePrinter.appendText(text);
+        }
+    }
+    /**
+     * Decide whether a parentheses group should increase indentation when inside nested structures.
+     * We only expand groups that contain further parentheses so simple comparisons stay compact.
+     */
+    shouldIndentNestedParentheses(token) {
+        if (!this.indentNestedParentheses) {
+            return false;
+        }
+        if (token.containerType !== SqlPrintTokenContainerType.ParenExpression) {
+            return false;
+        }
+        // Look for nested parentheses containers. If present, indent to highlight grouping.
+        return token.innerTokens.some((child) => this.containsParenExpression(child));
+    }
+    /**
+     * Recursively inspect descendants to find additional parentheses groups.
+     * Helps detect complex boolean groups like ((A) OR (B) OR (C)).
+     */
+    containsParenExpression(token) {
+        if (token.containerType === SqlPrintTokenContainerType.ParenExpression) {
+            return true;
+        }
+        for (const child of token.innerTokens) {
+            if (this.containsParenExpression(child)) {
+                return true;
+            }
+        }
+        return false;
+    }
     handleJoinClauseToken(token, level) {
         const text = this.applyKeywordCase(token.text);
         // before join clause, add newline (skip when inside WITH clause with full-oneline style)
@@ -335,6 +453,9 @@ export class SqlPrinter {
      * Skips spaces in CommentBlocks when in specific CTE modes to prevent duplication.
      */
     handleSpaceToken(token, parentContainerType) {
+        if (this.smartCommentBlockBuilder && this.smartCommentBlockBuilder.mode === 'line') {
+            this.flushSmartCommentBlockBuilder();
+        }
         if (this.shouldSkipCommentBlockSpace(parentContainerType)) {
             const currentLine = this.linePrinter.getCurrentLine();
             if (currentLine.text !== '' && !currentLine.text.endsWith(' ')) {
@@ -353,6 +474,337 @@ export class SqlPrinter {
             this.insideWithClause &&
             this.withClauseStyle === 'full-oneline';
     }
+    printCommentToken(text, level, parentContainerType) {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (this.commentStyle === 'smart' && parentContainerType === SqlPrintTokenContainerType.CommentBlock) {
+            if (this.handleSmartCommentBlockToken(text, trimmed, level)) {
+                return;
+            }
+        }
+        if (this.commentStyle === 'smart') {
+            const normalized = this.normalizeCommentForSmart(trimmed);
+            if (normalized.lines.length > 1 || normalized.forceBlock) {
+                const blockText = this.buildBlockComment(normalized.lines, level);
+                this.linePrinter.appendText(blockText);
+            }
+            else {
+                const content = normalized.lines[0];
+                const lineText = content ? `-- ${content}` : '--';
+                if (parentContainerType === SqlPrintTokenContainerType.CommentBlock) {
+                    this.linePrinter.appendText(lineText);
+                    this.pendingLineCommentBreak = level;
+                }
+                else {
+                    this.linePrinter.appendText(lineText);
+                    this.linePrinter.appendNewline(level);
+                }
+            }
+        }
+        else {
+            if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+                if (/\r?\n/.test(trimmed)) {
+                    // Keep multi-line block comments intact by normalizing line endings once.
+                    const newlineReplacement = this.isOnelineMode() ? ' ' : (typeof this.newline === 'string' ? this.newline : '\n');
+                    const normalized = trimmed.replace(/\r?\n/g, newlineReplacement);
+                    this.linePrinter.appendText(normalized);
+                }
+                else {
+                    this.linePrinter.appendText(trimmed);
+                }
+            }
+            else {
+                this.linePrinter.appendText(trimmed);
+            }
+            if (trimmed.startsWith('--')) {
+                if (parentContainerType === SqlPrintTokenContainerType.CommentBlock) {
+                    this.pendingLineCommentBreak = level;
+                }
+                else {
+                    this.linePrinter.appendNewline(level);
+                }
+            }
+        }
+    }
+    handleSmartCommentBlockToken(raw, trimmed, level) {
+        if (!this.smartCommentBlockBuilder) {
+            if (trimmed === '/*') {
+                // Begin assembling a multi-line block comment that is emitted as split tokens
+                this.smartCommentBlockBuilder = { lines: [], level, mode: 'block' };
+                return true;
+            }
+            const lineContent = this.extractLineCommentContent(trimmed);
+            if (lineContent !== null) {
+                this.smartCommentBlockBuilder = {
+                    lines: [lineContent],
+                    level,
+                    mode: 'line',
+                };
+                return true;
+            }
+            return false;
+        }
+        if (this.smartCommentBlockBuilder.mode === 'block') {
+            if (trimmed === '*/') {
+                const { lines, level: blockLevel } = this.smartCommentBlockBuilder;
+                const blockText = this.buildBlockComment(lines, blockLevel);
+                this.linePrinter.appendText(blockText);
+                this.pendingLineCommentBreak = blockLevel;
+                this.smartCommentBlockBuilder = null;
+                return true;
+            }
+            this.smartCommentBlockBuilder.lines.push(this.normalizeSmartBlockLine(raw));
+            return true;
+        }
+        const content = this.extractLineCommentContent(trimmed);
+        if (content !== null) {
+            this.smartCommentBlockBuilder.lines.push(content);
+            return true;
+        }
+        this.flushSmartCommentBlockBuilder();
+        return false;
+    }
+    handleCommentBlockContainer(token, level) {
+        var _a;
+        if (!this.exportComment) {
+            return;
+        }
+        if (this.commentStyle !== 'smart') {
+            const rawLines = this.extractRawCommentBlockLines(token);
+            if (rawLines.length > 0) {
+                const normalizedBlocks = rawLines.map(line => `/* ${line} */`).join(' ');
+                const hasTrailingSpace = (_a = token.innerTokens) === null || _a === void 0 ? void 0 : _a.some(child => child.type === SqlPrintTokenType.space && child.text.includes(' '));
+                this.linePrinter.appendText(hasTrailingSpace ? `${normalizedBlocks} ` : normalizedBlocks);
+                return;
+            }
+            for (const child of token.innerTokens) {
+                this.appendToken(child, level, token.containerType, 0, false);
+            }
+            return;
+        }
+        const lines = this.collectCommentBlockLines(token);
+        if (lines.length === 0 && !this.smartCommentBlockBuilder) {
+            // No meaningful content; treat as empty line comment to preserve spacing
+            this.smartCommentBlockBuilder = {
+                lines: [''],
+                level,
+                mode: 'line',
+            };
+            return;
+        }
+        if (!this.smartCommentBlockBuilder || this.smartCommentBlockBuilder.mode !== 'line') {
+            this.smartCommentBlockBuilder = {
+                lines: [...lines],
+                level,
+                mode: 'line',
+            };
+        }
+        else {
+            this.smartCommentBlockBuilder.lines.push(...lines);
+        }
+    }
+    normalizeSmartBlockLine(raw) {
+        // Remove trailing whitespace that only carries formatting artifacts
+        let line = raw.replace(/\s+$/g, '');
+        if (!line) {
+            return '';
+        }
+        if (line.startsWith('  ')) {
+            line = line.slice(2);
+        }
+        if (line.startsWith('* ')) {
+            return line.slice(2);
+        }
+        if (line === '*') {
+            return '';
+        }
+        if (line.startsWith('*')) {
+            return line.slice(1);
+        }
+        return line;
+    }
+    extractLineCommentContent(trimmed) {
+        if (trimmed.startsWith('--')) {
+            return trimmed.slice(2).trimStart();
+        }
+        if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+            const inner = trimmed.slice(2, -2).trim();
+            return inner;
+        }
+        return null;
+    }
+    flushSmartCommentBlockBuilder() {
+        var _a;
+        if (!this.smartCommentBlockBuilder) {
+            return;
+        }
+        const { lines, level, mode } = this.smartCommentBlockBuilder;
+        if (mode === 'line') {
+            if (lines.length > 1) {
+                const blockText = this.buildBlockComment(lines, level);
+                this.linePrinter.appendText(blockText);
+            }
+            else {
+                const content = (_a = lines[0]) !== null && _a !== void 0 ? _a : '';
+                const lineText = content ? `-- ${content}` : '--';
+                this.linePrinter.appendText(lineText);
+            }
+            if (!this.isOnelineMode()) {
+                this.linePrinter.appendNewline(level);
+            }
+            this.pendingLineCommentBreak = null;
+        }
+        this.smartCommentBlockBuilder = null;
+    }
+    collectCommentBlockLines(token) {
+        var _a;
+        const lines = [];
+        let collectingBlock = false;
+        for (const child of (_a = token.innerTokens) !== null && _a !== void 0 ? _a : []) {
+            if (child.type === SqlPrintTokenType.comment) {
+                const trimmed = child.text.trim();
+                if (trimmed === '/*') {
+                    collectingBlock = true;
+                    continue;
+                }
+                if (trimmed === '*/') {
+                    collectingBlock = false;
+                    continue;
+                }
+                if (collectingBlock) {
+                    lines.push(this.normalizeSmartBlockLine(child.text));
+                    continue;
+                }
+                const content = this.extractLineCommentContent(trimmed);
+                if (content !== null) {
+                    lines.push(content);
+                }
+            }
+        }
+        return lines;
+    }
+    extractRawCommentBlockLines(token) {
+        var _a;
+        const lines = [];
+        let collectingBlock = false;
+        for (const child of (_a = token.innerTokens) !== null && _a !== void 0 ? _a : []) {
+            if (child.type === SqlPrintTokenType.comment) {
+                const text = child.text;
+                const trimmed = text.trim();
+                if (trimmed === '/*') {
+                    collectingBlock = true;
+                    continue;
+                }
+                if (trimmed === '*/') {
+                    collectingBlock = false;
+                    continue;
+                }
+                if (collectingBlock) {
+                    if (trimmed.length > 0) {
+                        lines.push(trimmed);
+                    }
+                    continue;
+                }
+            }
+        }
+        return lines;
+    }
+    normalizeCommentForSmart(text) {
+        const trimmed = text.trim();
+        let source = trimmed;
+        let forceBlock = false;
+        if (trimmed.startsWith('--')) {
+            source = trimmed.slice(2);
+        }
+        else if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+            const inner = trimmed.slice(2, -2);
+            const normalizedInner = inner.replace(/\r?\n/g, '\n');
+            if (normalizedInner.includes('\n')) {
+                forceBlock = true;
+                source = inner;
+            }
+            else {
+                source = inner;
+                if (!source.trim()) {
+                    source = trimmed;
+                }
+            }
+        }
+        const escaped = this.escapeCommentDelimiters(source);
+        const normalized = escaped.replace(/\r?\n/g, '\n');
+        const rawSegments = normalized.split('\n');
+        const processedLines = [];
+        const processedRaw = [];
+        for (const segment of rawSegments) {
+            const rawTrimmed = segment.trim();
+            const sanitized = this.sanitizeCommentLine(segment);
+            if (sanitized.length > 0) {
+                processedLines.push(sanitized);
+                processedRaw.push(rawTrimmed);
+            }
+        }
+        let lines = processedLines;
+        if (lines.length === 0) {
+            lines = [''];
+        }
+        if (!forceBlock && lines.length === 1 && !lines[0] && trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+            const escapedFull = this.escapeCommentDelimiters(trimmed);
+            lines = [this.sanitizeCommentLine(escapedFull)];
+        }
+        if (!forceBlock && lines.length > 1) {
+            forceBlock = true;
+        }
+        lines = lines.map((line, index) => {
+            var _a;
+            if (/^[-=_+*#]+$/.test(line)) {
+                const rawLine = (_a = processedRaw[index]) !== null && _a !== void 0 ? _a : line;
+                const normalizedRaw = rawLine.replace(/\s+/g, '');
+                if (normalizedRaw.length >= line.length) {
+                    return normalizedRaw;
+                }
+            }
+            return line;
+        });
+        return { lines, forceBlock };
+    }
+    buildBlockComment(lines, level) {
+        var _a, _b, _c;
+        if (lines.length <= 1) {
+            const content = (_a = lines[0]) !== null && _a !== void 0 ? _a : '';
+            return content ? `/* ${content} */` : '/* */';
+        }
+        const newline = this.newline === ' ' ? '\n' : this.newline;
+        const currentLevel = (_c = (_b = this.linePrinter.getCurrentLine()) === null || _b === void 0 ? void 0 : _b.level) !== null && _c !== void 0 ? _c : level;
+        const baseIndent = this.getIndentString(currentLevel);
+        const unitIndent = '  ';
+        const innerIndent = baseIndent + unitIndent;
+        const body = lines.map(line => `${innerIndent}${line}`).join(newline);
+        const closing = `${baseIndent}*/`;
+        return `/*${newline}${body}${newline}${closing}`;
+    }
+    getIndentString(level) {
+        if (level <= 0) {
+            return '';
+        }
+        if (this.indentSize <= 0) {
+            return '  '.repeat(level);
+        }
+        const unit = typeof this.indentChar === 'string' ? this.indentChar : '';
+        return unit.repeat(this.indentSize * level);
+    }
+    sanitizeCommentLine(content) {
+        let sanitized = content;
+        sanitized = sanitized.replace(/\u2028|\u2029/g, ' ');
+        sanitized = sanitized.replace(/\s+/g, ' ').trim();
+        return sanitized;
+    }
+    escapeCommentDelimiters(content) {
+        return content
+            .replace(/\/\*/g, '\\/\\*')
+            .replace(/\*\//g, '*\\/');
+    }
     /**
      * Handles commentNewline tokens with conditional newline behavior.
      * In multiline mode (newline !== ' '), adds a newline after comments.
@@ -360,6 +812,14 @@ export class SqlPrinter {
      * Skips newlines in CTE modes (full-oneline, cte-oneline) to maintain one-line format.
      */
     handleCommentNewlineToken(token, level) {
+        if (this.smartCommentBlockBuilder) {
+            return;
+        }
+        if (this.pendingLineCommentBreak !== null) {
+            this.linePrinter.appendNewline(this.pendingLineCommentBreak);
+            this.pendingLineCommentBreak = null;
+            return;
+        }
         if (this.shouldSkipCommentNewline()) {
             return;
         }
@@ -405,10 +865,11 @@ export class SqlPrinter {
             cteCommaBreak: this.cteCommaBreak,
             valuesCommaBreak: this.valuesCommaBreak,
             andBreak: this.andBreak,
+            orBreak: this.orBreak,
             keywordCase: this.keywordCase,
             exportComment: false,
-            strictCommentPlacement: this.strictCommentPlacement,
             withClauseStyle: 'standard', // Prevent recursive processing
+            indentNestedParentheses: false,
         });
     }
     /**
@@ -434,10 +895,10 @@ export class SqlPrinter {
             commaBreak: 'none', // Disable comma-based line breaks
             cteCommaBreak: this.cteCommaBreak,
             valuesCommaBreak: 'none',
-            andBreak: 'none', // Disable AND/OR-based line breaks
+            andBreak: 'none', // Disable AND-based line breaks
+            orBreak: 'none', // Disable OR-based line breaks
             keywordCase: this.keywordCase,
             exportComment: this.exportComment,
-            strictCommentPlacement: this.strictCommentPlacement,
             withClauseStyle: 'standard',
             parenthesesOneLine: false, // Prevent recursive processing (avoid infinite loops)
             betweenOneLine: false, // Prevent recursive processing (avoid infinite loops)
@@ -445,6 +906,7 @@ export class SqlPrinter {
             joinOneLine: false, // Prevent recursive processing (avoid infinite loops)
             caseOneLine: false, // Prevent recursive processing (avoid infinite loops)
             subqueryOneLine: false, // Prevent recursive processing (avoid infinite loops)
+            indentNestedParentheses: false,
         });
     }
     /**