rawsql-ts 0.12.0 → 0.12.1

package/dist/esm/transformers/SqlPrinter.js

@@ -0,0 +1,1474 @@
+import { SqlPrintTokenType, SqlPrintTokenContainerType } from "../models/SqlPrintToken";
+import { LinePrinter } from "./LinePrinter";
+import { resolveIndentCharOption, resolveNewlineOption } from "./FormatOptionResolver";
+import { OnelineFormattingHelper, } from "./OnelineFormattingHelper";
+const CREATE_TABLE_SINGLE_PAREN_KEYWORDS = new Set(['unique', 'check', 'key', 'index']);
+const CREATE_TABLE_MULTI_PAREN_KEYWORDS = new Set(['primary key', 'foreign key', 'unique key']);
+const CREATE_TABLE_PAREN_KEYWORDS_WITH_IDENTIFIER = new Set(['references']);
+/**
+ * SqlPrinter formats a SqlPrintToken tree into a SQL string with flexible style options.
+ *
+ * This class provides various formatting options including:
+ * - Indentation control (character and size)
+ * - Line break styles for commas and AND operators
+ * - Keyword case transformation
+ * - Comment handling
+ * - WITH clause formatting styles
+ *
+ * @example
+ * const printer = new SqlPrinter({
+ *   indentChar: '  ',
+ *   indentSize: 1,
+ *   keywordCase: 'upper',
+ *   commaBreak: 'after',
+ *   withClauseStyle: 'cte-oneline'
+ * });
+ * const formatted = printer.print(sqlToken);
+ */
+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, _t, _u;
+        /** Track whether we are currently inside a WITH clause for full-oneline formatting */
+        this.insideWithClause = false;
+        /** Tracks nesting depth while formatting MERGE WHEN predicate segments */
+        this.mergeWhenPredicateDepth = 0;
+        /** 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);
+        this.indentChar = resolvedIndentChar !== null && resolvedIndentChar !== void 0 ? resolvedIndentChar : '';
+        this.indentSize = (_a = options === null || options === void 0 ? void 0 : options.indentSize) !== null && _a !== void 0 ? _a : 0;
+        // The default newline character is set to a blank space (' ') to enable one-liner formatting.
+        // This is intentional and differs from the LinePrinter default of '\r\n'.
+        this.newline = resolvedNewline !== null && resolvedNewline !== void 0 ? resolvedNewline : ' ';
+        this.commaBreak = (_b = options === null || options === void 0 ? void 0 : options.commaBreak) !== null && _b !== void 0 ? _b : 'none';
+        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.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.commentExportMode = this.resolveCommentExportMode(options === null || options === void 0 ? void 0 : options.exportComment);
+        this.withClauseStyle = (_h = options === null || options === void 0 ? void 0 : options.withClauseStyle) !== null && _h !== void 0 ? _h : 'standard';
+        this.commentStyle = (_j = options === null || options === void 0 ? void 0 : options.commentStyle) !== null && _j !== void 0 ? _j : 'block';
+        this.parenthesesOneLine = (_k = options === null || options === void 0 ? void 0 : options.parenthesesOneLine) !== null && _k !== void 0 ? _k : false;
+        this.betweenOneLine = (_l = options === null || options === void 0 ? void 0 : options.betweenOneLine) !== null && _l !== void 0 ? _l : false;
+        this.valuesOneLine = (_m = options === null || options === void 0 ? void 0 : options.valuesOneLine) !== null && _m !== void 0 ? _m : false;
+        this.joinOneLine = (_o = options === null || options === void 0 ? void 0 : options.joinOneLine) !== null && _o !== void 0 ? _o : false;
+        this.caseOneLine = (_p = options === null || options === void 0 ? void 0 : options.caseOneLine) !== null && _p !== void 0 ? _p : false;
+        this.subqueryOneLine = (_q = options === null || options === void 0 ? void 0 : options.subqueryOneLine) !== null && _q !== void 0 ? _q : false;
+        this.indentNestedParentheses = (_r = options === null || options === void 0 ? void 0 : options.indentNestedParentheses) !== null && _r !== void 0 ? _r : false;
+        this.insertColumnsOneLine = (_s = options === null || options === void 0 ? void 0 : options.insertColumnsOneLine) !== null && _s !== void 0 ? _s : false;
+        this.whenOneLine = (_t = options === null || options === void 0 ? void 0 : options.whenOneLine) !== null && _t !== void 0 ? _t : false;
+        const onelineOptions = {
+            parenthesesOneLine: this.parenthesesOneLine,
+            betweenOneLine: this.betweenOneLine,
+            valuesOneLine: this.valuesOneLine,
+            joinOneLine: this.joinOneLine,
+            caseOneLine: this.caseOneLine,
+            subqueryOneLine: this.subqueryOneLine,
+            insertColumnsOneLine: this.insertColumnsOneLine,
+            withClauseStyle: this.withClauseStyle,
+        };
+        this.onelineHelper = new OnelineFormattingHelper(onelineOptions);
+        this.linePrinter = new LinePrinter(this.indentChar, this.indentSize, this.newline, this.commaBreak);
+        // Initialize
+        this.indentIncrementContainers = new Set((_u = options === null || options === void 0 ? void 0 : options.indentIncrementContainerTypes) !== null && _u !== void 0 ? _u : [
+            SqlPrintTokenContainerType.SelectClause,
+            SqlPrintTokenContainerType.FromClause,
+            SqlPrintTokenContainerType.WhereClause,
+            SqlPrintTokenContainerType.GroupByClause,
+            SqlPrintTokenContainerType.HavingClause,
+            SqlPrintTokenContainerType.WindowFrameExpression,
+            SqlPrintTokenContainerType.PartitionByClause,
+            SqlPrintTokenContainerType.OrderByClause,
+            SqlPrintTokenContainerType.WindowClause,
+            SqlPrintTokenContainerType.LimitClause,
+            SqlPrintTokenContainerType.OffsetClause,
+            SqlPrintTokenContainerType.SubQuerySource,
+            SqlPrintTokenContainerType.BinarySelectQueryOperator, SqlPrintTokenContainerType.Values,
+            SqlPrintTokenContainerType.WithClause,
+            SqlPrintTokenContainerType.SwitchCaseArgument,
+            SqlPrintTokenContainerType.CaseKeyValuePair,
+            SqlPrintTokenContainerType.CaseThenValue,
+            SqlPrintTokenContainerType.ElseClause,
+            SqlPrintTokenContainerType.CaseElseValue,
+            SqlPrintTokenContainerType.SimpleSelectQuery,
+            SqlPrintTokenContainerType.CreateTableDefinition,
+            SqlPrintTokenContainerType.AlterTableStatement,
+            SqlPrintTokenContainerType.IndexColumnList,
+            SqlPrintTokenContainerType.SetClause
+            // Note: CommentBlock is intentionally excluded from indentIncrementContainers
+            // because it serves as a grouping mechanism without affecting indentation.
+            // CaseExpression, SwitchCaseArgument, CaseKeyValuePair, and ElseClause
+            // are not included by default to maintain backward compatibility with tests.
+            // SqlPrintTokenContainerType.CommonTable is also excluded by default.
+        ]);
+    }
+    /**
+     * Converts a SqlPrintToken tree to a formatted SQL string.
+     * @param token The root SqlPrintToken to format
+     * @param level Initial indentation level (default: 0)
+     * @returns Formatted SQL string
+     * @example
+     * const printer = new SqlPrinter({ indentChar: '  ', keywordCase: 'upper' });
+     * const formatted = printer.print(sqlToken);
+     */
+    print(token, level = 0) {
+        // 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, false, undefined, false);
+        return this.linePrinter.print();
+    }
+    // Resolve legacy boolean values into explicit comment export modes.
+    resolveCommentExportMode(option) {
+        if (option === undefined) {
+            return 'none';
+        }
+        if (option === true) {
+            return 'full';
+        }
+        if (option === false) {
+            return 'none';
+        }
+        return option;
+    }
+    // Determine whether the current mode allows emitting inline comments.
+    rendersInlineComments() {
+        return this.commentExportMode === 'full';
+    }
+    // Decide if a comment block or token should be rendered given its context.
+    shouldRenderComment(token, context) {
+        if (context === null || context === void 0 ? void 0 : context.forceRender) {
+            return this.commentExportMode !== 'none';
+        }
+        switch (this.commentExportMode) {
+            case 'full':
+                return true;
+            case 'none':
+                return false;
+            case 'header-only':
+                return token.isHeaderComment === true;
+            case 'top-header-only':
+                return token.isHeaderComment === true && Boolean(context === null || context === void 0 ? void 0 : context.isTopLevelContainer);
+            default:
+                return false;
+        }
+    }
+    appendToken(token, level, parentContainerType, caseContextDepth = 0, indentParentActive = false, commentContext, previousSiblingWasOpenParen = false) {
+        // Track WITH clause context for full-oneline formatting
+        const wasInsideWithClause = this.insideWithClause;
+        if (token.containerType === SqlPrintTokenContainerType.WithClause && this.withClauseStyle === 'full-oneline') {
+            this.insideWithClause = true;
+        }
+        if (this.shouldSkipToken(token)) {
+            return;
+        }
+        const containerIsTopLevel = parentContainerType === undefined;
+        let leadingCommentCount = 0;
+        // Collect leading comment blocks with context so we can respect the export mode.
+        const leadingCommentContexts = [];
+        if (token.innerTokens && token.innerTokens.length > 0) {
+            while (leadingCommentCount < token.innerTokens.length) {
+                const leadingCandidate = token.innerTokens[leadingCommentCount];
+                if (leadingCandidate.containerType !== SqlPrintTokenContainerType.CommentBlock) {
+                    break;
+                }
+                const context = {
+                    position: 'leading',
+                    isTopLevelContainer: containerIsTopLevel,
+                };
+                const shouldRender = this.shouldRenderComment(leadingCandidate, context);
+                leadingCommentContexts.push({ token: leadingCandidate, context, shouldRender });
+                leadingCommentCount++;
+            }
+        }
+        const hasRenderableLeadingComment = leadingCommentContexts.some(item => item.shouldRender);
+        const leadingCommentIndentLevel = hasRenderableLeadingComment
+            ? this.getLeadingCommentIndentLevel(parentContainerType, level)
+            : null;
+        if (hasRenderableLeadingComment
+            && !this.isOnelineMode()
+            && this.shouldAddNewlineBeforeLeadingComments(parentContainerType)) {
+            const currentLine = this.linePrinter.getCurrentLine();
+            if (currentLine.text.trim().length > 0) {
+                // Align the newline before leading comments with the intended comment indentation.
+                this.linePrinter.appendNewline(leadingCommentIndentLevel !== null && leadingCommentIndentLevel !== void 0 ? leadingCommentIndentLevel : level);
+            }
+        }
+        for (const leading of leadingCommentContexts) {
+            if (!leading.shouldRender) {
+                continue;
+            }
+            // Keep leading comment processing aligned with its computed indentation level.
+            this.appendToken(leading.token, leadingCommentIndentLevel !== null && leadingCommentIndentLevel !== void 0 ? leadingCommentIndentLevel : level, token.containerType, caseContextDepth, indentParentActive, leading.context, false);
+        }
+        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;
+            }
+        }
+        // Fallback context applies when the caller did not provide comment metadata.
+        const effectiveCommentContext = commentContext !== null && commentContext !== void 0 ? commentContext : {
+            position: 'inline',
+            isTopLevelContainer: containerIsTopLevel,
+        };
+        if (token.containerType === SqlPrintTokenContainerType.CommentBlock) {
+            if (!this.shouldRenderComment(token, effectiveCommentContext)) {
+                return;
+            }
+            const commentLevel = this.getCommentBaseIndentLevel(level, parentContainerType);
+            this.handleCommentBlockContainer(token, commentLevel, effectiveCommentContext);
+            return;
+        }
+        const current = this.linePrinter.getCurrentLine();
+        const isCaseContext = this.isCaseContext(token.containerType);
+        const nextCaseContextDepth = isCaseContext ? caseContextDepth + 1 : caseContextDepth;
+        const shouldIndentNested = this.shouldIndentNestedParentheses(token, previousSiblingWasOpenParen);
+        // Handle different token types
+        if (token.type === SqlPrintTokenType.keyword) {
+            this.handleKeywordToken(token, level, parentContainerType, caseContextDepth);
+        }
+        else if (token.type === SqlPrintTokenType.comma) {
+            this.handleCommaToken(token, level, parentContainerType);
+        }
+        else if (token.type === SqlPrintTokenType.parenthesis) {
+            this.handleParenthesisToken(token, level, indentParentActive, parentContainerType);
+        }
+        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 === SqlPrintTokenContainerType.JoinClause) {
+            this.handleJoinClauseToken(token, level);
+        }
+        else if (token.type === SqlPrintTokenType.comment) {
+            if (this.shouldRenderComment(token, effectiveCommentContext)) {
+                const commentLevel = this.getCommentBaseIndentLevel(level, parentContainerType);
+                this.printCommentToken(token.text, commentLevel, parentContainerType);
+            }
+        }
+        else if (token.type === SqlPrintTokenType.space) {
+            this.handleSpaceToken(token, parentContainerType);
+        }
+        else if (token.type === SqlPrintTokenType.commentNewline) {
+            if (this.whenOneLine && parentContainerType === SqlPrintTokenContainerType.MergeWhenClause) {
+                return;
+            }
+            const commentLevel = this.getCommentBaseIndentLevel(level, parentContainerType);
+            this.handleCommentNewlineToken(token, commentLevel);
+        }
+        else if (token.containerType === SqlPrintTokenContainerType.CommonTable && this.withClauseStyle === 'cte-oneline') {
+            this.handleCteOnelineToken(token, level);
+            return; // Return early to avoid processing innerTokens
+        }
+        else if (this.shouldFormatContainerAsOneline(token, shouldIndentNested)) {
+            this.handleOnelineToken(token, level);
+            return; // Return early to avoid processing innerTokens
+        }
+        else if (!this.tryAppendInsertClauseTokenText(token.text, parentContainerType)) {
+            this.linePrinter.appendText(token.text);
+        }
+        // append keyword tokens(not indented)
+        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, indentParentActive, undefined, false);
+            }
+        }
+        let innerLevel = level;
+        let increasedIndent = false;
+        const shouldIncreaseIndent = this.indentIncrementContainers.has(token.containerType) || shouldIndentNested;
+        const delayIndentNewline = shouldIndentNested && token.containerType === SqlPrintTokenContainerType.ParenExpression;
+        const isAlterTableStatement = token.containerType === SqlPrintTokenContainerType.AlterTableStatement;
+        let deferAlterTableIndent = false;
+        const alignExplainChild = this.shouldAlignExplainStatementChild(parentContainerType, token.containerType);
+        if (alignExplainChild) {
+            // Keep EXPLAIN target statements flush left so they render like standalone statements.
+            if (!this.isOnelineMode() && current.text !== '') {
+                this.linePrinter.appendNewline(level);
+            }
+            innerLevel = level;
+            increasedIndent = false;
+        }
+        else 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 !== '') {
+                if (isAlterTableStatement) {
+                    // Delay the first line break so ALTER TABLE keeps the table name on the opening line.
+                    innerLevel = level + 1;
+                    increasedIndent = true;
+                    deferAlterTableIndent = true;
+                }
+                else {
+                    let targetIndentLevel = level + 1;
+                    if (token.containerType === SqlPrintTokenContainerType.SetClause &&
+                        parentContainerType === SqlPrintTokenContainerType.MergeUpdateAction) {
+                        targetIndentLevel = level + 2;
+                    }
+                    if (this.shouldAlignCreateTableSelect(token.containerType, parentContainerType)) {
+                        innerLevel = level;
+                        increasedIndent = false;
+                        this.linePrinter.appendNewline(level);
+                    }
+                    else {
+                        innerLevel = targetIndentLevel;
+                        increasedIndent = true;
+                        this.linePrinter.appendNewline(innerLevel);
+                    }
+                }
+            }
+            else if (token.containerType === SqlPrintTokenContainerType.SetClause) {
+                innerLevel = parentContainerType === SqlPrintTokenContainerType.MergeUpdateAction ? level + 2 : level + 1;
+                increasedIndent = true;
+                current.level = innerLevel;
+            }
+        }
+        const isMergeWhenClause = this.whenOneLine && token.containerType === SqlPrintTokenContainerType.MergeWhenClause;
+        let mergePredicateActive = isMergeWhenClause;
+        let alterTableTableRendered = false;
+        let alterTableIndentInserted = false;
+        for (let i = leadingCommentCount; i < token.innerTokens.length; i++) {
+            const child = token.innerTokens[i];
+            const nextChild = token.innerTokens[i + 1];
+            const previousEntry = this.findPreviousSignificantToken(token.innerTokens, i);
+            const previousChild = previousEntry === null || previousEntry === void 0 ? void 0 : previousEntry.token;
+            const priorEntry = previousEntry ? this.findPreviousSignificantToken(token.innerTokens, previousEntry.index) : undefined;
+            const priorChild = priorEntry === null || priorEntry === void 0 ? void 0 : priorEntry.token;
+            const childIsAction = this.isMergeActionContainer(child);
+            const nextIsAction = this.isMergeActionContainer(nextChild);
+            const inMergePredicate = mergePredicateActive && !childIsAction;
+            if (isAlterTableStatement) {
+                if (child.containerType === SqlPrintTokenContainerType.QualifiedName) {
+                    // Track when the table name has been printed so we can defer indentation until after it.
+                    alterTableTableRendered = true;
+                }
+                else if (deferAlterTableIndent && alterTableTableRendered && !alterTableIndentInserted) {
+                    if (!this.isOnelineMode()) {
+                        this.linePrinter.appendNewline(innerLevel);
+                    }
+                    alterTableIndentInserted = true;
+                    deferAlterTableIndent = false;
+                    if (!this.isOnelineMode() && child.type === SqlPrintTokenType.space) {
+                        // Drop the space token because we already emitted a newline.
+                        continue;
+                    }
+                }
+            }
+            if (child.type === SqlPrintTokenType.space) {
+                if (this.shouldConvertSpaceToClauseBreak(token.containerType, nextChild)) {
+                    if (!this.isOnelineMode()) {
+                        // Use a dedicated indent resolver so clause breaks can shift indentation for nested blocks.
+                        const clauseBreakIndent = this.getClauseBreakIndentLevel(token.containerType, innerLevel);
+                        this.linePrinter.appendNewline(clauseBreakIndent);
+                    }
+                    if (isMergeWhenClause && nextIsAction) {
+                        mergePredicateActive = false;
+                    }
+                    continue;
+                }
+                this.handleSpaceToken(child, token.containerType, nextChild, previousChild, priorChild);
+                continue;
+            }
+            const previousChildWasOpenParen = (previousChild === null || previousChild === void 0 ? void 0 : previousChild.type) === SqlPrintTokenType.parenthesis && previousChild.text.trim() === '(';
+            const childIndentParentActive = token.containerType === SqlPrintTokenContainerType.ParenExpression ? shouldIndentNested : indentParentActive;
+            if (inMergePredicate) {
+                this.mergeWhenPredicateDepth++;
+            }
+            const childCommentContext = child.containerType === SqlPrintTokenContainerType.CommentBlock
+                ? { position: 'inline', isTopLevelContainer: containerIsTopLevel }
+                : undefined;
+            this.appendToken(child, innerLevel, token.containerType, nextCaseContextDepth, childIndentParentActive, childCommentContext, previousChildWasOpenParen);
+            if (inMergePredicate) {
+                this.mergeWhenPredicateDepth--;
+            }
+            if (childIsAction && isMergeWhenClause) {
+                mergePredicateActive = false;
+            }
+        }
+        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') {
+            this.insideWithClause = false;
+            // Add newline after WITH clause to separate it from main SELECT
+            this.linePrinter.appendNewline(level);
+            return; // Return early to avoid additional newline below
+        }
+        // indent level down
+        if (increasedIndent && shouldIncreaseIndent && !(this.insideWithClause && this.withClauseStyle === 'full-oneline') && !delayIndentNewline) {
+            this.linePrinter.appendNewline(level);
+        }
+    }
+    shouldAlignExplainStatementChild(parentType, childType) {
+        if (parentType !== SqlPrintTokenContainerType.ExplainStatement) {
+            return false;
+        }
+        switch (childType) {
+            case SqlPrintTokenContainerType.SimpleSelectQuery:
+            case SqlPrintTokenContainerType.InsertQuery:
+            case SqlPrintTokenContainerType.UpdateQuery:
+            case SqlPrintTokenContainerType.DeleteQuery:
+            case SqlPrintTokenContainerType.MergeQuery:
+                return true;
+            default:
+                return false;
+        }
+    }
+    isCaseContext(containerType) {
+        switch (containerType) {
+            case SqlPrintTokenContainerType.CaseExpression:
+            case SqlPrintTokenContainerType.CaseKeyValuePair:
+            case SqlPrintTokenContainerType.CaseThenValue:
+            case SqlPrintTokenContainerType.CaseElseValue:
+            case SqlPrintTokenContainerType.SwitchCaseArgument:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Determines if a token should be skipped during printing.
+     * Tokens are skipped if they have no content and no inner tokens,
+     * except for special token types that have semantic meaning despite empty text.
+     */
+    shouldSkipToken(token) {
+        // Special tokens with semantic meaning should never be skipped
+        if (token.type === SqlPrintTokenType.commentNewline) {
+            return false;
+        }
+        // Skip tokens that have no content and no children
+        return (!token.innerTokens || token.innerTokens.length === 0) && token.text === '';
+    }
+    applyKeywordCase(text) {
+        if (this.keywordCase === 'upper') {
+            return text.toUpperCase();
+        }
+        else if (this.keywordCase === 'lower') {
+            return text.toLowerCase();
+        }
+        return text;
+    }
+    handleKeywordToken(token, level, parentContainerType, caseContextDepth = 0) {
+        const lower = token.text.toLowerCase();
+        if (lower === 'and' &&
+            (this.andBreak !== 'none' || (this.whenOneLine && parentContainerType === SqlPrintTokenContainerType.MergeWhenClause))) {
+            this.handleAndOperatorToken(token, level, parentContainerType, caseContextDepth);
+            return;
+        }
+        else if (lower === 'or' &&
+            (this.orBreak !== 'none' || (this.whenOneLine && parentContainerType === SqlPrintTokenContainerType.MergeWhenClause))) {
+            this.handleOrOperatorToken(token, level, parentContainerType, caseContextDepth);
+            return;
+        }
+        const text = this.applyKeywordCase(token.text);
+        if (caseContextDepth > 0) {
+            this.linePrinter.appendText(text);
+            return;
+        }
+        this.ensureSpaceBeforeKeyword();
+        this.linePrinter.appendText(text);
+    }
+    ensureSpaceBeforeKeyword() {
+        const currentLine = this.linePrinter.getCurrentLine();
+        if (currentLine.text === '') {
+            return;
+        }
+        const lastChar = currentLine.text[currentLine.text.length - 1];
+        if (lastChar === '(') {
+            return;
+        }
+        this.ensureTrailingSpace();
+    }
+    ensureTrailingSpace() {
+        const currentLine = this.linePrinter.getCurrentLine();
+        if (currentLine.text === '') {
+            return;
+        }
+        if (!currentLine.text.endsWith(' ')) {
+            currentLine.text += ' ';
+        }
+        currentLine.text = currentLine.text.replace(/\s+$/, ' ');
+    }
+    /**
+     * Normalizes INSERT column list token text when one-line formatting is active.
+     */
+    tryAppendInsertClauseTokenText(text, parentContainerType) {
+        const currentLineText = this.linePrinter.getCurrentLine().text;
+        const result = this.onelineHelper.formatInsertClauseToken(text, parentContainerType, currentLineText, () => this.ensureTrailingSpace());
+        if (!result.handled) {
+            return false;
+        }
+        if (result.text) {
+            this.linePrinter.appendText(result.text);
+        }
+        return true;
+    }
+    handleCommaToken(token, level, parentContainerType) {
+        const text = token.text;
+        const isWithinWithClause = parentContainerType === SqlPrintTokenContainerType.WithClause;
+        let effectiveCommaBreak = this.onelineHelper.resolveCommaBreak(parentContainerType, this.commaBreak, this.cteCommaBreak, this.valuesCommaBreak);
+        if (parentContainerType === SqlPrintTokenContainerType.SetClause) {
+            effectiveCommaBreak = 'before';
+        }
+        // Skip comma newlines when inside WITH clause with full-oneline style
+        if (this.insideWithClause && this.withClauseStyle === 'full-oneline') {
+            this.linePrinter.appendText(text);
+        }
+        // Special handling for commas in WithClause when withClauseStyle is 'cte-oneline'
+        else if (this.withClauseStyle === 'cte-oneline' && isWithinWithClause) {
+            this.linePrinter.appendText(text);
+            this.linePrinter.appendNewline(level);
+        }
+        else if (effectiveCommaBreak === 'before') {
+            const previousCommaBreak = this.linePrinter.commaBreak;
+            if (previousCommaBreak !== 'before') {
+                this.linePrinter.commaBreak = 'before';
+            }
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(level);
+                if (this.newline === ' ') {
+                    // Remove the spacer introduced by space newlines so commas attach directly to the preceding token.
+                    this.linePrinter.trimTrailingWhitespaceFromPreviousLine();
+                }
+                if (parentContainerType === SqlPrintTokenContainerType.InsertClause) {
+                    // Align comma-prefixed column entries under the INSERT column indentation.
+                    this.linePrinter.getCurrentLine().level = level + 1;
+                }
+            }
+            this.linePrinter.appendText(text);
+            if (previousCommaBreak !== 'before') {
+                this.linePrinter.commaBreak = previousCommaBreak;
+            }
+        }
+        else if (effectiveCommaBreak === 'after') {
+            const previousCommaBreak = this.linePrinter.commaBreak;
+            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);
+            }
+            if (previousCommaBreak !== 'after') {
+                this.linePrinter.commaBreak = previousCommaBreak;
+            }
+        }
+        else if (effectiveCommaBreak === 'none') {
+            const previousCommaBreak = this.linePrinter.commaBreak;
+            if (previousCommaBreak !== 'none') {
+                this.linePrinter.commaBreak = 'none';
+            }
+            this.linePrinter.appendText(text);
+            if (this.onelineHelper.isInsertClauseOneline(parentContainerType)) {
+                this.ensureTrailingSpace();
+            }
+            if (previousCommaBreak !== 'none') {
+                this.linePrinter.commaBreak = previousCommaBreak;
+            }
+        }
+        else {
+            this.linePrinter.appendText(text);
+        }
+    }
+    handleAndOperatorToken(token, level, parentContainerType, caseContextDepth = 0) {
+        const text = this.applyKeywordCase(token.text);
+        if (caseContextDepth > 0) {
+            this.linePrinter.appendText(text);
+            return;
+        }
+        if (this.whenOneLine &&
+            (parentContainerType === SqlPrintTokenContainerType.MergeWhenClause || this.mergeWhenPredicateDepth > 0)) {
+            this.linePrinter.appendText(text);
+            return;
+        }
+        if (this.andBreak === 'before') {
+            // Skip newline when inside WITH clause with full-oneline style
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(level);
+            }
+            this.linePrinter.appendText(text);
+        }
+        else if (this.andBreak === 'after') {
+            this.linePrinter.appendText(text);
+            // Skip newline when inside WITH clause with full-oneline style
+            if (!(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                this.linePrinter.appendNewline(level);
+            }
+        }
+        else {
+            this.linePrinter.appendText(text);
+        }
+    }
+    handleParenthesisToken(token, level, indentParentActive, parentContainerType) {
+        if (token.text === '(') {
+            this.linePrinter.appendText(token.text);
+            if ((parentContainerType === SqlPrintTokenContainerType.InsertClause ||
+                parentContainerType === SqlPrintTokenContainerType.MergeInsertAction) &&
+                this.insertColumnsOneLine) {
+                return;
+            }
+            if (!this.isOnelineMode()) {
+                if (this.shouldBreakAfterOpeningParen(parentContainerType)) {
+                    this.linePrinter.appendNewline(level + 1);
+                }
+                else if (indentParentActive && !(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                    this.linePrinter.appendNewline(level);
+                }
+            }
+            return;
+        }
+        if (token.text === ')' && !this.isOnelineMode()) {
+            if (this.shouldBreakBeforeClosingParen(parentContainerType)) {
+                this.linePrinter.appendNewline(Math.max(level, 0));
+                this.linePrinter.appendText(token.text);
+                return;
+            }
+            if (indentParentActive && !(this.insideWithClause && this.withClauseStyle === 'full-oneline')) {
+                const closingLevel = Math.max(level - 1, 0);
+                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.whenOneLine &&
+            (parentContainerType === SqlPrintTokenContainerType.MergeWhenClause || this.mergeWhenPredicateDepth > 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, previousSiblingWasOpenParen = false) {
+        if (!this.indentNestedParentheses) {
+            return false;
+        }
+        if (token.containerType !== SqlPrintTokenContainerType.ParenExpression) {
+            return false;
+        }
+        // Look for nested parentheses containers. If present, indent to highlight grouping.
+        return previousSiblingWasOpenParen || 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 when multiline formatting is allowed
+        if (this.onelineHelper.shouldInsertJoinNewline(this.insideWithClause)) {
+            this.linePrinter.appendNewline(level);
+        }
+        this.linePrinter.appendText(text);
+    }
+    /**
+     * Decides whether the current container should collapse into a single line.
+     */
+    shouldFormatContainerAsOneline(token, shouldIndentNested) {
+        return this.onelineHelper.shouldFormatContainer(token, shouldIndentNested);
+    }
+    /**
+     * Detects an INSERT column list that must stay on a single line.
+     */
+    isInsertClauseOneline(parentContainerType) {
+        return this.onelineHelper.isInsertClauseOneline(parentContainerType);
+    }
+    /**
+     * Handles space tokens with context-aware filtering.
+     * Skips spaces in CommentBlocks when in specific CTE modes to prevent duplication.
+     */
+    handleSpaceToken(token, parentContainerType, nextToken, previousToken, priorToken) {
+        if (this.smartCommentBlockBuilder && this.smartCommentBlockBuilder.mode === 'line') {
+            this.flushSmartCommentBlockBuilder();
+        }
+        const currentLineText = this.linePrinter.getCurrentLine().text;
+        if (this.onelineHelper.shouldSkipInsertClauseSpace(parentContainerType, nextToken, currentLineText)) {
+            return;
+        }
+        if (this.onelineHelper.shouldSkipCommentBlockSpace(parentContainerType, this.insideWithClause)) {
+            const currentLine = this.linePrinter.getCurrentLine();
+            if (currentLine.text !== '' && !currentLine.text.endsWith(' ')) {
+                this.linePrinter.appendText(' ');
+            }
+            return;
+        }
+        // Skip redundant spaces before structural parentheses in CREATE TABLE DDL.
+        if (this.shouldSkipSpaceBeforeParenthesis(parentContainerType, nextToken, previousToken, priorToken)) {
+            return;
+        }
+        this.linePrinter.appendText(token.text);
+    }
+    findPreviousSignificantToken(tokens, index) {
+        for (let i = index - 1; i >= 0; i--) {
+            const candidate = tokens[i];
+            if (candidate.type === SqlPrintTokenType.space || candidate.type === SqlPrintTokenType.commentNewline) {
+                continue;
+            }
+            if (candidate.type === SqlPrintTokenType.comment && !this.rendersInlineComments()) {
+                continue;
+            }
+            return { token: candidate, index: i };
+        }
+        return undefined;
+    }
+    shouldSkipSpaceBeforeParenthesis(parentContainerType, nextToken, previousToken, priorToken) {
+        if (!nextToken || nextToken.type !== SqlPrintTokenType.parenthesis || nextToken.text !== '(') {
+            return false;
+        }
+        if (!parentContainerType || !this.isCreateTableSpacingContext(parentContainerType)) {
+            return false;
+        }
+        if (!previousToken) {
+            return false;
+        }
+        if (this.isCreateTableNameToken(previousToken, parentContainerType)) {
+            return true;
+        }
+        if (this.isCreateTableConstraintKeyword(previousToken, parentContainerType)) {
+            return true;
+        }
+        if (priorToken && this.isCreateTableConstraintKeyword(priorToken, parentContainerType)) {
+            if (this.isIdentifierAttachedToConstraint(previousToken, priorToken, parentContainerType)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    shouldAlignCreateTableSelect(containerType, parentContainerType) {
+        return containerType === SqlPrintTokenContainerType.SimpleSelectQuery &&
+            parentContainerType === SqlPrintTokenContainerType.CreateTableQuery;
+    }
+    isCreateTableSpacingContext(parentContainerType) {
+        switch (parentContainerType) {
+            case SqlPrintTokenContainerType.CreateTableQuery:
+            case SqlPrintTokenContainerType.CreateTableDefinition:
+            case SqlPrintTokenContainerType.TableConstraintDefinition:
+            case SqlPrintTokenContainerType.ColumnConstraintDefinition:
+            case SqlPrintTokenContainerType.ReferenceDefinition:
+                return true;
+            default:
+                return false;
+        }
+    }
+    isCreateTableNameToken(previousToken, parentContainerType) {
+        if (parentContainerType !== SqlPrintTokenContainerType.CreateTableQuery) {
+            return false;
+        }
+        return previousToken.containerType === SqlPrintTokenContainerType.QualifiedName;
+    }
+    isCreateTableConstraintKeyword(token, parentContainerType) {
+        if (token.type !== SqlPrintTokenType.keyword) {
+            return false;
+        }
+        const text = token.text.toLowerCase();
+        if (parentContainerType === SqlPrintTokenContainerType.ReferenceDefinition) {
+            return CREATE_TABLE_PAREN_KEYWORDS_WITH_IDENTIFIER.has(text);
+        }
+        if (CREATE_TABLE_SINGLE_PAREN_KEYWORDS.has(text)) {
+            return true;
+        }
+        if (CREATE_TABLE_MULTI_PAREN_KEYWORDS.has(text)) {
+            return true;
+        }
+        return false;
+    }
+    isIdentifierAttachedToConstraint(token, keywordToken, parentContainerType) {
+        if (!token) {
+            return false;
+        }
+        if (parentContainerType === SqlPrintTokenContainerType.ReferenceDefinition) {
+            return token.containerType === SqlPrintTokenContainerType.QualifiedName &&
+                CREATE_TABLE_PAREN_KEYWORDS_WITH_IDENTIFIER.has(keywordToken.text.toLowerCase());
+        }
+        if (parentContainerType === SqlPrintTokenContainerType.TableConstraintDefinition ||
+            parentContainerType === SqlPrintTokenContainerType.ColumnConstraintDefinition) {
+            const normalized = keywordToken.text.toLowerCase();
+            if (CREATE_TABLE_SINGLE_PAREN_KEYWORDS.has(normalized) ||
+                CREATE_TABLE_MULTI_PAREN_KEYWORDS.has(normalized)) {
+                return token.containerType === SqlPrintTokenContainerType.IdentifierString;
+            }
+        }
+        return false;
+    }
+    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 = this.resolveCommentIndentLevel(level, parentContainerType);
+                }
+                else {
+                    this.linePrinter.appendText(lineText);
+                    const effectiveLevel = this.resolveCommentIndentLevel(level, parentContainerType);
+                    this.linePrinter.appendNewline(effectiveLevel);
+                }
+            }
+        }
+        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 = this.resolveCommentIndentLevel(level, parentContainerType);
+                }
+                else {
+                    const effectiveLevel = this.resolveCommentIndentLevel(level, parentContainerType);
+                    this.linePrinter.appendNewline(effectiveLevel);
+                }
+            }
+        }
+    }
+    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, context) {
+        var _a;
+        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) {
+                // Force inner comment tokens to render once the block is approved.
+                const childContext = {
+                    position: context.position,
+                    isTopLevelContainer: context.isTopLevelContainer,
+                    forceRender: true,
+                };
+                this.appendToken(child, level, token.containerType, 0, false, childContext, 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') {
+            const meaningfulLineCount = lines.filter(line => line.trim() !== '').length;
+            if (meaningfulLineCount > 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, '*\\/');
+    }
+    getCommentBaseIndentLevel(level, parentContainerType) {
+        if (!parentContainerType) {
+            return level;
+        }
+        const clauseAlignedLevel = this.getClauseBreakIndentLevel(parentContainerType, level);
+        return Math.max(level, clauseAlignedLevel);
+    }
+    resolveCommentIndentLevel(level, parentContainerType) {
+        var _a;
+        const baseLevel = this.getCommentBaseIndentLevel(level, parentContainerType);
+        const currentLevel = (_a = this.linePrinter.getCurrentLine().level) !== null && _a !== void 0 ? _a : baseLevel;
+        return Math.max(baseLevel, currentLevel);
+    }
+    /**
+     * Handles commentNewline tokens with conditional newline behavior.
+     * In multiline mode (newline !== ' '), adds a newline after comments.
+     * In oneliner mode (newline === ' '), does nothing to keep comments on same line.
+     * 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;
+        }
+        if (!this.isOnelineMode()) {
+            this.linePrinter.appendNewline(level);
+        }
+    }
+    /**
+     * Determines whether to skip commentNewline tokens.
+     * Skips in CTE modes to maintain one-line formatting.
+     */
+    shouldSkipCommentNewline() {
+        return (this.insideWithClause && this.withClauseStyle === 'full-oneline') ||
+            this.withClauseStyle === 'cte-oneline';
+    }
+    shouldAddNewlineBeforeLeadingComments(parentType) {
+        if (!parentType) {
+            return false;
+        }
+        if (parentType === SqlPrintTokenContainerType.TupleExpression) {
+            return true;
+        }
+        if (parentType === SqlPrintTokenContainerType.InsertClause ||
+            parentType === SqlPrintTokenContainerType.MergeInsertAction) {
+            return !this.insertColumnsOneLine;
+        }
+        if (parentType === SqlPrintTokenContainerType.SetClause) {
+            return true;
+        }
+        if (parentType === SqlPrintTokenContainerType.SelectClause) {
+            return true;
+        }
+        if (parentType === SqlPrintTokenContainerType.ExplainStatement) {
+            // Ensure EXPLAIN targets print header comments on a dedicated line.
+            return true;
+        }
+        return false;
+    }
+    getLeadingCommentIndentLevel(parentType, currentLevel) {
+        if (parentType === SqlPrintTokenContainerType.TupleExpression) {
+            return currentLevel + 1;
+        }
+        if (parentType === SqlPrintTokenContainerType.InsertClause ||
+            parentType === SqlPrintTokenContainerType.MergeInsertAction ||
+            parentType === SqlPrintTokenContainerType.SelectClause) {
+            return currentLevel + 1;
+        }
+        if (parentType === SqlPrintTokenContainerType.SetClause) {
+            return currentLevel + 1;
+        }
+        return currentLevel;
+    }
+    /**
+     * Determines if the printer is in oneliner mode.
+     * Oneliner mode uses single spaces instead of actual newlines.
+     */
+    isOnelineMode() {
+        return this.newline === ' ';
+    }
+    /**
+     * Handles CTE tokens with one-liner formatting.
+     * Creates a nested SqlPrinter instance for proper CTE oneline formatting.
+     */
+    handleCteOnelineToken(token, level) {
+        const onelinePrinter = this.createCteOnelinePrinter();
+        const onelineResult = onelinePrinter.print(token, level);
+        let cleanedResult = this.cleanDuplicateSpaces(onelineResult);
+        cleanedResult = cleanedResult.replace(/\(\s+/g, '(').replace(/\s+\)/g, ' )');
+        this.linePrinter.appendText(cleanedResult.trim());
+    }
+    /**
+     * Creates a SqlPrinter instance configured for CTE oneline formatting.
+     */
+    createCteOnelinePrinter() {
+        return new SqlPrinter({
+            indentChar: '',
+            indentSize: 0,
+            newline: ' ',
+            commaBreak: this.commaBreak,
+            cteCommaBreak: this.cteCommaBreak,
+            valuesCommaBreak: this.valuesCommaBreak,
+            andBreak: this.andBreak,
+            orBreak: this.orBreak,
+            keywordCase: this.keywordCase,
+            exportComment: 'none',
+            withClauseStyle: 'standard', // Prevent recursive processing
+            indentNestedParentheses: false,
+            insertColumnsOneLine: this.insertColumnsOneLine,
+        });
+    }
+    /**
+     * Handles tokens with oneline formatting (parentheses, BETWEEN, VALUES, JOIN, CASE, subqueries).
+     * Creates a unified oneline printer that formats everything as one line regardless of content type.
+     */
+    handleOnelineToken(token, level) {
+        const onelinePrinter = this.createOnelinePrinter();
+        const onelineResult = onelinePrinter.print(token, level);
+        const cleanedResult = this.cleanDuplicateSpaces(onelineResult);
+        this.linePrinter.appendText(cleanedResult);
+    }
+    getClauseBreakIndentLevel(parentType, level) {
+        if (!parentType) {
+            return level;
+        }
+        switch (parentType) {
+            case SqlPrintTokenContainerType.MergeWhenClause:
+                // Actions under WHEN clauses should be indented one level deeper than the WHEN line.
+                return level + 1;
+            case SqlPrintTokenContainerType.MergeUpdateAction:
+            case SqlPrintTokenContainerType.MergeDeleteAction:
+            case SqlPrintTokenContainerType.MergeInsertAction:
+                // Keep MERGE actions and their follow-up keywords (e.g., VALUES, WHERE) aligned with the action keyword.
+                return level + 1;
+            default:
+                return level;
+        }
+    }
+    isMergeActionContainer(token) {
+        if (!token) {
+            return false;
+        }
+        switch (token.containerType) {
+            case SqlPrintTokenContainerType.MergeUpdateAction:
+            case SqlPrintTokenContainerType.MergeDeleteAction:
+            case SqlPrintTokenContainerType.MergeInsertAction:
+            case SqlPrintTokenContainerType.MergeDoNothingAction:
+                return true;
+            default:
+                return false;
+        }
+    }
+    shouldBreakAfterOpeningParen(parentType) {
+        if (!parentType) {
+            return false;
+        }
+        if (parentType === SqlPrintTokenContainerType.InsertClause ||
+            parentType === SqlPrintTokenContainerType.MergeInsertAction) {
+            return !this.isInsertClauseOneline(parentType);
+        }
+        return false;
+    }
+    shouldBreakBeforeClosingParen(parentType) {
+        if (!parentType) {
+            return false;
+        }
+        if (parentType === SqlPrintTokenContainerType.InsertClause ||
+            parentType === SqlPrintTokenContainerType.MergeInsertAction) {
+            return !this.isInsertClauseOneline(parentType);
+        }
+        return false;
+    }
+    shouldConvertSpaceToClauseBreak(parentType, nextToken) {
+        if (!parentType || !nextToken) {
+            return false;
+        }
+        const nextKeyword = nextToken.type === SqlPrintTokenType.keyword ? nextToken.text.toLowerCase() : null;
+        const nextContainer = nextToken.containerType;
+        if (parentType === SqlPrintTokenContainerType.MergeQuery) {
+            // Break before USING blocks and before each WHEN clause to mirror statement structure.
+            if (nextKeyword === 'using') {
+                return true;
+            }
+            if (nextContainer === SqlPrintTokenContainerType.MergeWhenClause) {
+                return true;
+            }
+        }
+        if (parentType === SqlPrintTokenContainerType.MergeWhenClause) {
+            // Force the action to start on the next line with additional indentation.
+            if (nextContainer === SqlPrintTokenContainerType.MergeUpdateAction ||
+                nextContainer === SqlPrintTokenContainerType.MergeDeleteAction ||
+                nextContainer === SqlPrintTokenContainerType.MergeInsertAction ||
+                nextContainer === SqlPrintTokenContainerType.MergeDoNothingAction) {
+                return true;
+            }
+        }
+        if (parentType === SqlPrintTokenContainerType.UpdateQuery) {
+            if (nextKeyword === 'set' || nextKeyword === 'from' || nextKeyword === 'where' || nextKeyword === 'returning') {
+                return true;
+            }
+        }
+        if (parentType === SqlPrintTokenContainerType.InsertQuery) {
+            if (nextKeyword === 'returning') {
+                return true;
+            }
+            if (nextKeyword && (nextKeyword.startsWith('select') || nextKeyword.startsWith('values'))) {
+                return true;
+            }
+            if (nextContainer === SqlPrintTokenContainerType.ValuesQuery || nextContainer === SqlPrintTokenContainerType.SimpleSelectQuery) {
+                return true;
+            }
+            if (nextContainer === SqlPrintTokenContainerType.InsertClause) {
+                return true;
+            }
+        }
+        if (parentType === SqlPrintTokenContainerType.DeleteQuery) {
+            if (nextKeyword === 'using' || nextKeyword === 'where' || nextKeyword === 'returning') {
+                return true;
+            }
+        }
+        if (parentType === SqlPrintTokenContainerType.MergeUpdateAction || parentType === SqlPrintTokenContainerType.MergeDeleteAction) {
+            if (nextKeyword === 'where') {
+                return true;
+            }
+        }
+        if (parentType === SqlPrintTokenContainerType.MergeInsertAction) {
+            if (nextKeyword && (nextKeyword.startsWith('values') || nextKeyword === 'default values')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Creates a unified SqlPrinter instance configured for oneline formatting.
+     * Works for all oneline options: parentheses, BETWEEN, VALUES, JOIN, CASE, subqueries.
+     * Sets all oneline options to false to prevent recursion and uses newline=' ' for actual oneline effect.
+     */
+    createOnelinePrinter() {
+        return new SqlPrinter({
+            indentChar: '',
+            indentSize: 0,
+            newline: ' ', // KEY: Replace all newlines with spaces - this makes everything oneline!
+            commaBreak: 'none', // Disable comma-based line breaks
+            cteCommaBreak: this.cteCommaBreak,
+            valuesCommaBreak: 'none',
+            andBreak: 'none', // Disable AND-based line breaks
+            orBreak: 'none', // Disable OR-based line breaks
+            keywordCase: this.keywordCase,
+            exportComment: this.commentExportMode,
+            commentStyle: this.commentStyle,
+            withClauseStyle: 'standard',
+            parenthesesOneLine: false, // Prevent recursive processing (avoid infinite loops)
+            betweenOneLine: false, // Prevent recursive processing (avoid infinite loops)
+            valuesOneLine: false, // Prevent recursive processing (avoid infinite loops)
+            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,
+            insertColumnsOneLine: this.insertColumnsOneLine,
+        });
+    }
+    /**
+     * Removes duplicate consecutive spaces while preserving single spaces.
+     * Simple and safe space normalization for CTE oneline mode.
+     */
+    cleanDuplicateSpaces(text) {
+        return text.replace(/\s{2,}/g, ' ');
+    }
+}
+//# sourceMappingURL=SqlPrinter.js.map