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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aforemendude
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,8 +5,8 @@ real column to calculate the available content width, so nested comments wrap mo
 
 ## Requirements
 
-- Node.js 18 or newer
-- Prettier 3 or newer
+- Node.js 20 or newer
+- Prettier 3 (`>=3.0.0 <4.0.0`)
 
 ## Install
 
@@ -37,9 +37,15 @@ preprocessing: the underlying Prettier parser preprocesses and parses the source
 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
+selected range; eligible comments inside that range can still be wrapped.
+
 Comment text is normalized and reflowed with Prettier's Markdown parser. The available content width is based on
 Prettier's `printWidth` minus the column where the comment text starts. `tabWidth`, `useTabs`, and `endOfLine` are used
-when measuring and rebuilding comments.
+when measuring and rebuilding comments. When `tabWidth` is `0`, tabs contribute zero columns during measurement, as they
+do in Prettier. If the plugin must synthesize indentation at a positive column, it uses spaces because zero-width tabs
+cannot advance to that column.
 
 Standalone `//` comments are wrapped in place. Adjacent standalone line comments are combined and reflowed as one
 Markdown block when they are directly next to each other and their `//` markers start in the same column.
@@ -53,7 +59,11 @@ function example() {
 ```
 
 Trailing `//` comments stay in place when the full source line fits within `printWidth`. If the source line is too long,
-the comment is moved above the code and wrapped using the code line's indentation.
+the comment is moved above the code and normally wrapped using the code line's indentation. On a line made up of closing
+delimiters such as `}`, `]`, or `)`, the moved comment is indented one additional level so it remains visually inside
+the construct being closed. When a comment directly trails the root value of a JSX expression or template interpolation,
+it can move above that value and wrap inside the expression delimiters. Nested or otherwise ambiguous expression
+comments and comments in JSX spreads stay in place.
 
 ```ts
 function example() {
@@ -67,6 +77,11 @@ Non-JSDoc `/* ... */` comments are also normalized as Markdown. A block comment
 comment fits within `printWidth`; otherwise, only standalone block comments are expanded into star-prefixed blocks. Long
 inline block comments are left unchanged when they cannot fit on one line.
 
+Multiline block comments are normalized as conventional block-comment text before Markdown parsing: leading indentation
+is removed, and a `*` that is the first non-whitespace character on a body line is treated as comment formatting, not
+Markdown content. This also applies to unstarred `/* ... */` blocks, so use line comments when Markdown-significant
+indentation or leading `*` characters must be preserved exactly.
+
 ```ts
 if (ready) {
   /*
@@ -78,9 +93,10 @@ if (ready) {
 ```
 
 JSX and TSX expression comments use the expression contents, not the outer React expression braces, to decide whether a
-block comment is standalone, trailing, or inline. A comment-only expression like `{/* ... */}` can wrap as a standalone
-JSX comment. A trailing expression comment like `{label /* ... */}` can move before `label` and wrap. A true inline
-expression comment like `{"abc" + /* ... */ "123"}` is left unchanged when it cannot fit on one line.
+block comment is standalone, leading, trailing, or inline. A comment-only expression like `{/* ... */}` can wrap as a
+standalone JSX comment. A leading expression comment like `{/* ... */ label}` can move above `label` and wrap. A
+trailing expression comment like `{label /* ... */}` can move before `label` and wrap. A true inline expression comment
+like `{"abc" + /* ... */ "123"}` is left unchanged when it cannot fit on one line.
 
 <!-- prettier-ignore-start -->
 ```tsx
@@ -91,6 +107,13 @@ expression comment like `{"abc" + /* ... */ "123"}` is left unchanged when it ca
      * make it inline.
      */
   }
