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

package/dist/utils/ast.js

@@ -0,0 +1,95 @@
+import { isRecord, numberOrUndefined } from './type-guards.js';
+const AST_TRAVERSAL_SKIP_KEYS = new Set([
+    'comments',
+    'errors',
+    'innerComments',
+    'leadingComments',
+    'loc',
+    'parent',
+    'range',
+    'tokens',
+    'trailingComments',
+]);
+export function visitAstNodes(ast, visitor) {
+    const seen = new Set();
+    visit(ast);
+    function visit(value) {
+        if (!isRecord(value) || seen.has(value)) {
+            return;
+        }
+        seen.add(value);
+        if (typeof value['type'] === 'string') {
+            visitor(value);
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (AST_TRAVERSAL_SKIP_KEYS.has(key)) {
+                continue;
+            }
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    visit(item);
+                }
+            }
+            else {
+                visit(child);
+            }
+        }
+    }
+}
+export function getAstNodeRange(node) {
+    const start = numberOrUndefined(node['start']) ?? getRangeNumber(node['range'], 0);
+    const end = numberOrUndefined(node['end']) ?? getRangeNumber(node['range'], 1);
+    if (start === undefined || end === undefined || start >= end) {
+        return undefined;
+    }
+    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;
+    }
+    return numberOrUndefined(range[index]);
+}

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

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

package/dist/utils/display-width.js

@@ -0,0 +1,19 @@
+import { util } from 'prettier';
+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, startColumn = 0) {
+    let column = startColumn;
+    let segmentStart = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] === '\t') {
+            column += util.getStringWidth(text.slice(segmentStart, index));
+            if (tabWidth > 0) {
+                column += tabWidth - (column % tabWidth);
+            }
+            segmentStart = index + 1;
+        }
+    }
+    return column + util.getStringWidth(text.slice(segmentStart)) - startColumn;
+}

package/dist/{shared/markdown.d.ts → utils/format-markdown.d.ts}

@@ -1,2 +1,2 @@
-import type { WrapOptions } from './types.js';
+import type { WrapOptions } from './wrap-options.js';
 export declare function formatMarkdownLines(markdown: string, printWidth: number, options: WrapOptions): Promise<string[]>;

package/dist/utils/format-markdown.js

@@ -0,0 +1,69 @@
+import { format } from 'prettier';
+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(normalizeLineTerminators(markdown));
+    let formatted;
+    try {
+        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');
+    while (isBlankLine(lines[0])) {
+        lines.shift();
+    }
+    while (isBlankLine(lines.at(-1))) {
+        lines.pop();
+    }
+    return lines.join('\n');
+}

package/dist/utils/indentation.d.ts

@@ -0,0 +1,4 @@
+import type { WrapOptions } from './wrap-options.js';
+export declare function getContinuationIndent(text: string, commentStart: number, markerColumn: number, options: WrapOptions): string;
+export declare function getLeadingIndent(text: string): string;
+export declare function makeIndent(column: number, options: WrapOptions): string;

package/dist/utils/indentation.js

@@ -0,0 +1,21 @@
+import { getLinePrefix } from './source-lines.js';
+import { getTabWidth } from './wrap-options.js';
+export function getContinuationIndent(text, commentStart, markerColumn, options) {
+    const linePrefix = getLinePrefix(text, commentStart);
+    if (/^[ \t]*$/u.test(linePrefix)) {
+        return linePrefix;
+    }
+    return makeIndent(markerColumn, options);
+}
+export function getLeadingIndent(text) {
+    return /^[ \t]*/u.exec(text)?.[0] ?? '';
+}
+export function makeIndent(column, options) {
+    const tabWidth = getTabWidth(options);
+    if (options.useTabs === true && tabWidth > 0) {
+        const tabs = Math.floor(column / tabWidth);
+        const spaces = column % tabWidth;
+        return `${'\t'.repeat(tabs)}${' '.repeat(spaces)}`;
+    }
+    return ' '.repeat(column);
+}

package/dist/utils/replacements.d.ts

@@ -0,0 +1,6 @@
+export type Replacement = {
+    end: number;
+    start: number;
+    text: string;
+};
+export declare function applyReplacements(text: string, replacements: Replacement[]): string;

package/dist/utils/replacements.js

@@ -0,0 +1,21 @@
+export function applyReplacements(text, replacements) {
+    let result = text;
+    for (const replacement of getNonOverlappingReplacements(replacements).sort((left, right) => right.start - left.start)) {
+        result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
+    }
+    return result;
+}
+function getNonOverlappingReplacements(replacements) {
+    return [...replacements]
+        .sort((left, right) => left.start - right.start || right.end - left.end)
+        .reduce((accepted, replacement) => {
+        const previous = accepted.at(-1);
+        if (previous === undefined || !rangesOverlap(previous, replacement)) {
+            accepted.push(replacement);
+        }
+        return accepted;
+    }, []);
+}
+function rangesOverlap(left, right) {
+    return left.start < right.end && right.start < left.end;
+}

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

@@ -0,0 +1,7 @@
+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;
+export declare function getLineEnd(text: string, index: number): number;
+export declare function isBlankLine(line: string | undefined): boolean;

package/dist/utils/source-lines.js

@@ -0,0 +1,43 @@
+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';
+    }
+    if (options.endOfLine === 'cr') {
+        return '\r';
+    }
+    if (options.endOfLine === 'auto') {
+        const match = /\r\n|\n|\r/u.exec(text);
+        return match?.[0] ?? '\n';
+    }
+    return '\n';
+}
+export function getLinePrefix(text, index) {
+    return text.slice(getLineStart(text, index), index);
+}
+export function getLineStart(text, index) {
+    for (let cursor = Math.min(index, text.length) - 1; cursor >= 0; cursor -= 1) {
+        const character = text[cursor];
+        if (character === '\n' || character === '\u2028' || character === '\u2029') {
+            return cursor + 1;
+        }
+        if (character === '\r' && text[cursor + 1] !== '\n') {
+            return cursor + 1;
+        }
+    }
+    return 0;
+}
+export function getLineEnd(text, index) {
+    for (let cursor = Math.max(index, 0); cursor < text.length; cursor += 1) {
+        const character = text[cursor];
+        if (character === '\r' || character === '\n' || character === '\u2028' || character === '\u2029') {
+            return character === '\n' && text[cursor - 1] === '\r' ? cursor - 1 : cursor;
+        }
+    }
+    return text.length;
+}
+export function isBlankLine(line) {
+    return line !== undefined && line.trim() === '';
+}

package/dist/utils/type-guards.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function numberOrUndefined(value: unknown): number | undefined;

package/dist/utils/type-guards.js

@@ -0,0 +1,6 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function numberOrUndefined(value) {
+    return typeof value === 'number' ? value : undefined;
+}

package/dist/utils/whitespace.d.ts

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

@@ -0,0 +1,26 @@
+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) {
+        const character = text[cursor];
+        if (character === undefined || !/\s/u.test(character)) {
+            break;
+        }
+        cursor += 1;
+    }
+    return cursor;
+}
+export function trimWhitespaceEnd(text, start, end) {
+    let cursor = end;
+    while (cursor > start) {
+        const character = text[cursor - 1];
+        if (character === undefined || !/\s/u.test(character)) {
+            break;
+        }
+        cursor -= 1;
+    }
+    return cursor;
+}

package/dist/{shared/options.d.ts → utils/wrap-options.d.ts}

@@ -1,4 +1,5 @@
-import type { WrapOptions } from './types.js';
+import type { ParserOptions } from 'prettier';
+export type WrapOptions = Pick<ParserOptions, 'endOfLine' | 'printWidth' | 'tabWidth' | 'useTabs'>;
 export declare function getAvailableContentWidth(options: WrapOptions, contentStartColumn: number): number;
 export declare function getPrintWidth(options: WrapOptions): number;
 export declare function getTabWidth(options: WrapOptions): number;

package/package.json

@@ -5,11 +5,21 @@
   },
   "description": "A Prettier plugin that wraps non-JSDoc JavaScript and TypeScript comments as Markdown.",
   "devDependencies": {
-    "prettier": "3.8.3",
-    "typescript": "6.0.3"
+    "@types/node": "20.19.43",
+    "prettier": "3.9.6",
+    "prettier-plugin-wrap-comments-stable": "npm:@aforemendude/prettier-plugin-wrap-comments@1.0.6",
+    "typescript": "7.0.2",
+    "vite": "8.2.0",
+    "vitest": "4.1.10"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=22.12.0"
+    }
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.0.0"
   },
   "exports": {
     ".": {
@@ -32,7 +42,7 @@
   "main": "./dist/index.js",
   "name": "@aforemendude/prettier-plugin-wrap-comments",
   "peerDependencies": {
-    "prettier": ">=3.0.0"
+    "prettier": ">=3.0.0 <4.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -42,14 +52,20 @@
     "url": "git+https://github.com/aforemendude/prettier-plugin-wrap-comments.git"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "prepack": "npm run verify",
-    "test": "npm run build && node --test test/*.test.mjs",
-    "verify": "npm install && npm run format:check && npm run test"
+    "benchmark": "vitest bench --run",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "clean": "node scripts/clean.mjs",
+    "format": "prettier --write --cache --cache-strategy metadata .",
+    "format:check": "prettier --check --cache --cache-strategy metadata .",
+    "format:nocache": "prettier --write .",
+    "prepack": "npm install && git diff --exit-code -- package-lock.json && npm run verify",
+    "test": "vitest run",
+    "test:integration": "vitest run test/integration",
+    "test:unit": "vitest run test/unit",
+    "typecheck": "tsc -p tsconfig.json",
+    "verify": "prettier --check . && npm run typecheck && npm run build && npm run test"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.6"
+  "version": "1.1.1"
 }

package/dist/comments/core.d.ts

@@ -1,8 +0,0 @@
-import type { CommentRange, RawComment } from '../shared/types.js';
-export declare function collectComments(ast: unknown): RawComment[];
-export declare function toCommentRange(comment: RawComment, text: string): CommentRange | undefined;
-export declare function normalizeLineCommentBody(rawBody: string): string;
-export declare function normalizeBlockCommentBody(rawComment: string): string;
-export declare function isDirectiveComment(body: string): boolean;
-export declare function isPrettierIgnoreComment(body: string): boolean;
-export declare function hasPreserveCommentMarker(rawComment: string): boolean;

package/dist/comments/core.js

@@ -1,114 +0,0 @@
-export function collectComments(ast) {
-    const candidate = ast;
-    if (Array.isArray(candidate.comments)) {
-        return candidate.comments;
-    }
-    if (Array.isArray(candidate.program?.comments)) {
-        return candidate.program.comments;
-    }
-    return [];
-}
-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;
-}
-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');
-}
-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';
-}
-export function hasPreserveCommentMarker(rawComment) {
-    return rawComment.startsWith('/*!') || rawComment.startsWith('//!');
-}
-function isBlankLine(line) {
-    return line !== undefined && line.trim() === '';
-}
-function numberOrUndefined(value) {
-    return typeof value === 'number' ? value : undefined;
-}

package/dist/comments/line.d.ts

@@ -1,6 +0,0 @@
-import type { CommentRange, Replacement, WrapOptions } from '../shared/types.js';
-export declare function wrapLineCommentGroup(text: string, comments: CommentRange[], options: WrapOptions): Promise<Replacement | undefined>;
-export declare function wrapTrailingLineComment(text: string, comment: CommentRange, options: WrapOptions): Promise<Replacement[] | undefined>;
-export declare function shouldSkipLineComment(text: string, comment: CommentRange): boolean;
-export declare function isStandaloneLineComment(text: string, comment: CommentRange): boolean;
-export declare function areAdjacentLineComments(text: string, previous: CommentRange, next: CommentRange): boolean;

