markdansi 0.3.0 → 0.3.2

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

@@ -3,6 +3,31 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { render } from "./index.js";
+function readOptionValue(argv, index, option, allowLeadingDashes = false) {
+    const value = argv[index + 1];
+    if (value === undefined || (!allowLeadingDashes && value.startsWith("--"))) {
+        throw new Error(`${option} requires a value`);
+    }
+    return value;
+}
+function parseIntegerOption(option, value, minimum) {
+    const parsed = Number(value);
+    if (!/^\d+$/u.test(value) || !Number.isSafeInteger(parsed) || parsed < minimum) {
+        const range = minimum === 0 ? "a non-negative integer" : "a positive integer";
+        throw new Error(`${option} must be ${range}`);
+    }
+    return parsed;
+}
+function parseTheme(value) {
+    if (value === "default" || value === "dim" || value === "bright")
+        return value;
+    throw new Error("--theme must be default, dim, or bright");
+}
+function parseTableBorder(value) {
+    if (value === "unicode" || value === "ascii" || value === "none")
+        return value;
+    throw new Error("--table-border must be unicode, ascii, or none");
+}
 /**
  * Ignore EPIPE when downstream (e.g., `head`) closes early.
  */
@@ -32,80 +57,85 @@ export function parseArgs(argv) {
             args.color = false;
         else if (a === "--no-links")
             args.hyperlinks = false;
+        else if (a === "--code-wrap")
+            args.codeWrap = true;
         else if (a === "--code-wrap=false")
             args.codeWrap = false;
         else if (a === "--code-wrap=true")
             args.codeWrap = true;
+        else if (a === "--code-box")
+            args.codeBox = true;
         else if (a === "--code-box=false")
             args.codeBox = false;
         else if (a === "--code-box=true")
             args.codeBox = true;
+        else if (a === "--code-gutter")
+            args.codeGutter = true;
         else if (a === "--code-gutter=true")
             args.codeGutter = true;
         else if (a === "--code-gutter=false")
             args.codeGutter = false;
         else if (a.startsWith("--table-border=")) {
-            const val = a.split("=")[1];
-            if (val === "unicode" || val === "ascii" || val === "none")
-                args.tableBorder = val;
+            args.tableBorder = parseTableBorder(a.slice("--table-border=".length));
+        }
+        else if (a === "--table-border") {
+            args.tableBorder = parseTableBorder(readOptionValue(argv, i, a));
+            i += 1;
         }
         else if (a === "--table-dense")
             args.tableDense = true;
+        else if (a === "--table-truncate")
+            args.tableTruncate = true;
         else if (a === "--table-truncate=false")
             args.tableTruncate = false;
         else if (a === "--table-truncate=true")
             args.tableTruncate = true;
         else if (a === "--table-padding") {
-            const next = argv[i + 1];
-            if (next)
-                args.tablePadding = Number(next);
+            const next = readOptionValue(argv, i, a);
+            args.tablePadding = parseIntegerOption(a, next, 0);
             i += 1;
         }
         else if (a === "--table-ellipsis") {
-            const next = argv[i + 1];
-            if (next)
-                args.tableEllipsis = next;
+            args.tableEllipsis = readOptionValue(argv, i, a, true);
             i += 1;
         }
         else if (a === "--in") {
-            const next = argv[i + 1];
-            if (next)
-                args.in = next;
+            args.in = readOptionValue(argv, i, a, true);
             i += 1;
         }
         else if (a === "--out") {
-            const next = argv[i + 1];
-            if (next)
-                args.out = next;
+            args.out = readOptionValue(argv, i, a, true);
             i += 1;
         }
         else if (a === "--width") {
-            const next = argv[i + 1];
-            if (next)
-                args.width = Number(next);
+            const next = readOptionValue(argv, i, a);
+            args.width = parseIntegerOption(a, next, 1);
             i += 1;
         }
         else if (a.startsWith("--theme=")) {
-            const themeVal = a.split("=")[1];
-            if (themeVal)
-                args.theme = themeVal;
+            args.theme = parseTheme(a.slice("--theme=".length));
+        }
+        else if (a === "--theme") {
+            args.theme = parseTheme(readOptionValue(argv, i, a));
+            i += 1;
         }
         else if (a === "--list-indent") {
-            const next = argv[i + 1];
-            if (next)
-                args.listIndent = Number(next);
+            const next = readOptionValue(argv, i, a);
+            args.listIndent = parseIntegerOption(a, next, 0);
             i += 1;
         }
         else if (a === "--quote-prefix") {
-            const next = argv[i + 1];
-            if (next)
-                args.quotePrefix = next;
+            args.quotePrefix = readOptionValue(argv, i, a, true);
             i += 1;
         }
         else if (a === "--help" || a === "-h")
             args.help = true;
-        else if (!a.startsWith("-") && !args.in)
+        else if (a.startsWith("-"))
+            throw new Error(`unknown option: ${a}`);
+        else if (!args.in)
             args.in = a;
+        else
+            throw new Error(`unexpected positional argument: ${a}`);
     }
     return args;
 }
