@aforemendude/prettier-plugin-wrap-comments 1.0.2

package/README.md

@@ -0,0 +1,79 @@
+# @aforemendude/prettier-plugin-wrap-comments
+
+A Prettier plugin that wraps non-JSDoc JavaScript and TypeScript comments as Markdown. It uses the comment marker's real
+column to calculate the available content width, so nested comments wrap more narrowly than top-level comments.
+
+## Install
+
+```sh
+npm install --save-dev @aforemendude/prettier-plugin-wrap-comments prettier
+```
+
+## Use
+
+Add the plugin to your Prettier config:
+
+```json
+{
+  "plugins": ["@aforemendude/prettier-plugin-wrap-comments"]
+}
+```
+
+Then run Prettier normally:
+
+```sh
+npx prettier --write .
+```
+
+## Behavior
+
+The plugin wraps standalone `//` and `/* ... */` comments before Prettier parses the file, then delegates formatting to
+Prettier's built-in JavaScript and TypeScript parsers.
+
+```ts
+function example() {
+  // This long paragraph is wrapped as Markdown, and the nested indentation is
+  // subtracted from the configured print width.
+  return true;
+}
+```
+
+JSDoc comments are left unchanged:
+
+```ts
+/**
+ * This documentation comment is not wrapped by the plugin.
+ */
+```
+
+Tooling directives such as `eslint-disable`, `@ts-expect-error`, `prettier-ignore`, source maps, and TypeScript
+triple-slash directives are also left untouched so their meaning is not changed. Trailing comments after code stay in
+place when the full line fits the configured print width. If the line is too long, the comment is moved above the code
+and wrapped there.
+
+## Supported Parsers
+
+- `babel`
+- `babel-ts`
+- `typescript`
+
+## Development
+
+```sh
+npm install
+npm run check
+```
+
+## Publishing
+
+The npm package name is `@aforemendude/prettier-plugin-wrap-comments`.
+
+Before publishing, make sure the version in `package.json` has been updated, then run:
+
+```sh
+npm run check
+npm publish --access public
+```
+
+The package scripts already run the important publish checks: `prepublishOnly` runs `npm run check`, and `prepack`
+builds the `dist` files that are included in the published package.

package/dist/comments/block.d.ts

@@ -0,0 +1,2 @@
+import type { CommentRange, Replacement, WrapOptions } from '../shared/types.js';
+export declare function wrapBlockComment(text: string, comment: CommentRange, options: WrapOptions): Promise<Replacement | undefined>;

package/dist/comments/block.js

@@ -0,0 +1,43 @@
+import { isDirectiveComment, normalizeBlockCommentBody } from './core.js';
+import { formatMarkdownLines } from '../shared/markdown.js';
+import { getAvailableContentWidth, getPrintWidth, getTabWidth } from '../shared/options.js';
+import { getColumnAt, getColumns, getLinePrefix, getPreferredNewline, isStandaloneBlockComment, } from '../shared/text.js';
+export async function wrapBlockComment(text, comment, options) {
+    const raw = text.slice(comment.start, comment.end);
+    if (raw.startsWith('/**')) {
+        return undefined;
+    }
+    const markdown = normalizeBlockCommentBody(raw);
+    if (markdown.trim() === '' || isDirectiveComment(markdown)) {
+        return undefined;
+    }
+    const tabWidth = getTabWidth(options);
+    const markerColumn = getColumnAt(text, comment.start, tabWidth);
+    const availableWidth = getAvailableContentWidth(options, markerColumn + 3);
+    const formattedLines = await formatMarkdownLines(markdown, availableWidth, options);
+    const replacementText = buildBlockReplacement(text, comment, formattedLines, options);
+    if (replacementText === undefined || replacementText === text.slice(comment.start, comment.end)) {
+        return undefined;
+    }
+    return {
+        end: comment.end,
+        start: comment.start,
+        text: replacementText,
+    };
+}
+function buildBlockReplacement(text, comment, formattedLines, options) {
+    const tabWidth = getTabWidth(options);
+    const markerColumn = getColumnAt(text, comment.start, tabWidth);
+    const singleLine = `/* ${formattedLines.join(' ')} */`;
+    const singleLineWidth = getColumns(singleLine, tabWidth);
+    if (formattedLines.length === 1 && markerColumn + singleLineWidth <= getPrintWidth(options)) {
+        return singleLine;
+    }
+    if (!isStandaloneBlockComment(text, comment)) {
+        return undefined;
+    }
+    const newline = getPreferredNewline(text, options);
+    const indent = getLinePrefix(text, comment.start);
+    const body = formattedLines.map((line) => `${indent} *${line.length === 0 ? '' : ` ${line}`}`).join(newline);
+    return `/*${newline}${body}${newline}${indent} */`;
+}

