@mx-space/cli 0.15.1 → 0.15.2

package/dist/src/cli/render/lexical/blocks.js

@@ -1,208 +0,0 @@
-import { SEPARATOR_WIDTH } from '../helpers';
-import { ANSI, visibleLen, wrap } from '../markdown';
-// Prefix each non-empty line of `text` with `prefix`. Empty lines stay empty so
-// terminals don't show stray prefix glyphs on visual breathers.
-const indentLines = (text, prefix) => text
-    .split('\n')
-    .map((line) => (line.length === 0 ? line : `${prefix}${line}`))
-    .join('\n');
-const padRight = (s, width) => {
-    const v = visibleLen(s);
-    return v < width ? s + ' '.repeat(width - v) : s;
-};
-const onlyElementChildren = (children) => children.filter((c) => c.type === 'element');
-export const paragraphRenderer = (node, ctx, inner) => inner.walkInlineChildren(node.children, ctx);
-const makeHeading = (level) => (node, ctx, inner) => {
-    const text = inner.walkInlineChildren(node.children, ctx);
-    if (level === 1) {
-        const styled = wrap(`${ANSI.bold}${ANSI.magenta}`, text, ctx.color);
-        const rule = wrap(ANSI.dim, '─'.repeat(Math.max(visibleLen(text), 1)), ctx.color);
-        return `${styled}\n${rule}`;
-    }
-    if (level === 2) {
-        const styled = wrap(`${ANSI.bold}${ANSI.cyan}`, text, ctx.color);
-        const rule = wrap(ANSI.dim, '─'.repeat(Math.max(visibleLen(text), 1)), ctx.color);
-        return `${styled}\n${rule}`;
-    }
-    return wrap(ANSI.bold, text, ctx.color);
-};
-export const h1Renderer = makeHeading(1);
-export const h2Renderer = makeHeading(2);
-export const h3Renderer = makeHeading(3);
-export const h4Renderer = makeHeading(4);
-export const h5Renderer = makeHeading(5);
-export const h6Renderer = makeHeading(6);
-export const blockquoteRenderer = (node, ctx, inner) => {
-    const body = inner.walkBlockChildren(node.children, ctx);
-    const prefix = wrap(ANSI.dim, '│ ', ctx.color);
-    const out = indentLines(body, prefix);
-    const attribution = node.attrs.attribution;
-    if (attribution) {
-        const attrLine = wrap(ANSI.dim, `   — ${attribution}`, ctx.color);
-        return out ? `${out}\n${attrLine}` : attrLine;
-    }
-    return out;
-};
-export const hrRenderer = (_node, ctx) => wrap(ANSI.dim, '─'.repeat(SEPARATOR_WIDTH), ctx.color);
-const renderListItemBody = (li, ctx, inner) => {
-    // Split children: inline-ish content first (with paragraph breaks preserved
-    // as `\n`-joined segments), nested ul/ol below.
-    const segments = [];
-    let buffer = [];
-    const nestedBlocks = [];
-    const flush = () => {
-        if (buffer.length === 0)
-            return;
-        segments.push(inner.walkInlineChildren(buffer, ctx));
-        buffer = [];
-    };
-    for (const c of li.children) {
-        if (c.type === 'element' && (c.tag === 'ul' || c.tag === 'ol')) {
-            flush();
-            nestedBlocks.push(c);
-        }
-        else if (c.type === 'element' && c.tag === 'p') {
-            flush();
-            segments.push(inner.walkInlineChildren(c.children, ctx));
-        }
-        else if (c.type === 'text' && /^\s*$/.test(c.value)) {
-            // skip pretty-print whitespace between sibling paragraphs
-            continue;
-        }
-        else {
-            buffer.push(c);
-        }
-    }
-    flush();
-    const head = segments.join('\n');
-    const nested = nestedBlocks.length > 0
-        ? inner.walkBlockChildren(nestedBlocks, {
-            ...ctx,
-            indent: ctx.indent + 2,
-        })
-        : '';
-    return { inlineHead: head, nested };
-};
-const liPrefix = (li, ordinal, numWidth, ctx) => {
-    const checked = li.attrs.checked;
-    if (checked === 'true')
-        return wrap(ANSI.dim, '[x] ', ctx.color);
-    if (checked === 'false')
-        return wrap(ANSI.dim, '[ ] ', ctx.color);
-    if (ordinal != null) {
-        const label = `${ordinal}.`.padStart(numWidth);
-        return `${label} `;
-    }
-    return '- ';
-};
-const renderList = (ordered) => (node, ctx, inner) => {
-    const items = onlyElementChildren(node.children).filter((c) => c.tag === 'li');
-    if (items.length === 0)
-        return '';
-    const numWidth = ordered ? String(items.length).length + 1 : 0;
-    const indentStr = ' '.repeat(ctx.indent);
-    const lines = [];
-    items.forEach((item, idx) => {
-        const prefix = liPrefix(item, ordered ? idx + 1 : null, numWidth, ctx);
-        const { inlineHead, nested } = renderListItemBody(item, ctx, inner);
-        const contIndent = ' '.repeat(visibleLen(prefix));
-        const head = inlineHead
-            .split('\n')
-            .map((line, i) => (i === 0 ? line : `${contIndent}${line}`))
-            .join('\n');
-        lines.push(`${indentStr}${prefix}${head}`);
-        if (nested)
-            lines.push(nested);
-    });
-    return lines.join('\n');
-};
-export const ulRenderer = renderList(false);
-export const olRenderer = renderList(true);
-// Defensive: `<li>` dispatched outside a list — render as a paragraph.
-export const liRenderer = (node, ctx, inner) => inner.walkInlineChildren(node.children, ctx);
-export const tableRenderer = (node, ctx, inner) => {
-    const rows = onlyElementChildren(node.children).filter((c) => c.tag === 'tr');
-    if (rows.length === 0)
-        return '';
-    const matrix = rows.map((row) => onlyElementChildren(row.children)
-        .filter((c) => c.tag === 'th' || c.tag === 'td')
-        .map((cell) => inner.walkInlineChildren(cell.children, ctx)));
-    const numCols = Math.max(...matrix.map((r) => r.length));
-    const widths = [];
-    for (let i = 0; i < numCols; i++) {
-        let max = 0;
-        for (const row of matrix) {
-            const cell = row[i] ?? '';
-            if (visibleLen(cell) > max)
-                max = visibleLen(cell);
-        }
-        widths.push(max);
-    }
-    const headerIsAllTh = rows.length > 0 &&
-        onlyElementChildren(rows[0].children).every((c) => c.tag === 'th');
-    const lines = [];
-    matrix.forEach((row, rowIdx) => {
-        const padded = row.map((cell, idx) => padRight(cell, widths[idx] ?? 0));
-        const rendered = rowIdx === 0 && headerIsAllTh
-            ? padded.map((c) => wrap(ANSI.bold, c, ctx.color))
-            : padded;
-        lines.push(rendered.join(' │ '));
-        if (rowIdx === 0 && headerIsAllTh) {
-            const sep = widths.map((w) => '─'.repeat(w)).join('─┼─');
-            lines.push(wrap(ANSI.dim, sep, ctx.color));
-        }
-    });
-    return lines.join('\n');
-};
-const ALERT_LABEL_COLOR = {
-    info: ANSI.cyan,
-    tip: ANSI.cyan,
-    warning: ANSI.yellow,
-    error: ANSI.red,
-    success: ANSI.green,
-    note: ANSI.dim,
-};
-const renderBox = (defaultType) => (node, ctx, inner) => {
-    const type = (node.attrs.type ?? defaultType).toLowerCase();
-    const colorCode = ALERT_LABEL_COLOR[type] ?? ANSI.cyan;
-    const labelLine = wrap(colorCode, type.toUpperCase(), ctx.color);
-    const rule = wrap(ANSI.dim, '─'.repeat(SEPARATOR_WIDTH), ctx.color);
-    const body = inner.walkBlockChildren(node.children, ctx);
-    const prefix = wrap(ANSI.dim, '│ ', ctx.color);
-    const indented = indentLines(body, prefix);
-    return `${labelLine}\n${rule}\n${indented}\n${rule}`;
-};
-export const alertRenderer = renderBox('info');
-export const bannerRenderer = renderBox('info');
-export const detailsRenderer = (node, ctx, inner) => {
-    const summary = node.attrs.summary ?? '';
-    const head = wrap(ANSI.dim, `▸ ${summary}`, ctx.color);
-    const body = inner.walkBlockChildren(node.children, ctx);
-    if (!body)
-        return head;
-    const indented = indentLines(body, '  ');
-    return `${head}\n${indented}`;
-};
-export const spoilerRenderer = (node, ctx, inner) => {
-    const text = inner.walkInlineChildren(node.children, ctx);
-    return wrap(ANSI.dim, text, ctx.color);
-};
-export const blockRendererEntries = [
-    ['p', paragraphRenderer],
-    ['h1', h1Renderer],
-    ['h2', h2Renderer],
-    ['h3', h3Renderer],
-    ['h4', h4Renderer],
-    ['h5', h5Renderer],
-    ['h6', h6Renderer],
-    ['blockquote', blockquoteRenderer],
-    ['hr', hrRenderer],
-    ['ul', ulRenderer],
-    ['ol', olRenderer],
-    ['li', liRenderer],
-    ['table', tableRenderer],
-    ['alert', alertRenderer],
-    ['banner', bannerRenderer],
-    ['details', detailsRenderer],
-    ['spoiler', spoilerRenderer],
-];

