markdansi 0.1.0

package/.biome.json

@@ -0,0 +1,24 @@
+{
+	"$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
+		}
+	}
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# Markdansi
+
+🎨 Markdansi: Wraps, colors, links—no baggage.  
+![npm unpublished](https://img.shields.io/badge/npm-unpublished-lightgrey) ![license MIT](https://img.shields.io/badge/license-MIT-blue.svg) ![node >=22](https://img.shields.io/badge/node-%3E%3D22-brightgreen) ![tests vitest](https://img.shields.io/badge/tests-vitest-blue?logo=vitest)
+
+Tiny, dependency-light Markdown → ANSI renderer and CLI for modern Node (>=22). Focuses on readable terminal output with sensible wrapping, GFM support (tables, task lists, strikethrough), optional OSC‑8 hyperlinks, and zero built‑in syntax highlighting (pluggable hook).
+
+## Install
+
+> Not yet published to npm (name available as of November 16, 2025). Install from git or local path until released.
+
+```bash
+pnpm add markdansi
+# or
+npm install markdansi
+```
+
+## CLI
+
+```bash
+markdansi [--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).
+- 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
+
+```js
+import { render, createRenderer, strip, themes } from 'markdansi';
+
+const ansi = render('# Hello **world**', { width: 60 });
+
+const renderNoWrap = createRenderer({ wrap: false });
+const out = renderNoWrap('A very long line...');
+
+// Plain text (no ANSI/OSC)
+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' },
+  },
+  highlighter: (code, lang) => code.toUpperCase(),
+});
+console.log(custom('`inline`\n\n```\nblock code\n```'));
+```
+
+### Options
+
+- `wrap` (default `true`): if `false`, no hard wrapping anywhere.
+- `width`: used only when `wrap===true`; default TTY columns or 80.
+- `color` (default TTY): `false` removes all ANSI/OSC.
+- `hyperlinks` (default auto): enable/disable OSC‑8 links.
+- `theme`: `default | dim | bright` or custom theme object.
+- `listIndent`: spaces per nesting level (default 2).
+- `quotePrefix`: blockquote line prefix (default `│ `).
+- `highlighter(code, lang)`: optional hook to recolor code blocks; must not add/remove newlines.
+
+## Status
+
+Version: `0.1.0`  
+Tests: `pnpm test`  
+License: MIT
+
+## Notes
+
+- Code blocks never hard‑wrap; long lines may overflow. If `lang` is present, a faint `[lang]` label is shown.
+- Tables are ASCII boxed, align using GFM alignment, and wrap cell text on spaces; very long words may overflow.
+- Tight vs loose lists follow GFM; task items render `[ ]` / `[x]`.
+
+See `docs/spec.md` for full behavior details.*** End Patch

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+export type ColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | `#${string}` | `${number}`;
+export type StyleIntent = {
+    color?: ColorName;
+    bgColor?: ColorName;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    strike?: boolean;
+};
+export type Theme = {
+    heading?: StyleIntent;
+    strong?: StyleIntent;
+    emph?: StyleIntent;
+    inlineCode?: StyleIntent;
+    blockCode?: StyleIntent;
+    code?: StyleIntent;
+    link?: StyleIntent;
+    quote?: StyleIntent;
+    hr?: StyleIntent;
+    listMarker?: StyleIntent;
+    tableHeader?: StyleIntent;
+    tableCell?: StyleIntent;
+};
+export type ThemeName = "default" | "dim" | "bright";
+export type Highlighter = (code: string, lang?: string) => string;
+export interface RenderOptions {
+    wrap?: boolean;
+    width?: number;
+    hyperlinks?: boolean;
+    color?: boolean;
+    theme?: ThemeName | Theme;
+    /**
+     * Spaces per nesting level for lists (default 2).
+     */
+    listIndent?: number;
+    /**
+     * Prefix used for blockquotes (default "│ ").
+     */
+    quotePrefix?: string;
+    highlighter?: Highlighter;
+}
+export declare function render(markdown: string, options?: RenderOptions): string;
+export declare function createRenderer(options?: RenderOptions): (markdown: string) => string;
+export declare function strip(markdown: string, options?: RenderOptions): string;
+export declare const themes: Record<ThemeName | string, Theme>;