package/dist/comments/line.js

@@ -1,108 +0,0 @@
-import { hasPreserveCommentMarker, isDirectiveComment, normalizeLineCommentBody } from './core.js';
-import { formatMarkdownLines } from '../shared/markdown.js';
-import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../shared/options.js';
-import { getColumnAt, getColumns, getContinuationIndent, getLineEnd, getLinePrefix, getLineStart, getPreferredNewline, makeIndent, } from '../shared/text.js';
-export async function wrapLineCommentGroup(text, comments, options) {
-    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 = 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 ? commentText : `${newline}${continuationIndent}${commentText}`;
-    })
-        .join('');
-    const start = firstComment.start;
-    const end = lastComment.end;
-    if (replacementText === text.slice(start, end)) {
-        return undefined;
-    }
-    return {
-        end,
-        start,
-        text: replacementText,
-    };
-}
-export async function wrapTrailingLineComment(text, comment, options) {
-    if (isTrailingLineCommentWithinPrintWidth(text, comment, options)) {
-        return undefined;
-    }
-    const lineStart = getLineStart(text, comment.start);
-    const lineEnd = getLineEnd(text, comment.end);
-    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 indent = getTrailingCommentIndent(codeText, linePrefix, options);
-    const availableWidth = getAvailableContentWidth(options, getColumns(indent, tabWidth) + 3);
-    const formattedLines = await formatMarkdownLines(body, availableWidth, options);
-    const newline = getPreferredNewline(text, options);
-    const leadingCommentText = formattedLines
-        .map((line) => `${indent}${line.length === 0 ? '//' : `// ${line}`}`)
-        .join(newline);
-    const codeEnd = lineStart + codeText.length;
-    return [
-        {
-            end: lineStart,
-            start: lineStart,
-            text: `${leadingCommentText}${newline}`,
-        },
-        {
-            end: lineEnd,
-            start: codeEnd,
-            text: '',
-        },
-    ];
-}
-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 isStandaloneLineComment(text, comment) {
-    return /^[ \t]*$/u.test(getLinePrefix(text, comment.start));
-}
-export function areAdjacentLineComments(text, previous, next) {
-    return /^(?:\r\n|\n|\r)[ \t]*$/u.test(text.slice(previous.end, next.start));
-}
-function isTrailingLineCommentWithinPrintWidth(text, comment, options) {
-    const tabWidth = getTabWidth(options);
-    const lineStart = getLineStart(text, comment.start);
-    const lineEnd = getLineEnd(text, comment.end);
-    const lineText = text.slice(lineStart, lineEnd).replace(/[ \t]+$/u, '');
-    return getColumns(lineText, tabWidth) <= getPrintWidth(options);
-}
-function getLineIndent(linePrefix) {
-    return /^[ \t]*/u.exec(linePrefix)?.[0] ?? '';
-}
-function getTrailingCommentIndent(codeText, linePrefix, options) {
-    const indent = getLineIndent(linePrefix);
-    if (!isClosingDelimiterLine(codeText)) {
-        return indent;
-    }
-    const tabWidth = getTabWidth(options);
-    return makeIndent(getColumns(indent, tabWidth) + tabWidth, options);
-}
-function isClosingDelimiterLine(codeText) {
-    return /^[ \t]*[\])}]+[\])};,]*[ \t]*$/u.test(codeText);
-}

package/dist/comments/wrap.d.ts

@@ -1,3 +0,0 @@
-import type { WrapOptions } from '../shared/types.js';
-export declare function wrapComments<T>(text: string, ast: T, options: WrapOptions): Promise<string>;
-export declare function neutralizePrettierIgnoreForIgnoredComments<T>(text: string, ast: T): T;