@@ -114,8 +144,8 @@ export function parseArgs(argv) {
  */
 function main() {
     handleStdoutEpipe();
-    const args = parseArgs(process.argv);
-    if (args.help) {
+    const { in: inputPath, out: outputPath, help, ...renderOptions } = parseArgs(process.argv);
+    if (help) {
         process.stdout.write(`markdansi [FILE] [options]
 
   markdansi file.md            Render file
@@ -143,21 +173,12 @@ Options:
 `);
         process.exit(0);
     }
-    const input = args.in && args.in !== "-"
-        ? fs.readFileSync(path.resolve(args.in), "utf8")
+    const input = inputPath && inputPath !== "-"
+        ? fs.readFileSync(path.resolve(inputPath), "utf8")
         : fs.readFileSync(0, "utf8");
-    const renderOptions = {
-        ...(args.wrap !== undefined ? { wrap: args.wrap } : {}),
-        ...(args.width !== undefined ? { width: args.width } : {}),
-        ...(args.color !== undefined ? { color: args.color } : {}),
-        ...(args.hyperlinks !== undefined ? { hyperlinks: args.hyperlinks } : {}),
-        ...(args.theme !== undefined ? { theme: args.theme } : {}),
-        ...(args.listIndent !== undefined ? { listIndent: args.listIndent } : {}),
-        ...(args.quotePrefix !== undefined ? { quotePrefix: args.quotePrefix } : {}),
-    };
     const output = render(input, renderOptions);
-    if (args.out) {
-        fs.writeFileSync(path.resolve(args.out), output, "utf8");
+    if (outputPath) {
+        fs.writeFileSync(path.resolve(outputPath), output, "utf8");
     }
     else {
         process.stdout.write(output);
@@ -177,5 +198,11 @@ export function isDirectCliInvocation(metaUrl, argv1) {
 }
 // Only run the CLI when executed directly, not when imported for tests.
 if (isDirectCliInvocation(import.meta.url, process.argv[1])) {
-    main();
+    try {
+        main();
+    }
+    catch (error) {
+        console.error(`markdansi: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
 }

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

@@ -468,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;

package/docs/spec.md

@@ -4,7 +4,8 @@ Goal: Tiny, dependency‑light Markdown → ANSI renderer & CLI for Node ≥22,
 
 ## 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.
@@ -65,7 +66,7 @@ Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineC
 
 ## Rendering Pipeline
 
-1. **Parse** via micromark with combined GFM extensions → AST events.
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdansi",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Tiny dependency-light markdown to ANSI converter.",
   "keywords": [
     "ansi",
@@ -48,41 +48,31 @@
     "lint": "rm -rf dist coverage && pnpm format:check && oxlint --deny-warnings src test",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsgo -p tsconfig.json --noEmit",
-    "types": "tsgo -p tsconfig.json --emitDeclarationOnly",
-    "compile": "tsgo -p tsconfig.json",
+    "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",
-    "mdast-util-from-markdown": "^2.0.3",
-    "mdast-util-gfm": "^3.1.0",
-    "micromark": "^4.0.2",
-    "micromark-extension-gfm": "^3.0.0",
-    "micromark-util-combine-extensions": "^2.0.1",
+    "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"
+    "supports-hyperlinks": "^4.5.0"
   },
   "devDependencies": {
-    "@types/mdast": "^4.0.4",
-    "@types/node": "^25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260503.1",
-    "@vitest/coverage-v8": "^4.1.5",
-    "oxfmt": "^0.47.0",
-    "oxlint": "^1.62.0",
-    "tsx": "^4.21.0",
+    "@types/node": "^26.0.1",
+    "@vitest/coverage-v8": "^4.1.9",
+    "oxfmt": "^0.57.0",
+    "oxlint": "^1.72.0",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.9"
   },
   "engines": {
     "node": ">=22"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }