markdansi 0.1.0 → 0.1.1

package/dist/render.js

@@ -0,0 +1,424 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import { hyperlinkSupported, osc8 } from "./hyperlink.js";
+import { parse } from "./parser.js";
+import { createStyler, themes } from "./theme.js";
+import { visibleWidth, wrapText, wrapWithPrefix } from "./wrap.js";
+function resolveOptions(userOptions = {}) {
+    const wrap = userOptions.wrap !== undefined ? userOptions.wrap : true;
+    const baseWidth = userOptions.width ?? (wrap ? process.stdout.columns || 80 : undefined);
+    const color = userOptions.color !== undefined ? userOptions.color : process.stdout.isTTY;
+    // OSC hyperlinks require color support; if color is off, force hyperlinks off too
+    const hyperlinks = userOptions.hyperlinks !== undefined
+        ? userOptions.hyperlinks
+        : color && hyperlinkSupported();
+    const effectiveHyperlinks = color ? hyperlinks : false;
+    const baseTheme = themes.default ?? {};
+    const userTheme = userOptions.theme && typeof userOptions.theme === "object"
+        ? userOptions.theme
+        : themes[userOptions.theme || "default"] || baseTheme;
+    const mergedTheme = {
+        ...baseTheme,
+        ...(userTheme || {}),
+        inlineCode: userTheme?.inlineCode ||
+            userTheme?.code ||
+            baseTheme.inlineCode ||
+            baseTheme.code ||
+            {},
+        blockCode: userTheme?.blockCode ||
+            userTheme?.code ||
+            baseTheme.blockCode ||
+            baseTheme.code ||
+            {},
+    };
+    const highlighter = userOptions.highlighter;
+    const listIndent = userOptions.listIndent ?? 2;
+    const quotePrefix = userOptions.quotePrefix ?? "│ ";
+    const tableBorder = userOptions.tableBorder || "unicode";
+    const tablePadding = userOptions.tablePadding ?? 1;
+    const tableDense = userOptions.tableDense ?? false;
+    const tableTruncate = userOptions.tableTruncate ?? true;
+    const tableEllipsis = userOptions.tableEllipsis ?? "…";
+    const codeBox = userOptions.codeBox ?? true;
+    const codeGutter = userOptions.codeGutter ?? false;
+    const codeWrap = userOptions.codeWrap ?? true;
+    const resolved = {
+        wrap,
+        color,
+        hyperlinks: effectiveHyperlinks,
+        theme: mergedTheme,
+        highlighter,
+        listIndent,
+        quotePrefix,
+        tableBorder,
+        tablePadding,
+        tableDense,
+        tableTruncate,
+        tableEllipsis,
+        codeBox,
+        codeGutter,
+        codeWrap,
+    };
+    if (baseWidth !== undefined)
+        resolved.width = baseWidth;
+    return resolved;
+}
+const HR_WIDTH = 40;
+const MAX_COL = 40;
+const TABLE_BOX = {
+    unicode: {
+        topLeft: "┌",
+        topRight: "┐",
+        bottomLeft: "└",
+        bottomRight: "┘",
+        hSep: "─",
+        vSep: "│",
+        tSep: "┬",
+        mSep: "┼",
+        bSep: "┴",
+        mLeft: "├",
+        mRight: "┤",
+    },
+    ascii: {
+        topLeft: "+",
+        topRight: "+",
+        bottomLeft: "+",
+        bottomRight: "+",
+        hSep: "-",
+        vSep: "|",
+        tSep: "+",
+        mSep: "+",
+        bSep: "+",
+        mLeft: "+",
+        mRight: "+",
+    },
+};
+/**
+ * Render Markdown input to an ANSI string.
+ */
+export function render(markdown, userOptions = {}) {
+    const options = resolveOptions(userOptions);
+    const style = createStyler({ color: options.color });
+    const tree = parse(markdown);
+    const ctx = { options, style };
+    const body = renderChildren(tree.children, ctx, 0, true).join("");
+    return options.color ? body : stripAnsi(body);
+}
+/**
+ * Create a reusable renderer with fixed options.
+ */
+export function createRenderer(options) {
+    return (md) => render(md, options);
+}
+function renderChildren(children, ctx, indentLevel = 0, isTightList = false) {
+    const out = [];
+    for (const node of children) {
+        out.push(renderNode(node, ctx, indentLevel, isTightList));
+    }
+    return out.flat();
+}
+function renderNode(node, ctx, indentLevel, isTightList) {
+    switch (node.type) {
+        case "paragraph":
+            return renderParagraph(node, ctx, indentLevel);
+        case "heading":
+            return renderHeading(node, ctx);
+        case "thematicBreak":
+            return renderHr(ctx);
+        case "blockquote":
+            return renderBlockquote(node, ctx, indentLevel);
+        case "list":
+            return renderList(node, ctx, indentLevel);
+        case "listItem":
+            return renderListItem(node, ctx, indentLevel, isTightList);
+        case "code":
+            return renderCodeBlock(node, ctx);
+        case "table":
+            return renderTable(node, ctx);
+        default:
+            return []; // inline handled elsewhere or intentionally skipped
+    }
+}
+function renderParagraph(node, ctx, indentLevel) {
+    const text = renderInline(node.children, ctx);
+    const prefix = " ".repeat(ctx.options.listIndent * indentLevel);
+    const lines = wrapWithPrefix(text, ctx.options.width ?? 80, ctx.options.wrap, prefix);
+    return lines.map((l) => `${l}\n`);
+}
+function renderHeading(node, ctx) {
+    const text = renderInline(node.children, ctx);
+    const styled = ctx.style(text, ctx.options.theme.heading);
+    return [`\n${styled}\n`];
+}
+function renderHr(ctx) {
+    const width = ctx.options.wrap
+        ? Math.min(ctx.options.width ?? HR_WIDTH, HR_WIDTH)
+        : HR_WIDTH;
+    const line = "—".repeat(width);
+    return [`${ctx.style(line, ctx.options.theme.hr)}\n`];
+}
+function renderBlockquote(node, ctx, indentLevel) {
+    // Render blockquote children as text, then wrap with the quote prefix so
+    // wrapping accounts for prefix width.
+    const inner = renderChildren(node.children, ctx, indentLevel);
+    const prefix = ctx.style(ctx.options.quotePrefix, ctx.options.theme.quote);
+    const text = inner.join("").trimEnd();
+    const wrapped = wrapWithPrefix(text, ctx.options.width ?? 80, ctx.options.wrap, prefix);
+    return wrapped.map((l) => `${l}\n`);
+}
+function renderList(node, ctx, indentLevel) {
+    const tight = node.spread === false;
+    const items = node.children.flatMap((item, idx) => renderListItem(item, ctx, indentLevel, tight, Boolean(node.ordered), node.start ?? 1, idx));
+    return items;
+}
+function renderListItem(node, ctx, indentLevel, tight, ordered = false, start = 1, idx = 0) {
+    const marker = ordered ? `${start + idx}.` : "-";
+    const markerStyled = ctx.style(marker, ctx.options.theme.listMarker);
+    const content = renderChildren(node.children, ctx, indentLevel + 1, tight)
+        .join("")
+        .trimEnd()
+        .split("\n");
+    // Drop leading blank lines so bullets prefix real content (e.g., headings in lists)
+    while (content.length && (content[0]?.trim() ?? "") === "") {
+        content.shift();
+    }
+    const isTask = typeof node.checked === "boolean";
+    const box = isTask && node.checked ? "[x]" : "[ ]";
+    const firstBullet = " ".repeat(ctx.options.listIndent * indentLevel) +
+        (isTask
+            ? `${ctx.style(box, ctx.options.theme.listMarker)} `
+            : `${markerStyled} `);
+    const lines = [];
+    content.forEach((line, i) => {
+        const clean = line.replace(/^\s+/, "");
+        const prefix = i === 0
+            ? firstBullet
+            : `${" ".repeat(ctx.options.listIndent * indentLevel)}${" ".repeat(ctx.options.listIndent)}`;
+        lines.push(prefix + clean);
+    });
+    if (!tight)
+        lines.push("");
+    return lines.map((l) => `${l}\n`);
+}
+function renderCodeBlock(node, ctx) {
+    const theme = ctx.options.theme.blockCode || ctx.options.theme.inlineCode;
+    const lines = (node.value ?? "").split("\n");
+    const gutterWidth = ctx.options.codeGutter
+        ? String(lines.length).length + 2
+        : 0;
+    const boxPadding = ctx.options.codeBox ? 4 : 0;
+    const wrapLimit = ctx.options.codeWrap && ctx.options.wrap && ctx.options.width
+        ? Math.max(1, ctx.options.width - boxPadding - gutterWidth)
+        : undefined; // undefined => no hard wrap limit
+    const contentLines = lines.flatMap((line, idx) => {
+        const segments = wrapLimit !== undefined ? wrapCodeLine(line, wrapLimit) : [line];
+        return segments.map((segment, segIdx) => {
+            const highlighted = ctx.options.highlighter?.(segment, node.lang ?? undefined) ??
+                ctx.style(segment, theme);
+            if (!ctx.options.codeGutter)
+                return highlighted;
+            const num = segIdx === 0
+                ? String(idx + 1).padStart(gutterWidth - 2, " ")
+                : " ".repeat(gutterWidth - 1);
+            return `${ctx.style(num, { dim: true })} ${highlighted}`;
+        });
+    });
+    if (!ctx.options.codeBox) {
+        return [`${contentLines.join("\n")}\n\n`];
+    }
+    // Boxed block
+    const maxLine = Math.max(...contentLines.map((l) => visibleWidth(l)), 0);
+    const minInner = node.lang ? node.lang.length + 2 : 0;
+    const wrapTarget = ctx.options.codeWrap && ctx.options.width
+        ? Math.min(maxLine, Math.max(1, ctx.options.width - 4))
+        : maxLine;
+    const innerWidth = Math.max(ctx.options.codeWrap ? wrapTarget : maxLine, minInner);
+    const topLang = node.lang
+        ? `${ctx.style(`[${node.lang}]`, { dim: true })} `
+        : "";
+    const h = "─".repeat(Math.max(innerWidth, topLang.length));
+    const top = `┌ ${topLang}${h.slice(topLang.length)}┐`;
+    const bottom = `└${"─".repeat(h.length + 1)}┘`;
+    const boxLines = contentLines.map((ln) => {
+        const pad = Math.max(0, h.length - visibleWidth(ln));
+        const left = ctx.style("│ ", { dim: true });
+        const right = ctx.style(" │", { dim: true });
+        return `${left}${ln}${" ".repeat(pad)}${right}`;
+    });
+    return [`${top}\n${boxLines.join("\n")}\n${bottom}\n\n`];
+}
+function renderInline(children, ctx) {
+    let out = "";
+    for (const node of children) {
+        switch (node.type) {
+            case "text":
+                out += node.value;
+                break;
+            case "emphasis":
+                out += ctx.style(renderInline(node.children, ctx), ctx.options.theme.emph);
+                break;
+            case "strong":
+                out += ctx.style(renderInline(node.children, ctx), ctx.options.theme.strong);
+                break;
+            case "delete":
+                out += ctx.style(renderInline(node.children, ctx), { strike: true });
+                break;
+            case "inlineCode": {
+                const codeTheme = ctx.options.theme.inlineCode || ctx.options.theme.blockCode;
+                const content = ctx.style(node.value, codeTheme);
+                out += content;
+                break;
+            }
+            case "link":
+                out += renderLink(node, ctx);
+                break;
+            case "break":
+                out += "\n";
+                break;
+            default:
+                if ("value" in node && typeof node.value === "string")
+                    out += node.value;
+        }
+    }
+    return out;
+}
+function renderLink(node, ctx) {
+    const label = renderInline(node.children, ctx) || node.url;
+    const url = node.url || "";
+    if (ctx.options.hyperlinks && url) {
+        return osc8(url, label);
+    }
+    if (url && label !== url) {
+        return (ctx.style(label, ctx.options.theme.link) +
+            ctx.style(` (${url})`, { dim: true }));
+    }
+    return ctx.style(label, ctx.options.theme.link);
+}
+function renderTable(node, ctx) {
+    const header = node.children[0];
+    if (!header)
+        return [];
+    const rows = node.children.slice(1);
+    const cells = [header, ...rows].map((row) => row.children.map((cell) => renderInline(cell.children, ctx)));
+    const colCount = Math.max(...cells.map((r) => r.length));
+    const widths = new Array(colCount).fill(1);
+    const aligns = node.align || [];
+    const pad = ctx.options.tablePadding;
+    const minContent = Math.max(1, ctx.options.tableEllipsis.length + 1);
+    // ensure we always have room for at least one visible char + ellipsis + padding
+    const minColWidth = Math.max(1, pad * 2 + minContent);
+    cells.forEach((row) => {
+        row.forEach((cell, idx) => {
+            // Cap each column to MAX_COL but keep at least 1
+            widths[idx] = Math.max(widths[idx], Math.min(MAX_COL, visibleWidth(cell)));
+        });
+    });
+    const totalWidth = widths.reduce((a, b) => a + b, 0) + 3 * colCount + 1;
+    if (ctx.options.wrap && ctx.options.width && totalWidth > ctx.options.width) {
+        // Shrink widest columns until the table fits; allow overflow if already at minima
+        let over = totalWidth - ctx.options.width;
+        while (over > 0) {
+            const i = widths.indexOf(Math.max(...widths));
+            if (widths[i] <= minColWidth)
+                break;
+            widths[i] -= 1;
+            over -= 1;
+        }
+    }
+    for (let i = 0; i < widths.length; i += 1) {
+        if (widths[i] < minColWidth)
+            widths[i] = minColWidth;
+    }
+    const renderRow = (row, isHeader = false) => {
+        const linesPerCol = row.map((cell, idx) => {
+            const padded = ` ${cell} `;
+            const target = Math.max(minContent, widths[idx] - pad * 2);
+            const cellText = ctx.options.tableTruncate
+                ? truncateCell(cell, target, ctx.options.tableEllipsis)
+                : padded;
+            const wrapped = wrapText(cellText, ctx.options.wrap ? target : Number.MAX_SAFE_INTEGER, ctx.options.wrap);
+            return wrapped.map((l) => padCell(` ${l} `, widths[idx], aligns[idx] ?? "left", ctx.options.tablePadding));
+        });
+        // Row height = max wrapped lines in any column; pad shorter ones
+        const height = Math.max(...linesPerCol.map((c) => c.length));
+        const out = [];
+        for (let i = 0; i < height; i += 1) {
+            const parts = linesPerCol.map((col, idx) => {
+                const content = col[i] ?? padCell("", widths[idx], aligns[idx] ?? "left");
+                return isHeader
+                    ? ctx.style(content, ctx.options.theme.tableHeader)
+                    : ctx.style(content, ctx.options.theme.tableCell);
+            });
+            out.push(parts);
+        }
+        return out;
+    };
+    const headerRows = renderRow(header.children.map((c) => renderInline(c.children, ctx)), true);
+    const bodyRows = rows.flatMap((r) => renderRow(r.children.map((c) => renderInline(c.children, ctx))));
+    if (ctx.options.tableBorder === "none") {
+        const lines = [...headerRows, ...bodyRows]
+            .map((row) => row.join(" | "))
+            .join("\n");
+        return [`${lines}\n\n`];
+    }
+    const box = TABLE_BOX[ctx.options.tableBorder] || TABLE_BOX.unicode;
+    const hLine = (sepMid, sepLeft, sepRight) => `${sepLeft}${widths
+        .map((w) => box.hSep.repeat(w))
+        .join(sepMid)}${sepRight}\n`;
+    const top = hLine(box.tSep, box.topLeft, box.topRight);
+    const mid = hLine(box.mSep, box.mLeft, box.mRight);
+    const bottom = hLine(box.bSep, box.bottomLeft, box.bottomRight);
+    const renderFlat = (rowsArr) => rowsArr
+        .map((r) => `${box.vSep}${r.map((c) => c).join(box.vSep)}${box.vSep}\n`)
+        .join("");
+    const dense = ctx.options.tableDense;
+    const out = [
+        top,
+        renderFlat(headerRows),
+        dense ? "" : mid,
+        renderFlat(bodyRows),
+        bottom,
+        "\n",
+    ];
+    return out;
+}
+function truncateCell(text, width, ellipsis) {
+    if (stringWidth(text) <= width)
+        return text;
+    if (width <= ellipsis.length)
+        return ellipsis.slice(0, width);
+    return text.slice(0, width - ellipsis.length) + ellipsis;
+}
+function wrapCodeLine(text, width) {
+    // Hard-wrap code even without spaces while keeping ANSI-safe width accounting.
+    if (width <= 0)
+        return [text];
+    const parts = [];
+    let current = "";
+    for (const ch of [...text]) {
+        const chWidth = stringWidth(ch);
+        if (visibleWidth(current) + chWidth > width) {
+            parts.push(current);
+            current = ch;
+            continue;
+        }
+        current += ch;
+    }
+    if (current !== "")
+        parts.push(current);
+    return parts.length ? parts : [""];
+}
+function padCell(text, width, align = "left", _padSpaces = 0) {
+    const core = text;
+    const pad = width - stringWidth(stripAnsi(core));
+    if (pad <= 0)
+        return core;
+    if (align === "right")
+        return `${" ".repeat(pad)}${core}`;
+    if (align === "center") {
+        const left = Math.floor(pad / 2);
+        const right = pad - left;
+        return `${" ".repeat(left)}${core}${" ".repeat(right)}`;
+    }
+    return `${core}${" ".repeat(pad)}`;
+}

