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

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/index.d.ts

@@ -1,10 +1,14 @@
 import type { Plugin } from 'prettier';
+declare const name = "@aforemendude/prettier-plugin-wrap-comments";
 declare const parsers: {
     [parserName: string]: import("prettier").Parser<any>;
 };
 declare const printers: {
     [astFormat: string]: import("prettier").Printer<any>;
 };
-declare const plugin: Plugin;
-export { parsers, printers };
+declare const plugin: NamedPlugin;
+export { name, parsers, printers };
 export default plugin;
+interface NamedPlugin extends Plugin {
+    name: string;
+}

package/dist/index.js

@@ -1,10 +1,13 @@
 import { createParsers } from './plugin/create-parsers.js';
 import { createPrinters } from './plugin/create-printers.js';
+import { PLUGIN_NAME } from './plugin/plugin-name.js';
+const name = PLUGIN_NAME;
 const parsers = createParsers();
 const printers = createPrinters();
 const plugin = {
+    name,
     parsers,
     printers,
 };
-export { parsers, printers };
+export { name, parsers, printers };
 export default plugin;

package/dist/plugin/create-parsers.js

@@ -6,6 +6,7 @@ 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';
+import { PLUGIN_NAME } from './plugin-name.js';
 export function createParsers() {
     const parsers = {};
     for (const parserName of SUPPORTED_PARSER_NAMES) {
@@ -18,23 +19,28 @@ export function createParsers() {
     return parsers;
 }
 function createWrappedParser(parserName, parser) {
-    return {
+    const wrappedParser = {
         ...parser,
         async parse(text, options) {
-            const ast = await parser.parse(text, options);
+            const delegate = await resolveParserDelegate(parserName, parser, wrappedParser, options);
+            const ast = await parseWithDelegate(text, delegate, 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);
+            const delegate = await resolveParserDelegate(parserName, parser, wrappedParser, options);
+            const preprocessed = await preprocessWithDelegate(text, delegate, options);
             if (hasOffsetSensitiveFormatting(text, options)) {
                 return preprocessed;
             }
+            if (!preprocessed.includes('//') && !preprocessed.includes('/*')) {
+                return preprocessed;
+            }
             let ast;
             try {
-                ast = await parser.parse(preprocessed, options);
+                ast = await parseWithDelegate(preprocessed, delegate, { ...options, parser: parserName });
             }
             catch {
                 return preprocessed;
@@ -42,12 +48,93 @@ function createWrappedParser(parserName, parser) {
             if (collectAstComments(ast).length === 0) {
                 return preprocessed;
             }
-            const printerLayoutSource = await getPrinterLayoutSource(preprocessed, ast, parserName, parser, options);
+            const printerLayoutSource = await getPrinterLayoutSource(preprocessed, ast, parserName, delegate.parser, createDelegateOptions(options, delegate.plugins));
             const result = await wrapCommentsWithMetadata(preprocessed, ast, options, printerLayoutSource);
             setJsxBlockCommentRewrites(options, result.jsxBlockCommentRewrites);
             return result.text;
         },
     };
+    return wrappedParser;
+}
+async function resolveParserDelegate(parserName, nativeParser, wrappedParser, options) {
+    const plugins = options.plugins ?? [];
+    const wrappedPluginIndex = findWrappedPluginIndex(plugins, parserName, wrappedParser);
+    if (wrappedPluginIndex === -1) {
+        return { parser: nativeParser };
+    }
+    for (let index = wrappedPluginIndex - 1; index >= 0; index -= 1) {
+        const plugin = getPlugin(plugins[index]);
+        const parserEntry = getParserEntry(plugin, parserName);
+        if (parserEntry === undefined) {
+            continue;
+        }
+        const precedingParser = typeof parserEntry === 'function' ? await parserEntry() : parserEntry;
+        if (isParser(precedingParser)) {
+            return {
+                parser: precedingParser,
+                plugins: plugins.slice(0, wrappedPluginIndex),
+            };
+        }
+    }
+    return { parser: nativeParser };
+}
+async function parseWithDelegate(text, delegate, options) {
+    return withDelegatePlugins(options, delegate.plugins, async () => delegate.parser.parse(text, options));
+}
+async function preprocessWithDelegate(text, delegate, options) {
+    const preprocess = delegate.parser.preprocess;
+    if (preprocess === undefined) {
+        return text;
+    }
+    return withDelegatePlugins(options, delegate.plugins, async () => preprocess(text, options));
+}
+async function withDelegatePlugins(options, plugins, callback) {
+    if (plugins === undefined) {
+        return callback();
+    }
+    const originalPlugins = options.plugins;
+    options.plugins = plugins;
+    try {
+        return await callback();
+    }
+    finally {
+        options.plugins = originalPlugins;
+    }
+}
+function createDelegateOptions(options, plugins) {
+    return plugins === undefined ? options : { ...options, plugins };
+}
+function findWrappedPluginIndex(plugins, parserName, wrappedParser) {
+    for (let index = plugins.length - 1; index >= 0; index -= 1) {
+        const plugin = getPlugin(plugins[index]);
+        const parserEntry = getParserEntry(plugin, parserName);
+        if (parserEntry === wrappedParser) {
+            return index;
+        }
+    }
+    for (let index = plugins.length - 1; index >= 0; index -= 1) {
+        const plugin = getPlugin(plugins[index]);
+        const parserEntry = getParserEntry(plugin, parserName);
+        if (plugin?.name === PLUGIN_NAME && parserEntry !== undefined) {
+            return index;
+        }
+    }
+    return -1;
+}
+function getPlugin(plugin) {
+    if (typeof plugin !== 'object' || plugin === null || plugin instanceof URL) {
+        return undefined;
+    }
+    return plugin;
+}
+function getParserEntry(plugin, parserName) {
+    if (plugin?.parsers === undefined || !Object.hasOwn(plugin.parsers, parserName)) {
+        return undefined;
+    }
+    return plugin.parsers[parserName];
+}
+function isParser(value) {
+    return typeof value === 'object' && value !== null && 'parse' in value && typeof value.parse === 'function';
 }
 function hasOffsetSensitiveFormatting(text, options) {
     const cursorOffset = options['cursorOffset'];

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/plugin/plugin-name.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_NAME = "@aforemendude/prettier-plugin-wrap-comments";

package/dist/plugin/plugin-name.js

@@ -0,0 +1 @@
+export const PLUGIN_NAME = '@aforemendude/prettier-plugin-wrap-comments';

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) {