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

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,9 @@ 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 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
@@ -37,9 +63,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 +85,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() {
@@ -138,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
 
@@ -149,13 +188,51 @@ 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,
+`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 benchmark
 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.
+
+`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.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, 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);
+}
+export function normalizeLineCommentBody(rawBody) {
+    if (rawBody.trim() === '') {
+        return '';
+    }
+    return rawBody.replace(/^[ \t]?/, '').replace(/[ \t]+$/u, '');
+}
+export function normalizeBlockCommentBody(rawComment) {
+    const body = normalizeLineTerminators(rawComment.slice(2, -2));
+    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,52 @@
+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,
+    /^[@#]__(?: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,
+    /^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,
+    /^prettier-ignore-start\b/u,
+    /^prettier-ignore-end\b/u,
+    /^stylelint\b/u,
+    /^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,
+];
+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,5 @@
+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

@@ -0,0 +1,23 @@
+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) || hasFlowCommentTypeMarker(raw)) {
+        return true;
+    }
+    const body = normalizeBlockCommentBody(raw);
+    return body.trim() === '' || isDirectiveComment(body);
+}
+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.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,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 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 isOnlyHorizontalWhitespace(before) && isOnlyHorizontalWhitespace(after);
+}
+export function areCommentsOnAdjacentLines(text, previousComment, comment) {
+    return isOnlyHorizontalWhitespaceAroundNewline(text.slice(previousComment.end, comment.start));
+}
+export function isCommentAdjacentBeforeIndex(text, comment, index) {
+    return isOnlyHorizontalWhitespaceAroundNewline(text.slice(comment.end, index));
+}
+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/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,12 @@
+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 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

@@ -0,0 +1,117 @@
+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 = [];
+    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 getEmbeddedTrailingLineCommentMove(text, comment, range) {
+    const expression = range?.expression;
+    if (range === undefined || expression === undefined) {
+        return undefined;
+    }
+    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, range, nextRange) {
+    if (blockComment.kind !== 'block' ||
+        nextComment?.kind !== 'line' ||
+        blockComment.end >= nextComment.start ||
+        nextComment.end > getLineEnd(text, blockComment.start)) {
+        return false;
+    }
+    const expression = range?.expression;
+    const rootExpression = range === undefined || expression === undefined
+        ? undefined
+        : getRootExpressionRangeBefore(text, expression, blockComment.start, range.start);
+    return (range !== undefined &&
+        range === nextRange &&
+        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];
+    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 };
+}

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 { 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, containerMatch: ContainingRangeMatch<JsxExpressionContainerRange> | undefined, tabWidth: number, outputCommentLayout: PrinterCommentLayout | undefined, outputCommentMarkerColumns: Array<number | undefined>): BlockCommentLayout | undefined;