package/dist/src/cli/render/lexical/code.d.ts

@@ -1,2 +0,0 @@
-import type { BlockRenderer } from './walker';
-export declare const codeblockRenderer: BlockRenderer;

package/dist/src/cli/render/lexical/code.js

@@ -1,22 +0,0 @@
-import { highlightCode } from '../codehighlight';
-import { ANSI, wrap } from '../markdown';
-const collectText = (children) => {
-    let out = '';
-    for (const child of children) {
-        if (child.type === 'text')
-            out += child.value;
-        else
-            out += collectText(child.children);
-    }
-    return out;
-};
-export const codeblockRenderer = (node, ctx) => {
-    const lang = node.attrs.lang ?? '';
-    const code = collectText(node.children).replace(/\n+$/, '');
-    const body = highlightCode(code, lang, ctx.color);
-    if (lang) {
-        const label = wrap(ANSI.dim, lang, ctx.color);
-        return `${label}\n${body}`;
-    }
-    return body;
-};

package/dist/src/cli/render/lexical/embeds.d.ts

@@ -1,6 +0,0 @@
-import type { BlockRenderer } from './walker';
-export declare const imgRenderer: BlockRenderer;
-export declare const videoRenderer: BlockRenderer;
-export declare const linkCardRenderer: BlockRenderer;
-export declare const embedRenderer: BlockRenderer;
-export declare const embedRendererEntries: ReadonlyArray<readonly [string, BlockRenderer]>;

