@aforemendude/prettier-plugin-wrap-comments 1.0.3 → 1.0.4

package/README.md

@@ -77,14 +77,53 @@ if (ready) {
 }
 ```
 
+JSX and TSX expression comments use the expression contents, not the outer React expression braces, to decide whether a
+block comment is standalone, trailing, or inline. A comment-only expression like `{/* ... */}` can wrap as a standalone
+JSX comment. A trailing expression comment like `{label /* ... */}` can move before `label` and wrap. A true inline
+expression comment like `{"abc" + /* ... */ "123"}` is left unchanged when it cannot fit on one line.
+
+<!-- prettier-ignore-start -->
+```tsx
+<span>
+  {
+    /*
+     * This expression comment wraps because the surrounding JSX braces do not
+     * make it inline.
+     */
+  }
+  {
+    /*
+     * This expression comment moved above the expression value because it was
+     * trailing.
+     */
+    label
+  }
+  {'abc' + /* This inline expression comment stays in place. */ '123'}
+</span>
+```
+<!-- prettier-ignore-end -->
+
+`prettier-ignore` markers are preserved and affect wrapping only when the marker body is exactly `prettier-ignore`. When
+one of these markers is directly above a standalone block comment, the plugin leaves that block comment unchanged. If
+the block comment is one the plugin would otherwise wrap, the following code still formats normally; if the block
+comment is already skipped by the plugin, such as a JSDoc or directive block, Prettier keeps its normal ignore behavior
+for the following code.
+
+For trailing line comments, a `// prettier-ignore` line can apply to the code line and its inline comment. The plugin
+walks past adjacent standalone comments that it normally leaves alone, such as an `eslint-disable-next-line` directive,
+so an ignored code line's trailing comment remains inline and unchanged. A directive comment by itself does not ignore
+the following code line; without `// prettier-ignore`, an overlong trailing comment below a directive is still moved
+above the statement and wrapped.
+
 The plugin leaves these comments unchanged:
 
 - JSDoc comments that start with `/**`
 - bang-preserved comments that start with `/*!` or `//!`
 - TypeScript-style triple-slash line comments that start with `///`
 - empty comment bodies
-- directive comments such as `@license`, `@preserve`, JSX and TypeScript pragmas, source map directives, `#__PURE__`,
-  `@__PURE__`, lint/coverage/formatter directives, `vite-ignore`, and webpack magic comments
+- `prettier-ignore` markers themselves
+- other directive comments such as `@license`, `@preserve`, JSX and TypeScript pragmas, source map directives,
+  `#__PURE__`, `@__PURE__`, lint/coverage/formatter directives, `vite-ignore`, and webpack magic comments
 
 ## Supported Parsers
 

package/dist/comments/block.d.ts

@@ -1,2 +1,12 @@
 import type { CommentRange, Replacement, WrapOptions } from '../shared/types.js';
-export declare function wrapBlockComment(text: string, comment: CommentRange, options: WrapOptions): Promise<Replacement | undefined>;
+export type BlockCommentLayout = {
+    contentColumn?: number;
+    multilineIndent?: string;
+    placement: 'inline' | 'standalone' | 'trailing';
+    trailingMove?: {
+        insertAt: number;
+        removeEnd: number;
+        removeStart: number;
+    };
+};
+export declare function wrapBlockComment(text: string, comment: CommentRange, options: WrapOptions, layout?: BlockCommentLayout): Promise<Replacement | Replacement[] | undefined>;

package/dist/comments/block.js

