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

package/dist/comments/wrap-comments.js

@@ -0,0 +1,169 @@
+import { shouldSkipLineComment } from './comment-eligibility.js';
+import { isStandaloneBlockComment, isStandaloneLineComment } from './comment-location.js';
+import { collectCommentEntries } from './comment-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';
+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;
+}
+export async function wrapCommentsWithMetadata(text, ast, options, printerLayoutSource) {
+    const commentEntries = collectCommentEntries(ast, text);
+    const comments = commentEntries.map((entry) => entry.range);
+    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 };
+    }
+    const replacements = [];
+    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) {
+            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], jsxExpressionContainerMatches[index], tabWidth, outputCommentLayout, printerLayout.jsxCommentMarkerColumns);
+            if (jsxLayout?.placement === 'inline') {
+                continue;
+            }
+            const outputLayout = outputCommentLayout === undefined
+                ? undefined
+                : {
+                    markerColumn: outputCommentLayout.markerColumn,
+                    placement: isStandaloneBlockComment(text, comment) ? 'standalone' : 'inline',
+                };
+            const replacement = await wrapBlockComment(text, comment, options, jsxLayout ?? outputLayout);
+            const preservesEmbeddedCommentOrder = doesBlockCommentSeparateEmbeddedTrailingLineComment(text, comment, comments[index + 1], embeddedExpressionRangeMatches[index]?.range, embeddedExpressionRangeMatches[index + 1]?.range);
+            if (Array.isArray(replacement)) {
+                if (!preservesEmbeddedCommentOrder) {
+                    replacements.push(...replacement);
+                }
+            }
+            else if (replacement !== undefined) {
+                replacements.push(replacement);
+                recordSameLineReplacementWidthDelta(text, comment, replacement, outputCommentLayout, tabWidth, sameLineWidthDeltas);
+                if (jsxLayout !== undefined) {
+                    jsxBlockCommentRewrites.push({ blockCommentIndex, text: replacement.text });
+                }
+            }
+            continue;
+        }
+        if (shouldSkipLineComment(text, comment)) {
+            continue;
+        }
+        if (isPrettierIgnoredStandaloneLineComment(text, commentEntries, index)) {
+            index = collectLineCommentGroup(text, comments, index, tabWidth).endIndex;
+            continue;
+        }
+        if (!isStandaloneLineComment(text, comment)) {
+            if (isPrettierIgnoredTrailingLineComment(text, commentEntries, index)) {
+                continue;
+            }
+            const embeddedExpressionRange = embeddedExpressionRangeMatches[index]?.range;
+            const embeddedMove = getEmbeddedTrailingLineCommentMove(text, comment, embeddedExpressionRange);
+            if (embeddedMove === undefined && embeddedExpressionRange !== undefined) {
+                continue;
+            }
+            const trailingLayout = getTrailingLineCommentLayout(text, comment, outputCommentLayout, tabWidth, sameLineWidthDeltas);
+            const replacement = await wrapTrailingLineComment(text, comment, options, trailingLayout, embeddedMove);
+            if (replacement !== undefined) {
+                replacements.push(...replacement);
+            }
+            continue;
+        }
+        const group = collectLineCommentGroup(text, comments, index, tabWidth);
+        index = group.endIndex;
+        const replacement = await wrapLineCommentGroup(text, group.comments, options, outputCommentLayout?.markerColumn);
+        if (replacement !== undefined) {
+            replacements.push(replacement);
+        }
+    }
+    return {
+        jsxBlockCommentRewrites,
+        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-line-comment-group.d.ts

@@ -0,0 +1,4 @@
+import type { CommentRange } from './comment-ranges.js';
+import type { Replacement } from '../utils/replacements.js';
+import type { WrapOptions } from '../utils/wrap-options.js';
+export declare function wrapLineCommentGroup(text: string, comments: CommentRange[], options: WrapOptions, outputMarkerColumn?: number): Promise<Replacement | undefined>;

package/dist/comments/wrap-line-comment-group.js

@@ -0,0 +1,39 @@
+import { normalizeLineCommentBody } from './comment-body.js';
+import { getColumnAt } from '../utils/display-width.js';
+import { formatMarkdownLines } from '../utils/format-markdown.js';
+import { getContinuationIndent } from '../utils/indentation.js';
+import { getPreferredNewline } from '../utils/source-lines.js';
+import { getAvailableContentWidth, getTabWidth } from '../utils/wrap-options.js';
+export async function wrapLineCommentGroup(text, comments, options, outputMarkerColumn) {
+    const firstComment = comments[0];
+    if (firstComment === undefined) {
+        return undefined;
+    }
+    const lastComment = comments.at(-1) ?? firstComment;
+    const bodyLines = comments.map((comment) => normalizeLineCommentBody(text.slice(comment.start + 2, comment.end)));
+    if (bodyLines.every((line) => line.trim() === '')) {
+        return undefined;
+    }
+    const tabWidth = getTabWidth(options);
+    const markerColumn = outputMarkerColumn ?? getColumnAt(text, firstComment.start, tabWidth);
+    const availableWidth = getAvailableContentWidth(options, markerColumn + 3);
+    const formattedLines = await formatMarkdownLines(bodyLines.join('\n'), availableWidth, options);
+    const newline = getPreferredNewline(text, options);
+    const continuationIndent = getContinuationIndent(text, firstComment.start, markerColumn, options);
+    const replacementText = formattedLines
+        .map((line, index) => {
+        const commentText = line.length === 0 ? '//' : `// ${line}`;
+        return `${index === 0 ? '' : continuationIndent}${commentText}`;
+    })
+        .join(newline);
+    const start = firstComment.start;
+    const end = lastComment.end;
+    if (replacementText === text.slice(start, end)) {
+        return undefined;
+    }
+    return {
+        end,
+        start,
+        text: replacementText,
+    };
+}

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

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

package/dist/comments/wrap-trailing-line-comment.js

@@ -0,0 +1,78 @@
+import { normalizeLineCommentBody } from './comment-body.js';
+import { getColumnAt, getColumns } from '../utils/display-width.js';
+import { formatMarkdownLines } from '../utils/format-markdown.js';
+import { getLeadingIndent, makeIndent } from '../utils/indentation.js';
+import { getLineEnd, getLineStart, getPreferredNewline } from '../utils/source-lines.js';
+import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../utils/wrap-options.js';
+export async function wrapTrailingLineComment(text, comment, options, outputLayout, move) {
+    const lineStart = getLineStart(text, comment.start);
+    const lineEnd = getLineEnd(text, comment.start);
+    if (comment.end > lineEnd) {
+        return undefined;
+    }
+    if (isTrailingLineCommentWithinPrintWidth(text, lineStart, lineEnd, options, outputLayout?.lineWidth)) {
+        return undefined;
+    }
+    const linePrefix = text.slice(lineStart, comment.start);
+    const codeText = linePrefix.replace(/[ \t]+$/u, '');
+    if (codeText.trim() === '') {
+        return undefined;
+    }
+    const body = normalizeLineCommentBody(text.slice(comment.start + 2, comment.end));
+    if (body.trim() === '') {
+        return undefined;
+    }
+    const tabWidth = getTabWidth(options);
+    const markerColumn = move === undefined ? undefined : (outputLayout?.lineIndentColumn ?? getColumnAt(text, move.insertAt, tabWidth));
+    const indent = markerColumn === undefined
+        ? getTrailingCommentIndent(codeText, linePrefix, options, outputLayout?.lineIndentColumn)
+        : makeIndent(markerColumn, options);
+    const availableWidth = getAvailableContentWidth(options, getColumns(indent, tabWidth) + 3);
+    const formattedLines = await formatMarkdownLines(body, availableWidth, options);
+    const newline = getPreferredNewline(text, options);
+    const leadingCommentText = buildLeadingCommentText(formattedLines, indent, newline, move !== undefined);
+    const codeEnd = lineStart + codeText.length;
+    const insertAt = move?.insertAt ?? lineStart;
+    const insertionSuffix = move === undefined ? '' : indent;
+    return [
+        {
+            end: insertAt,
+            start: insertAt,
+            text: [leadingCommentText, insertionSuffix].join(newline),
+        },
+        {
+            end: lineEnd,
+            start: move?.removeStart ?? codeEnd,
+            text: '',
+        },
+    ];
+}
+function buildLeadingCommentText(formattedLines, indent, newline, startsAtExpression) {
+    return formattedLines
+        .map((line, index) => {
+        const lineIndent = startsAtExpression && index === 0 ? '' : indent;
+        return `${lineIndent}${line.length === 0 ? '//' : `// ${line}`}`;
+    })
+        .join(newline);
+}
+function isTrailingLineCommentWithinPrintWidth(text, lineStart, lineEnd, options, outputLineWidth) {
+    if (outputLineWidth !== undefined) {
+        return outputLineWidth <= getPrintWidth(options);
+    }
+    const tabWidth = getTabWidth(options);
+    const lineText = text.slice(lineStart, lineEnd).replace(/[ \t]+$/u, '');
+    return getColumns(lineText, tabWidth) <= getPrintWidth(options);
+}
+function getTrailingCommentIndent(codeText, linePrefix, options, outputLineIndentColumn) {
+    const indent = getLeadingIndent(linePrefix);
+    if (outputLineIndentColumn === undefined && !isClosingDelimiterLine(codeText)) {
+        return indent;
+    }
+    const tabWidth = getTabWidth(options);
+    const indentColumn = outputLineIndentColumn ?? getColumns(indent, tabWidth);
+    const commentIndentColumn = isClosingDelimiterLine(codeText) ? indentColumn + tabWidth : indentColumn;
+    return makeIndent(commentIndentColumn, options);
+}
+function isClosingDelimiterLine(codeText) {
+    return /^[ \t]*[\])}]+[\])};,]*[ \t]*$/u.test(codeText);
+}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import type { Plugin } from 'prettier';
 declare const parsers: {
     [parserName: string]: import("prettier").Parser<any>;
-} | undefined;
+};
 declare const printers: {
     [astFormat: string]: import("prettier").Printer<any>;
-} | undefined;
+};
 declare const plugin: Plugin;
 export { parsers, printers };
 export default plugin;