package/dist/comments/core.d.ts

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

package/dist/comments/core.js

@@ -0,0 +1,74 @@
+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 };
+    }
+    if (typeof comment.type === 'string') {
+        if (comment.type.includes('Line')) {
+            return { end, kind: 'line', start };
+        }
+        if (comment.type.includes('Block')) {
+            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');
+}
+export function isDirectiveComment(body) {
+    return /^(?:@(?:__NO_SIDE_EFFECTS__|__PURE__|jsx|jsxImportSource|license|preserve|ts-check|ts-expect-error|ts-ignore|ts-nocheck)\b|#\s*sourceMappingURL=|[@#]__PURE__\b|biome-ignore\b|c8\b|deno-lint-ignore\b|eslint\b|eslint-|exported\b|globals?\b|istanbul\b|jshint\b|nyc\b|oxlint\b|prettier-ignore\b|prettier-ignore-start\b|prettier-ignore-end\b|sourceMappingURL=|stylelint\b|tslint\b|v8\b|vite-ignore\b|webpack(?:ChunkName|Exclude|Ignore|Include|Mode|Prefetch|Preload)\b)/u.test(body.trimStart());
+}
+function isBlankLine(line) {
+    return line !== undefined && line.trim() === '';
+}
+function numberOrUndefined(value) {
+    return typeof value === 'number' ? value : undefined;
+}

package/dist/comments/line.d.ts

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

@@ -0,0 +1,90 @@
+import { 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, } 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 = getLineIndent(linePrefix);
+    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 replacementText = `${leadingCommentText}${newline}${codeText}`;
+    return {
+        end: lineEnd,
+        start: lineStart,
+        text: replacementText,
+    };
+}
+export function shouldSkipLineComment(text, comment) {
+    const raw = text.slice(comment.start, comment.end);
+    if (raw.startsWith('///')) {
+        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] ?? '';
+}

package/dist/comments/wrap.d.ts

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

package/dist/comments/wrap.js

@@ -0,0 +1,62 @@
+import { wrapBlockComment } from './block.js';
+import { collectComments, toCommentRange } from './core.js';
+import { areAdjacentLineComments, isStandaloneLineComment, shouldSkipLineComment, wrapLineCommentGroup, wrapTrailingLineComment, } from './line.js';
+import { getTabWidth } from '../shared/options.js';
+import { applyReplacements, getColumnAt } from '../shared/text.js';
+export async function wrapComments(text, ast, options) {
+    const comments = collectComments(ast)
+        .map((comment) => toCommentRange(comment, text))
+        .filter((comment) => comment !== undefined)
+        .sort((left, right) => left.start - right.start);
+    if (comments.length === 0) {
+        return text;
+    }
+    const replacements = [];
+    const tabWidth = getTabWidth(options);
+    for (let index = 0; index < comments.length; index += 1) {
+        const comment = comments[index];
+        if (comment === undefined) {
+            continue;
+        }
+        if (comment.kind === 'block') {
+            const replacement = await wrapBlockComment(text, comment, options);
+            if (replacement !== undefined) {
+                replacements.push(replacement);
+            }
+            continue;
+        }
+        if (shouldSkipLineComment(text, comment)) {
+            continue;
+        }
+        if (!isStandaloneLineComment(text, comment)) {
+            const replacement = await wrapTrailingLineComment(text, comment, options);
+            if (replacement !== undefined) {
+                replacements.push(replacement);
+            }
+            continue;
+        }
+        const group = [comment];
+        let previousComment = comment;
+        while (index + 1 < comments.length) {
+            const nextComment = comments[index + 1];
+            if (nextComment === undefined) {
+                break;
+            }
+            if (nextComment.kind !== 'line' ||
+                !isStandaloneLineComment(text, nextComment) ||
+                shouldSkipLineComment(text, nextComment) ||
+                !areAdjacentLineComments(text, previousComment, nextComment) ||
+                getColumnAt(text, comment.start, tabWidth) !== getColumnAt(text, nextComment.start, tabWidth)) {
+                break;
+            }
+            group.push(nextComment);
+            previousComment = nextComment;
+            index += 1;
+        }
+        const replacement = await wrapLineCommentGroup(text, group, options);
+        if (replacement !== undefined) {
+            replacements.push(replacement);
+        }
+    }
+    return applyReplacements(text, replacements);
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,10 @@
+import * as estreePlugin from 'prettier/plugins/estree';
+import { buildParsers } from './plugin/parsers.js';
+const parsers = buildParsers();
+const printers = estreePlugin.printers;
+const plugin = {
+    parsers,
+    printers,
+};
+export { parsers, printers };
+export default plugin;

package/dist/plugin/parsers.d.ts

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

package/dist/plugin/parsers.js

@@ -0,0 +1,31 @@
+import * as babelPlugin from 'prettier/plugins/babel';
+import * as typescriptPlugin from 'prettier/plugins/typescript';
+import { wrapComments } from '../comments/wrap.js';
+const parserNames = ['babel', 'babel-ts', 'typescript'];
+function wrapParser(parser) {
+    return {
+        ...parser,
+        async preprocess(text, options) {
+            const preprocessed = parser.preprocess === undefined ? text : await parser.preprocess(text, options);
+            let ast;
+            try {
+                ast = await parser.parse(preprocessed, options);
+            }
+            catch {
+                return preprocessed;
+            }
+            return wrapComments(preprocessed, ast, options);
+        },
+    };
+}
+export function buildParsers() {
+    const parsers = {};
+    for (const parserName of parserNames) {
+        const sourceParsers = parserName === 'typescript' ? typescriptPlugin.parsers : babelPlugin.parsers;
+        const parser = sourceParsers[parserName];
+        if (parser !== undefined) {
+            parsers[parserName] = wrapParser(parser);
+        }
+    }
+    return parsers;
+}

package/dist/shared/markdown.d.ts

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

package/dist/shared/markdown.js

@@ -0,0 +1,20 @@
+import { format } from 'prettier';
+import { getTabWidth } from './options.js';
+import { trimBlankEdges } from './text.js';
+export async function formatMarkdownLines(markdown, printWidth, options) {
+    const normalized = trimBlankEdges(markdown.replace(/\r\n?/g, '\n'));
+    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');
+    }
+    catch {
+        return normalized.split('\n');
+    }
+}

package/dist/shared/options.d.ts

@@ -0,0 +1,4 @@
+import type { WrapOptions } from './types.js';
+export declare function getAvailableContentWidth(options: WrapOptions, contentStartColumn: number): number;
+export declare function getPrintWidth(options: WrapOptions): number;
+export declare function getTabWidth(options: WrapOptions): number;

package/dist/shared/options.js

@@ -0,0 +1,11 @@
+const DEFAULT_PRINT_WIDTH = 80;
+const DEFAULT_TAB_WIDTH = 2;
+export function getAvailableContentWidth(options, contentStartColumn) {
+    return Math.max(1, getPrintWidth(options) - contentStartColumn);
+}
+export function getPrintWidth(options) {
+    return typeof options.printWidth === 'number' ? options.printWidth : DEFAULT_PRINT_WIDTH;
+}
+export function getTabWidth(options) {
+    return typeof options.tabWidth === 'number' ? options.tabWidth : DEFAULT_TAB_WIDTH;
+}

package/dist/shared/text.d.ts

@@ -0,0 +1,14 @@
+import type { Replacement, WrapOptions } from './types.js';
+export declare function applyReplacements(text: string, replacements: Replacement[]): string;
+export declare function getPreferredNewline(text: string, options: WrapOptions): string;
+export declare function getContinuationIndent(text: string, commentStart: number, markerColumn: number, 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 getColumnAt(text: string, index: number, tabWidth: number): number;
+export declare function getColumns(text: string, tabWidth: number): number;
+export declare function isStandaloneBlockComment(text: string, comment: {
+    end: number;
+    start: number;
+}): boolean;
+export declare function trimBlankEdges(markdown: string): string;

package/dist/shared/text.js

@@ -0,0 +1,84 @@
+import { getTabWidth } from './options.js';
+export function applyReplacements(text, replacements) {
+    let result = text;
+    for (const replacement of [...replacements].sort((left, right) => right.start - left.start)) {
+        result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
+    }
+    return result;
+}
+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 getContinuationIndent(text, commentStart, markerColumn, options) {
+    const linePrefix = getLinePrefix(text, commentStart);
+    if (/^[ \t]*$/u.test(linePrefix)) {
+        return linePrefix;
+    }
+    return makeIndent(markerColumn, options);
+}
+export function getLinePrefix(text, index) {
+    return text.slice(getLineStart(text, index), index);
+}
+export function getLineStart(text, index) {
+    const newlineIndex = text.lastIndexOf('\n', index - 1);
+    return newlineIndex === -1 ? 0 : newlineIndex + 1;
+}
+export function getLineEnd(text, index) {
+    const newlineIndex = text.indexOf('\n', index);
+    if (newlineIndex === -1) {
+        return text.length;
+    }
+    return text[newlineIndex - 1] === '\r' ? newlineIndex - 1 : newlineIndex;
+}
+export function getColumnAt(text, index, tabWidth) {
+    return getColumns(text.slice(getLineStart(text, index), index), tabWidth);
+}
+export function getColumns(text, tabWidth) {
+    let column = 0;
+    for (const character of text) {
+        if (character === '\t') {
+            column += tabWidth - (column % tabWidth);
+        }
+        else {
+            column += 1;
+        }
+    }
+    return column;
+}
+export function isStandaloneBlockComment(text, comment) {
+    const before = text.slice(getLineStart(text, comment.start), comment.start);
+    const after = text.slice(comment.end, getLineEnd(text, comment.end));
+    return /^[ \t]*$/u.test(before) && /^[ \t]*$/u.test(after);
+}
+export 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');
+}
+function isBlankLine(line) {
+    return line !== undefined && line.trim() === '';
+}
+function makeIndent(column, options) {
+    const tabWidth = getTabWidth(options);
+    if (options.useTabs === true) {
+        const tabs = Math.floor(column / tabWidth);
+        const spaces = column % tabWidth;
+        return `${'\t'.repeat(tabs)}${' '.repeat(spaces)}`;
+    }
+    return ' '.repeat(column);
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,30 @@
+import type { ParserOptions } from 'prettier';
+export type AstWithComments = {
+    comments?: unknown;
+    program?: {
+        comments?: unknown;
+    };
+};
+export type RawComment = {
+    end?: unknown;
+    loc?: {
+        start?: {
+            column?: unknown;
+        };
+    };
+    range?: unknown;
+    start?: unknown;
+    type?: unknown;
+    value?: unknown;
+};
+export type CommentRange = {
+    end: number;
+    kind: 'block' | 'line';
+    start: number;
+};
+export type Replacement = {
+    end: number;
+    start: number;
+    text: string;
+};
+export type WrapOptions = Pick<ParserOptions, 'endOfLine' | 'printWidth' | 'tabWidth' | 'useTabs'>;

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "author": "aforemendude",
+  "bugs": {
+    "url": "https://github.com/aforemendude/prettier-plugin-wrap-comments/issues"
+  },
+  "description": "A Prettier plugin that wraps non-JSDoc JavaScript and TypeScript comments as Markdown.",
+  "devDependencies": {
+    "prettier": "3.8.3",
+    "typescript": "6.0.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/aforemendude/prettier-plugin-wrap-comments",
+  "keywords": [
+    "prettier",
+    "prettier-plugin",
+    "comments",
+    "markdown",
+    "typescript"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "name": "@aforemendude/prettier-plugin-wrap-comments",
+  "peerDependencies": {
+    "prettier": ">=3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "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"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "1.0.2"
+}