+  {
+    /*
+     * This expression comment moved above the expression value because it was
+     * leading.
+     */
+    label
+  }
   {
     /*
      * This expression comment moved above the expression value because it was
@@ -109,11 +132,16 @@ the block comment is one the plugin would otherwise wrap, the following code sti
 comment is already skipped by the plugin, such as a JSDoc or directive block, Prettier keeps its normal ignore behavior
 for the following code.
 
-For trailing line comments, a `// prettier-ignore` line can apply to the code line and its inline comment. The plugin
-walks past adjacent standalone comments that it normally leaves alone, such as an `eslint-disable-next-line` directive,
-so an ignored code line's trailing comment remains inline and unchanged. A directive comment by itself does not ignore
-the following code line; without `// prettier-ignore`, an overlong trailing comment below a directive is still moved
-above the statement and wrapped.
+An exact `// prettier-ignore` marker can also apply to the following adjacent standalone `//` comment group. The plugin
+leaves that group unchanged and neutralizes the marker for Prettier, so code after the ignored comment group still
+formats normally.
+
+For trailing line comments, a standalone exact-body `prettier-ignore` marker, written as `// prettier-ignore` or
+`/* prettier-ignore */`, can apply to the code line and its inline comment. The plugin walks past adjacent standalone
+comments that it normally leaves alone, such as an `eslint-disable-next-line` directive, so an ignored code line's
+trailing comment remains inline and unchanged. A directive comment by itself does not ignore the following code line;
+without `prettier-ignore`, an overlong trailing comment below a directive is still moved above the statement and
+wrapped.
 
 The plugin leaves these comments unchanged:
 
@@ -133,11 +161,19 @@ The plugin leaves these comments unchanged:
 
 ## Development
 
+Source files are organized by responsibility. `src/plugin/` contains parser and printer integration,
+`src/comments/wrap-comments.ts` coordinates the rewriting pipeline, the other `src/comments/` modules isolate comment
+analysis and wrapping concerns, and `src/utils/` contains reusable utilities. Unit tests under `test/unit/` mirror those
+concerns and source file names wherever practical.
+
 ```sh
 npm install
 npm run format:check
+npm run typecheck
 npm run test
+npm run build
 ```
 
-`npm run test` builds `dist` before running the Node test suite. `npm run verify` runs `npm install`,
-`npm run format:check`, and `npm run test`.
+`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.

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

@@ -0,0 +1,4 @@
+import type { CommentRange } from './comment-ranges.js';
+export declare function getCommentBody(text: string, comment: CommentRange): string;
+export declare function normalizeLineCommentBody(rawBody: string): string;
+export declare function normalizeBlockCommentBody(rawComment: string): string;

package/dist/comments/comment-body.js

@@ -0,0 +1,36 @@
+import { isBlankLine } 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);
+}
+export function normalizeLineCommentBody(rawBody) {
+    if (rawBody.trim() === '') {
+        return '';
+    }
+    return rawBody.replace(/^[ \t]?/, '').replace(/[ \t]+$/u, '');
+}
+export function normalizeBlockCommentBody(rawComment) {
+    const body = rawComment.slice(2, -2).replace(/\r\n?/g, '\n');
+    const lines = body.split('\n');
+    if (lines.length === 1) {
+        return lines[0]?.trim() ?? '';
+    }
+    while (isBlankLine(lines[0])) {
+        lines.shift();
+    }
+    while (isBlankLine(lines.at(-1))) {
+        lines.pop();
+    }
+    return lines
+        .map((line) => {
+        const withoutIndent = line.replace(/^[ \t]*/u, '');
+        if (!withoutIndent.startsWith('*')) {
+            return withoutIndent.replace(/[ \t]+$/u, '');
+        }
+        return withoutIndent
+            .slice(1)
+            .replace(/^[ \t]?/u, '')
+            .replace(/[ \t]+$/u, '');
+    })
+        .join('\n');
+}

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

@@ -0,0 +1,2 @@
+export declare function isDirectiveComment(body: string): boolean;
+export declare function isPrettierIgnoreComment(body: string): boolean;

package/dist/comments/comment-directives.js

