schematex 0.2.0 → 0.2.3

package/dist/{chunk-M6AMNXQ7.js → chunk-S3RBKJM5.js}

@@ -1,30 +1,34 @@
-import { orgchart } from './chunk-7WXAAVR3.js';
-import { circuit } from './chunk-2OIW3MAE.js';
-import { blockdiagram } from './chunk-5SH5NUDW.js';
-import { ladder } from './chunk-L6IHSTPP.js';
-import { sld } from './chunk-A74ZCP5I.js';
-import { entity } from './chunk-MRGS54WN.js';
-import { fishbone } from './chunk-IQIJ6WW6.js';
-import { venn } from './chunk-MXJ6FHSY.js';
-import { flowchart } from './chunk-JZGFSRVT.js';
-import { genogram } from './chunk-HLYA4QBB.js';
-import { ecomap } from './chunk-RQX53J6M.js';
-import { pedigree } from './chunk-TPA36ULU.js';
-import { phylo } from './chunk-4TS5NB7L.js';
-import { sociogram } from './chunk-YO4GU6JX.js';
-import { timing } from './chunk-GEPBET4L.js';
-import { logic } from './chunk-SPIW4VWP.js';
-import { resolveBaseTheme, resolveTimelineTheme, cssCustomProperties, resolveMindmapTheme } from './chunk-TIGP2OEJ.js';
+import { orgchart } from './chunk-FCGHV6ZK.js';
+import { circuit } from './chunk-PGALHQFF.js';
+import { blockdiagram } from './chunk-UGCUNADI.js';
+import { ladder } from './chunk-U6L3FAML.js';
+import { sld } from './chunk-FE6GAUNW.js';
+import { entity } from './chunk-M5B2UUNW.js';
+import { fishbone } from './chunk-ZNDIGQJD.js';
+import { venn } from './chunk-JDTB7IKL.js';
+import { flowchart } from './chunk-SN7NTZI6.js';
+import { genogram } from './chunk-2BM3HJSK.js';
+import { ecomap } from './chunk-LR4X4ZRG.js';
+import { pedigree } from './chunk-OC22GGQN.js';
+import { phylo } from './chunk-YQANC7HQ.js';
+import { sociogram } from './chunk-RP5UATRA.js';
+import { timing } from './chunk-45KP67RR.js';
+import { logic } from './chunk-5YYAYW67.js';
+import { resolveBaseTheme, resolveTimelineTheme, cssCustomProperties, resolveMindmapTheme } from './chunk-2VNMKOUO.js';
 import { title, desc, el, text, path, rect, group, svgRoot, escapeXml, defs, circle, polygon, line } from './chunk-KLJEK547.js';
 
 // src/diagrams/decisiontree/parser.ts
 var DTreeParseError = class extends Error {
-  constructor(message, line2) {
+  constructor(message, line2, column, source) {
     super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
     this.line = line2;
+    this.column = column;
+    this.source = source;
     this.name = "DTreeParseError";
   }
   line;
+  column;
+  source;
 };
 function preprocess(src) {
   const out = [];
@@ -1225,12 +1229,16 @@ function formatYear(value, span) {
 
 // src/diagrams/timeline/parser.ts
 var TimelineParseError = class extends Error {
-  constructor(message, line2) {
+  constructor(message, line2, column, source) {
     super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
     this.line = line2;
+    this.column = column;
+    this.source = source;
     this.name = "TimelineParseError";
   }
   line;
+  column;
+  source;
 };
 function preprocess2(src) {
   const out = [];
@@ -2618,8 +2626,193 @@ var timeline = {
   }
 };
 
+// src/diagrams/mindmap/inline.ts
+var RE_TASK = /^\[( |x|X)\]\s+(.*)$/;
+function tokenizeInline(raw) {
+  const tokens = [];
+  let text2 = raw;
+  const task = text2.match(RE_TASK);
+  if (task) {
+    tokens.push({ kind: "checkbox", checked: task[1].toLowerCase() === "x" });
+    text2 = task[2];
+  }
+  parseInto(text2, tokens, { bold: false, italic: false });
+  return tokens;
+}
+function parseInto(src, out, style) {
+  let i = 0;
+  let plain = "";
+  const flushPlain = () => {
+    if (plain.length === 0) return;
+    out.push({ kind: "text", value: plain, bold: style.bold || void 0, italic: style.italic || void 0 });
+    plain = "";
+  };
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "`") {
+      const end = src.indexOf("`", i + 1);
+      if (end > i) {
+        flushPlain();
+        out.push({ kind: "code", value: src.slice(i + 1, end) });
+        i = end + 1;
+        continue;
+      }
+    }
+    if (ch === "[") {
+      const closeBracket = findUnescaped(src, "]", i + 1);
+      if (closeBracket > 0 && src[closeBracket + 1] === "(") {
+        const closeParen = findUnescaped(src, ")", closeBracket + 2);
+        if (closeParen > 0) {
+          flushPlain();
+          const inner = [];
+          parseInto(src.slice(i + 1, closeBracket), inner, style);
+          out.push({ kind: "link", href: src.slice(closeBracket + 2, closeParen), value: inner });
+          i = closeParen + 1;
+          continue;
+        }
+      }
+    }
+    if (ch === "*" && src[i + 1] === "*") {
+      const end = src.indexOf("**", i + 2);
+      if (end > i) {
+        flushPlain();
+        parseInto(src.slice(i + 2, end), out, { ...style, bold: true });
+        i = end + 2;
+        continue;
+      }
+    }
+    if (ch === "*") {
+      const end = src.indexOf("*", i + 1);
+      if (end > i && src[end + 1] !== "*") {
+        flushPlain();
+        parseInto(src.slice(i + 1, end), out, { ...style, italic: true });
+        i = end + 1;
+        continue;
+      }
+    }
+    plain += ch;
+    i++;
+  }
+  flushPlain();
+}
+function findUnescaped(s, ch, from) {
+  for (let i = from; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === ch) return i;
+  }
+  return -1;
+}
+var EM_REGULAR = 0.58;
+var EM_BOLD = 0.62;
+var EM_CODE = 0.62;
+var CHECKBOX_EM = 1.05;
+function measureTokens(tokens, fontSize) {
+  let w = 0;
+  for (const t of tokens) {
+    w += tokenWidth(t, fontSize);
+  }
+  return w;
+}
+function tokenWidth(t, fs) {
+  switch (t.kind) {
+    case "text": {
+      const em = t.bold ? EM_BOLD : EM_REGULAR;
+      return t.value.length * fs * em;
+    }
+    case "code":
+      return t.value.length * fs * EM_CODE + 4;
+    case "link":
+      return measureTokens(t.value, fs);
+    case "checkbox":
+      return fs * CHECKBOX_EM;
+  }
+}
+function tokensToPlainText(tokens) {
+  let out = "";
+  for (const t of tokens) {
+    switch (t.kind) {
+      case "text":
+      case "code":
+        out += t.value;
+        break;
+      case "link":
+        out += tokensToPlainText(t.value);
+        break;
+      case "checkbox":
+        out += t.checked ? "[x] " : "[ ] ";
+        break;
+    }
+  }
+  return out;
+}
+function wrapTokens(tokens, maxWidth, fontSize) {
+  const lines = [];
+  let line2 = [];
+  let lineW = 0;
+  const pushLine = () => {
+    lines.push({ tokens: line2, width: lineW });
+    line2 = [];
+    lineW = 0;
+  };
+  const pushAtomic = (t, w) => {
+    if (lineW > 0 && lineW + w > maxWidth) pushLine();
+    line2.push(t);
+    lineW += w;
+  };
+  for (const t of tokens) {
+    if (t.kind === "text") {
+      const words = splitWordsWithTrailingSpace(t.value);
+      for (const w of words) {
+        const wt = { kind: "text", value: w, bold: t.bold, italic: t.italic };
+        const ww = tokenWidth(wt, fontSize);
+        if (lineW > 0 && lineW + ww > maxWidth) {
+          pushLine();
+          const trimmed = w.replace(/^ +/, "");
+          if (trimmed.length === 0) continue;
+          const tt = { kind: "text", value: trimmed, bold: t.bold, italic: t.italic };
+          line2.push(tt);
+          lineW = tokenWidth(tt, fontSize);
+        } else {
+          line2.push(wt);
+          lineW += ww;
+        }
+      }
+    } else {
+      pushAtomic(t, tokenWidth(t, fontSize));
+    }
+  }
+  pushLine();
+  return lines;
+}
+function splitWordsWithTrailingSpace(s) {
+  if (s.length === 0) return [];
+  const out = [];
+  const re = /(\S+\s*)|(\s+)/g;
+  let m;
+  while ((m = re.exec(s)) !== null) {
+    out.push(m[0]);
+  }
+  return out.length > 0 ? out : [s];
+}
+
 // src/diagrams/mindmap/parser.ts
+var MindmapParseError = class extends Error {
+  constructor(message, line2, column, source) {
+    super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
+    this.line = line2;
+    this.column = column;
+    this.source = source;
+    this.name = "MindmapParseError";
+  }
+  line;
+  column;
+  source;
+};
 var VALID_STYLES = ["map", "logic-right"];
+var DEFAULT_MAX_LABEL_WIDTH = 240;
 function parseDirective(line2, out) {
   const body = line2.replace(/^%%\s*/, "").trim();
   const idx = body.indexOf(":");
@@ -2630,26 +2823,39 @@ function parseDirective(line2, out) {
     out.style = val;
   } else if (key === "theme") {
     out.themeOverride = val;
+  } else if (key === "maxlabelwidth") {
+    const n = Number(val);
+    if (Number.isFinite(n) && n >= 80 && n <= 1e3) out.maxLabelWidth = n;
   }
 }
+function makeNode(id, label, depth) {
+  return { id, label, tokens: tokenizeInline(label), depth, children: [] };
+}
 function parseMindmap(text2) {
-  const lines = text2.split(/\r?\n/);
-  if (lines[0]?.trim().toLowerCase() === "mindmap") lines.shift();
-  const directives = { style: "map" };
+  const allLines = text2.split(/\r?\n/);
+  let lineOffset = 0;
+  if (allLines[0]?.trim().toLowerCase() === "mindmap") {
+    allLines.shift();
+    lineOffset = 1;
+  }
+  const lines = allLines;
+  const directives = { style: "map", maxLabelWidth: DEFAULT_MAX_LABEL_WIDTH };
   let root = null;
   let idCounter2 = 0;
   const nextId2 = () => `n${idCounter2++}`;
   const stack = [];
   let lastHeadingDepth = 0;
-  const attach = (node, depth) => {
+  const attach = (node, depth, lineNo, source) => {
     while (stack.length && stack[stack.length - 1].depth >= depth) stack.pop();
     const parent = stack[stack.length - 1]?.node;
-    if (!parent) throw new Error("Mindmap: orphan node \u2014 expected root # heading first");
+    if (!parent) throw new MindmapParseError("orphan node \u2014 expected root # heading first", lineNo, void 0, source);
     node.depth = parent.depth + 1;
     parent.children.push(node);
     stack.push({ node, depth });
   };
-  for (const raw of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i] ?? "";
+    const lineNo = i + 1 + lineOffset;
     const line2 = raw.replace(/\s+$/, "");
     const trimmed = line2.trim();
     if (!trimmed) continue;
@@ -2661,14 +2867,14 @@ function parseMindmap(text2) {
     if (heading) {
       const depth = heading[1].length - 1;
       const label = heading[2].trim();
-      const node = { id: nextId2(), label, depth, children: [] };
+      const node = makeNode(nextId2(), label, depth);
       if (depth === 0) {
-        if (root) throw new Error("Mindmap: multiple `#` center nodes not allowed");
+        if (root) throw new MindmapParseError("multiple `#` center nodes not allowed", lineNo, void 0, line2);
         root = node;
         stack.length = 0;
         stack.push({ node, depth: 0 });
       } else {
-        attach(node, depth);
+        attach(node, depth, lineNo, line2);
       }
       lastHeadingDepth = depth;
       continue;
@@ -2678,16 +2884,17 @@ function parseMindmap(text2) {
       const indent = bullet[1].length;
       const depth = lastHeadingDepth + 1 + Math.floor(indent / 2);
       const label = bullet[2].trim();
-      const node = { id: nextId2(), label, depth, children: [] };
-      attach(node, depth);
+      const node = makeNode(nextId2(), label, depth);
+      attach(node, depth, lineNo, line2);
       continue;
     }
   }
-  if (!root) throw new Error("Mindmap: missing central topic \u2014 start with `# Title`");
+  if (!root) throw new MindmapParseError("missing central topic \u2014 start with `# Title`");
   const ast = {
     type: "mindmap",
     style: directives.style,
-    root
+    root,
+    maxLabelWidth: directives.maxLabelWidth
   };
   if (directives.themeOverride) ast.themeOverride = directives.themeOverride;
   return ast;
@@ -2695,10 +2902,10 @@ function parseMindmap(text2) {
 
 // src/diagrams/mindmap/layout.ts
 var PADDING = 40;
-var SIBLING_GAP = 20;
+var SIBLING_GAP = 18;
 var MAIN_GAP = 44;
-var ROOT_CAPSULE_PAD_X = 10;
-var ROOT_CAPSULE_PAD_Y = 10;
+var UNDERLINE_GAP = 4;
+var LINE_GAP = 4;
 function bezierGapFor(childDepth) {
   if (childDepth <= 1) return 90;
   if (childDepth === 2) return 60;
@@ -2712,47 +2919,68 @@ function fontSizeOf(depth) {
   if (depth === 1) return FONT_MAIN;
   return FONT_SUB;
 }
-function estimateLabelWidth2(label, depth) {
-  return Math.max(32, label.length * fontSizeOf(depth) * 0.58);
+function lineHeightOf(fs) {
+  return fs + LINE_GAP;
 }
-function rowHeightOf(depth) {
-  return fontSizeOf(depth) + 14;
+function widthBudget(depth, maxLabelWidth) {
+  if (depth === 0) return maxLabelWidth * 1.5;
+  return maxLabelWidth;
+}
+function measureLabel(node, maxWidth) {
+  const fs = fontSizeOf(node.depth);
+  const raw = measureTokens(node.tokens, fs);
+  let lines;
+  if (raw <= maxWidth) {
+    lines = [{ tokens: node.tokens.slice(), width: raw }];
+  } else {
+    lines = wrapTokens(node.tokens, maxWidth, fs);
+  }
+  let maxW = 0;
+  for (const ln of lines) if (ln.width > maxW) maxW = ln.width;
+  const lh = lineHeightOf(fs);
+  const height = lines.length * lh + UNDERLINE_GAP;
+  return { lines, width: Math.max(32, maxW), height };
 }
-function computeColumns(subtreeRoots, firstColStartX) {
+function computeMaxLW(subtreeRoots, maxLabelWidth) {
   const maxLW = [];
   const walk = (n) => {
-    const lw = estimateLabelWidth2(n.label, n.depth);
-    if (maxLW[n.depth] === void 0 || lw > maxLW[n.depth]) maxLW[n.depth] = lw;
+    const m = measureLabel(n, widthBudget(n.depth, maxLabelWidth));
+    if (maxLW[n.depth] === void 0 || m.width > maxLW[n.depth]) maxLW[n.depth] = m.width;
     for (const c of n.children) walk(c);
   };
   for (const r of subtreeRoots) walk(r);
+  return maxLW;
+}
+function buildColumns(maxLW, firstColStartX, rootDepth) {
   const center = [];
-  if (subtreeRoots.length === 0) return { center };
-  const rootDepth = subtreeRoots[0].depth;
+  if (maxLW[rootDepth] === void 0) return { center };
   let slotLeft = firstColStartX;
   center[rootDepth] = slotLeft + maxLW[rootDepth] / 2;
   for (let d = rootDepth + 1; d < maxLW.length; d++) {
     slotLeft = slotLeft + maxLW[d - 1] + bezierGapFor(d);
-    center[d] = slotLeft + maxLW[d] / 2;
+    center[d] = slotLeft + (maxLW[d] ?? 0) / 2;
   }
   return { center };
 }
-function tidyRight(node, yTop, branchIdx, columns, out) {
-  const rowH = rowHeightOf(node.depth);
-  const lw = estimateLabelWidth2(node.label, node.depth);
+function tidyRight(node, yTop, branchIdx, columns, maxLabelWidth, maxLW, out) {
+  const m = measureLabel(node, widthBudget(node.depth, maxLabelWidth));
   const x = columns.center[node.depth];
+  const fs = fontSizeOf(node.depth);
+  const labelWidth = Math.max(m.width, maxLW[node.depth] ?? m.width);
   if (node.children.length === 0) {
     const ln2 = {
       node,
       x,
-      y: yTop + rowH / 2,
+      y: yTop + m.height / 2,
       side: "right",
       branchIndex: branchIdx,
-      labelWidth: lw,
-      labelHeight: rowH
+      labelWidth,
+      labelHeight: m.height,
+      fontSize: fs,
+      lines: m.lines
     };
     out.push(ln2);
-    return { layoutNode: ln2, height: rowH };
+    return { layoutNode: ln2, height: m.height };
   }
   let cursor = yTop;
   const childLayouts = [];
@@ -2763,12 +2991,14 @@ function tidyRight(node, yTop, branchIdx, columns, out) {
       cursor,
       branchIdx,
       columns,
+      maxLabelWidth,
+      maxLW,
       out
     );
     childLayouts.push(cln);
     cursor += height;
   }
-  const totalH = Math.max(rowH, cursor - yTop);
+  const totalH = Math.max(m.height, cursor - yTop);
   const firstY = childLayouts[0].y;
   const lastY = childLayouts[childLayouts.length - 1].y;
   const parentY = (firstY + lastY) / 2;
@@ -2778,8 +3008,10 @@ function tidyRight(node, yTop, branchIdx, columns, out) {
     y: parentY,
     side: "right",
     branchIndex: branchIdx,
-    labelWidth: lw,
-    labelHeight: rowH
+    labelWidth,
+    labelHeight: m.height,
+    fontSize: fs,
+    lines: m.lines
   };
   out.push(ln);
   return { layoutNode: ln, height: totalH };
@@ -2794,7 +3026,15 @@ function bezierH(x1, y1, x2, y2) {
   return `M ${x1.toFixed(1)} ${y1.toFixed(1)} C ${(x1 + k).toFixed(1)} ${y1.toFixed(1)}, ${(x2 - k).toFixed(1)} ${y2.toFixed(1)}, ${x2.toFixed(1)} ${y2.toFixed(1)}`;
 }
 function edgeWidthFor(depth) {
-  return depth <= 1 ? 2.2 : 1.4;
+  if (depth <= 1) return 2.2;
+  if (depth === 2) return 1.6;
+  return 1.2;
+}
+function underlineWidthFor(depth) {
+  if (depth === 0) return 2.4;
+  if (depth === 1) return 2.2;
+  if (depth === 2) return 1.6;
+  return 1.2;
 }
 function normalize(nodes) {
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
@@ -2805,8 +3045,8 @@ function normalize(nodes) {
     const rightX = n.x + lw / 2;
     minX = Math.min(minX, leftX);
     maxX = Math.max(maxX, rightX);
-    minY = Math.min(minY, n.y - lh);
-    maxY = Math.max(maxY, n.y + lh);
+    minY = Math.min(minY, n.y - lh / 2);
+    maxY = Math.max(maxY, n.y + lh / 2);
   }
   const dx = PADDING - minX;
   const dy = PADDING - minY;
@@ -2816,10 +3056,14 @@ function normalize(nodes) {
   }
   return { width: maxX - minX + PADDING * 2, height: maxY - minY + PADDING * 2 };
 }
+function underlineY(n) {
+  return n.y + n.labelHeight / 2 - UNDERLINE_GAP / 2;
+}
 function buildEdges(root, byId) {
   const edges = [];
   const walk = (parent) => {
     const pln = byId.get(parent.id);
+    const pUY = underlineY(pln);
     for (const c of parent.children) {
       const cln = byId.get(c.id);
       let fromX;
@@ -2833,7 +3077,7 @@ function buildEdges(root, byId) {
       edges.push({
         from: parent.id,
         to: c.id,
-        path: bezierH(fromX, pln.y, toX, cln.y),
+        path: bezierH(fromX, pUY, toX, underlineY(cln)),
         color: "",
         width: edgeWidthFor(c.depth)
       });
@@ -2850,24 +3094,23 @@ function layoutMap(ast) {
   const rightMains = mains.slice(0, rightCount);
   const leftMains = mains.slice(rightCount);
   const nodes = [];
-  const rootLabelW = estimateLabelWidth2(root.label, 0);
-  const rootCapsuleW = rootLabelW + ROOT_CAPSULE_PAD_X * 2;
-  const rootCapsuleH = rowHeightOf(0) + ROOT_CAPSULE_PAD_Y;
-  const firstColLeft = rootCapsuleW / 2 + bezierGapFor(1);
-  const rightCols = computeColumns(rightMains, firstColLeft);
+  const mw = ast.maxLabelWidth;
+  const rootM = measureLabel(root, widthBudget(0, mw));
+  const firstColLeft = rootM.width / 2 + bezierGapFor(1);
+  const maxLW = computeMaxLW([...rightMains, ...leftMains], mw);
+  const cols = buildColumns(maxLW, firstColLeft, 1);
   let rightCursor = 0;
   for (let i = 0; i < rightMains.length; i++) {
     if (i > 0) rightCursor += MAIN_GAP;
-    const { height: height2 } = tidyRight(rightMains[i], rightCursor, i, rightCols, nodes);
+    const { height: height2 } = tidyRight(rightMains[i], rightCursor, i, cols, mw, maxLW, nodes);
     rightCursor += height2;
   }
   const rightHeight = rightCursor;
-  const leftCols = computeColumns(leftMains, firstColLeft);
   const leftStart = nodes.length;
   let leftCursor = 0;
   for (let i = 0; i < leftMains.length; i++) {
     if (i > 0) leftCursor += MAIN_GAP;
-    const { height: height2 } = tidyRight(leftMains[i], leftCursor, rightCount + i, leftCols, nodes);
+    const { height: height2 } = tidyRight(leftMains[i], leftCursor, rightCount + i, cols, mw, maxLW, nodes);
     leftCursor += height2;
   }
   const leftHeight = leftCursor;
@@ -2882,8 +3125,10 @@ function layoutMap(ast) {
     y: rootY,
     side: "center",
     branchIndex: -1,
-    labelWidth: rootCapsuleW,
-    labelHeight: rootCapsuleH
+    labelWidth: rootM.width,
+    labelHeight: rootM.height,
+    fontSize: fontSizeOf(0),
+    lines: rootM.lines
   };
   nodes.push(rootNode);
   const { width, height } = normalize(nodes);
@@ -2894,15 +3139,15 @@ function layoutMap(ast) {
 function layoutLogicRight(ast) {
   const root = ast.root;
   const nodes = [];
-  const rootLabelW = estimateLabelWidth2(root.label, 0);
-  const rootCapsuleW = rootLabelW + ROOT_CAPSULE_PAD_X * 2;
-  const rootCapsuleH = rowHeightOf(0) + ROOT_CAPSULE_PAD_Y;
-  const firstColLeft = rootCapsuleW / 2 + bezierGapFor(1);
-  const cols = computeColumns(root.children, firstColLeft);
+  const mw = ast.maxLabelWidth;
+  const rootM = measureLabel(root, widthBudget(0, mw));
+  const firstColLeft = rootM.width / 2 + bezierGapFor(1);
+  const maxLW = computeMaxLW(root.children, mw);
+  const cols = buildColumns(maxLW, firstColLeft, 1);
   let cursor = 0;
   for (let i = 0; i < root.children.length; i++) {
     if (i > 0) cursor += MAIN_GAP;
-    const { height: height2 } = tidyRight(root.children[i], cursor, i, cols, nodes);
+    const { height: height2 } = tidyRight(root.children[i], cursor, i, cols, mw, maxLW, nodes);
     cursor += height2;
   }
   const totalHeight = cursor;
@@ -2912,8 +3157,10 @@ function layoutLogicRight(ast) {
     y: totalHeight / 2,
     side: "center",
     branchIndex: -1,
-    labelWidth: rootCapsuleW,
-    labelHeight: rootCapsuleH
+    labelWidth: rootM.width,
+    labelHeight: rootM.height,
+    fontSize: fontSizeOf(0),
+    lines: rootM.lines
   };
   nodes.push(rootNode);
   const { width, height } = normalize(nodes);
@@ -2928,91 +3175,170 @@ function layoutMindmap(ast) {
 }
 
 // src/diagrams/mindmap/renderer.ts
-var UNDERLINE_MAIN = 2.2;
-var UNDERLINE_MAIN_MONO = 1.5;
+function strokeScale(theme) {
+  return theme.branchPalette.length <= 1 ? 0.7 : 1;
+}
 function paletteColor(theme, branchIndex) {
   if (branchIndex < 0) return theme.centralFill;
   return theme.branchPalette[branchIndex % theme.branchPalette.length];
 }
-function underlineMain(theme) {
-  return theme.branchPalette.length <= 1 ? UNDERLINE_MAIN_MONO : UNDERLINE_MAIN;
+function renderLine(line2, leftX, cy, fontSize, fontFamily, fontWeight, theme) {
+  const baselineY = cy + fontSize * 0.35;
+  const tspans = [];
+  const decorations = [];
+  let cursor = leftX;
+  const emit = (tok, inheritedHref) => {
+    switch (tok.kind) {
+      case "text": {
+        const w = measureToken(tok, fontSize);
+        tspans.push(
+          tspan({
+            x: cursor,
+            y: baselineY,
+            fill: inheritedHref ? theme.linkColor : theme.text,
+            "font-weight": tok.bold ? 700 : fontWeight,
+            "font-style": tok.italic ? "italic" : void 0,
+            "text-decoration": inheritedHref ? "underline" : void 0
+          }, tok.value)
+        );
+        cursor += w;
+        break;
+      }
+      case "code": {
+        const w = measureToken(tok, fontSize);
+        decorations.push(rect({
+          x: cursor,
+          y: cy - fontSize * 0.6,
+          width: w,
+          height: fontSize * 1.2,
+          rx: 3,
+          ry: 3,
+          fill: theme.codeBg
+        }));
+        tspans.push(
+          tspan({
+            x: cursor + 2,
+            y: baselineY,
+            fill: theme.codeFg,
+            "font-family": "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+            "font-size": fontSize * 0.92
+          }, tok.value)
+        );
+        cursor += w;
+        break;
+      }
+      case "link": {
+        const aStart = `<a href="${escapeXml(tok.href)}" target="_blank" rel="noopener">`;
+        const innerStart = tspans.length;
+        for (const inner of tok.value) emit(inner, tok.href);
+        const innerTspans = tspans.splice(innerStart).join("");
+        tspans.push(aStart + innerTspans + "</a>");
+        break;
+      }
+      case "checkbox": {
+        const size = fontSize * 0.85;
+        const boxX = cursor;
+        const boxY = cy - size / 2;
+        decorations.push(rect({
+          x: boxX,
+          y: boxY,
+          width: size,
+          height: size,
+          rx: 2,
+          ry: 2,
+          fill: tok.checked ? theme.checkboxFill : "none",
+          stroke: tok.checked ? theme.checkboxFill : theme.checkboxStroke,
+          "stroke-width": 1.5
+        }));
+        if (tok.checked) {
+          const p = `M ${(boxX + size * 0.2).toFixed(1)} ${(boxY + size * 0.5).toFixed(1)} L ${(boxX + size * 0.42).toFixed(1)} ${(boxY + size * 0.72).toFixed(1)} L ${(boxX + size * 0.82).toFixed(1)} ${(boxY + size * 0.28).toFixed(1)}`;
+          decorations.push(path({
+            d: p,
+            fill: "none",
+            stroke: "#ffffff",
+            "stroke-width": 2,
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round"
+          }));
+        }
+        cursor += size + fontSize * 0.25;
+        break;
+      }
+    }
+  };
+  for (const tok of line2.tokens) emit(tok);
+  const textElement = el("text", {
+    "font-family": fontFamily,
+    "font-size": fontSize,
+    "font-weight": fontWeight
+  }, tspans.join(""));
+  return { textElement, decorations };
+}
+function measureToken(tok, fs) {
+  switch (tok.kind) {
+    case "text":
+      return tok.value.length * fs * (tok.bold ? 0.62 : 0.58);
+    case "code":
+      return tok.value.length * fs * 0.62 + 4;
+    case "link": {
+      let w = 0;
+      for (const t of tok.value) w += measureToken(t, fs);
+      return w;
+    }
+    case "checkbox":
+      return fs * 0.85 + fs * 0.25;
+  }
 }
-function renderCentral(n, theme, fontFamily) {
-  const fs = fontSizeOf(0);
-  const pillW = n.labelWidth;
-  const pillH = n.labelHeight;
-  return group(
-    { class: "schematex-mindmap-central", "data-node-id": n.node.id },
-    [
-      rect({
-        x: n.x - pillW / 2,
-        y: n.y - pillH / 2,
-        width: pillW,
-        height: pillH,
-        rx: pillH / 2,
-        ry: pillH / 2,
-        fill: "none",
-        stroke: theme.textMuted,
-        "stroke-width": underlineMain(theme)
-      }),
-      text(
-        {
-          x: n.x,
-          y: n.y + fs * 0.35,
-          "text-anchor": "middle",
-          "font-family": fontFamily,
-          "font-size": fs,
-          "font-weight": 700,
-          fill: theme.text
-        },
-        n.node.label
-      )
-    ]
-  );
+function tspan(attrs, content) {
+  const pairs = [];
+  for (const [k, v] of Object.entries(attrs)) {
+    if (v === void 0) continue;
+    pairs.push(`${k}="${typeof v === "number" ? String(v) : escapeXml(String(v))}"`);
+  }
+  return `<tspan ${pairs.join(" ")}>${escapeXml(content)}</tspan>`;
 }
-function renderBranchNode(n, color, theme, fontFamily) {
+function renderNode(n, color, theme, fontFamily) {
+  const isRoot = n.node.depth === 0;
   const isMain = n.node.depth === 1;
-  const fs = fontSizeOf(n.node.depth);
-  const tx = n.x;
-  const ty = isMain ? n.y - 3 : n.y + fs * 0.35;
+  const fs = n.fontSize;
+  const lh = lineHeightOf(fs);
+  const lineCount = n.lines.length;
+  const topY = n.y - n.labelHeight / 2;
+  const underlineY2 = n.y + n.labelHeight / 2 - UNDERLINE_GAP / 2;
+  const children = [];
+  const decorations = [];
+  const weight = isRoot ? 700 : isMain ? 600 : 400;
+  const textLeft = n.x - n.labelWidth / 2;
+  for (let i = 0; i < lineCount; i++) {
+    const line2 = n.lines[i];
+    const cy = topY + (i + 0.5) * lh;
+    const r = renderLine(line2, textLeft, cy, fs, fontFamily, weight, theme);
+    decorations.push(...r.decorations);
+    children.push(r.textElement);
+  }
   const ux1 = n.x - n.labelWidth / 2;
   const ux2 = n.x + n.labelWidth / 2;
-  const uy = n.y;
-  const children = [
-    text(
-      {
-        x: tx,
-        y: ty,
-        "text-anchor": "middle",
-        "font-family": fontFamily,
-        "font-size": fs,
-        "font-weight": isMain ? 600 : 400,
-        fill: theme.text
-      },
-      n.node.label
-    )
-  ];
-  if (isMain) {
-    children.push(
-      el("line", {
-        x1: ux1,
-        y1: uy,
-        x2: ux2,
-        y2: uy,
-        stroke: color,
-        "stroke-width": underlineMain(theme),
-        "stroke-linecap": "round"
-      })
-    );
-  }
+  const sw = underlineWidthFor(n.node.depth) * strokeScale(theme);
+  children.push(
+    el("line", {
+      x1: ux1,
+      y1: underlineY2,
+      x2: ux2,
+      y2: underlineY2,
+      stroke: color,
+      "stroke-width": sw,
+      "stroke-linecap": "round"
+    })
+  );
+  const cls = isRoot ? "schematex-mindmap-central" : isMain ? "schematex-mindmap-main" : "schematex-mindmap-leaf";
   return group(
     {
-      class: isMain ? "schematex-mindmap-main" : "schematex-mindmap-leaf",
+      class: cls,
       "data-node-id": n.node.id,
       "data-depth": n.node.depth,
       "data-branch-idx": n.branchIndex
     },
-    children
+    [...decorations, ...children]
   );
 }
 function renderMindmapAST(ast, themeName = "default", fontFamily = "system-ui, -apple-system, sans-serif") {
@@ -3036,15 +3362,10 @@ function renderMindmapAST(ast, themeName = "default", fontFamily = "system-ui, -
   }
   const nodeSvgs = [];
   for (const n of layout.nodes) {
-    if (n.node.depth === 0) {
-      nodeSvgs.push(renderCentral(n, theme, fontFamily));
-    } else {
-      nodeSvgs.push(
-        renderBranchNode(n, paletteColor(theme, n.branchIndex), theme, fontFamily)
-      );
-    }
+    const color = n.node.depth === 0 ? theme.centralFill : paletteColor(theme, n.branchIndex);
+    nodeSvgs.push(renderNode(n, color, theme, fontFamily));
   }
-  const title2 = ast.title ?? ast.root.label;
+  const title2 = ast.title ?? tokensToPlainText(ast.root.tokens);
   return svgRoot(
     {
       viewBox: `0 0 ${layout.width.toFixed(1)} ${layout.height.toFixed(1)}`,
@@ -4535,5 +4856,5 @@ function render(text2, config) {
 }
 
 export { decisiontree, parse, render, timeline };
-//# sourceMappingURL=chunk-M6AMNXQ7.js.map
-//# sourceMappingURL=chunk-M6AMNXQ7.js.map
+//# sourceMappingURL=chunk-S3RBKJM5.js.map
+//# sourceMappingURL=chunk-S3RBKJM5.js.map