markdansi 0.3.0 → 0.3.1

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/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.1",
   "description": "Tiny dependency-light markdown to ANSI converter.",
   "keywords": [
     "ansi",
@@ -48,28 +48,23 @@
     "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"
   },
   "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",
@@ -79,10 +74,5 @@
   },
   "engines": {
     "node": ">=22"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }