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

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,6 +31,31 @@ Then run Prettier normally:
 npx prettier --write .
 ```
 
+### 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
@@ -148,10 +174,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 +188,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 +219,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 +229,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;

package/dist/comments/wrap-block-comment.js

@@ -37,7 +37,9 @@ function buildBlockReplacement(text, comment, formattedLines, options, layout) {
     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') {

package/dist/comments/wrap-comments.js

@@ -1,7 +1,7 @@
 import { shouldSkipLineComment } from './comment-eligibility.js';
 import { isStandaloneBlockComment, isStandaloneLineComment } from './comment-location.js';
 import { collectCommentEntries } from './comment-ranges.js';
-import { collectEmbeddedExpressionRanges, doesBlockCommentSeparateEmbeddedTrailingLineComment, getEmbeddedTrailingLineCommentMove, isCommentInEmbeddedExpression, } from './embedded-expression-ranges.js';
+import { collectEmbeddedExpressionRanges, doesBlockCommentSeparateEmbeddedTrailingLineComment, getEmbeddedTrailingLineCommentMove, } from './embedded-expression-ranges.js';
 import { collectJsxExpressionContainerRanges, getJsxExpressionBlockCommentLayout } from './jsx-expression-layout.js';
 import { collectLineCommentGroup } from './line-comment-groups.js';
 import { collectPrettierIgnoredLineRanges, isCommentInIgnoredLineRange, isPrettierIgnoredBlockComment, isPrettierIgnoredStandaloneLineComment, isPrettierIgnoredTrailingLineComment, } from './prettier-ignore.js';
@@ -9,7 +9,10 @@ import { getPrinterLayout } from './printer-layout.js';
 import { wrapBlockComment } from './wrap-block-comment.js';
 import { wrapLineCommentGroup } from './wrap-line-comment-group.js';
 import { wrapTrailingLineComment } from './wrap-trailing-line-comment.js';
+import { matchOrderedRangesToSmallestContainers } from '../utils/ast.js';
+import { getColumnAt, getColumns } from '../utils/display-width.js';
 import { applyReplacements } from '../utils/replacements.js';
+import { getLineEnd, getLineStart } from '../utils/source-lines.js';
 import { getTabWidth } from '../utils/wrap-options.js';
 export async function wrapComments(text, ast, options, printerLayoutSource) {
     return (await wrapCommentsWithMetadata(text, ast, options, printerLayoutSource)).text;
@@ -20,6 +23,8 @@ export async function wrapCommentsWithMetadata(text, ast, options, printerLayout
     const embeddedExpressionRanges = collectEmbeddedExpressionRanges(ast);
     const jsxExpressionContainers = collectJsxExpressionContainerRanges(ast);
     const ignoredLineRanges = collectPrettierIgnoredLineRanges(text, ast, commentEntries);
+    const embeddedExpressionRangeMatches = matchOrderedRangesToSmallestContainers(comments, embeddedExpressionRanges);
+    const jsxExpressionContainerMatches = matchOrderedRangesToSmallestContainers(comments, jsxExpressionContainers);
     if (comments.length === 0) {
         return { jsxBlockCommentRewrites: [], text };
     }
@@ -27,21 +32,34 @@ export async function wrapCommentsWithMetadata(text, ast, options, printerLayout
     const jsxBlockCommentRewrites = [];
     const tabWidth = getTabWidth(options);
     const printerLayout = getPrinterLayout(text, commentEntries, jsxExpressionContainers, printerLayoutSource, tabWidth);
+    const sameLineWidthDeltas = {
+        output: new Map(),
+        source: new Map(),
+    };
     let blockCommentIndex = -1;
+    let ignoredLineRangeIndex = 0;
     for (let index = 0; index < comments.length; index += 1) {
         const comment = comments[index];
         const outputCommentLayout = printerLayout.comments[index];
         if (comment?.kind === 'block') {
             blockCommentIndex += 1;
         }
-        if (comment === undefined || isCommentInIgnoredLineRange(comment, ignoredLineRanges)) {
+        if (comment === undefined) {
+            continue;
+        }
+        let ignoredLineRange = ignoredLineRanges[ignoredLineRangeIndex];
+        while (ignoredLineRange !== undefined && ignoredLineRange.end <= comment.start) {
+            ignoredLineRangeIndex += 1;
+            ignoredLineRange = ignoredLineRanges[ignoredLineRangeIndex];
+        }
+        if (isCommentInIgnoredLineRange(comment, ignoredLineRange)) {
             continue;
         }
         if (comment.kind === 'block') {
             if (isPrettierIgnoredBlockComment(text, commentEntries, index)) {
                 continue;
             }
-            const jsxLayout = getJsxExpressionBlockCommentLayout(text, comment, comments[index - 1], jsxExpressionContainers, tabWidth, outputCommentLayout, printerLayout.jsxCommentMarkerColumns);
+            const jsxLayout = getJsxExpressionBlockCommentLayout(text, comment, comments[index - 1], jsxExpressionContainerMatches[index], tabWidth, outputCommentLayout, printerLayout.jsxCommentMarkerColumns);
             if (jsxLayout?.placement === 'inline') {
                 continue;
             }
@@ -52,7 +70,7 @@ export async function wrapCommentsWithMetadata(text, ast, options, printerLayout
                     placement: isStandaloneBlockComment(text, comment) ? 'standalone' : 'inline',
                 };
             const replacement = await wrapBlockComment(text, comment, options, jsxLayout ?? outputLayout);
-            const preservesEmbeddedCommentOrder = doesBlockCommentSeparateEmbeddedTrailingLineComment(text, comment, comments[index + 1], embeddedExpressionRanges);
+            const preservesEmbeddedCommentOrder = doesBlockCommentSeparateEmbeddedTrailingLineComment(text, comment, comments[index + 1], embeddedExpressionRangeMatches[index]?.range, embeddedExpressionRangeMatches[index + 1]?.range);
             if (Array.isArray(replacement)) {
                 if (!preservesEmbeddedCommentOrder) {
                     replacements.push(...replacement);
@@ -60,6 +78,7 @@ export async function wrapCommentsWithMetadata(text, ast, options, printerLayout
             }
             else if (replacement !== undefined) {
                 replacements.push(replacement);
+                recordSameLineReplacementWidthDelta(text, comment, replacement, outputCommentLayout, tabWidth, sameLineWidthDeltas);
                 if (jsxLayout !== undefined) {
                     jsxBlockCommentRewrites.push({ blockCommentIndex, text: replacement.text });
                 }
@@ -77,11 +96,13 @@ export async function wrapCommentsWithMetadata(text, ast, options, printerLayout
             if (isPrettierIgnoredTrailingLineComment(text, commentEntries, index)) {
                 continue;
             }
-            const embeddedMove = getEmbeddedTrailingLineCommentMove(text, comment, embeddedExpressionRanges);
-            if (embeddedMove === undefined && isCommentInEmbeddedExpression(comment, embeddedExpressionRanges)) {
+            const embeddedExpressionRange = embeddedExpressionRangeMatches[index]?.range;
+            const embeddedMove = getEmbeddedTrailingLineCommentMove(text, comment, embeddedExpressionRange);
+            if (embeddedMove === undefined && embeddedExpressionRange !== undefined) {
                 continue;
             }
-            const replacement = await wrapTrailingLineComment(text, comment, options, outputCommentLayout, embeddedMove);
+            const trailingLayout = getTrailingLineCommentLayout(text, comment, outputCommentLayout, tabWidth, sameLineWidthDeltas);
+            const replacement = await wrapTrailingLineComment(text, comment, options, trailingLayout, embeddedMove);
             if (replacement !== undefined) {
                 replacements.push(...replacement);
             }
@@ -99,3 +120,50 @@ export async function wrapCommentsWithMetadata(text, ast, options, printerLayout
         text: applyReplacements(text, replacements),
     };
 }
+function recordSameLineReplacementWidthDelta(text, comment, replacement, outputLayout, tabWidth, sameLineWidthDeltas) {
+    const original = text.slice(comment.start, comment.end);
+    if (containsLineTerminator(original) || containsLineTerminator(replacement.text)) {
+        return;
+    }
+    const sourceLineStart = getLineStart(text, comment.start);
+    const sourceWidthDelta = sameLineWidthDeltas.source.get(sourceLineStart) ?? 0;
+    const sourceMarkerColumn = getColumnAt(text, comment.start, tabWidth) + sourceWidthDelta;
+    const sourceReplacementWidthDelta = getReplacementWidthDelta(original, replacement.text, sourceMarkerColumn, tabWidth);
+    addLineWidthDelta(sameLineWidthDeltas.source, sourceLineStart, sourceReplacementWidthDelta);
+    if (outputLayout === undefined) {
+        return;
+    }
+    const outputWidthDelta = sameLineWidthDeltas.output.get(outputLayout.lineStart) ?? 0;
+    const outputMarkerColumn = outputLayout.markerColumn + outputWidthDelta;
+    const outputReplacementWidthDelta = getReplacementWidthDelta(original, replacement.text, outputMarkerColumn, tabWidth);
+    addLineWidthDelta(sameLineWidthDeltas.output, outputLayout.lineStart, outputReplacementWidthDelta);
+}
+function getTrailingLineCommentLayout(text, comment, outputLayout, tabWidth, sameLineWidthDeltas) {
+    if (outputLayout !== undefined) {
+        const lineWidthDelta = sameLineWidthDeltas.output.get(outputLayout.lineStart) ?? 0;
+        return lineWidthDelta === 0
+            ? outputLayout
+            : { ...outputLayout, lineWidth: outputLayout.lineWidth + lineWidthDelta };
+    }
+    const lineStart = getLineStart(text, comment.start);
+    const lineWidthDelta = sameLineWidthDeltas.source.get(lineStart) ?? 0;
+    if (lineWidthDelta === 0) {
+        return undefined;
+    }
+    const lineEnd = getLineEnd(text, comment.start);
+    const lineText = text.slice(lineStart, lineEnd).replace(/[ \t]+$/u, '');
+    return { lineWidth: getColumns(lineText, tabWidth) + lineWidthDelta };
+}
+function getReplacementWidthDelta(original, replacement, markerColumn, tabWidth) {
+    const originalWidth = getColumns(original, tabWidth, markerColumn);
+    const replacementWidth = getColumns(replacement, tabWidth, markerColumn);
+    return replacementWidth - originalWidth;
+}
+function addLineWidthDelta(lineWidthDeltas, lineStart, delta) {
+    if (delta !== 0) {
+        lineWidthDeltas.set(lineStart, (lineWidthDeltas.get(lineStart) ?? 0) + delta);
+    }
+}
+function containsLineTerminator(text) {
+    return /[\r\n\u2028\u2029]/u.test(text);
+}

package/dist/comments/wrap-trailing-line-comment.d.ts

@@ -3,7 +3,7 @@ import type { EmbeddedTrailingLineCommentMove } from './embedded-expression-rang
 import type { Replacement } from '../utils/replacements.js';
 import type { WrapOptions } from '../utils/wrap-options.js';
 export type TrailingLineCommentLayout = {
-    lineIndentColumn: number;
+    lineIndentColumn?: number;
     lineWidth: number;
 };
 export declare function wrapTrailingLineComment(text: string, comment: CommentRange, options: WrapOptions, outputLayout?: TrailingLineCommentLayout, move?: EmbeddedTrailingLineCommentMove): Promise<Replacement[] | undefined>;

package/dist/plugin/create-parsers.js

@@ -32,9 +32,12 @@ function createWrappedParser(parserName, parser) {
             if (hasOffsetSensitiveFormatting(text, options)) {
                 return preprocessed;
             }
+            if (!preprocessed.includes('//') && !preprocessed.includes('/*')) {
+                return preprocessed;
+            }
             let ast;
             try {
-                ast = await parser.parse(preprocessed, options);
+                ast = await parser.parse(preprocessed, { ...options, parser: parserName });
             }
             catch {
                 return preprocessed;

package/dist/plugin/create-printers.js

@@ -1,12 +1,18 @@
 import { doc } from 'prettier';
 import * as estreePlugin from 'prettier/plugins/estree';
+import { getNeutralizedPrettierIgnoreOriginalText } from '../comments/prettier-ignore.js';
+import { normalizeLineTerminators } from '../utils/source-lines.js';
 import { isRecord } from '../utils/type-guards.js';
 import { isRewrittenJsxBlockComment } from './jsx-comment-rewrite-metadata.js';
 const { hardline, indent } = doc.builders;
+const { mapDoc, replaceEndOfLine } = doc.utils;
 export function createPrinters() {
     const estreePrinter = estreePlugin.printers.estree;
+    const estreePrintComment = estreePrinter.printComment;
+    if (estreePrintComment === undefined) {
+        throw new Error('Expected the native estree printer to provide printComment');
+    }
     return {
-        ...estreePlugin.printers,
         estree: {
             ...estreePrinter,
             print(path, options, print, args) {
@@ -15,6 +21,21 @@ export function createPrinters() {
                 }
                 return estreePrinter.print(path, options, print, args);
             },
+            printComment(path, options) {
+                const originalText = getNeutralizedPrettierIgnoreOriginalText(path.node);
+                if (originalText !== undefined) {
+                    const normalizedOriginalText = normalizeLineTerminators(originalText);
+                    return normalizedOriginalText.includes('\n')
+                        ? replaceEndOfLine(normalizedOriginalText)
+                        : normalizedOriginalText;
+                }
+                if (isRewrittenMultilineBlockComment(path.node)) {
+                    const printedComment = estreePrintComment(path, options);
+                    const normalizedComment = mapDoc(printedComment, (currentDoc) => typeof currentDoc === 'string' ? normalizeLineTerminators(currentDoc) : currentDoc);
+                    return replaceEndOfLine(normalizedComment, hardline);
+                }
+                return estreePrintComment(path, options);
+            },
         },
     };
 }
@@ -34,5 +55,5 @@ function isRewrittenMultilineBlockComment(comment) {
         return false;
     }
     const value = comment['value'];
-    return typeof value === 'string' && value.includes('\n') && isRewrittenJsxBlockComment(comment);
+    return typeof value === 'string' && /[\r\n\u2028\u2029]/u.test(value) && isRewrittenJsxBlockComment(comment);
 }

package/dist/plugin/get-printer-layout-source.js

@@ -1,8 +1,16 @@
 import { format } from 'prettier';
+import { neutralizePrettierIgnoreForIgnoredComments } from '../comments/prettier-ignore.js';
 import { createPrinters } from './create-printers.js';
 export async function getPrinterLayoutSource(text, ast, parserName, parser, options) {
+    const printerLayoutParser = {
+        ...parser,
+        async parse(source, parserOptions) {
+            const printerLayoutAst = await parser.parse(source, parserOptions);
+            return neutralizePrettierIgnoreForIgnoredComments(source, printerLayoutAst);
+        },
+    };
     const printerLayoutPlugin = {
-        parsers: { [parserName]: parser },
+        parsers: { [parserName]: printerLayoutParser },
         printers: createPrinters(),
     };
     try {
@@ -15,7 +23,7 @@ export async function getPrinterLayoutSource(text, ast, parserName, parser, opti
         if (formattedText === text) {
             return { ast, text };
         }
-        const formattedAst = await parser.parse(formattedText, options);
+        const formattedAst = await parser.parse(formattedText, { ...options, parser: parserName });
         return {
             ast: formattedAst,
             text: formattedText,

package/dist/utils/ast.d.ts

@@ -2,5 +2,11 @@ export type SourceRange = {
     end: number;
     start: number;
 };
+export type ContainingRangeMatch<Range extends SourceRange> = {
+    index: number;
+    range: Range;
+};
 export declare function visitAstNodes(ast: unknown, visitor: (node: Record<string, unknown>) => void): void;
 export declare function getAstNodeRange(node: Record<string, unknown>): SourceRange | undefined;
+export declare function collectAstNodeRangesByStart(ast: unknown): Map<number, SourceRange>;
+export declare function matchOrderedRangesToSmallestContainers<Range extends SourceRange>(targets: readonly SourceRange[], containers: readonly Range[]): Array<ContainingRangeMatch<Range> | undefined>;

package/dist/utils/ast.js

@@ -44,6 +44,49 @@ export function getAstNodeRange(node) {
     }
     return { end, start };
 }
+export function collectAstNodeRangesByStart(ast) {
+    const rangesByStart = new Map();
+    visitAstNodes(ast, (node) => {
+        const range = getAstNodeRange(node);
+        if (range === undefined) {
+            return;
+        }
+        const existingRange = rangesByStart.get(range.start);
+        if (existingRange === undefined || range.end > existingRange.end) {
+            rangesByStart.set(range.start, range);
+        }
+    });
+    return rangesByStart;
+}
+export function matchOrderedRangesToSmallestContainers(targets, containers) {
+    const matches = [];
+    const openContainers = [];
+    let containerIndex = 0;
+    for (const target of targets) {
+        let container = containers[containerIndex];
+        while (container !== undefined && container.start < target.start) {
+            let previousContainer = openContainers[openContainers.length - 1];
+            while (previousContainer !== undefined && previousContainer.range.end <= container.start) {
+                openContainers.pop();
+                previousContainer = openContainers[openContainers.length - 1];
+            }
+            if (previousContainer === undefined ||
+                previousContainer.range.start !== container.start ||
+                previousContainer.range.end !== container.end) {
+                openContainers.push({ index: containerIndex, range: container });
+            }
+            containerIndex += 1;
+            container = containers[containerIndex];
+        }
+        let containingRange = openContainers[openContainers.length - 1];
+        while (containingRange !== undefined && containingRange.range.end <= target.end) {
+            openContainers.pop();
+            containingRange = openContainers[openContainers.length - 1];
+        }
+        matches.push(containingRange);
+    }
+    return matches;
+}
 function getRangeNumber(range, index) {
     if (!Array.isArray(range)) {
         return undefined;

package/dist/utils/display-width.d.ts

@@ -1,2 +1,2 @@
 export declare function getColumnAt(text: string, index: number, tabWidth: number): number;
-export declare function getColumns(text: string, tabWidth: number): number;
+export declare function getColumns(text: string, tabWidth: number, startColumn?: number): number;

package/dist/utils/display-width.js

@@ -3,8 +3,8 @@ import { getLineStart } from './source-lines.js';
 export function getColumnAt(text, index, tabWidth) {
     return getColumns(text.slice(getLineStart(text, index), index), tabWidth);
 }
-export function getColumns(text, tabWidth) {
-    let column = 0;
+export function getColumns(text, tabWidth, startColumn = 0) {
+    let column = startColumn;
     let segmentStart = 0;
     for (let index = 0; index < text.length; index += 1) {
         if (text[index] === '\t') {
@@ -15,5 +15,5 @@ export function getColumns(text, tabWidth) {
             segmentStart = index + 1;
         }
     }
-    return column + util.getStringWidth(text.slice(segmentStart));
+    return column + util.getStringWidth(text.slice(segmentStart)) - startColumn;
 }

package/dist/utils/format-markdown.js

@@ -1,22 +1,61 @@
 import { format } from 'prettier';
-import { isBlankLine } from './source-lines.js';
+import { isBlankLine, normalizeLineTerminators } from './source-lines.js';
 import { getTabWidth } from './wrap-options.js';
+const MAX_MARKDOWN_FORMAT_PASSES = 3;
 export async function formatMarkdownLines(markdown, printWidth, options) {
-    const normalized = trimBlankEdges(markdown.replace(/\r\n?/g, '\n'));
+    const normalized = trimBlankEdges(normalizeLineTerminators(markdown));
+    let formatted;
     try {
-        const formatted = await format(normalized, {
-            endOfLine: 'lf',
-            parser: 'markdown',
-            printWidth,
-            proseWrap: 'always',
-            tabWidth: getTabWidth(options),
-            useTabs: options.useTabs,
-        });
-        return formatted.replace(/\n$/, '').split('\n');
+        formatted = await formatMarkdown(normalized, printWidth, options);
     }
     catch {
         return normalized.split('\n');
     }
+    if (startsWithThematicRule(normalized)) {
+        formatted = await stabilizePotentialFrontMatter(formatted, printWidth, options);
+    }
+    return formatted.replace(/\n$/, '').split('\n');
+}
+async function formatMarkdown(markdown, printWidth, options) {
+    return format(markdown, {
+        endOfLine: 'lf',
+        parser: 'markdown',
+        printWidth,
+        proseWrap: 'always',
+        tabWidth: getTabWidth(options),
+        useTabs: options.useTabs,
+    });
+}
+async function stabilizePotentialFrontMatter(formatted, printWidth, options) {
+    const seen = new Set([formatted]);
+    let current = formatted;
+    for (let pass = 1; pass < MAX_MARKDOWN_FORMAT_PASSES && hasPotentialFrontMatterAmbiguity(current); pass += 1) {
+        let next;
+        try {
+            next = await formatMarkdown(current, printWidth, options);
+        }
+        catch {
+            return current;
+        }
+        if (next === current || seen.has(next)) {
+            return current;
+        }
+        seen.add(next);
+        current = next;
+    }
+    return current;
+}
+function startsWithThematicRule(markdown) {
+    const [firstLine = ''] = markdown.split('\n', 1);
+    return /^[ \t]{0,3}([*_-])(?:[ \t]*\1){2,}[ \t]*$/u.test(firstLine);
+}
+function hasPotentialFrontMatterAmbiguity(markdown) {
+    const lines = markdown.replace(/\n$/u, '').split('\n');
+    if (lines[0] !== '---') {
+        return false;
+    }
+    const closingDelimiterIndex = lines.indexOf('---', 1);
+    return closingDelimiterIndex > 1 && (isBlankLine(lines[1]) || isBlankLine(lines[closingDelimiterIndex - 1]));
 }
 function trimBlankEdges(markdown) {
     const lines = markdown.split('\n');

package/dist/utils/source-lines.d.ts

@@ -1,4 +1,5 @@
 import type { WrapOptions } from './wrap-options.js';
+export declare function normalizeLineTerminators(text: string): string;
 export declare function getPreferredNewline(text: string, options: WrapOptions): string;
 export declare function getLinePrefix(text: string, index: number): string;
 export declare function getLineStart(text: string, index: number): number;

package/dist/utils/source-lines.js

@@ -1,3 +1,6 @@
+export function normalizeLineTerminators(text) {
+    return text.replace(/\r\n|[\r\u2028\u2029]/gu, '\n');
+}
 export function getPreferredNewline(text, options) {
     if (options.endOfLine === 'crlf') {
         return '\r\n';

package/dist/utils/whitespace.d.ts

@@ -1,2 +1,3 @@
+export declare function isEcmaScriptHorizontalWhitespace(character: string): boolean;
 export declare function skipWhitespace(text: string, index: number): number;
 export declare function trimWhitespaceEnd(text: string, start: number, end: number): number;

package/dist/utils/whitespace.js

@@ -1,3 +1,7 @@
+const ECMASCRIPT_HORIZONTAL_WHITESPACE_PATTERN = /^[\t\u000b\u000c \u00a0\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]$/u;
+export function isEcmaScriptHorizontalWhitespace(character) {
+    return ECMASCRIPT_HORIZONTAL_WHITESPACE_PATTERN.test(character);
+}
 export function skipWhitespace(text, index) {
     let cursor = index;
     while (cursor < text.length) {

package/package.json

@@ -9,9 +9,15 @@
     "prettier": "3.9.6",
     "prettier-plugin-wrap-comments-stable": "npm:@aforemendude/prettier-plugin-wrap-comments@1.0.6",
     "typescript": "7.0.2",
-    "vite": "8.1.5",
+    "vite": "8.2.0",
     "vitest": "4.1.10"
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=22.12.0"
+    }
+  },
   "engines": {
     "node": ">=20.0.0"
   },
@@ -46,18 +52,20 @@
     "url": "git+https://github.com/aforemendude/prettier-plugin-wrap-comments.git"
   },
   "scripts": {
+    "benchmark": "vitest bench --run",
     "build": "npm run clean && tsc -p tsconfig.build.json",
     "clean": "node scripts/clean.mjs",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "format": "prettier --write --cache --cache-strategy metadata .",
+    "format:check": "prettier --check --cache --cache-strategy metadata .",
+    "format:nocache": "prettier --write .",
     "prepack": "npm install && git diff --exit-code -- package-lock.json && npm run verify",
     "test": "vitest run",
     "test:integration": "vitest run test/integration",
     "test:unit": "vitest run test/unit",
     "typecheck": "tsc -p tsconfig.json",
-    "verify": "npm run format:check && npm run typecheck && npm run build && npm run test"
+    "verify": "prettier --check . && npm run typecheck && npm run build && npm run test"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.1.0"
+  "version": "1.1.1"
 }