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

package/dist/plugin/create-parsers.js

@@ -0,0 +1,57 @@
+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;
+            }
+            let ast;
+            try {
+                ast = await parser.parse(preprocessed, options);
+            }
+            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/{printers.js → create-printers.js}

@@ -1,22 +1,24 @@
 import { doc } from 'prettier';
 import * as estreePlugin from 'prettier/plugins/estree';
+import { isRecord } from '../utils/type-guards.js';
+import { isRewrittenJsxBlockComment } from './jsx-comment-rewrite-metadata.js';
 const { hardline, indent } = doc.builders;
-export function buildPrinters() {
+export function createPrinters() {
     const estreePrinter = estreePlugin.printers.estree;
     return {
         ...estreePlugin.printers,
         estree: {
             ...estreePrinter,
             print(path, options, print, args) {
-                if (isMultilineEmptyJsxExpressionBlockComment(path.node)) {
-                    return ['{', indent([hardline, path.call(print, 'expression')]), hardline, '}'];
+                if (isRewrittenMultilineEmptyJsxExpressionBlockComment(path.node)) {
+                    return ['{', indent([hardline, print('expression')]), hardline, '}'];
                 }
                 return estreePrinter.print(path, options, print, args);
             },
         },
     };
 }
-function isMultilineEmptyJsxExpressionBlockComment(node) {
+function isRewrittenMultilineEmptyJsxExpressionBlockComment(node) {
     if (!isRecord(node) || node['type'] !== 'JSXExpressionContainer') {
         return false;
     }
@@ -25,15 +27,12 @@ function isMultilineEmptyJsxExpressionBlockComment(node) {
         return false;
     }
     const comments = expression['comments'];
-    return Array.isArray(comments) && comments.some(isMultilineBlockComment);
+    return Array.isArray(comments) && comments.some(isRewrittenMultilineBlockComment);
 }
-function isMultilineBlockComment(comment) {
+function isRewrittenMultilineBlockComment(comment) {
     if (!isRecord(comment) || (comment['type'] !== 'Block' && comment['type'] !== 'CommentBlock')) {
         return false;
     }
     const value = comment['value'];
-    return typeof value === 'string' && value.includes('\n');
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
+    return typeof value === 'string' && value.includes('\n') && 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,27 @@
+import { format } from 'prettier';
+import { createPrinters } from './create-printers.js';
+export async function getPrinterLayoutSource(text, ast, parserName, parser, options) {
+    const printerLayoutPlugin = {
+        parsers: { [parserName]: parser },
+        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);
+        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,6 @@
+export type SourceRange = {
+    end: number;
+    start: number;
+};
+export declare function visitAstNodes(ast: unknown, visitor: (node: Record<string, unknown>) => void): void;
+export declare function getAstNodeRange(node: Record<string, unknown>): SourceRange | undefined;

package/dist/utils/ast.js

@@ -0,0 +1,52 @@
+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 };
+}
+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): 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) {
+    let column = 0;
+    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));
+}

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/{shared/markdown.js → utils/format-markdown.js}

@@ -1,6 +1,6 @@
 import { format } from 'prettier';
-import { getTabWidth } from './options.js';
-import { trimBlankEdges } from './text.js';
+import { isBlankLine } from './source-lines.js';
+import { getTabWidth } from './wrap-options.js';
 export async function formatMarkdownLines(markdown, printWidth, options) {
     const normalized = trimBlankEdges(markdown.replace(/\r\n?/g, '\n'));
     try {
@@ -18,3 +18,13 @@ export async function formatMarkdownLines(markdown, printWidth, options) {
         return normalized.split('\n');
     }
 }
+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,6 @@
+import type { WrapOptions } from './wrap-options.js';
+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,40 @@
+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,2 @@
+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,22 @@
+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,15 @@
   },
   "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.1.5",
+    "vitest": "4.1.10"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.0.0"
   },
   "exports": {
     ".": {
@@ -32,7 +36,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 +46,18 @@
     "url": "git+https://github.com/aforemendude/prettier-plugin-wrap-comments.git"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "clean": "node scripts/clean.mjs",
     "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"
+    "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": "npm run format:check && npm run typecheck && npm run build && npm run test"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.5"
+  "version": "1.1.0"
 }

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;