schematex 0.1.0 → 0.2.0

package/dist/chunk-M6AMNXQ7.js

@@ -0,0 +1,4539 @@
+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 { 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) {
+    super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
+    this.line = line2;
+    this.name = "DTreeParseError";
+  }
+  line;
+};
+function preprocess(src) {
+  const out = [];
+  const lines = src.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw === void 0) continue;
+    if (!raw.trim() || raw.trim().startsWith("#") || raw.trim().startsWith("//")) continue;
+    const indentSpaces = raw.length - raw.replace(/^\s+/, "").length;
+    out.push({ indent: Math.floor(indentSpaces / 2), text: raw.trim(), line: i + 1 });
+  }
+  return out;
+}
+function tokenize(s) {
+  const tokens = [];
+  let i = 0;
+  while (i < s.length) {
+    const ch = s[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      const end = s.indexOf('"', i + 1);
+      if (end < 0) throw new DTreeParseError(`Unterminated string: ${s}`);
+      tokens.push(s.slice(i, end + 1));
+      i = end + 1;
+      continue;
+    }
+    let j = i;
+    let bracket = 0;
+    while (j < s.length) {
+      const c = s[j];
+      if (c === "[") bracket++;
+      else if (c === "]") bracket--;
+      else if (bracket === 0 && /\s/.test(c)) break;
+      else if (bracket === 0 && c === '"') break;
+      j++;
+    }
+    tokens.push(s.slice(i, j));
+    i = j;
+  }
+  return tokens;
+}
+function unquote(s) {
+  if (s.startsWith('"') && s.endsWith('"')) return s.slice(1, -1);
+  return s;
+}
+function parseKV(tokens) {
+  const keys = {};
+  const labels = [];
+  const rest = [];
+  for (const tok of tokens) {
+    if (tok.startsWith('"') && tok.endsWith('"')) {
+      labels.push(unquote(tok));
+    } else if (tok.includes("=")) {
+      const idx = tok.indexOf("=");
+      const k = tok.slice(0, idx);
+      const v = tok.slice(idx + 1);
+      keys[k] = v;
+    } else {
+      rest.push(tok);
+    }
+  }
+  return { keys, labels, rest };
+}
+function parseNumberList(s) {
+  const inner = s.replace(/^\[/, "").replace(/\]$/, "");
+  return inner.split(",").map((p) => Number(p.trim())).filter((n) => !Number.isNaN(n));
+}
+var idCounter = 0;
+function nextId(prefix = "n") {
+  idCounter++;
+  return `${prefix}${idCounter}`;
+}
+function parseDecisionLine(tokens, _ctx, lineNum) {
+  let idx = 0;
+  let incomingChoice;
+  let incomingProb;
+  if (tokens[idx] === "choice") {
+    idx++;
+    const next = tokens[idx];
+    if (!next || !next.startsWith('"')) throw new DTreeParseError(`"choice" requires a label`, lineNum);
+    incomingChoice = unquote(next);
+    idx++;
+    if (idx >= tokens.length) {
+      return {
+        id: nextId(),
+        kind: "decision",
+        // placeholder; will be overridden if sole child exists
+        label: "",
+        children: [],
+        incomingChoice,
+        // special marker so parseBody knows this is a wrapper
+        _wrapper: "choice"
+      };
+    }
+  } else if (tokens[idx] === "prob") {
+    idx++;
+    const p = Number(tokens[idx]);
+    if (Number.isNaN(p)) throw new DTreeParseError(`"prob" requires a numeric probability`, lineNum);
+    incomingProb = p;
+    idx++;
+  }
+  const kw = tokens[idx];
+  if (!kw) throw new DTreeParseError(`Missing node kind`, lineNum);
+  const rest = tokens.slice(idx + 1);
+  const parsed = parseKV(rest);
+  let kind;
+  if (kw === "decision") kind = "decision";
+  else if (kw === "chance") kind = "chance";
+  else if (kw === "end" || kw === "outcome") kind = "end";
+  else throw new DTreeParseError(`Unknown node kind "${kw}" in decision mode`, lineNum);
+  const label = parsed.labels[0] ?? "";
+  const payoffStr = parsed.keys.payoff;
+  const payoff = payoffStr !== void 0 ? Number(payoffStr) : void 0;
+  return {
+    id: nextId(),
+    kind,
+    label,
+    children: [],
+    incomingChoice,
+    incomingProb,
+    payoff
+  };
+}
+function parseMlLine(tokens, ctx, lineNum) {
+  let idx = 0;
+  let mlBranch;
+  if (tokens[idx] === "true" || tokens[idx] === "false") {
+    mlBranch = tokens[idx];
+    idx++;
+  }
+  const kw = tokens[idx];
+  if (!kw) throw new DTreeParseError(`Missing ML node kind`, lineNum);
+  idx++;
+  const rest = tokens.slice(idx);
+  const parsed = parseKV(rest);
+  let kind;
+  if (kw === "split") kind = "split";
+  else if (kw === "leaf") kind = "leaf";
+  else throw new DTreeParseError(`Unknown ML node kind "${kw}"`, lineNum);
+  const label = parsed.labels[0] ?? "";
+  const k = parsed.keys;
+  let value;
+  if (k.value !== void 0) {
+    if (k.value.startsWith("[")) value = parseNumberList(k.value);
+    else value = Number(k.value);
+  }
+  if (typeof value === "number") ctx.regression = true;
+  let impurity;
+  for (const impKey of ["gini", "entropy", "mse", "gain", "impurity"]) {
+    if (k[impKey] !== void 0) {
+      impurity = Number(k[impKey]);
+      break;
+    }
+  }
+  return {
+    id: nextId(),
+    kind,
+    label,
+    children: [],
+    feature: k.feature,
+    op: k.op,
+    threshold: k.threshold !== void 0 ? Number.isNaN(Number(k.threshold)) ? k.threshold : Number(k.threshold) : void 0,
+    samples: k.samples !== void 0 ? Number(k.samples) : void 0,
+    value,
+    impurity,
+    mlBranch,
+    className: k.class
+  };
+}
+function parseTaxonomyLine(tokens, _ctx, lineNum) {
+  let idx = 0;
+  let branchLabel;
+  if (tokens[idx] === "yes:" || tokens[idx] === "no:") {
+    branchLabel = tokens[idx].replace(":", "");
+    idx++;
+  } else if (tokens[idx] === "label") {
+    idx++;
+    const lbl = tokens[idx];
+    if (!lbl || !lbl.startsWith('"')) throw new DTreeParseError(`"label" requires a quoted string`, lineNum);
+    branchLabel = unquote(lbl.replace(/":?$/, '"'));
+    if (lbl.endsWith(':"')) ;
+    idx++;
+    if (tokens[idx] === ":") idx++;
+  }
+  const kw = tokens[idx];
+  if (!kw) throw new DTreeParseError(`Missing taxonomy node kind`, lineNum);
+  idx++;
+  const rest = tokens.slice(idx);
+  const parsed = parseKV(rest);
+  let kind;
+  if (kw === "q" || kw === "question") kind = "question";
+  else if (kw === "a" || kw === "answer" || kw === "leaf") kind = "answer";
+  else throw new DTreeParseError(`Unknown taxonomy node kind "${kw}"`, lineNum);
+  return {
+    id: nextId(),
+    kind,
+    label: parsed.labels[0] ?? "",
+    children: [],
+    branchLabel
+  };
+}
+function parseNodeLine(text2, mode, ctx, lineNum) {
+  const normalized = text2.replace(/"\s*:\s*/g, '" : ');
+  const tokens = tokenize(normalized).filter((t) => t !== ":");
+  if (mode === "decision") return parseDecisionLine(tokens, ctx, lineNum);
+  if (mode === "ml") return parseMlLine(tokens, ctx, lineNum);
+  return parseTaxonomyLine(tokens, ctx, lineNum);
+}
+function buildTree(lines, mode, ctx) {
+  if (lines.length === 0) throw new DTreeParseError("No tree body");
+  const [first, ...rest] = lines;
+  if (!first) throw new DTreeParseError("No tree body");
+  const root = parseNodeLine(first.text, mode, ctx, first.line);
+  const stack = [{ node: root, indent: first.indent }];
+  for (const line2 of rest) {
+    const node = parseNodeLine(line2.text, mode, ctx, line2.line);
+    while (stack.length > 0 && stack[stack.length - 1].indent >= line2.indent) stack.pop();
+    const parent = stack[stack.length - 1];
+    if (!parent) throw new DTreeParseError(`Orphan line (bad indent): ${line2.text}`, line2.line);
+    parent.node.children.push(node);
+    stack.push({ node, indent: line2.indent });
+  }
+  return collapseWrappers(root);
+}
+function collapseWrappers(node) {
+  node.children = node.children.map(collapseWrappers).flatMap((c) => {
+    const anyC = c;
+    if (anyC._wrapper === "choice") {
+      return c.children.map((gc) => ({ ...gc, incomingChoice: c.incomingChoice }));
+    }
+    return [c];
+  });
+  return node;
+}
+function computeEV(node) {
+  for (const c of node.children) computeEV(c);
+  if (node.kind === "end") {
+    node.ev = node.payoff ?? 0;
+    return;
+  }
+  if (node.kind === "chance") {
+    let sum = 0;
+    for (const c of node.children) sum += (c.incomingProb ?? 0) * (c.ev ?? 0);
+    node.ev = sum;
+    return;
+  }
+  if (node.kind === "decision") {
+    let best = -Infinity;
+    for (const c of node.children) {
+      if ((c.ev ?? -Infinity) > best) best = c.ev ?? -Infinity;
+    }
+    node.ev = best;
+    for (const c of node.children) {
+      if ((c.ev ?? -Infinity) === best) c.optimal = true;
+    }
+    return;
+  }
+}
+function validateDecision(node, lineMap) {
+  if (node.kind === "chance" && node.children.length > 0) {
+    const sum = node.children.reduce((a, c) => a + (c.incomingProb ?? 0), 0);
+    if (Math.abs(sum - 1) > 0.01) {
+      throw new DTreeParseError(
+        `chance "${node.label}" probabilities do not sum to 1.0 (got ${sum.toFixed(3)})`
+      );
+    }
+  }
+  for (const c of node.children) validateDecision(c);
+}
+function parseDecisionTree(src) {
+  idCounter = 0;
+  const lines = preprocess(src);
+  if (lines.length === 0) throw new DTreeParseError("Empty input");
+  const header = lines.shift();
+  const headerMatch = header.text.match(/^decisiontree(?::(\w+))?(?:\s+"([^"]*)")?\s*$/i);
+  if (!headerMatch) throw new DTreeParseError(`Invalid header: ${header.text}`, header.line);
+  const modeRaw = (headerMatch[1] ?? "taxonomy").toLowerCase();
+  const mode = modeRaw === "decision" || modeRaw === "da" ? "decision" : modeRaw === "ml" ? "ml" : "taxonomy";
+  const title2 = headerMatch[2];
+  const nodeKeywords = /* @__PURE__ */ new Set([
+    "decision",
+    "chance",
+    "end",
+    "outcome",
+    "choice",
+    "prob",
+    "split",
+    "leaf",
+    "true",
+    "false",
+    "q",
+    "question",
+    "a",
+    "answer",
+    "yes:",
+    "no:",
+    "label"
+  ]);
+  const config = {};
+  while (lines.length > 0) {
+    const l = lines[0];
+    const firstTok = l.text.split(/\s+/)[0];
+    if (nodeKeywords.has(firstTok)) break;
+    const m = l.text.match(/^([a-zA-Z][\w-]*)\s*:\s*(.+)$/);
+    if (!m) break;
+    config[m[1]] = m[2].trim();
+    lines.shift();
+  }
+  let direction = "top-down";
+  if (config.direction === "left-right" || config.direction === "lr") direction = "left-right";
+  if (mode === "decision" && !config.direction) direction = "left-right";
+  const classes = config.classes ? config.classes.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  let impurityName;
+  if (config.impurity) {
+    const v = config.impurity.toLowerCase();
+    if (v === "gini" || v === "entropy" || v === "mse" || v === "gain") impurityName = v;
+  }
+  const branchLabels = config.branchLabels === "relation" || config["branch-labels"] === "relation" ? "relation" : "boolean";
+  const branchLengthProb = config.branchLength === "probability" || config["branch-length"] === "probability";
+  let edgeStyle;
+  const es = (config.edgeStyle || config["edge-style"] || "").toLowerCase();
+  if (es === "diagonal" || es === "orthogonal" || es === "bracket") edgeStyle = es;
+  const ctx = { regression: false };
+  const root = buildTree(lines, mode, ctx);
+  if (mode === "decision") {
+    validateDecision(root);
+    computeEV(root);
+  }
+  return {
+    type: "decisiontree",
+    mode,
+    title: title2,
+    direction,
+    classes,
+    impurityName: impurityName ?? (mode === "ml" ? "gini" : void 0),
+    branchLabels,
+    branchLengthProb,
+    edgeStyle,
+    regression: ctx.regression,
+    root
+  };
+}
+
+// src/diagrams/decisiontree/layout.ts
+function sizeOf(node, mode) {
+  if (mode === "decision") {
+    if (node.kind === "decision") return { w: 58, h: 36 };
+    if (node.kind === "chance") return { w: 34, h: 34 };
+    return { w: 22, h: 22 };
+  }
+  if (mode === "ml") {
+    if (node.kind === "split") return { w: 200, h: 100 };
+    return { w: 200, h: 82 };
+  }
+  return { w: 150, h: 50 };
+}
+function wrap(node, mode, depth, parent) {
+  const w = {
+    node,
+    size: sizeOf(node, mode),
+    depth,
+    parent,
+    children: [],
+    prelim: 0,
+    mod: 0,
+    xFinal: 0,
+    yFinal: 0
+  };
+  w.children = node.children.map((c) => wrap(c, mode, depth + 1, w));
+  return w;
+}
+function collect(w, out) {
+  out.push(w);
+  for (const c of w.children) collect(c, out);
+}
+function sibExtent(w, sibH) {
+  return sibH ? w.size.w : w.size.h;
+}
+function assignLeafPositions(w, sibH, unit, leafGap, cursor) {
+  if (w.children.length === 0) {
+    w.prelim = cursor.v;
+    const extent = sibExtent(w, sibH);
+    cursor.v += Math.max(extent, unit) + leafGap;
+    return;
+  }
+  for (const c of w.children) assignLeafPositions(c, sibH, unit, leafGap, cursor);
+  const first = w.children[0].prelim;
+  const last = w.children[w.children.length - 1].prelim;
+  w.prelim = (first + last) / 2;
+}
+function subtreeSibRange(w, sibH) {
+  const e = sibExtent(w, sibH);
+  let lo = w.prelim - e / 2;
+  let hi = w.prelim + e / 2;
+  for (const c of w.children) {
+    const cr = subtreeSibRange(c, sibH);
+    if (cr.lo < lo) lo = cr.lo;
+    if (cr.hi > hi) hi = cr.hi;
+  }
+  return { lo, hi };
+}
+function enforceSibGap(w, sibH, sibGap) {
+  for (const c of w.children) enforceSibGap(c, sibH, sibGap);
+  for (let i = 1; i < w.children.length; i++) {
+    const prev = w.children[i - 1];
+    const cur = w.children[i];
+    const prevR = subtreeSibRange(prev, sibH);
+    const curR = subtreeSibRange(cur, sibH);
+    const gap = curR.lo - prevR.hi;
+    if (gap < sibGap) {
+      shiftSubtree(cur, sibGap - gap);
+    }
+  }
+  if (w.children.length > 0) {
+    const first = w.children[0].prelim;
+    const last = w.children[w.children.length - 1].prelim;
+    w.prelim = (first + last) / 2;
+  }
+}
+function shiftSubtree(w, dx) {
+  w.prelim += dx;
+  for (const c of w.children) shiftSubtree(c, dx);
+}
+function computeLevelOffsets(root, sibH, levelGap) {
+  const depthSizes = [];
+  const all = [];
+  collect(root, all);
+  for (const n of all) {
+    const dSize = sibH ? n.size.h : n.size.w;
+    depthSizes[n.depth] = Math.max(depthSizes[n.depth] ?? 0, dSize);
+  }
+  const offsets = [];
+  let acc = 0;
+  for (let i = 0; i < depthSizes.length; i++) {
+    if (i === 0) acc = 0;
+    else acc += depthSizes[i - 1] / 2 + levelGap + depthSizes[i] / 2;
+    offsets.push(acc);
+  }
+  return offsets;
+}
+function setFinal(w, sibH, levelOffsets) {
+  const d = levelOffsets[w.depth] ?? 0;
+  if (sibH) {
+    w.xFinal = w.prelim;
+    w.yFinal = d;
+  } else {
+    w.xFinal = d;
+    w.yFinal = w.prelim;
+  }
+  for (const c of w.children) setFinal(c, sibH, levelOffsets);
+}
+function routeEdge(style, sibH, p, c, rail) {
+  const px = p.x, py = p.y, cx = c.x, cy = c.y;
+  let startX, startY, endX, endY;
+  if (sibH) {
+    startX = px;
+    startY = py + p.height / 2;
+    endX = cx;
+    endY = cy - c.height / 2;
+  } else {
+    startX = px + p.width / 2;
+    startY = py;
+    endX = cx - c.width / 2;
+    endY = cy;
+  }
+  if (style === "diagonal") {
+    const tLabel = 0.68;
+    const lx = startX + (endX - startX) * tLabel;
+    const ly = startY + (endY - startY) * tLabel;
+    const dx = endX - startX;
+    const dy = endY - startY;
+    let angle = Math.atan2(dy, dx) * 180 / Math.PI;
+    if (angle > 90) angle -= 180;
+    if (angle < -90) angle += 180;
+    return {
+      path: `M ${startX} ${startY} L ${endX} ${endY}`,
+      labelX: lx,
+      labelY: ly,
+      angle
+    };
+  }
+  if (style === "bracket") {
+    if (sibH) {
+      const stub2 = Math.min(18, Math.abs(endY - startY) * 0.25);
+      const elbowY = startY + stub2;
+      const midX = (startX + endX) / 2;
+      const midY = (elbowY + endY) / 2;
+      const angle = Math.atan2(endY - elbowY, endX - startX) * 180 / Math.PI;
+      return {
+        path: `M ${startX} ${startY} L ${startX} ${elbowY} L ${endX} ${endY}`,
+        labelX: midX,
+        labelY: midY,
+        angle: angle > 90 ? angle - 180 : angle < -90 ? angle + 180 : angle
+      };
+    }
+    const stub = Math.min(18, Math.abs(endX - startX) * 0.25);
+    const elbowX = startX + stub;
+    return {
+      path: `M ${startX} ${startY} L ${elbowX} ${startY} L ${endX} ${endY}`,
+      labelX: (elbowX + endX) / 2,
+      labelY: (startY + endY) / 2,
+      angle: Math.atan2(endY - startY, endX - elbowX) * 180 / Math.PI
+    };
+  }
+  if (sibH) {
+    const railY = rail ?? (startY + endY) / 2;
+    return {
+      path: `M ${startX} ${startY} L ${startX} ${railY} L ${endX} ${railY} L ${endX} ${endY}`,
+      labelX: (startX + endX) / 2,
+      labelY: railY,
+      angle: 0
+    };
+  }
+  const railX = rail ?? (startX + endX) / 2;
+  return {
+    path: `M ${startX} ${startY} L ${railX} ${startY} L ${railX} ${endY} L ${endX} ${endY}`,
+    labelX: railX,
+    labelY: (startY + endY) / 2,
+    angle: 0
+  };
+}
+function routeSnappedEnd(sibH, p, c) {
+  if (sibH) {
+    const startX2 = p.x, startY2 = p.y + p.height / 2;
+    const endX2 = c.x, endY2 = c.y - c.height / 2;
+    return {
+      path: `M ${startX2} ${startY2} L ${endX2} ${endY2}`,
+      labelX: (startX2 + endX2) / 2,
+      labelY: (startY2 + endY2) / 2,
+      angle: 0
+    };
+  }
+  const startX = p.x + p.width / 2;
+  const startY = p.y;
+  const endX = c.x - c.width / 2;
+  const endY = c.y;
+  const naturalCx = c.naturalX ?? c.x;
+  const bendX = Math.max(naturalCx, startX + 20);
+  const dx = bendX - startX;
+  const dy = endY - startY;
+  let angle = Math.atan2(dy, dx) * 180 / Math.PI;
+  if (angle > 90) angle -= 180;
+  if (angle < -90) angle += 180;
+  const t = 0.7;
+  const labelX = startX + (bendX - startX) * t;
+  const labelY = startY + (endY - startY) * t;
+  return {
+    path: `M ${startX} ${startY} L ${bendX} ${endY} L ${endX} ${endY}`,
+    labelX,
+    labelY,
+    angle
+  };
+}
+function layoutDecisionTree(ast) {
+  const sibH = ast.direction === "top-down";
+  const root = wrap(ast.root, ast.mode, 0);
+  const all = [];
+  collect(root, all);
+  const perDepthDepthSize = [];
+  for (const w of all) {
+    const d = sibH ? w.size.h : w.size.w;
+    perDepthDepthSize[w.depth] = Math.max(perDepthDepthSize[w.depth] ?? 0, d);
+  }
+  for (const w of all) {
+    const target = perDepthDepthSize[w.depth];
+    if (sibH) w.size.h = target;
+    else w.size.w = target;
+  }
+  const maxSibExtent = Math.max(...all.map((w) => sibExtent(w, sibH)));
+  let leafGap, levelGap, sibGap;
+  if (ast.mode === "ml") {
+    leafGap = 40;
+    levelGap = 80;
+    sibGap = 40;
+  } else if (ast.mode === "decision") {
+    leafGap = sibH ? 40 : 36;
+    levelGap = sibH ? 90 : 110;
+    sibGap = 30;
+  } else {
+    leafGap = sibH ? 30 : 22;
+    levelGap = sibH ? 80 : 90;
+    sibGap = 26;
+  }
+  const unit = Math.max(maxSibExtent, sibH ? 120 : 50);
+  const cursor = { v: 0 };
+  assignLeafPositions(root, sibH, unit, leafGap, cursor);
+  enforceSibGap(root, sibH, sibGap);
+  const levelOffsets = computeLevelOffsets(root, sibH, levelGap);
+  setFinal(root, sibH, levelOffsets);
+  const PADDING2 = 40;
+  const extraLeft = ast.mode === "decision" && !sibH ? 110 : 0;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const n of all) {
+    minX = Math.min(minX, n.xFinal - n.size.w / 2);
+    minY = Math.min(minY, n.yFinal - n.size.h / 2);
+    maxX = Math.max(maxX, n.xFinal + n.size.w / 2);
+    maxY = Math.max(maxY, n.yFinal + n.size.h / 2);
+  }
+  const needsPayoffCol = ast.mode === "decision" && !sibH;
+  const payoffColGap = needsPayoffCol ? 110 : 0;
+  const extraRight = needsPayoffCol ? 180 : ast.mode === "decision" ? 110 : 20;
+  const naturalXMap = /* @__PURE__ */ new Map();
+  for (const w of all) naturalXMap.set(w.node.id, w.xFinal);
+  if (needsPayoffCol) {
+    let endMaxX = -Infinity;
+    for (const w of all) if (w.node.kind === "end") endMaxX = Math.max(endMaxX, w.xFinal);
+    for (const w of all) if (w.node.kind === "end") w.xFinal = endMaxX;
+    minX = Infinity;
+    maxX = -Infinity;
+    for (const n of all) {
+      minX = Math.min(minX, n.xFinal - n.size.w / 2);
+      maxX = Math.max(maxX, n.xFinal + n.size.w / 2);
+    }
+  }
+  const offsetX = PADDING2 + extraLeft - minX;
+  const offsetY = PADDING2 - minY;
+  const layoutNodes = all.map((w) => ({
+    node: w.node,
+    x: w.xFinal + offsetX,
+    y: w.yFinal + offsetY,
+    width: w.size.w,
+    height: w.size.h,
+    depth: w.depth,
+    naturalX: (naturalXMap.get(w.node.id) ?? w.xFinal) + offsetX,
+    naturalY: w.yFinal + offsetY
+  }));
+  const nodeById = new Map(layoutNodes.map((n) => [n.node.id, n]));
+  const edgeStyle = ast.edgeStyle ?? (ast.mode === "decision" ? "diagonal" : "orthogonal");
+  const levelRails = [];
+  if (edgeStyle === "orthogonal") {
+    for (let d = 1; d < perDepthDepthSize.length; d++) {
+      const parentBotY = (levelOffsets[d - 1] ?? 0) + perDepthDepthSize[d - 1] / 2;
+      const childTopY = (levelOffsets[d] ?? 0) - perDepthDepthSize[d] / 2;
+      levelRails[d] = (parentBotY + childTopY) / 2 + (sibH ? offsetY : offsetX);
+    }
+  }
+  const labelAnchors = {};
+  const edges = [];
+  for (const w of all) {
+    for (const c of w.children) {
+      const pn = nodeById.get(w.node.id);
+      const cn = nodeById.get(c.node.id);
+      const wasSnapped = needsPayoffCol && c.node.kind === "end" && cn.naturalX !== void 0 && Math.abs(cn.naturalX - cn.x) > 1;
+      const geom = wasSnapped ? routeSnappedEnd(sibH, pn, cn) : routeEdge(edgeStyle, sibH, pn, cn, levelRails[c.depth]);
+      const isOptimal = c.node.optimal === true;
+      let strokeWidth = 1.6;
+      if (isOptimal) strokeWidth = 3;
+      if (ast.branchLengthProb && c.node.incomingProb !== void 0) {
+        strokeWidth = 1 + c.node.incomingProb * 2.5;
+      }
+      let label;
+      if (ast.mode === "decision") {
+        if (c.node.incomingChoice !== void 0) label = c.node.incomingChoice;
+        else if (c.node.incomingProb !== void 0) label = formatProb(c.node.incomingProb);
+      } else if (ast.mode === "ml") {
+        if (c.node.mlBranch) {
+          if (ast.branchLabels === "relation" && w.node.op && w.node.threshold !== void 0) {
+            const op = c.node.mlBranch === "true" ? w.node.op : flipOp(w.node.op);
+            label = `${op} ${w.node.threshold}`;
+          } else {
+            label = c.node.mlBranch === "true" ? "True" : "False";
+          }
+        }
+      } else {
+        if (c.node.branchLabel) label = c.node.branchLabel;
+      }
+      labelAnchors[c.node.id] = { x: geom.labelX, y: geom.labelY, angle: geom.angle };
+      edges.push({ from: w.node.id, to: c.node.id, path: geom.path, label, isOptimal, strokeWidth });
+    }
+  }
+  let payoffColumnX;
+  if (needsPayoffCol) {
+    let endX = 0;
+    for (const n of layoutNodes) if (n.node.kind === "end") endX = Math.max(endX, n.x + n.width / 2);
+    payoffColumnX = endX + payoffColGap;
+  }
+  const width = Math.ceil(maxX - minX + PADDING2 * 2 + extraRight + extraLeft);
+  const height = Math.ceil(maxY - minY + PADDING2 * 2);
+  return {
+    width,
+    height,
+    nodes: layoutNodes,
+    edges,
+    levelRails: edgeStyle === "orthogonal" ? levelRails : void 0,
+    title: ast.title,
+    mode: ast.mode,
+    direction: ast.direction,
+    edgeStyle,
+    labelAnchors,
+    payoffColumnX
+  };
+}
+function flipOp(op) {
+  if (op === "<=") return ">";
+  if (op === "<") return ">=";
+  if (op === ">=") return "<";
+  if (op === ">") return "<=";
+  return op;
+}
+function formatProb(p) {
+  if (p >= 0.01 && p <= 0.99) {
+    const pct = Math.round(p * 100);
+    if (Math.abs(p * 100 - pct) < 0.01) return `p=${pct}%`;
+  }
+  return `p=${p}`;
+}
+
+// src/diagrams/decisiontree/renderer.ts
+var CLASS_PALETTE = [
+  "#0ea5e9",
+  "#10b981",
+  "#f59e0b",
+  "#f43f5e",
+  "#8b5cf6",
+  "#14b8a6",
+  "#ec4899",
+  "#84cc16",
+  "#06b6d4",
+  "#f97316"
+];
+function buildCss(t) {
+  return `
+.lt-dtree { background: ${t.bg}; font-family: system-ui, -apple-system, sans-serif; }
+.lt-dtree-title { font: 500 16px sans-serif; fill: ${t.text}; }
+.lt-dtree-edge { fill: none; stroke: ${t.stroke}; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
+.lt-dtree-edge-optimal { fill: none; stroke: ${t.positive}; stroke-width: 3; stroke-linecap: round; stroke-linejoin: round; }
+.lt-dtree-edge-leader { fill: none; stroke: ${t.stroke}; stroke-width: 1; stroke-dasharray: 2 2; opacity: 0.55; }
+.lt-dtree-edge-label { font: 500 11px sans-serif; fill: ${t.text}; text-anchor: middle; dominant-baseline: middle; }
+.lt-dtree-edge-prob { font: italic 400 10px sans-serif; fill: ${t.textMuted}; text-anchor: middle; dominant-baseline: middle; }
+.lt-dtree-edge-label-bg { fill: ${t.bg}; stroke: none; }
+.lt-dtree-decision { fill: #dbeafe; stroke: #1d4ed8; stroke-width: 1.6; }
+.lt-dtree-chance { fill: #fef3c7; stroke: #b45309; stroke-width: 1.6; }
+.lt-dtree-outcome { fill: #f1f5f9; stroke: ${t.stroke}; stroke-width: 1.4; }
+.lt-dtree-node-label { font: 500 12px sans-serif; fill: ${t.text}; }
+.lt-dtree-ev { font: 500 10px "SF Mono", monospace; fill: ${t.textMuted}; }
+.lt-dtree-ev-optimal { font: 600 10px "SF Mono", monospace; fill: ${t.positive}; }
+.lt-dtree-payoff { font: 600 12px "SF Mono", monospace; fill: ${t.text}; }
+.lt-dtree-payoff-neg { font: 600 12px "SF Mono", monospace; fill: ${t.negative ?? "#dc2626"}; }
+.lt-dtree-ml-rect { stroke: ${t.stroke}; stroke-width: 1; }
+.lt-dtree-ml-line-1 { font: 500 12px sans-serif; fill: ${t.text}; }
+.lt-dtree-ml-line-muted { font: 400 10px sans-serif; fill: ${t.textMuted}; }
+.lt-dtree-ml-mono { font: 400 10px "SF Mono", monospace; fill: ${t.textMuted}; }
+.lt-dtree-ml-class { font: 600 11px sans-serif; }
+.lt-dtree-taxon { fill: #eef2ff; stroke: #4f46e5; stroke-width: 1.4; }
+.lt-dtree-taxon-leaf { fill: #ecfdf5; stroke: #059669; stroke-width: 1.4; }
+.lt-dtree-taxon-label { font: 500 12px sans-serif; fill: ${t.text}; text-anchor: middle; }
+`.trim();
+}
+function renderDecisionNode(ln, layout) {
+  const n = ln.node;
+  const parts = [];
+  const sibH = layout.direction === "top-down";
+  if (n.kind === "decision") {
+    parts.push(rect({
+      x: ln.x - ln.width / 2,
+      y: ln.y - ln.height / 2,
+      width: ln.width,
+      height: ln.height,
+      rx: 2,
+      ry: 2,
+      class: "lt-dtree-decision"
+    }));
+    if (n.label) {
+      if (sibH) {
+        parts.push(text({
+          x: ln.x,
+          y: ln.y - ln.height / 2 - 8,
+          class: "lt-dtree-node-label",
+          "text-anchor": "middle"
+        }, n.label));
+      } else {
+        parts.push(text({
+          x: ln.x - ln.width / 2 - 8,
+          y: ln.y + 4,
+          class: "lt-dtree-node-label",
+          "text-anchor": "end"
+        }, n.label));
+      }
+    }
+    if (n.ev !== void 0) {
+      parts.push(text({
+        x: ln.x,
+        y: ln.y + ln.height / 2 + 13,
+        class: "lt-dtree-ev",
+        "text-anchor": "middle"
+      }, `EV=${formatNum(n.ev)}`));
+    }
+  } else if (n.kind === "chance") {
+    parts.push(circle({
+      cx: ln.x,
+      cy: ln.y,
+      r: ln.width / 2,
+      class: "lt-dtree-chance"
+    }));
+    if (n.label) {
+      if (sibH) {
+        parts.push(text({
+          x: ln.x,
+          y: ln.y - ln.height / 2 - 8,
+          class: "lt-dtree-node-label",
+          "text-anchor": "middle"
+        }, n.label));
+      } else {
+        parts.push(text({
+          x: ln.x,
+          y: ln.y - ln.height / 2 - 6,
+          class: "lt-dtree-node-label",
+          "text-anchor": "middle"
+        }, n.label));
+      }
+    }
+    if (n.ev !== void 0) {
+      parts.push(text({
+        x: ln.x,
+        y: ln.y + ln.height / 2 + 13,
+        class: n.optimal ? "lt-dtree-ev-optimal" : "lt-dtree-ev",
+        "text-anchor": "middle"
+      }, `EV=${formatNum(n.ev)}`));
+    }
+  } else if (n.kind === "end") {
+    const halfW = ln.width / 2;
+    const halfH = ln.height / 2;
+    const pts = [
+      `${ln.x - halfW},${ln.y - halfH}`,
+      `${ln.x + halfW},${ln.y}`,
+      `${ln.x - halfW},${ln.y + halfH}`
+    ].join(" ");
+    parts.push(polygon({ points: pts, class: "lt-dtree-outcome" }));
+    const colX = layout.payoffColumnX;
+    const tipX = ln.x + halfW;
+    const textY = ln.y + 4;
+    const payoffCls = n.payoff !== void 0 && n.payoff < 0 ? "lt-dtree-payoff-neg" : "lt-dtree-payoff";
+    const payoffStr = n.payoff !== void 0 ? formatPayoff(n.payoff) : "";
+    if (colX !== void 0 && colX > tipX + 20) {
+      parts.push(path({
+        d: `M ${tipX + 2} ${ln.y} L ${colX - 6} ${ln.y}`,
+        class: "lt-dtree-edge-leader"
+      }));
+      if (n.label) {
+        parts.push(text({
+          x: (tipX + colX) / 2,
+          y: ln.y - 6,
+          class: "lt-dtree-edge-label",
+          "text-anchor": "middle"
+        }, n.label));
+      }
+      if (payoffStr) {
+        parts.push(text({
+          x: colX,
+          y: textY,
+          class: payoffCls,
+          "text-anchor": "start"
+        }, payoffStr));
+      }
+    } else {
+      const labelParts = [];
+      if (payoffStr) labelParts.push(payoffStr);
+      if (n.label) labelParts.push(n.label);
+      if (labelParts.length > 0) {
+        parts.push(text({
+          x: tipX + 8,
+          y: textY,
+          class: payoffCls
+        }, labelParts.join(" \xB7 ")));
+      }
+    }
+  }
+  return group({
+    "data-node-id": n.id,
+    "data-node-kind": n.kind,
+    "data-ev": n.ev !== void 0 ? String(n.ev) : ""
+  }, parts);
+}
+function formatNum(n) {
+  if (Math.abs(n) >= 1e4) return n.toLocaleString(void 0, { maximumFractionDigits: 0 });
+  if (Number.isInteger(n)) return String(n);
+  return n.toFixed(2);
+}
+function formatPayoff(n) {
+  const abs = Math.abs(n);
+  const sign = n < 0 ? "-" : "";
+  if (abs >= 1e6) return `${sign}$${(abs / 1e6).toFixed(abs >= 1e7 ? 0 : 1)}M`;
+  if (abs >= 1e3) return `${sign}$${abs.toLocaleString()}`;
+  return String(n);
+}
+function classColor(i) {
+  return CLASS_PALETTE[i % CLASS_PALETTE.length];
+}
+function mlNodeFillColor(n) {
+  if (!Array.isArray(n.value)) return { fill: "#f1f5f9" };
+  const arr = n.value;
+  const sum = arr.reduce((a, b) => a + b, 0);
+  if (sum === 0) return { fill: "#f1f5f9" };
+  let maxIdx = 0;
+  for (let i = 1; i < arr.length; i++) if (arr[i] > arr[maxIdx]) maxIdx = i;
+  const purity = arr[maxIdx] / sum;
+  const nClasses = arr.length;
+  const minPurity = 1 / nClasses;
+  const alpha = Math.max(0.12, 0.12 + 0.8 * ((purity - minPurity) / (1 - minPurity)));
+  return { fill: hexWithAlpha(classColor(maxIdx), alpha) };
+}
+function hexWithAlpha(hex, alpha) {
+  return hex + Math.round(alpha * 255).toString(16).padStart(2, "0");
+}
+function renderMlNode(ln, ast) {
+  const n = ln.node;
+  const { fill } = mlNodeFillColor(n);
+  const parts = [];
+  const x = ln.x - ln.width / 2;
+  const y = ln.y - ln.height / 2;
+  parts.push(rect({
+    x,
+    y,
+    width: ln.width,
+    height: ln.height,
+    rx: 6,
+    ry: 6,
+    fill,
+    class: "lt-dtree-ml-rect"
+  }));
+  const textX = ln.x;
+  let textY = y + 16;
+  const lineH = 14;
+  if (n.kind === "split" && n.feature) {
+    const thresh = typeof n.threshold === "number" ? formatNum(n.threshold) : n.threshold ?? "";
+    parts.push(text(
+      { x: textX, y: textY, class: "lt-dtree-ml-line-1", "text-anchor": "middle" },
+      `${n.feature} ${n.op ?? ""} ${thresh}`
+    ));
+    textY += lineH;
+  } else if (n.label) {
+    parts.push(text({ x: textX, y: textY, class: "lt-dtree-ml-line-1", "text-anchor": "middle" }, n.label));
+    textY += lineH;
+  }
+  if (n.impurity !== void 0) {
+    const impName = ast.impurityName ?? "gini";
+    parts.push(text(
+      { x: textX, y: textY, class: "lt-dtree-ml-line-muted", "text-anchor": "middle" },
+      `${impName} = ${formatNum(n.impurity)}`
+    ));
+    textY += lineH;
+  }
+  if (n.samples !== void 0) {
+    parts.push(text(
+      { x: textX, y: textY, class: "lt-dtree-ml-line-muted", "text-anchor": "middle" },
+      `samples = ${n.samples}`
+    ));
+    textY += lineH;
+  }
+  if (n.value !== void 0) {
+    const vStr = Array.isArray(n.value) ? `value = [${n.value.join(", ")}]` : `value = ${formatNum(n.value)}`;
+    parts.push(text({ x: textX, y: textY, class: "lt-dtree-ml-mono", "text-anchor": "middle" }, vStr));
+    textY += lineH;
+  }
+  if (n.className) {
+    let colorIdx = 0;
+    if (ast.classes) {
+      const idx = ast.classes.indexOf(n.className);
+      if (idx >= 0) colorIdx = idx;
+    }
+    parts.push(text(
+      { x: textX, y: textY, class: "lt-dtree-ml-class", "text-anchor": "middle", fill: classColor(colorIdx) },
+      `class = ${n.className}`
+    ));
+    textY += lineH;
+  } else if (typeof n.value === "number") {
+    parts.push(text(
+      { x: textX, y: textY, class: "lt-dtree-ml-class", "text-anchor": "middle", fill: "#0f172a" },
+      `predicted = ${formatNum(n.value)}`
+    ));
+    textY += lineH;
+  }
+  if (Array.isArray(n.value) && ast.classes) {
+    const arr = n.value;
+    const sum = arr.reduce((a, b) => a + b, 0);
+    if (sum > 0) {
+      const barY = y + ln.height - 10;
+      const barX = x + 10;
+      const barW = ln.width - 20;
+      let cursor = barX;
+      for (let i = 0; i < arr.length; i++) {
+        const seg = arr[i] / sum * barW;
+        if (seg > 0) {
+          parts.push(rect({ x: cursor, y: barY, width: seg, height: 5, fill: classColor(i), stroke: "none" }));
+        }
+        cursor += seg;
+      }
+    }
+  }
+  return group({
+    "data-node-id": n.id,
+    "data-node-kind": n.kind,
+    "data-samples": n.samples !== void 0 ? String(n.samples) : "",
+    "data-class": n.className ?? ""
+  }, parts);
+}
+function renderTaxonomyNode(ln) {
+  const n = ln.node;
+  const isLeaf = n.kind === "answer" || n.children.length === 0;
+  const cls = isLeaf ? "lt-dtree-taxon-leaf" : "lt-dtree-taxon";
+  const parts = [];
+  parts.push(rect({
+    x: ln.x - ln.width / 2,
+    y: ln.y - ln.height / 2,
+    width: ln.width,
+    height: ln.height,
+    rx: 8,
+    ry: 8,
+    class: cls
+  }));
+  const lines = wrapText(n.label, 22);
+  const totalH = lines.length * 14;
+  let ty = ln.y - totalH / 2 + 11;
+  for (const line2 of lines) {
+    parts.push(text({ x: ln.x, y: ty, class: "lt-dtree-taxon-label" }, line2));
+    ty += 14;
+  }
+  return group({
+    "data-node-id": n.id,
+    "data-node-kind": n.kind,
+    "data-leaf": isLeaf ? "true" : "false"
+  }, parts);
+}
+function wrapText(text2, maxChars) {
+  if (text2.length <= maxChars) return [text2];
+  const words = text2.split(/\s+/);
+  const lines = [];
+  let cur = "";
+  for (const w of words) {
+    if (!cur) cur = w;
+    else if ((cur + " " + w).length > maxChars) {
+      lines.push(cur);
+      cur = w;
+    } else cur = cur + " " + w;
+    if (lines.length >= 1 && cur.length >= maxChars) {
+      lines.push(cur);
+      cur = "";
+      break;
+    }
+  }
+  if (cur) lines.push(cur);
+  return lines.slice(0, 2);
+}
+function renderDecisionTree(ast, config) {
+  const t = resolveBaseTheme(config?.theme ?? "default");
+  const layout = layoutDecisionTree(ast);
+  const titleOffset = ast.title ? 36 : 10;
+  const width = Math.ceil(layout.width);
+  const height = Math.ceil(layout.height + titleOffset);
+  const children = [];
+  children.push(title(ast.title ?? "Decision Tree"));
+  children.push(desc(`Decision tree (${ast.mode} mode) with ${layout.nodes.length} nodes and ${layout.edges.length} edges`));
+  children.push(el("style", {}, buildCss(t)));
+  if (ast.title) {
+    children.push(text({ x: 20, y: 24, class: "lt-dtree-title" }, ast.title));
+  }
+  const inner = [];
+  for (const e of layout.edges) {
+    const cls = e.isOptimal ? "lt-dtree-edge-optimal" : "lt-dtree-edge";
+    const attrs = { d: e.path, class: cls, "data-edge": `${e.from}->${e.to}` };
+    if (e.strokeWidth !== void 0 && !e.isOptimal) attrs["stroke-width"] = e.strokeWidth;
+    inner.push(path(attrs));
+  }
+  const anchors = layout.labelAnchors ?? {};
+  for (const e of layout.edges) {
+    if (!e.label) continue;
+    const a = anchors[e.to];
+    if (!a) continue;
+    const isProb = ast.mode === "decision" && /^p=/i.test(e.label);
+    const labelClass = isProb ? "lt-dtree-edge-prob" : "lt-dtree-edge-label";
+    let lx = a.x;
+    let ly = a.y;
+    const absAngle = Math.abs(a.angle);
+    const perpOffset = layout.edgeStyle === "diagonal" || layout.edgeStyle === "bracket" ? 9 : 0;
+    if (perpOffset > 0 && absAngle > 1 && absAngle < 89) {
+      const rad = a.angle * Math.PI / 180;
+      const nx = -Math.sin(rad);
+      const ny = Math.cos(rad);
+      const flip = ny < 0 ? -1 : 1;
+      lx += nx * perpOffset * flip;
+      ly += ny * perpOffset * flip;
+    }
+    const charW = isProb ? 5.5 : 6.2;
+    const w = Math.max(e.label.length * charW + 10, 18);
+    const h = 14;
+    inner.push(rect({
+      x: lx - w / 2,
+      y: ly - h / 2,
+      width: w,
+      height: h,
+      class: "lt-dtree-edge-label-bg",
+      rx: 3,
+      ry: 3
+    }));
+    inner.push(text({ x: lx, y: ly, class: labelClass }, e.label));
+  }
+  for (const ln of layout.nodes) {
+    if (ast.mode === "decision") inner.push(renderDecisionNode(ln, layout));
+    else if (ast.mode === "ml") inner.push(renderMlNode(ln, ast));
+    else inner.push(renderTaxonomyNode(ln));
+  }
+  children.push(group({ transform: `translate(0, ${titleOffset})`, "data-mode": ast.mode }, inner));
+  return svgRoot({
+    class: "lt-dtree",
+    role: "img",
+    "aria-label": escapeXml(ast.title ?? `Decision tree (${ast.mode})`),
+    width,
+    height,
+    viewBox: `0 0 ${width} ${height}`
+  }, children);
+}
+
+// src/diagrams/decisiontree/index.ts
+var decisiontree = {
+  type: "decisiontree",
+  detect(text2) {
+    return /^\s*decisiontree\b/i.test(text2);
+  },
+  parse: parseDecisionTree,
+  render(text2, config) {
+    const ast = parseDecisionTree(text2);
+    return renderDecisionTree(ast, config);
+  }
+};
+
+// src/diagrams/timeline/dates.ts
+function parseDate(raw) {
+  const s = raw.trim();
+  const mGeo = /^(-?\d+(?:\.\d+)?)\s*(Ma|Ga|ka)$/i.exec(s);
+  if (mGeo) {
+    const n = parseFloat(mGeo[1]);
+    const unit = mGeo[2].toLowerCase();
+    const mult = unit === "ga" ? 1e9 : unit === "ma" ? 1e6 : 1e3;
+    return {
+      value: 1970 - n * mult,
+      raw: s,
+      precision: "ma"
+    };
+  }
+  const mBC = /^(\d+)\s*(BC|BCE)$/i.exec(s);
+  if (mBC) {
+    return { value: -parseInt(mBC[1], 10), raw: s, precision: "year" };
+  }
+  const mIso = /^(-?\d{1,5})-(\d{1,2})-(\d{1,2})$/.exec(s);
+  if (mIso) {
+    const y = parseInt(mIso[1], 10);
+    const mo = parseInt(mIso[2], 10);
+    const d = parseInt(mIso[3], 10);
+    return {
+      value: y + (dayOfYear(y, mo, d) - 1) / daysInYear(y),
+      raw: s,
+      precision: "day"
+    };
+  }
+  const mYm = /^(-?\d{1,5})-(\d{1,2})$/.exec(s);
+  if (mYm) {
+    const y = parseInt(mYm[1], 10);
+    const mo = parseInt(mYm[2], 10);
+    return {
+      value: y + (mo - 1) / 12,
+      raw: s,
+      precision: "month"
+    };
+  }
+  const mYq = /^(-?\d{1,5})-?Q([1-4])$/i.exec(s);
+  if (mYq) {
+    const y = parseInt(mYq[1], 10);
+    const q = parseInt(mYq[2], 10);
+    return { value: y + (q - 1) * 0.25, raw: s, precision: "month" };
+  }
+  const mY = /^(-?\d+)$/.exec(s);
+  if (mY) {
+    return { value: parseInt(mY[1], 10), raw: s, precision: "year" };
+  }
+  throw new Error(`Cannot parse date: "${raw}"`);
+}
+function daysInYear(y) {
+  const leap = y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+  return leap ? 366 : 365;
+}
+function dayOfYear(y, m, d) {
+  const dim = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (y % 4 === 0 && y % 100 !== 0 || y % 400 === 0) dim[1] = 29;
+  let total = d;
+  for (let i = 0; i < m - 1; i++) total += dim[i];
+  return total;
+}
+function formatYear(value, span) {
+  const y = Math.round(value);
+  if (span >= 2e6) return `${Math.round((1970 - value) / 1e6)} Ma`;
+  if (span >= 2e3) return y < 0 ? `${-y} BC` : `${y}`;
+  if (span >= 50) return y < 0 ? `${-y} BC` : `${y}`;
+  return y < 0 ? `${-y} BC` : `${y}`;
+}
+
+// src/diagrams/timeline/parser.ts
+var TimelineParseError = class extends Error {
+  constructor(message, line2) {
+    super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
+    this.line = line2;
+    this.name = "TimelineParseError";
+  }
+  line;
+};
+function preprocess2(src) {
+  const out = [];
+  const lines = src.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw === void 0) continue;
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#") || trimmed.startsWith("//")) continue;
+    const spaces = raw.length - raw.replace(/^\s+/, "").length;
+    out.push({ indent: Math.floor(spaces / 2), text: trimmed, line: i + 1 });
+  }
+  return out;
+}
+function readQuoted(s, lineNum) {
+  const t = s.trimStart();
+  if (!t.startsWith('"')) {
+    throw new TimelineParseError(`Expected quoted string, got: ${s}`, lineNum);
+  }
+  const end = t.indexOf('"', 1);
+  if (end < 0) throw new TimelineParseError(`Unterminated string: ${s}`, lineNum);
+  return [t.slice(1, end), t.slice(end + 1)];
+}
+function parseProperties(s, lineNum) {
+  const t = s.trimEnd();
+  if (!t.endsWith("]")) return { props: {}, rest: s };
+  const open = t.lastIndexOf("[");
+  if (open < 0) return { props: {}, rest: s };
+  const inner = t.slice(open + 1, -1);
+  const props = {};
+  const parts = splitTopLevel(inner, ",");
+  for (const p of parts) {
+    const pt = p.trim();
+    if (!pt) continue;
+    const idx = pt.indexOf(":");
+    if (idx < 0) {
+      throw new TimelineParseError(`Invalid property (missing ':'): ${pt}`, lineNum);
+    }
+    const k = pt.slice(0, idx).trim();
+    let v = pt.slice(idx + 1).trim();
+    if (v.startsWith('"') && v.endsWith('"')) v = v.slice(1, -1);
+    props[k] = v;
+  }
+  return { props, rest: t.slice(0, open).trimEnd() };
+}
+function splitTopLevel(s, sep) {
+  const out = [];
+  let depth = 0;
+  let inQuote = false;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"') inQuote = !inQuote;
+    if (inQuote) continue;
+    if (ch === "[" || ch === "(") depth++;
+    else if (ch === "]" || ch === ")") depth--;
+    else if (ch === sep && depth === 0) {
+      out.push(s.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(s.slice(start));
+  return out;
+}
+function splitDateAndBody(s, lineNum) {
+  let inQuote = false;
+  let colon = -1;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"') inQuote = !inQuote;
+    if (inQuote) continue;
+    if (c === ":") {
+      colon = i;
+      break;
+    }
+  }
+  if (colon < 0) throw new TimelineParseError(`Expected ':' after date: ${s}`, lineNum);
+  const datePart = s.slice(0, colon).trim();
+  const body = s.slice(colon + 1).trim();
+  const dd = datePart.indexOf("..");
+  if (dd > 0) {
+    return {
+      date: datePart.slice(0, dd).trim(),
+      end: datePart.slice(dd + 2).trim(),
+      body
+    };
+  }
+  const mDash = / - /.exec(datePart);
+  if (mDash && mDash.index > 0) {
+    return {
+      date: datePart.slice(0, mDash.index).trim(),
+      end: datePart.slice(mDash.index + 3).trim(),
+      body
+    };
+  }
+  return { date: datePart, body };
+}
+function parseTimeline(src) {
+  const lines = preprocess2(src);
+  if (!lines.length) throw new TimelineParseError("Empty timeline");
+  const ast = {
+    type: "timeline",
+    title: void 0,
+    style: "swimlane",
+    orientation: "horizontal",
+    scale: "proportional",
+    axis: "bottom",
+    events: [],
+    eras: [],
+    tracks: []
+  };
+  let i = 0;
+  let autoId = 0;
+  const nextId2 = (prefix) => `${prefix}-${++autoId}`;
+  const first = lines[0];
+  if (/^timeline\b/i.test(first.text)) {
+    const rest = first.text.replace(/^timeline\b/i, "").trim();
+    if (rest) {
+      if (rest.startsWith('"')) {
+        const [title2] = readQuoted(rest, first.line);
+        ast.title = title2;
+      } else {
+        ast.title = rest;
+      }
+    }
+    i = 1;
+  }
+  while (i < lines.length) {
+    const L = lines[i];
+    const text2 = L.text;
+    if (/^config\s*:/i.test(text2)) {
+      const body = text2.replace(/^config\s*:\s*/i, "");
+      const eq = body.indexOf("=");
+      if (eq < 0) throw new TimelineParseError(`Expected 'key = value' in config: ${text2}`, L.line);
+      const k = body.slice(0, eq).trim();
+      const v = body.slice(eq + 1).trim();
+      applyConfig(ast, k, v, L.line);
+      i++;
+      continue;
+    }
+    if (/^era\b/i.test(text2)) {
+      const body = text2.replace(/^era\s+/i, "");
+      const { props, rest } = parseProperties(body, L.line);
+      const { date, end, body: labelPart } = splitDateAndBody(rest, L.line);
+      if (!end) throw new TimelineParseError(`era requires a date range: ${text2}`, L.line);
+      const [label] = readQuoted(labelPart, L.line);
+      const era = {
+        id: nextId2("era"),
+        label,
+        start: safeParseDate(date, L.line),
+        end: safeParseDate(end, L.line),
+        color: props["color"]
+      };
+      ast.eras.push(era);
+      i++;
+      continue;
+    }
+    if (/^track\b/i.test(text2)) {
+      const body = text2.replace(/^track\s+/i, "");
+      const [name, restAfter] = readQuoted(body, L.line);
+      if (!restAfter.trim().startsWith(":")) {
+        throw new TimelineParseError(`Expected ':' after track name`, L.line);
+      }
+      const trackId = nextId2("track");
+      ast.tracks.push({ id: trackId, label: name });
+      i++;
+      while (i < lines.length && lines[i].indent > L.indent) {
+        const child = lines[i];
+        if (/^note\s*:/i.test(child.text)) {
+          i++;
+          continue;
+        }
+        const parsed2 = parseEventLine(child.text, child.line, nextId2);
+        if (!parsed2) throw new TimelineParseError(`Unrecognized line in track: ${child.text}`, child.line);
+        parsed2.event.trackId = trackId;
+        ast.events.push(parsed2.event);
+        i++;
+        if (i < lines.length && /^note\s*:/i.test(lines[i].text) && lines[i].indent > child.indent) {
+          const noteBody = lines[i].text.replace(/^note\s*:\s*/i, "");
+          const [note] = readQuoted(noteBody, lines[i].line);
+          parsed2.event.note = note;
+          i++;
+        }
+      }
+      continue;
+    }
+    const parsed = parseEventLine(text2, L.line, nextId2);
+    if (parsed) {
+      ast.events.push(parsed.event);
+      i++;
+      if (i < lines.length && /^note\s*:/i.test(lines[i].text) && lines[i].indent > L.indent) {
+        const noteBody = lines[i].text.replace(/^note\s*:\s*/i, "");
+        const [note] = readQuoted(noteBody, lines[i].line);
+        parsed.event.note = note;
+        i++;
+      }
+      continue;
+    }
+    throw new TimelineParseError(`Unrecognized line: ${text2}`, L.line);
+  }
+  return ast;
+}
+function safeParseDate(raw, line2) {
+  try {
+    return parseDate(raw);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new TimelineParseError(msg, line2);
+  }
+}
+function applyConfig(ast, k, v, line2) {
+  switch (k) {
+    case "style": {
+      const normalized = v === "gantt-project" ? "gantt" : v;
+      if (normalized !== "swimlane" && normalized !== "gantt" && normalized !== "lollipop") {
+        throw new TimelineParseError(`Invalid style: ${v}`, line2);
+      }
+      ast.style = normalized;
+      break;
+    }
+    case "orientation":
+      if (v !== "horizontal" && v !== "vertical") {
+        throw new TimelineParseError(`Invalid orientation: ${v}`, line2);
+      }
+      ast.orientation = v;
+      break;
+    case "scale":
+      if (v !== "proportional" && v !== "equidistant" && v !== "log") {
+        throw new TimelineParseError(`Invalid scale: ${v}`, line2);
+      }
+      ast.scale = v;
+      break;
+    case "axis":
+      if (v !== "bottom" && v !== "center") {
+        throw new TimelineParseError(`Invalid axis: ${v}`, line2);
+      }
+      ast.axis = v;
+      break;
+    default:
+      (ast.metadata ??= {})[k] = v;
+  }
+}
+function parseEventLine(text2, line2, nextId2) {
+  const { props, rest } = parseProperties(text2, line2);
+  const { date, end, body } = splitDateAndBody(rest, line2);
+  let kind = end ? "range" : "point";
+  let bodyS = body.trim();
+  if (/^milestone\b/i.test(bodyS)) {
+    kind = "milestone";
+    bodyS = bodyS.replace(/^milestone\s+/i, "");
+  }
+  if (!bodyS.startsWith('"')) return null;
+  const [label] = readQuoted(bodyS, line2);
+  const sideRaw = props["side"];
+  const side = sideRaw === "above" || sideRaw === "below" ? sideRaw : void 0;
+  const ev = {
+    id: nextId2("ev"),
+    label,
+    kind,
+    start: safeParseDate(date, line2),
+    end: end ? safeParseDate(end, line2) : void 0,
+    icon: props["icon"],
+    shape: props["shape"],
+    color: props["color"],
+    category: props["category"],
+    side
+  };
+  return { event: ev, hasNote: false };
+}
+
+// src/diagrams/timeline/layout.ts
+var CANVAS_WIDTH = 960;
+var PAD_LEFT_WITH_TRACKS = 140;
+var PAD_LEFT_NO_TRACKS = 40;
+var PAD_RIGHT = 40;
+var PAD_TOP_BASE = 40;
+var ERA_BAND_HEIGHT = 16;
+var AXIS_HEIGHT = 40;
+var LANE_HEIGHT_RANGE = 36;
+var LANE_HEIGHT_POINT = 28;
+var LANE_GAP = 8;
+var DEFAULT_CATEGORY_PALETTE = [
+  "#2563eb",
+  "#059669",
+  "#d97706",
+  "#7c3aed",
+  "#dc2626",
+  "#0891b2",
+  "#db2777",
+  "#475569"
+];
+function layoutTimeline(ast) {
+  switch (ast.style) {
+    case "gantt":
+      return layoutGantt(ast);
+    case "lollipop":
+      return layoutLollipop(ast);
+    case "swimlane":
+    default:
+      return layoutSwimlane(ast);
+  }
+}
+function timeExtent(ast) {
+  const starts = [
+    ...ast.events.map((e) => e.start.value),
+    ...ast.eras.map((e) => e.start.value)
+  ];
+  const ends = [
+    ...ast.events.map((e) => e.end?.value ?? e.start.value),
+    ...ast.eras.map((e) => e.end.value)
+  ];
+  if (!starts.length) return { min: 0, max: 1, span: 1 };
+  const min = Math.min(...starts);
+  const max = Math.max(...ends);
+  const span = max - min || 1;
+  return { min, max, span };
+}
+function buildScale(mode, events, tMin, tMax, plotX, plotW) {
+  if (mode === "equidistant") {
+    const sorted = events.slice().sort((a, b) => a.start.value - b.start.value);
+    const n = sorted.length || 1;
+    const indexByValue = /* @__PURE__ */ new Map();
+    sorted.forEach((e, i) => indexByValue.set(e.start.value, i));
+    return (v) => {
+      const idx = indexByValue.get(v);
+      if (idx !== void 0) {
+        return plotX + (n === 1 ? plotW / 2 : idx / (n - 1) * plotW);
+      }
+      return plotX + (v - tMin) / (tMax - tMin) * plotW;
+    };
+  }
+  if (mode === "log") {
+    const now = Math.max(tMax, 0);
+    const toAgo = (v) => Math.max(1, now - v + 1);
+    const minAgo = toAgo(tMax);
+    const maxAgo = toAgo(tMin);
+    const logMin = Math.log10(minAgo);
+    const logMax = Math.log10(maxAgo);
+    const range = logMax - logMin || 1;
+    return (v) => {
+      const frac = (logMax - Math.log10(toAgo(v))) / range;
+      return plotX + frac * plotW;
+    };
+  }
+  const span = tMax - tMin || 1;
+  return (v) => plotX + (v - tMin) / span * plotW;
+}
+function packEraRows(eras) {
+  if (!eras.length) return { rows: 0, rowOf: [] };
+  const rowsEnd = [];
+  const rowOf = [];
+  for (const e of eras) {
+    let placed = -1;
+    for (let i = 0; i < rowsEnd.length; i++) {
+      if (rowsEnd[i] <= e.start.value) {
+        placed = i;
+        break;
+      }
+    }
+    if (placed < 0) {
+      rowsEnd.push(e.end.value);
+      placed = rowsEnd.length - 1;
+    } else {
+      rowsEnd[placed] = e.end.value;
+    }
+    rowOf.push(placed);
+  }
+  return { rows: rowsEnd.length, rowOf };
+}
+function generateTicks(tMin, tMax, span, xScale, mode) {
+  const ticks = [];
+  if (mode === "log") {
+    const now = Math.max(tMax, 0);
+    const minAgo = Math.max(1, now - tMax + 1);
+    const maxAgo = Math.max(1, now - tMin + 1);
+    const logMin = Math.floor(Math.log10(minAgo));
+    const logMax = Math.ceil(Math.log10(maxAgo));
+    for (let p = logMin; p <= logMax; p++) {
+      const ago = Math.pow(10, p);
+      const v = now - ago;
+      if (v < tMin || v > tMax) continue;
+      const label = ago >= 1e6 ? `${ago / 1e6} Ma` : ago >= 1e3 ? `${ago / 1e3} ka` : `${ago} yr`;
+      ticks.push({ value: v, x: xScale(v), label, major: true });
+    }
+    return ticks;
+  }
+  const step = niceStep(span);
+  const start = Math.ceil(tMin / step) * step;
+  for (let v = start; v <= tMax; v += step) {
+    ticks.push({ value: v, x: xScale(v), label: formatYear(v, span), major: true });
+  }
+  return ticks;
+}
+function niceStep(span) {
+  const candidates = [
+    0.01,
+    0.02,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2,
+    5,
+    10,
+    20,
+    25,
+    50,
+    100,
+    200,
+    500,
+    1e3,
+    2e3,
+    5e3,
+    1e4,
+    5e4,
+    1e5,
+    5e5,
+    1e6
+  ];
+  for (const c of candidates) {
+    if (span / c <= 10) return c;
+  }
+  return Math.pow(10, Math.ceil(Math.log10(span / 10)));
+}
+function estimateLabelWidth(label, icon) {
+  const iconW = icon ? 14 : 0;
+  return 6.5 * label.length + iconW + 4;
+}
+function layoutSwimlane(ast) {
+  const events = ast.events.slice().sort((a, b) => a.start.value - b.start.value);
+  const allTracks = resolveTracks(ast, events);
+  assignAutoTracks(events, allTracks);
+  const { min: startVal, max: endVal, span } = timeExtent(ast);
+  const paddedStart = startVal - span * 0.02;
+  const paddedEnd = endVal + span * 0.02;
+  const hasNamedTracks = ast.tracks.length > 0;
+  const plotX = hasNamedTracks ? PAD_LEFT_WITH_TRACKS : PAD_LEFT_NO_TRACKS;
+  const plotRight = CANVAS_WIDTH - PAD_RIGHT;
+  const plotW = plotRight - plotX;
+  const xScale = buildScale(ast.scale, events, paddedStart, paddedEnd, plotX, plotW);
+  const eraRows = packEraRows(ast.eras);
+  const eraBandTotal = eraRows.rows * (ERA_BAND_HEIGHT + 2);
+  const titleOffset = ast.title ? 28 : 0;
+  const plotY = PAD_TOP_BASE + titleOffset + eraBandTotal;
+  const lanes = [];
+  let cursorY = plotY + 8;
+  for (const t of allTracks) {
+    const hasRange = events.some((e) => e.trackId === t.id && e.kind === "range");
+    const h = hasRange ? LANE_HEIGHT_RANGE : LANE_HEIGHT_POINT;
+    lanes.push({ trackId: t.id, label: t.label, y: cursorY, height: h });
+    cursorY += h + LANE_GAP;
+  }
+  const plotH = cursorY - plotY;
+  const axisY = cursorY + 4;
+  const height = axisY + AXIS_HEIGHT + 20;
+  const eraLayouts = ast.eras.map((e, idx) => ({
+    era: e,
+    x: xScale(e.start.value),
+    width: Math.max(2, xScale(e.end.value) - xScale(e.start.value)),
+    bandRow: eraRows.rowOf[idx]
+  }));
+  const laneByTrack = new Map(lanes.map((l) => [l.trackId, l]));
+  const eventLayouts = [];
+  const labelBoxes = [];
+  for (const ev of events) {
+    const lane = laneByTrack.get(ev.trackId);
+    if (!lane) continue;
+    if (ev.kind === "range") {
+      const x = xScale(ev.start.value);
+      const xe = xScale(ev.end.value);
+      const w = Math.max(4, xe - x);
+      eventLayouts.push({
+        event: ev,
+        x,
+        w,
+        y: lane.y + 6,
+        h: lane.height - 12,
+        labelX: x + w / 2,
+        labelY: lane.y + lane.height / 2 + 4,
+        labelAnchor: "middle"
+      });
+    } else {
+      const x = xScale(ev.start.value);
+      const cy = lane.y + lane.height / 2;
+      const labelW = estimateLabelWidth(ev.label, ev.icon);
+      const candidates = [
+        cy - 14,
+        cy + 18,
+        cy - 28,
+        cy + 32,
+        cy - 42,
+        cy + 46,
+        cy - 56,
+        cy + 60
+      ];
+      let labelY = candidates[0];
+      for (const y of candidates) {
+        const box = { x1: x - labelW / 2, x2: x + labelW / 2, y };
+        const collide = labelBoxes.some((b) => Math.abs(b.y - box.y) < 13 && b.x1 < box.x2 && b.x2 > box.x1);
+        if (!collide) {
+          labelY = y;
+          labelBoxes.push(box);
+          break;
+        }
+      }
+      eventLayouts.push({
+        event: ev,
+        x,
+        y: cy,
+        h: LANE_HEIGHT_POINT,
+        labelX: x,
+        labelY,
+        labelAnchor: "middle",
+        noteX: ev.note ? x + 12 : void 0,
+        noteY: ev.note ? cy + 16 : void 0
+      });
+    }
+  }
+  return {
+    width: CANVAS_WIDTH,
+    height,
+    style: "swimlane",
+    plotX,
+    plotY,
+    plotW,
+    plotH,
+    lanes,
+    events: eventLayouts,
+    eras: eraLayouts,
+    ticks: generateTicks(paddedStart, paddedEnd, span, xScale, ast.scale).filter((t) => t.x >= plotX - 2 && t.x <= plotX + plotW + 2),
+    axisY,
+    title: ast.title
+  };
+}
+function resolveTracks(ast, events) {
+  const namedIds = new Set(ast.tracks.map((t) => t.id));
+  const tracks = ast.tracks.slice();
+  for (const ev of events) {
+    if (ev.trackId && !namedIds.has(ev.trackId)) {
+      ev.trackId = void 0;
+    }
+  }
+  return tracks;
+}
+function assignAutoTracks(events, tracks) {
+  const unassigned = events.filter((e) => !e.trackId);
+  if (unassigned.length === 0) return;
+  const pointsOnly = unassigned.every((e) => e.kind !== "range");
+  if (pointsOnly) {
+    let lane = tracks.find((t) => t.id === "__auto_points__");
+    if (!lane) {
+      lane = { id: "__auto_points__", label: "" };
+      tracks.push(lane);
+    }
+    for (const ev of unassigned) ev.trackId = lane.id;
+    return;
+  }
+  const packed = [];
+  const pointLane = { id: "__auto_points__", label: "" };
+  const pointEvents = [];
+  for (const ev of unassigned) {
+    if (ev.kind !== "range") {
+      pointEvents.push(ev);
+      continue;
+    }
+    let placed = false;
+    for (const lane of packed) {
+      if (ev.start.value >= lane.endX) {
+        ev.trackId = lane.id;
+        lane.endX = ev.end.value;
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      const id = `__auto_${packed.length}__`;
+      tracks.push({ id, label: "" });
+      packed.push({ id, endX: ev.end.value });
+      ev.trackId = id;
+    }
+  }
+  if (pointEvents.length) {
+    tracks.push(pointLane);
+    for (const ev of pointEvents) ev.trackId = pointLane.id;
+  }
+}
+var GANTT_PIN_ZONE = 70;
+var GANTT_LANE_H = 30;
+var GANTT_LEGEND_W = 140;
+function layoutGantt(ast) {
+  const events = ast.events.slice().sort((a, b) => a.start.value - b.start.value);
+  const { min: startVal, max: endVal, span } = timeExtent(ast);
+  const padSpan = span * 0.03;
+  const paddedStart = startVal - padSpan;
+  const paddedEnd = endVal + padSpan;
+  const categories = [];
+  const catSeen = /* @__PURE__ */ new Set();
+  for (const ev of events) {
+    const c = ev.category ?? (ev.kind === "range" ? ast.tracks.find((t) => t.id === ev.trackId)?.label : void 0);
+    if (c && !catSeen.has(c)) {
+      catSeen.add(c);
+      categories.push(c);
+    }
+  }
+  if (!categories.length && events.some((e) => e.kind === "range")) {
+    categories.push("Tasks");
+  }
+  const hasLegend = categories.length > 0;
+  const plotX = hasLegend ? PAD_LEFT_WITH_TRACKS - 20 : PAD_LEFT_NO_TRACKS;
+  const plotRight = CANVAS_WIDTH - (hasLegend ? GANTT_LEGEND_W + 20 : PAD_RIGHT);
+  const plotW = plotRight - plotX;
+  const xScale = buildScale(ast.scale, events, paddedStart, paddedEnd, plotX, plotW);
+  const eraRows = packEraRows(ast.eras);
+  const eraBandTotal = eraRows.rows * (ERA_BAND_HEIGHT + 2);
+  const titleOffset = ast.title ? 28 : 0;
+  const pinZoneTop = PAD_TOP_BASE + titleOffset + eraBandTotal;
+  const pinZoneBottom = pinZoneTop + GANTT_PIN_ZONE;
+  const axisY = pinZoneBottom;
+  const lanes = categories.map((c, i) => ({
+    trackId: `__cat_${i}__`,
+    label: c,
+    y: axisY + 14 + i * GANTT_LANE_H,
+    height: GANTT_LANE_H - 8
+  }));
+  const plotY = pinZoneTop;
+  const plotH = lanes.length ? lanes[lanes.length - 1].y + lanes[lanes.length - 1].height - plotY : GANTT_PIN_ZONE;
+  const height = lanes.length ? lanes[lanes.length - 1].y + lanes[lanes.length - 1].height + 40 : axisY + 60;
+  const palette = DEFAULT_CATEGORY_PALETTE;
+  const colorFor = (cat) => {
+    if (!cat) return palette[0];
+    const idx = categories.indexOf(cat);
+    return palette[(idx < 0 ? 0 : idx) % palette.length];
+  };
+  const laneByCat = new Map(lanes.map((l) => [l.label, l]));
+  const pins = [];
+  const eventLayouts = [];
+  const pinBoxes = [];
+  for (const ev of events) {
+    if (ev.kind === "range") {
+      const cat = ev.category ?? "Tasks";
+      const lane = laneByCat.get(cat) ?? lanes[0];
+      if (!lane) continue;
+      const x2 = xScale(ev.start.value);
+      const xe = xScale(ev.end.value);
+      const w = Math.max(4, xe - x2);
+      eventLayouts.push({
+        event: ev,
+        x: x2,
+        w,
+        y: lane.y + 4,
+        h: lane.height - 8,
+        labelX: x2 + w / 2,
+        labelY: lane.y + lane.height / 2 + 4,
+        labelAnchor: "middle"
+      });
+      continue;
+    }
+    const x = xScale(ev.start.value);
+    const labelW = estimateLabelWidth(ev.label, ev.icon);
+    let labelY = pinZoneTop + 12;
+    let step = 0;
+    while (step < 4) {
+      const box = { x1: x - labelW / 2, x2: x + labelW / 2, y: labelY };
+      const collide = pinBoxes.some((b) => Math.abs(b.y - box.y) < 14 && b.x1 < box.x2 && b.x2 > box.x1);
+      if (!collide) {
+        pinBoxes.push(box);
+        break;
+      }
+      labelY += 16;
+      step++;
+    }
+    pins.push({
+      event: ev,
+      x,
+      labelY,
+      axisY,
+      color: colorFor(ev.category)
+    });
+  }
+  const eraLayouts = ast.eras.map((e, idx) => ({
+    era: e,
+    x: xScale(e.start.value),
+    width: Math.max(2, xScale(e.end.value) - xScale(e.start.value)),
+    bandRow: eraRows.rowOf[idx]
+  }));
+  const legend = categories.map((c) => ({ label: c, color: colorFor(c) }));
+  return {
+    width: CANVAS_WIDTH,
+    height,
+    style: "gantt",
+    plotX,
+    plotY,
+    plotW,
+    plotH,
+    lanes,
+    events: eventLayouts,
+    eras: eraLayouts,
+    ticks: generateTicks(paddedStart, paddedEnd, span, xScale, ast.scale).filter((t) => t.x >= plotX - 2 && t.x <= plotX + plotW + 2),
+    axisY,
+    title: ast.title,
+    pins,
+    legend: hasLegend ? legend : void 0
+  };
+}
+var LOLLIPOP_CARD_W = 180;
+var LOLLIPOP_CARD_H = 54;
+var LOLLIPOP_STEM_BASE = 26;
+var LOLLIPOP_STEM_STACK = 18;
+function layoutLollipop(ast) {
+  const events = ast.events.slice().sort((a, b) => a.start.value - b.start.value);
+  const eStarts = events.map((e) => e.start.value);
+  const eEnds = events.map((e) => e.end?.value ?? e.start.value);
+  const eStart = eStarts.length ? Math.min(...eStarts) : 0;
+  const eEnd = eEnds.length ? Math.max(...eEnds) : 1;
+  const span = Math.max(1e-9, eEnd - eStart);
+  const padSpan = span * 0.02;
+  const paddedStart = eStart - padSpan;
+  const paddedEnd = eEnd + padSpan;
+  const plotX = PAD_LEFT_NO_TRACKS + 20;
+  const plotRight = CANVAS_WIDTH - PAD_RIGHT - 20;
+  const plotW = plotRight - plotX;
+  const CARD_HALF = LOLLIPOP_CARD_W / 2;
+  const axisInset = CARD_HALF + 8;
+  const axisStart = plotX + axisInset;
+  const axisEnd = plotRight - axisInset;
+  const axisW = Math.max(1, axisEnd - axisStart);
+  const rawScale = buildScale(ast.scale, events, paddedStart, paddedEnd, axisStart, axisW);
+  const xScale = (v) => Math.max(plotX, Math.min(plotRight, rawScale(v)));
+  const eraRows = packEraRows(ast.eras);
+  const eraBandTotal = eraRows.rows * (ERA_BAND_HEIGHT + 2);
+  const titleOffset = ast.title ? 28 : 0;
+  const plotY = PAD_TOP_BASE + titleOffset + eraBandTotal;
+  const cards = [];
+  let alt = "above";
+  const palette = DEFAULT_CATEGORY_PALETTE;
+  const aboveRows = [];
+  const belowRows = [];
+  for (let i = 0; i < events.length; i++) {
+    const ev = events[i];
+    if (ev.kind === "range") continue;
+    const side = ev.side ?? alt;
+    if (!ev.side) alt = alt === "above" ? "below" : "above";
+    const x = xScale(ev.start.value);
+    const cardX = x - LOLLIPOP_CARD_W / 2;
+    const cardRight = cardX + LOLLIPOP_CARD_W;
+    const rows = side === "above" ? aboveRows : belowRows;
+    let row = 0;
+    for (; row < rows.length; row++) {
+      if (rows[row] <= cardX + 2) {
+        rows[row] = cardRight;
+        break;
+      }
+    }
+    if (row === rows.length) {
+      rows.push(cardRight);
+    }
+    const stemLen = LOLLIPOP_STEM_BASE + row * LOLLIPOP_STEM_STACK;
+    cards.push({
+      event: ev,
+      x,
+      axisY: 0,
+      // filled after we know axisY
+      side,
+      cardX,
+      cardY: 0,
+      cardW: LOLLIPOP_CARD_W,
+      cardH: LOLLIPOP_CARD_H,
+      stemY1: 0,
+      stemY2: 0,
+      color: ev.color ?? palette[i % palette.length],
+      index: row
+    });
+    cards[cards.length - 1]._stemLen = stemLen;
+  }
+  const maxAboveStems = aboveRows.length;
+  const maxBelowStems = belowRows.length;
+  const topExtent = LOLLIPOP_CARD_H + LOLLIPOP_STEM_BASE + Math.max(0, maxAboveStems - 1) * LOLLIPOP_STEM_STACK;
+  const realAxisY = plotY + topExtent + 10;
+  const bottomExtent = LOLLIPOP_CARD_H + LOLLIPOP_STEM_BASE + Math.max(0, maxBelowStems - 1) * LOLLIPOP_STEM_STACK;
+  const height = realAxisY + bottomExtent + 40;
+  for (const c of cards) {
+    const stemLen = c._stemLen ?? LOLLIPOP_STEM_BASE;
+    c.axisY = realAxisY;
+    if (c.side === "above") {
+      c.stemY1 = realAxisY - 3;
+      c.stemY2 = realAxisY - stemLen;
+      c.cardY = c.stemY2 - c.cardH;
+    } else {
+      c.stemY1 = realAxisY + 3;
+      c.stemY2 = realAxisY + stemLen;
+      c.cardY = c.stemY2;
+    }
+    delete c._stemLen;
+  }
+  const eventLayouts = [];
+  for (const ev of events) {
+    if (ev.kind !== "range") continue;
+    const x = xScale(ev.start.value);
+    const xe = xScale(ev.end.value);
+    const w = Math.max(4, xe - x);
+    eventLayouts.push({
+      event: ev,
+      x,
+      w,
+      y: realAxisY - 5,
+      h: 10,
+      labelX: x + w / 2,
+      labelY: realAxisY - 10,
+      labelAnchor: "middle"
+    });
+  }
+  const eraLayouts = ast.eras.map((e, idx) => ({
+    era: e,
+    x: xScale(e.start.value),
+    width: Math.max(2, xScale(e.end.value) - xScale(e.start.value)),
+    bandRow: eraRows.rowOf[idx]
+  }));
+  const leftmostIdxByRow = /* @__PURE__ */ new Map();
+  const rightmostIdxByRow = /* @__PURE__ */ new Map();
+  eraLayouts.forEach((e, i) => {
+    const curL = leftmostIdxByRow.get(e.bandRow);
+    if (curL === void 0 || e.x < eraLayouts[curL].x) leftmostIdxByRow.set(e.bandRow, i);
+    const curR = rightmostIdxByRow.get(e.bandRow);
+    const right = e.x + e.width;
+    if (curR === void 0 || right > eraLayouts[curR].x + eraLayouts[curR].width) {
+      rightmostIdxByRow.set(e.bandRow, i);
+    }
+  });
+  for (const [, i] of leftmostIdxByRow) {
+    const e = eraLayouts[i];
+    const right = e.x + e.width;
+    e.x = Math.min(e.x, plotX);
+    e.width = right - e.x;
+  }
+  for (const [, i] of rightmostIdxByRow) {
+    const e = eraLayouts[i];
+    e.width = Math.max(e.width, plotRight - e.x);
+  }
+  return {
+    width: CANVAS_WIDTH,
+    height,
+    style: "lollipop",
+    plotX,
+    plotY,
+    plotW,
+    plotH: height - plotY - 20,
+    lanes: [],
+    events: eventLayouts,
+    eras: eraLayouts,
+    ticks: generateTicks(paddedStart, paddedEnd, span, xScale, ast.scale).filter((t) => t.x >= plotX - 2 && t.x <= plotX + plotW + 2),
+    axisY: realAxisY,
+    title: ast.title,
+    cards
+  };
+}
+
+// src/diagrams/timeline/renderer.ts
+var ERA_BAND_HEIGHT2 = 16;
+var ERA_ROW_GAP = 2;
+function renderTimeline(src, config) {
+  const ast = parseTimeline(src);
+  const layout = layoutTimeline(ast);
+  const theme = resolveTimelineTheme(config?.theme ?? "default");
+  const styleBlock = styleForTheme(theme, config?.fontFamily);
+  const children = [
+    title(ast.title ? `Timeline \u2014 ${ast.title}` : "Timeline"),
+    desc("Schematex timeline diagram"),
+    defs([`<style>${styleBlock}</style>`])
+  ];
+  if (ast.title) {
+    children.push(
+      text(
+        { x: layout.width / 2, y: 26, "text-anchor": "middle", class: "st-title" },
+        ast.title
+      )
+    );
+  }
+  children.push(renderEras(layout, theme));
+  switch (layout.style) {
+    case "gantt":
+      children.push(renderGantt(layout, theme));
+      break;
+    case "lollipop":
+      children.push(renderLollipop(layout, theme));
+      break;
+    case "swimlane":
+    default:
+      children.push(renderSwimlane(layout, theme));
+      break;
+  }
+  children.push(renderAxis(layout));
+  return svgRoot(
+    {
+      viewBox: `0 0 ${layout.width} ${layout.height}`,
+      width: layout.width,
+      height: layout.height,
+      class: `st-timeline st-timeline-${layout.style}`,
+      "data-diagram-type": "timeline",
+      "data-style": layout.style,
+      role: "graphics-document"
+    },
+    children
+  );
+}
+function styleForTheme(theme, fontFamily) {
+  const font = fontFamily ?? "system-ui, -apple-system, sans-serif";
+  return `
+    .st-timeline { ${cssCustomProperties(theme)}
+      --st-axis: ${theme.axis};
+      --st-axis-label: ${theme.axisLabel};
+      --st-era-label: ${theme.eraLabel};
+      --st-lane-stripe: ${theme.laneStripe};
+      --st-marker-ring: ${theme.markerRing};
+      --st-marker-fill: ${theme.markerFill};
+      --st-milestone-fill: ${theme.milestoneFill};
+      --st-pin-shaft: ${theme.pinShaft};
+      --st-card-bg: ${theme.cardBg};
+      --st-card-stroke: ${theme.cardStroke};
+      --st-card-text: ${theme.cardText};
+      --st-legend-bg: ${theme.legendBg};
+      --st-legend-stroke: ${theme.legendStroke};
+      font-family: ${font}; background: var(--schematex-bg); }
+    .st-title { font-size: 16px; font-weight: 600; fill: var(--schematex-text); }
+    .st-axis-line { stroke: var(--st-axis); stroke-width: 1.5; fill: none; }
+    .st-axis-tick { stroke: var(--st-axis); stroke-width: 1; opacity: 0.55; }
+    .st-axis-label { font-size: 11px; fill: var(--st-axis-label); }
+    .st-era-rect { opacity: ${theme.eraOpacity}; }
+    .st-era-strip { opacity: ${theme.eraPlotOpacity}; }
+    .st-era-label { font-size: 11px; font-weight: 500; fill: var(--st-era-label); }
+    .st-event-dot { stroke: var(--st-marker-fill); stroke-width: 1.5; }
+    .st-event-label { font-size: 12px; fill: var(--schematex-text); }
+    .st-range-bar { opacity: 0.88; }
+    .st-range-label { font-size: 11px; fill: #fff; font-weight: 500; }
+    .st-milestone { stroke: var(--st-marker-fill); stroke-width: 2; }
+    .st-milestone-label { font-size: 12px; fill: var(--schematex-text); font-weight: 600; }
+    .st-track-label { font-size: 12px; font-weight: 600; fill: var(--schematex-text); }
+    .st-lane-stripe { fill: var(--st-lane-stripe); opacity: ${theme.laneStripeOpacity}; }
+    .st-callout-line { stroke: var(--st-axis); stroke-width: 0.8; stroke-dasharray: 2 2; opacity: 0.5; fill: none; }
+    .st-callout-text { font-size: 10.5px; fill: var(--schematex-text-muted); }
+    .st-label-leader { stroke: var(--st-axis); stroke-width: 0.75; opacity: 0.35; fill: none; }
+    .st-icon { font-size: 14px; }
+    /* Gantt */
+    .st-pin-shaft { stroke: var(--st-pin-shaft); stroke-width: 1.25; stroke-dasharray: 3 2; fill: none; }
+    .st-pin-label { font-size: 11.5px; fill: var(--schematex-text); font-weight: 500; }
+    .st-pin-head { stroke: var(--st-marker-fill); stroke-width: 1.5; }
+    .st-lane-label { font-size: 11px; fill: var(--schematex-text-muted); font-weight: 500; }
+    .st-legend-box { fill: var(--st-legend-bg); stroke: var(--st-legend-stroke); stroke-width: 1; }
+    .st-legend-title { font-size: 11px; font-weight: 600; fill: var(--schematex-text-muted); }
+    .st-legend-label { font-size: 11px; fill: var(--schematex-text); }
+    /* Lollipop */
+    .st-card { fill: var(--st-card-bg); stroke: var(--st-card-stroke); stroke-width: 1; }
+    .st-card-title { font-size: 12px; font-weight: 600; fill: var(--st-card-text); }
+    .st-card-date { font-size: 10.5px; fill: var(--schematex-text-muted); }
+    .st-card-icon { font-size: 16px; }
+    .st-stem { stroke: var(--st-axis); stroke-width: 1.25; opacity: 0.55; fill: none; }
+    .st-lp-marker-ring { stroke-width: 2.5; }
+    .st-lp-marker-core { stroke: none; }
+  `;
+}
+function renderEras(layout, theme) {
+  if (!layout.eras.length) return "";
+  const topBase = layout.title ? 54 : 40;
+  const palette = theme.palette;
+  const leftmostOnRow = /* @__PURE__ */ new Map();
+  const rightmostOnRow = /* @__PURE__ */ new Map();
+  layout.eras.forEach((e, i) => {
+    const l = leftmostOnRow.get(e.bandRow);
+    if (l === void 0 || e.x < layout.eras[l].x) leftmostOnRow.set(e.bandRow, i);
+    const r = rightmostOnRow.get(e.bandRow);
+    if (r === void 0 || e.x + e.width > layout.eras[r].x + layout.eras[r].width) rightmostOnRow.set(e.bandRow, i);
+  });
+  const plotEnd = layout.plotX + layout.plotW;
+  const items = layout.eras.map((e, i) => {
+    const y = topBase + e.bandRow * (ERA_BAND_HEIGHT2 + ERA_ROW_GAP);
+    const fill = e.era.color ?? palette[i % palette.length];
+    const labelX = e.x + 6;
+    const isLeftmost = leftmostOnRow.get(e.bandRow) === i;
+    const isRightmost = rightmostOnRow.get(e.bandRow) === i;
+    const stripX = isLeftmost ? Math.min(e.x, layout.plotX) : e.x;
+    const stripEnd = isRightmost ? Math.max(e.x + e.width, plotEnd) : e.x + e.width;
+    return [
+      rect({
+        x: e.x,
+        y,
+        width: e.width,
+        height: ERA_BAND_HEIGHT2,
+        fill,
+        class: "st-era-rect",
+        "data-era-id": e.era.id
+      }),
+      rect({
+        x: stripX,
+        y: layout.plotY,
+        width: stripEnd - stripX,
+        height: layout.plotH,
+        fill,
+        class: "st-era-strip"
+      }),
+      text(
+        { x: labelX, y: y + 12, class: "st-era-label" },
+        truncate(e.era.label, Math.max(4, Math.floor(e.width / 7)))
+      )
+    ].join("");
+  });
+  return group({ class: "st-eras" }, items);
+}
+function renderAxis(layout) {
+  const ax = layout.axisY;
+  const items = [
+    line({ x1: layout.plotX, y1: ax, x2: layout.plotX + layout.plotW, y2: ax, class: "st-axis-line" })
+  ];
+  for (const t of layout.ticks) {
+    items.push(line({ x1: t.x, y1: ax, x2: t.x, y2: ax + 5, class: "st-axis-tick" }));
+    items.push(text({ x: t.x, y: ax + 18, "text-anchor": "middle", class: "st-axis-label" }, t.label));
+  }
+  return group({ class: "st-axis" }, items);
+}
+function renderSwimlane(layout, theme) {
+  const parts = [];
+  parts.push(renderTrackLabels(layout));
+  parts.push(renderLaneStripes(layout));
+  parts.push(renderSwimlaneRanges(layout, theme));
+  parts.push(renderSwimlanePoints(layout, theme));
+  parts.push(renderLabels(layout));
+  parts.push(renderNotes(layout));
+  return parts.join("");
+}
+function renderTrackLabels(layout) {
+  const items = layout.lanes.filter((l) => l.label).map((l) => text(
+    { x: layout.plotX - 12, y: l.y + l.height / 2 + 4, "text-anchor": "end", class: "st-track-label" },
+    l.label
+  ));
+  return group({ class: "st-track-labels" }, items);
+}
+function renderLaneStripes(layout) {
+  const items = layout.lanes.map((l, i) => {
+    if (i % 2 !== 0) return "";
+    return rect({
+      x: layout.plotX,
+      y: l.y,
+      width: layout.plotW,
+      height: l.height,
+      class: "st-lane-stripe"
+    });
+  }).filter(Boolean);
+  return group({ class: "st-lanes" }, items);
+}
+function renderSwimlaneRanges(layout, theme) {
+  const items = [];
+  const trackOrder = layout.lanes.map((l) => l.trackId);
+  const palette = theme.categoryPalette;
+  for (const ev of layout.events) {
+    if (ev.event.kind !== "range") continue;
+    const idx = trackOrder.indexOf(ev.event.trackId);
+    const fill = ev.event.color ?? palette[(idx < 0 ? 0 : idx) % palette.length];
+    items.push(rect({
+      x: ev.x,
+      y: ev.y,
+      width: ev.w ?? 4,
+      height: ev.h,
+      rx: 4,
+      ry: 4,
+      fill,
+      class: "st-range-bar",
+      "data-event-id": ev.event.id
+    }));
+    const w = ev.w ?? 0;
+    if (w >= 60) {
+      items.push(text(
+        { x: ev.labelX, y: ev.labelY, "text-anchor": "middle", class: "st-range-label" },
+        truncate(ev.event.label, Math.floor(w / 6))
+      ));
+    } else if (w > 0) {
+      items.push(text(
+        { x: ev.x + w + 4, y: ev.labelY, "text-anchor": "start", class: "st-event-label" },
+        ev.event.label
+      ));
+    }
+  }
+  return group({ class: "st-ranges" }, items);
+}
+function renderSwimlanePoints(layout, theme) {
+  const items = [];
+  for (const ev of layout.events) {
+    if (ev.event.kind === "range") continue;
+    const isMilestone = ev.event.kind === "milestone";
+    const color = ev.event.color ?? (isMilestone ? theme.milestoneFill : theme.markerRing);
+    const shape = ev.event.shape ?? (isMilestone ? "star" : "circle");
+    items.push(renderMarker(ev, color, shape, isMilestone));
+  }
+  return group({ class: "st-points" }, items);
+}
+function renderMarker(ev, color, shape, isMilestone) {
+  const x = ev.x;
+  const y = ev.y;
+  const r = isMilestone ? 8 : 5;
+  const klass = isMilestone ? "st-milestone" : "st-event-dot";
+  switch (shape) {
+    case "square":
+      return rect({ x: x - r, y: y - r, width: r * 2, height: r * 2, fill: color, class: klass, "data-event-id": ev.event.id });
+    case "diamond":
+      return path({ d: `M ${x},${y - r} L ${x + r},${y} L ${x},${y + r} L ${x - r},${y} Z`, fill: color, class: klass, "data-event-id": ev.event.id });
+    case "star":
+      return path({ d: starPath(x, y, r + 2, (r + 2) / 2.5, 5), fill: color, class: klass, "data-event-id": ev.event.id });
+    case "flag":
+      return path({ d: `M ${x - r},${y + r} L ${x - r},${y - r - 4} L ${x + r + 4},${y - r - 1} L ${x - r},${y + 2}`, fill: color, class: klass, "data-event-id": ev.event.id });
+    case "circle":
+    default:
+      return circle({ cx: x, cy: y, r, fill: color, class: klass, "data-event-id": ev.event.id });
+  }
+}
+function renderLabels(layout) {
+  const items = [];
+  for (const ev of layout.events) {
+    if (ev.event.kind === "range") continue;
+    const cls = ev.event.kind === "milestone" ? "st-milestone-label" : "st-event-label";
+    const text2 = ev.event.icon ? `${ev.event.icon} ${ev.event.label}` : ev.event.label;
+    const dy = ev.labelY - ev.y;
+    if (Math.abs(dy) > 22) {
+      const y1 = dy < 0 ? ev.y - 6 : ev.y + 6;
+      const y2 = dy < 0 ? ev.labelY + 3 : ev.labelY - 10;
+      items.push(line({ x1: ev.x, y1, x2: ev.x, y2, class: "st-label-leader" }));
+    }
+    items.push(text(
+      { x: ev.labelX, y: ev.labelY, "text-anchor": ev.labelAnchor, class: cls },
+      text2
+    ));
+  }
+  return group({ class: "st-labels" }, items);
+}
+function renderNotes(layout) {
+  const items = [];
+  for (const ev of layout.events) {
+    if (!ev.event.note) continue;
+    const x = ev.x;
+    const ny = ev.noteY ?? ev.y + 18;
+    const nx = ev.noteX ?? x + 10;
+    const wrapped = wrapText2(ev.event.note, 46);
+    items.push(path({ d: `M ${x} ${ev.y + 6} Q ${x + 4} ${ny - 4} ${nx} ${ny}`, class: "st-callout-line" }));
+    wrapped.forEach((ln, i) => {
+      items.push(text(
+        { x: nx, y: ny + i * 13, class: "st-callout-text" },
+        ln
+      ));
+    });
+  }
+  return group({ class: "st-notes" }, items);
+}
+function renderGantt(layout, theme) {
+  const parts = [];
+  parts.push(renderGanttLanes(layout));
+  parts.push(renderGanttBars(layout, theme));
+  parts.push(renderGanttPins(layout));
+  if (layout.legend && layout.legend.length) {
+    parts.push(renderLegend(layout));
+  }
+  return parts.join("");
+}
+function renderGanttLanes(layout) {
+  const items = [];
+  layout.lanes.forEach((l, i) => {
+    if (i % 2 === 0) {
+      items.push(rect({
+        x: layout.plotX,
+        y: l.y,
+        width: layout.plotW,
+        height: l.height,
+        class: "st-lane-stripe"
+      }));
+    }
+    items.push(text({
+      x: layout.plotX - 10,
+      y: l.y + l.height / 2 + 4,
+      "text-anchor": "end",
+      class: "st-lane-label"
+    }, l.label));
+  });
+  return group({ class: "st-gantt-lanes" }, items);
+}
+function renderGanttBars(layout, theme) {
+  const items = [];
+  const laneByCat = new Map(layout.lanes.map((l) => [l.label, l]));
+  const legendByLabel = new Map((layout.legend ?? []).map((l) => [l.label, l.color]));
+  for (const ev of layout.events) {
+    if (ev.event.kind !== "range") continue;
+    const cat = ev.event.category ?? layout.lanes[0]?.label ?? "";
+    const color = ev.event.color ?? legendByLabel.get(cat) ?? theme.categoryPalette[0];
+    const w = ev.w ?? 4;
+    items.push(rect({
+      x: ev.x,
+      y: ev.y,
+      width: w,
+      height: ev.h,
+      rx: 5,
+      ry: 5,
+      fill: color,
+      class: "st-range-bar",
+      "data-event-id": ev.event.id,
+      "data-category": cat
+    }));
+    if (w >= 60) {
+      items.push(text(
+        { x: ev.labelX, y: ev.labelY, "text-anchor": "middle", class: "st-range-label" },
+        truncate(ev.event.label, Math.floor(w / 6))
+      ));
+    } else if (w > 0) {
+      const lane = laneByCat.get(cat);
+      const ly = lane ? lane.y + lane.height / 2 + 4 : ev.labelY;
+      items.push(text(
+        { x: ev.x + w + 4, y: ly, "text-anchor": "start", class: "st-event-label" },
+        ev.event.label
+      ));
+    }
+  }
+  return group({ class: "st-gantt-bars" }, items);
+}
+function renderGanttPins(layout) {
+  const pins = layout.pins ?? [];
+  if (!pins.length) return "";
+  const items = [];
+  for (const p of pins) {
+    items.push(renderPin(p));
+  }
+  return group({ class: "st-gantt-pins" }, items);
+}
+function renderPin(p) {
+  const isMilestone = p.event.kind === "milestone";
+  const shaft = path({
+    d: `M ${p.x} ${p.labelY + 2} L ${p.x} ${p.axisY - 4}`,
+    class: "st-pin-shaft"
+  });
+  const head = isMilestone ? path({
+    d: starPath(p.x, p.axisY - 6, 7, 3, 5),
+    fill: p.color,
+    class: "st-pin-head",
+    "data-event-id": p.event.id
+  }) : circle({
+    cx: p.x,
+    cy: p.axisY - 6,
+    r: 5,
+    fill: p.color,
+    class: "st-pin-head",
+    "data-event-id": p.event.id
+  });
+  const txt = p.event.icon ? `${p.event.icon} ${p.event.label}` : p.event.label;
+  const label = text(
+    { x: p.x, y: p.labelY, "text-anchor": "middle", class: "st-pin-label" },
+    txt
+  );
+  return shaft + head + label;
+}
+function renderLegend(layout) {
+  const legend = layout.legend ?? [];
+  if (!legend.length) return "";
+  const boxW = 130;
+  const padding = 10;
+  const rowH = 18;
+  const h = padding * 2 + 18 + legend.length * rowH;
+  const x = layout.width - boxW - 16;
+  const y = layout.plotY;
+  const items = [
+    rect({ x, y, width: boxW, height: h, rx: 6, ry: 6, class: "st-legend-box" }),
+    text({ x: x + padding, y: y + padding + 12, class: "st-legend-title" }, "Teams")
+  ];
+  legend.forEach((it, i) => {
+    const rowY = y + padding + 18 + i * rowH + 8;
+    items.push(rect({ x: x + padding, y: rowY - 7, width: 12, height: 12, rx: 2, ry: 2, fill: it.color }));
+    items.push(text({ x: x + padding + 20, y: rowY + 3, class: "st-legend-label" }, truncate(it.label, 14)));
+  });
+  return group({ class: "st-legend" }, items);
+}
+function renderLollipop(layout, theme) {
+  const parts = [];
+  parts.push(renderLollipopRanges(layout, theme));
+  parts.push(renderLollipopCards(layout, theme));
+  return parts.join("");
+}
+function renderLollipopRanges(layout, theme) {
+  const items = [];
+  for (const ev of layout.events) {
+    if (ev.event.kind !== "range") continue;
+    const color = ev.event.color ?? theme.categoryPalette[0];
+    items.push(rect({
+      x: ev.x,
+      y: ev.y,
+      width: ev.w ?? 4,
+      height: ev.h,
+      rx: 3,
+      ry: 3,
+      fill: color,
+      class: "st-range-bar",
+      "data-event-id": ev.event.id
+    }));
+  }
+  return group({ class: "st-lp-ranges" }, items);
+}
+function renderLollipopCards(layout, theme) {
+  const cards = layout.cards ?? [];
+  if (!cards.length) return "";
+  const items = [];
+  for (const c of cards) {
+    items.push(renderLollipopCard(c, theme));
+  }
+  return group({ class: "st-lp-cards" }, items);
+}
+function renderLollipopCard(c, theme) {
+  const parts = [];
+  parts.push(path({ d: `M ${c.x} ${c.stemY1} L ${c.x} ${c.stemY2}`, class: "st-stem" }));
+  parts.push(circle({ cx: c.x, cy: c.axisY, r: 7, fill: theme.markerFill, stroke: c.color, class: "st-lp-marker-ring" }));
+  parts.push(circle({ cx: c.x, cy: c.axisY, r: 3.2, fill: c.color, class: "st-lp-marker-core" }));
+  parts.push(rect({
+    x: c.cardX,
+    y: c.cardY,
+    width: c.cardW,
+    height: c.cardH,
+    rx: 8,
+    ry: 8,
+    class: "st-card"
+  }));
+  parts.push(rect({
+    x: c.cardX,
+    y: c.cardY,
+    width: 4,
+    height: c.cardH,
+    rx: 2,
+    ry: 2,
+    fill: c.color
+  }));
+  const padX = c.cardX + 14;
+  const titleText = c.event.icon ? `${c.event.icon}  ${c.event.label}` : c.event.label;
+  parts.push(text(
+    { x: padX, y: c.cardY + 22, class: "st-card-title" },
+    truncate(titleText, 26)
+  ));
+  parts.push(text(
+    { x: padX, y: c.cardY + 40, class: "st-card-date" },
+    c.event.start.raw
+  ));
+  return parts.join("");
+}
+function truncate(s, maxChars) {
+  if (s.length <= maxChars) return s;
+  if (maxChars < 4) return "";
+  return s.slice(0, maxChars - 1) + "\u2026";
+}
+function wrapText2(s, max) {
+  const words = s.split(/\s+/);
+  const out = [];
+  let cur = "";
+  for (const w of words) {
+    if ((cur + " " + w).trim().length > max) {
+      if (cur) out.push(cur);
+      cur = w;
+    } else {
+      cur = (cur ? cur + " " : "") + w;
+    }
+  }
+  if (cur) out.push(cur);
+  return out.slice(0, 4);
+}
+function starPath(cx, cy, rOuter, rInner, points) {
+  const step = Math.PI / points;
+  let d = "";
+  for (let i = 0; i < points * 2; i++) {
+    const r = i % 2 === 0 ? rOuter : rInner;
+    const a = i * step - Math.PI / 2;
+    const x = cx + r * Math.cos(a);
+    const y = cy + r * Math.sin(a);
+    d += (i === 0 ? "M" : "L") + x.toFixed(2) + "," + y.toFixed(2) + " ";
+  }
+  return d + "Z";
+}
+
+// src/diagrams/timeline/index.ts
+var timeline = {
+  type: "timeline",
+  detect(text2) {
+    return /^\s*timeline\b/i.test(text2);
+  },
+  parse: parseTimeline,
+  render(text2, config) {
+    return renderTimeline(text2, config);
+  }
+};
+
+// src/diagrams/mindmap/parser.ts
+var VALID_STYLES = ["map", "logic-right"];
+function parseDirective(line2, out) {
+  const body = line2.replace(/^%%\s*/, "").trim();
+  const idx = body.indexOf(":");
+  if (idx < 0) return;
+  const key = body.slice(0, idx).trim().toLowerCase();
+  const val = body.slice(idx + 1).trim();
+  if (key === "style" && VALID_STYLES.includes(val)) {
+    out.style = val;
+  } else if (key === "theme") {
+    out.themeOverride = val;
+  }
+}
+function parseMindmap(text2) {
+  const lines = text2.split(/\r?\n/);
+  if (lines[0]?.trim().toLowerCase() === "mindmap") lines.shift();
+  const directives = { style: "map" };
+  let root = null;
+  let idCounter2 = 0;
+  const nextId2 = () => `n${idCounter2++}`;
+  const stack = [];
+  let lastHeadingDepth = 0;
+  const attach = (node, depth) => {
+    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");
+    node.depth = parent.depth + 1;
+    parent.children.push(node);
+    stack.push({ node, depth });
+  };
+  for (const raw of lines) {
+    const line2 = raw.replace(/\s+$/, "");
+    const trimmed = line2.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("%%")) {
+      parseDirective(trimmed, directives);
+      continue;
+    }
+    const heading = line2.match(/^\s*(#{1,6})\s+(.+)$/);
+    if (heading) {
+      const depth = heading[1].length - 1;
+      const label = heading[2].trim();
+      const node = { id: nextId2(), label, depth, children: [] };
+      if (depth === 0) {
+        if (root) throw new Error("Mindmap: multiple `#` center nodes not allowed");
+        root = node;
+        stack.length = 0;
+        stack.push({ node, depth: 0 });
+      } else {
+        attach(node, depth);
+      }
+      lastHeadingDepth = depth;
+      continue;
+    }
+    const bullet = line2.match(/^(\s*)[-*+]\s+(.+)$/);
+    if (bullet) {
+      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);
+      continue;
+    }
+  }
+  if (!root) throw new Error("Mindmap: missing central topic \u2014 start with `# Title`");
+  const ast = {
+    type: "mindmap",
+    style: directives.style,
+    root
+  };
+  if (directives.themeOverride) ast.themeOverride = directives.themeOverride;
+  return ast;
+}
+
+// src/diagrams/mindmap/layout.ts
+var PADDING = 40;
+var SIBLING_GAP = 20;
+var MAIN_GAP = 44;
+var ROOT_CAPSULE_PAD_X = 10;
+var ROOT_CAPSULE_PAD_Y = 10;
+function bezierGapFor(childDepth) {
+  if (childDepth <= 1) return 90;
+  if (childDepth === 2) return 60;
+  return 45;
+}
+var FONT_CENTRAL = 20;
+var FONT_MAIN = 15;
+var FONT_SUB = 13;
+function fontSizeOf(depth) {
+  if (depth === 0) return FONT_CENTRAL;
+  if (depth === 1) return FONT_MAIN;
+  return FONT_SUB;
+}
+function estimateLabelWidth2(label, depth) {
+  return Math.max(32, label.length * fontSizeOf(depth) * 0.58);
+}
+function rowHeightOf(depth) {
+  return fontSizeOf(depth) + 14;
+}
+function computeColumns(subtreeRoots, firstColStartX) {
+  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;
+    for (const c of n.children) walk(c);
+  };
+  for (const r of subtreeRoots) walk(r);
+  const center = [];
+  if (subtreeRoots.length === 0) return { center };
+  const rootDepth = subtreeRoots[0].depth;
+  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;
+  }
+  return { center };
+}
+function tidyRight(node, yTop, branchIdx, columns, out) {
+  const rowH = rowHeightOf(node.depth);
+  const lw = estimateLabelWidth2(node.label, node.depth);
+  const x = columns.center[node.depth];
+  if (node.children.length === 0) {
+    const ln2 = {
+      node,
+      x,
+      y: yTop + rowH / 2,
+      side: "right",
+      branchIndex: branchIdx,
+      labelWidth: lw,
+      labelHeight: rowH
+    };
+    out.push(ln2);
+    return { layoutNode: ln2, height: rowH };
+  }
+  let cursor = yTop;
+  const childLayouts = [];
+  for (let i = 0; i < node.children.length; i++) {
+    if (i > 0) cursor += SIBLING_GAP;
+    const { layoutNode: cln, height } = tidyRight(
+      node.children[i],
+      cursor,
+      branchIdx,
+      columns,
+      out
+    );
+    childLayouts.push(cln);
+    cursor += height;
+  }
+  const totalH = Math.max(rowH, cursor - yTop);
+  const firstY = childLayouts[0].y;
+  const lastY = childLayouts[childLayouts.length - 1].y;
+  const parentY = (firstY + lastY) / 2;
+  const ln = {
+    node,
+    x,
+    y: parentY,
+    side: "right",
+    branchIndex: branchIdx,
+    labelWidth: lw,
+    labelHeight: rowH
+  };
+  out.push(ln);
+  return { layoutNode: ln, height: totalH };
+}
+function labelEdgeX(n, outward) {
+  if (n.side === "center") return n.x;
+  const dir = n.side === "left" ? -1 : 1;
+  return n.x + (outward ? dir : -dir) * n.labelWidth / 2;
+}
+function bezierH(x1, y1, x2, y2) {
+  const k = (x2 - x1) * 0.55;
+  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;
+}
+function normalize(nodes) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const n of nodes) {
+    const lw = n.labelWidth;
+    const lh = n.labelHeight;
+    const leftX = n.x - lw / 2;
+    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);
+  }
+  const dx = PADDING - minX;
+  const dy = PADDING - minY;
+  for (const n of nodes) {
+    n.x += dx;
+    n.y += dy;
+  }
+  return { width: maxX - minX + PADDING * 2, height: maxY - minY + PADDING * 2 };
+}
+function buildEdges(root, byId) {
+  const edges = [];
+  const walk = (parent) => {
+    const pln = byId.get(parent.id);
+    for (const c of parent.children) {
+      const cln = byId.get(c.id);
+      let fromX;
+      if (pln.side === "center") {
+        const halfW = pln.labelWidth / 2;
+        fromX = cln.side === "left" ? pln.x - halfW : pln.x + halfW;
+      } else {
+        fromX = labelEdgeX(pln, true);
+      }
+      const toX = labelEdgeX(cln, false);
+      edges.push({
+        from: parent.id,
+        to: c.id,
+        path: bezierH(fromX, pln.y, toX, cln.y),
+        color: "",
+        width: edgeWidthFor(c.depth)
+      });
+      walk(c);
+    }
+  };
+  walk(root);
+  return edges;
+}
+function layoutMap(ast) {
+  const root = ast.root;
+  const mains = root.children;
+  const rightCount = Math.ceil(mains.length / 2);
+  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);
+  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);
+    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);
+    leftCursor += height2;
+  }
+  const leftHeight = leftCursor;
+  for (let k = leftStart; k < nodes.length; k++) {
+    nodes[k].x = -nodes[k].x;
+    nodes[k].side = "left";
+  }
+  const rootY = Math.max(rightHeight, leftHeight) / 2;
+  const rootNode = {
+    node: root,
+    x: 0,
+    y: rootY,
+    side: "center",
+    branchIndex: -1,
+    labelWidth: rootCapsuleW,
+    labelHeight: rootCapsuleH
+  };
+  nodes.push(rootNode);
+  const { width, height } = normalize(nodes);
+  const byId = new Map(nodes.map((n) => [n.node.id, n]));
+  const edges = buildEdges(root, byId);
+  return { width, height, style: "map", nodes, edges, title: ast.title };
+}
+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);
+  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);
+    cursor += height2;
+  }
+  const totalHeight = cursor;
+  const rootNode = {
+    node: root,
+    x: 0,
+    y: totalHeight / 2,
+    side: "center",
+    branchIndex: -1,
+    labelWidth: rootCapsuleW,
+    labelHeight: rootCapsuleH
+  };
+  nodes.push(rootNode);
+  const { width, height } = normalize(nodes);
+  const byId = new Map(nodes.map((n) => [n.node.id, n]));
+  const edges = buildEdges(root, byId);
+  return { width, height, style: "logic-right", nodes, edges, title: ast.title };
+}
+function layoutMindmap(ast) {
+  const style = ast.style;
+  if (style === "logic-right") return layoutLogicRight(ast);
+  return layoutMap(ast);
+}
+
+// src/diagrams/mindmap/renderer.ts
+var UNDERLINE_MAIN = 2.2;
+var UNDERLINE_MAIN_MONO = 1.5;
+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 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 renderBranchNode(n, color, theme, fontFamily) {
+  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 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"
+      })
+    );
+  }
+  return group(
+    {
+      class: isMain ? "schematex-mindmap-main" : "schematex-mindmap-leaf",
+      "data-node-id": n.node.id,
+      "data-depth": n.node.depth,
+      "data-branch-idx": n.branchIndex
+    },
+    children
+  );
+}
+function renderMindmapAST(ast, themeName = "default", fontFamily = "system-ui, -apple-system, sans-serif") {
+  const theme = resolveMindmapTheme(ast.themeOverride ?? themeName);
+  const layout = layoutMindmap(ast);
+  const byId = new Map(layout.nodes.map((n) => [n.node.id, n]));
+  const edgeSvgs = [];
+  for (const e of layout.edges) {
+    const target = byId.get(e.to);
+    if (!target) continue;
+    const color = paletteColor(theme, target.branchIndex);
+    edgeSvgs.push(
+      path({
+        d: e.path,
+        fill: "none",
+        stroke: color,
+        "stroke-width": e.width,
+        "stroke-linecap": "round"
+      })
+    );
+  }
+  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 title2 = ast.title ?? ast.root.label;
+  return svgRoot(
+    {
+      viewBox: `0 0 ${layout.width.toFixed(1)} ${layout.height.toFixed(1)}`,
+      width: layout.width.toFixed(1),
+      height: layout.height.toFixed(1),
+      role: "graphics-document",
+      "aria-label": `Mindmap: ${escapeXml(title2)}`
+    },
+    [
+      title(title2),
+      desc(`${layout.style} mindmap with ${layout.nodes.length} nodes`),
+      rect({ x: 0, y: 0, width: layout.width, height: layout.height, fill: theme.bg }),
+      group({ class: "schematex-mindmap-edges", "aria-hidden": "true" }, edgeSvgs),
+      group({ class: "schematex-mindmap-nodes" }, nodeSvgs)
+    ]
+  );
+}
+function renderMindmap(text2, opts) {
+  const ast = parseMindmap(text2);
+  return renderMindmapAST(ast, opts?.theme, opts?.fontFamily);
+}
+
+// src/diagrams/mindmap/index.ts
+var mindmap = {
+  type: "mindmap",
+  detect(text2) {
+    const lines = text2.trim().split("\n");
+    const first = lines[0]?.trim().toLowerCase() ?? "";
+    if (first.startsWith("mindmap")) return true;
+    for (const ln of lines) {
+      const t = ln.trim();
+      if (!t) continue;
+      if (t.startsWith("%%")) continue;
+      return /^#\s+\S/.test(t);
+    }
+    return false;
+  },
+  parse: parseMindmap,
+  render(text2, config) {
+    return renderMindmap(text2, {
+      theme: config?.theme,
+      fontFamily: config?.fontFamily
+    });
+  }
+};
+
+// src/diagrams/matrix/templates.ts
+var TEMPLATES = {
+  "eisenhower": {
+    grid: "2x2",
+    xAxis: { low: "Urgent", high: "Not Urgent" },
+    yAxis: { low: "Not Important", high: "Important" },
+    annotations: [
+      { q: 1, label: "Schedule" },
+      { q: 2, label: "Do First" },
+      { q: 3, label: "Delete" },
+      { q: 4, label: "Delegate" }
+    ]
+  },
+  "impact-effort": {
+    grid: "2x2",
+    xAxis: { low: "Low Effort", high: "High Effort" },
+    yAxis: { low: "Low Impact", high: "High Impact" },
+    annotations: [
+      { q: 1, label: "Major Projects" },
+      { q: 2, label: "Quick Wins" },
+      { q: 3, label: "Fill-ins" },
+      { q: 4, label: "Thankless" }
+    ]
+  },
+  "rice": {
+    grid: "2x2",
+    xAxis: { low: "Low Effort", high: "High Effort" },
+    yAxis: { low: "Low Reach \xD7 Impact", high: "High Reach \xD7 Impact" },
+    annotations: [
+      { q: 1, label: "Strategic Bets" },
+      { q: 2, label: "High RICE" },
+      { q: 3, label: "Backlog" },
+      { q: 4, label: "Reconsider" }
+    ]
+  },
+  "bcg": {
+    grid: "2x2",
+    // BCG convention: high market share on left (x-axis reversed)
+    xAxis: { low: "High Market Share", high: "Low Market Share" },
+    yAxis: { low: "Low Growth", high: "High Growth" },
+    annotations: [
+      { q: 1, label: "Question Marks" },
+      { q: 2, label: "Stars" },
+      { q: 3, label: "Cash Cows" },
+      { q: 4, label: "Dogs" }
+    ]
+  },
+  "ansoff": {
+    grid: "2x2",
+    xAxis: { low: "Existing Products", high: "New Products" },
+    yAxis: { low: "Existing Markets", high: "New Markets" },
+    annotations: [
+      { q: 1, label: "Diversification" },
+      { q: 2, label: "Market Development" },
+      { q: 3, label: "Market Penetration" },
+      { q: 4, label: "Product Development" }
+    ]
+  },
+  "johari": {
+    grid: "2x2",
+    xAxis: { low: "Known to Self", high: "Not Known to Self" },
+    yAxis: { low: "Not Known to Others", high: "Known to Others" },
+    annotations: [
+      { q: 1, label: "Blind" },
+      { q: 2, label: "Open / Arena" },
+      { q: 3, label: "Hidden / Fa\xE7ade" },
+      { q: 4, label: "Unknown" }
+    ]
+  },
+  "9-box": {
+    grid: "3x3",
+    cols: 3,
+    rows: 3,
+    xAxis: { low: "Low Performance", high: "High Performance" },
+    yAxis: { low: "Low Potential", high: "High Potential" },
+    cellLabels: [
+      { col: 0, row: 2, label: "Enigma" },
+      { col: 1, row: 2, label: "Growth Employee" },
+      { col: 2, row: 2, label: "Future Leader" },
+      { col: 0, row: 1, label: "Dilemma" },
+      { col: 1, row: 1, label: "Core Player" },
+      { col: 2, row: 1, label: "High Impact" },
+      { col: 0, row: 0, label: "Under-performer" },
+      { col: 1, row: 0, label: "Effective" },
+      { col: 2, row: 0, label: "Trusted Pro" }
+    ]
+  },
+  "risk-matrix": {
+    grid: "NxM",
+    mode: "heatmap",
+    cols: 5,
+    rows: 5,
+    xAxis: { low: "Negligible", high: "Severe" },
+    yAxis: { low: "Rare", high: "Certain" },
+    rowLabels: ["Rare", "Unlikely", "Possible", "Likely", "Certain"],
+    colLabels: ["Negligible", "Minor", "Moderate", "Major", "Severe"]
+  }
+};
+function resolveTemplate(name) {
+  if (name in TEMPLATES) return TEMPLATES[name];
+  return void 0;
+}
+function applyTemplateDefaults(ast, spec) {
+  if (spec.grid === "3x3") {
+    ast.grid = "3x3";
+    ast.cols = 3;
+    ast.rows = 3;
+  } else if (spec.grid === "NxM") {
+    ast.grid = "NxM";
+    ast.cols = spec.cols ?? 5;
+    ast.rows = spec.rows ?? 5;
+  } else {
+    ast.grid = "2x2";
+    ast.cols = 2;
+    ast.rows = 2;
+  }
+  if (spec.mode) ast.mode = spec.mode;
+  if (!ast.xAxis.low && !ast.xAxis.high) ast.xAxis = { ...spec.xAxis };
+  if (!ast.yAxis.low && !ast.yAxis.high) ast.yAxis = { ...spec.yAxis };
+  if (spec.annotations && ast.annotations.length === 0) {
+    ast.annotations = spec.annotations.map((a) => ({ ...a }));
+  }
+  if (spec.cellLabels && ast.cellLabels.length === 0) {
+    ast.cellLabels = spec.cellLabels.map((c) => ({ ...c }));
+  }
+  if (spec.rowLabels && !ast.rowLabels) ast.rowLabels = [...spec.rowLabels];
+  if (spec.colLabels && !ast.colLabels) ast.colLabels = [...spec.colLabels];
+}
+
+// src/diagrams/matrix/parser.ts
+var TEMPLATE_NAMES = /* @__PURE__ */ new Set([
+  "eisenhower",
+  "impact-effort",
+  "rice",
+  "bcg",
+  "ansoff",
+  "johari",
+  "9-box",
+  "risk-matrix"
+]);
+var DEFAULT_CONFIG = {
+  quadrantBg: true,
+  gridLines: true,
+  axisArrows: true,
+  labelCollision: "auto",
+  bubbleScale: "area",
+  quadrantAnnotations: true,
+  legendPosition: "bottom-right",
+  offChartPolicy: "clamp-badge",
+  showAxis: "auto",
+  margins: false
+};
+function emptyAxis() {
+  return { low: "", high: "" };
+}
+function newAST() {
+  return {
+    type: "matrix",
+    mode: "quadrant",
+    grid: "2x2",
+    cols: 2,
+    rows: 2,
+    xAxis: emptyAxis(),
+    yAxis: emptyAxis(),
+    points: [],
+    cells: [],
+    cellLabels: [],
+    annotations: [],
+    config: { ...DEFAULT_CONFIG }
+  };
+}
+function stripQuotes(s) {
+  const t = s.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function readQuoted2(line2, from) {
+  let i = from;
+  while (i < line2.length && /\s/.test(line2[i])) i++;
+  if (line2[i] !== '"' && line2[i] !== "'") return null;
+  const quote = line2[i];
+  const start = i + 1;
+  let end = start;
+  while (end < line2.length && line2[end] !== quote) end++;
+  if (end >= line2.length) return null;
+  return { text: line2.slice(start, end), next: end + 1 };
+}
+function parseAxis(raw) {
+  const arrowMatch = raw.match(/\s*(→|↑|->|>|↓|←|<-|<)\s*/);
+  if (arrowMatch) {
+    const arrow = arrowMatch[1];
+    const idx = arrowMatch.index;
+    const left = raw.slice(0, idx).trim();
+    const right = raw.slice(idx + arrowMatch[0].length).trim();
+    const reversed = arrow === "\u2190" || arrow === "<-" || arrow === "<";
+    if (reversed) {
+      return { low: right, high: left, reversed: true };
+    }
+    return { low: left, high: right };
+  }
+  return { low: "", high: raw.trim() };
+}
+function parseNumberList2(raw) {
+  const t = raw.trim();
+  const inner = t.startsWith("[") && t.endsWith("]") ? t.slice(1, -1) : t;
+  return inner.split(",").map((s) => stripQuotes(s.trim())).filter((s) => s.length > 0);
+}
+function parseProperties2(raw, point) {
+  let i = 0;
+  while (i < raw.length) {
+    while (i < raw.length && /\s/.test(raw[i])) i++;
+    if (i >= raw.length) break;
+    const keyMatch = raw.slice(i).match(/^([a-zA-Z_-]+)\s*:\s*/);
+    if (!keyMatch) break;
+    const key = keyMatch[1].toLowerCase();
+    i += keyMatch[0].length;
+    if (raw[i] === '"' || raw[i] === "'") {
+      const q = readQuoted2(raw, i);
+      if (!q) break;
+      if (key === "note") point.note = q.text;
+      else if (key === "label") point.label = q.text;
+      i = q.next;
+    } else {
+      const rest = raw.slice(i);
+      const endMatch = rest.match(/\s+[a-zA-Z_-]+\s*:/);
+      const end = endMatch ? endMatch.index : rest.length;
+      const val = rest.slice(0, end).trim();
+      i += end;
+      if (key === "size") {
+        const n = Number(val);
+        if (!Number.isNaN(n)) point.size = n;
+      } else if (key === "category") {
+        point.category = val;
+      } else if (key === "color") {
+        point.color = val;
+      } else if (key === "shape") {
+        if (val === "circle" || val === "square" || val === "triangle" || val === "diamond") {
+          point.shape = val;
+        }
+      } else if (key === "highlight") {
+        point.highlight = val === "true" || val === "1";
+      }
+    }
+  }
+}
+function parsePointLine(line2, st) {
+  const q = readQuoted2(line2, 0);
+  if (!q) return false;
+  const rest = line2.slice(q.next).trim();
+  const atMatch = rest.match(/^at\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*(.*)$/);
+  if (!atMatch) return false;
+  const x = Number(atMatch[1]);
+  const y = Number(atMatch[2]);
+  const props = atMatch[3];
+  const offChart = x < 0 || x > 1 || y < 0 || y > 1;
+  const clampedX = Math.max(0, Math.min(1, x));
+  const clampedY = Math.max(0, Math.min(1, y));
+  const point = {
+    id: `p${st.pointIdSeq++}`,
+    label: q.text,
+    x: clampedX,
+    y: clampedY,
+    offChart,
+    origX: offChart ? x : void 0,
+    origY: offChart ? y : void 0
+  };
+  if (props) parseProperties2(props, point);
+  st.ast.points.push(point);
+  return true;
+}
+function parseCellLine(line2, st) {
+  const m = line2.match(/^cell\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)\s*(.*)$/i);
+  if (!m) return false;
+  const col = Number(m[1]);
+  const row = Number(m[2]);
+  const rest = m[3];
+  const cell = { col, row };
+  const valMatch = rest.match(/value:\s*(-?\d+(?:\.\d+)?)/i);
+  if (valMatch) cell.value = Number(valMatch[1]);
+  const labMatch = rest.match(/label:\s*"([^"]*)"/i);
+  if (labMatch) cell.label = labMatch[1];
+  const lvlMatch = rest.match(/level:\s*(strong|medium|weak)\b/i);
+  if (lvlMatch) {
+    const lv = lvlMatch[1].toLowerCase();
+    cell.level = lv;
+    if (cell.value === void 0) cell.value = lv === "strong" ? 3 : lv === "medium" ? 2 : 1;
+  }
+  st.ast.cells.push(cell);
+  if (cell.label) {
+    st.ast.cellLabels.push({ col, row, label: cell.label });
+  }
+  return true;
+}
+function parseConfigLine(key, value, ast) {
+  const k = key.trim().toLowerCase();
+  const v = value.trim();
+  if (k === "quadrantbg") ast.config.quadrantBg = v === "true";
+  else if (k === "gridlines") ast.config.gridLines = v === "true";
+  else if (k === "axisarrows") ast.config.axisArrows = v === "true";
+  else if (k === "labelcollision") ast.config.labelCollision = v.replace(/"/g, "");
+  else if (k === "bubblescale") ast.config.bubbleScale = v === "radius" ? "radius" : "area";
+  else if (k === "quadrantannotations") ast.config.quadrantAnnotations = v === "true";
+  else if (k === "legendposition") {
+    const t = v.replace(/"/g, "");
+    ast.config.legendPosition = t;
+  } else if (k === "offchartpolicy") {
+    const t = v.replace(/"/g, "");
+    ast.config.offChartPolicy = t;
+  }
+}
+function parseHeader(line2, ast) {
+  const t = line2.trim();
+  const rest = t.slice("matrix".length).trim();
+  const heatMatch = rest.match(/^heatmap\s+(\d+)\s*x\s*(\d+)\s*(.*)$/i);
+  if (heatMatch) {
+    ast.mode = "heatmap";
+    ast.grid = "NxM";
+    ast.cols = Number(heatMatch[1]);
+    ast.rows = Number(heatMatch[2]);
+    const title2 = heatMatch[3].trim();
+    if (title2) ast.title = stripQuotes(title2);
+    return void 0;
+  }
+  const corrMatch = rest.match(/^correlation\s*(?:(\d+)\s*x\s*(\d+))?\s*(.*)$/i);
+  if (corrMatch) {
+    ast.mode = "correlation";
+    ast.grid = "NxM";
+    if (corrMatch[1] && corrMatch[2]) {
+      ast.cols = Number(corrMatch[1]);
+      ast.rows = Number(corrMatch[2]);
+    }
+    const title2 = corrMatch[3].trim();
+    if (title2) ast.title = stripQuotes(title2);
+    return void 0;
+  }
+  const tokenMatch = rest.match(/^([a-zA-Z0-9_-]+)\s*(.*)$/);
+  if (tokenMatch) {
+    const tok = tokenMatch[1].toLowerCase();
+    const remainder = tokenMatch[2].trim();
+    if (TEMPLATE_NAMES.has(tok)) {
+      if (remainder) ast.title = stripQuotes(remainder);
+      return tok;
+    }
+    if (rest.startsWith('"') || rest.startsWith("'")) {
+      ast.title = stripQuotes(rest);
+    } else if (rest.length > 0) {
+      ast.title = stripQuotes(rest);
+    }
+  }
+  return void 0;
+}
+function parseMatrix(text2) {
+  const st = { ast: newAST(), pointIdSeq: 0 };
+  const lines = text2.split(/\r?\n/);
+  let templateName;
+  let inConfig = false;
+  for (let raw of lines) {
+    let line2 = raw;
+    const hashIdx = findCommentStart(line2);
+    if (hashIdx >= 0) line2 = line2.slice(0, hashIdx);
+    line2 = line2.trim();
+    if (!line2) {
+      inConfig = false;
+      continue;
+    }
+    if (/^matrix\b/i.test(line2)) {
+      templateName = parseHeader(line2, st.ast);
+      continue;
+    }
+    if (/^config\s*:/i.test(line2)) {
+      inConfig = true;
+      continue;
+    }
+    if (inConfig) {
+      const kv = line2.match(/^([a-zA-Z]+)\s*:\s*(.+)$/);
+      if (kv) {
+        parseConfigLine(kv[1], kv[2], st.ast);
+        continue;
+      }
+      inConfig = false;
+    }
+    if (/^title\s*:/i.test(line2)) {
+      st.ast.title = stripQuotes(line2.replace(/^title\s*:\s*/i, ""));
+      continue;
+    }
+    if (/^x-axis\s*:/i.test(line2)) {
+      st.ast.xAxis = parseAxis(line2.replace(/^x-axis\s*:\s*/i, ""));
+      continue;
+    }
+    if (/^y-axis\s*:/i.test(line2)) {
+      st.ast.yAxis = parseAxis(line2.replace(/^y-axis\s*:\s*/i, ""));
+      continue;
+    }
+    if (/^rows\s*:/i.test(line2)) {
+      st.ast.rowLabels = parseNumberList2(line2.replace(/^rows\s*:\s*/i, ""));
+      if (st.ast.mode !== "quadrant") st.ast.rows = st.ast.rowLabels.length;
+      continue;
+    }
+    if (/^cols\s*:/i.test(line2)) {
+      st.ast.colLabels = parseNumberList2(line2.replace(/^cols\s*:\s*/i, ""));
+      if (st.ast.mode !== "quadrant") st.ast.cols = st.ast.colLabels.length;
+      continue;
+    }
+    if (/^grid\s*:/i.test(line2)) {
+      const v = line2.replace(/^grid\s*:\s*/i, "").trim().toLowerCase();
+      const gm = v.match(/^(\d+)\s*x\s*(\d+)$/);
+      if (gm) {
+        const c = Number(gm[1]);
+        const r = Number(gm[2]);
+        st.ast.cols = c;
+        st.ast.rows = r;
+        if (c === 2 && r === 2) st.ast.grid = "2x2";
+        else if (c === 3 && r === 3) st.ast.grid = "3x3";
+        else st.ast.grid = "NxM";
+      }
+      continue;
+    }
+    if (/^quadrant\s+/i.test(line2)) {
+      const m = line2.match(/^quadrant\s+(?:Q)?(\d)\s*"([^"]*)"(.*)$/i);
+      if (m) {
+        const q = Number(m[1]);
+        const rest = m[3].trim();
+        const descMatch = rest.match(/description:\s*"([^"]*)"/i);
+        const description = descMatch ? descMatch[1] : void 0;
+        if (q >= 1 && q <= 4) {
+          const existing = st.ast.annotations.find((a) => a.q === q);
+          if (existing) {
+            existing.label = m[2];
+            if (description) existing.description = description;
+          } else {
+            st.ast.annotations.push({ q, label: m[2], description });
+          }
+        }
+      }
+      continue;
+    }
+    if (/^axis\s*:/i.test(line2)) {
+      const v = line2.replace(/^axis\s*:\s*/i, "").trim().toLowerCase().replace(/"/g, "");
+      if (v === "none" || v === "off" || v === "hidden") st.ast.config.showAxis = "off";
+      else if (v === "on" || v === "show" || v === "visible") st.ast.config.showAxis = "on";
+      else st.ast.config.showAxis = "auto";
+      continue;
+    }
+    if (/^margins\s*:/i.test(line2)) {
+      const v = line2.replace(/^margins\s*:\s*/i, "").trim().toLowerCase();
+      st.ast.config.margins = v === "true" || v === "on" || v === "1";
+      continue;
+    }
+    if (/^cell\s*\(/i.test(line2)) {
+      parseCellLine(line2, st);
+      continue;
+    }
+    if (line2.startsWith('"') || line2.startsWith("'")) {
+      if (parsePointLine(line2, st)) continue;
+    }
+  }
+  if (templateName) {
+    const spec = resolveTemplate(templateName);
+    if (spec) {
+      applyTemplateDefaults(st.ast, spec);
+      st.ast.template = templateName;
+    }
+  }
+  if (st.ast.cols === 3 && st.ast.rows === 3 && st.ast.grid !== "NxM") {
+    st.ast.grid = "3x3";
+  }
+  if (st.ast.mode === "heatmap" || st.ast.mode === "correlation") st.ast.grid = "NxM";
+  return st.ast;
+}
+function findCommentStart(line2) {
+  let inQuote = null;
+  for (let i = 0; i < line2.length; i++) {
+    const ch = line2[i];
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null;
+    } else if (ch === '"' || ch === "'") {
+      inQuote = ch;
+    } else if (ch === "#") {
+      return i;
+    }
+  }
+  return -1;
+}
+
+// src/diagrams/matrix/layout.ts
+var CANVAS_W = 720;
+var CANVAS_H = 560;
+var PADDING_X = 110;
+var PADDING_Y = 90;
+var CHAR_W = 6.2;
+var LABEL_H = 14;
+function estimateWidth(text2) {
+  const cjk = (text2.match(/[\u3000-\u9fff]/g) ?? []).length;
+  return (text2.length - cjk) * CHAR_W + cjk * 12 + 8;
+}
+function clamp01(v) {
+  return Math.max(0.02, Math.min(0.98, v));
+}
+function placePoint(p, plot) {
+  const nx = clamp01(p.x);
+  const ny = clamp01(p.y);
+  const px = plot.x0 + nx * plot.w;
+  const py = plot.y0 + (1 - ny) * plot.h;
+  return { px, py };
+}
+function computeRadius(p, maxSize, plot, scale) {
+  if (p.size === void 0) return 6;
+  const maxRadius = Math.max(14, plot.h * 0.08);
+  const minRadius = 4;
+  if (maxSize <= 0) return 6;
+  const ratio = p.size / maxSize;
+  if (scale === "radius") {
+    return Math.max(minRadius, ratio * maxRadius);
+  }
+  const maxArea = Math.PI * maxRadius * maxRadius;
+  const area = ratio * maxArea;
+  const r = Math.sqrt(area / Math.PI);
+  return Math.max(minRadius, r);
+}
+function resolveLabelCollisions(points, plot, mode) {
+  if (mode === "off") {
+    for (const p of points) {
+      p.label.lx = p.px + p.r + 4 + p.label.width / 2;
+      p.label.ly = p.py - p.r - 4;
+    }
+    return;
+  }
+  for (const p of points) {
+    p.label.ax = p.px;
+    p.label.ay = p.py;
+    p.label.lx = p.px + p.r + 4 + p.label.width / 2;
+    p.label.ly = p.py - p.r - 4;
+    p.label.external = false;
+    p.label.textAnchor = "middle";
+  }
+  if (mode === "leader-only") {
+    for (const p of points) {
+      p.label.external = true;
+      p.label.lx = p.px + p.r + 12 + p.label.width / 2;
+      p.label.ly = p.py;
+      p.label.textAnchor = "middle";
+    }
+    return;
+  }
+  const PAD = 3;
+  for (let iter = 0; iter < 30; iter++) {
+    let moved = false;
+    for (let i = 0; i < points.length; i++) {
+      for (let j = i + 1; j < points.length; j++) {
+        const a = points[i].label;
+        const b = points[j].label;
+        const ax0 = a.lx - a.width / 2 - PAD;
+        const ax1 = a.lx + a.width / 2 + PAD;
+        const ay0 = a.ly - a.height / 2 - PAD;
+        const ay1 = a.ly + a.height / 2 + PAD;
+        const bx0 = b.lx - b.width / 2 - PAD;
+        const bx1 = b.lx + b.width / 2 + PAD;
+        const by0 = b.ly - b.height / 2 - PAD;
+        const by1 = b.ly + b.height / 2 + PAD;
+        const overlapX = Math.min(ax1, bx1) - Math.max(ax0, bx0);
+        const overlapY = Math.min(ay1, by1) - Math.max(ay0, by0);
+        if (overlapX > 0 && overlapY > 0) {
+          const dx = a.lx - b.lx || 0.1;
+          const dy = a.ly - b.ly || 0.1;
+          const len = Math.hypot(dx, dy) || 1;
+          const ux = dx / len;
+          const uy = dy / len;
+          const step = Math.min(3, Math.min(overlapX, overlapY) / 2 + 0.5);
+          a.lx += ux * step;
+          a.ly += uy * step;
+          b.lx -= ux * step;
+          b.ly -= uy * step;
+          moved = true;
+        }
+      }
+      const lb = points[i].label;
+      if (lb.lx - lb.width / 2 < plot.x0 + 2) lb.lx = plot.x0 + 2 + lb.width / 2;
+      if (lb.lx + lb.width / 2 > plot.x0 + plot.w - 2) lb.lx = plot.x0 + plot.w - 2 - lb.width / 2;
+      if (lb.ly - lb.height / 2 < plot.y0 + 2) lb.ly = plot.y0 + 2 + lb.height / 2;
+      if (lb.ly + lb.height / 2 > plot.y0 + plot.h - 2) lb.ly = plot.y0 + plot.h - 2 - lb.height / 2;
+    }
+    if (!moved) break;
+  }
+  if (mode === "auto") {
+    for (const p of points) {
+      const dx = p.label.lx - p.px;
+      const dy = p.label.ly - p.py;
+      if (Math.hypot(dx, dy) > 40) {
+        p.label.external = true;
+      }
+    }
+  }
+}
+function layoutMatrix(ast) {
+  const canvasWidth = CANVAS_W;
+  const canvasHeight = CANVAS_H;
+  const plot = {
+    x0: PADDING_X,
+    y0: PADDING_Y - 30,
+    w: canvasWidth - PADDING_X * 2,
+    h: canvasHeight - PADDING_Y * 2
+  };
+  const points = [];
+  const categoriesSet = /* @__PURE__ */ new Set();
+  if (ast.mode === "quadrant") {
+    let maxSize = 0;
+    for (const p of ast.points) {
+      if (p.size !== void 0 && p.size > maxSize) maxSize = p.size;
+    }
+    for (const p of ast.points) {
+      const { px, py } = placePoint(p, plot);
+      const r = computeRadius(p, maxSize, plot, ast.config.bubbleScale);
+      const width = estimateWidth(p.label);
+      const label = {
+        text: p.label,
+        ax: px,
+        ay: py,
+        lx: px + r + 4 + width / 2,
+        ly: py - r - 4,
+        width,
+        height: LABEL_H,
+        external: false,
+        textAnchor: "middle"
+      };
+      points.push({ point: p, px, py, r, label });
+      if (p.category) categoriesSet.add(p.category);
+    }
+    resolveLabelCollisions(points, plot, ast.config.labelCollision);
+  }
+  return {
+    canvasWidth,
+    canvasHeight,
+    plot,
+    points,
+    categories: [...categoriesSet]
+  };
+}
+
+// src/diagrams/matrix/renderer.ts
+var CATEGORY_COLORS = [
+  "#2563eb",
+  "#16a34a",
+  "#dc2626",
+  "#9333ea",
+  "#ea580c",
+  "#0891b2",
+  "#ca8a04",
+  "#db2777"
+];
+var QUADRANT_TINTS = [
+  // Q1 TR, Q2 TL, Q3 BL, Q4 BR
+  "#dbeafe",
+  "#dcfce7",
+  "#f3f4f6",
+  "#fed7aa"
+];
+var HEAT_RAMP = [
+  "#f0fdf4",
+  "#bbf7d0",
+  "#fde68a",
+  "#fdba74",
+  "#f87171",
+  "#ef4444",
+  "#b91c1c"
+];
+var CSS = `
+.sx-matrix { background: #fff; font-family: system-ui, -apple-system, "Segoe UI", sans-serif; }
+.sx-matrix-title { font: 600 16px sans-serif; fill: #111; }
+.sx-matrix-grid { stroke: #e5e7eb; stroke-width: 1; fill: none; }
+.sx-matrix-mid { stroke: #9ca3af; stroke-width: 1.2; stroke-dasharray: 4 3; fill: none; }
+.sx-matrix-plot-border { stroke: #374151; stroke-width: 1.2; fill: none; }
+.sx-matrix-axis-label { font: 500 12px sans-serif; fill: #374151; }
+.sx-matrix-axis-end { font: 500 11px sans-serif; fill: #6b7280; }
+.sx-matrix-quad-annot { font: 600 13px sans-serif; fill: #475569; opacity: 0.75; }
+.sx-matrix-quad-desc { font: 400 10.5px sans-serif; fill: #64748b; opacity: 0.85; }
+.sx-matrix-corr-header { font: 600 11.5px sans-serif; fill: #1f2937; text-anchor: middle; }
+.sx-matrix-corr-rowlabel { font: 500 11.5px sans-serif; fill: #1f2937; text-anchor: end; dominant-baseline: central; }
+.sx-matrix-corr-margin { font: 500 11px sans-serif; fill: #374151; text-anchor: middle; dominant-baseline: central; }
+.sx-matrix-corr-margin-best { font: 700 11.5px sans-serif; fill: #111; text-anchor: middle; dominant-baseline: central; }
+.sx-matrix-corr-grid { stroke: #d1d5db; stroke-width: 0.8; fill: none; }
+.sx-matrix-corr-rowbg-a { fill: #f0fdf4; }
+.sx-matrix-corr-rowbg-b { fill: #fff; }
+.sx-matrix-cell-label { font: 500 12px sans-serif; fill: #1f2937; text-anchor: middle; }
+.sx-matrix-cell-value { font: 600 18px sans-serif; fill: #111; text-anchor: middle; }
+.sx-matrix-bubble { stroke-width: 1.5; }
+.sx-matrix-label { font: 500 11px sans-serif; fill: #111827; text-anchor: middle; dominant-baseline: central; pointer-events: none; }
+.sx-matrix-leader { stroke: #94a3b8; stroke-width: 0.6; opacity: 0.7; fill: none; }
+.sx-matrix-legend-text { font: 500 11px sans-serif; fill: #374151; }
+.sx-matrix-offchart { fill: #ea580c; }
+`.trim();
+function axisArrow() {
+  return el(
+    "marker",
+    {
+      id: "sx-matrix-arrow",
+      viewBox: "0 0 10 10",
+      refX: 8,
+      refY: 5,
+      markerWidth: 8,
+      markerHeight: 8,
+      orient: "auto-start-reverse"
+    },
+    [el("path", { d: "M0,0 L10,5 L0,10 z", fill: "#374151" })]
+  );
+}
+function bubbleFill(p, categories) {
+  if (p.color) return p.color;
+  if (p.category) {
+    const idx = categories.indexOf(p.category);
+    if (idx >= 0) return CATEGORY_COLORS[idx % CATEGORY_COLORS.length];
+  }
+  return "#2563eb";
+}
+function renderQuadrantBackground(ast, lay) {
+  if (!ast.config.quadrantBg || ast.grid !== "2x2") return "";
+  const { plot } = lay;
+  const halfW = plot.w / 2;
+  const halfH = plot.h / 2;
+  const rects = [
+    { x: plot.x0 + halfW, y: plot.y0, w: halfW, h: halfH, fill: QUADRANT_TINTS[0] },
+    { x: plot.x0, y: plot.y0, w: halfW, h: halfH, fill: QUADRANT_TINTS[1] },
+    { x: plot.x0, y: plot.y0 + halfH, w: halfW, h: halfH, fill: QUADRANT_TINTS[2] },
+    { x: plot.x0 + halfW, y: plot.y0 + halfH, w: halfW, h: halfH, fill: QUADRANT_TINTS[3] }
+  ];
+  return group(
+    { id: "sx-matrix-quad-bg" },
+    rects.map(
+      (r) => rect({ x: r.x, y: r.y, width: r.w, height: r.h, fill: r.fill, "fill-opacity": 0.55 })
+    )
+  );
+}
+function renderGrid(ast, lay) {
+  if (!ast.config.gridLines) return "";
+  if (ast.mode === "correlation") return "";
+  const { plot } = lay;
+  const lines = [];
+  const cols = ast.cols;
+  const rows = ast.rows;
+  for (let i = 1; i < cols; i++) {
+    const x = plot.x0 + plot.w * i / cols;
+    const cls = cols === 2 && i === 1 ? "sx-matrix-mid" : "sx-matrix-grid";
+    lines.push(line({ x1: x, y1: plot.y0, x2: x, y2: plot.y0 + plot.h, class: cls }));
+  }
+  for (let j = 1; j < rows; j++) {
+    const y = plot.y0 + plot.h * j / rows;
+    const cls = rows === 2 && j === 1 ? "sx-matrix-mid" : "sx-matrix-grid";
+    lines.push(line({ x1: plot.x0, y1: y, x2: plot.x0 + plot.w, y2: y, class: cls }));
+  }
+  lines.push(
+    rect({
+      x: plot.x0,
+      y: plot.y0,
+      width: plot.w,
+      height: plot.h,
+      class: "sx-matrix-plot-border",
+      fill: "none"
+    })
+  );
+  return group({ id: "sx-matrix-grid" }, lines);
+}
+function shouldShowAxis(ast) {
+  if (ast.config.showAxis === "on") return true;
+  if (ast.config.showAxis === "off") return false;
+  return ast.mode === "quadrant";
+}
+function renderAxes(ast, lay) {
+  if (!shouldShowAxis(ast)) return "";
+  const { plot } = lay;
+  const els = [];
+  const marker = ast.config.axisArrows ? { "marker-end": "url(#sx-matrix-arrow)" } : {};
+  const xy = plot.y0 + plot.h + 14;
+  const yx = plot.x0 - 14;
+  els.push(
+    line({
+      x1: plot.x0,
+      y1: xy,
+      x2: plot.x0 + plot.w,
+      y2: xy,
+      stroke: "#374151",
+      "stroke-width": 1.2,
+      ...marker
+    })
+  );
+  els.push(
+    line({
+      x1: yx,
+      y1: plot.y0 + plot.h,
+      x2: yx,
+      y2: plot.y0,
+      stroke: "#374151",
+      "stroke-width": 1.2,
+      ...marker
+    })
+  );
+  if (ast.xAxis.low) {
+    els.push(
+      text(
+        { x: plot.x0, y: xy + 20, class: "sx-matrix-axis-end", "text-anchor": "start" },
+        ast.xAxis.low
+      )
+    );
+  }
+  if (ast.xAxis.high) {
+    els.push(
+      text(
+        { x: plot.x0 + plot.w, y: xy + 20, class: "sx-matrix-axis-end", "text-anchor": "end" },
+        ast.xAxis.high
+      )
+    );
+  }
+  if (ast.yAxis.low) {
+    els.push(
+      text(
+        {
+          x: yx - 24,
+          y: plot.y0 + plot.h,
+          class: "sx-matrix-axis-end",
+          "text-anchor": "end",
+          transform: `rotate(-90 ${yx - 24} ${plot.y0 + plot.h})`
+        },
+        ast.yAxis.low
+      )
+    );
+  }
+  if (ast.yAxis.high) {
+    els.push(
+      text(
+        {
+          x: yx - 24,
+          y: plot.y0,
+          class: "sx-matrix-axis-end",
+          "text-anchor": "start",
+          transform: `rotate(-90 ${yx - 24} ${plot.y0})`
+        },
+        ast.yAxis.high
+      )
+    );
+  }
+  return group({ id: "sx-matrix-axes" }, els);
+}
+function renderQuadAnnotations(ast, lay) {
+  if (!ast.config.quadrantAnnotations || ast.grid !== "2x2" || ast.annotations.length === 0) return "";
+  const { plot } = lay;
+  plot.w / 2;
+  plot.h / 2;
+  const padding = 14;
+  const positions = {
+    1: { x: plot.x0 + plot.w - padding, y: plot.y0 + padding + 14, anchor: "end" },
+    // TR
+    2: { x: plot.x0 + padding, y: plot.y0 + padding + 14, anchor: "start" },
+    // TL
+    3: { x: plot.x0 + padding, y: plot.y0 + plot.h - padding, anchor: "start" },
+    // BL
+    4: { x: plot.x0 + plot.w - padding, y: plot.y0 + plot.h - padding, anchor: "end" }
+    // BR
+  };
+  const nodes = [];
+  for (const a of ast.annotations) {
+    const pos = positions[a.q];
+    const growsUp = a.q === 3 || a.q === 4;
+    const descLines = a.description ? wrapLabel(a.description, 28) : [];
+    const labelY = growsUp && descLines.length > 0 ? pos.y - descLines.length * 12 : pos.y;
+    nodes.push(
+      text(
+        { x: pos.x, y: labelY, class: "sx-matrix-quad-annot", "text-anchor": pos.anchor },
+        a.label
+      )
+    );
+    for (let i = 0; i < descLines.length; i++) {
+      nodes.push(
+        text(
+          {
+            x: pos.x,
+            y: labelY + 14 + i * 12,
+            class: "sx-matrix-quad-desc",
+            "text-anchor": pos.anchor
+          },
+          descLines[i]
+        )
+      );
+    }
+  }
+  return group({ id: "sx-matrix-quad-annot" }, nodes);
+}
+function wrapLabel(text2, maxChars) {
+  const words = text2.split(/\s+/);
+  const out = [];
+  let cur = "";
+  for (const w of words) {
+    if ((cur + " " + w).trim().length > maxChars) {
+      if (cur) out.push(cur);
+      cur = w;
+    } else {
+      cur = (cur ? cur + " " : "") + w;
+    }
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+function render3x3CellLabels(ast, lay) {
+  if (ast.grid !== "3x3" || ast.cellLabels.length === 0) return "";
+  const { plot } = lay;
+  const cellW = plot.w / ast.cols;
+  const cellH = plot.h / ast.rows;
+  const nodes = ast.cellLabels.map((cl) => {
+    const cx = plot.x0 + cellW * (cl.col + 0.5);
+    const cy = plot.y0 + cellH * (ast.rows - 1 - cl.row + 0.5);
+    return text({ x: cx, y: cy, class: "sx-matrix-cell-label" }, cl.label);
+  });
+  return group({ id: "sx-matrix-cell-labels" }, nodes);
+}
+function renderHeatmap(ast, lay) {
+  if (ast.mode !== "heatmap") return "";
+  const { plot } = lay;
+  const cellW = plot.w / ast.cols;
+  const cellH = plot.h / ast.rows;
+  const maxVal = Math.max(
+    1,
+    ...ast.cells.map((c) => c.value ?? (c.col + 1) * (c.row + 1))
+  );
+  const cells = [];
+  for (let col = 0; col < ast.cols; col++) {
+    for (let row = 0; row < ast.rows; row++) {
+      const found = ast.cells.find((c) => c.col === col && c.row === row);
+      const value = found?.value ?? (col + 1) * (row + 1);
+      const ratio = Math.min(1, value / maxVal);
+      const idx = Math.min(HEAT_RAMP.length - 1, Math.floor(ratio * HEAT_RAMP.length));
+      const color = HEAT_RAMP[idx];
+      const x = plot.x0 + col * cellW;
+      const y = plot.y0 + (ast.rows - 1 - row) * cellH;
+      cells.push(
+        rect({
+          x,
+          y,
+          width: cellW,
+          height: cellH,
+          fill: color,
+          stroke: "#fff",
+          "stroke-width": 2
+        })
+      );
+    }
+  }
+  if (ast.rowLabels) {
+    for (let row = 0; row < ast.rows; row++) {
+      const lbl = ast.rowLabels[row];
+      if (!lbl) continue;
+      const y = plot.y0 + (ast.rows - 1 - row + 0.5) * cellH;
+      cells.push(
+        text(
+          {
+            x: plot.x0 - 8,
+            y,
+            class: "sx-matrix-axis-end",
+            "text-anchor": "end",
+            "dominant-baseline": "central"
+          },
+          lbl
+        )
+      );
+    }
+  }
+  if (ast.colLabels) {
+    for (let col = 0; col < ast.cols; col++) {
+      const lbl = ast.colLabels[col];
+      if (!lbl) continue;
+      const x = plot.x0 + (col + 0.5) * cellW;
+      cells.push(
+        text(
+          {
+            x,
+            y: plot.y0 + plot.h + 16,
+            class: "sx-matrix-axis-end",
+            "text-anchor": "middle"
+          },
+          lbl
+        )
+      );
+    }
+  }
+  for (const cl of ast.cellLabels) {
+    const cx = plot.x0 + cellW * (cl.col + 0.5);
+    const cy = plot.y0 + cellH * (ast.rows - 1 - cl.row + 0.5);
+    const words = cl.label.split(/\s+/);
+    const lines = [];
+    let cur = "";
+    for (const w of words) {
+      if ((cur + " " + w).trim().length > 14) {
+        if (cur) lines.push(cur);
+        cur = w;
+      } else {
+        cur = (cur ? cur + " " : "") + w;
+      }
+    }
+    if (cur) lines.push(cur);
+    const lineH = 13;
+    const startY = cy - (lines.length - 1) * lineH / 2;
+    for (let i = 0; i < lines.length; i++) {
+      cells.push(
+        text(
+          {
+            x: cx,
+            y: startY + i * lineH,
+            class: "sx-matrix-cell-label",
+            "dominant-baseline": "central"
+          },
+          lines[i]
+        )
+      );
+    }
+  }
+  return group({ id: "sx-matrix-heatmap" }, cells);
+}
+var DOT_COLORS = {
+  strong: "#16a34a",
+  medium: "#86efac",
+  weak: "#9ca3af"
+};
+function levelFromValue(v) {
+  if (v >= 3) return "strong";
+  if (v >= 2) return "medium";
+  return "weak";
+}
+function renderCorrelation(ast, lay) {
+  if (ast.mode !== "correlation") return "";
+  const { plot } = lay;
+  const marginCols = ast.config.margins ? 2 : 0;
+  const marginRows = ast.config.margins ? 2 : 0;
+  const cellW = plot.w / (ast.cols + marginCols);
+  const cellH = plot.h / (ast.rows + marginRows);
+  const gridW = cellW * ast.cols;
+  const gridH = cellH * ast.rows;
+  const nodes = [];
+  for (let row = 0; row < ast.rows; row++) {
+    const y = plot.y0 + (ast.rows - 1 - row) * cellH;
+    nodes.push(
+      rect({
+        x: plot.x0,
+        y,
+        width: gridW,
+        height: cellH,
+        class: row % 2 === 0 ? "sx-matrix-corr-rowbg-a" : "sx-matrix-corr-rowbg-b"
+      })
+    );
+  }
+  for (let i = 0; i <= ast.cols; i++) {
+    const x = plot.x0 + i * cellW;
+    nodes.push(line({ x1: x, y1: plot.y0, x2: x, y2: plot.y0 + gridH, class: "sx-matrix-corr-grid" }));
+  }
+  for (let j = 0; j <= ast.rows; j++) {
+    const y = plot.y0 + j * cellH;
+    nodes.push(line({ x1: plot.x0, y1: y, x2: plot.x0 + gridW, y2: y, class: "sx-matrix-corr-grid" }));
+  }
+  const dotR = Math.max(4, Math.min(cellW, cellH) * 0.28);
+  const rowSums = new Array(ast.rows).fill(0);
+  const colSums = new Array(ast.cols).fill(0);
+  for (const c of ast.cells) {
+    if (c.col < 0 || c.col >= ast.cols || c.row < 0 || c.row >= ast.rows) continue;
+    const v = c.value ?? (c.level ? c.level === "strong" ? 3 : c.level === "medium" ? 2 : 1 : 0);
+    if (v <= 0) continue;
+    rowSums[c.row] += v;
+    colSums[c.col] += v;
+    const lvl = c.level ?? levelFromValue(v);
+    const cx = plot.x0 + (c.col + 0.5) * cellW;
+    const cy = plot.y0 + (ast.rows - 1 - c.row + 0.5) * cellH;
+    nodes.push(
+      circle({
+        cx,
+        cy,
+        r: dotR,
+        fill: DOT_COLORS[lvl],
+        stroke: DOT_COLORS[lvl],
+        "stroke-width": 1
+      })
+    );
+  }
+  if (ast.colLabels) {
+    for (let col = 0; col < ast.cols; col++) {
+      const label = ast.colLabels[col];
+      if (!label) continue;
+      const cx = plot.x0 + (col + 0.5) * cellW;
+      const lines = wrapLabel(label, 10);
+      const startY = plot.y0 - 8 - (lines.length - 1) * 12;
+      for (let i = 0; i < lines.length; i++) {
+        nodes.push(
+          text(
+            { x: cx, y: startY + i * 12, class: "sx-matrix-corr-header" },
+            lines[i]
+          )
+        );
+      }
+    }
+  }
+  if (ast.rowLabels) {
+    for (let row = 0; row < ast.rows; row++) {
+      const label = ast.rowLabels[row];
+      if (!label) continue;
+      const y = plot.y0 + (ast.rows - 1 - row + 0.5) * cellH;
+      nodes.push(
+        text({ x: plot.x0 - 8, y, class: "sx-matrix-corr-rowlabel" }, label)
+      );
+    }
+  }
+  if (ast.config.margins) {
+    const rowRanks = rankOf(rowSums);
+    const colRanks = rankOf(colSums);
+    const bestRow = rowSums.length > 0 ? Math.max(...rowSums) : 0;
+    const bestCol = colSums.length > 0 ? Math.max(...colSums) : 0;
+    const scoreColX = plot.x0 + gridW + cellW * 0.5;
+    const rankColX = plot.x0 + gridW + cellW * 1.5;
+    nodes.push(text({ x: scoreColX, y: plot.y0 - 8, class: "sx-matrix-corr-header" }, "Score"));
+    nodes.push(text({ x: rankColX, y: plot.y0 - 8, class: "sx-matrix-corr-header" }, "Rank"));
+    for (let row = 0; row < ast.rows; row++) {
+      const y = plot.y0 + (ast.rows - 1 - row + 0.5) * cellH;
+      const sum = rowSums[row];
+      const rank = rowRanks[row];
+      const cls = sum === bestRow && sum > 0 ? "sx-matrix-corr-margin-best" : "sx-matrix-corr-margin";
+      nodes.push(text({ x: scoreColX, y, class: cls }, String(sum)));
+      nodes.push(
+        text({ x: rankColX, y, class: rank === 1 ? "sx-matrix-corr-margin-best" : "sx-matrix-corr-margin" }, String(rank))
+      );
+    }
+    const scoreRowY = plot.y0 + gridH + cellH * 0.5;
+    const rankRowY = plot.y0 + gridH + cellH * 1.5;
+    nodes.push(
+      text(
+        { x: plot.x0 - 8, y: scoreRowY, class: "sx-matrix-corr-rowlabel" },
+        "Score"
+      )
+    );
+    nodes.push(
+      text(
+        { x: plot.x0 - 8, y: rankRowY, class: "sx-matrix-corr-rowlabel" },
+        "Rank"
+      )
+    );
+    for (let col = 0; col < ast.cols; col++) {
+      const cx = plot.x0 + (col + 0.5) * cellW;
+      const sum = colSums[col];
+      const rank = colRanks[col];
+      nodes.push(
+        text(
+          {
+            x: cx,
+            y: scoreRowY,
+            class: sum === bestCol && sum > 0 ? "sx-matrix-corr-margin-best" : "sx-matrix-corr-margin"
+          },
+          String(sum)
+        )
+      );
+      nodes.push(
+        text(
+          {
+            x: cx,
+            y: rankRowY,
+            class: rank === 1 ? "sx-matrix-corr-margin-best" : "sx-matrix-corr-margin"
+          },
+          String(rank)
+        )
+      );
+    }
+  }
+  return group({ id: "sx-matrix-correlation" }, nodes);
+}
+function rankOf(vals) {
+  const sorted = [...vals].map((v, i) => ({ v, i })).sort((a, b) => b.v - a.v);
+  const ranks = new Array(vals.length).fill(0);
+  let prev = -Infinity;
+  let rank = 0;
+  let seen = 0;
+  for (const e of sorted) {
+    seen++;
+    if (e.v !== prev) {
+      rank = seen;
+      prev = e.v;
+    }
+    ranks[e.i] = rank;
+  }
+  return ranks;
+}
+function renderCorrelationLegend(ast, lay) {
+  if (ast.mode !== "correlation") return "";
+  const xBase = lay.plot.x0 + lay.plot.w + 20;
+  const yBase = lay.plot.y0 + 8;
+  const items = [
+    ["strong", "Strong (3)"],
+    ["medium", "Medium (2)"],
+    ["weak", "Weak (1)"]
+  ];
+  const rows = items.map(
+    (it, i) => group({ transform: `translate(${xBase}, ${yBase + i * 18})` }, [
+      circle({ cx: 6, cy: 6, r: 5, fill: DOT_COLORS[it[0]], stroke: DOT_COLORS[it[0]] }),
+      text({ x: 18, y: 10, class: "sx-matrix-legend-text" }, it[1])
+    ])
+  );
+  return group({ id: "sx-matrix-corr-legend" }, rows);
+}
+function renderPoints(ast, lay) {
+  if (ast.mode !== "quadrant") return "";
+  const nodes = [];
+  for (const p of lay.points) {
+    nodes.push(renderOnePoint(p, lay.categories));
+  }
+  return group({ id: "sx-matrix-points" }, nodes);
+}
+function renderOnePoint(pl, categories) {
+  const p = pl.point;
+  const color = bubbleFill(p, categories);
+  const shape = p.shape ?? "circle";
+  let shapeEl;
+  const stroke = p.highlight ? "#111" : color;
+  const strokeWidth = p.highlight ? 2.2 : 1.5;
+  const fillOpacity = p.size !== void 0 ? 0.45 : 0.75;
+  if (shape === "circle") {
+    shapeEl = circle({
+      cx: pl.px,
+      cy: pl.py,
+      r: pl.r,
+      fill: color,
+      "fill-opacity": fillOpacity,
+      stroke,
+      "stroke-width": strokeWidth,
+      class: "sx-matrix-bubble"
+    });
+  } else if (shape === "square") {
+    shapeEl = rect({
+      x: pl.px - pl.r,
+      y: pl.py - pl.r,
+      width: pl.r * 2,
+      height: pl.r * 2,
+      fill: color,
+      "fill-opacity": fillOpacity,
+      stroke,
+      "stroke-width": strokeWidth,
+      class: "sx-matrix-bubble"
+    });
+  } else if (shape === "diamond") {
+    const r = pl.r;
+    shapeEl = polygon({
+      points: `${pl.px},${pl.py - r} ${pl.px + r},${pl.py} ${pl.px},${pl.py + r} ${pl.px - r},${pl.py}`,
+      fill: color,
+      "fill-opacity": fillOpacity,
+      stroke,
+      "stroke-width": strokeWidth,
+      class: "sx-matrix-bubble"
+    });
+  } else {
+    const r = pl.r;
+    shapeEl = polygon({
+      points: `${pl.px},${pl.py - r} ${pl.px + r},${pl.py + r * 0.8} ${pl.px - r},${pl.py + r * 0.8}`,
+      fill: color,
+      "fill-opacity": fillOpacity,
+      stroke,
+      "stroke-width": strokeWidth,
+      class: "sx-matrix-bubble"
+    });
+  }
+  const leader = pl.label.external ? line({
+    x1: pl.px,
+    y1: pl.py,
+    x2: pl.label.lx,
+    y2: pl.label.ly,
+    class: "sx-matrix-leader"
+  }) : "";
+  const label = text(
+    { x: pl.label.lx, y: pl.label.ly, class: "sx-matrix-label" },
+    pl.label.text
+  );
+  let badge = "";
+  if (p.offChart) {
+    const bx = pl.px;
+    const by = pl.py;
+    badge = text(
+      { x: bx + pl.r + 4, y: by - pl.r - 2, class: "sx-matrix-offchart", "font-size": 14, "font-weight": 700 },
+      "\u2197"
+    );
+  }
+  const titleStr = p.note ? `${p.label} \xB7 (${p.origX ?? p.x}, ${p.origY ?? p.y}) \u2014 ${p.note}` : `${p.label} \xB7 (${(p.origX ?? p.x).toFixed(2)}, ${(p.origY ?? p.y).toFixed(2)})${p.size !== void 0 ? ` \xB7 size ${p.size}` : ""}`;
+  return group(
+    {
+      class: "sx-matrix-point",
+      "data-point-id": p.id,
+      "data-label": p.label,
+      ...p.category ? { "data-category": p.category } : {}
+    },
+    [title(titleStr), shapeEl, leader, label, badge].filter((s) => s.length > 0)
+  );
+}
+function renderLegend2(ast, lay) {
+  if (ast.config.legendPosition === "none") return "";
+  if (ast.mode === "heatmap") {
+    const x = lay.plot.x0 + lay.plot.w - 220;
+    const y = lay.plot.y0 + lay.plot.h + 40;
+    const w = 210;
+    const h = 10;
+    const stops = HEAT_RAMP.map(
+      (c, i) => el("stop", { offset: `${i / (HEAT_RAMP.length - 1) * 100}%`, "stop-color": c })
+    );
+    const grad = el(
+      "linearGradient",
+      { id: "sx-matrix-heatgrad", x1: "0%", x2: "100%" },
+      stops
+    );
+    return group({ id: "sx-matrix-legend" }, [
+      el("defs", {}, [grad]),
+      rect({ x, y, width: w, height: h, fill: "url(#sx-matrix-heatgrad)", stroke: "#d1d5db" }),
+      text({ x, y: y - 4, class: "sx-matrix-legend-text", "text-anchor": "start" }, "Low"),
+      text(
+        { x: x + w, y: y - 4, class: "sx-matrix-legend-text", "text-anchor": "end" },
+        "High"
+      )
+    ]);
+  }
+  if (lay.categories.length === 0) return "";
+  const xBase = lay.plot.x0 + lay.plot.w + 12;
+  const yBase = lay.plot.y0 + 8;
+  const rows = lay.categories.map((cat, i) => {
+    const color = CATEGORY_COLORS[i % CATEGORY_COLORS.length];
+    return group({ transform: `translate(${xBase}, ${yBase + i * 18})` }, [
+      circle({ cx: 6, cy: 6, r: 5, fill: color, "fill-opacity": 0.7, stroke: color }),
+      text({ x: 18, y: 10, class: "sx-matrix-legend-text" }, cat)
+    ]);
+  });
+  return group({ id: "sx-matrix-legend" }, rows);
+}
+function renderTitle(ast, lay) {
+  if (!ast.title) return "";
+  return text(
+    { x: lay.canvasWidth / 2, y: 28, class: "sx-matrix-title", "text-anchor": "middle" },
+    ast.title
+  );
+}
+function renderMatrixAST(ast) {
+  const lay = layoutMatrix(ast);
+  const needsLegendSpace = lay.categories.length > 0 || ast.mode === "correlation";
+  const extraWidth = needsLegendSpace && lay.plot.x0 + lay.plot.w + 140 > lay.canvasWidth ? 160 : 0;
+  const canvasWidth = lay.canvasWidth + extraWidth;
+  const body = [
+    renderTitle(ast, lay),
+    renderQuadrantBackground(ast, lay),
+    renderGrid(ast, lay),
+    renderQuadAnnotations(ast, lay),
+    render3x3CellLabels(ast, lay),
+    renderHeatmap(ast, lay),
+    renderCorrelation(ast, lay),
+    renderAxes(ast, lay),
+    renderPoints(ast, lay),
+    renderLegend2(ast, lay),
+    renderCorrelationLegend(ast, lay)
+  ].filter((s) => s.length > 0);
+  return svgRoot(
+    {
+      class: "sx-matrix",
+      "data-diagram-type": "matrix",
+      "data-mode": ast.mode,
+      width: canvasWidth,
+      height: lay.canvasHeight,
+      viewBox: `0 0 ${canvasWidth} ${lay.canvasHeight}`,
+      role: "graphics-document"
+    },
+    [
+      title(ast.title ? `Matrix \u2014 ${escapeXml(ast.title)}` : "Matrix diagram"),
+      desc(
+        `Matrix diagram${ast.template ? ` (${ast.template} template)` : ""}, ${ast.mode} mode, ${ast.points.length} point(s)`
+      ),
+      defs([el("style", {}, CSS), axisArrow()]),
+      ...body
+    ]
+  );
+}
+function renderMatrix(text2) {
+  const ast = parseMatrix(text2);
+  return renderMatrixAST(ast);
+}
+
+// src/diagrams/matrix/index.ts
+var matrix = {
+  type: "matrix",
+  detect(text2) {
+    const first = text2.trim().split("\n")[0]?.trim().toLowerCase() ?? "";
+    return first.startsWith("matrix");
+  },
+  parse: parseMatrix,
+  render(text2) {
+    return renderMatrix(text2);
+  }
+};
+
+// src/core/api.ts
+var plugins = [
+  genogram,
+  ecomap,
+  pedigree,
+  phylo,
+  sociogram,
+  timing,
+  logic,
+  circuit,
+  blockdiagram,
+  ladder,
+  sld,
+  entity,
+  fishbone,
+  venn,
+  flowchart,
+  mindmap,
+  matrix,
+  orgchart,
+  decisiontree,
+  timeline
+];
+function detectPlugin(text2, config) {
+  if (config?.type) {
+    const plugin = plugins.find((p) => p.type === config.type);
+    if (plugin) return plugin;
+  }
+  for (const plugin of plugins) {
+    if (plugin.detect(text2)) return plugin;
+  }
+  throw new Error(
+    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', or 'orgchart'."
+  );
+}
+function parse(text2, config) {
+  const plugin = detectPlugin(text2, config);
+  if (plugin.parse) return plugin.parse(text2);
+  throw new Error(
+    `Diagram type '${plugin.type}' does not yet expose a parse() method.`
+  );
+}
+function render(text2, config) {
+  const plugin = detectPlugin(text2, config);
+  const renderConfig = {
+    fontFamily: config?.fontFamily ?? "system-ui, -apple-system, sans-serif",
+    fontSize: 12,
+    theme: config?.theme ?? "default",
+    padding: config?.padding ?? 20
+  };
+  return plugin.render(text2, renderConfig);
+}
+
+export { decisiontree, parse, render, timeline };
+//# sourceMappingURL=chunk-M6AMNXQ7.js.map
+//# sourceMappingURL=chunk-M6AMNXQ7.js.map