@aforemendude/prettier-plugin-wrap-comments 1.1.0 → 1.2.0

package/README.md

@@ -5,7 +5,8 @@ real column to calculate the available content width, so nested comments wrap mo
 
 ## Requirements
 
-- Node.js 20 or newer
+- Node.js 20 or newer to use the plugin
+- Node.js 22.12 or newer to develop the plugin
 - Prettier 3 (`>=3.0.0 <4.0.0`)
 
 ## Install
@@ -30,12 +31,52 @@ Then run Prettier normally:
 npx prettier --write .
 ```
 
+### Use With `prettier-plugin-jsdoc`
+
+When using both plugins, `@aforemendude/prettier-plugin-wrap-comments` must be loaded after `prettier-plugin-jsdoc`:
+
+```json
+{
+  "plugins": ["prettier-plugin-jsdoc", "@aforemendude/prettier-plugin-wrap-comments"]
+}
+```
+
+This order is required regardless of `prettier-plugin-jsdoc`'s documentation saying that it should be the last plugin.
+With wrap-comments last, ordinary comments are handled here and parsing is delegated to the preceding JSDoc plugin, so
+JSDoc comments are formatted as well.
+
+### Cache Repeated CLI Runs
+
+Prettier's CLI cache skips files that have not changed since a successful formatting pass. Enable it in package scripts
+so contributors use it consistently. This repository uses the faster `metadata` strategy for local formatting:
+
+```json
+{
+  "scripts": {
+    "format": "prettier --write --cache --cache-strategy metadata .",
+    "format:check": "prettier --check --cache --cache-strategy metadata .",
+    "format:nocache": "prettier --write ."
+  }
+}
+```
+
+The first cached run still processes every file; later runs skip files whose relevant metadata and other cache keys have
+not changed. Omit `--cache-strategy metadata` to use the default `content` strategy when workflows such as Git
+operations frequently change timestamps without changing file contents.
+
+By default, Prettier stores the cache under `node_modules/.cache/prettier/`, which is normally excluded from version
+control with `node_modules`. Prettier does not include plugin versions or implementations in its cache keys, so run the
+uncached command once after updating this plugin or another Prettier plugin. Running Prettier without `--cache`, as the
+`format:nocache` script does, also removes the default cache. See [Prettier's CLI cache documentation][prettier-cache]
+for cache keys, strategies, and custom cache locations.
+
 ## Behavior
 
 The plugin wraps comments for Prettier's `babel`, `babel-ts`, and `typescript` parsers. It runs during parser
-preprocessing: the underlying Prettier parser preprocesses and parses the source first, the plugin rewrites eligible
-comments from that parsed comment list, and Prettier then formats the rewritten source with its built-in JavaScript and
-TypeScript printers. If the parser cannot parse the preprocessed source, the plugin leaves the source unchanged.
+preprocessing: the nearest preceding plugin for the selected parser, or Prettier's built-in parser when there is none,
+preprocesses and parses the source first. This plugin rewrites eligible comments from that parsed comment list, and
+Prettier then formats the rewritten source with its built-in JavaScript and TypeScript printers. If the parser cannot
+parse the preprocessed source, the plugin leaves the source unchanged.
 
 Offset-sensitive formatting is conservative. Full-file `formatWithCursor` calls skip comment rewriting so Prettier can
 map the cursor from the original source. During range formatting, preprocessing does not rewrite text outside Prettier's
@@ -148,10 +189,13 @@ 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 `///`
+- Flow type annotations and includes that start with `/*:`, `/*::`, or `/*flow-include`, including Flow's supported
+  spaces or tabs before the marker
 - empty comment bodies
 - `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
+- other directive comments such as `@license`, `@preserve`, JSX, TypeScript, and Flow pragmas, Flow error suppressions,
+  `flowlint` comments, source map directives, `#__PURE__`, `@__PURE__`, exact Node test coverage controls, other
+  lint/coverage/formatter directives, `vite-ignore`, and webpack magic comments
 
 ## Supported Parsers
 
@@ -159,6 +203,28 @@ The plugin leaves these comments unchanged:
 - `babel-ts`
 - `typescript`
 