package/dist/index.js

@@ -1,7 +1,7 @@
-import { buildParsers } from './plugin/parsers.js';
-import { buildPrinters } from './plugin/printers.js';
-const parsers = buildParsers();
-const printers = buildPrinters();
+import { createParsers } from './plugin/create-parsers.js';
+import { createPrinters } from './plugin/create-printers.js';
+const parsers = createParsers();
+const printers = createPrinters();
 const plugin = {
     parsers,
     printers,

package/dist/plugin/create-parsers.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'prettier';
+export declare function createParsers(): NonNullable<Plugin['parsers']>;

package/dist/plugin/create-parsers.js

@@ -0,0 +1,60 @@
+import * as babelPlugin from 'prettier/plugins/babel';
+import * as typescriptPlugin from 'prettier/plugins/typescript';
+import { collectAstComments } from '../comments/comment-ranges.js';
+import { neutralizePrettierIgnoreForIgnoredComments } from '../comments/prettier-ignore.js';
+import { wrapCommentsWithMetadata } from '../comments/wrap-comments.js';
+import { getPrinterLayoutSource } from './get-printer-layout-source.js';
+import { markRewrittenJsxBlockComments, setJsxBlockCommentRewrites } from './jsx-comment-rewrite-metadata.js';
+import { SUPPORTED_PARSER_NAMES } from './parser-names.js';
+export function createParsers() {
+    const parsers = {};
+    for (const parserName of SUPPORTED_PARSER_NAMES) {
+        const sourceParsers = parserName === 'typescript' ? typescriptPlugin.parsers : babelPlugin.parsers;
+        const parser = sourceParsers[parserName];
+        if (parser !== undefined) {
+            parsers[parserName] = createWrappedParser(parserName, parser);
+        }
+    }
+    return parsers;
+}
+function createWrappedParser(parserName, parser) {
+    return {
+        ...parser,
+        async parse(text, options) {
+            const ast = await parser.parse(text, options);
+            const neutralizedAst = neutralizePrettierIgnoreForIgnoredComments(text, ast);
+            markRewrittenJsxBlockComments(text, neutralizedAst, options);
+            return neutralizedAst;
+        },
+        async preprocess(text, options) {
+            setJsxBlockCommentRewrites(options, []);
+            const preprocessed = parser.preprocess === undefined ? text : await parser.preprocess(text, options);
+            if (hasOffsetSensitiveFormatting(text, options)) {
+                return preprocessed;
+            }
+            if (!preprocessed.includes('//') && !preprocessed.includes('/*')) {
+                return preprocessed;
+            }
+            let ast;
+            try {
+                ast = await parser.parse(preprocessed, { ...options, parser: parserName });
+            }
+            catch {
+                return preprocessed;
+            }
+            if (collectAstComments(ast).length === 0) {
+                return preprocessed;
+            }
+            const printerLayoutSource = await getPrinterLayoutSource(preprocessed, ast, parserName, parser, options);
+            const result = await wrapCommentsWithMetadata(preprocessed, ast, options, printerLayoutSource);
+            setJsxBlockCommentRewrites(options, result.jsxBlockCommentRewrites);
+            return result.text;
+        },
+    };
+}
+function hasOffsetSensitiveFormatting(text, options) {
+    const cursorOffset = options['cursorOffset'];
+    const hasCursor = typeof cursorOffset === 'number' && cursorOffset >= 0;
+    const hasPartialRange = options.rangeStart > 0 || options.rangeEnd < text.length;
+    return hasCursor || hasPartialRange;
+}

package/dist/plugin/create-printers.d.ts

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

package/dist/plugin/create-printers.js

@@ -0,0 +1,59 @@
+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 {
+        estree: {
+            ...estreePrinter,
+            print(path, options, print, args) {
+                if (isRewrittenMultilineEmptyJsxExpressionBlockComment(path.node)) {
+                    return ['{', indent([hardline, print('expression')]), hardline, '}'];
+                }
+                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);
+            },
+        },
+    };
+}
+function isRewrittenMultilineEmptyJsxExpressionBlockComment(node) {
+    if (!isRecord(node) || node['type'] !== 'JSXExpressionContainer') {
+        return false;
+    }
+    const expression = node['expression'];
+    if (!isRecord(expression) || expression['type'] !== 'JSXEmptyExpression') {
+        return false;
+    }
+    const comments = expression['comments'];
+    return Array.isArray(comments) && comments.some(isRewrittenMultilineBlockComment);
+}
+function isRewrittenMultilineBlockComment(comment) {
+    if (!isRecord(comment) || (comment['type'] !== 'Block' && comment['type'] !== 'CommentBlock')) {
+        return false;
+    }
+    const value = comment['value'];
+    return typeof value === 'string' && /[\r\n\u2028\u2029]/u.test(value) && isRewrittenJsxBlockComment(comment);
+}