@@ -0,0 +1,48 @@
+const PRAGMA_DIRECTIVE_COMMENT_PATTERNS = [
+    /^@(?:license|preserve)\b/u,
+    /^@(?:jsxFrag|jsxImportSource|jsxRuntime|jsx)\b/u,
+    /^@(?:ts-check|ts-expect-error|ts-ignore|ts-nocheck)\b/u,
+    /^[@#]__(?:NO_SIDE_EFFECTS|PURE)__\b/u,
+];
+const SOURCE_MAP_DIRECTIVE_COMMENT_PATTERNS = [
+    /^[#@][ \t]*sourceMappingURL=/u,
+    /^[#@][ \t]*sourceURL=/u,
+    /^sourceMappingURL=/u,
+    /^sourceURL=/u,
+];
+const TOOL_DIRECTIVE_COMMENT_PATTERNS = [
+    /^biome-ignore\b/u,
+    /^c8\b/u,
+    /^deno-lint-ignore\b/u,
+    /^eslint\b/u,
+    /^eslint-/u,
+    /^exported\b/u,
+    /^globals?\b/u,
+    /^istanbul\b/u,
+    /^jshint\b/u,
+    /^nyc\b/u,
+    /^oxlint\b/u,
+    /^prettier-ignore\b/u,
+    /^prettier-ignore-start\b/u,
+    /^prettier-ignore-end\b/u,
+    /^stylelint\b/u,
+    /^tslint\b/u,
+    /^v8\b/u,
+    /^vite-ignore\b/u,
+];
+const BUNDLER_DIRECTIVE_COMMENT_PATTERNS = [
+    /^webpack(?:ChunkName|Exclude|Ignore|Include|Mode|Prefetch|Preload)\b/u,
+];
+const DIRECTIVE_COMMENT_PATTERNS = [
+    ...PRAGMA_DIRECTIVE_COMMENT_PATTERNS,
+    ...SOURCE_MAP_DIRECTIVE_COMMENT_PATTERNS,
+    ...TOOL_DIRECTIVE_COMMENT_PATTERNS,
+    ...BUNDLER_DIRECTIVE_COMMENT_PATTERNS,
+];
+export function isDirectiveComment(body) {
+    const normalizedBody = body.trimStart();
+    return DIRECTIVE_COMMENT_PATTERNS.some((pattern) => pattern.test(normalizedBody));
+}
+export function isPrettierIgnoreComment(body) {
+    return body.trim() === 'prettier-ignore';
+}

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

@@ -0,0 +1,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;

package/dist/comments/comment-eligibility.js

@@ -0,0 +1,20 @@
+import { normalizeBlockCommentBody, normalizeLineCommentBody } from './comment-body.js';
+import { isDirectiveComment } from './comment-directives.js';
+export function shouldSkipLineComment(text, comment) {
+    const raw = text.slice(comment.start, comment.end);
+    if (raw.startsWith('///') || hasPreserveCommentMarker(raw)) {
+        return true;
+    }
+    return isDirectiveComment(normalizeLineCommentBody(raw.slice(2)));
+}
+export function shouldSkipBlockComment(text, comment) {
+    const raw = text.slice(comment.start, comment.end);
+    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
+        return true;
+    }
+    const body = normalizeBlockCommentBody(raw);
+    return body.trim() === '' || isDirectiveComment(body);
+}
+export function hasPreserveCommentMarker(rawComment) {
+    return rawComment.startsWith('/*!') || rawComment.startsWith('//!');
+}

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

@@ -0,0 +1,9 @@
+import type { CommentRange } from './comment-ranges.js';
+export declare function isStandaloneComment(text: string, comment: CommentRange): boolean;
+export declare function isStandaloneLineComment(text: string, comment: CommentRange): boolean;
+export declare function isStandaloneBlockComment(text: string, comment: {
+    end: number;
+    start: number;
+}): boolean;
+export declare function areCommentsOnAdjacentLines(text: string, previousComment: CommentRange, comment: CommentRange): boolean;
+export declare function isCommentAdjacentBeforeIndex(text: string, comment: CommentRange, index: number): boolean;

package/dist/comments/comment-location.js

@@ -0,0 +1,21 @@
+import { getLineEnd, getLinePrefix, getLineStart } from '../utils/source-lines.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));
+}
+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);
+}
+export function areCommentsOnAdjacentLines(text, previousComment, comment) {
+    return isOnlyNewlineAndIndent(text.slice(previousComment.end, comment.start));
+}
+export function isCommentAdjacentBeforeIndex(text, comment, index) {
+    return isOnlyNewlineAndIndent(text.slice(comment.end, index));
+}
+function isOnlyNewlineAndIndent(text) {
+    return /^(?:\r\n|[\n\r\u2028\u2029])[ \t]*$/u.test(text);
+}

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

@@ -0,0 +1,24 @@
+export type RawComment = {
+    end?: unknown;
+    loc?: {
+        start?: {
+            column?: unknown;
+        };
+    };
+    range?: unknown;
+    start?: unknown;
+    type?: unknown;
+    value?: unknown;
+};
+export type CommentRange = {
+    end: number;
+    kind: 'block' | 'line';
+    start: number;
+};
+export type CommentEntry = {
+    range: CommentRange;
+    raw: RawComment;
+};
+export declare function collectAstComments(ast: unknown): RawComment[];
+export declare function collectCommentEntries(ast: unknown, text: string): CommentEntry[];
+export declare function toCommentRange(comment: RawComment, text: string): CommentRange | undefined;

package/dist/comments/comment-ranges.js