@@ -2,7 +2,7 @@ import { hasPreserveCommentMarker, isDirectiveComment, normalizeBlockCommentBody
 import { formatMarkdownLines } from '../shared/markdown.js';
 import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../shared/options.js';
 import { getColumnAt, getColumns, getLinePrefix, getPreferredNewline, isStandaloneBlockComment, } from '../shared/text.js';
-export async function wrapBlockComment(text, comment, options) {
+export async function wrapBlockComment(text, comment, options, layout = getDefaultBlockCommentLayout(text, comment)) {
     const raw = text.slice(comment.start, comment.end);
     if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
         return undefined;
@@ -13,19 +13,25 @@ export async function wrapBlockComment(text, comment, options) {
     }
     const tabWidth = getTabWidth(options);
     const markerColumn = getColumnAt(text, comment.start, tabWidth);
-    const availableWidth = getAvailableContentWidth(options, markerColumn + 3);
+    const availableWidth = getAvailableContentWidth(options, layout.contentColumn ?? markerColumn + 3);
     const formattedLines = await formatMarkdownLines(markdown, availableWidth, options);
-    const replacementText = buildBlockReplacement(text, comment, formattedLines, options);
-    if (replacementText === undefined || replacementText === text.slice(comment.start, comment.end)) {
+    const replacement = buildBlockReplacement(text, comment, formattedLines, options, layout);
+    if (replacement === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(replacement)) {
+        return replacement;
+    }
+    if (replacement === text.slice(comment.start, comment.end)) {
         return undefined;
     }
     return {
         end: comment.end,
         start: comment.start,
-        text: replacementText,
+        text: replacement,
     };
 }
-function buildBlockReplacement(text, comment, formattedLines, options) {
+function buildBlockReplacement(text, comment, formattedLines, options, layout) {
     const tabWidth = getTabWidth(options);
     const markerColumn = getColumnAt(text, comment.start, tabWidth);
     const singleLine = `/* ${formattedLines.join(' ')} */`;
@@ -33,11 +39,34 @@ function buildBlockReplacement(text, comment, formattedLines, options) {
     if (formattedLines.length === 1 && markerColumn + singleLineWidth <= getPrintWidth(options)) {
         return singleLine;
     }
-    if (!isStandaloneBlockComment(text, comment)) {
+    if (layout.placement === 'inline') {
         return undefined;
     }
     const newline = getPreferredNewline(text, options);
-    const indent = getLinePrefix(text, comment.start);
+    const indent = layout.multilineIndent ?? getLinePrefix(text, comment.start);
+    const replacementText = buildMultilineBlockReplacement(formattedLines, newline, indent);
+    if (layout.trailingMove !== undefined) {
+        return [
+            {
+                end: layout.trailingMove.insertAt,
+                start: layout.trailingMove.insertAt,
+                text: `${replacementText}${newline}`,
+            },
+            {
+                end: layout.trailingMove.removeEnd,
+                start: layout.trailingMove.removeStart,
+                text: '',
+            },
+        ];
+    }
+    return replacementText;
+}
+function buildMultilineBlockReplacement(formattedLines, newline, indent) {
     const body = formattedLines.map((line) => `${indent} *${line.length === 0 ? '' : ` ${line}`}`).join(newline);
     return `/*${newline}${body}${newline}${indent} */`;
 }
+function getDefaultBlockCommentLayout(text, comment) {
+    return {
+        placement: isStandaloneBlockComment(text, comment) ? 'standalone' : 'inline',
+    };
+}

package/dist/comments/core.d.ts

@@ -4,4 +4,5 @@ export declare function toCommentRange(comment: RawComment, text: string): Comme
 export declare function normalizeLineCommentBody(rawBody: string): string;
 export declare function normalizeBlockCommentBody(rawComment: string): string;
 export declare function isDirectiveComment(body: string): boolean;
+export declare function isPrettierIgnoreComment(body: string): boolean;
 export declare function hasPreserveCommentMarker(rawComment: string): boolean;

package/dist/comments/core.js

@@ -108,6 +108,9 @@ export function isDirectiveComment(body) {
     const normalizedBody = body.trimStart();
     return DIRECTIVE_COMMENT_PATTERNS.some((pattern) => pattern.test(normalizedBody));
 }
+export function isPrettierIgnoreComment(body) {
+    return body.trim() === 'prettier-ignore';
+}
 export function hasPreserveCommentMarker(rawComment) {
     return rawComment.startsWith('/*!') || rawComment.startsWith('//!');
 }

package/dist/comments/line.d.ts

@@ -1,6 +1,6 @@
 import type { CommentRange, Replacement, WrapOptions } from '../shared/types.js';
 export declare function wrapLineCommentGroup(text: string, comments: CommentRange[], options: WrapOptions): Promise<Replacement | undefined>;
-export declare function wrapTrailingLineComment(text: string, comment: CommentRange, options: WrapOptions): Promise<Replacement | undefined>;
+export declare function wrapTrailingLineComment(text: string, comment: CommentRange, options: WrapOptions): Promise<Replacement[] | undefined>;
 export declare function shouldSkipLineComment(text: string, comment: CommentRange): boolean;
 export declare function isStandaloneLineComment(text: string, comment: CommentRange): boolean;
 export declare function areAdjacentLineComments(text: string, previous: CommentRange, next: CommentRange): boolean;

package/dist/comments/line.js

@@ -1,7 +1,7 @@
 import { hasPreserveCommentMarker, isDirectiveComment, normalizeLineCommentBody } from './core.js';
 import { formatMarkdownLines } from '../shared/markdown.js';
 import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../shared/options.js';
-import { getColumnAt, getColumns, getContinuationIndent, getLineEnd, getLinePrefix, getLineStart, getPreferredNewline, } from '../shared/text.js';
+import { getColumnAt, getColumns, getContinuationIndent, getLineEnd, getLinePrefix, getLineStart, getPreferredNewline, makeIndent, } from '../shared/text.js';
 export async function wrapLineCommentGroup(text, comments, options) {
     const firstComment = comments[0];
     if (firstComment === undefined) {
@@ -51,19 +51,26 @@ export async function wrapTrailingLineComment(text, comment, options) {
         return undefined;
     }
     const tabWidth = getTabWidth(options);
-    const indent = getLineIndent(linePrefix);
+    const indent = getTrailingCommentIndent(codeText, linePrefix, options);
     const availableWidth = getAvailableContentWidth(options, getColumns(indent, tabWidth) + 3);
     const formattedLines = await formatMarkdownLines(body, availableWidth, options);
     const newline = getPreferredNewline(text, options);
     const leadingCommentText = formattedLines
         .map((line) => `${indent}${line.length === 0 ? '//' : `// ${line}`}`)
         .join(newline);
-    const replacementText = `${leadingCommentText}${newline}${codeText}`;
-    return {
-        end: lineEnd,
-        start: lineStart,
-        text: replacementText,
-    };
+    const codeEnd = lineStart + codeText.length;
+    return [
+        {
+            end: lineStart,
+            start: lineStart,
+            text: `${leadingCommentText}${newline}`,
+        },
+        {
+            end: lineEnd,
+            start: codeEnd,
+            text: '',
+        },
+    ];
 }
 export function shouldSkipLineComment(text, comment) {
     const raw = text.slice(comment.start, comment.end);
@@ -88,3 +95,14 @@ function isTrailingLineCommentWithinPrintWidth(text, comment, options) {
 function getLineIndent(linePrefix) {
     return /^[ \t]*/u.exec(linePrefix)?.[0] ?? '';
 }
+function getTrailingCommentIndent(codeText, linePrefix, options) {
+    const indent = getLineIndent(linePrefix);
+    if (!isClosingDelimiterLine(codeText)) {
+        return indent;
+    }
+    const tabWidth = getTabWidth(options);
+    return makeIndent(getColumns(indent, tabWidth) + tabWidth, options);
+}
+function isClosingDelimiterLine(codeText) {
+    return /^[ \t]*[\])}]+[\])};,]*[ \t]*$/u.test(codeText);
+}

package/dist/comments/wrap.d.ts

@@ -1,2 +1,3 @@
 import type { WrapOptions } from '../shared/types.js';
 export declare function wrapComments<T>(text: string, ast: T, options: WrapOptions): Promise<string>;
+export declare function neutralizePrettierIgnoreForIgnoredBlockComments<T>(text: string, ast: T): T;

package/dist/comments/wrap.js

@@ -1,13 +1,25 @@
 import { wrapBlockComment } from './block.js';
-import { collectComments, toCommentRange } from './core.js';
+import { collectComments, hasPreserveCommentMarker, isDirectiveComment, isPrettierIgnoreComment, normalizeBlockCommentBody, normalizeLineCommentBody, toCommentRange, } from './core.js';
 import { areAdjacentLineComments, isStandaloneLineComment, shouldSkipLineComment, wrapLineCommentGroup, wrapTrailingLineComment, } from './line.js';
 import { getTabWidth } from '../shared/options.js';
-import { applyReplacements, getColumnAt } from '../shared/text.js';
+import { applyReplacements, getColumnAt, getColumns, getLineEnd, getLinePrefix, getLineStart, isStandaloneBlockComment, } from '../shared/text.js';
+const NEUTRALIZED_PRETTIER_IGNORE_COMMENT = 'prettier-ignore wrap-comments';
+const AST_TRAVERSAL_SKIP_KEYS = new Set([
+    'comments',
+    'errors',
+    'innerComments',
+    'leadingComments',
+    'loc',
+    'parent',
+    'range',
+    'tokens',
+    'trailingComments',
+]);
 export async function wrapComments(text, ast, options) {
-    const comments = collectComments(ast)
-        .map((comment) => toCommentRange(comment, text))
-        .filter((comment) => comment !== undefined)
-        .sort((left, right) => left.start - right.start);
+    const commentEntries = collectSortedCommentEntries(ast, text);
+    const comments = commentEntries.map((entry) => entry.range);
+    const jsxExpressionContainers = collectJsxExpressionContainerRanges(ast);
+    const ignoredLineRanges = collectPrettierIgnoredLineRanges(text, ast, commentEntries);
     if (comments.length === 0) {
         return text;
     }
@@ -18,9 +30,22 @@ export async function wrapComments(text, ast, options) {
         if (comment === undefined) {
             continue;
         }
+        if (isCommentInIgnoredLineRange(comment, ignoredLineRanges)) {
+            continue;
+        }
         if (comment.kind === 'block') {
-            const replacement = await wrapBlockComment(text, comment, options);
-            if (replacement !== undefined) {
+            if (isPrettierIgnoredBlockComment(text, commentEntries, index)) {
+                continue;
+            }
+            const jsxLayout = getJsxExpressionBlockCommentLayout(text, comment, jsxExpressionContainers, tabWidth);
+            if (jsxLayout?.placement === 'inline') {
+                continue;
+            }
+            const replacement = await wrapBlockComment(text, comment, options, jsxLayout);
+            if (Array.isArray(replacement)) {
+                replacements.push(...replacement);
+            }
+            else if (replacement !== undefined) {
                 replacements.push(replacement);
             }
             continue;
@@ -29,9 +54,12 @@ export async function wrapComments(text, ast, options) {
             continue;
         }
         if (!isStandaloneLineComment(text, comment)) {
+            if (isPrettierIgnoredTrailingLineComment(text, commentEntries, index)) {
+                continue;
+            }
             const replacement = await wrapTrailingLineComment(text, comment, options);
             if (replacement !== undefined) {
-                replacements.push(replacement);
+                replacements.push(...replacement);
             }
             continue;
         }
@@ -60,3 +88,289 @@ export async function wrapComments(text, ast, options) {
     }
     return applyReplacements(text, replacements);
 }
+export function neutralizePrettierIgnoreForIgnoredBlockComments(text, ast) {
+    const comments = collectSortedCommentEntries(ast, text);
+    for (let index = 0; index < comments.length; index += 1) {
+        const entry = comments[index];
+        const previousEntry = comments[index - 1];
+        if (entry !== undefined &&
+            previousEntry !== undefined &&
+            isPrettierIgnoredBlockComment(text, comments, index) &&
+            !isBlockCommentNormallyIgnored(text, entry.range)) {
+            previousEntry.raw.value = NEUTRALIZED_PRETTIER_IGNORE_COMMENT;
+        }
+    }
+    return ast;
+}
+function collectSortedCommentEntries(ast, text) {
+    return collectComments(ast)
+        .map((raw) => ({ range: toCommentRange(raw, text), raw }))
+        .filter((entry) => entry.range !== undefined)
+        .sort((left, right) => left.range.start - right.range.start);
+}
+function collectPrettierIgnoredLineRanges(text, ast, comments) {
+    const nodeRanges = collectAstNodeRanges(ast);
+    const ignoredLineRanges = [];
+    for (let index = 0; index < comments.length; index += 1) {
+        const comment = comments[index]?.range;
+        if (comment === undefined ||
+            comment.kind !== 'line' ||
+            !isStandaloneLineComment(text, comment) ||
+            !isPrettierIgnoreComment(getCommentBody(text, comment))) {
+            continue;
+        }
+        const targetStart = getPrettierIgnoreTargetStart(text, comments, index);
+        if (targetStart === undefined) {
+            continue;
+        }
+        const targetRange = nodeRanges.find((range) => range.start === targetStart);
+        if (targetRange === undefined) {
+            continue;
+        }
+        ignoredLineRanges.push({
+            end: getLineEnd(text, targetRange.end),
+            start: getLineStart(text, targetRange.start),
+        });
+    }
+    return ignoredLineRanges;
+}
+function collectAstNodeRanges(ast) {
+    const ranges = [];
+    const seen = new Set();
+    visit(ast);
+    return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
+    function visit(value) {
+        if (!isRecord(value) || seen.has(value)) {
+            return;
+        }
+        seen.add(value);
+        const range = getAstNodeRange(value);
+        if (range !== undefined && typeof value['type'] === 'string') {
+            ranges.push(range);
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (AST_TRAVERSAL_SKIP_KEYS.has(key)) {
+                continue;
+            }
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    visit(item);
+                }
+            }
+            else {
+                visit(child);
+            }
+        }
+    }
+}
+function collectJsxExpressionContainerRanges(ast) {
+    const ranges = [];
+    const seen = new Set();
+    visit(ast);
+    return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
+    function visit(value) {
+        if (!isRecord(value) || seen.has(value)) {
+            return;
+        }
+        seen.add(value);
+        if (value['type'] === 'JSXExpressionContainer') {
+            const range = getAstNodeRange(value);
+            if (range !== undefined) {
+                ranges.push(range);
+            }
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (AST_TRAVERSAL_SKIP_KEYS.has(key)) {
+                continue;
+            }
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    visit(item);
+                }
+            }
+            else {
+                visit(child);
+            }
+        }
+    }
+}
+function getAstNodeRange(node) {
+    const start = numberOrUndefined(node['start']) ?? getRangeNumber(node['range'], 0);
+    const end = numberOrUndefined(node['end']) ?? getRangeNumber(node['range'], 1);
+    if (start === undefined || end === undefined || start >= end) {
+        return undefined;
+    }
+    return { end, start };
+}
+function getRangeNumber(range, index) {
+    if (!Array.isArray(range)) {
+        return undefined;
+    }
+    return numberOrUndefined(range[index]);
+}
+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) || !isCommentNormallyIgnored(text, comment)) {
+            return undefined;
+        }
+        cursor = comment.end;
+    }
+    const targetStart = skipWhitespace(text, cursor);
+    return targetStart >= text.length ? undefined : targetStart;
+}
+function skipWhitespace(text, index) {
+    let cursor = index;
+    while (cursor < text.length) {
+        const character = text[cursor];
+        if (character === undefined || !/\s/u.test(character)) {
+            break;
+        }
+        cursor += 1;
+    }
+    return cursor;
+}
+function isCommentInIgnoredLineRange(comment, ignoredLineRanges) {
+    return ignoredLineRanges.some((range) => comment.start >= range.start && comment.start < range.end);
+}
+function getJsxExpressionBlockCommentLayout(text, comment, jsxExpressionContainers, tabWidth) {
+    const container = getSmallestContainingRange(comment, jsxExpressionContainers);
+    if (container === undefined || text[container.start] !== '{' || text[container.end - 1] !== '}') {
+        return undefined;
+    }
+    const expressionTextBeforeComment = text.slice(container.start + 1, comment.start).trim();
+    const expressionTextAfterComment = text.slice(comment.end, container.end - 1).trim();
+    const containerOutputColumn = getJsxExpressionContainerOutputColumn(text, container, tabWidth);
+    if (expressionTextBeforeComment === '' && expressionTextAfterComment === '') {
+        return { contentColumn: containerOutputColumn + tabWidth + 3, multilineIndent: '', placement: 'standalone' };
+    }
+    if (expressionTextBeforeComment !== '' && expressionTextAfterComment === '') {
+        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: containerOutputColumn + tabWidth + 3,
+            multilineIndent: '',
+            placement: 'trailing',
+            trailingMove: {
+                insertAt: expressionStart,
+                removeEnd: removalEnd,
+                removeStart: expressionEnd,
+            },
+        };
+    }
+    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 = /^[ \t]*/u.exec(linePrefix)?.[0] ?? '';
+    return getColumns(lineIndent, tabWidth) + tabWidth;
+}
+function trimWhitespaceEnd(text, start, end) {
+    let cursor = end;
+    while (cursor > start) {
+        const character = text[cursor - 1];
+        if (character === undefined || !/\s/u.test(character)) {
+            break;
+        }
+        cursor -= 1;
+    }
+    return cursor;
+}
+function getSmallestContainingRange(comment, ranges) {
+    let containingRange;
+    for (const range of ranges) {
+        if (comment.start <= range.start || comment.end >= range.end) {
+            continue;
+        }
+        if (containingRange === undefined || range.end - range.start < containingRange.end - containingRange.start) {
+            containingRange = range;
+        }
+    }
+    return containingRange;
+}
+function isPrettierIgnoredBlockComment(text, comments, index) {
+    const comment = comments[index]?.range;
+    const previousComment = comments[index - 1]?.range;
+    if (comment === undefined || comment.kind !== 'block' || previousComment === undefined) {
+        return false;
+    }
+    if (!isStandaloneComment(text, previousComment) || !isAdjacentPreviousComment(text, previousComment, comment)) {
+        return false;
+    }
+    return isPrettierIgnoreComment(getCommentBody(text, previousComment));
+}
+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 (!isAdjacentCommentBeforeIndex(text, previousComment, cursor)) {
+            return false;
+        }
+        const body = getCommentBody(text, previousComment);
+        if (previousComment.kind === 'line' && isPrettierIgnoreComment(body)) {
+            return true;
+        }
+        if (!isCommentNormallyIgnored(text, previousComment)) {
+            return false;
+        }
+        cursor = getLineStart(text, previousComment.start);
+    }
+    return false;
+}
+function isCommentNormallyIgnored(text, comment) {
+    if (comment.kind === 'line') {
+        const raw = text.slice(comment.start, comment.end);
+        return shouldSkipLineComment(text, comment) && !isPrettierIgnoreComment(normalizeLineCommentBody(raw.slice(2)));
+    }
+    return isBlockCommentNormallyIgnored(text, comment);
+}
+function isBlockCommentNormallyIgnored(text, comment) {
+    const raw = text.slice(comment.start, comment.end);
+    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
+        return true;
+    }
+    const body = normalizeBlockCommentBody(raw);
+    return body.trim() === '' || isDirectiveComment(body);
+}
+function isStandaloneComment(text, comment) {
+    return comment.kind === 'line' ? isStandaloneLineComment(text, comment) : isStandaloneBlockComment(text, comment);
+}
+function isAdjacentPreviousComment(text, previousComment, comment) {
+    return /^(?:\r\n|\n|\r)[ \t]*$/u.test(text.slice(previousComment.end, comment.start));
+}
+function isAdjacentCommentBeforeIndex(text, comment, index) {
+    return /^(?:\r\n|\n|\r)[ \t]*$/u.test(text.slice(comment.end, index));
+}
+function getCommentBody(text, comment) {
+    const raw = text.slice(comment.start, comment.end);
+    return comment.kind === 'line' ? normalizeLineCommentBody(raw.slice(2)) : normalizeBlockCommentBody(raw);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function numberOrUndefined(value) {
+    return typeof value === 'number' ? value : undefined;
+}

package/dist/index.d.ts

@@ -3,9 +3,8 @@ declare const parsers: {
     [parserName: string]: import("prettier").Parser<any>;
 } | undefined;
 declare const printers: {
-    estree: import("prettier").Printer;
-    "estree-json": import("prettier").Printer;
-};
+    [astFormat: string]: import("prettier").Printer<any>;
+} | undefined;
 declare const plugin: Plugin;
 export { parsers, printers };
 export default plugin;