package/docs/spec.md

@@ -0,0 +1,83 @@
+# Markdansi v1 – Design Spec
+
+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).
+- `chalk`: small, ESM‑only color/style helper.
+- `string-width`: correct visible width (emoji / wide chars).
+- `strip-ansi`: strip codes for width/wrapping.
+- `supports-hyperlinks`: detect OSC‑8 hyperlink support.
+
+Dev: `vitest`.
+
+## Surface Area
+### Library (ESM default, CJS export provided)
+`render(markdown: string, options?: RenderOptions): string`
+
+`createRenderer(options?: RenderOptions): (md: string) => string`
+
+`type RenderOptions = {`
+`  wrap?: boolean;            // default: true; if false => no hard wraps anywhere`
+`  width?: number;            // used only when wrap===true; default: TTY cols or 80`
+`  hyperlinks?: boolean;      // default: auto via supports-hyperlinks`
+`  color?: boolean;           // default: true if TTY; if false => no ANSI/OSC at all`
+`  theme?: ThemeName | Theme; // built-ins: default, dim, bright`
+`  highlighter?: (code: string, lang?: string) => string; // hook, must not add newlines`
+`}``
+
+`type Theme = { heading, strong, emph, inlineCode, blockCode, code?, link, quote, hr, listMarker, tableHeader, tableCell }`
+Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineCode` / `blockCode` are used if present; otherwise `code` acts as a fallback for both.
+
+`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`.
+- 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 dim box; if `lang` present, show a faint `[lang]` tag. Highlighter hook may recolor text but must not add/remove newlines. Code blocks never hard-wrap; long lines may overflow.
+- Tables: render with simple ASCII borders; align based on GFM alignment; wrap cell text respecting width.
+- Wrapping: word-wrap on spaces; uses `string-width` on stripped text. Preserve hard breaks; words longer than width are allowed to overflow. Code blocks ignore wrap.
+- Hyperlinks: OSC‑8 when supported and allowed; fallback to underlined text plus URL in parentheses.
+- 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:
+   - 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 code, subtle quotes/hr.
+- `dim`: muted colors for low-contrast terminals.
+- `bright`: higher contrast variant.
+
+## 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.
+- Highlighter hook: receives raw code and optional lang; may return ANSI-colored text but must not add or remove newlines. Markdansi owns indentation/padding; code blocks never hard-wrap.
+- Tables width algorithm: compute desired column widths from content (cap at e.g. 40). While total exceeds width, decrement widest columns until it fits; if even minimums won’t fit, allow overflow. Respect GFM alignment per column. Cells with newlines keep those breaks.
+- Lists: honor GFM tight vs loose lists (tight => no blank line between items; loose => blank line). Nesting indent = 2 spaces per level; bullets use `-`; ordered lists use input numbering.
+- Blockquotes: prefix each wrapped line with `│ ` (configurable via `quotePrefix`); quote content wraps accounting for the prefix width.
+- List indent is configurable via `listIndent` (default 2 spaces per level).

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "markdansi",
+  "version": "0.1.0",
+  "description": "Tiny dependency-light markdown to ANSI converter.",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": {
+      "import": "./src/index.js"
+    },
+    "./cli": "./src/cli.js"
+  },
+  "bin": {
+    "markdansi": "./src/cli.js"
+  },
+  "keywords": [
+    "markdown",
+    "ansi",
+    "terminal",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "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": [
+    "src",
+    "dist",
+    "README.md",
+    "docs/spec.md",
+    "package.json",
+    "tsconfig.json",
+    ".biome.json",
+    "types"
+  ],
+  "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.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.5",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.9",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.9"
+  },
+  "scripts": {
+    "build": "pnpm lint && pnpm test",
+    "clean": "rm -rf dist",
+    "lint": "rm -rf dist coverage && biome check .",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "types": "tsc -p tsconfig.json"
+  }
+}