+## Performance
+
+`npm run benchmark` compares uncached, in-memory `prettier.format()` calls with and without the plugin across five
+generated files. Lower times are better. The plugin/plain column divides the plugin mean by the plain Prettier mean.
+
+These results are from a representative run on August 8, 2026, using Linux 6.8, an Intel Core i7-10750H, Node.js
+24.18.0, Prettier 3.9.6, and Vitest 4.1.10. The suite was configured with `time: 500`, `iterations: 10`,
+`warmupTime: 100`, and `warmupIterations: 2` for each case.
+
+| Generated workload                         | Characters | Plain Prettier mean |        Plugin mean | Plugin/plain |
+| ------------------------------------------ | ---------: | ------------------: | -----------------: | -----------: |
+| Comment-free JavaScript                    |     29,995 |  54.78 ms (±10.09%) |  45.59 ms (±5.82%) |        0.83× |
+| Code-heavy JavaScript with sparse comments |     30,494 |   44.05 ms (±3.22%) | 135.66 ms (±3.81%) |        3.08× |
+| Comment-heavy TypeScript                   |     64,432 |  56.75 ms (±11.82%) | 327.61 ms (±2.67%) |        5.77× |
+| Preformatted comment-heavy TypeScript      |     54,467 |   54.54 ms (±2.47%) | 279.65 ms (±2.50%) |        5.13× |
+| JSX-comment-heavy TSX                      |     40,575 |   57.52 ms (±6.87%) | 263.67 ms (±3.83%) |        4.58× |
+
+The comment-free case takes the plugin's early exit after scanning for comment delimiters. Its apparent speedup should
+be treated as benchmark variation, not as an expected optimization over plain Prettier. In this run, sparse comments
+took about 3.08× the plain formatting time, while comment-heavy inputs took 4.58–5.77×. These measurements isolate
+formatter work on changed files; enabling the CLI cache above skips that work for unchanged files.
+
 ## Development
 
 Source files are organized by responsibility. `src/plugin/` contains parser and printer integration,
