markdansi 0.2.1 → 0.3.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-\g<1>2026 Peter Steinberger
+Copyright (c) 2026 Peter Steinberger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -11,6 +11,7 @@ Tiny, dependency-light Markdown → ANSI renderer and CLI for modern Node (>=22)
 Published on npm as `markdansi`.
 
 ## Install
+
 Grab it from npm; no native deps, so install is instant on Node 22+.
 
 ```bash
@@ -22,85 +23,90 @@ npm install markdansi
 ```
 
 ## CLI
+
 Quick one-shot renderer: pipe Markdown in, ANSI comes out. Flags let you pick width, wrap, colors, links, and table/list styling.
 
 ```bash
-markdansi [--in FILE] [--out FILE] [--width N] [--no-wrap] [--no-color] [--no-links] [--theme default|dim|bright]
+markdansi [FILE] [--in FILE] [--out FILE] [--width N] [--no-wrap] [--no-color] [--no-links] [--theme default|dim|bright]
 [--list-indent N] [--quote-prefix STR]
 ```
 
-- Input: stdin if `--in` not given (use `--in -` for stdin explicitly).
+- Input: positional `FILE`, `--in FILE`, or stdin when neither is given (use `--in -` for stdin explicitly).
 - Output: stdout unless `--out` provided.
 - Wrapping: on by default; `--no-wrap` disables hard wrapping.
 - Links: OSC‑8 when supported; `--no-links` disables.
 - Lists/quotes: `--list-indent` sets spaces per nesting level (default 2); `--quote-prefix` sets blockquote prefix (default `│ `).
 
 ## Library
+
 Use the renderer directly in Node/TS for customizable theming, optional syntax highlighting hooks, and OSC‑8 link control.
 
 ### ESM / CommonJS
+
 Markdansi ships ESM (`"type":"module"`). If you’re in CommonJS (or a tool like `tsx` running your script as CJS), prefer dynamic import:
 
 ```js
-const { render } = await import('markdansi');
-console.log(render('# hello'));
+const { render } = await import("markdansi");
+console.log(render("# hello"));
 ```
 
 ### Streaming (recommended: hybrid blocks)
+
 If you’re streaming Markdown (LLM output), keep scrollback safe by emitting **completed fragments only**
 and writing them once (append-only; no in-place redraw).
 
 Hybrid mode streams regular lines as they complete, but buffers multi-line constructs that need context:
+
 - Fenced code blocks (``` / ~~~) — flushed only after the closing fence
 - Tables — flushed only after the header separator row + until the table ends
 
 ```js
-import { createMarkdownStreamer, render } from 'markdansi';
+import { createMarkdownStreamer, render } from "markdansi";
 
 const streamer = createMarkdownStreamer({
   render: (md) => render(md, { width: process.stdout.columns ?? 80 }),
-  spacing: 'single', // collapse consecutive blank lines
+  spacing: "single", // collapse consecutive blank lines
 });
 
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', (delta) => {
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (delta) => {
   const chunk = streamer.push(delta);
   if (chunk) process.stdout.write(chunk);
 });
