markdansi 0.1.2 → 0.1.3

package/README.md

@@ -50,6 +50,39 @@ const custom = createRenderer({
   highlighter: (code, lang) => code.toUpperCase(),
 });
 console.log(custom('`inline`\n\n```\nblock code\n```'));
+
+// Example: real syntax highlighting with Shiki (TS + Swift)
+import { bundledLanguages, bundledThemes, createHighlighter } from 'shiki';
+
+const shiki = await createHighlighter({
+  themes: [bundledThemes['github-dark']],
+  langs: [bundledLanguages.typescript, bundledLanguages.swift],
+});
+
+const highlighted = createRenderer({
+  highlighter: (code, lang) => {
+    if (!lang) return code;
+    const normalized = lang.toLowerCase();
+    if (!['ts', 'typescript', 'swift'].includes(normalized)) return code;
+    const { tokens } = shiki.codeToTokens(code, {
+      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,
+          )
+          .join(''),
+      )
+      .join('\n');
+  },
+});
+console.log(highlighted('```ts\nconst x: number = 1\n```\n```swift\nlet x = 1\n```'));
 ```
 
 ### Options

package/dist/render.js

@@ -132,7 +132,100 @@ function normalizeNodes(tree) {
         if (node)
             normalized.push(node);
     }
-    return { ...tree, children: normalized };
+    const mergedCodes = mergeAdjacentCodeBlocks(normalized);
+    const taggedDiffs = mergedCodes.map((child) => tagDiffBlock(child));
+    return { ...tree, children: taggedDiffs };
+}
+function flattenCodeList(list) {
+    if (!list.children.length ||
+        !list.children.every((item) => item.children.length === 1 &&
+            item.children[0]?.type === "code" &&
+            item.children[0].value !== undefined))
+        return null;
+    const codes = list.children.map((item) => item.children[0]);
+    const sameLang = codes.every((c) => c.lang === codes[0]?.lang);
+    const lang = sameLang ? (codes[0]?.lang ?? undefined) : undefined;
+    return {
+        type: "code",
+        lang: lang ?? undefined,
+        value: codes.map((c) => c.value).join("\n"),
+        position: list.position,
+    };
+}
+function mergeAdjacentCodeBlocks(nodes) {
+    const out = [];
+    let pending = null;
+    const flush = () => {
+        if (pending) {
+            out.push(pending);
+            pending = null;
+        }
+    };
+    for (const node of nodes) {
+        if (node?.type === "code") {
+            if (pending &&
+                (pending.lang === node.lang || (!pending.lang && !node.lang))) {
+                const nextValue = `${pending.value}\n${node.value}`;
+                pending = {
+                    type: "code",
+                    lang: pending.lang,
+                    meta: pending.meta,
+                    value: nextValue,
+                    position: pending.position,
+                };
+            }
+            else {
+                flush();
+                pending = node;
+            }
+            continue;
+        }
+        if (node?.type === "list") {
+            const flattened = flattenCodeList(node);
+            if (flattened) {
+                if (pending &&
+                    (pending.lang === flattened.lang ||
+                        (!pending.lang && !flattened.lang))) {
+                    const nextValue = `${pending.value}\n${flattened.value}`;
+                    pending = {
+                        type: "code",
+                        lang: pending.lang,
+                        meta: pending.meta,
+                        value: nextValue,
+                        position: pending.position,
+                    };
+                }
+                else {
+                    flush();
+                    pending = flattened;
+                }
+                continue;
+            }
+        }
+        flush();
+        out.push(node);
+    }
+    flush();
+    return out;
+}
+function looksLikeDiff(text) {
+    const lines = text.split("\n").map((l) => l.trim());
+    if (lines.some((l) => l.startsWith("diff --git") ||
+        l.startsWith("--- a/") ||
+        l.startsWith("+++ b/") ||
+        l.startsWith("@@ ")))
+        return true;
+    const nonEmpty = lines.filter((l) => l !== "");
+    if (nonEmpty.length < 3)
+        return false;
+    const markers = nonEmpty.filter((l) => /^[+\-@]/.test(l)).length;
+    return markers >= Math.max(3, Math.ceil(nonEmpty.length * 0.6));
+}
+function tagDiffBlock(node) {
+    if (node?.type === "code" && !node.lang && looksLikeDiff(node.value)) {
+        return { ...node, lang: "diff" };
+    }
+    return node;
 }
 const HR_WIDTH = 40;
 const MAX_COL = 40;
@@ -320,11 +413,14 @@ function renderDefinition(node, _ctx) {
 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 boxPadding = ctx.options.codeBox ? 4 : 0;
-    const wrapLimit = ctx.options.codeWrap && ctx.options.wrap && ctx.options.width
+    const shouldWrap = isDiff ? false : ctx.options.codeWrap;
+    const useBox = ctx.options.codeBox && lines.length > 1;
+    const boxPadding = useBox ? 4 : 0;
+    const wrapLimit = shouldWrap && ctx.options.wrap && ctx.options.width
         ? Math.max(1, ctx.options.width - boxPadding - gutterWidth)
         : undefined; // undefined => no hard wrap limit
     const contentLines = lines.flatMap((line, idx) => {
@@ -340,7 +436,7 @@ function renderCodeBlock(node, ctx) {
             return `${ctx.style(num, { dim: true })} ${highlighted}`;
         });
     });
-    if (!ctx.options.codeBox) {
+    if (!useBox) {
         return [`${contentLines.join("\n")}\n\n`];
     }
     // Boxed block

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdansi",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Tiny dependency-light markdown to ANSI converter.",
   "type": "module",
   "main": "dist/index.js",