@aforemendude/prettier-plugin-wrap-comments 1.0.6 → 1.1.1

package/dist/comments/jsx-expression-layout.js

@@ -0,0 +1,114 @@
+import { isStandaloneBlockComment } from './comment-location.js';
+import { getAstNodeRange, visitAstNodes } from '../utils/ast.js';
+import { getColumns } from '../utils/display-width.js';
+import { getLeadingIndent } from '../utils/indentation.js';
+import { getLinePrefix, getLineStart } from '../utils/source-lines.js';
+import { isRecord } from '../utils/type-guards.js';
+import { skipWhitespace, trimWhitespaceEnd } from '../utils/whitespace.js';
+export function collectJsxExpressionContainerRanges(ast) {
+    const ranges = [];
+    visitAstNodes(ast, (node) => {
+        if (node['type'] !== 'JSXExpressionContainer') {
+            return;
+        }
+        const range = getAstNodeRange(node);
+        if (range === undefined) {
+            return;
+        }
+        const expressionNode = node['expression'];
+        const expression = isRecord(expressionNode) && expressionNode['type'] !== 'JSXEmptyExpression'
+            ? getAstNodeRange(expressionNode)
+            : undefined;
+        ranges.push({ ...range, expression });
+    });
+    return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
+}
+export function getPrintedJsxCommentMarkerColumn(text, container, tabWidth) {
+    const linePrefix = getLinePrefix(text, container.start);
+    const lineIndent = getLeadingIndent(linePrefix);
+    return getColumns(lineIndent, tabWidth) + tabWidth;
+}
+export function getJsxExpressionBlockCommentLayout(text, comment, previousComment, containerMatch, tabWidth, outputCommentLayout, outputCommentMarkerColumns) {
+    if (containerMatch === undefined) {
+        return undefined;
+    }
+    const container = containerMatch.range;
+    if (text[container.start] !== '{' || text[container.end - 1] !== '}') {
+        return undefined;
+    }
+    const hasExpressionBeforeComment = container.expression !== undefined && container.expression.start < comment.start;
+    const hasExpressionAfterComment = container.expression !== undefined && container.expression.end > comment.end;
+    const multilineMarkerColumn = outputCommentMarkerColumns[containerMatch.index] ??
+        getJsxExpressionContainerOutputColumn(text, container, tabWidth) + tabWidth;
+    const markerColumn = outputCommentLayout?.markerColumn ?? multilineMarkerColumn;
+    const contentColumn = multilineMarkerColumn + 3;
+    if (!hasExpressionBeforeComment && !hasExpressionAfterComment) {
+        return {
+            contentColumn,
+            markerColumn,
+            multilineIndent: '',
+            placement: 'standalone',
+            singleLineSuffixWidth: outputCommentLayout?.suffixWidth ?? 1,
+        };
+    }
+    if (hasExpressionBeforeComment && !hasExpressionAfterComment) {
+        const hasEarlierCommentInContainer = previousComment !== undefined && previousComment.start > container.start && previousComment.end < container.end;
+        if (hasEarlierCommentInContainer) {
+            return {
+                contentColumn,
+                markerColumn,
+                multilineIndent: '',
+                placement: 'standalone',
+                singleLineSuffixWidth: outputCommentLayout?.suffixWidth ?? 1,
+            };
+        }
+        const expressionStart = skipWhitespace(text, container.start + 1);
+        const expressionEnd = trimWhitespaceEnd(text, container.start + 1, comment.start);
+        const removalEnd = Math.min(skipWhitespace(text, comment.end), container.end - 1);
+        return {
+            contentColumn,
+            markerColumn,
+            multilineIndent: '',
+            placement: 'trailing',
+            singleLineSuffixWidth: outputCommentLayout?.suffixWidth ?? 1,
+            trailingMove: {
+                insertAt: expressionStart,
+                removeEnd: removalEnd,
+                removeStart: expressionEnd,
+            },
+        };
+    }
+    if (!hasExpressionBeforeComment) {
+        if (isStandaloneBlockComment(text, comment)) {
+            return {
+                contentColumn,
+                markerColumn,
+                multilineIndent: '',
+                placement: 'standalone',
+                preserveMultiline: getLineStart(text, comment.start) !== getLineStart(text, comment.end),
+                singleLineSuffixWidth: outputCommentLayout?.suffixWidth ?? 0,
+            };
+        }
+        const expressionStart = skipWhitespace(text, comment.end);
+        return {
+            contentColumn,
+            leadingMove: {
+                removeEnd: expressionStart,
+                removeStart: comment.end,
+            },
+            markerColumn,
+            multilineIndent: '',
+            placement: 'standalone',
+            singleLineSuffixWidth: outputCommentLayout?.suffixWidth ?? getColumns(text.slice(comment.end, container.end), tabWidth),
+        };
+    }
+    return { placement: 'inline' };
+}
+function getJsxExpressionContainerOutputColumn(text, container, tabWidth) {
+    const linePrefix = getLinePrefix(text, container.start);
+    if (/^[ \t]*$/u.test(linePrefix)) {
+        return getColumns(linePrefix, tabWidth);
+    }
+    const lineIndent = getLeadingIndent(linePrefix);
+    return getColumns(lineIndent, tabWidth) + tabWidth;
+}