-process.stdin.on('end', () => {
+process.stdin.on("end", () => {
   const tail = streamer.finish();
   if (tail) process.stdout.write(tail);
 });
 ```
 
-```js
-import { render, createRenderer, strip, themes } from 'markdansi';
+````js
+import { render, createRenderer, strip, themes } from "markdansi";
 
-const ansi = render('# Hello **world**', { width: 60 });
+const ansi = render("# Hello **world**", { width: 60 });
 
 const renderNoWrap = createRenderer({ wrap: false });
-const out = renderNoWrap('A very long line...');
+const out = renderNoWrap("A very long line...");
 
 // Plain text (no ANSI/OSC)
-const plain = strip('link to [x](https://example.com)');
+const plain = strip("link to [x](https://example.com)");
 
 // Custom theme and highlighter hook
 const custom = createRenderer({
   theme: {
     ...themes.default,
-    code: { color: 'cyan', dim: true }, // fallback used for inline/block
-    inlineCode: { color: 'red' },
-    blockCode: { color: 'green' },
+    code: { color: "cyan", dim: true }, // fallback used for inline/block
+    inlineCode: { color: "red" },
+    blockCode: { color: "green" },
   },
   highlighter: (code, lang) => code.toUpperCase(),
 });
-console.log(custom('`inline`\n\n```\nblock code\n```'));
+console.log(custom("`inline`\n\n```\nblock code\n```"));
 
 // Example: real syntax highlighting with Shiki (TS + Swift)
-import { bundledLanguages, bundledThemes, createHighlighter } from 'shiki';
+import { bundledLanguages, bundledThemes, createHighlighter } from "shiki";
 
 const shiki = await createHighlighter({
-  themes: [bundledThemes['github-dark']],
+  themes: [bundledThemes["github-dark"]],
   langs: [bundledLanguages.typescript, bundledLanguages.swift],
 });
 
@@ -108,27 +114,29 @@ const highlighted = createRenderer({
   highlighter: (code, lang) => {
     if (!lang) return code;
     const normalized = lang.toLowerCase();
-    if (!['ts', 'typescript', 'swift'].includes(normalized)) return code;
+    if (!["ts", "typescript", "swift"].includes(normalized)) return code;
     const { tokens } = shiki.codeToTokens(code, {
-      lang: normalized === 'swift' ? 'swift' : 'ts',
-      theme: 'github-dark',
+      lang: normalized === "swift" ? "swift" : "ts",
+      theme: "github-dark",
     });
     return tokens
       .map((line) =>
         line
           .map((token) =>
-            token.color ? `\u001b[38;2;${parseInt(token.color.slice(1, 3), 16)};${parseInt(
-              token.color.slice(3, 5),
-              16,
-            )};${parseInt(token.color.slice(5, 7), 16)}m${token.content}\u001b[39m` : token.content,
+            token.color
+              ? `\u001b[38;2;${parseInt(token.color.slice(1, 3), 16)};${parseInt(
+                  token.color.slice(3, 5),
+                  16,
+                )};${parseInt(token.color.slice(5, 7), 16)}m${token.content}\u001b[39m`
+              : token.content,
           )
-          .join(''),
+          .join(""),
       )
-      .join('\n');
+      .join("\n");
   },
 });
-console.log(highlighted('```ts\nconst x: number = 1\n```\n```swift\nlet x = 1\n```'));
-```
+console.log(highlighted("```ts\nconst x: number = 1\n```\n```swift\nlet x = 1\n```"));
+````
 
 ### Options
 

package/dist/ast.d.ts

@@ -0,0 +1,99 @@
+export type Position = unknown;
+type Node = {
+    type: string;
+    position?: Position;
+};
+export type Text = Node & {
+    type: "text";
+    value: string;
+};
+export type Emphasis = Node & {
+    type: "emphasis";
+    children: InlineNode[];
+};
+export type Strong = Node & {
+    type: "strong";
+    children: InlineNode[];
+};
+export type Delete = Node & {
+    type: "delete";
+    children: InlineNode[];
+};
+export type InlineCode = Node & {
+    type: "inlineCode";
+    value: string;
+};
+export type Link = Node & {
+    type: "link";
+    url: string;
+    title?: string | null | undefined;
+    children: InlineNode[];
+};
+export type Break = Node & {
+    type: "break";
+};
+export type Html = Node & {
+    type: "html";
+    value: string;
+};
+export type InlineNode = Text | Emphasis | Strong | Delete | InlineCode | Link | Break | Html;
+export type Paragraph = Node & {
+    type: "paragraph";
+    children: InlineNode[];
+};
+export type Heading = Node & {
+    type: "heading";
+    depth: number;
+    children: InlineNode[];
+};
+export type ThematicBreak = Node & {
+    type: "thematicBreak";
+};
+export type Blockquote = Node & {
+    type: "blockquote";
+    children: BlockNode[];
+};
+export type List = Node & {
+    type: "list";
+    ordered?: boolean | undefined;
+    start?: number | null | undefined;
+    spread?: boolean | undefined;
+    children: ListItem[];
+};
+export type ListItem = Node & {
+    type: "listItem";
+    checked?: boolean | null | undefined;
+    spread?: boolean | undefined;
+    children: BlockNode[];
+};
+export type Code = Node & {
+    type: "code";
+    value: string;
+    lang?: string | null | undefined;
+    meta?: string | null | undefined;
+};
+export type TableCell = Node & {
+    type: "tableCell";
+    children: InlineNode[];
+};
+export type TableRow = Node & {
+    type: "tableRow";
+    children: TableCell[];
+};
+export type Table = Node & {
+    type: "table";
+    align?: Array<"left" | "right" | "center" | null> | undefined;
+    children: TableRow[];
+};
+export type Definition = Node & {
+    type: "definition";
+    identifier: string;
+    url?: string | undefined;
+    title?: string | null | undefined;
+};
+export type BlockNode = Paragraph | Heading | ThematicBreak | Blockquote | List | ListItem | Code | Table | Definition;
+export type Root = Node & {
+    type: "root";
+    children: BlockNode[];
+};
+export {};

package/dist/ast.js

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

package/dist/cli.js

@@ -104,6 +104,8 @@ export function parseArgs(argv) {
         }
         else if (a === "--help" || a === "-h")
             args.help = true;
+        else if (!a.startsWith("-") && !args.in)
+            args.in = a;
     }
     return args;
 }
@@ -114,7 +116,13 @@ function main() {
     handleStdoutEpipe();
     const args = parseArgs(process.argv);
     if (args.help) {
-        process.stdout.write(`markdansi options:
+        process.stdout.write(`markdansi [FILE] [options]
+
+  markdansi file.md            Render file
+  markdansi --in file.md       Same (explicit)
+  cat file.md | markdansi      Read from stdin
+
+Options:
   --in FILE           Input file (default: stdin)
   --out FILE          Output file (default: stdout)
   --width N           Wrap width (default: TTY cols or 80)
@@ -145,9 +153,7 @@ function main() {
         ...(args.hyperlinks !== undefined ? { hyperlinks: args.hyperlinks } : {}),
         ...(args.theme !== undefined ? { theme: args.theme } : {}),
         ...(args.listIndent !== undefined ? { listIndent: args.listIndent } : {}),
-        ...(args.quotePrefix !== undefined
-            ? { quotePrefix: args.quotePrefix }
-            : {}),
+        ...(args.quotePrefix !== undefined ? { quotePrefix: args.quotePrefix } : {}),
     };
     const output = render(input, renderOptions);
     if (args.out) {

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { createRenderer, render as renderMarkdown } from "./render.js";
 import { createMarkdownStreamer } from "./stream.js";
 import { themes } from "./theme.js";
 import type { RenderOptions, Theme, ThemeName } from "./types.js";
-export { createMarkdownStreamer, createRenderer, renderMarkdown as render, themes, };
+export { createMarkdownStreamer, createRenderer, renderMarkdown as render, themes };
 export type { RenderOptions, Theme, ThemeName };
 /**
  * Render Markdown to plain text (no ANSI, no hyperlinks) while preserving layout/wrapping.

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRenderer, render as renderMarkdown } from "./render.js";
 import { createMarkdownStreamer } from "./stream.js";
 import { themes } from "./theme.js";
-export { createMarkdownStreamer, createRenderer, renderMarkdown as render, themes, };
+export { createMarkdownStreamer, createRenderer, renderMarkdown as render, themes };
 /**
  * Render Markdown to plain text (no ANSI, no hyperlinks) while preserving layout/wrapping.
  */

package/dist/parser.d.ts

@@ -1,2 +1,2 @@
-import type { Root } from "mdast";
+import type { Root } from "./ast.js";
 export declare function parse(markdown: string): Root;

package/dist/parser.js

@@ -1,9 +1,205 @@
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { gfmFromMarkdown } from "mdast-util-gfm";
-import { gfm as gfmSyntax } from "micromark-extension-gfm";
-export function parse(markdown) {
-    return fromMarkdown(markdown, {
-        extensions: [gfmSyntax()],
-        mdastExtensions: [gfmFromMarkdown()],
+import { decodeNamedCharacterReference } from "decode-named-character-reference";
+import { marked } from "marked";
+const CHARACTER_REFERENCE = /&(#\d+|#x[\da-f]+|[a-z][\da-z]+);/giu;
+function decodeNumericReference(body, radix) {
+    const offset = radix === 16 ? 2 : 1;
+    const codePoint = Number.parseInt(body.slice(offset), radix);
+    const isDisallowedControl = codePoint <= 0x08 ||
+        codePoint === 0x0b ||
+        (codePoint >= 0x0e && codePoint <= 0x1f) ||
+        (codePoint >= 0x7f && codePoint <= 0x9f);
+    const isNonCharacter = (codePoint >= 0xfdd0 && codePoint <= 0xfdef) ||
+        (codePoint & 0xffff) === 0xfffe ||
+        (codePoint & 0xffff) === 0xffff;
+    if (!Number.isSafeInteger(codePoint) ||
+        codePoint <= 0 ||
+        codePoint > 0x10ffff ||
+        (codePoint >= 0xd800 && codePoint <= 0xdfff) ||
+        isDisallowedControl ||
+        isNonCharacter) {
+        return "\uFFFD";
+    }
+    return String.fromCodePoint(codePoint);
+}
+function decodeEntities(value) {
+    return value.replace(CHARACTER_REFERENCE, (reference, body) => {
+        if (body.startsWith("#x") || body.startsWith("#X")) {
+            return decodeNumericReference(body, 16);
+        }
+        if (body.startsWith("#")) {
+            return decodeNumericReference(body, 10);
+        }
+        return decodeNamedCharacterReference(body) || reference;
+    });
+}
+function convertInlineTokens(tokens) {
+    if (!tokens)
+        return [];
+    const nodes = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case "text": {
+                const text = token;
+                if (text.tokens?.length) {
+                    nodes.push(...convertInlineTokens(text.tokens));
+                }
+                else {
+                    nodes.push({ type: "text", value: decodeEntities(text.text) });
+                }
+                break;
+            }
+            case "escape":
+                nodes.push({ type: "text", value: token.text });
+                break;
+            case "em":
+                nodes.push({
+                    type: "emphasis",
+                    children: convertInlineTokens(token.tokens),
+                });
+                break;
+            case "strong":
+                nodes.push({
+                    type: "strong",
+                    children: convertInlineTokens(token.tokens),
+                });
+                break;
+            case "del":
+                nodes.push({
+                    type: "delete",
+                    children: convertInlineTokens(token.tokens),
+                });
+                break;
+            case "codespan":
+                nodes.push({ type: "inlineCode", value: token.text });
+                break;
+            case "link": {
+                const link = token;
+                nodes.push({
+                    type: "link",
+                    url: decodeEntities(link.href),
+                    title: link.title ? decodeEntities(link.title) : link.title,
+                    children: convertInlineTokens(link.tokens),
+                });
+                break;
+            }
+            case "br":
+                nodes.push({ type: "break" });
+                break;
+            case "html":
+                nodes.push({ type: "html", value: token.text });
+                break;
+            default:
+                break;
+        }
+    }
+    return nodes;
+}
+function convertCode(token) {
+    const info = token.lang?.trim() ?? "";
+    const separator = info.search(/\s/u);
+    const lang = separator >= 0 ? info.slice(0, separator) : info;
+    const meta = separator >= 0 ? info.slice(separator).trim() : "";
+    return {
+        type: "code",
+        value: token.text,
+        ...(lang ? { lang } : {}),
+        ...(meta ? { meta } : {}),
+    };
+}
+function convertListItem(item) {
+    return {
+        type: "listItem",
+        checked: item.task ? Boolean(item.checked) : null,
+        spread: item.loose,
+        children: convertBlockTokens(item.tokens),
+    };
+}
+function convertTableCell(cell) {
+    return {
+        type: "tableCell",
+        children: convertInlineTokens(cell.tokens),
+    };
+}
+function convertTableRow(cells) {
+    return {
+        type: "tableRow",
+        children: cells.map(convertTableCell),
+    };
+}
+function convertBlockToken(token) {
+    switch (token.type) {
+        case "paragraph":
+            return {
+                type: "paragraph",
+                children: convertInlineTokens(token.tokens),
+            };
+        case "text": {
+            const text = token;
+            return {
+                type: "paragraph",
+                children: text.tokens?.length
+                    ? convertInlineTokens(text.tokens)
+                    : [{ type: "text", value: decodeEntities(text.text) }],
+            };
+        }
+        case "heading": {
+            const heading = token;
+            return {
+                type: "heading",
+                depth: heading.depth,
+                children: convertInlineTokens(heading.tokens),
+            };
+        }
+        case "hr":
+            return { type: "thematicBreak" };
+        case "blockquote":
+            return {
+                type: "blockquote",
+                children: convertBlockTokens(token.tokens),
+            };
+        case "list": {
+            const list = token;
+            return {
+                type: "list",
+                ordered: list.ordered,
+                start: list.ordered && typeof list.start === "number" ? list.start : null,
+                spread: list.loose,
+                children: list.items.map(convertListItem),
+            };
+        }
+        case "code":
+            return convertCode(token);
+        case "table": {
+            const table = token;
+            return {
+                type: "table",
+                align: table.align,
+                children: [convertTableRow(table.header), ...table.rows.map(convertTableRow)],
+            };
+        }
+        case "def": {
+            const definition = token;
+            const title = decodeEntities((definition.title ?? "").replace(/\s+/gu, " ").trim());
+            return {
+                type: "definition",
+                identifier: definition.tag,
+                url: decodeEntities(definition.href),
+                title: title || null,
+            };
+        }
+        default:
+            return null;
+    }
+}
+function convertBlockTokens(tokens) {
+    return tokens.flatMap((token) => {
+        const node = convertBlockToken(token);
+        return node ? [node] : [];
     });
 }
+export function parse(markdown) {
+    return {
+        type: "root",
+        children: convertBlockTokens(marked.lexer(markdown, { gfm: true })),
+    };
+}

package/dist/render.js

@@ -1,3 +1,4 @@
+import sliceAnsi from "slice-ansi";
 import stringWidth from "string-width";
 import stripAnsi from "strip-ansi";
 import { hyperlinkSupported, osc8 } from "./hyperlink.js";
@@ -21,9 +22,7 @@ function resolveOptions(userOptions = {}) {
     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 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"
@@ -31,17 +30,9 @@ function resolveOptions(userOptions = {}) {
         : 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 ||
-            {},
+        ...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;
@@ -163,8 +154,7 @@ function mergeAdjacentCodeBlocks(nodes) {
     };
     for (const node of nodes) {
         if (node?.type === "code") {
-            if (pending &&
-                (pending.lang === node.lang || (!pending.lang && !node.lang))) {
+            if (pending && (pending.lang === node.lang || (!pending.lang && !node.lang))) {
                 const nextValue = `${pending.value}\n${node.value}`;
                 pending = {
                     type: "code",
@@ -183,9 +173,7 @@ function mergeAdjacentCodeBlocks(nodes) {
         if (node?.type === "list") {
             const flattened = flattenCodeList(node);
             if (flattened) {
-                if (pending &&
-                    (pending.lang === flattened.lang ||
-                        (!pending.lang && !flattened.lang))) {
+                if (pending && (pending.lang === flattened.lang || (!pending.lang && !flattened.lang))) {
                     const nextValue = `${pending.value}\n${flattened.value}`;
                     pending = {
                         type: "code",
@@ -329,9 +317,7 @@ function renderParagraph(node, ctx, indentLevel) {
     const defPattern = /^\[[^\]]+]:\s+\S/;
     let inDefinitions = false;
     for (const line of rawLines) {
-        if (defPattern.test(line) &&
-            normalized.length > 0 &&
-            normalized.at(-1) !== "") {
+        if (defPattern.test(line) && normalized.length > 0 && normalized.at(-1) !== "") {
             normalized.push(""); // insert blank line before footer-style definitions
         }
         if (defPattern.test(line)) {
@@ -355,9 +341,7 @@ function renderHeading(node, ctx) {
     return [`\n${styled}\n`];
 }
 function renderHr(ctx) {
-    const width = ctx.options.wrap
-        ? Math.min(ctx.options.width ?? HR_WIDTH, HR_WIDTH)
-        : HR_WIDTH;
+    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`];
 }
@@ -389,9 +373,7 @@ function renderListItem(node, ctx, indentLevel, tight, ordered = false, start =
     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} `);
+        (isTask ? `${ctx.style(box, ctx.options.theme.listMarker)} ` : `${markerStyled} `);
     const lines = [];
     content.forEach((line, i) => {
         const clean = line.replace(/^\s+/, "");
@@ -414,9 +396,7 @@ function renderCodeBlock(node, ctx) {
     const theme = ctx.options.theme.blockCode || ctx.options.theme.inlineCode;
     const lines = (node.value ?? "").split("\n");
     const isDiff = node.lang === "diff";
-    const gutterWidth = ctx.options.codeGutter
-        ? String(lines.length).length + 2
-        : 0;
+    const gutterWidth = ctx.options.codeGutter ? String(lines.length).length + 2 : 0;
     const shouldWrap = isDiff ? false : ctx.options.codeWrap;
     const useBox = ctx.options.codeBox && lines.length > 1;
     const boxPadding = useBox ? 4 : 0;
@@ -426,13 +406,10 @@ function renderCodeBlock(node, ctx) {
     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);
+            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);
+            const num = segIdx === 0 ? String(idx + 1).padStart(gutterWidth - 2, " ") : " ".repeat(gutterWidth - 1);
             return `${ctx.style(num, { dim: true })} ${highlighted}`;
         });
     });
@@ -491,9 +468,9 @@ function renderInline(children, ctx) {
             case "break":
                 out += HARD_BREAK;
                 break;
-            default:
-                if ("value" in node && typeof node.value === "string")
-                    out += node.value;
+            case "html":
+                out += node.value;
+                break;
         }
     }
     return out;
@@ -530,10 +507,7 @@ function normalizeParagraphInlineText(text) {
         }
         const leftTrim = left.trimStart();
         const rightTrim = right.trimStart();
-        const keepNewline = left === "" ||
-            right === "" ||
-            defPattern.test(leftTrim) ||
-            defPattern.test(rightTrim);
+        const keepNewline = left === "" || right === "" || defPattern.test(leftTrim) || defPattern.test(rightTrim);
         out += keepNewline ? "\n" : " ";
         out += rightTrim;
     }
@@ -550,8 +524,7 @@ function renderLink(node, ctx) {
         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) + ctx.style(` (${url})`, { dim: true });
     }
     return ctx.style(label, ctx.options.theme.link);
 }
@@ -562,7 +535,7 @@ function renderTable(node, ctx) {
     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 widths = Array.from({ length: colCount }, () => 1);
     const aligns = node.align || [];
     const pad = ctx.options.tablePadding;
     const padStr = " ".repeat(Math.max(0, pad));
@@ -573,7 +546,7 @@ function renderTable(node, ctx) {
         row.forEach((cell, idx) => {
             const padded = `${padStr}${cell}${padStr}`;
             // Cap each column to MAX_COL but keep at least 1
-            widths[idx] = Math.max(widths[idx], Math.min(MAX_COL, visibleWidth(padded)));
+            widths[idx] = Math.max(widths[idx] ?? 1, Math.min(MAX_COL, visibleWidth(padded)));
         });
     });
     const totalWidth = widths.reduce((a, b) => a + b, 0) + 3 * colCount + 1;
@@ -582,19 +555,20 @@ function renderTable(node, ctx) {
         let over = totalWidth - ctx.options.width;
         while (over > 0) {
             const i = widths.indexOf(Math.max(...widths));
-            if (widths[i] <= minColWidth)
+            if ((widths[i] ?? minColWidth) <= minColWidth)
                 break;
-            widths[i] -= 1;
+            widths[i] = (widths[i] ?? minColWidth) - 1;
             over -= 1;
         }
     }
     for (let i = 0; i < widths.length; i += 1) {
-        if (widths[i] < minColWidth)
+        if ((widths[i] ?? minColWidth) < minColWidth)
             widths[i] = minColWidth;
     }
     const renderRow = (row, isHeader = false) => {
         const linesPerCol = row.map((cell, idx) => {
-            const target = Math.max(minContent, widths[idx] - pad * 2);
+            const width = widths[idx] ?? minColWidth;
+            const target = Math.max(minContent, width - pad * 2);
             const content = ctx.options.tableTruncate
                 ? truncateCell(cell, target, ctx.options.tableEllipsis)
                 : cell;
@@ -602,7 +576,7 @@ function renderTable(node, ctx) {
             return wrapped.map((l) => {
                 const aligned = padCell(l, target, aligns[idx] ?? "left");
                 const padded = `${padStr}${aligned}${padStr}`;
-                return padCell(padded, widths[idx], "left");
+                return padCell(padded, width, "left");
             });
         });
         // Row height = max wrapped lines in any column; pad shorter ones
@@ -610,7 +584,7 @@ function renderTable(node, ctx) {
         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");
+                const content = col[i] ?? padCell("", widths[idx] ?? minColWidth, aligns[idx] ?? "left");
                 return isHeader
                     ? ctx.style(content, ctx.options.theme.tableHeader)
                     : ctx.style(content, ctx.options.theme.tableCell);
@@ -622,38 +596,36 @@ function renderTable(node, ctx) {
     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");
+        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 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 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",
-    ];
+    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;
+    const ellipsisWidth = stringWidth(ellipsis);
+    if (width <= ellipsisWidth)
+        return sliceCellContent(ellipsis, width);
+    return `${sliceCellContent(text, width - ellipsisWidth)}${ellipsis}`;
+}
+function sliceCellContent(text, width) {
+    let end = Math.max(0, width);
+    let sliced = sliceAnsi(text, 0, end);
+    // slice-ansi owns ANSI/OSC/grapheme boundaries; clamp with Markdansi's width metric.
+    while (end > 0 && stringWidth(sliced) > width) {
+        end -= 1;
+        sliced = sliceAnsi(text, 0, end);
+    }
+    return sliced;
 }
 function wrapCodeLine(text, width) {
     // Hard-wrap code even without spaces while keeping ANSI-safe width accounting.
@@ -661,7 +633,7 @@ function wrapCodeLine(text, width) {
         return [text];
     const parts = [];
     let current = "";
-    for (const ch of [...text]) {
+    for (const ch of text) {
         const chWidth = stringWidth(ch);
         if (visibleWidth(current) + chWidth > width) {
             parts.push(current);

package/dist/stream.js

@@ -126,8 +126,7 @@ export function createMarkdownStreamer(options) {
             fence = fenceStart;
             fenceBuffer = `${line}\n`;
             // Some fences are single-line in streams (rare). Handle close immediately.
-            if (isFenceEnd(line, fenceStart) &&
-                line.trimStart().match(/^(```+|~~~+)\s*$/)) {
+            if (isFenceEnd(line, fenceStart) && line.trimStart().match(/^(```+|~~~+)\s*$/)) {
                 return out + flushFence();
             }
             return out;

package/docs/spec.md

@@ -3,7 +3,9 @@
 Goal: Tiny, dependency‑light Markdown → ANSI renderer & CLI for Node ≥22, using pnpm. Output is terminal ANSI only (no HTML). Focus on readable defaults, sensible wrapping, and minimal runtime deps.
 
 ## Core Dependencies (runtime)
-- `micromark`, `micromark-extension-gfm`, `micromark-util-combine-extensions`: GFM parsing (tables, task lists, strikethrough, autolink literals).
+
+- `marked`: GFM parsing (tables, task lists, strikethrough, autolink literals).
+- `decode-named-character-reference`: decode Markdown character references in text and URLs.
 - `chalk`: small, ESM‑only color/style helper.
 - `string-width`: correct visible width (emoji / wide chars).
 - `strip-ansi`: strip codes for width/wrapping.
@@ -12,7 +14,9 @@ Goal: Tiny, dependency‑light Markdown → ANSI renderer & CLI for Node ≥22,
 Dev: `vitest`, TypeScript (NodeNext).
 
 ## Surface Area
+
 ### Library (ESM default, CJS export provided)
+
 `render(markdown: string, options?: RenderOptions): string`
 
 `createRenderer(options?: RenderOptions): (md: string) => string`
@@ -42,13 +46,16 @@ Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineC
 `strip(markdown: string): string` — convenience: render with `color=false`, `hyperlinks=false`.
 
 ### CLI
-`markdansi [--in FILE] [--out FILE] [--width N] [--no-wrap] [--no-color] [--no-links] [--theme default|dim|bright]`
-- Input: stdin if no `--in`.
+
+`markdansi [FILE] [--in FILE] [--out FILE] [--width N] [--no-wrap] [--no-color] [--no-links] [--theme default|dim|bright]`
+
+- Input: positional `FILE`, `--in FILE`, or stdin when neither is given.
 - Output: stdout if no `--out`.
 - Wrap: on by default; `--no-wrap` disables; width auto from TTY when not provided.
 - Links: OSC‑8 hyperlinks enabled when terminal supports; `--no-links` disables.
 
 ## Feature Scope (v1)
+
 - Blocks: paragraphs, headings (1–6), blockquotes, fenced/indented code blocks, HR, tables, unordered/ordered lists, task lists.
 - Inline: strong, emphasis, code spans, autolinks/links, strikethrough (GFM `~~`), backslash escapes.
 - Code blocks: monospace box (unicode or ascii; `codeBox=false` disables). Optional gutter with 1‑based line numbers when `codeGutter=true`. If `lang` present, show faint header label. Highlighter hook may recolor text but must not add/remove newlines. Code blocks wrap to the available width by default (hard-wrap long tokens); set `codeWrap=false` to allow overflow.
@@ -58,15 +65,17 @@ Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineC
 - Error handling: never throw on malformed emphasis; leave literals untouched if unmatched.
 
 ## Rendering Pipeline
-1) **Parse** via micromark with combined GFM extensions → AST events.
-2) **Build light IR** (nodes: paragraph, heading, list, listItem, taskItem, table, tableRow, tableCell, code, inline text/emph/strong/del/code/link).
-3) **Render** to ANSI:
+
+1. **Parse** via Marked's GFM lexer → lightweight internal AST.
+2. **Build light IR** (nodes: paragraph, heading, list, listItem, taskItem, table, tableRow, tableCell, code, inline text/emph/strong/del/code/link).
+3. **Render** to ANSI:
    - Style map from theme to SGR codes.
    - Wrap paragraphs/table cells using `string-width` + `strip-ansi`; wrap only breaks on spaces.
    - OSC‑8 links when `hyperlinks` true; otherwise underline + optional URL suffix.
    - Track active SGR for wrapping splits to re-open styles on new lines.
 
 ## Themes (initial)
+
 - `default`: bold headings, blue links, cyan inline code, green block code, yellow table headers, subtle quotes/hr.
 - `dim`: muted colors for low-contrast terminals.
 - `bright`: higher contrast variant.
@@ -75,17 +84,21 @@ Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineC
 - `contrast`: magenta headings, cyan inline, green block code, yellow headers, bright markers.
 
 ## Testing (vitest)
+
 - Unit: inline formatting (emph/strong/code/strike), links/hyperlinks on/off, wrap/no-wrap behavior, table alignment and wrapping, task lists, strikethrough.
 - Snapshot-ish string comparisons for representative documents (with colors off to avoid brittle codes).
 
 ## Non-Goals (v1)
+
 - Images, footnotes, math, HTML passthrough, syntax highlighting bundle.
 
 ## Notes
+
 - Highlighting: built-in is “label-only”; extensibility via `highlighter` hook. No extra deps added for highlighting.
 - ESM-first; provide CJS export entry for compatibility.
 
 ## Behaviors & edge-case rules
+
 - Wrap/width precedence: `wrap=false` disables all hard wrapping; `width` is ignored in that mode. When `wrap=true`, width is `options.width ?? ttyColumns ?? 80`.
 - Color flag: `color=false` removes all ANSI/OSC output (no bold/italic/underline, no hyperlinks); output is plain text.
 - Hyperlinks fallback: inline links render as `label (url)` when OSC‑8 disabled; autolinks render as the URL only. URLs count toward width.

package/package.json

@@ -1,83 +1,78 @@
 {
-	"name": "markdansi",
-	"version": "0.2.1",
-	"description": "Tiny dependency-light markdown to ANSI converter.",
-	"type": "module",
-	"main": "dist/index.js",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js",
-			"default": "./dist/index.js"
-		},
-		"./cli": "./dist/cli.js"
-	},
-	"bin": {
-		"markdansi": "dist/cli.js"
-	},
-	"scripts": {
-		"build": "pnpm lint && pnpm test && pnpm compile",
-		"clean": "rm -rf dist",
-		"lint": "rm -rf dist coverage && biome check .",
-		"test": "vitest run",
-		"test:coverage": "vitest run --coverage",
-		"types": "tsc -p tsconfig.json --emitDeclarationOnly",
-		"compile": "tsc -p tsconfig.json",
-		"prepare": "pnpm compile",
-		"markdansi": "tsx src/cli.ts"
-	},
-	"keywords": [
-		"markdown",
-		"ansi",
-		"terminal",
-		"cli"
-	],
-	"engines": {
-		"node": ">=22"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/steipete/Markdansi.git"
-	},
-	"bugs": {
-		"url": "https://github.com/steipete/Markdansi/issues"
-	},
-	"homepage": "https://github.com/steipete/Markdansi#readme",
-	"author": "Peter Steinberger",
-	"license": "MIT",
-	"sideEffects": false,
-	"files": [
-		"dist",
-		"README.md",
-		"docs/spec.md",
-		"package.json",
-		"tsconfig.json",
-		".biome.json"
-	],
-	"types": "dist/index.d.ts",
-	"dependencies": {
-		"chalk": "^5.6.2",
-		"mdast-util-from-markdown": "^2.0.2",
-		"mdast-util-gfm": "^3.1.0",
-		"micromark": "^4.0.2",
-		"micromark-extension-gfm": "^3.0.0",
-		"micromark-util-combine-extensions": "^2.0.1",
-		"string-width": "^8.1.0",
-		"strip-ansi": "^7.1.2",
-		"supports-hyperlinks": "^4.4.0"
-	},
-	"devDependencies": {
-		"@biomejs/biome": "^2.3.10",
-		"@types/mdast": "^4.0.4",
-		"@types/node": "^25.0.3",
-		"@vitest/coverage-v8": "^4.0.16",
-		"tsx": "^4.21.0",
-		"typescript": "^5.9.3",
-		"vitest": "^4.0.16"
-	},
-	"pnpm": {
-		"onlyBuiltDependencies": [
-			"esbuild"
-		]
-	}
+  "name": "markdansi",
+  "version": "0.3.1",
+  "description": "Tiny dependency-light markdown to ANSI converter.",
+  "keywords": [
+    "ansi",
+    "cli",
+    "markdown",
+    "terminal"
+  ],
+  "homepage": "https://github.com/steipete/Markdansi#readme",
+  "bugs": {
+    "url": "https://github.com/steipete/Markdansi/issues"
+  },
+  "license": "MIT",
+  "author": "Peter Steinberger",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/steipete/Markdansi.git"
+  },
+  "bin": {
+    "markdansi": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "docs/spec.md",
+    "package.json",
+    "tsconfig.json"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./cli": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "pnpm lint && pnpm typecheck && pnpm test && pnpm compile",
+    "clean": "rm -rf dist",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "lint": "rm -rf dist coverage && pnpm format:check && oxlint --deny-warnings src test",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "types": "tsc -p tsconfig.json --emitDeclarationOnly",
+    "compile": "tsc -p tsconfig.json",
+    "prepare": "pnpm compile",
+    "markdansi": "tsx src/cli.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "decode-named-character-reference": "^1.3.0",
+    "marked": "^18.0.5",
+    "slice-ansi": "^9.0.0",
+    "string-width": "^8.2.1",
+    "strip-ansi": "^7.2.0",
+    "supports-hyperlinks": "^4.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@vitest/coverage-v8": "^4.1.5",
+    "oxfmt": "^0.47.0",
+    "oxlint": "^1.62.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=22"
+  }
 }

package/tsconfig.json

@@ -1,17 +1,18 @@
 {
-	"compilerOptions": {
-		"strict": true,
-		"noUncheckedIndexedAccess": true,
-		"exactOptionalPropertyTypes": true,
-		"noPropertyAccessFromIndexSignature": true,
-		"declaration": true,
-		"outDir": "dist",
-		"rootDir": "src",
-		"module": "NodeNext",
-		"moduleResolution": "NodeNext",
-		"target": "ES2022",
-		"resolveJsonModule": true
-	},
-	"include": ["src/**/*.ts"],
-	"exclude": ["node_modules", "dist", "coverage"]
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2022",
+    "types": ["node"],
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "coverage"]
 }

package/.biome.json

@@ -1,24 +0,0 @@
-{
-	"$schema": "https://biomejs.dev/schemas/1.8.0/schema.json",
-	"extends": ["biome:recommended"],
-	"formatter": {
-		"enabled": true
-	},
-	"organizeImports": {
-		"enabled": true
-	},
-	"files": {
-		"ignore": [
-			"coverage/**",
-			"**/coverage/**",
-			"node_modules/**",
-			"dist/**",
-			"**/dist/**"
-		]
-	},
-	"linter": {
-		"rules": {
-			"recommended": true
-		}
-	}
-}