package/dist/theme.d.ts

@@ -0,0 +1,18 @@
+import type { StyleIntent, Theme } from "./types.js";
+export interface Themes {
+    default: Theme;
+    dim: Theme;
+    bright: Theme;
+    solarized: Theme;
+    monochrome: Theme;
+    contrast: Theme;
+    [key: string]: Theme;
+}
+export declare const themes: Themes;
+export type Styler = (text: string, style?: StyleIntent) => string;
+/**
+ * Create a Chalk-based styling helper that applies StyleIntent safely.
+ */
+export declare function createStyler({ color }: {
+    color: boolean;
+}): Styler;

package/dist/theme.js

@@ -0,0 +1,105 @@
+import { Chalk } from "chalk";
+const base = {
+    heading: { color: "yellow", bold: true },
+    strong: { bold: true },
+    emph: { italic: true },
+    inlineCode: { color: "cyan" },
+    blockCode: { color: "green" },
+    link: { color: "blue", underline: true },
+    quote: { dim: true },
+    hr: { dim: true },
+    listMarker: { color: "cyan" },
+    tableHeader: { bold: true, color: "yellow" },
+    tableCell: {},
+};
+const dim = {
+    ...base,
+    heading: { color: "white", bold: true, dim: true },
+    link: { color: "blue", underline: true, dim: true },
+};
+const bright = {
+    ...base,
+    heading: { color: "magenta", bold: true },
+    link: { color: "cyan", underline: true },
+    inlineCode: { color: "green" },
+    blockCode: { color: "green" },
+};
+const solarized = {
+    heading: { color: "yellow", bold: true },
+    strong: { bold: true },
+    emph: { italic: true },
+    inlineCode: { color: "cyan" },
+    blockCode: { color: "#2aa198" },
+    link: { color: "blue", underline: true },
+    quote: { color: "white", dim: true },
+    hr: { color: "white", dim: true },
+    listMarker: { color: "cyan" },
+    tableHeader: { color: "yellow", bold: true },
+};
+const monochrome = {
+    heading: { bold: true },
+    strong: { bold: true },
+    emph: { italic: true },
+    inlineCode: { dim: true },
+    blockCode: { dim: true },
+    link: { underline: true },
+    quote: { dim: true },
+    hr: { dim: true },
+    listMarker: { dim: true },
+    tableHeader: { bold: true },
+};
+const contrast = {
+    heading: { color: "magenta", bold: true },
+    strong: { color: "white", bold: true },
+    emph: { color: "white", italic: true },
+    inlineCode: { color: "cyan", bold: true },
+    blockCode: { color: "green", bold: true },
+    link: { color: "blue", underline: true },
+    quote: { color: "white", dim: true },
+    hr: { color: "white", dim: true },
+    listMarker: { color: "yellow", bold: true },
+    tableHeader: { color: "yellow", bold: true },
+    tableCell: { color: "white" },
+};
+export const themes = {
+    default: Object.freeze(base),
+    dim: Object.freeze(dim),
+    bright: Object.freeze(bright),
+    solarized: Object.freeze(solarized),
+    monochrome: Object.freeze(monochrome),
+    contrast: Object.freeze(contrast),
+};
+/**
+ * Create a Chalk-based styling helper that applies StyleIntent safely.
+ */
+export function createStyler({ color }) {
+    const level = color ? 3 : 0;
+    const chalk = new Chalk({ level });
+    const apply = (text, style = {}) => {
+        if (!color)
+            return text;
+        let fn = chalk;
+        if (style.color) {
+            const indexed = fn;
+            if (indexed[style.color])
+                fn = indexed[style.color];
+        }
+        if (style.bgColor) {
+            const indexed = fn;
+            if (indexed[style.bgColor])
+                fn = indexed[style.bgColor];
+        }
+        if (style.bold)
+            fn = fn.bold;
+        if (style.italic)
+            fn = fn.italic;
+        if (style.underline)
+            fn = fn.underline;
+        if (style.dim)
+            fn = fn.dim;
+        if (style.strike)
+            fn = fn.strikethrough;
+        return fn(text);
+    };
+    return apply;
+}

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+export type ColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | `#${string}` | `${number}`;
+export type StyleIntent = {
+    color?: ColorName;
+    bgColor?: ColorName;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    strike?: boolean;
+};
+export type Theme = {
+    heading?: StyleIntent;
+    strong?: StyleIntent;
+    emph?: StyleIntent;
+    inlineCode?: StyleIntent;
+    blockCode?: StyleIntent;
+    code?: StyleIntent;
+    link?: StyleIntent;
+    quote?: StyleIntent;
+    hr?: StyleIntent;
+    listMarker?: StyleIntent;
+    tableHeader?: StyleIntent;
+    tableCell?: StyleIntent;
+};
+export type ThemeName = "default" | "dim" | "bright";
+export type Highlighter = (code: string, lang?: string) => string;
+export interface RenderOptions {
+    wrap?: boolean;
+    width?: number;
+    hyperlinks?: boolean;
+    color?: boolean;
+    theme?: ThemeName | Theme;
+    /**
+     * Spaces per nesting level for lists (default 2).
+     */
+    listIndent?: number;
+    /**
+     * Prefix used for blockquotes (default "│ ").
+     */
+    quotePrefix?: string;
+    /** Table border style: unicode (default), ascii, or none. */
+    tableBorder?: "unicode" | "ascii" | "none";
+    /** Spaces around cell content (default 1). */
+    tablePadding?: number;
+    /** If true, reduces separator rows (default false). */
+    tableDense?: boolean;
+    /** If true, truncates cell content to fit column width (default true). */
+    tableTruncate?: boolean;
+    /** Ellipsis text for truncation (default "…"). */
+    tableEllipsis?: string;
+    /** Draw a box around fenced code blocks (default true). */
+    codeBox?: boolean;
+    /** Show line-number gutter for code blocks (default false). */
+    codeGutter?: boolean;
+    /** Wrap code lines to width; otherwise overflow (default true). */
+    codeWrap?: boolean;
+    highlighter?: Highlighter;
+}