package/dist/src/cli/render/lexical/embeds.js

@@ -1,51 +0,0 @@
-import { ANSI, wrap } from '../markdown';
-const basename = (path) => {
-    const idx = path.lastIndexOf('/');
-    return idx >= 0 ? path.slice(idx + 1) : path;
-};
-export const imgRenderer = (node, ctx) => {
-    const { alt, src, caption } = node.attrs;
-    let label;
-    if (alt)
-        label = `[image: ${alt}]`;
-    else if (src)
-        label = `[image: ${basename(src)}]`;
-    else
-        label = '[image]';
-    const main = wrap(ANSI.dim, label, ctx.color);
-    if (caption) {
-        const cap = wrap(ANSI.dim, caption, ctx.color);
-        return `${main}\n${cap}`;
-    }
-    return main;
-};
-export const videoRenderer = (node, ctx) => {
-    const { src } = node.attrs;
-    return wrap(ANSI.dim, `[video: ${src ?? ''}]`, ctx.color);
-};
-export const linkCardRenderer = (node, ctx) => {
-    const { url, title, description } = node.attrs;
-    if (!title) {
-        return wrap(ANSI.dim, `[link: ${url ?? ''}]`, ctx.color);
-    }
-    const top = `${wrap(ANSI.dim, '┌ ', ctx.color)}${title}`;
-    const bottom = wrap(ANSI.dim, `└ ${url ?? ''}`, ctx.color);
-    if (description) {
-        const mid = wrap(ANSI.dim, `│ ${description}`, ctx.color);
-        return `${top}\n${mid}\n${bottom}`;
-    }
-    return `${top}\n${bottom}`;
-};
-export const embedRenderer = (node, ctx) => {
-    const { url, source } = node.attrs;
-    const label = source
-        ? `[embed: ${source} ${url ?? ''}]`
-        : `[embed: ${url ?? ''}]`;
-    return wrap(ANSI.dim, label, ctx.color);
-};
-export const embedRendererEntries = [
-    ['img', imgRenderer],
-    ['video', videoRenderer],
-    ['link-card', linkCardRenderer],
-    ['embed', embedRenderer],
-];