@@ -0,0 +1,36 @@
+import { numberOrUndefined } from '../utils/type-guards.js';
+export function collectAstComments(ast) {
+    if (ast === null || ast === undefined) {
+        return [];
+    }
+    const candidate = ast;
+    if (Array.isArray(candidate.comments)) {
+        return candidate.comments;
+    }
+    if (Array.isArray(candidate.program?.comments)) {
+        return candidate.program.comments;
+    }
+    return [];
+}
+export function collectCommentEntries(ast, text) {
+    return collectAstComments(ast)
+        .map((raw) => ({ range: toCommentRange(raw, text), raw }))
+        .filter((entry) => entry.range !== undefined)
+        .sort((left, right) => left.range.start - right.range.start);
+}
+export function toCommentRange(comment, text) {
+    const range = Array.isArray(comment.range) ? comment.range : undefined;
+    const start = numberOrUndefined(comment.start) ?? numberOrUndefined(range?.[0]);
+    const end = numberOrUndefined(comment.end) ?? numberOrUndefined(range?.[1]);
+    if (start === undefined || end === undefined || start >= end) {
+        return undefined;
+    }
+    const rawStart = text.slice(start, start + 3);
+    if (rawStart.startsWith('//')) {
+        return { end, kind: 'line', start };
+    }
+    if (rawStart.startsWith('/*')) {
+        return { end, kind: 'block', start };
+    }
+    return undefined;
+}

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

@@ -0,0 +1,13 @@
+import type { CommentRange } from './comment-ranges.js';
+import type { SourceRange } from '../utils/ast.js';
+export type EmbeddedExpressionRange = SourceRange & {
+    expression?: SourceRange;
+};
+export type EmbeddedTrailingLineCommentMove = {
+    insertAt: number;
+    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;

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

@@ -0,0 +1,105 @@
+import { getAstNodeRange, visitAstNodes } from '../utils/ast.js';
+import { getLineEnd } from '../utils/source-lines.js';
+import { isRecord, numberOrUndefined } from '../utils/type-guards.js';
+const JSX_EMBEDDED_EXPRESSION_TYPES = new Set(['JSXExpressionContainer', 'JSXSpreadAttribute', 'JSXSpreadChild']);
+export function collectEmbeddedExpressionRanges(ast) {
+    const ranges = [];
+    visitAstNodes(ast, (node) => {
+        const type = node['type'];
+        if (typeof type !== 'string') {
+            return;
+        }
+        if (JSX_EMBEDDED_EXPRESSION_TYPES.has(type)) {
+            const range = getAstNodeRange(node);
+            if (range !== undefined) {
+                const expressionNode = type === 'JSXExpressionContainer' ? node['expression'] : undefined;
+                const expression = isRecord(expressionNode) ? getAstNodeRange(expressionNode) : undefined;
+                ranges.push(expression === undefined ? range : { ...range, expression });
+            }
+            return;
+        }
+        if (type === 'TemplateLiteral') {
+            collectTemplateInterpolationRanges(node, 'expressions', ranges);
+        }
+        else if (type === 'TSTemplateLiteralType') {
+            collectTemplateInterpolationRanges(node, 'types', ranges);
+        }
+    });
+    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);
+    const expression = range?.expression;
+    if (expression === undefined ||
+        expression.end > comment.start ||
+        !/^[\t ]*$/u.test(text.slice(expression.end, comment.start))) {
+        return undefined;
+    }
+    return { insertAt: expression.start, removeStart: expression.end };
+}
+export function doesBlockCommentSeparateEmbeddedTrailingLineComment(text, blockComment, nextComment, ranges) {
+    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;
+    return (range !== undefined &&
+        range === nextRange &&
+        expression !== undefined &&
+        expression.end <= blockComment.start &&
+        /^[\t ]*$/u.test(text.slice(expression.end, blockComment.start)) &&
+        /^[\t ]*$/u.test(text.slice(blockComment.end, nextComment.start)));
+}
+function collectTemplateInterpolationRanges(node, expressionsKey, ranges) {
+    const quasis = node['quasis'];
+    const expressions = node[expressionsKey];
+    if (!Array.isArray(quasis) || !Array.isArray(expressions) || quasis.length !== expressions.length + 1) {
+        return;
+    }
+    for (let index = 0; index < expressions.length; index += 1) {
+        const precedingQuasi = getNodeBoundary(quasis[index]);
+        const followingQuasi = getNodeBoundary(quasis[index + 1]);
+        const expression = getExpressionRange(expressions[index]);
+        if (precedingQuasi === undefined ||
+            followingQuasi === undefined ||
+            expression === undefined ||
+            precedingQuasi.end >= followingQuasi.start) {
+            continue;
+        }
+        ranges.push({ end: followingQuasi.start, expression, start: precedingQuasi.end });
+    }
+}
+function getExpressionRange(value) {
+    return isRecord(value) ? getAstNodeRange(value) : undefined;
+}
+function getNodeBoundary(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const range = Array.isArray(value['range']) ? value['range'] : undefined;
+    const start = numberOrUndefined(value['start']) ?? numberOrUndefined(range?.[0]);
+    const end = numberOrUndefined(value['end']) ?? numberOrUndefined(range?.[1]);
+    if (start === undefined || end === undefined || start > end) {
+        return undefined;
+    }
+    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

@@ -0,0 +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';
+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;

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

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

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

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

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