@@ -168,6 +234,7 @@ concerns and source file names wherever practical.
 
 ```sh
 npm install
+npm run benchmark
 npm run format:check
 npm run typecheck
 npm run test
@@ -177,3 +244,10 @@ npm run build
 `npm run test` runs the TypeScript unit and fixture-based integration suites with Vitest. Use `npm run test:unit` or
 `npm run test:integration` to run one suite. `npm run build` removes and recreates `dist` using a cross-platform Node
 cleanup script, and `npm run verify` runs formatting, type checking, the build, and both test suites.
+
+`npm run benchmark` compares plain Prettier with Prettier using the plugin. Its JavaScript, TypeScript, and TSX inputs
+are generated in memory by the files under `test/benchmark`, so large benchmark fixtures are not stored in the
+repository. Benchmarks use Vitest's separate benchmark mode and do not run as part of `npm run test` or
+`npm run verify`.
+
+[prettier-cache]: https://prettier.io/docs/cli#--cache

package/dist/comments/comment-body.js

@@ -1,4 +1,4 @@
-import { isBlankLine } from '../utils/source-lines.js';
+import { isBlankLine, normalizeLineTerminators } from '../utils/source-lines.js';
 export function getCommentBody(text, comment) {
     const raw = text.slice(comment.start, comment.end);
     return comment.kind === 'line' ? normalizeLineCommentBody(raw.slice(2)) : normalizeBlockCommentBody(raw);
@@ -10,7 +10,7 @@ export function normalizeLineCommentBody(rawBody) {
     return rawBody.replace(/^[ \t]?/, '').replace(/[ \t]+$/u, '');
 }
 export function normalizeBlockCommentBody(rawComment) {
-    const body = rawComment.slice(2, -2).replace(/\r\n?/g, '\n');
+    const body = normalizeLineTerminators(rawComment.slice(2, -2));
     const lines = body.split('\n');
     if (lines.length === 1) {
         return lines[0]?.trim() ?? '';

package/dist/comments/comment-directives.js

@@ -1,4 +1,5 @@
 const PRAGMA_DIRECTIVE_COMMENT_PATTERNS = [
+    /^@(?:flow|noflow)\b/u,
     /^@(?:license|preserve)\b/u,
     /^@(?:jsxFrag|jsxImportSource|jsxRuntime|jsx)\b/u,
     /^@(?:ts-check|ts-expect-error|ts-ignore|ts-nocheck)\b/u,
@@ -17,9 +18,11 @@ const TOOL_DIRECTIVE_COMMENT_PATTERNS = [
     /^eslint\b/u,
     /^eslint-/u,
     /^exported\b/u,
+    /^flowlint(?:-next-line|-line)?\b/u,
     /^globals?\b/u,
     /^istanbul\b/u,
     /^jshint\b/u,
+    /^node:coverage (?:disable|enable|ignore next(?: [1-9]\d*)?)$/u,
     /^nyc\b/u,
     /^oxlint\b/u,
     /^prettier-ignore\b/u,
@@ -29,6 +32,7 @@ const TOOL_DIRECTIVE_COMMENT_PATTERNS = [
     /^tslint\b/u,
     /^v8\b/u,
     /^vite-ignore\b/u,
+    /^\$(?:FlowExpectedError|FlowFixMe)\b/u,
 ];
 const BUNDLER_DIRECTIVE_COMMENT_PATTERNS = [
     /^webpack(?:ChunkName|Exclude|Ignore|Include|Mode|Prefetch|Preload)\b/u,

package/dist/comments/comment-eligibility.d.ts

@@ -2,3 +2,4 @@ import type { CommentRange } from './comment-ranges.js';
 export declare function shouldSkipLineComment(text: string, comment: CommentRange): boolean;
 export declare function shouldSkipBlockComment(text: string, comment: CommentRange): boolean;
 export declare function hasPreserveCommentMarker(rawComment: string): boolean;
+export declare function hasFlowCommentTypeMarker(rawComment: string): boolean;

package/dist/comments/comment-eligibility.js

@@ -9,7 +9,7 @@ export function shouldSkipLineComment(text, comment) {
 }
 export function shouldSkipBlockComment(text, comment) {
     const raw = text.slice(comment.start, comment.end);
-    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
+    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw) || hasFlowCommentTypeMarker(raw)) {
         return true;
     }
     const body = normalizeBlockCommentBody(raw);
@@ -18,3 +18,6 @@ export function shouldSkipBlockComment(text, comment) {
 export function hasPreserveCommentMarker(rawComment) {
     return rawComment.startsWith('/*!') || rawComment.startsWith('//!');
 }
+export function hasFlowCommentTypeMarker(rawComment) {
+    return /^\/\*[ \t]*(?::|flow-include)/u.test(rawComment);
+}

package/dist/comments/comment-location.js

@@ -1,21 +1,39 @@
 import { getLineEnd, getLinePrefix, getLineStart } from '../utils/source-lines.js';
+import { isEcmaScriptHorizontalWhitespace } from '../utils/whitespace.js';
 export function isStandaloneComment(text, comment) {
     return comment.kind === 'line' ? isStandaloneLineComment(text, comment) : isStandaloneBlockComment(text, comment);
 }
 export function isStandaloneLineComment(text, comment) {
-    return /^[ \t]*$/u.test(getLinePrefix(text, comment.start));
+    return isOnlyHorizontalWhitespace(getLinePrefix(text, comment.start));
 }
 export function isStandaloneBlockComment(text, comment) {
     const before = text.slice(getLineStart(text, comment.start), comment.start);
     const after = text.slice(comment.end, getLineEnd(text, comment.end));
-    return /^[ \t]*$/u.test(before) && /^[ \t]*$/u.test(after);
+    return isOnlyHorizontalWhitespace(before) && isOnlyHorizontalWhitespace(after);
 }
 export function areCommentsOnAdjacentLines(text, previousComment, comment) {
-    return isOnlyNewlineAndIndent(text.slice(previousComment.end, comment.start));
+    return isOnlyHorizontalWhitespaceAroundNewline(text.slice(previousComment.end, comment.start));
 }
 export function isCommentAdjacentBeforeIndex(text, comment, index) {
-    return isOnlyNewlineAndIndent(text.slice(comment.end, index));
+    return isOnlyHorizontalWhitespaceAroundNewline(text.slice(comment.end, index));
 }
-function isOnlyNewlineAndIndent(text) {
-    return /^(?:\r\n|[\n\r\u2028\u2029])[ \t]*$/u.test(text);
+function isOnlyHorizontalWhitespaceAroundNewline(text) {
+    let newlineStart = 0;
+    while (newlineStart < text.length) {
+        const character = text[newlineStart];
+        if (character === undefined || !isEcmaScriptHorizontalWhitespace(character)) {
+            break;
+        }
+        newlineStart += 1;
+    }
+    const newline = /^(?:\r\n|[\n\r\u2028\u2029])/u.exec(text.slice(newlineStart))?.[0];
+    return newline !== undefined && isOnlyHorizontalWhitespace(text.slice(newlineStart + newline.length));
+}
+function isOnlyHorizontalWhitespace(text) {
+    for (const character of text) {
+        if (!isEcmaScriptHorizontalWhitespace(character)) {
+            return false;
+        }
+    }
+    return true;
 }

package/dist/comments/embedded-expression-ranges.d.ts

@@ -8,6 +8,5 @@ export type EmbeddedTrailingLineCommentMove = {
     removeStart: number;
 };
 export declare function collectEmbeddedExpressionRanges(ast: unknown): EmbeddedExpressionRange[];
-export declare function isCommentInEmbeddedExpression(comment: CommentRange, ranges: SourceRange[]): boolean;
-export declare function getEmbeddedTrailingLineCommentMove(text: string, comment: CommentRange, ranges: EmbeddedExpressionRange[]): EmbeddedTrailingLineCommentMove | undefined;
-export declare function doesBlockCommentSeparateEmbeddedTrailingLineComment(text: string, blockComment: CommentRange, nextComment: CommentRange | undefined, ranges: EmbeddedExpressionRange[]): boolean;
+export declare function getEmbeddedTrailingLineCommentMove(text: string, comment: CommentRange, range: EmbeddedExpressionRange | undefined): EmbeddedTrailingLineCommentMove | undefined;
+export declare function doesBlockCommentSeparateEmbeddedTrailingLineComment(text: string, blockComment: CommentRange, nextComment: CommentRange | undefined, range: EmbeddedExpressionRange | undefined, nextRange: EmbeddedExpressionRange | undefined): boolean;

package/dist/comments/embedded-expression-ranges.js

@@ -1,6 +1,7 @@
 import { getAstNodeRange, visitAstNodes } from '../utils/ast.js';
 import { getLineEnd } from '../utils/source-lines.js';
 import { isRecord, numberOrUndefined } from '../utils/type-guards.js';
+import { skipWhitespace, trimWhitespaceEnd } from '../utils/whitespace.js';
 const JSX_EMBEDDED_EXPRESSION_TYPES = new Set(['JSXExpressionContainer', 'JSXSpreadAttribute', 'JSXSpreadChild']);
 export function collectEmbeddedExpressionRanges(ast) {
     const ranges = [];
@@ -27,36 +28,59 @@ export function collectEmbeddedExpressionRanges(ast) {
     });
     return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
 }
-export function isCommentInEmbeddedExpression(comment, ranges) {
-    return getSmallestContainingRange(comment, ranges) !== undefined;
-}
-export function getEmbeddedTrailingLineCommentMove(text, comment, ranges) {
-    const range = getSmallestContainingRange(comment, ranges);
+export function getEmbeddedTrailingLineCommentMove(text, comment, range) {
     const expression = range?.expression;
-    if (expression === undefined ||
-        expression.end > comment.start ||
-        !/^[\t ]*$/u.test(text.slice(expression.end, comment.start))) {
+    if (range === undefined || expression === undefined) {
         return undefined;
     }
-    return { insertAt: expression.start, removeStart: expression.end };
+    const rootExpression = getRootExpressionRangeBefore(text, expression, comment.start, range.start);
+    return rootExpression === undefined ? undefined : { insertAt: rootExpression.start, removeStart: rootExpression.end };
 }
-export function doesBlockCommentSeparateEmbeddedTrailingLineComment(text, blockComment, nextComment, ranges) {
+export function doesBlockCommentSeparateEmbeddedTrailingLineComment(text, blockComment, nextComment, range, nextRange) {
     if (blockComment.kind !== 'block' ||
         nextComment?.kind !== 'line' ||
         blockComment.end >= nextComment.start ||
         nextComment.end > getLineEnd(text, blockComment.start)) {
         return false;
     }
-    const range = getSmallestContainingRange(blockComment, ranges);
-    const nextRange = getSmallestContainingRange(nextComment, ranges);
     const expression = range?.expression;
+    const rootExpression = range === undefined || expression === undefined
+        ? undefined
+        : getRootExpressionRangeBefore(text, expression, blockComment.start, range.start);
     return (range !== undefined &&
         range === nextRange &&
-        expression !== undefined &&
-        expression.end <= blockComment.start &&
-        /^[\t ]*$/u.test(text.slice(expression.end, blockComment.start)) &&
+        rootExpression !== undefined &&
         /^[\t ]*$/u.test(text.slice(blockComment.end, nextComment.start)));
 }
+function getRootExpressionRangeBefore(text, expression, before, containerStart) {
+    if (expression.end > before) {
+        return undefined;
+    }
+    let cursor = expression.end;
+    let expandedEnd = expression.end;
+    let parenthesisCount = 0;
+    while (cursor < before) {
+        cursor = skipWhitespace(text, cursor);
+        if (cursor >= before) {
+            break;
+        }
+        if (text[cursor] !== ')') {
+            return undefined;
+        }
+        cursor += 1;
+        expandedEnd = cursor;
+        parenthesisCount += 1;
+    }
+    let expandedStart = expression.start;
+    for (let index = 0; index < parenthesisCount; index += 1) {
+        expandedStart = trimWhitespaceEnd(text, containerStart, expandedStart);
+        if (expandedStart <= containerStart || text[expandedStart - 1] !== '(') {
+            return undefined;
+        }
+        expandedStart -= 1;
+    }
+    return { end: expandedEnd, start: expandedStart };
+}
 function collectTemplateInterpolationRanges(node, expressionsKey, ranges) {
     const quasis = node['quasis'];
     const expressions = node[expressionsKey];
@@ -91,15 +115,3 @@ function getNodeBoundary(value) {
     }
     return { end, start };
 }
-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;
-}

package/dist/comments/jsx-expression-layout.d.ts

@@ -1,10 +1,10 @@
 import type { CommentRange } from './comment-ranges.js';
 import type { PrinterCommentLayout } from './printer-layout.js';
 import type { BlockCommentLayout } from './wrap-block-comment.js';
-import type { SourceRange } from '../utils/ast.js';
+import type { ContainingRangeMatch, SourceRange } from '../utils/ast.js';
 export type JsxExpressionContainerRange = SourceRange & {
     expression: SourceRange | undefined;
 };
 export declare function collectJsxExpressionContainerRanges(ast: unknown): JsxExpressionContainerRange[];
 export declare function getPrintedJsxCommentMarkerColumn(text: string, container: SourceRange, tabWidth: number): number;
-export declare function getJsxExpressionBlockCommentLayout(text: string, comment: CommentRange, previousComment: CommentRange | undefined, containers: JsxExpressionContainerRange[], tabWidth: number, outputCommentLayout: PrinterCommentLayout | undefined, outputCommentMarkerColumns: Array<number | undefined>): BlockCommentLayout | undefined;
+export declare function getJsxExpressionBlockCommentLayout(text: string, comment: CommentRange, previousComment: CommentRange | undefined, containerMatch: ContainingRangeMatch<JsxExpressionContainerRange> | undefined, tabWidth: number, outputCommentLayout: PrinterCommentLayout | undefined, outputCommentMarkerColumns: Array<number | undefined>): BlockCommentLayout | undefined;

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

@@ -2,7 +2,7 @@ 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 } from '../utils/source-lines.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) {
@@ -28,15 +28,17 @@ export function getPrintedJsxCommentMarkerColumn(text, container, tabWidth) {
     const lineIndent = getLeadingIndent(linePrefix);
     return getColumns(lineIndent, tabWidth) + tabWidth;
 }
-export function getJsxExpressionBlockCommentLayout(text, comment, previousComment, containers, tabWidth, outputCommentLayout, outputCommentMarkerColumns) {
-    const container = getSmallestContainingRange(comment, containers);
-    if (container === undefined || text[container.start] !== '{' || text[container.end - 1] !== '}') {
+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 containerIndex = containers.indexOf(container);
-    const multilineMarkerColumn = outputCommentMarkerColumns[containerIndex] ??
+    const multilineMarkerColumn = outputCommentMarkerColumns[containerMatch.index] ??
         getJsxExpressionContainerOutputColumn(text, container, tabWidth) + tabWidth;
     const markerColumn = outputCommentLayout?.markerColumn ?? multilineMarkerColumn;
     const contentColumn = multilineMarkerColumn + 3;
@@ -78,7 +80,14 @@ export function getJsxExpressionBlockCommentLayout(text, comment, previousCommen
     }
     if (!hasExpressionBeforeComment) {
         if (isStandaloneBlockComment(text, comment)) {
-            return { placement: 'inline' };
+            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 {
@@ -103,15 +112,3 @@ function getJsxExpressionContainerOutputColumn(text, container, tabWidth) {
     const lineIndent = getLeadingIndent(linePrefix);
     return getColumns(lineIndent, tabWidth) + tabWidth;
 }
-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;
-}

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

@@ -1,8 +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, ignoredLineRanges: SourceRange[]): boolean;
+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

@@ -3,10 +3,12 @@ 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 { getAstNodeRange, visitAstNodes } from '../utils/ast.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) {
@@ -17,38 +19,55 @@ export function neutralizePrettierIgnoreForIgnoredComments(text, ast) {
             ((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 nodeRanges = collectAstNodeRanges(ast);
+    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) ||
+            (!isStandaloneComment(text, comment) && jsxTargetRange === undefined) ||
             !isPrettierIgnoreComment(getCommentBody(text, comment))) {
             continue;
         }
-        const targetStart = getPrettierIgnoreTargetStart(text, comments, index);
-        if (targetStart === undefined) {
-            continue;
+        let targetRange = jsxTargetRange;
+        if (targetRange === undefined) {
+            const targetStart = getPrettierIgnoreTargetStart(text, comments, index);
+            if (targetStart === undefined) {
+                continue;
+            }
+            targetRange = nodeRangesByStart.get(targetStart);
         }
-        const targetRange = nodeRanges.find((range) => range.start === targetStart);
         if (targetRange === undefined) {
             continue;
         }
-        ignoredLineRanges.push({
+        appendMergedRange(ignoredLineRanges, {
             end: getLineEnd(text, targetRange.end),
             start: getLineStart(text, targetRange.start),
         });
     }
     return ignoredLineRanges;
 }
-export function isCommentInIgnoredLineRange(comment, ignoredLineRanges) {
-    return ignoredLineRanges.some((range) => comment.start >= range.start && comment.start < range.end);
+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;
@@ -107,15 +126,82 @@ export function isPrettierIgnoredTrailingLineComment(text, comments, index) {
     }
     return false;
 }
-function collectAstNodeRanges(ast) {
-    const ranges = [];
+function collectJsxPrettierIgnoreTargetRanges(text, ast, comments) {
+    const commentsByStart = new Map(comments.map((entry) => [entry.range.start, entry.range]));
+    const targetRangesByIgnoreStart = new Map();
     visitAstNodes(ast, (node) => {
-        const range = getAstNodeRange(node);
-        if (range !== undefined) {
-            ranges.push(range);
+        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 ranges.sort((left, right) => left.start - right.start || right.end - left.end);
+    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;
@@ -143,3 +229,11 @@ function isSkippableCommentBetweenIgnoreAndTarget(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

@@ -6,6 +6,7 @@ export type PrinterLayoutSource = {
 };
 export type PrinterCommentLayout = {
     lineIndentColumn: number;
+    lineStart: number;
     lineWidth: number;
     markerColumn: number;
     suffixWidth: number;

package/dist/comments/printer-layout.js

@@ -57,6 +57,7 @@ function getPrinterCommentLayout(text, comment, tabWidth) {
     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/wrap-block-comment.d.ts

@@ -10,6 +10,7 @@ export type BlockCommentLayout = {
     markerColumn?: number;
     multilineIndent?: string;
     placement: 'inline' | 'standalone' | 'trailing';
+    preserveMultiline?: boolean;
     singleLineSuffixWidth?: number;
     trailingMove?: {
         insertAt: number;