package/dist/index.js

@@ -1,7 +1,7 @@
-import * as estreePlugin from 'prettier/plugins/estree';
 import { buildParsers } from './plugin/parsers.js';
+import { buildPrinters } from './plugin/printers.js';
 const parsers = buildParsers();
-const printers = estreePlugin.printers;
+const printers = buildPrinters();
 const plugin = {
     parsers,
     printers,

package/dist/plugin/parsers.js

@@ -1,10 +1,14 @@
 import * as babelPlugin from 'prettier/plugins/babel';
 import * as typescriptPlugin from 'prettier/plugins/typescript';
-import { wrapComments } from '../comments/wrap.js';
+import { neutralizePrettierIgnoreForIgnoredBlockComments, wrapComments } from '../comments/wrap.js';
 const parserNames = ['babel', 'babel-ts', 'typescript'];
 function wrapParser(parser) {
     return {
         ...parser,
+        async parse(text, options) {
+            const ast = await parser.parse(text, options);
+            return neutralizePrettierIgnoreForIgnoredBlockComments(text, ast);
+        },
         async preprocess(text, options) {
             const preprocessed = parser.preprocess === undefined ? text : await parser.preprocess(text, options);
             let ast;

package/dist/plugin/printers.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'prettier';
+export declare function buildPrinters(): Plugin['printers'];

package/dist/plugin/printers.js

@@ -0,0 +1,39 @@
+import { doc } from 'prettier';
+import * as estreePlugin from 'prettier/plugins/estree';
+const { hardline, indent } = doc.builders;
+export function buildPrinters() {
+    const estreePrinter = estreePlugin.printers.estree;
+    return {
+        ...estreePlugin.printers,
+        estree: {
+            ...estreePrinter,
+            print(path, options, print, args) {
+                if (isMultilineEmptyJsxExpressionBlockComment(path.node)) {
+                    return ['{', indent([hardline, path.call(print, 'expression')]), hardline, '}'];
+                }
+                return estreePrinter.print(path, options, print, args);
+            },
+        },
+    };
+}
+function isMultilineEmptyJsxExpressionBlockComment(node) {
+    if (!isRecord(node) || node['type'] !== 'JSXExpressionContainer') {
+        return false;
+    }
+    const expression = node['expression'];
+    if (!isRecord(expression) || expression['type'] !== 'JSXEmptyExpression') {
+        return false;
+    }
+    const comments = expression['comments'];
+    return Array.isArray(comments) && comments.some(isMultilineBlockComment);
+}
+function isMultilineBlockComment(comment) {
+    if (!isRecord(comment) || (comment['type'] !== 'Block' && comment['type'] !== 'CommentBlock')) {
+        return false;
+    }
+    const value = comment['value'];
+    return typeof value === 'string' && value.includes('\n');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/shared/text.d.ts

@@ -12,3 +12,4 @@ export declare function isStandaloneBlockComment(text: string, comment: {
     start: number;
 }): boolean;
 export declare function trimBlankEdges(markdown: string): string;
+export declare function makeIndent(column: number, options: WrapOptions): string;

package/dist/shared/text.js

@@ -11,13 +11,16 @@ function getNonOverlappingReplacements(replacements) {
         .sort((left, right) => left.start - right.start || right.end - left.end)
         .reduce((accepted, replacement) => {
         const previous = accepted.at(-1);
-        if (previous === undefined || previous.end <= replacement.start) {
+        if (previous === undefined || !rangesOverlap(previous, replacement)) {
             accepted.push(replacement);
             return accepted;
         }
         return accepted;
     }, []);
 }
+function rangesOverlap(left, right) {
+    return left.start < right.end && right.start < left.end;
+}
 export function getPreferredNewline(text, options) {
     if (options.endOfLine === 'crlf') {
         return '\r\n';
@@ -85,7 +88,7 @@ export function trimBlankEdges(markdown) {
 function isBlankLine(line) {
     return line !== undefined && line.trim() === '';
 }
-function makeIndent(column, options) {
+export function makeIndent(column, options) {
     const tabWidth = getTabWidth(options);
     if (options.useTabs === true) {
         const tabs = Math.floor(column / tabWidth);

package/package.json

@@ -51,5 +51,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.3"
+  "version": "1.0.4"
 }