package/dist/comments/line-comment-groups.d.ts

@@ -0,0 +1,6 @@
+import type { CommentRange } from './comment-ranges.js';
+export type LineCommentGroup = {
+    comments: CommentRange[];
+    endIndex: number;
+};
+export declare function collectLineCommentGroup(text: string, comments: CommentRange[], startIndex: number, tabWidth: number): LineCommentGroup;

package/dist/comments/line-comment-groups.js

@@ -0,0 +1,28 @@
+import { shouldSkipLineComment } from './comment-eligibility.js';
+import { areCommentsOnAdjacentLines, isStandaloneLineComment } from './comment-location.js';
+import { getColumnAt } from '../utils/display-width.js';
+export function collectLineCommentGroup(text, comments, startIndex, tabWidth) {
+    const firstComment = comments[startIndex];
+    if (firstComment === undefined) {
+        return { comments: [], endIndex: startIndex };
+    }
+    const group = [firstComment];
+    const markerColumn = getColumnAt(text, firstComment.start, tabWidth);
+    let endIndex = startIndex;
+    let previousComment = firstComment;
+    while (endIndex + 1 < comments.length) {
+        const nextComment = comments[endIndex + 1];
+        if (nextComment === undefined ||
+            nextComment.kind !== 'line' ||
+            !isStandaloneLineComment(text, nextComment) ||
+            shouldSkipLineComment(text, nextComment) ||
+            !areCommentsOnAdjacentLines(text, previousComment, nextComment) ||
+            markerColumn !== getColumnAt(text, nextComment.start, tabWidth)) {
+            break;
+        }
+        group.push(nextComment);
+        previousComment = nextComment;
+        endIndex += 1;
+    }
+    return { comments: group, endIndex };
+}

package/dist/comments/prettier-ignore.d.ts

@@ -0,0 +1,9 @@
+import type { CommentEntry, CommentRange } from './comment-ranges.js';
+import type { SourceRange } from '../utils/ast.js';
+export declare function neutralizePrettierIgnoreForIgnoredComments<T>(text: string, ast: T): T;
+export declare function getNeutralizedPrettierIgnoreOriginalText(comment: unknown): string | undefined;
+export declare function collectPrettierIgnoredLineRanges(text: string, ast: unknown, comments: CommentEntry[]): SourceRange[];
+export declare function isCommentInIgnoredLineRange(comment: CommentRange, ignoredLineRange: SourceRange | undefined): boolean;
+export declare function isPrettierIgnoredBlockComment(text: string, comments: CommentEntry[], index: number): boolean;
+export declare function isPrettierIgnoredStandaloneLineComment(text: string, comments: CommentEntry[], index: number): boolean;
+export declare function isPrettierIgnoredTrailingLineComment(text: string, comments: CommentEntry[], index: number): boolean;

package/dist/comments/prettier-ignore.js