package/src/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { render } from "./index.js";
+
+function parseArgs(argv) {
+	const args = {};
+	for (let i = 2; i < argv.length; i += 1) {
+		const a = argv[i];
+		if (a === "--no-wrap") args.wrap = false;
+		else if (a === "--no-color") args.color = false;
+		else if (a === "--no-links") args.hyperlinks = false;
+		else if (a === "--in") args.in = argv[++i];
+		else if (a === "--out") args.out = argv[++i];
+		else if (a === "--width") args.width = Number(argv[++i]);
+		else if (a.startsWith("--theme=")) args.theme = a.split("=")[1];
+		else if (a === "--list-indent") args.listIndent = Number(argv[++i]);
+		else if (a === "--quote-prefix") args.quotePrefix = argv[++i];
+		else if (a === "--help" || a === "-h") args.help = true;
+	}
+	return args;
+}
+
+function main() {
+	const args = parseArgs(process.argv);
+	if (args.help) {
+		process.stdout.write(`markdansi options:
+  --in FILE           Input file (default: stdin)
+  --out FILE          Output file (default: stdout)
+  --width N           Wrap width (default: TTY cols or 80)
+  --no-wrap           Disable hard wrapping
+  --no-color          Disable ANSI/OSC output
+  --no-links          Disable OSC-8 hyperlinks
+  --theme NAME        Theme (default|dim|bright)
+  --list-indent N     Spaces per list nesting level (default: 2)
+  --quote-prefix STR  Prefix for blockquotes (default: "│ ")
+`);
+		process.exit(0);
+	}
+	const input =
+		args.in && args.in !== "-"
+			? fs.readFileSync(path.resolve(args.in), "utf8")
+			: fs.readFileSync(0, "utf8");
+
+	const output = render(input, {
+		wrap: args.wrap,
+		width: args.width,
+		color: args.color,
+		hyperlinks: args.hyperlinks,
+		theme: args.theme,
+		listIndent: args.listIndent,
+		quotePrefix: args.quotePrefix,
+	});
+
+	if (args.out) {
+		fs.writeFileSync(path.resolve(args.out), output, "utf8");
+	} else {
+		process.stdout.write(output);
+	}
+}
+
+main();

package/src/hyperlink.js