package/dist/src/cli/render/lexical/index.d.ts

@@ -1,9 +0,0 @@
-import { type BlockRenderer, type InlineRenderer } from './walker';
-export type { LiteXmlNode } from './parser';
-export { parseLitexml } from './parser';
-export { type BlockRenderer, type InlineRenderer, type RenderCtx, type WalkApi, } from './walker';
-export declare const blockRenderers: Map<string, BlockRenderer>;
-export declare const inlineRenderers: Map<string, InlineRenderer>;
-export declare const renderLexicalAnsi: (xml: string, opts: {
-    readonly color: boolean;
-}) => string;

package/dist/src/cli/render/lexical/index.js

@@ -1,25 +0,0 @@
-import { blockRendererEntries } from './blocks';
-import { codeblockRenderer } from './code';
-import { embedRendererEntries } from './embeds';
-import { inlineRendererEntries } from './inlines';
-import { parseLitexml } from './parser';
-import { createWalker } from './walker';
-export { parseLitexml } from './parser';
-export const blockRenderers = new Map([
-    ...blockRendererEntries,
-    ...embedRendererEntries,
-    ['codeblock', codeblockRenderer],
-]);
-export const inlineRenderers = new Map(inlineRendererEntries);
-const defaultWalker = createWalker({
-    blocks: blockRenderers,
-    inlines: inlineRenderers,
-});
-export const renderLexicalAnsi = (xml, opts) => {
-    const nodes = parseLitexml(xml);
-    const out = defaultWalker.walkBlockChildren(nodes, {
-        color: opts.color,
-        indent: 0,
-    });
-    return out.replace(/\n+$/, '');
-};

package/dist/src/cli/render/lexical/inlines.d.ts

@@ -1,17 +0,0 @@
-import type { InlineRenderer } from './walker';
-export declare const boldRenderer: InlineRenderer;
-export declare const italicRenderer: InlineRenderer;
-export declare const strikeRenderer: InlineRenderer;
-export declare const underlineRenderer: InlineRenderer;
-export declare const codeRenderer: InlineRenderer;
-export declare const subRenderer: InlineRenderer;
-export declare const supRenderer: InlineRenderer;
-export declare const markRenderer: InlineRenderer;
-export declare const linkRenderer: InlineRenderer;
-export declare const brRenderer: InlineRenderer;
-export declare const mentionRenderer: InlineRenderer;
-export declare const tagRenderer: InlineRenderer;
-export declare const commentRenderer: InlineRenderer;
-export declare const footnoteRenderer: InlineRenderer;
-export declare const rubyRenderer: InlineRenderer;
-export declare const inlineRendererEntries: ReadonlyArray<readonly [string, InlineRenderer]>;

package/dist/src/cli/render/lexical/inlines.js