@@ -0,0 +1,239 @@
+import { getCommentBody } from './comment-body.js';
+import { isPrettierIgnoreComment } from './comment-directives.js';
+import { shouldSkipBlockComment, shouldSkipLineComment } from './comment-eligibility.js';
+import { areCommentsOnAdjacentLines, isCommentAdjacentBeforeIndex, isStandaloneBlockComment, isStandaloneComment, isStandaloneLineComment, } from './comment-location.js';
+import { collectCommentEntries } from './comment-ranges.js';
+import { collectAstNodeRangesByStart, getAstNodeRange, visitAstNodes } from '../utils/ast.js';
+import { getLineEnd, getLineStart } from '../utils/source-lines.js';
+import { isRecord } from '../utils/type-guards.js';
+import { skipWhitespace } from '../utils/whitespace.js';
+const NEUTRALIZED_PRETTIER_IGNORE_COMMENT = 'prettier-ignore wrap-comments';
+const neutralizedPrettierIgnoreOriginalTextKey = Symbol('neutralizedPrettierIgnoreOriginalText');
+export function neutralizePrettierIgnoreForIgnoredComments(text, ast) {
+    const comments = collectCommentEntries(ast, text);
+    for (let index = 0; index < comments.length; index += 1) {
+        const entry = comments[index];
+        const previousEntry = comments[index - 1];
+        const shouldNeutralize = entry !== undefined &&
+            previousEntry !== undefined &&
+            ((isPrettierIgnoredBlockComment(text, comments, index) && !shouldSkipBlockComment(text, entry.range)) ||
+                (isPrettierIgnoredStandaloneLineComment(text, comments, index) && !shouldSkipLineComment(text, entry.range)));
+        if (shouldNeutralize) {
+            if (previousEntry.range.kind === 'block') {
+                const originalText = text.slice(previousEntry.range.start, previousEntry.range.end);
+                previousEntry.raw[neutralizedPrettierIgnoreOriginalTextKey] =
+                    originalText;
+            }
+            previousEntry.raw.value = NEUTRALIZED_PRETTIER_IGNORE_COMMENT;
+        }
+    }
+    return ast;
+}
+export function getNeutralizedPrettierIgnoreOriginalText(comment) {
+    if (!isRecord(comment)) {
+        return undefined;
+    }
+    const originalText = comment[neutralizedPrettierIgnoreOriginalTextKey];
+    return typeof originalText === 'string' ? originalText : undefined;
+}
+export function collectPrettierIgnoredLineRanges(text, ast, comments) {
+    const nodeRangesByStart = collectAstNodeRangesByStart(ast);
+    const jsxTargetRangesByIgnoreStart = collectJsxPrettierIgnoreTargetRanges(text, ast, comments);
+    const ignoredLineRanges = [];
+    for (let index = 0; index < comments.length; index += 1) {
+        const comment = comments[index]?.range;
+        const jsxTargetRange = comment === undefined ? undefined : jsxTargetRangesByIgnoreStart.get(comment.start);
+        if (comment === undefined ||
+            (!isStandaloneComment(text, comment) && jsxTargetRange === undefined) ||
+            !isPrettierIgnoreComment(getCommentBody(text, comment))) {
+            continue;
+        }
+        let targetRange = jsxTargetRange;
+        if (targetRange === undefined) {
+            const targetStart = getPrettierIgnoreTargetStart(text, comments, index);
+            if (targetStart === undefined) {
+                continue;
+            }
+            targetRange = nodeRangesByStart.get(targetStart);
+        }
+        if (targetRange === undefined) {
+            continue;
+        }
+        appendMergedRange(ignoredLineRanges, {
+            end: getLineEnd(text, targetRange.end),
+            start: getLineStart(text, targetRange.start),
+        });
+    }
+    return ignoredLineRanges;
+}
+export function isCommentInIgnoredLineRange(comment, ignoredLineRange) {
+    return (ignoredLineRange !== undefined && comment.start >= ignoredLineRange.start && comment.start < ignoredLineRange.end);
+}
+export function isPrettierIgnoredBlockComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    const previousComment = comments[index - 1]?.range;
+    if (comment === undefined ||
+        comment.kind !== 'block' ||
+        !isStandaloneBlockComment(text, comment) ||
+        previousComment === undefined) {
+        return false;
+    }
+    if (!isStandaloneComment(text, previousComment) || !areCommentsOnAdjacentLines(text, previousComment, comment)) {
+        return false;
+    }
+    return isPrettierIgnoreComment(getCommentBody(text, previousComment));
+}
+export function isPrettierIgnoredStandaloneLineComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    const previousComment = comments[index - 1]?.range;
+    if (comment === undefined ||
+        comment.kind !== 'line' ||
+        !isStandaloneLineComment(text, comment) ||
+        previousComment === undefined ||
+        previousComment.kind !== 'line') {
+        return false;
+    }
+    if (!isStandaloneComment(text, previousComment) || !areCommentsOnAdjacentLines(text, previousComment, comment)) {
+        return false;
+    }
+    return isPrettierIgnoreComment(getCommentBody(text, previousComment));
+}
+export function isPrettierIgnoredTrailingLineComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    if (comment === undefined || comment.kind !== 'line' || isStandaloneLineComment(text, comment)) {
+        return false;
+    }
+    let cursor = getLineStart(text, comment.start);
+    for (let previousIndex = index - 1; previousIndex >= 0; previousIndex -= 1) {
+        const previousComment = comments[previousIndex]?.range;
+        if (previousComment !== undefined && previousComment.end > cursor) {
+            continue;
+        }
+        if (previousComment === undefined || !isStandaloneComment(text, previousComment)) {
+            return false;
+        }
+        if (!isCommentAdjacentBeforeIndex(text, previousComment, cursor)) {
+            return false;
+        }
+        const body = getCommentBody(text, previousComment);
+        if (isPrettierIgnoreComment(body)) {
+            return true;
+        }
+        if (!isSkippableCommentBetweenIgnoreAndTarget(text, previousComment)) {
+            return false;
+        }
+        cursor = getLineStart(text, previousComment.start);
+    }
+    return false;
+}
+function collectJsxPrettierIgnoreTargetRanges(text, ast, comments) {
+    const commentsByStart = new Map(comments.map((entry) => [entry.range.start, entry.range]));
+    const targetRangesByIgnoreStart = new Map();
+    visitAstNodes(ast, (node) => {
+        if (!isJsxElementOrFragment(node)) {
+            return;
+        }
+        const children = node['children'];
+        if (!Array.isArray(children)) {
+            return;
+        }
+        for (let ignoreIndex = 0; ignoreIndex < children.length; ignoreIndex += 1) {
+            const ignoreContainer = children[ignoreIndex];
+            if (!isRecord(ignoreContainer)) {
+                continue;
+            }
+            const ignoreComment = getCommentOnlyJsxExpressionContainerComment(text, ignoreContainer, commentsByStart);
+            if (ignoreComment === undefined || !isPrettierIgnoreComment(getCommentBody(text, ignoreComment))) {
+                continue;
+            }
+            const target = getNextSignificantJsxChild(text, children, ignoreIndex);
+            if (target === undefined || !isJsxElementOrFragment(target)) {
+                continue;
+            }
+            const targetRange = getAstNodeRange(target);
+            if (targetRange !== undefined) {
+                targetRangesByIgnoreStart.set(ignoreComment.start, targetRange);
+            }
+        }
+    });
+    return targetRangesByIgnoreStart;
+}
+function getNextSignificantJsxChild(text, children, ignoreIndex) {
+    for (let index = ignoreIndex + 1; index < children.length; index += 1) {
+        const child = children[index];
+        if (!isRecord(child)) {
+            return undefined;
+        }
+        if (isMultilineWhitespaceJsxText(text, child)) {
+            continue;
+        }
+        return child;
+    }
+    return undefined;
+}
+function isMultilineWhitespaceJsxText(text, node) {
+    if (node['type'] !== 'JSXText') {
+        return false;
+    }
+    const range = getAstNodeRange(node);
+    if (range === undefined) {
+        return false;
+    }
+    const raw = text.slice(range.start, range.end);
+    return raw.includes('\n') && /^[ \t\r\n]*$/u.test(raw);
+}
+function getCommentOnlyJsxExpressionContainerComment(text, container, commentsByStart) {
+    const expression = container['expression'];
+    if (container['type'] !== 'JSXExpressionContainer' ||
+        !isRecord(expression) ||
+        expression['type'] !== 'JSXEmptyExpression') {
+        return undefined;
+    }
+    const range = getAstNodeRange(container);
+    if (range === undefined || text[range.start] !== '{' || text[range.end - 1] !== '}') {
+        return undefined;
+    }
+    const commentStart = skipWhitespace(text, range.start + 1);
+    const comment = commentsByStart.get(commentStart);
+    if (comment === undefined || comment.kind !== 'block' || skipWhitespace(text, comment.end) !== range.end - 1) {
+        return undefined;
+    }
+    return comment;
+}
+function isJsxElementOrFragment(node) {
+    return node['type'] === 'JSXElement' || node['type'] === 'JSXFragment';
+}
+function getPrettierIgnoreTargetStart(text, comments, ignoreCommentIndex) {
+    const ignoreComment = comments[ignoreCommentIndex]?.range;
+    if (ignoreComment === undefined) {
+        return undefined;
+    }
+    let cursor = ignoreComment.end;
+    for (let index = ignoreCommentIndex + 1; index < comments.length; index += 1) {
+        cursor = skipWhitespace(text, cursor);
+        const comment = comments[index]?.range;
+        if (comment === undefined || comment.start !== cursor) {
+            break;
+        }
+        if (!isStandaloneComment(text, comment) || !isSkippableCommentBetweenIgnoreAndTarget(text, comment)) {
+            return undefined;
+        }
+        cursor = comment.end;
+    }
+    const targetStart = skipWhitespace(text, cursor);
+    return targetStart >= text.length ? undefined : targetStart;
+}
+function isSkippableCommentBetweenIgnoreAndTarget(text, comment) {
+    if (comment.kind === 'block') {
+        return shouldSkipBlockComment(text, comment);
+    }
+    return shouldSkipLineComment(text, comment) && !isPrettierIgnoreComment(getCommentBody(text, comment));
+}
+function appendMergedRange(ranges, range) {
+    const previousRange = ranges[ranges.length - 1];
+    if (previousRange === undefined || range.start > previousRange.end) {
+        ranges.push(range);
+        return;
+    }
+    previousRange.end = Math.max(previousRange.end, range.end);
+}