package/dist/types.js

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

package/dist/wrap.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Visible width of a string, ignoring ANSI escape codes.
+ */
+export declare function visibleWidth(text: string): number;
+/**
+ * Wrap a single paragraph string into lines respecting visible width.
+ * Breaks only on spaces. Words longer than width overflow.
+ */
+export declare function wrapText(text: string, width: number, wrap: boolean): string[];
+export declare function wrapWithPrefix(text: string, width: number, wrap: boolean, prefix?: string): string[];

package/dist/wrap.js

@@ -0,0 +1,48 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+/**
+ * Visible width of a string, ignoring ANSI escape codes.
+ */
+export function visibleWidth(text) {
+    return stringWidth(stripAnsi(text));
+}
+/**
+ * Wrap a single paragraph string into lines respecting visible width.
+ * Breaks only on spaces. Words longer than width overflow.
+ */
+export function wrapText(text, width, wrap) {
+    if (!wrap || width <= 0)
+        return [text];
+    const words = text.split(/(\s+)/).filter((w) => w.length > 0);
+    const lines = [];
+    let current = "";
+    let currentWidth = 0;
+    for (const word of words) {
+        const w = visibleWidth(word);
+        if (current !== "" && currentWidth + w > width && !/^\s+$/.test(word)) {
+            lines.push(current);
+            current = word.replace(/^\s+/, "");
+            currentWidth = visibleWidth(current);
+            continue;
+        }
+        current += word;
+        currentWidth = visibleWidth(current);
+    }
+    if (current !== "")
+        lines.push(current);
+    if (lines.length === 0)
+        lines.push("");
+    return lines;
+}
+export function wrapWithPrefix(text, width, wrap, prefix = "") {
+    if (!wrap)
+        return text.split("\n").map((line) => prefix + line);
+    const out = [];
+    const w = Math.max(1, width - visibleWidth(prefix));
+    for (const line of text.split("\n")) {
+        const parts = wrapText(line, w, wrap);
+        for (const p of parts)
+            out.push(prefix + p);
+    }
+    return out;
+}