@@ -1,76 +0,0 @@
-import { ANSI, visibleLen, wrap } from '../markdown';
-// Specific reset codes (not ANSI.reset) so nested formats survive — e.g.
-// closing italic with `\x1b[23m` doesn't strip an outer bold.
-const formatPair = (open, close) => {
-    return (node, ctx, inner) => {
-        const text = inner.walkInlineChildren(node.children, ctx);
-        return ctx.color ? `${open}${text}${close}` : text;
-    };
-};
-export const boldRenderer = formatPair('\x1B[1m', '\x1B[22m');
-export const italicRenderer = formatPair('\x1B[3m', '\x1B[23m');
-export const strikeRenderer = formatPair('\x1B[9m', '\x1B[29m');
-export const underlineRenderer = formatPair('\x1B[4m', '\x1B[24m');
-// Inline `code`: dim only — italic on top of dim renders inconsistently
-// across terminals and breaks alignment when copy-pasted.
-export const codeRenderer = formatPair('\x1B[2m', '\x1B[22m');
-// `sub`/`sup`: no real subscript/superscript in TTY — degrade to dim so the
-// content stays distinguishable but doesn't disrupt the line.
-export const subRenderer = formatPair('\x1B[2m', '\x1B[22m');
-export const supRenderer = formatPair('\x1B[2m', '\x1B[22m');
-export const markRenderer = formatPair('\x1B[7m', '\x1B[27m');
-export const linkRenderer = (node, ctx, inner) => {
-    const href = node.attrs.href ?? '';
-    const text = inner.walkInlineChildren(node.children, ctx);
-    if (!href)
-        return text;
-    // If text already reveals the URL there's no point appending it.
-    if (visibleLen(text) > 0 && text.trim() === href)
-        return text;
-    const suffix = wrap(ANSI.dim, ` (${href})`, ctx.color);
-    return `${text}${suffix}`;
-};
-export const brRenderer = () => '\n';
-export const mentionRenderer = (node, ctx, inner) => {
-    const handle = node.attrs.handle ?? '';
-    const display = inner.walkInlineChildren(node.children, ctx).trim();
-    const label = display || handle;
-    return wrap(ANSI.dim, `@${label}`, ctx.color);
-};
-export const tagRenderer = (node, ctx, inner) => {
-    const text = inner.walkInlineChildren(node.children, ctx).trim();
-    return wrap(ANSI.dim, `#${text}`, ctx.color);
-};
-export const commentRenderer = (node, ctx, inner) => {
-    const text = inner.walkInlineChildren(node.children, ctx);
-    return wrap(ANSI.dim, text, ctx.color);
-};
-export const footnoteRenderer = (node, ctx) => {
-    const ref = node.attrs.ref ?? '';
-    return wrap(ANSI.dim, `[^${ref}]`, ctx.color);
-};
-export const rubyRenderer = (node, ctx, inner) => {
-    const base = inner.walkInlineChildren(node.children, ctx);
-    const rt = node.attrs.rt ?? '';
-    if (!rt)
-        return base;
-    const suffix = wrap(ANSI.dim, ` (${rt})`, ctx.color);
-    return `${base}${suffix}`;
-};
-export const inlineRendererEntries = [
-    ['b', boldRenderer],
-    ['i', italicRenderer],
-    ['s', strikeRenderer],
-    ['u', underlineRenderer],
-    ['code', codeRenderer],
-    ['sub', subRenderer],
-    ['sup', supRenderer],
-    ['mark', markRenderer],
-    ['a', linkRenderer],
-    ['br', brRenderer],
-    ['mention', mentionRenderer],
-    ['tag', tagRenderer],
-    ['comment', commentRenderer],
-    ['footnote', footnoteRenderer],
-    ['ruby', rubyRenderer],
-];

package/dist/src/cli/render/lexical/parser.d.ts

@@ -1,10 +0,0 @@
-export type LiteXmlNode = {
-    readonly type: 'text';
-    readonly value: string;
-} | {
-    readonly type: 'element';
-    readonly tag: string;
-    readonly attrs: Readonly<Record<string, string>>;
-    readonly children: ReadonlyArray<LiteXmlNode>;
-};
-export declare const parseLitexml: (xml: string) => ReadonlyArray<LiteXmlNode>;

package/dist/src/cli/render/lexical/parser.js

@@ -1,64 +0,0 @@
-import { XMLParser } from 'fast-xml-parser';
-const TEXT_KEY = '#text';
-const ATTR_KEY = ':@';
-const parser = new XMLParser({
-    preserveOrder: true,
-    ignoreAttributes: false,
-    attributeNamePrefix: '',
-    parseAttributeValue: false,
-    processEntities: true,
-    trimValues: false,
-    textNodeName: TEXT_KEY,
-});
-const normalizeAttrs = (raw) => {
-    if (!raw || typeof raw !== 'object')
-        return {};
-    const out = {};
-    for (const [k, v] of Object.entries(raw)) {
-        out[k] = v == null ? '' : String(v);
-    }
-    return out;
-};
-const normalize = (raw) => {
-    if (!Array.isArray(raw))
-        return [];
-    const out = [];
-    for (const entry of raw) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const obj = entry;
-        const attrs = normalizeAttrs(obj[ATTR_KEY]);
-        for (const [key, value] of Object.entries(obj)) {
-            if (key === ATTR_KEY)
-                continue;
-            if (key === TEXT_KEY) {
-                out.push({ type: 'text', value: value == null ? '' : String(value) });
-                continue;
-            }
-            out.push({
-                type: 'element',
-                tag: key,
-                attrs,
-                children: normalize(value),
-            });
-        }
-    }
-    return out;
-};
-export const parseLitexml = (xml) => {
-    try {
-        // fast-xml-parser needs a single document root; LiteXML emits multiple
-        // top-level elements, so we synthesize one.
-        const raw = parser.parse(`<root>${xml}</root>`);
-        if (!Array.isArray(raw) || raw.length === 0)
-            return [];
-        const first = raw[0];
-        if (!first)
-            return [];
-        const inner = first.root;
-        return normalize(inner);
-    }
-    catch {
-        return [];
-    }
-};