package/dist/comments/printer-layout.d.ts

@@ -0,0 +1,18 @@
+import type { CommentEntry } from './comment-ranges.js';
+import type { JsxExpressionContainerRange } from './jsx-expression-layout.js';
+export type PrinterLayoutSource = {
+    ast: unknown;
+    text: string;
+};
+export type PrinterCommentLayout = {
+    lineIndentColumn: number;
+    lineStart: number;
+    lineWidth: number;
+    markerColumn: number;
+    suffixWidth: number;
+};
+export type PrinterLayout = {
+    comments: Array<PrinterCommentLayout | undefined>;
+    jsxCommentMarkerColumns: Array<number | undefined>;
+};
+export declare function getPrinterLayout(text: string, commentEntries: CommentEntry[], jsxExpressionContainers: JsxExpressionContainerRange[], source: PrinterLayoutSource | undefined, tabWidth: number): PrinterLayout;

package/dist/comments/printer-layout.js

@@ -0,0 +1,65 @@
+import { collectCommentEntries } from './comment-ranges.js';
+import { collectJsxExpressionContainerRanges, getPrintedJsxCommentMarkerColumn } from './jsx-expression-layout.js';
+import { getColumns } from '../utils/display-width.js';
+import { getLeadingIndent } from '../utils/indentation.js';
+import { getLineEnd, getLineStart } from '../utils/source-lines.js';
+export function getPrinterLayout(text, commentEntries, jsxExpressionContainers, source, tabWidth) {
+    if (source === undefined) {
+        return {
+            comments: [],
+            jsxCommentMarkerColumns: [],
+        };
+    }
+    const outputCommentEntries = collectCommentEntries(source.ast, source.text);
+    const alignedOutputComments = alignOutputComments(text, commentEntries, source.text, outputCommentEntries);
+    const outputJsxExpressionContainers = collectJsxExpressionContainerRanges(source.ast);
+    const jsxCommentMarkerColumns = outputJsxExpressionContainers.length === jsxExpressionContainers.length
+        ? outputJsxExpressionContainers.map((container) => getPrintedJsxCommentMarkerColumn(source.text, container, tabWidth))
+        : [];
+    return {
+        comments: alignedOutputComments.map((comment) => comment === undefined ? undefined : getPrinterCommentLayout(source.text, comment.range, tabWidth)),
+        jsxCommentMarkerColumns,
+    };
+}
+function alignOutputComments(text, comments, outputText, outputComments) {
+    if (comments.length === outputComments.length &&
+        comments.every((comment, index) => comment.range.kind === outputComments[index]?.range.kind)) {
+        return outputComments;
+    }
+    const alignedComments = [];
+    let outputIndex = 0;
+    for (const comment of comments) {
+        const raw = normalizeCommentForMatching(text.slice(comment.range.start, comment.range.end));
+        let matchingComment;
+        while (outputIndex < outputComments.length) {
+            const candidate = outputComments[outputIndex];
+            outputIndex += 1;
+            if (candidate !== undefined &&
+                candidate.range.kind === comment.range.kind &&
+                normalizeCommentForMatching(outputText.slice(candidate.range.start, candidate.range.end)) === raw) {
+                matchingComment = candidate;
+                break;
+            }
+        }
+        alignedComments.push(matchingComment);
+    }
+    return alignedComments;
+}
+function normalizeCommentForMatching(raw) {
+    return raw.replace(/\r\n?/gu, '\n');
+}
+function getPrinterCommentLayout(text, comment, tabWidth) {
+    const lineStart = getLineStart(text, comment.start);
+    const lineEnd = getLineEnd(text, comment.end);
+    const linePrefix = text.slice(lineStart, comment.start);
+    const lineIndent = getLeadingIndent(linePrefix);
+    const lineText = text.slice(lineStart, lineEnd).replace(/[ \t]+$/u, '');
+    const suffix = text.slice(comment.end, lineEnd).replace(/[ \t]+$/u, '');
+    return {
+        lineIndentColumn: getColumns(lineIndent, tabWidth),
+        lineStart,
+        lineWidth: getColumns(lineText, tabWidth),
+        markerColumn: getColumns(linePrefix, tabWidth),
+        suffixWidth: getColumns(suffix, tabWidth),
+    };
+}

package/dist/comments/{block.d.ts → wrap-block-comment.d.ts}

@@ -1,12 +1,16 @@
-import type { CommentRange, Replacement, WrapOptions } from '../shared/types.js';
+import type { CommentRange } from './comment-ranges.js';
+import type { Replacement } from '../utils/replacements.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
 export type BlockCommentLayout = {
     contentColumn?: number;
     leadingMove?: {
         removeEnd: number;
         removeStart: number;
     };
+    markerColumn?: number;
     multilineIndent?: string;
     placement: 'inline' | 'standalone' | 'trailing';
+    preserveMultiline?: boolean;
     singleLineSuffixWidth?: number;
     trailingMove?: {
         insertAt: number;

package/dist/comments/{block.js → wrap-block-comment.js}

@@ -1,18 +1,18 @@
-import { hasPreserveCommentMarker, isDirectiveComment, normalizeBlockCommentBody } from './core.js';
-import { formatMarkdownLines } from '../shared/markdown.js';
-import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../shared/options.js';
-import { getColumnAt, getColumns, getLinePrefix, getPreferredNewline, isStandaloneBlockComment, } from '../shared/text.js';
+import { normalizeBlockCommentBody } from './comment-body.js';
+import { shouldSkipBlockComment } from './comment-eligibility.js';
+import { isStandaloneBlockComment } from './comment-location.js';
+import { getColumnAt, getColumns } from '../utils/display-width.js';
+import { formatMarkdownLines } from '../utils/format-markdown.js';
+import { getLinePrefix, getPreferredNewline } from '../utils/source-lines.js';
+import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../utils/wrap-options.js';
 export async function wrapBlockComment(text, comment, options, layout = getDefaultBlockCommentLayout(text, comment)) {
-    const raw = text.slice(comment.start, comment.end);
-    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
+    if (shouldSkipBlockComment(text, comment)) {
         return undefined;
     }
+    const raw = text.slice(comment.start, comment.end);
     const markdown = normalizeBlockCommentBody(raw);
-    if (markdown.trim() === '' || isDirectiveComment(markdown)) {
-        return undefined;
-    }
     const tabWidth = getTabWidth(options);
-    const markerColumn = getColumnAt(text, comment.start, tabWidth);
+    const markerColumn = layout.markerColumn ?? getColumnAt(text, comment.start, tabWidth);
     const availableWidth = getAvailableContentWidth(options, layout.contentColumn ?? markerColumn + 3);
     const formattedLines = await formatMarkdownLines(markdown, availableWidth, options);
     const replacement = buildBlockReplacement(text, comment, formattedLines, options, layout);
@@ -33,11 +33,13 @@ export async function wrapBlockComment(text, comment, options, layout = getDefau
 }
 function buildBlockReplacement(text, comment, formattedLines, options, layout) {
     const tabWidth = getTabWidth(options);
-    const markerColumn = getColumnAt(text, comment.start, tabWidth);
+    const markerColumn = layout.markerColumn ?? getColumnAt(text, comment.start, tabWidth);
     const singleLine = `/* ${formattedLines.join(' ')} */`;
     const singleLineWidth = getColumns(singleLine, tabWidth);
     const singleLineSuffixWidth = layout.singleLineSuffixWidth ?? 0;
-    if (formattedLines.length === 1 && markerColumn + singleLineWidth + singleLineSuffixWidth <= getPrintWidth(options)) {
+    if (layout.preserveMultiline !== true &&
+        formattedLines.length === 1 &&
+        markerColumn + singleLineWidth + singleLineSuffixWidth <= getPrintWidth(options)) {
         return singleLine;
     }
     if (layout.placement === 'inline') {
@@ -46,12 +48,13 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
     const newline = getPreferredNewline(text, options);
     const indent = layout.multilineIndent ?? getLinePrefix(text, comment.start);
     const replacementText = buildMultilineBlockReplacement(formattedLines, newline, indent);
+    const replacementTextWithNewline = [replacementText, ''].join(newline);
     if (layout.trailingMove !== undefined) {
         return [
             {
                 end: layout.trailingMove.insertAt,
                 start: layout.trailingMove.insertAt,
-                text: `${replacementText}${newline}`,
+                text: replacementTextWithNewline,
             },
             {
                 end: layout.trailingMove.removeEnd,
@@ -65,7 +68,7 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
             {
                 end: comment.end,
                 start: comment.start,
-                text: `${replacementText}${newline}`,
+                text: replacementTextWithNewline,
             },
             {
                 end: layout.leadingMove.removeEnd,
@@ -78,7 +81,7 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
 }
 function buildMultilineBlockReplacement(formattedLines, newline, indent) {
     const body = formattedLines.map((line) => `${indent} *${line.length === 0 ? '' : ` ${line}`}`).join(newline);
-    return `/*${newline}${body}${newline}${indent} */`;
+    return ['/*', body, `${indent} */`].join(newline);
 }
 function getDefaultBlockCommentLayout(text, comment) {
     return {

package/dist/comments/wrap-comments.d.ts

@@ -0,0 +1,9 @@
+import type { PrinterLayoutSource } from './printer-layout.js';
+import type { JsxBlockCommentRewrite } from '../plugin/jsx-comment-rewrite-metadata.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
+export type WrapCommentsResult = {
+    jsxBlockCommentRewrites: JsxBlockCommentRewrite[];
+    text: string;
+};
+export declare function wrapComments<T>(text: string, ast: T, options: WrapOptions, printerLayoutSource?: PrinterLayoutSource): Promise<string>;
+export declare function wrapCommentsWithMetadata<T>(text: string, ast: T, options: WrapOptions, printerLayoutSource?: PrinterLayoutSource): Promise<WrapCommentsResult>;