@@ -0,0 +1,15 @@
+import supportsHyperlinks from "supports-hyperlinks";
+
+/**
+ * Detect OSC-8 hyperlink support for a given stream (defaults to stdout).
+ */
+export function hyperlinkSupported(stream = process.stdout) {
+	if (supportsHyperlinks && typeof supportsHyperlinks.stdout === "function") {
+		return supportsHyperlinks.stdout(stream);
+	}
+	return false;
+}
+
+export function osc8(url, text) {
+	return `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
+}

package/src/index.js

@@ -0,0 +1,12 @@
+import { createRenderer, render as renderMarkdown } from "./render.js";
+import { themes } from "./theme.js";
+
+export { renderMarkdown as render, createRenderer, themes };
+
+export function strip(markdown, options = {}) {
+	return renderMarkdown(markdown, {
+		...options,
+		color: false,
+		hyperlinks: false,
+	});
+}

package/src/parser.js

@@ -0,0 +1,10 @@
+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()],
+	});
+}

package/src/render.js

@@ -0,0 +1,342 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import { hyperlinkSupported, osc8 } from "./hyperlink.js";
+import { parse } from "./parser.js";
+import { createStyler, themes } from "./theme.js";
+import { visibleWidth, wrapText, wrapWithPrefix } from "./wrap.js";
+
+function resolveOptions(userOptions = {}) {
+	const wrap = userOptions.wrap !== undefined ? userOptions.wrap : true;
+	const baseWidth =
+		userOptions.width ?? (wrap ? process.stdout.columns || 80 : undefined);
+	const color =
+		userOptions.color !== undefined ? userOptions.color : process.stdout.isTTY;
+	// OSC hyperlinks require color support; if color is off, force hyperlinks off too
+	const hyperlinks =
+		userOptions.hyperlinks !== undefined
+			? userOptions.hyperlinks
+			: color && hyperlinkSupported();
+	const effectiveHyperlinks = color ? hyperlinks : false;
+	const theme =
+		userOptions.theme && typeof userOptions.theme === "object"
+			? userOptions.theme
+			: themes[userOptions.theme || "default"] || themes.default;
+	const mergedTheme = {
+		...themes.default,
+		...(theme || {}),
+		// optional fallback: if only `code` provided, reuse for inline/block
+		inlineCode: theme?.inlineCode || theme?.code || themes.default.inlineCode,
+		blockCode: theme?.blockCode || theme?.code || themes.default.blockCode,
+	};
+	const highlighter = userOptions.highlighter;
+	const listIndent = userOptions.listIndent ?? 2;
+	const quotePrefix = userOptions.quotePrefix ?? "│ ";
+	return {
+		wrap,
+		width: baseWidth,
+		color,
+		hyperlinks: effectiveHyperlinks,
+		theme: mergedTheme,
+		highlighter,
+		listIndent,
+		quotePrefix,
+	};
+}
+
+const HR_WIDTH = 40;
+const MAX_COL = 40;
+
+export function render(markdown, userOptions = {}) {
+	const options = resolveOptions(userOptions);
+	const style = createStyler({ color: options.color });
+	const tree = parse(markdown);
+	const ctx = { options, style };
+	const body = renderChildren(tree.children, ctx, 0, true).join("");
+	return options.color ? body : stripAnsi(body);
+}
+
+export function createRenderer(options) {
+	return (md) => render(md, options);
+}
+
+function renderChildren(children, ctx, indentLevel = 0, isTightList = false) {
+	const out = [];
+	for (const node of children) {
+		out.push(renderNode(node, ctx, indentLevel, isTightList));
+	}
+	return out.flat();
+}
+
+function renderNode(node, ctx, indentLevel, isTightList) {
+	switch (node.type) {
+		case "paragraph":
+			return renderParagraph(node, ctx, indentLevel);
+		case "heading":
+			return renderHeading(node, ctx);
+		case "thematicBreak":
+			return renderHr(ctx);
+		case "blockquote":
+			return renderBlockquote(node, ctx, indentLevel);
+		case "list":
+			return renderList(node, ctx, indentLevel);
+		case "listItem":
+			return renderListItem(node, ctx, indentLevel, isTightList);
+		case "code":
+			return renderCodeBlock(node, ctx);
+		case "table":
+			return renderTable(node, ctx);
+		default:
+			return []; // inline handled elsewhere or intentionally skipped
+	}
+}
+
+function renderParagraph(node, ctx, indentLevel) {
+	const text = renderInline(node.children, ctx);
+	const prefix = " ".repeat(ctx.options.listIndent * indentLevel);
+	const lines = wrapWithPrefix(
+		text,
+		ctx.options.width ?? 80,
+		ctx.options.wrap,
+		prefix,
+	);
+	return lines.map((l) => `${l}\n`);
+}
+
+function renderHeading(node, ctx) {
+	const text = renderInline(node.children, ctx);
+	const styled = ctx.style(text, ctx.options.theme.heading);
+	return [`\n${styled}\n`];
+}
+
+function renderHr(ctx) {
+	const width = ctx.options.wrap
+		? Math.min(ctx.options.width ?? HR_WIDTH, HR_WIDTH)
+		: HR_WIDTH;
+	const line = "—".repeat(width);
+	return [`${ctx.style(line, ctx.options.theme.hr)}\n`];
+}
+
+function renderBlockquote(node, ctx, indentLevel) {
+	// Render blockquote children as text, then wrap with the quote prefix so
+	// wrapping accounts for prefix width.
+	const inner = renderChildren(node.children, ctx, indentLevel);
+	const prefix = ctx.style(ctx.options.quotePrefix, ctx.options.theme.quote);
+	const text = inner.join("").trimEnd();
+	const wrapped = wrapWithPrefix(
+		text,
+		ctx.options.width ?? 80,
+		ctx.options.wrap,
+		prefix,
+	);
+	return wrapped.map((l) => `${l}\n`);
+}
+
+function renderList(node, ctx, indentLevel) {
+	const tight = node.spread === false;
+	const items = node.children.flatMap((item, idx) =>
+		renderListItem(
+			item,
+			ctx,
+			indentLevel,
+			tight,
+			node.ordered,
+			node.start ?? 1,
+			idx,
+		),
+	);
+	return items;
+}
+
+function renderListItem(
+	node,
+	ctx,
+	indentLevel,
+	tight,
+	ordered = false,
+	start = 1,
+	idx = 0,
+) {
+	const marker = ordered ? `${start + idx}.` : "-";
+	const markerStyled = ctx.style(marker, ctx.options.theme.listMarker);
+	const content = renderChildren(node.children, ctx, indentLevel + 1, tight)
+		.join("")
+		.trimEnd()
+		.split("\n");
+
+	// Drop leading blank lines so bullets prefix real content (e.g., headings in lists)
+	while (content.length && content[0].trim() === "") {
+		content.shift();
+	}
+
+	const isTask = typeof node.checked === "boolean";
+	const box = isTask ? (node.checked ? "[x]" : "[ ]") : null;
+	const firstBullet =
+		" ".repeat(ctx.options.listIndent * indentLevel) +
+		(isTask
+			? `${ctx.style(box, ctx.options.theme.listMarker)} `
+			: `${markerStyled} `);
+
+	const lines = [];
+	content.forEach((line, i) => {
+		const clean = line.replace(/^\s+/, "");
+		const prefix =
+			i === 0
+				? firstBullet
+				: `${" ".repeat(ctx.options.listIndent * indentLevel)}${" ".repeat(
+						ctx.options.listIndent,
+					)}`;
+		lines.push(prefix + clean);
+	});
+	if (!tight) lines.push("");
+	return lines.map((l) => `${l}\n`);
+}
+
+function renderCodeBlock(node, ctx) {
+	const theme = ctx.options.theme.blockCode || ctx.options.theme.inlineCode;
+	const label = node.lang ? ctx.style(`[${node.lang}] `, { dim: true }) : "";
+	let body = node.value ?? "";
+	if (ctx.options.highlighter) {
+		const res = ctx.options.highlighter(body, node.lang);
+		if (typeof res === "string") body = res;
+	} else {
+		body = body
+			.split("\n")
+			.map((l) => ctx.style(l, theme))
+			.join("\n");
+	}
+	return [`${label}${body}\n\n`];
+}
+
+function renderInline(children, ctx) {
+	let out = "";
+	for (const node of children) {
+		switch (node.type) {
+			case "text":
+				out += node.value;
+				break;
+			case "emphasis":
+				out += ctx.style(
+					renderInline(node.children, ctx),
+					ctx.options.theme.emph,
+				);
+				break;
+			case "strong":
+				out += ctx.style(
+					renderInline(node.children, ctx),
+					ctx.options.theme.strong,
+				);
+				break;
+			case "delete":
+				out += ctx.style(renderInline(node.children, ctx), { strike: true });
+				break;
+			case "inlineCode": {
+				const codeTheme =
+					ctx.options.theme.inlineCode || ctx.options.theme.blockCode;
+				const content = ctx.style(node.value, codeTheme);
+				out += content;
+				break;
+			}
+			case "link":
+				out += renderLink(node, ctx);
+				break;
+			case "break":
+				out += "\n";
+				break;
+			default:
+				if (node.value) out += node.value;
+		}
+	}
+	return out;
+}
+
+function renderLink(node, ctx) {
+	const label = renderInline(node.children, ctx) || node.url;
+	const url = node.url || "";
+	if (ctx.options.hyperlinks && url) {
+		return osc8(url, label);
+	}
+	if (url && label !== url) {
+		return (
+			ctx.style(label, ctx.options.theme.link) +
+			ctx.style(` (${url})`, { dim: true })
+		);
+	}
+	return ctx.style(label, ctx.options.theme.link);
+}
+
+function renderTable(node, ctx) {
+	const header = node.children[0];
+	const rows = node.children.slice(1);
+	const cells = [header, ...rows].map((row) =>
+		row.children.map((cell) => renderInline(cell.children, ctx)),
+	);
+	const colCount = Math.max(...cells.map((r) => r.length));
+	const widths = new Array(colCount).fill(1);
+	const aligns = node.align || [];
+
+	cells.forEach((row) => {
+		row.forEach((cell, idx) => {
+			// Cap each column to MAX_COL but keep at least 1
+			widths[idx] = Math.max(
+				widths[idx],
+				Math.min(MAX_COL, visibleWidth(cell)),
+			);
+		});
+	});
+
+	const totalWidth = widths.reduce((a, b) => a + b, 0) + 3 * colCount + 1;
+	if (ctx.options.wrap && ctx.options.width && totalWidth > ctx.options.width) {
+		// Shrink widest columns until the table fits; allow overflow if already at minima
+		let over = totalWidth - ctx.options.width;
+		while (over > 0) {
+			const i = widths.indexOf(Math.max(...widths));
+			if (widths[i] <= 1) break;
+			widths[i] -= 1;
+			over -= 1;
+		}
+	}
+
+	const renderRow = (row, isHeader = false) => {
+		const linesPerCol = row.map((cell, idx) =>
+			wrapText(cell, widths[idx], ctx.options.wrap).map((l) =>
+				padCell(l, widths[idx], aligns[idx]),
+			),
+		);
+		// Row height = max wrapped lines in any column; pad shorter ones
+		const height = Math.max(...linesPerCol.map((c) => c.length));
+		const out = [];
+		for (let i = 0; i < height; i += 1) {
+			const parts = linesPerCol.map((col, idx) => {
+				const content = col[i] ?? padCell("", widths[idx], aligns[idx]);
+				return isHeader
+					? ctx.style(content, ctx.options.theme.tableHeader)
+					: ctx.style(content, ctx.options.theme.tableCell);
+			});
+			out.push(`| ${parts.join(" | ")} |\n`);
+		}
+		return out;
+	};
+
+	const headerRows = renderRow(
+		header.children.map((c) => renderInline(c.children, ctx)),
+		true,
+	);
+	const divider = `| ${widths.map((w) => "—".repeat(w)).join(" | ")} |\n`;
+	const bodyRows = rows.flatMap((r) =>
+		renderRow(r.children.map((c) => renderInline(c.children, ctx))),
+	);
+
+	return [...headerRows, divider, ...bodyRows, "\n"];
+}
+
+function padCell(text, width, align = "left") {
+	const pad = width - stringWidth(stripAnsi(text));
+	if (pad <= 0) return text;
+	if (align === "right") return `${" ".repeat(pad)}${text}`;
+	if (align === "center") {
+		const left = Math.floor(pad / 2);
+		const right = pad - left;
+		return `${" ".repeat(left)}${text}${" ".repeat(right)}`;
+	}
+	return `${text}${" ".repeat(pad)}`;
+}

package/src/theme.js

@@ -0,0 +1,53 @@
+import { Chalk } from "chalk";
+
+const base = {
+	heading: { color: "yellow", bold: true },
+	strong: { bold: true },
+	emph: { italic: true },
+	inlineCode: { color: "cyan", dim: true },
+	blockCode: { color: "cyan", dim: true },
+	link: { color: "blue", underline: true },
+	quote: { dim: true },
+	hr: { dim: true },
+	listMarker: { color: "cyan" },
+	tableHeader: { bold: true },
+	tableCell: {},
+};
+
+const dim = {
+	...base,
+	heading: { color: "white", bold: true, dim: true },
+	link: { color: "blue", underline: true, dim: true },
+};
+
+const bright = {
+	...base,
+	heading: { color: "magenta", bold: true },
+	link: { color: "cyan", underline: true },
+	inlineCode: { color: "green" },
+	blockCode: { color: "green" },
+};
+
+export const themes = {
+	default: Object.freeze(base),
+	dim: Object.freeze(dim),
+	bright: Object.freeze(bright),
+};
+
+export function createStyler({ color }) {
+	const level = color ? 3 : 0;
+	const chalk = new Chalk({ level });
+	const apply = (text, style = {}) => {
+		if (!color) return text;
+		let fn = chalk;
+		if (style.color && fn[style.color]) fn = fn[style.color];
+		if (style.bgColor && fn[style.bgColor]) fn = fn[style.bgColor];
+		if (style.bold) fn = fn.bold;
+		if (style.italic) fn = fn.italic;
+		if (style.underline) fn = fn.underline;
+		if (style.dim) fn = fn.dim;
+		if (style.strike) fn = fn.strikethrough;
+		return fn(text);
+	};
+	return apply;
+}

package/src/wrap.js

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

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+	"compilerOptions": {
+		"strict": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"allowJs": true,
+		"checkJs": true,
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"outDir": "dist",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"target": "ES2022",
+		"resolveJsonModule": true
+	},
+	"include": ["types/**/*.ts"],
+	"exclude": ["node_modules", "dist", "coverage"]
+}

package/types/index.ts

@@ -0,0 +1,74 @@
+// Public API typings for Markdansi.
+// Hand-authored source for `pnpm types` (tsc --emitDeclarationOnly)
+// to produce dist/index.d.ts. Keep in sync with src/ changes.
+
+export type ColorName =
+	| "black"
+	| "red"
+	| "green"
+	| "yellow"
+	| "blue"
+	| "magenta"
+	| "cyan"
+	| "white"
+	| `#${string}`
+	| `${number}`;
+
+export type StyleIntent = {
+	color?: ColorName;
+	bgColor?: ColorName;
+	bold?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	dim?: boolean;
+	strike?: boolean;
+};
+
+export type Theme = {
+	heading?: StyleIntent;
+	strong?: StyleIntent;
+	emph?: StyleIntent;
+	inlineCode?: StyleIntent;
+	blockCode?: StyleIntent;
+	code?: StyleIntent;
+	link?: StyleIntent;
+	quote?: StyleIntent;
+	hr?: StyleIntent;
+	listMarker?: StyleIntent;
+	tableHeader?: StyleIntent;
+	tableCell?: StyleIntent;
+};
+
+export type ThemeName = "default" | "dim" | "bright";
+
+export type Highlighter = (code: string, lang?: string) => string;
+
+export interface RenderOptions {
+	wrap?: boolean;
+	width?: number;
+	hyperlinks?: boolean;
+	color?: boolean;
+	theme?: ThemeName | Theme;
+	/**
+	 * Spaces per nesting level for lists (default 2).
+	 */
+	listIndent?: number;
+	/**
+	 * Prefix used for blockquotes (default "│ ").
+	 */
+	quotePrefix?: string;
+	highlighter?: Highlighter;
+}
+
+export declare function render(
+	markdown: string,
+	options?: RenderOptions,
+): string;
+export declare function createRenderer(
+	options?: RenderOptions,
+): (markdown: string) => string;
+export declare function strip(
+	markdown: string,
+	options?: RenderOptions,
+): string;
+export declare const themes: Record<ThemeName | string, Theme>;