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

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 neutralizePrettierIgnoreForIgnoredBlockComments<T>(text: string, ast: T): T;

package/dist/comments/wrap.js

@@ -1,375 +0,0 @@
-import { wrapBlockComment } from './block.js';
-import { collectComments, hasPreserveCommentMarker, isDirectiveComment, isPrettierIgnoreComment, normalizeBlockCommentBody, normalizeLineCommentBody, toCommentRange, } from './core.js';
-import { areAdjacentLineComments, isStandaloneLineComment, shouldSkipLineComment, wrapLineCommentGroup, wrapTrailingLineComment, } from './line.js';
-import { getTabWidth } from '../shared/options.js';
-import { applyReplacements, getColumnAt, getColumns, getLineEnd, getLinePrefix, getLineStart, isStandaloneBlockComment, } from '../shared/text.js';
-const NEUTRALIZED_PRETTIER_IGNORE_COMMENT = 'prettier-ignore wrap-comments';
-const AST_TRAVERSAL_SKIP_KEYS = new Set([
-    'comments',
-    'errors',
-    'innerComments',
-    'leadingComments',
-    'loc',
-    'parent',
-    'range',
-    'tokens',
-    'trailingComments',
-]);
-export async function wrapComments(text, ast, options) {
-    const commentEntries = collectSortedCommentEntries(ast, text);
-    const comments = commentEntries.map((entry) => entry.range);
-    const jsxExpressionContainers = collectJsxExpressionContainerRanges(ast);
-    const ignoredLineRanges = collectPrettierIgnoredLineRanges(text, ast, commentEntries);
-    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 (isCommentInIgnoredLineRange(comment, ignoredLineRanges)) {
-            continue;
-        }
-        if (comment.kind === 'block') {
-            if (isPrettierIgnoredBlockComment(text, commentEntries, index)) {
-                continue;
-            }
-            const jsxLayout = getJsxExpressionBlockCommentLayout(text, comment, jsxExpressionContainers, tabWidth);
-            if (jsxLayout?.placement === 'inline') {
-                continue;
-            }
-            const replacement = await wrapBlockComment(text, comment, options, jsxLayout);
-            if (Array.isArray(replacement)) {
-                replacements.push(...replacement);
-            }
-            else if (replacement !== undefined) {
-                replacements.push(replacement);
-            }
-            continue;
-        }
-        if (shouldSkipLineComment(text, comment)) {
-            continue;
-        }
-        if (!isStandaloneLineComment(text, comment)) {
-            if (isPrettierIgnoredTrailingLineComment(text, commentEntries, index)) {
-                continue;
-            }
-            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);
-}
-export function neutralizePrettierIgnoreForIgnoredBlockComments(text, ast) {
-    const comments = collectSortedCommentEntries(ast, text);
-    for (let index = 0; index < comments.length; index += 1) {
-        const entry = comments[index];
-        const previousEntry = comments[index - 1];
-        if (entry !== undefined &&
-            previousEntry !== undefined &&
-            isPrettierIgnoredBlockComment(text, comments, index) &&
-            !isBlockCommentNormallyIgnored(text, entry.range)) {
-            previousEntry.raw.value = NEUTRALIZED_PRETTIER_IGNORE_COMMENT;
-        }
-    }
-    return ast;
-}
-function collectSortedCommentEntries(ast, text) {
-    return collectComments(ast)
-        .map((raw) => ({ range: toCommentRange(raw, text), raw }))
-        .filter((entry) => entry.range !== undefined)
-        .sort((left, right) => left.range.start - right.range.start);
-}
-function collectPrettierIgnoredLineRanges(text, ast, comments) {
-    const nodeRanges = collectAstNodeRanges(ast);
-    const ignoredLineRanges = [];
-    for (let index = 0; index < comments.length; index += 1) {
-        const comment = comments[index]?.range;
-        if (comment === undefined ||
-            !isStandaloneComment(text, comment) ||
-            !isPrettierIgnoreComment(getCommentBody(text, comment))) {
-            continue;
-        }
-        const targetStart = getPrettierIgnoreTargetStart(text, comments, index);
-        if (targetStart === undefined) {
-            continue;
-        }
-        const targetRange = nodeRanges.find((range) => range.start === targetStart);
-        if (targetRange === undefined) {
-            continue;
-        }
-        ignoredLineRanges.push({
-            end: getLineEnd(text, targetRange.end),
-            start: getLineStart(text, targetRange.start),
-        });
-    }
-    return ignoredLineRanges;
-}
-function collectAstNodeRanges(ast) {
-    const ranges = [];
-    const seen = new Set();
-    visit(ast);
-    return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
-    function visit(value) {
-        if (!isRecord(value) || seen.has(value)) {
-            return;
-        }
-        seen.add(value);
-        const range = getAstNodeRange(value);
-        if (range !== undefined && typeof value['type'] === 'string') {
-            ranges.push(range);
-        }
-        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);
-            }
-        }
-    }
-}
-function collectJsxExpressionContainerRanges(ast) {
-    const ranges = [];
-    const seen = new Set();
-    visit(ast);
-    return ranges.sort((left, right) => left.start - right.start || right.end - left.end);
-    function visit(value) {
-        if (!isRecord(value) || seen.has(value)) {
-            return;
-        }
-        seen.add(value);
-        if (value['type'] === 'JSXExpressionContainer') {
-            const range = getAstNodeRange(value);
-            if (range !== undefined) {
-                ranges.push(range);
-            }
-        }
-        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);
-            }
-        }
-    }
-}
-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]);
-}
-function getPrettierIgnoreTargetStart(text, comments, ignoreCommentIndex) {
-    const ignoreComment = comments[ignoreCommentIndex]?.range;
-    if (ignoreComment === undefined) {
-        return undefined;
-    }
-    let cursor = ignoreComment.end;
-    for (let index = ignoreCommentIndex + 1; index < comments.length; index += 1) {
-        cursor = skipWhitespace(text, cursor);
-        const comment = comments[index]?.range;
-        if (comment === undefined || comment.start !== cursor) {
-            break;
-        }
-        if (!isStandaloneComment(text, comment) || !isCommentNormallyIgnored(text, comment)) {
-            return undefined;
-        }
-        cursor = comment.end;
-    }
-    const targetStart = skipWhitespace(text, cursor);
-    return targetStart >= text.length ? undefined : targetStart;
-}
-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;
-}
-function isCommentInIgnoredLineRange(comment, ignoredLineRanges) {
-    return ignoredLineRanges.some((range) => comment.start >= range.start && comment.start < range.end);
-}
-function getJsxExpressionBlockCommentLayout(text, comment, jsxExpressionContainers, tabWidth) {
-    const container = getSmallestContainingRange(comment, jsxExpressionContainers);
-    if (container === undefined || text[container.start] !== '{' || text[container.end - 1] !== '}') {
-        return undefined;
-    }
-    const expressionTextBeforeComment = text.slice(container.start + 1, comment.start).trim();
-    const expressionTextAfterComment = text.slice(comment.end, container.end - 1).trim();
-    const containerOutputColumn = getJsxExpressionContainerOutputColumn(text, container, tabWidth);
-    if (expressionTextBeforeComment === '' && expressionTextAfterComment === '') {
-        return { contentColumn: containerOutputColumn + tabWidth + 3, multilineIndent: '', placement: 'standalone' };
-    }
-    if (expressionTextBeforeComment !== '' && expressionTextAfterComment === '') {
-        const expressionStart = skipWhitespace(text, container.start + 1);
-        const expressionEnd = trimWhitespaceEnd(text, container.start + 1, comment.start);
-        const removalEnd = Math.min(skipWhitespace(text, comment.end), container.end - 1);
-        return {
-            contentColumn: containerOutputColumn + tabWidth + 3,
-            multilineIndent: '',
-            placement: 'trailing',
-            trailingMove: {
-                insertAt: expressionStart,
-                removeEnd: removalEnd,
-                removeStart: expressionEnd,
-            },
-        };
-    }
-    return { placement: 'inline' };
-}
-function getJsxExpressionContainerOutputColumn(text, container, tabWidth) {
-    const linePrefix = getLinePrefix(text, container.start);
-    if (/^[ \t]*$/u.test(linePrefix)) {
-        return getColumns(linePrefix, tabWidth);
-    }
-    const lineIndent = /^[ \t]*/u.exec(linePrefix)?.[0] ?? '';
-    return getColumns(lineIndent, tabWidth) + tabWidth;
-}
-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;
-}
-function getSmallestContainingRange(comment, ranges) {
-    let containingRange;
-    for (const range of ranges) {
-        if (comment.start <= range.start || comment.end >= range.end) {
-            continue;
-        }
-        if (containingRange === undefined || range.end - range.start < containingRange.end - containingRange.start) {
-            containingRange = range;
-        }
-    }
-    return containingRange;
-}
-function isPrettierIgnoredBlockComment(text, comments, index) {
-    const comment = comments[index]?.range;
-    const previousComment = comments[index - 1]?.range;
-    if (comment === undefined || comment.kind !== 'block' || previousComment === undefined) {
-        return false;
-    }
-    if (!isStandaloneComment(text, previousComment) || !isAdjacentPreviousComment(text, previousComment, comment)) {
-        return false;
-    }
-    return isPrettierIgnoreComment(getCommentBody(text, previousComment));
-}
-function isPrettierIgnoredTrailingLineComment(text, comments, index) {
-    const comment = comments[index]?.range;
-    if (comment === undefined || comment.kind !== 'line' || isStandaloneLineComment(text, comment)) {
-        return false;
-    }
-    let cursor = getLineStart(text, comment.start);
-    for (let previousIndex = index - 1; previousIndex >= 0; previousIndex -= 1) {
-        const previousComment = comments[previousIndex]?.range;
-        if (previousComment !== undefined && previousComment.end > cursor) {
-            continue;
-        }
-        if (previousComment === undefined || !isStandaloneComment(text, previousComment)) {
-            return false;
-        }
-        if (!isAdjacentCommentBeforeIndex(text, previousComment, cursor)) {
-            return false;
-        }
-        const body = getCommentBody(text, previousComment);
-        if (previousComment.kind === 'line' && isPrettierIgnoreComment(body)) {
-            return true;
-        }
-        if (!isCommentNormallyIgnored(text, previousComment)) {
-            return false;
-        }
-        cursor = getLineStart(text, previousComment.start);
-    }
-    return false;
-}
-function isCommentNormallyIgnored(text, comment) {
-    if (comment.kind === 'line') {
-        const raw = text.slice(comment.start, comment.end);
-        return shouldSkipLineComment(text, comment) && !isPrettierIgnoreComment(normalizeLineCommentBody(raw.slice(2)));
-    }
-    return isBlockCommentNormallyIgnored(text, comment);
-}
-function isBlockCommentNormallyIgnored(text, comment) {
-    const raw = text.slice(comment.start, comment.end);
-    if (raw.startsWith('/**') || hasPreserveCommentMarker(raw)) {
-        return true;
-    }
-    const body = normalizeBlockCommentBody(raw);
-    return body.trim() === '' || isDirectiveComment(body);
-}
-function isStandaloneComment(text, comment) {
-    return comment.kind === 'line' ? isStandaloneLineComment(text, comment) : isStandaloneBlockComment(text, comment);
-}
-function isAdjacentPreviousComment(text, previousComment, comment) {
-    return /^(?:\r\n|\n|\r)[ \t]*$/u.test(text.slice(previousComment.end, comment.start));
-}
-function isAdjacentCommentBeforeIndex(text, comment, index) {
-    return /^(?:\r\n|\n|\r)[ \t]*$/u.test(text.slice(comment.end, index));
-}
-function getCommentBody(text, comment) {
-    const raw = text.slice(comment.start, comment.end);
-    return comment.kind === 'line' ? normalizeLineCommentBody(raw.slice(2)) : normalizeBlockCommentBody(raw);
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function numberOrUndefined(value) {
-    return typeof value === 'number' ? value : undefined;
-}

package/dist/plugin/parsers.d.ts

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

package/dist/plugin/parsers.js

@@ -1,35 +0,0 @@
-import * as babelPlugin from 'prettier/plugins/babel';
-import * as typescriptPlugin from 'prettier/plugins/typescript';
-import { neutralizePrettierIgnoreForIgnoredBlockComments, wrapComments } from '../comments/wrap.js';
-const parserNames = ['babel', 'babel-ts', 'typescript'];
-function wrapParser(parser) {
-    return {
-        ...parser,
-        async parse(text, options) {
-            const ast = await parser.parse(text, options);
-            return neutralizePrettierIgnoreForIgnoredBlockComments(text, ast);
-        },
-        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/plugin/printers.d.ts

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

package/dist/shared/text.d.ts

@@ -1,15 +0,0 @@
-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;
-export declare function makeIndent(column: number, options: WrapOptions): string;

package/dist/shared/text.js

@@ -1,99 +0,0 @@
-import { getTabWidth } from './options.js';
-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;
-        }
-        return accepted;
-    }, []);
-}
-function rangesOverlap(left, right) {
-    return left.start < right.end && right.start < left.end;
-}
-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() === '';
-}
-export 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

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

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