package/dist/src/cli/render/lexical/walker.d.ts

@@ -1,21 +0,0 @@
-import type { LiteXmlNode } from './parser';
-export interface RenderCtx {
-    readonly color: boolean;
-    readonly indent: number;
-}
-export interface WalkApi {
-    readonly walkBlock: (node: LiteXmlNode, ctx: RenderCtx) => string;
-    readonly walkInline: (node: LiteXmlNode, ctx: RenderCtx) => string;
-    readonly walkBlockChildren: (children: ReadonlyArray<LiteXmlNode>, ctx: RenderCtx) => string;
-    readonly walkInlineChildren: (children: ReadonlyArray<LiteXmlNode>, ctx: RenderCtx) => string;
-}
-export type BlockRenderer = (node: Extract<LiteXmlNode, {
-    type: 'element';
-}>, ctx: RenderCtx, inner: WalkApi) => string;
-export type InlineRenderer = (node: Extract<LiteXmlNode, {
-    type: 'element';
-}>, ctx: RenderCtx, inner: WalkApi) => string;
-export declare const createWalker: (registries: {
-    readonly blocks: ReadonlyMap<string, BlockRenderer>;
-    readonly inlines: ReadonlyMap<string, InlineRenderer>;
-}) => WalkApi;

package/dist/src/cli/render/lexical/walker.js

@@ -1,51 +0,0 @@
-export const createWalker = (registries) => {
-    const walkInline = (node, ctx) => {
-        if (node.type === 'text')
-            return node.value;
-        const inline = registries.inlines.get(node.tag);
-        if (inline)
-            return inline(node, ctx, api);
-        return walkInlineChildren(node.children, ctx);
-    };
-    const walkBlock = (node, ctx) => {
-        if (node.type === 'text')
-            return node.value;
-        const block = registries.blocks.get(node.tag);
-        if (block)
-            return block(node, ctx, api);
-        return walkBlockChildren(node.children, ctx);
-    };
-    const walkInlineChildren = (children, ctx) => {
-        let out = '';
-        for (const child of children)
-            out += walkInline(child, ctx);
-        return out;
-    };
-    const walkBlockChildren = (children, ctx) => {
-        if (children.length === 0)
-            return '';
-        let out = '';
-        let first = true;
-        for (const child of children) {
-            // Drop whitespace-only text nodes between blocks — these are pretty-print
-            // artifacts from the upstream XML serializer (litexml `compact: false`).
-            if (child.type === 'text' && /^\s*$/.test(child.value))
-                continue;
-            const rendered = walkBlock(child, ctx);
-            if (!rendered)
-                continue;
-            if (!first)
-                out += '\n\n';
-            out += rendered;
-            first = false;
-        }
-        return out;
-    };
-    const api = {
-        walkBlock,
-        walkInline,
-        walkBlockChildren,
-        walkInlineChildren,
-    };
-    return api;
-};

package/dist/src/cli/render/markdown.d.ts

@@ -1,18 +0,0 @@
-export interface RenderOptions {
-    readonly color: boolean;
-}
-export declare const ANSI: {
-    readonly reset: "\u001B[0m";
-    readonly bold: "\u001B[1m";
-    readonly dim: "\u001B[2m";
-    readonly red: "\u001B[31m";
-    readonly green: "\u001B[32m";
-    readonly yellow: "\u001B[33m";
-    readonly blue: "\u001B[34m";
-    readonly magenta: "\u001B[35m";
-    readonly cyan: "\u001B[36m";
-};
-export declare const wrap: (code: string, text: string, on: boolean) => string;
-export declare const visibleLen: (s: string) => number;
-export declare const isColorEnabled: (stream: NodeJS.WriteStream) => boolean;
-export declare const renderMarkdownToAnsi: (markdown: string, opts: RenderOptions) => string;