package/dist/plugin/get-printer-layout-source.d.ts

@@ -0,0 +1,4 @@
+import type { Parser, ParserOptions } from 'prettier';
+import type { PrinterLayoutSource } from '../comments/printer-layout.js';
+import type { SupportedParserName } from './parser-names.js';
+export declare function getPrinterLayoutSource<T>(text: string, ast: T, parserName: SupportedParserName, parser: Parser<T>, options: ParserOptions): Promise<PrinterLayoutSource | undefined>;

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

@@ -0,0 +1,35 @@
+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]: printerLayoutParser },
+        printers: createPrinters(),
+    };
+    try {
+        const formattedText = await format(text, {
+            ...options,
+            endOfLine: 'lf',
+            parser: parserName,
+            plugins: [printerLayoutPlugin],
+        });
+        if (formattedText === text) {
+            return { ast, text };
+        }
+        const formattedAst = await parser.parse(formattedText, { ...options, parser: parserName });
+        return {
+            ast: formattedAst,
+            text: formattedText,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/plugin/jsx-comment-rewrite-metadata.d.ts

@@ -0,0 +1,8 @@
+import type { ParserOptions } from 'prettier';
+export type JsxBlockCommentRewrite = {
+    blockCommentIndex: number;
+    text: string;
+};
+export declare function setJsxBlockCommentRewrites(options: ParserOptions, rewrites: readonly JsxBlockCommentRewrite[]): void;
+export declare function markRewrittenJsxBlockComments(text: string, ast: unknown, options: ParserOptions): void;
+export declare function isRewrittenJsxBlockComment(comment: unknown): boolean;

package/dist/plugin/jsx-comment-rewrite-metadata.js

@@ -0,0 +1,40 @@
+import { collectAstComments } from '../comments/comment-ranges.js';
+import { getAstNodeRange } from '../utils/ast.js';
+import { isRecord } from '../utils/type-guards.js';
+const jsxBlockCommentRewritesKey = Symbol('jsxBlockCommentRewrites');
+const rewrittenJsxBlockCommentKey = Symbol('rewrittenJsxBlockComment');
+export function setJsxBlockCommentRewrites(options, rewrites) {
+    const metadataOptions = options;
+    if (rewrites.length === 0) {
+        delete metadataOptions[jsxBlockCommentRewritesKey];
+        return;
+    }
+    metadataOptions[jsxBlockCommentRewritesKey] = [...rewrites];
+}
+export function markRewrittenJsxBlockComments(text, ast, options) {
+    const metadataOptions = options;
+    const rewrites = metadataOptions[jsxBlockCommentRewritesKey];
+    delete metadataOptions[jsxBlockCommentRewritesKey];
+    if (rewrites === undefined) {
+        return;
+    }
+    const blockComments = collectAstComments(ast)
+        .filter(isBlockComment)
+        .sort((left, right) => getCommentStart(left) - getCommentStart(right));
+    for (const rewrite of rewrites) {
+        const comment = blockComments[rewrite.blockCommentIndex];
+        const range = comment === undefined ? undefined : getAstNodeRange(comment);
+        if (comment !== undefined && range !== undefined && text.slice(range.start, range.end) === rewrite.text) {
+            comment[rewrittenJsxBlockCommentKey] = true;
+        }
+    }
+}
+export function isRewrittenJsxBlockComment(comment) {
+    return isRecord(comment) && comment[rewrittenJsxBlockCommentKey] === true;
+}
+function isBlockComment(comment) {
+    return isRecord(comment) && (comment['type'] === 'Block' || comment['type'] === 'CommentBlock');
+}
+function getCommentStart(comment) {
+    return getAstNodeRange(comment)?.start ?? Number.POSITIVE_INFINITY;
+}

package/dist/plugin/parser-names.d.ts

@@ -0,0 +1,2 @@
+export declare const SUPPORTED_PARSER_NAMES: readonly ['babel', 'babel-ts', 'typescript'];
+export type SupportedParserName = (typeof SUPPORTED_PARSER_NAMES)[number];

package/dist/plugin/parser-names.js

@@ -0,0 +1 @@
+export const SUPPORTED_PARSER_NAMES = ['babel', 'babel-ts', 'typescript'];

package/dist/utils/ast.d.ts

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