@pixerate/editor 0.54.0 → 0.56.0

package/dist/chunk-WWJNC7SX.js

@@ -1,3848 +0,0 @@
-// src/diagram/source/lines.ts
-var HEADER_PATTERNS = [
-  [/^\s*(flowchart|graph)(?:-elk)?\b/i, "flowchart"],
-  [/^\s*stateDiagram(?:-v2)?\b/i, "state"],
-  [/^\s*classDiagram(?:-v2)?\b/i, "class"],
-  [/^\s*erDiagram\b/i, "er"],
-  [/^\s*requirementDiagram\b/i, "requirement"],
-  [/^\s*mindmap\b/i, "mindmap"],
-  [/^\s*sequenceDiagram\b/i, "sequence"],
-  [/^\s*gantt\b/i, "gantt"],
-  [/^\s*pie\b/i, "pie"],
-  [/^\s*journey\b/i, "journey"],
-  [/^\s*timeline\b/i, "timeline"],
-  [/^\s*gitGraph\b/i, "gitGraph"],
-  [/^\s*C4(Context|Container|Component|Dynamic|Deployment)\b/, "c4"],
-  [/^\s*quadrantChart\b/i, "quadrant"],
-  [/^\s*sankey(?:-beta)?\b/i, "sankey"],
-  [/^\s*xychart(?:-beta)?\b/i, "xychart"],
-  [/^\s*block(?:-beta)?\b/i, "block"],
-  [/^\s*architecture(?:-beta)?\b/i, "architecture"],
-  [/^\s*packet(?:-beta)?\b/i, "packet"],
-  [/^\s*kanban\b/i, "kanban"],
-  [/^\s*radar(?:-beta)?\b/i, "radar"],
-  [/^\s*treemap(?:-beta)?\b/i, "treemap"],
-  [/^\s*info\b/i, "info"]
-];
-function detectFamilyFromHeader(header) {
-  for (const [re, family] of HEADER_PATTERNS) {
-    if (re.test(header)) return family;
-  }
-  return "unknown";
-}
-function isCommentLine(line) {
-  const t = line.trim();
-  return t.startsWith("%%") && !t.startsWith("%%{");
-}
-function isDirectiveLine(line) {
-  return /^\s*%%\{.*\}%%\s*$/.test(line);
-}
-function splitSource(source) {
-  const eol = source.includes("\r\n") ? "\r\n" : "\n";
-  const rawLines = source.split(/\r\n|\n/);
-  let end = rawLines.length;
-  while (end > 0 && rawLines[end - 1].trim() === "") end--;
-  const trailingLines = rawLines.slice(end);
-  const trailing = trailingLines.length ? eol + trailingLines.join(eol) : "";
-  const lines = rawLines.slice(0, end);
-  const preambleLines = [];
-  let i = 0;
-  let frontmatter;
-  if (lines[0] !== void 0 && /^---\s*$/.test(lines[0])) {
-    preambleLines.push(lines[0]);
-    i = 1;
-    const fm = [];
-    while (i < lines.length && !/^---\s*$/.test(lines[i])) {
-      fm.push(lines[i]);
-      preambleLines.push(lines[i]);
-      i++;
-    }
-    if (i < lines.length) {
-      preambleLines.push(lines[i]);
-      i++;
-    }
-    frontmatter = parseSimpleYaml(fm);
-  }
-  while (i < lines.length) {
-    const line = lines[i];
-    if (line.trim() === "" || isDirectiveLine(line) || isCommentLine(line)) {
-      preambleLines.push(line);
-      i++;
-      continue;
-    }
-    break;
-  }
-  const headerIndex = i;
-  const header = lines[i] ?? "";
-  const bodyLines = lines.slice(i + 1);
-  return {
-    eol,
-    preamble: { lines: preambleLines, frontmatter },
-    header,
-    headerIndex,
-    bodyLines,
-    trailing
-  };
-}
-function parseSimpleYaml(lines) {
-  const out = {};
-  let currentKey = null;
-  let nested = null;
-  for (const raw of lines) {
-    if (raw.trim() === "" || raw.trim().startsWith("#")) continue;
-    const indent = raw.length - raw.trimStart().length;
-    const m = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(raw.trim());
-    if (!m) continue;
-    const [, key, valueRaw] = m;
-    const value = parseYamlScalar(valueRaw);
-    if (indent === 0) {
-      currentKey = key;
-      if (valueRaw.trim() === "") {
-        nested = {};
-        out[key] = nested;
-      } else {
-        nested = null;
-        out[key] = value;
-      }
-    } else if (nested && currentKey) {
-      nested[key] = value;
-    }
-  }
-  return out;
-}
-function parseYamlScalar(v) {
-  const t = v.trim();
-  if (t === "") return "";
-  if (t.startsWith("{") || t.startsWith("[")) {
-    try {
-      return JSON.parse(t);
-    } catch {
-      return t;
-    }
-  }
-  if (/^(true|false)$/i.test(t)) return t.toLowerCase() === "true";
-  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
-  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
-    return t.slice(1, -1);
-  }
-  return t;
-}
-function splitStatements(line) {
-  const parts = [];
-  let depth = 0;
-  let quote = null;
-  let cur = "";
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if (quote) {
-      cur += ch;
-      if (ch === quote) quote = null;
-      continue;
-    }
-    if (ch === '"' || ch === "`") {
-      quote = ch;
-      cur += ch;
-      continue;
-    }
-    if (ch === "[" || ch === "(" || ch === "{") depth++;
-    else if (ch === "]" || ch === ")" || ch === "}") depth = Math.max(0, depth - 1);
-    if (ch === ";" && depth === 0) {
-      parts.push(cur);
-      cur = "";
-      continue;
-    }
-    cur += ch;
-  }
-  parts.push(cur);
-  return parts;
-}
-
-// src/diagram/source/metadata.ts
-var META_COMMENT_PREFIX = "%% @pixerate ";
-var META_FRONTMATTER_KEY = "pixerate";
-var LEGACY_FRONTMATTER_KEY = "ursula";
-var META_LINE = /^\s*%%\s*@(?:pixerate|ursula)\s+(\{.*\})\s*$/;
-var LEGACY_LAYOUT_LINE = /^\s*%%\s*@layout\b\s*(.*?)\s*$/;
-function emptyMeta() {
-  return { v: 1 };
-}
-function extractMetaFromBody(bodyLines) {
-  let meta = null;
-  let legacy = null;
-  const rest = [];
-  for (const line of bodyLines) {
-    const m = META_LINE.exec(line);
-    if (m) {
-      const parsed = safeParseMeta(m[1]);
-      if (parsed) meta = mergeMeta(meta ?? emptyMeta(), parsed);
-      continue;
-    }
-    const lm = LEGACY_LAYOUT_LINE.exec(line);
-    if (lm) {
-      const parsed = safeParseMeta(`{"layout":${lm[1] || "null"}}`);
-      if (parsed) legacy = mergeMeta(legacy ?? emptyMeta(), parsed);
-      continue;
-    }
-    rest.push(line);
-  }
-  if (legacy) meta = meta ? mergeMeta(legacy, meta) : legacy;
-  return { bodyLines: rest, meta };
-}
-function extractMetaFromFrontmatter(preamble) {
-  const value = preamble.frontmatter?.[META_FRONTMATTER_KEY] ?? preamble.frontmatter?.[LEGACY_FRONTMATTER_KEY];
-  if (!value) return null;
-  if (typeof value === "string") return safeParseMeta(value);
-  if (typeof value === "object") return normaliseMeta(value);
-  return null;
-}
-function safeParseMeta(json) {
-  try {
-    const value = JSON.parse(json);
-    return normaliseMeta(value);
-  } catch {
-    return null;
-  }
-}
-function normaliseMeta(value) {
-  const meta = { v: 1 };
-  if (value.layout && typeof value.layout === "object") {
-    const layout = {};
-    for (const [id, pos] of Object.entries(value.layout)) {
-      if (Array.isArray(pos) && pos.length === 2 && pos.every((n) => typeof n === "number")) {
-        layout[id] = [pos[0], pos[1]];
-      }
-    }
-    meta.layout = layout;
-  }
-  if (value.sizes && typeof value.sizes === "object") {
-    const sizes = {};
-    for (const [id, size] of Object.entries(value.sizes)) {
-      if (Array.isArray(size) && size.length === 2 && size.every((n) => typeof n === "number")) {
-        sizes[id] = [size[0], size[1]];
-      }
-    }
-    meta.sizes = sizes;
-  }
-  if (value.viewport && typeof value.viewport === "object") {
-    const vp = value.viewport;
-    if (typeof vp.x === "number" && typeof vp.y === "number" && typeof vp.zoom === "number") {
-      meta.viewport = { x: vp.x, y: vp.y, zoom: vp.zoom };
-    }
-  }
-  if (value.ext && typeof value.ext === "object") meta.ext = value.ext;
-  return meta;
-}
-function mergeMeta(a, b) {
-  return {
-    v: 1,
-    layout: a.layout || b.layout ? { ...a.layout, ...b.layout } : void 0,
-    sizes: a.sizes || b.sizes ? { ...a.sizes, ...b.sizes } : void 0,
-    viewport: b.viewport ?? a.viewport,
-    ext: a.ext || b.ext ? { ...a.ext, ...b.ext } : void 0
-  };
-}
-function isMetaEmpty(meta) {
-  const hasLayout = !!meta.layout && Object.keys(meta.layout).length > 0;
-  const hasSizes = !!meta.sizes && Object.keys(meta.sizes).length > 0;
-  const hasExt = !!meta.ext && Object.keys(meta.ext).length > 0;
-  return !hasLayout && !hasSizes && !meta.viewport && !hasExt;
-}
-function serializeMeta(meta) {
-  const out = { v: 1 };
-  if (meta.layout && Object.keys(meta.layout).length) {
-    const layout = {};
-    for (const id of Object.keys(meta.layout).sort()) {
-      const [x, y] = meta.layout[id];
-      layout[id] = [Math.round(x), Math.round(y)];
-    }
-    out.layout = layout;
-  }
-  if (meta.sizes && Object.keys(meta.sizes).length) {
-    const sizes = {};
-    for (const id of Object.keys(meta.sizes).sort()) {
-      const [w, h] = meta.sizes[id];
-      sizes[id] = [Math.round(w), Math.round(h)];
-    }
-    out.sizes = sizes;
-  }
-  if (meta.viewport) {
-    out.viewport = {
-      x: Math.round(meta.viewport.x),
-      y: Math.round(meta.viewport.y),
-      zoom: Math.round(meta.viewport.zoom * 1e3) / 1e3
-    };
-  }
-  if (meta.ext && Object.keys(meta.ext).length) out.ext = meta.ext;
-  return JSON.stringify(out);
-}
-function metaCommentLine(meta, indent = "  ") {
-  return `${indent}${META_COMMENT_PREFIX}${serializeMeta(meta)}`;
-}
-function writeMetaToPreamble(preamble, meta) {
-  const lines = [...preamble.lines];
-  const hasFm = lines[0] !== void 0 && /^---\s*$/.test(lines[0]);
-  const entry = meta && !isMetaEmpty(meta) ? `${META_FRONTMATTER_KEY}: ${serializeMeta(meta)}` : null;
-  if (!hasFm) {
-    if (!entry) return lines;
-    return ["---", entry, "---", ...lines];
-  }
-  const close = lines.findIndex((l, i) => i > 0 && /^---\s*$/.test(l));
-  const fmEnd = close === -1 ? lines.length : close;
-  const existing = lines.findIndex(
-    (l, i) => i > 0 && i < fmEnd && new RegExp(`^(?:${META_FRONTMATTER_KEY}|${LEGACY_FRONTMATTER_KEY})\\s*:`).test(l)
-  );
-  if (existing !== -1) {
-    if (entry) lines[existing] = entry;
-    else lines.splice(existing, 1);
-  } else if (entry) {
-    lines.splice(fmEnd, 0, entry);
-  }
-  if (!entry) {
-    const close2 = lines.findIndex((l, i) => i > 0 && /^---\s*$/.test(l));
-    if (close2 === 1) lines.splice(0, 2);
-  }
-  return lines;
-}
-var FRONTMATTER_META_FAMILIES = /* @__PURE__ */ new Set(["requirement"]);
-function defaultCarrierFor(family) {
-  return FRONTMATTER_META_FAMILIES.has(family) ? "frontmatter" : "comment";
-}
-
-// src/diagram/flowchart/edges.ts
-var START_HEADS = {
-  "<": "arrow_point",
-  x: "arrow_cross",
-  o: "arrow_circle"
-};
-var END_HEADS = {
-  ">": "arrow_point",
-  x: "arrow_cross",
-  o: "arrow_circle"
-};
-var EDGE_ID = /^([A-Za-z0-9_À-￿-]+)@(?=[<xo]?[-=~.])/;
-var PLAIN = /^([<xo](?=[-=~]))?(-{2,}|={2,}|-\.+-|~{3,})([>xo])?/;
-var TEXT_OPEN = /^([<xo](?=[-=]))?(--|-\.|==)(?=\s)/;
-var TEXT_CLOSE = /\s+(-{2,}|\.+-|={2,})([>xo])?(?=$|\s|\||[A-Za-z0-9_À-￿([{>"`&])/;
-function patternOf(body) {
-  if (body.startsWith("~")) return "invisible";
-  if (body.startsWith("=")) return "thick";
-  if (body.includes(".")) return "dotted";
-  return "solid";
-}
-function lengthOf(body, hasEndHead) {
-  if (body.startsWith("~")) return Math.max(1, body.length - 2);
-  if (body.includes(".")) return Math.max(1, (body.match(/\./g) ?? []).length);
-  return Math.max(1, body.length - (hasEndHead ? 1 : 2));
-}
-function closerLength(closer, hasEndHead) {
-  if (closer.includes(".")) return Math.max(1, (closer.match(/\./g) ?? []).length);
-  return Math.max(1, closer.length - (hasEndHead ? 1 : 2));
-}
-function parseLink(input) {
-  let pos = 0;
-  let id;
-  const idm = EDGE_ID.exec(input);
-  if (idm) {
-    id = idm[1];
-    pos += idm[0].length;
-  }
-  const rest = input.slice(pos);
-  const tm = TEXT_OPEN.exec(rest);
-  if (tm) {
-    const afterOpen = rest.slice(tm[0].length);
-    const cm = TEXT_CLOSE.exec(afterOpen);
-    if (cm && cm.index > 0) {
-      const label = afterOpen.slice(0, cm.index).trim();
-      if (label && !/^[-=.>|]/.test(label)) {
-        const closer = cm[1];
-        const endHead2 = cm[2];
-        const consumed2 = pos + tm[0].length + cm.index + cm[0].length;
-        const body2 = tm[2];
-        const result2 = {
-          id,
-          pattern: patternOf(body2 === "-." ? "-.-" : body2),
-          arrowStart: tm[1] ? START_HEADS[tm[1]] : "none",
-          arrowEnd: endHead2 ? END_HEADS[endHead2] : "none",
-          length: closerLength(closer, !!endHead2),
-          label: unquoteLabel(label),
-          labelStyle: "inline",
-          consumed: consumed2,
-          raw: input.slice(0, consumed2)
-        };
-        return withPipeLabel(input, result2);
-      }
-    }
-  }
-  const pm = PLAIN.exec(rest);
-  if (!pm) return null;
-  const body = pm[2];
-  const endHead = pm[3];
-  const consumed = pos + pm[0].length;
-  const result = {
-    id,
-    pattern: patternOf(body),
-    arrowStart: pm[1] ? START_HEADS[pm[1]] : "none",
-    arrowEnd: endHead ? END_HEADS[endHead] : "none",
-    length: lengthOf(body, !!endHead),
-    consumed,
-    raw: input.slice(0, consumed)
-  };
-  return withPipeLabel(input, result);
-}
-function withPipeLabel(input, link) {
-  const after = input.slice(link.consumed);
-  const m = /^\s*\|(\s*"[^"]*"\s*)\|/.exec(after) ?? /^\s*\|([^|]*)\|/.exec(after);
-  if (!m) return link;
-  const consumed = link.consumed + m[0].length;
-  return {
-    ...link,
-    label: unquoteLabel(m[1].trim()),
-    labelStyle: link.label ? link.labelStyle : "pipe",
-    consumed,
-    raw: input.slice(0, consumed)
-  };
-}
-function unquoteLabel(text) {
-  const t = text.trim();
-  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
-  return t;
-}
-var NEEDS_QUOTE = /[[\]{}()|<>"#;&%]|^\s|\s$|^-|^=|^\./;
-function quoteLabelIfNeeded(label) {
-  if (label === "") return '""';
-  if (label.startsWith("`") && label.endsWith("`")) return `"${label}"`;
-  if (NEEDS_QUOTE.test(label)) {
-    return `"${label.replace(/"/g, "#quot;")}"`;
-  }
-  return label;
-}
-var START_CHAR = {
-  arrow_point: "<",
-  arrow_cross: "x",
-  arrow_circle: "o"
-};
-var END_CHAR = {
-  arrow_point: ">",
-  arrow_cross: "x",
-  arrow_circle: "o"
-};
-function formatLink(spec) {
-  const start = START_CHAR[spec.arrowStart] ?? "";
-  const end = END_CHAR[spec.arrowEnd] ?? "";
-  const len = Math.max(1, spec.length);
-  const label = spec.label?.trim();
-  const body = (closing) => {
-    switch (spec.pattern) {
-      case "invisible":
-        return "~".repeat(len + 2);
-      case "thick":
-        return "=".repeat(end ? len + 1 : len + 2);
-      case "dotted":
-        return closing ? `${".".repeat(len)}-` : `-${".".repeat(len)}-`;
-      default:
-        return "-".repeat(end ? len + 1 : len + 2);
-    }
-  };
-  const prefix = spec.id ? `${spec.id}@` : "";
-  if (label && spec.labelStyle === "inline" && spec.pattern !== "invisible") {
-    const open = spec.pattern === "thick" ? "==" : spec.pattern === "dotted" ? "-." : "--";
-    return `${prefix}${start}${open} ${quoteLabelIfNeeded(label)} ${body(true)}${end}`;
-  }
-  const token = `${prefix}${start}${body(false)}${end}`;
-  if (label) return `${token}|${quoteLabelIfNeeded(label)}|`;
-  return token;
-}
-
-// src/diagram/flowchart/shapes.ts
-var FLOWCHART_SHAPES = [
-  {
-    name: "rect",
-    title: "Rectangle",
-    aliases: ["rectangle", "proc", "process", "squareRect", "square"],
-    bracket: { open: "[", close: "]" },
-    category: "basic"
-  },
-  {
-    name: "rounded",
-    title: "Rounded rectangle",
-    aliases: ["rounded-rectangle", "event", "roundedRect", "round"],
-    bracket: { open: "(", close: ")" },
-    category: "basic"
-  },
-  {
-    name: "stadium",
-    title: "Stadium",
-    aliases: ["pill", "terminal"],
-    bracket: { open: "([", close: "])" },
-    category: "basic"
-  },
-  {
-    name: "subproc",
-    title: "Subprocess",
-    aliases: ["subprocess", "subroutine", "framed-rectangle", "fr-rect"],
-    bracket: { open: "[[", close: "]]" },
-    category: "process"
-  },
-  {
-    name: "cyl",
-    title: "Cylinder (database)",
-    aliases: ["cylinder", "database", "db"],
-    bracket: { open: "[(", close: ")]" },
-    category: "data"
-  },
-  {
-    name: "circle",
-    title: "Circle",
-    aliases: ["circ"],
-    bracket: { open: "((", close: "))" },
-    category: "basic"
-  },
-  {
-    name: "odd",
-    title: "Asymmetric",
-    aliases: ["asymmetric", "rect_left_inv_arrow"],
-    bracket: { open: ">", close: "]" },
-    category: "misc"
-  },
-  {
-    name: "diam",
-    title: "Diamond (decision)",
-    aliases: ["diamond", "decision", "question"],
-    bracket: { open: "{", close: "}" },
-    category: "control"
-  },
-  {
-    name: "hex",
-    title: "Hexagon (prepare)",
-    aliases: ["hexagon", "prepare"],
-    bracket: { open: "{{", close: "}}" },
-    category: "process"
-  },
-  {
-    name: "lean-r",
-    title: "Parallelogram (lean right)",
-    aliases: ["lean-right", "in-out", "lean_right"],
-    bracket: { open: "[/", close: "/]" },
-    category: "data"
-  },
-  {
-    name: "lean-l",
-    title: "Parallelogram (lean left)",
-    aliases: ["lean-left", "out-in", "lean_left"],
-    bracket: { open: "[\\", close: "\\]" },
-    category: "data"
-  },
-  {
-    name: "trap-b",
-    title: "Trapezoid (base bottom)",
-    aliases: ["trapezoid-bottom", "priority", "trapezoid"],
-    bracket: { open: "[/", close: "\\]" },
-    category: "process"
-  },
-  {
-    name: "trap-t",
-    title: "Trapezoid (base top)",
-    aliases: ["trapezoid-top", "manual", "inv_trapezoid"],
-    bracket: { open: "[\\", close: "/]" },
-    category: "process"
-  },
-  {
-    name: "dbl-circ",
-    title: "Double circle",
-    aliases: ["double-circle", "doublecircle"],
-    bracket: { open: "(((", close: ")))" },
-    category: "basic"
-  },
-  // Data-syntax-only shapes
-  { name: "text", title: "Text", aliases: [], category: "misc" },
-  {
-    name: "card",
-    title: "Card (notched rectangle)",
-    aliases: ["notched-rectangle", "notch-rect"],
-    category: "misc"
-  },
-  {
-    name: "lin-rect",
-    title: "Lined rectangle (shaded process)",
-    aliases: ["lined-rectangle", "lin-proc", "lined-process", "shaded-process"],
-    category: "process"
-  },
-  {
-    name: "sm-circ",
-    title: "Small circle (start)",
-    aliases: ["small-circle", "start"],
-    category: "control"
-  },
-  {
-    name: "fr-circ",
-    title: "Framed circle (stop)",
-    aliases: ["framed-circle", "stop"],
-    category: "control"
-  },
-  { name: "fork", title: "Fork / join", aliases: ["join"], category: "control" },
-  { name: "hourglass", title: "Hourglass (collate)", aliases: ["collate"], category: "process" },
-  {
-    name: "brace",
-    title: "Comment (left brace)",
-    aliases: ["brace-l", "comment"],
-    category: "misc"
-  },
-  { name: "brace-r", title: "Comment (right brace)", aliases: [], category: "misc" },
-  { name: "braces", title: "Comment (both braces)", aliases: [], category: "misc" },
-  {
-    name: "bolt",
-    title: "Lightning bolt (com link)",
-    aliases: ["com-link", "lightning-bolt"],
-    category: "misc"
-  },
-  { name: "doc", title: "Document", aliases: ["document"], category: "data" },
-  {
-    name: "delay",
-    title: "Delay (half-rounded rectangle)",
-    aliases: ["half-rounded-rectangle"],
-    category: "process"
-  },
-  {
-    name: "h-cyl",
-    title: "Horizontal cylinder (direct access)",
-    aliases: ["das", "horizontal-cylinder"],
-    category: "data"
-  },
-  {
-    name: "lin-cyl",
-    title: "Lined cylinder (disk storage)",
-    aliases: ["disk", "lined-cylinder"],
-    category: "data"
-  },
-  {
-    name: "curv-trap",
-    title: "Curved trapezoid (display)",
-    aliases: ["curved-trapezoid", "display"],
-    category: "misc"
-  },
-  {
-    name: "div-rect",
-    title: "Divided rectangle",
-    aliases: ["div-proc", "divided-process", "divided-rectangle"],
-    category: "process"
-  },
-  {
-    name: "tri",
-    title: "Triangle (extract)",
-    aliases: ["extract", "triangle"],
-    category: "process"
-  },
-  {
-    name: "win-pane",
-    title: "Window pane (internal storage)",
-    aliases: ["internal-storage", "window-pane"],
-    category: "data"
-  },
-  {
-    name: "f-circ",
-    title: "Filled circle (junction)",
-    aliases: ["filled-circle", "junction"],
-    category: "control"
-  },
-  { name: "lin-doc", title: "Lined document", aliases: ["lined-document"], category: "data" },
-  { name: "notch-rect", title: "Notched rectangle (card)", aliases: [], category: "misc" },
-  { name: "flag", title: "Flag (paper tape)", aliases: ["paper-tape"], category: "data" },
-  {
-    name: "docs",
-    title: "Stacked documents",
-    aliases: ["documents", "st-doc", "stacked-document"],
-    category: "data"
-  },
-  {
-    name: "st-rect",
-    title: "Stacked rectangles",
-    aliases: ["processes", "procs", "stacked-rectangle"],
-    category: "process"
-  },
-  {
-    name: "bow-rect",
-    title: "Bow-tie rectangle (stored data)",
-    aliases: ["bow-tie-rectangle", "stored-data"],
-    category: "data"
-  },
-  {
-    name: "cross-circ",
-    title: "Crossed circle (summary)",
-    aliases: ["crossed-circle", "summary"],
-    category: "process"
-  },
-  { name: "tag-doc", title: "Tagged document", aliases: ["tagged-document"], category: "data" },
-  {
-    name: "tag-rect",
-    title: "Tagged rectangle",
-    aliases: ["tag-proc", "tagged-process", "tagged-rectangle"],
-    category: "process"
-  },
-  {
-    name: "notch-pent",
-    title: "Notched pentagon (loop limit)",
-    aliases: ["loop-limit", "notched-pentagon"],
-    category: "control"
-  },
-  {
-    name: "flip-tri",
-    title: "Flipped triangle (manual file)",
-    aliases: ["flipped-triangle", "manual-file"],
-    category: "data"
-  },
-  {
-    name: "sl-rect",
-    title: "Sloped rectangle (manual input)",
-    aliases: ["manual-input", "sloped-rectangle"],
-    category: "data"
-  },
-  { name: "icon", title: "Icon", aliases: [], category: "misc" },
-  { name: "image", title: "Image", aliases: ["img"], category: "misc" },
-  { name: "anchor", title: "Anchor (invisible)", aliases: [], category: "misc" }
-];
-var BY_NAME = /* @__PURE__ */ new Map();
-for (const def of FLOWCHART_SHAPES) {
-  BY_NAME.set(def.name, def);
-  for (const alias of def.aliases) BY_NAME.set(alias, def);
-}
-function resolveShape(name) {
-  if (!name) return void 0;
-  return BY_NAME.get(name) ?? BY_NAME.get(name.toLowerCase());
-}
-function canonicalShape(name) {
-  if (!name) return "rect";
-  return resolveShape(name)?.name ?? name;
-}
-var BRACKET_OPENERS = Array.from(
-  new Set(FLOWCHART_SHAPES.filter((s) => s.bracket).map((s) => s.bracket.open))
-).sort((a, b) => b.length - a.length);
-function closersFor(open) {
-  return FLOWCHART_SHAPES.filter((s) => s.bracket?.open === open).map((s) => s.bracket.close).sort((a, b) => b.length - a.length);
-}
-function shapeForBracket(open, close) {
-  return FLOWCHART_SHAPES.find((s) => s.bracket?.open === open && s.bracket.close === close);
-}
-var DEFAULT_SHAPE = "rect";
-
-// src/diagram/flowchart/statements.ts
-function readId(input, pos) {
-  let i = pos;
-  while (i < input.length) {
-    const ch = input[i];
-    const next = input[i + 1];
-    if (/[A-Za-z0-9_À-￿!#$%*+?/\\'`]/.test(ch)) {
-      i++;
-      continue;
-    }
-    if (ch === "." && next !== "-") {
-      i++;
-      continue;
-    }
-    if (ch === "-" && next !== ">" && next !== "-" && next !== "." && next !== void 0 && !/\s/.test(next)) {
-      i++;
-      continue;
-    }
-    if (ch === "=" && next !== "=") {
-      i++;
-      continue;
-    }
-    break;
-  }
-  return input.slice(pos, i);
-}
-function findCloser(input, pos, closers) {
-  let quote = null;
-  for (let i = pos; i < input.length; i++) {
-    const ch = input[i];
-    if (quote) {
-      if (ch === quote) quote = null;
-      continue;
-    }
-    if (ch === '"') {
-      quote = ch;
-      continue;
-    }
-    for (const closer of closers) {
-      if (input.startsWith(closer, i)) return { index: i, closer };
-    }
-  }
-  return null;
-}
-function readBraceBlock(input, pos) {
-  let depth = 0;
-  let quote = null;
-  for (let i = pos; i < input.length; i++) {
-    const ch = input[i];
-    if (quote) {
-      if (ch === quote) quote = null;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      continue;
-    }
-    if (ch === "{") depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0) return i + 1;
-    }
-  }
-  return -1;
-}
-function parseShapeData(inner) {
-  const out = {};
-  const parts = [];
-  let cur = "";
-  let quote = null;
-  for (const ch of inner) {
-    if (quote) {
-      cur += ch;
-      if (ch === quote) quote = null;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      cur += ch;
-      continue;
-    }
-    if (ch === "," || ch === "\n") {
-      parts.push(cur);
-      cur = "";
-      continue;
-    }
-    cur += ch;
-  }
-  parts.push(cur);
-  for (const part of parts) {
-    const m = /^\s*([A-Za-z_][\w-]*)\s*:\s*([\s\S]*?)\s*$/.exec(part);
-    if (m) out[m[1]] = m[2];
-  }
-  return out;
-}
-function unquoteData(value) {
-  if (value === void 0) return void 0;
-  const t = value.trim();
-  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
-    return t.slice(1, -1);
-  }
-  return t;
-}
-function formatShapeData(data) {
-  const entries = Object.entries(data).map(([k, v]) => `${k}: ${v}`);
-  return `@{ ${entries.join(", ")} }`;
-}
-function readNode(input, pos) {
-  const id = readId(input, pos);
-  if (!id) return null;
-  let i = pos + id.length;
-  const node = { id, classes: [] };
-  if (input[i] === "@" && input[i + 1] === "{") {
-    const end = readBraceBlock(input, i + 1);
-    if (end !== -1) {
-      const inner = input.slice(i + 2, end - 1);
-      const data = parseShapeData(inner);
-      node.form = "data";
-      if (data.shape !== void 0) {
-        node.shape = canonicalShape(unquoteData(data.shape));
-        delete data.shape;
-      }
-      if (data.label !== void 0) {
-        node.label = unquoteData(data.label);
-        node.labelQuoted = /^\s*["']/.test(data.label);
-        delete data.label;
-      }
-      if ("img" in data) node.shape = "image";
-      else if ("icon" in data && node.shape === void 0) node.shape = "icon";
-      node.data = data;
-      i = end;
-    }
-  } else {
-    for (const open of BRACKET_OPENERS) {
-      if (!input.startsWith(open, i)) continue;
-      const closers = closersFor(open);
-      const found = findCloser(input, i + open.length, closers);
-      if (!found) break;
-      const shapeDef = shapeForBracket(open, found.closer);
-      if (!shapeDef) break;
-      const rawLabel = input.slice(i + open.length, found.index);
-      node.shape = shapeDef.name;
-      node.form = "bracket";
-      node.label = unquoteLabel(rawLabel);
-      node.labelQuoted = rawLabel.trim().startsWith('"');
-      i = found.index + found.closer.length;
-      break;
-    }
-  }
-  while (input.startsWith(":::", i)) {
-    const cls = readId(input, i + 3);
-    if (!cls) break;
-    node.classes.push(cls);
-    i += 3 + cls.length;
-  }
-  return { node, end: i };
-}
-function skipWs(input, pos) {
-  let i = pos;
-  while (i < input.length && /\s/.test(input[i])) i++;
-  return i;
-}
-function parseChain(text) {
-  const groups = [];
-  const links = [];
-  let pos = skipWs(text, 0);
-  let group = [];
-  const first = readNode(text, pos);
-  if (!first) return null;
-  group.push(first.node);
-  pos = skipWs(text, first.end);
-  while (pos < text.length) {
-    if (text[pos] === "&") {
-      pos = skipWs(text, pos + 1);
-      const n = readNode(text, pos);
-      if (!n) return null;
-      group.push(n.node);
-      pos = skipWs(text, n.end);
-      continue;
-    }
-    const link = parseLink(text.slice(pos));
-    if (link) {
-      groups.push(group);
-      group = [];
-      links.push({
-        id: link.id,
-        pattern: link.pattern,
-        arrowStart: link.arrowStart,
-        arrowEnd: link.arrowEnd,
-        length: link.length,
-        label: link.label,
-        labelStyle: link.labelStyle
-      });
-      pos = skipWs(text, pos + link.consumed);
-      const n = readNode(text, pos);
-      if (!n) return null;
-      group.push(n.node);
-      pos = skipWs(text, n.end);
-      continue;
-    }
-    return null;
-  }
-  groups.push(group);
-  return { groups, links };
-}
-function splitStyles(text) {
-  return text.split(",").map((s) => s.trim()).filter(Boolean);
-}
-function parseStatement(line) {
-  const indent = line.match(/^\s*/)[0];
-  const text = line.trim();
-  if (text === "" || text.startsWith("%%")) return { kind: "raw", raw: line };
-  let m;
-  if (/^end\s*$/i.test(text)) return { kind: "end", raw: line, indent };
-  if (m = /^direction\s+(TB|TD|BT|LR|RL)\s*$/i.exec(text)) {
-    return { kind: "direction", raw: line, indent, direction: m[1].toUpperCase() };
-  }
-  if (m = /^subgraph\s+(.*)$/i.exec(text)) {
-    const rest = m[1].trim();
-    let sm;
-    if (sm = /^([^\s["]+)\s*\[(.*)\]\s*$/.exec(rest)) {
-      return {
-        kind: "subgraph",
-        raw: line,
-        indent,
-        id: sm[1],
-        title: unquoteLabel(sm[2]),
-        titleForm: "bracket"
-      };
-    }
-    if (sm = /^"(.*)"\s*$/.exec(rest)) {
-      return { kind: "subgraph", raw: line, indent, id: sm[1], title: sm[1], titleForm: "bare" };
-    }
-    if (/\s/.test(rest)) {
-      return { kind: "subgraph", raw: line, indent, id: rest, title: rest, titleForm: "bare" };
-    }
-    return { kind: "subgraph", raw: line, indent, id: rest, titleForm: "none" };
-  }
-  if (m = /^classDef\s+([^\s]+)\s+(.*)$/.exec(text)) {
-    return {
-      kind: "classDef",
-      raw: line,
-      indent,
-      names: m[1].split(","),
-      styles: splitStyles(m[2])
-    };
-  }
-  if (m = /^class\s+([^\s]+)\s+([^\s]+)\s*$/.exec(text)) {
-    return { kind: "class", raw: line, indent, ids: m[1].split(","), className: m[2] };
-  }
-  if (m = /^style\s+([^\s]+)\s+(.*)$/.exec(text)) {
-    return { kind: "style", raw: line, indent, id: m[1], styles: splitStyles(m[2]) };
-  }
-  if (m = /^linkStyle\s+(default|[\d,\s]+)\s+(.*)$/.exec(text)) {
-    const targets = m[1] === "default" ? "default" : m[1].split(",").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => !Number.isNaN(n));
-    return { kind: "linkStyle", raw: line, indent, targets, styles: splitStyles(m[2]) };
-  }
-  if (m = /^click\s+([^\s]+)\s+(.*)$/.exec(text)) {
-    return { kind: "click", raw: line, indent, id: m[1], rest: m[2] };
-  }
-  if (/^(accTitle|accDescr)\b/.test(text) || /^title\s/.test(text))
-    return { kind: "raw", raw: line };
-  const chain = parseChain(text);
-  if (chain) return { kind: "chain", raw: line, indent, chain };
-  return { kind: "raw", raw: line };
-}
-function formatNode(node) {
-  let out = node.id;
-  const shape = node.shape ? resolveShape(node.shape) : void 0;
-  const useData = node.form === "data" || node.shape && !shape?.bracket || node.data && Object.keys(node.data).length;
-  if (useData && (node.shape || node.label !== void 0 || node.data && Object.keys(node.data).length)) {
-    const data = {};
-    const implied = node.shape === "image" && node.data && "img" in node.data || node.shape === "icon" && node.data && "icon" in node.data;
-    if (node.shape && !implied) data.shape = node.shape;
-    if (node.label !== void 0) data.label = JSON.stringify(node.label);
-    Object.assign(data, node.data ?? {});
-    out += formatShapeData(data);
-  } else if (shape?.bracket && (node.label !== void 0 || node.shape !== "rect" || node.form === "bracket")) {
-    const label = node.label ?? node.id;
-    const text = node.labelQuoted ? `"${label.replace(/"/g, "#quot;")}"` : quoteLabelIfNeeded(label);
-    out += `${shape.bracket.open}${text}${shape.bracket.close}`;
-  } else if (node.label !== void 0 && node.label !== node.id) {
-    out += `[${quoteLabelIfNeeded(node.label)}]`;
-  }
-  for (const cls of node.classes) out += `:::${cls}`;
-  return out;
-}
-function formatChain(chain) {
-  const parts = [];
-  chain.groups.forEach((group, i) => {
-    parts.push(group.map(formatNode).join(" & "));
-    const link = chain.links[i];
-    if (link) parts.push(formatLink(link));
-  });
-  return parts.join(" ");
-}
-function formatStatement(stmt) {
-  if (stmt.kind === "raw" || stmt.kind === "end") return stmt.raw;
-  if (!stmt.dirty) return stmt.raw;
-  switch (stmt.kind) {
-    case "chain":
-      return stmt.indent + formatChain(stmt.chain);
-    case "subgraph": {
-      if (stmt.titleForm === "none" || stmt.title === void 0)
-        return `${stmt.indent}subgraph ${stmt.id}`;
-      if (stmt.titleForm === "bare")
-        return `${stmt.indent}subgraph ${stmt.title.includes(" ") || stmt.title !== stmt.id ? `"${stmt.title}"` : stmt.title}`;
-      return `${stmt.indent}subgraph ${stmt.id} [${quoteLabelIfNeeded(stmt.title)}]`;
-    }
-    case "direction":
-      return `${stmt.indent}direction ${stmt.direction}`;
-    case "classDef":
-      return `${stmt.indent}classDef ${stmt.names.join(",")} ${stmt.styles.join(",")}`;
-    case "class":
-      return `${stmt.indent}class ${stmt.ids.join(",")} ${stmt.className}`;
-    case "style":
-      return `${stmt.indent}style ${stmt.id} ${stmt.styles.join(",")}`;
-    case "linkStyle":
-      return `${stmt.indent}linkStyle ${stmt.targets === "default" ? "default" : stmt.targets.join(",")} ${stmt.styles.join(",")}`;
-    case "click":
-      return `${stmt.indent}click ${stmt.id} ${stmt.rest}`;
-  }
-}
-function joinLogicalLines(lines) {
-  const out = [];
-  let i = 0;
-  while (i < lines.length) {
-    let cur = lines[i];
-    const at = cur.indexOf("@{");
-    if (at !== -1 && readBraceBlock(cur, at + 1) === -1) {
-      let j = i + 1;
-      while (j < lines.length) {
-        cur += "\n" + lines[j];
-        j++;
-        if (readBraceBlock(cur, at + 1) !== -1) break;
-      }
-      out.push(cur);
-      i = j;
-      continue;
-    }
-    out.push(cur);
-    i++;
-  }
-  return out;
-}
-
-// src/diagram/flowchart/parse.ts
-function autoEdgeId(source, target, ordinal) {
-  return `L_${source}_${target}_${ordinal}`;
-}
-var HEADER_DIRECTION = /^\s*(?:flowchart|graph)(?:-elk)?\s*(TB|TD|BT|LR|RL)?\s*;?\s*$/i;
-function headerDirection(header) {
-  const m = HEADER_DIRECTION.exec(header);
-  return (m?.[1] ?? "TB").toUpperCase();
-}
-function tokenizeBody(bodyLines) {
-  const statements = [];
-  for (const logical of joinLogicalLines(bodyLines)) {
-    if (logical.includes("@{") || !logical.includes(";")) {
-      statements.push(parseStatement(logical));
-      continue;
-    }
-    const segments = splitStatements(logical);
-    const nonEmpty = segments.filter((s) => s.trim() !== "");
-    if (nonEmpty.length <= 1) {
-      const stmt = parseStatement(nonEmpty[0] ?? logical);
-      stmt.raw = logical;
-      statements.push(stmt);
-      continue;
-    }
-    const parsed = nonEmpty.map((seg, i) => parseStatement(i === 0 ? seg : seg.trimStart()));
-    statements.push(...withCompoundMarker(parsed, logical));
-  }
-  return statements;
-}
-var COMPOUND = /* @__PURE__ */ Symbol("compound");
-function withCompoundMarker(parsed, raw) {
-  parsed.forEach((stmt, i) => markCompound(stmt, parsed, i === 0 ? raw : ""));
-  return parsed;
-}
-function markCompound(stmt, members, raw) {
-  stmt[COMPOUND] = { members, raw };
-}
-function compoundInfo(stmt) {
-  return stmt[COMPOUND];
-}
-function buildGraph(statements, direction, title) {
-  const nodes = /* @__PURE__ */ new Map();
-  const groups = /* @__PURE__ */ new Map();
-  const edges = [];
-  const classDefs = {};
-  const diagnostics = [];
-  const stack = [];
-  const membership = /* @__PURE__ */ new Map();
-  const classAssignments = [];
-  const styleAssignments = [];
-  const clicks = [];
-  const linkStyles = [];
-  const dataOnly = [];
-  let ordinal = 0;
-  const touch = (ref) => {
-    let node = nodes.get(ref.id);
-    if (!node) {
-      node = { id: ref.id, label: ref.id, shape: DEFAULT_SHAPE, classes: [], styles: [] };
-      nodes.set(ref.id, node);
-    }
-    if (ref.label !== void 0) node.label = ref.label;
-    if (ref.shape) node.shape = ref.shape;
-    for (const cls of ref.classes) if (!node.classes.includes(cls)) node.classes.push(cls);
-    if (ref.data && Object.keys(ref.data).length) {
-      node.data = { ...node.data ?? {}, ...stripQuotes(ref.data) };
-    }
-    const current = stack[stack.length - 1];
-    if (current) membership.get(current).add(ref.id);
-    return node;
-  };
-  statements.forEach((stmt, index) => {
-    switch (stmt.kind) {
-      case "subgraph": {
-        const parent = stack[stack.length - 1];
-        if (groups.has(stmt.id)) {
-          diagnostics.push({
-            severity: "warning",
-            message: `Duplicate subgraph id "${stmt.id}"`,
-            line: index + 1,
-            source: "pixerate"
-          });
-        }
-        groups.set(stmt.id, {
-          id: stmt.id,
-          label: stmt.title ?? stmt.id,
-          parentId: parent,
-          classes: [],
-          styles: []
-        });
-        membership.set(stmt.id, /* @__PURE__ */ new Set());
-        if (parent) membership.get(parent).add(stmt.id);
-        stack.push(stmt.id);
-        break;
-      }
-      case "end":
-        if (!stack.length) {
-          diagnostics.push({
-            severity: "warning",
-            message: "Stray `end` without a subgraph",
-            line: index + 1,
-            source: "pixerate"
-          });
-        }
-        stack.pop();
-        break;
-      case "direction": {
-        const current = stack[stack.length - 1];
-        if (current) groups.get(current).direction = stmt.direction;
-        break;
-      }
-      case "chain": {
-        const { groups: ngroups, links } = stmt.chain;
-        if (ngroups.length === 1 && ngroups[0].length === 1 && links.length === 0) {
-          const ref = ngroups[0];
-          const only = ref[0];
-          if (only.form === "data" && only.data && !only.shape && only.label === void 0 && ("animate" in only.data || "animation" in only.data)) {
-            dataOnly.push({ id: only.id, data: only.data });
-            break;
-          }
-        }
-        for (const group of ngroups) for (const ref of group) touch(ref);
-        links.forEach((link, i) => {
-          const from = ngroups[i];
-          const to = ngroups[i + 1];
-          for (const s of from) {
-            for (const t of to) {
-              const id = link.id ?? autoEdgeId(s.id, t.id, ordinal);
-              edges.push({
-                id,
-                source: s.id,
-                target: t.id,
-                label: link.label,
-                pattern: link.pattern,
-                arrowStart: link.arrowStart,
-                arrowEnd: link.arrowEnd,
-                length: link.length,
-                classes: [],
-                styles: [],
-                userDefinedId: !!link.id
-              });
-              ordinal++;
-            }
-          }
-        });
-        break;
-      }
-      case "classDef":
-        for (const name of stmt.names) classDefs[name] = [...stmt.styles];
-        break;
-      case "class":
-        classAssignments.push({ ids: stmt.ids, className: stmt.className });
-        break;
-      case "style":
-        styleAssignments.push({ id: stmt.id, styles: stmt.styles });
-        break;
-      case "linkStyle":
-        linkStyles.push({ targets: stmt.targets, styles: stmt.styles });
-        break;
-      case "click":
-        clicks.push({ id: stmt.id, rest: stmt.rest });
-        break;
-      default:
-        break;
-    }
-  });
-  if (stack.length) {
-    diagnostics.push({
-      severity: "warning",
-      message: `${stack.length} subgraph(s) missing \`end\``,
-      source: "pixerate"
-    });
-  }
-  const parentOf2 = /* @__PURE__ */ new Map();
-  for (const [groupId, members] of membership) {
-    for (const member of members) parentOf2.set(member, groupId);
-  }
-  for (const node of nodes.values()) {
-    const parent = parentOf2.get(node.id);
-    if (parent && groups.has(parent)) node.parentId = parent;
-  }
-  for (const group of groups.values()) {
-    const parent = parentOf2.get(group.id);
-    if (parent && parent !== group.id && groups.has(parent)) group.parentId = parent;
-  }
-  for (const { ids, className } of classAssignments) {
-    for (const id of ids) {
-      const node = nodes.get(id);
-      const group = groups.get(id);
-      const target = node ?? group;
-      if (target && !target.classes.includes(className)) target.classes.push(className);
-    }
-  }
-  for (const { id, styles } of styleAssignments) {
-    const target = nodes.get(id) ?? groups.get(id);
-    if (target) target.styles.push(...styles);
-  }
-  for (const { id, rest } of clicks) {
-    const node = nodes.get(id);
-    if (!node) continue;
-    const parsed = parseClick(rest);
-    if (parsed.href) {
-      node.link = parsed.href;
-      node.linkTarget = parsed.target;
-    }
-    if (parsed.tooltip) node.tooltip = parsed.tooltip;
-    if (parsed.callback) node.data = { ...node.data ?? {}, callback: parsed.callback };
-  }
-  for (const { targets, styles } of linkStyles) {
-    if (targets === "default") {
-      for (const edge of edges) edge.styles.push(...styles);
-    } else {
-      for (const idx of targets) {
-        const edge = edges[idx];
-        if (edge) edge.styles.push(...styles);
-        else
-          diagnostics.push({
-            severity: "warning",
-            message: `linkStyle index ${idx} has no edge`,
-            source: "pixerate"
-          });
-      }
-    }
-  }
-  for (const { id, data } of dataOnly) {
-    const edge = edges.find((e) => e.id === id);
-    if (edge) {
-      if (data.animate !== void 0) edge.animate = data.animate.trim() === "true";
-      if (data.animation !== void 0) {
-        const a = data.animation.trim();
-        if (a === "fast" || a === "slow") edge.animation = a;
-      }
-    } else {
-      const node = {
-        id,
-        label: id,
-        shape: DEFAULT_SHAPE,
-        classes: [],
-        styles: [],
-        data: stripQuotes(data)
-      };
-      nodes.set(id, node);
-    }
-  }
-  return {
-    graph: {
-      direction,
-      nodes: [...nodes.values()],
-      edges,
-      groups: [...groups.values()],
-      classDefs,
-      title
-    },
-    diagnostics
-  };
-}
-function stripQuotes(data) {
-  const out = {};
-  for (const [k, v] of Object.entries(data)) {
-    const t = v.trim();
-    if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))
-      out[k] = t.slice(1, -1);
-    else if (t === "true" || t === "false") out[k] = t === "true";
-    else if (/^-?\d+(\.\d+)?$/.test(t)) out[k] = Number(t);
-    else out[k] = t;
-  }
-  return out;
-}
-function parseClick(rest) {
-  const out = {};
-  const strings = [...rest.matchAll(/"([^"]*)"/g)].map((m) => m[1]);
-  const words = rest.replace(/"[^"]*"/g, "").trim().split(/\s+/).filter(Boolean);
-  const targetWord = words.find((w) => /^_(blank|self|parent|top)$/.test(w));
-  if (targetWord) out.target = targetWord;
-  if (words[0] === "href") {
-    out.href = strings[0];
-    out.tooltip = strings[1];
-  } else if (words[0] === "call" || words[0] === "callback") {
-    out.callback = words[0] === "callback" ? words[1] : rest.replace(/^call\s+/, "").replace(/"[^"]*"/g, "").trim();
-    out.tooltip = strings[0];
-  } else if (strings.length && /^https?:|^\/|^#|^mailto:/.test(strings[0])) {
-    out.href = strings[0];
-    out.tooltip = strings[1];
-  } else if (words.length) {
-    out.callback = words[0];
-    out.tooltip = strings[0];
-  }
-  return out;
-}
-function parseFlowchart(_source, ctx) {
-  const statements = tokenizeBody(ctx.bodyLines);
-  const direction = headerDirection(ctx.header);
-  const title = typeof ctx.preamble.frontmatter?.title === "string" ? ctx.preamble.frontmatter.title : void 0;
-  const { graph, diagnostics } = buildGraph(statements, direction, title);
-  return {
-    family: "flowchart",
-    tier: "editable",
-    source: ctx.source,
-    preamble: ctx.preamble,
-    header: ctx.header,
-    trailing: ctx.trailing,
-    eol: ctx.eol,
-    graph,
-    meta: ctx.meta,
-    metaCarrier: ctx.metaCarrier,
-    body: { statements },
-    diagnostics,
-    dirty: false
-  };
-}
-
-// src/diagram/flowchart/serialize.ts
-function serializeStatements(statements) {
-  const out = [];
-  const emitted = /* @__PURE__ */ new Set();
-  const present = new Set(statements);
-  for (const stmt of statements) {
-    if (emitted.has(stmt)) continue;
-    const compound = compoundInfo(stmt);
-    if (compound) {
-      const members = compound.members.filter((m) => present.has(m));
-      const complete = members.length === compound.members.length;
-      const anyDirty = members.some((m) => "dirty" in m && m.dirty);
-      if (complete && !anyDirty) {
-        out.push(compound.raw);
-        for (const member of compound.members) emitted.add(member);
-        continue;
-      }
-      const indent = "indent" in compound.members[0] ? compound.members[0].indent : "";
-      for (const member of members) {
-        const text = formatStatement(member);
-        if (text.trim() === "") continue;
-        out.push(text.startsWith(indent) ? text : indent + text.trimStart());
-      }
-      for (const member of compound.members) emitted.add(member);
-      continue;
-    }
-    out.push(formatStatement(stmt));
-    emitted.add(stmt);
-  }
-  return out;
-}
-function detectIndent(statements) {
-  for (const stmt of statements) {
-    if ("indent" in stmt && stmt.indent) return stmt.indent;
-  }
-  return "  ";
-}
-function assembleDocument(doc, bodyLines, indent) {
-  const meta = isMetaEmpty(doc.meta) ? null : doc.meta;
-  const preambleLines = doc.metaCarrier === "frontmatter" ? writeMetaToPreamble(doc.preamble, meta) : [...doc.preamble.lines];
-  const lines = [...preambleLines];
-  if (doc.header) lines.push(doc.header);
-  if (meta && doc.metaCarrier === "comment") lines.push(metaCommentLine(meta, indent));
-  lines.push(...bodyLines);
-  return lines.join(doc.eol) + doc.trailing;
-}
-function serializeFlowchart(doc) {
-  const bodyLines = serializeStatements(doc.body.statements);
-  return assembleDocument(doc, bodyLines, detectIndent(doc.body.statements));
-}
-
-// src/diagram/flowchart/edit.ts
-function applyFlowchartEdit(doc, op) {
-  if (op.type === "removeEdges" && op.ids.length > 1) return removeEdgesOneByOne(doc, op.ids);
-  const statements = cloneStatements(doc.body.statements);
-  const work = {
-    ...doc,
-    body: { statements },
-    meta: { ...doc.meta, layout: { ...doc.meta.layout }, sizes: { ...doc.meta.sizes } }
-  };
-  const indent = detectIndent(statements);
-  switch (op.type) {
-    case "moveNodes":
-      for (const { id, position } of op.moves) work.meta.layout[id] = position;
-      return reparse(work, false);
-    case "resizeNode":
-      if (op.size) work.meta.sizes[op.id] = op.size;
-      else delete work.meta.sizes[op.id];
-      return reparse(work, false);
-    case "setViewport":
-      work.meta.viewport = op.viewport;
-      return reparse(work, false);
-    case "setMetaExt":
-      work.meta.ext = { ...work.meta.ext ?? {}, [op.key]: op.value };
-      if (op.value === void 0) delete work.meta.ext[op.key];
-      return reparse(work, false);
-    case "setDirection":
-      work.header = setHeaderDirection(work.header, op.direction);
-      return reparse(work, true);
-    case "setTitle":
-      work.preamble = {
-        ...work.preamble,
-        lines: setFrontmatterTitle(work.preamble.lines, op.title)
-      };
-      return reparse(work, true);
-    case "replaceSource":
-      return parseFlowchartSource(op.source, work.metaCarrier);
-    default:
-      break;
-  }
-  switch (op.type) {
-    case "addNode": {
-      const ref = {
-        id: op.node.id,
-        label: op.node.label ?? op.node.id,
-        shape: canonicalShape(op.node.shape ?? "rect"),
-        form: "bracket",
-        classes: [...op.node.classes ?? []]
-      };
-      const data = shapeDataFor(ref.shape, encodeData(op.node.data));
-      if (Object.keys(data).length) {
-        ref.form = "data";
-        ref.data = data;
-      }
-      const stmt = {
-        kind: "chain",
-        raw: "",
-        indent,
-        chain: { groups: [[ref]], links: [] },
-        dirty: true
-      };
-      insertIntoGroup(statements, stmt, op.node.parentId, indent);
-      if (op.position) work.meta.layout[op.node.id] = op.position;
-      if (op.node.styles?.length) {
-        statements.push({
-          kind: "style",
-          raw: "",
-          indent,
-          id: op.node.id,
-          styles: [...op.node.styles],
-          dirty: true
-        });
-      }
-      break;
-    }
-    case "removeNodes": {
-      const ids = new Set(op.ids.filter((id) => !doc.graph.groups.some((g) => g.id === id)));
-      for (const gid of op.ids.filter((id) => doc.graph.groups.some((g) => g.id === id))) {
-        const range = groupRange(statements, gid);
-        if (!range) continue;
-        statements.splice(range.end, 1);
-        statements.splice(range.start, 1);
-        delete work.meta.layout[gid];
-        delete work.meta.sizes[gid];
-      }
-      const removedEdgeOrdinals = edgeOrdinalsTouching(
-        doc.graph.edges,
-        (e) => ids.has(e.source) || ids.has(e.target)
-      );
-      removeNodesFromStatements(statements, ids);
-      dropRedundantBareMentions(statements);
-      filterInPlace(statements, (s) => {
-        if (s.kind === "style" || s.kind === "click") return !ids.has(s.id);
-        if (s.kind === "class") {
-          s.ids = s.ids.filter((id) => !ids.has(id));
-          if (!s.ids.length) return false;
-          s.dirty = true;
-          return true;
-        }
-        return true;
-      });
-      adjustLinkStyles(statements, removedEdgeOrdinals);
-      for (const id of ids) {
-        delete work.meta.layout[id];
-        delete work.meta.sizes[id];
-      }
-      break;
-    }
-    case "renameNode": {
-      const ref = declaringRef(statements, op.id, "label") ?? firstRef(statements, op.id);
-      if (!ref) break;
-      const node = doc.graph.nodes.find((n) => n.id === op.id);
-      if (ref.ref.label === void 0) {
-        ref.ref.shape = ref.ref.shape ?? node?.shape ?? "rect";
-        ref.ref.form = ref.ref.form ?? "bracket";
-      }
-      ref.ref.label = op.label;
-      ref.ref.labelQuoted = void 0;
-      ref.stmt.dirty = true;
-      break;
-    }
-    case "setNodeShape": {
-      const shape = canonicalShape(op.shape);
-      const ref = declaringRef(statements, op.id, "shape") ?? firstRef(statements, op.id);
-      if (!ref) break;
-      const node = doc.graph.nodes.find((n) => n.id === op.id);
-      ref.ref.shape = shape;
-      if (ref.ref.label === void 0) ref.ref.label = node?.label ?? op.id;
-      ref.ref.form = ref.ref.form ?? "bracket";
-      const data = shapeDataFor(shape, ref.ref.data ?? {});
-      if (Object.keys(data).length) ref.ref.form = "data";
-      ref.ref.data = Object.keys(data).length ? data : void 0;
-      ref.stmt.dirty = true;
-      break;
-    }
-    case "setNodeClasses": {
-      for (const s of statements) {
-        if (s.kind === "chain") {
-          for (const g of s.chain.groups) {
-            for (const r of g) {
-              if (r.id === op.id && r.classes.length) {
-                r.classes = [];
-                s.dirty = true;
-              }
-            }
-          }
-        }
-      }
-      filterInPlace(statements, (s) => {
-        if (s.kind !== "class") return true;
-        if (!s.ids.includes(op.id)) return true;
-        s.ids = s.ids.filter((id) => id !== op.id);
-        s.dirty = true;
-        return s.ids.length > 0;
-      });
-      const [first, ...rest] = op.classes;
-      if (first) {
-        const ref = declaringRef(statements, op.id, "label") ?? firstRef(statements, op.id);
-        if (ref) {
-          ref.ref.classes = [first];
-          ref.stmt.dirty = true;
-        }
-      }
-      for (const cls of rest)
-        statements.push({
-          kind: "class",
-          raw: "",
-          indent,
-          ids: [op.id],
-          className: cls,
-          dirty: true
-        });
-      break;
-    }
-    case "setNodeStyles": {
-      filterInPlace(statements, (s) => !(s.kind === "style" && s.id === op.id));
-      if (op.styles.length)
-        statements.push({
-          kind: "style",
-          raw: "",
-          indent,
-          id: op.id,
-          styles: [...op.styles],
-          dirty: true
-        });
-      break;
-    }
-    case "setNodeLink": {
-      filterInPlace(statements, (s) => !(s.kind === "click" && s.id === op.id));
-      if (op.link) {
-        const parts = [`href "${op.link}"`];
-        if (op.tooltip) parts.push(`"${op.tooltip}"`);
-        if (op.target) parts.push(op.target);
-        statements.push({
-          kind: "click",
-          raw: "",
-          indent,
-          id: op.id,
-          rest: parts.join(" "),
-          dirty: true
-        });
-      }
-      break;
-    }
-    case "setNodeData": {
-      const ref = declaringRef(statements, op.id, "label") ?? firstRef(statements, op.id);
-      if (!ref) break;
-      const node = doc.graph.nodes.find((n) => n.id === op.id);
-      ref.ref.form = "data";
-      ref.ref.shape = ref.ref.shape ?? node?.shape ?? "rect";
-      if (ref.ref.label === void 0) ref.ref.label = node?.label ?? op.id;
-      const data = { ...ref.ref.data ?? {} };
-      for (const [k, v] of Object.entries(op.data)) {
-        if (v === void 0 || v === null) delete data[k];
-        else data[k] = typeof v === "string" ? JSON.stringify(v) : String(v);
-      }
-      ref.ref.data = data;
-      ref.stmt.dirty = true;
-      break;
-    }
-    case "addEdge": {
-      const link = {
-        id: op.edge.userDefinedId ? op.edge.id : void 0,
-        pattern: op.edge.pattern ?? "solid",
-        arrowStart: op.edge.arrowStart ?? "none",
-        arrowEnd: op.edge.arrowEnd ?? "arrow_point",
-        length: op.edge.length ?? 1,
-        label: op.edge.label || void 0,
-        labelStyle: op.edge.label ? "pipe" : void 0
-      };
-      const stmt = {
-        kind: "chain",
-        raw: "",
-        indent,
-        chain: {
-          groups: [[{ id: op.edge.source, classes: [] }], [{ id: op.edge.target, classes: [] }]],
-          links: [link]
-        },
-        dirty: true
-      };
-      appendAtEnd(statements, stmt);
-      if (op.edge.styles?.length) {
-        statements.push({
-          kind: "linkStyle",
-          raw: "",
-          indent,
-          targets: [doc.graph.edges.length],
-          styles: [...op.edge.styles],
-          dirty: true
-        });
-      }
-      break;
-    }
-    case "removeEdges": {
-      const ids = new Set(op.ids);
-      const removedOrdinals = edgeOrdinalsTouching(doc.graph.edges, (e) => ids.has(e.id));
-      for (const edge of doc.graph.edges) {
-        if (!ids.has(edge.id)) continue;
-        const located = locateEdge(statements, doc.graph.edges, edge.id);
-        if (!located) continue;
-        removeLinkFromChain(
-          statements,
-          located.stmt,
-          located.linkIndex,
-          located.source,
-          located.target,
-          indent
-        );
-      }
-      adjustLinkStyles(statements, removedOrdinals);
-      break;
-    }
-    case "setEdgeLabel":
-    case "setEdgeStyle":
-    case "reconnectEdge": {
-      const located = locateEdge(statements, doc.graph.edges, op.id);
-      if (!located) break;
-      const stmt = isolateEdge(
-        statements,
-        located.stmt,
-        located.linkIndex,
-        located.source,
-        located.target,
-        indent
-      );
-      const link = stmt.chain.links[0];
-      if (op.type === "setEdgeLabel") {
-        link.label = op.label || void 0;
-        if (link.label && !link.labelStyle) link.labelStyle = "pipe";
-      } else if (op.type === "setEdgeStyle") {
-        if (op.pattern) link.pattern = op.pattern;
-        if (op.arrowStart) link.arrowStart = op.arrowStart;
-        if (op.arrowEnd) link.arrowEnd = op.arrowEnd;
-        if (op.length) link.length = op.length;
-        if (op.styles) {
-          const ordinal = doc.graph.edges.findIndex((e) => e.id === op.id);
-          setLinkStyleFor(statements, ordinal, op.styles, indent);
-        }
-      } else {
-        stmt.chain.groups[0] = [{ id: op.source, classes: [] }];
-        stmt.chain.groups[1] = [{ id: op.target, classes: [] }];
-      }
-      stmt.dirty = true;
-      break;
-    }
-    case "groupNodes": {
-      const open = {
-        kind: "subgraph",
-        raw: "",
-        indent,
-        id: op.groupId,
-        title: op.label,
-        titleForm: "bracket",
-        dirty: true
-      };
-      const members = op.nodeIds.map((id) => ({
-        kind: "chain",
-        raw: "",
-        indent: indent + indent,
-        chain: { groups: [[{ id, classes: [] }]], links: [] },
-        dirty: true
-      }));
-      const block = [
-        open,
-        ...members,
-        { kind: "end", raw: `${indent}end`, indent }
-      ];
-      if (op.parentId) insertManyIntoGroup(statements, block, op.parentId, indent);
-      else statements.push(...block);
-      break;
-    }
-    case "ungroup": {
-      const range = groupRange(statements, op.groupId);
-      if (!range) break;
-      const openIndent = statements[range.start].indent;
-      const inner = openIndent + indent;
-      for (let i = range.start + 1; i < range.end; i++) {
-        const s = statements[i];
-        if (s.kind === "raw" || s.kind === "end") {
-          if (s.raw.startsWith(inner))
-            s.raw = openIndent + s.raw.slice(inner.length);
-          continue;
-        }
-        if (s.indent.startsWith(inner)) {
-          s.indent = openIndent + s.indent.slice(inner.length);
-          s.dirty = true;
-        }
-      }
-      statements.splice(range.end, 1);
-      statements.splice(range.start, 1);
-      for (let i = range.start; i < range.end - 1; i++) {
-        const s = statements[i];
-        if (s && s.kind === "direction" && depthAt(statements, i) === depthAt(statements, range.start)) {
-          statements.splice(i, 1);
-          break;
-        }
-      }
-      delete work.meta.layout[op.groupId];
-      delete work.meta.sizes[op.groupId];
-      break;
-    }
-    case "renameGroup": {
-      const range = groupRange(statements, op.id);
-      if (!range) break;
-      const open = statements[range.start];
-      open.title = op.label;
-      if (open.titleForm === "none") open.titleForm = "bracket";
-      if (open.titleForm === "bare") {
-        open.titleForm = "bracket";
-      }
-      open.dirty = true;
-      break;
-    }
-    case "setGroupDirection": {
-      const range = groupRange(statements, op.id);
-      if (!range) break;
-      let found = -1;
-      for (let i = range.start + 1; i < range.end; i++) {
-        const s = statements[i];
-        if (s.kind === "direction" && depthAt(statements, i) === depthAt(statements, range.start) + 1) {
-          found = i;
-          break;
-        }
-      }
-      if (op.direction) {
-        if (found !== -1) {
-          const s = statements[found];
-          s.direction = op.direction;
-          s.dirty = true;
-        } else {
-          const inner = statements[range.start].indent + indent;
-          statements.splice(range.start + 1, 0, {
-            kind: "direction",
-            raw: "",
-            indent: inner,
-            direction: op.direction,
-            dirty: true
-          });
-        }
-      } else if (found !== -1) {
-        statements.splice(found, 1);
-      }
-      break;
-    }
-    case "setNodeParent": {
-      for (const id of op.ids) {
-        const bare = statements.map((s, i) => ({ s, i })).filter(
-          ({ s }) => s.kind === "chain" && s.chain.links.length === 0 && s.chain.groups[0].length === 1 && s.chain.groups[0][0].id === id
-        );
-        let decl;
-        for (const { s, i } of bare.reverse()) {
-          const ref = s.chain.groups[0][0];
-          if (ref.label !== void 0 || ref.shape) decl = { ...ref };
-          statements.splice(i, 1);
-        }
-        if (op.parentId) {
-          const ref = decl ?? { id, classes: [] };
-          const stmt = {
-            kind: "chain",
-            raw: "",
-            indent,
-            chain: { groups: [[ref]], links: [] },
-            dirty: true
-          };
-          insertIntoGroup(statements, stmt, op.parentId, indent);
-        } else if (decl) {
-          appendAtEnd(statements, {
-            kind: "chain",
-            raw: "",
-            indent,
-            chain: { groups: [[decl]], links: [] },
-            dirty: true
-          });
-        }
-      }
-      break;
-    }
-    case "setClassDef": {
-      let found = false;
-      for (const s of statements) {
-        if (s.kind !== "classDef") continue;
-        if (s.names.length === 1 && s.names[0] === op.name) {
-          found = true;
-          if (op.styles) {
-            s.styles = [...op.styles];
-            s.dirty = true;
-          }
-        } else if (s.names.includes(op.name) && op.styles) {
-          s.names = s.names.filter((n) => n !== op.name);
-          s.dirty = true;
-        }
-      }
-      if (!op.styles)
-        filterInPlace(
-          statements,
-          (s) => !(s.kind === "classDef" && s.names.length === 1 && s.names[0] === op.name)
-        );
-      else if (!found)
-        statements.push({
-          kind: "classDef",
-          raw: "",
-          indent,
-          names: [op.name],
-          styles: [...op.styles],
-          dirty: true
-        });
-      break;
-    }
-    default:
-      break;
-  }
-  return reparse(work, true);
-}
-function cloneStatements(statements) {
-  const clones = statements.map(cloneStatement);
-  const index = new Map(statements.map((s, i) => [s, i]));
-  const done = /* @__PURE__ */ new Set();
-  statements.forEach((original) => {
-    const info = compoundInfo(original);
-    if (!info || done.has(original)) return;
-    const members = info.members.map((m) => clones[index.get(m)]);
-    info.members.forEach((m, j) => {
-      done.add(m);
-      markCompound(members[j], members, j === 0 ? info.raw : "");
-    });
-  });
-  return clones;
-}
-function cloneStatement(s) {
-  if (s.kind === "chain") {
-    return {
-      ...s,
-      chain: {
-        groups: s.chain.groups.map(
-          (g) => g.map((r) => ({
-            ...r,
-            classes: [...r.classes],
-            data: r.data ? { ...r.data } : void 0
-          }))
-        ),
-        links: s.chain.links.map((l) => ({ ...l }))
-      }
-    };
-  }
-  if (s.kind === "classDef") return { ...s, names: [...s.names], styles: [...s.styles] };
-  if (s.kind === "class") return { ...s, ids: [...s.ids] };
-  if (s.kind === "style") return { ...s, styles: [...s.styles] };
-  if (s.kind === "linkStyle")
-    return {
-      ...s,
-      targets: s.targets === "default" ? "default" : [...s.targets],
-      styles: [...s.styles]
-    };
-  return { ...s };
-}
-function reparse(work, structural) {
-  const text = serializeFlowchart(work);
-  const next = parseFlowchartSource(text, work.metaCarrier);
-  next.dirty = doc_dirty(work, structural);
-  return next;
-}
-function doc_dirty(work, structural) {
-  return work.dirty || structural;
-}
-function parseFlowchartSource(source, carrier) {
-  const split = splitSource(source);
-  const fromBody = extractMetaFromBody(split.bodyLines);
-  const fromFm = extractMetaFromFrontmatter(split.preamble);
-  let meta = emptyMeta();
-  if (fromFm) meta = mergeMeta(meta, fromFm);
-  if (fromBody.meta) meta = mergeMeta(meta, fromBody.meta);
-  return parseFlowchart(source, {
-    source,
-    eol: split.eol,
-    preamble: split.preamble,
-    header: split.header,
-    bodyLines: fromBody.bodyLines,
-    trailing: split.trailing,
-    meta,
-    metaCarrier: carrier ?? (fromFm && !fromBody.meta ? "frontmatter" : defaultCarrierFor("flowchart")),
-    family: "flowchart"
-  });
-}
-function filterInPlace(arr, keep) {
-  let j = 0;
-  for (let i = 0; i < arr.length; i++) {
-    if (keep(arr[i])) arr[j++] = arr[i];
-  }
-  arr.length = j;
-}
-function setHeaderDirection(header, direction) {
-  const m = /^(\s*)(flowchart|graph)(-elk)?\b/i.exec(header);
-  if (!m) return header;
-  const keyword = `${m[2]}${m[3] ?? ""}`;
-  const trailingSemi = /;\s*$/.test(header) ? ";" : "";
-  return `${m[1]}${keyword} ${direction}${trailingSemi}`;
-}
-function setFrontmatterTitle(lines, title) {
-  const out = [...lines];
-  const hasFm = out[0] !== void 0 && /^---\s*$/.test(out[0]);
-  if (!hasFm) {
-    if (title === void 0) return out;
-    return ["---", `title: ${title}`, "---", ...out];
-  }
-  const close = out.findIndex((l, i) => i > 0 && /^---\s*$/.test(l));
-  const end = close === -1 ? out.length : close;
-  const idx = out.findIndex((l, i) => i > 0 && i < end && /^title\s*:/.test(l));
-  if (title === void 0) {
-    if (idx !== -1) out.splice(idx, 1);
-    const close2 = out.findIndex((l, i) => i > 0 && /^---\s*$/.test(l));
-    if (close2 === 1) out.splice(0, 2);
-    return out;
-  }
-  if (idx !== -1) out[idx] = `title: ${title}`;
-  else out.splice(end, 0, `title: ${title}`);
-  return out;
-}
-function depthAt(statements, index) {
-  let depth = 0;
-  for (let i = 0; i < index; i++) {
-    const s = statements[i];
-    if (s.kind === "subgraph") depth++;
-    else if (s.kind === "end") depth = Math.max(0, depth - 1);
-  }
-  return depth;
-}
-function groupRange(statements, groupId) {
-  const start = statements.findIndex((s) => s.kind === "subgraph" && s.id === groupId);
-  if (start === -1) return null;
-  let depth = 0;
-  for (let i = start; i < statements.length; i++) {
-    const s = statements[i];
-    if (s.kind === "subgraph") depth++;
-    else if (s.kind === "end") {
-      depth--;
-      if (depth === 0) return { start, end: i };
-    }
-  }
-  return { start, end: statements.length };
-}
-function appendAtEnd(statements, stmt) {
-  statements.push(stmt);
-}
-function insertIntoGroup(statements, stmt, groupId, indent) {
-  insertManyIntoGroup(statements, [stmt], groupId, indent);
-}
-function insertManyIntoGroup(statements, block, groupId, indent) {
-  const range = groupId ? groupRange(statements, groupId) : null;
-  if (!range) {
-    statements.push(...block);
-    return;
-  }
-  const open = statements[range.start];
-  const inner = open.indent + indent;
-  for (const s of block)
-    if ("indent" in s)
-      s.indent = inner + s.indent.slice(indent.length);
-  statements.splice(range.end, 0, ...block);
-}
-function declaringRef(statements, id, prop) {
-  for (const s of statements) {
-    if (s.kind !== "chain") continue;
-    for (const g of s.chain.groups) {
-      for (const r of g) {
-        if (r.id === id && r[prop] !== void 0) return { stmt: s, ref: r };
-      }
-    }
-  }
-  return null;
-}
-function firstRef(statements, id) {
-  for (const s of statements) {
-    if (s.kind !== "chain") continue;
-    for (const g of s.chain.groups) for (const r of g) if (r.id === id) return { stmt: s, ref: r };
-  }
-  return null;
-}
-function edgeOrdinalsTouching(edges, predicate) {
-  const out = [];
-  edges.forEach((e, i) => {
-    if (predicate(e)) out.push(i);
-  });
-  return out;
-}
-function adjustLinkStyles(statements, removedOrdinals) {
-  if (!removedOrdinals.length) return;
-  const removed = new Set(removedOrdinals);
-  filterInPlace(statements, (s) => {
-    if (s.kind !== "linkStyle" || s.targets === "default") return true;
-    const next = s.targets.filter((t) => !removed.has(t)).map((t) => t - removedOrdinals.filter((r) => r < t).length);
-    if (next.length !== s.targets.length || next.some((t, i) => t !== s.targets[i])) {
-      s.targets = next;
-      s.dirty = true;
-    }
-    return next.length > 0;
-  });
-}
-function setLinkStyleFor(statements, ordinal, styles, indent) {
-  if (ordinal < 0) return;
-  filterInPlace(statements, (s) => {
-    if (s.kind !== "linkStyle" || s.targets === "default") return true;
-    if (!s.targets.includes(ordinal)) return true;
-    s.targets = s.targets.filter((t) => t !== ordinal);
-    s.dirty = true;
-    return s.targets.length > 0;
-  });
-  if (styles.length)
-    statements.push({
-      kind: "linkStyle",
-      raw: "",
-      indent,
-      targets: [ordinal],
-      styles: [...styles],
-      dirty: true
-    });
-}
-function locateEdge(statements, edges, edgeId) {
-  const target = edges.find((e) => e.id === edgeId);
-  if (!target) return null;
-  const ordinal = edges.indexOf(target);
-  let n = 0;
-  for (const s of statements) {
-    if (s.kind !== "chain") continue;
-    const { groups, links } = s.chain;
-    if (groups.length === 1 && groups[0].length === 1 && links.length === 0 && isEdgeDataStatement(groups[0][0]))
-      continue;
-    for (let i = 0; i < links.length; i++) {
-      for (const from of groups[i]) {
-        for (const to of groups[i + 1]) {
-          if (n === ordinal) return { stmt: s, linkIndex: i, source: from.id, target: to.id };
-          n++;
-        }
-      }
-    }
-  }
-  return null;
-}
-function isEdgeDataStatement(ref) {
-  return ref.form === "data" && !!ref.data && !ref.shape && ref.label === void 0 && ("animate" in ref.data || "animation" in ref.data);
-}
-function isolateEdge(statements, stmt, linkIndex, source, target, indent) {
-  const { groups, links } = stmt.chain;
-  const simple = groups.length === 2 && groups[0].length === 1 && groups[1].length === 1;
-  if (simple) return stmt;
-  const expanded = expandChain(stmt.chain);
-  const idx = statements.indexOf(stmt);
-  const out = expanded.map((chain) => ({
-    kind: "chain",
-    raw: "",
-    indent: stmt.indent || indent,
-    chain,
-    dirty: true
-  }));
-  statements.splice(idx, 1, ...out);
-  const found = out.find(
-    (s) => s.chain.links.length === 1 && s.chain.groups[0][0].id === source && s.chain.groups[1][0].id === target && sameLink(s.chain.links[0], links[linkIndex])
-  );
-  return found ?? out[0];
-}
-function sameLink(a, b) {
-  return a.pattern === b.pattern && a.arrowStart === b.arrowStart && a.arrowEnd === b.arrowEnd && a.label === b.label && a.id === b.id && a.length === b.length;
-}
-function expandChain(chain) {
-  const out = [];
-  const declared = /* @__PURE__ */ new Set();
-  const refFor = (r) => {
-    if (declared.has(r.id)) return { id: r.id, classes: [] };
-    declared.add(r.id);
-    return { ...r, classes: [...r.classes] };
-  };
-  chain.links.forEach((link, i) => {
-    for (const from of chain.groups[i]) {
-      for (const to of chain.groups[i + 1]) {
-        out.push({ groups: [[refFor(from)], [refFor(to)]], links: [{ ...link }] });
-      }
-    }
-  });
-  if (!chain.links.length) {
-    for (const ref of chain.groups[0]) out.push({ groups: [[refFor(ref)]], links: [] });
-  }
-  return out;
-}
-function removeLinkFromChain(statements, stmt, linkIndex, source, target, indent) {
-  const isolated = isolateEdge(statements, stmt, linkIndex, source, target, indent);
-  const idx = statements.indexOf(isolated);
-  if (idx === -1) return;
-  const [from, to] = [isolated.chain.groups[0][0], isolated.chain.groups[1][0]];
-  const keep = [];
-  for (const ref of [from, to]) {
-    const declares = ref.label !== void 0 || ref.shape || ref.classes.length || ref.data && Object.keys(ref.data).length;
-    const mentionedElsewhere = statements.some(
-      (s) => s !== isolated && s.kind === "chain" && s.chain.groups.some((g) => g.some((r) => r.id === ref.id))
-    );
-    if (declares || !mentionedElsewhere) {
-      keep.push({
-        kind: "chain",
-        raw: "",
-        indent: isolated.indent || indent,
-        chain: { groups: [[ref]], links: [] },
-        dirty: true
-      });
-    }
-  }
-  statements.splice(idx, 1, ...keep);
-}
-function dropRedundantBareMentions(statements) {
-  const mentions = /* @__PURE__ */ new Map();
-  for (const s of statements) {
-    if (s.kind !== "chain") continue;
-    for (const g of s.chain.groups)
-      for (const r of g) mentions.set(r.id, (mentions.get(r.id) ?? 0) + 1);
-  }
-  filterInPlace(statements, (s) => {
-    if (s.kind !== "chain" || !s.dirty || s.chain.links.length || s.chain.groups[0].length !== 1)
-      return true;
-    const ref = s.chain.groups[0][0];
-    const bare = ref.label === void 0 && !ref.shape && !ref.classes.length && !(ref.data && Object.keys(ref.data).length);
-    if (!bare) return true;
-    if ((mentions.get(ref.id) ?? 0) > 1) {
-      mentions.set(ref.id, mentions.get(ref.id) - 1);
-      return false;
-    }
-    return true;
-  });
-}
-function removeNodesFromStatements(statements, ids) {
-  for (let i = 0; i < statements.length; i++) {
-    const s = statements[i];
-    if (s.kind !== "chain") continue;
-    const mentions = s.chain.groups.some((g) => g.some((r) => ids.has(r.id)));
-    if (!mentions) continue;
-    const pieces = splitChainWithout(s.chain, ids);
-    const replacement = pieces.map((chain) => ({
-      kind: "chain",
-      raw: "",
-      indent: s.indent,
-      chain,
-      dirty: true
-    }));
-    statements.splice(i, 1, ...replacement);
-    i += replacement.length - 1;
-  }
-}
-function splitChainWithout(chain, ids) {
-  const out = [];
-  let cur = { groups: [], links: [] };
-  for (let i = 0; i < chain.groups.length; i++) {
-    const group = chain.groups[i].filter((r) => !ids.has(r.id));
-    if (!group.length) {
-      if (cur.groups.length) out.push(cur);
-      cur = { groups: [], links: [] };
-      continue;
-    }
-    if (cur.groups.length) cur.links.push({ ...chain.links[i - 1] });
-    cur.groups.push(group);
-  }
-  if (cur.groups.length) out.push(cur);
-  return out;
-}
-function removeEdgesOneByOne(doc, ids) {
-  const wanted = new Set(ids);
-  const targets = doc.graph.edges.map((edge, ordinal) => ({ edge, ordinal })).filter(({ edge }) => wanted.has(edge.id)).map(({ edge, ordinal }) => ({
-    ordinal,
-    source: edge.source,
-    target: edge.target,
-    pairIndex: doc.graph.edges.slice(0, ordinal).filter((e) => e.source === edge.source && e.target === edge.target).length
-  })).sort((a, b) => b.ordinal - a.ordinal);
-  let current = doc;
-  for (const t of targets) {
-    const match = current.graph.edges.filter((e) => e.source === t.source && e.target === t.target)[t.pairIndex];
-    if (match) current = applyFlowchartEdit(current, { type: "removeEdges", ids: [match.id] });
-  }
-  return current;
-}
-function encodeData(data) {
-  const out = {};
-  for (const [k, v] of Object.entries(data ?? {})) {
-    if (v === void 0 || v === null) continue;
-    out[k] = typeof v === "string" ? JSON.stringify(v) : String(v);
-  }
-  return out;
-}
-var IMAGE_KEYS = ["img", "pos", "w", "h", "constraint"];
-function shapeDataFor(shape, data) {
-  const out = { ...data };
-  if (shape === "image") {
-    if (!("img" in out)) out.img = '""';
-  } else {
-    for (const key of IMAGE_KEYS) delete out[key];
-  }
-  return out;
-}
-
-// src/diagram/flowchart/index.ts
-var flowchartAdapter = {
-  family: "flowchart",
-  tier: "editable",
-  parse: parseFlowchart,
-  serialize: serializeFlowchart,
-  apply: applyFlowchartEdit
-};
-
-// src/diagram/lines-grammar/engine.ts
-function buildLineGraph(grammar, statements, direction, title) {
-  const nodes = /* @__PURE__ */ new Map();
-  const groups = /* @__PURE__ */ new Map();
-  const edges = [];
-  const classDefs = {};
-  const diagnostics = [];
-  const stack = [];
-  const classAssignments = [];
-  const styleAssignments = [];
-  let ordinal = 0;
-  const touch = (decl, role) => {
-    if (role !== "decl" && grammar.resolveEndpoint) {
-      const resolved = grammar.resolveEndpoint(decl.id, stack, role);
-      if (resolved) {
-        if (!nodes.has(resolved.id)) {
-          nodes.set(resolved.id, {
-            id: resolved.id,
-            label: resolved.label,
-            shape: resolved.shape,
-            parentId: stack[stack.length - 1],
-            classes: [],
-            styles: [],
-            data: { synthetic: true }
-          });
-        }
-        return resolved.id;
-      }
-    }
-    let node = nodes.get(decl.id);
-    if (!node) {
-      node = { id: decl.id, label: decl.id, shape: grammar.defaultShape, classes: [], styles: [] };
-      nodes.set(decl.id, node);
-    }
-    const parent = stack[stack.length - 1];
-    if (parent) node.parentId = parent;
-    if (decl.label !== void 0) node.label = decl.label;
-    if (decl.shape) node.shape = decl.shape;
-    for (const cls of decl.classes) if (!node.classes.includes(cls)) node.classes.push(cls);
-    if (decl.data) node.data = mergeData(node.data, decl.data);
-    return node.id;
-  };
-  for (const stmt of statements) {
-    switch (stmt.kind) {
-      case "groupOpen": {
-        const parent = stack[stack.length - 1];
-        const existing = nodes.get(stmt.id);
-        if (existing) nodes.delete(stmt.id);
-        groups.set(stmt.id, {
-          id: stmt.id,
-          label: stmt.label ?? existing?.label ?? stmt.id,
-          parentId: parent,
-          classes: existing?.classes ?? [],
-          styles: existing?.styles ?? [],
-          data: existing?.data
-        });
-        stack.push(stmt.id);
-        break;
-      }
-      case "groupClose":
-        if (!stack.length)
-          diagnostics.push({
-            severity: "warning",
-            message: "Unbalanced closing brace",
-            source: "pixerate"
-          });
-        stack.pop();
-        break;
-      case "direction": {
-        const current = stack[stack.length - 1];
-        if (current) groups.get(current).direction = stmt.direction;
-        break;
-      }
-      case "node":
-        touch(stmt.decl, "decl");
-        break;
-      case "edge": {
-        const s = touch(stmt.source, "source");
-        const t = touch(stmt.target, "target");
-        edges.push({
-          id: `L_${s}_${t}_${ordinal}`,
-          source: s,
-          target: t,
-          label: stmt.label,
-          pattern: stmt.pattern,
-          arrowStart: stmt.arrowStart,
-          arrowEnd: stmt.arrowEnd,
-          length: 1,
-          classes: [],
-          styles: [],
-          userDefinedId: false,
-          data: stmt.data
-        });
-        ordinal++;
-        break;
-      }
-      case "classDef":
-        for (const name of stmt.names) classDefs[name] = [...stmt.styles];
-        break;
-      case "class":
-        classAssignments.push({ ids: stmt.ids, className: stmt.className });
-        break;
-      case "style":
-        styleAssignments.push({ id: stmt.id, styles: stmt.styles });
-        break;
-      default:
-        break;
-    }
-  }
-  if (stack.length)
-    diagnostics.push({
-      severity: "warning",
-      message: `${stack.length} block(s) not closed`,
-      source: "pixerate"
-    });
-  for (const edge of edges) {
-    for (const end of ["source", "target"]) {
-      const id = edge[end];
-      if (groups.has(id) && nodes.has(id)) nodes.delete(id);
-    }
-  }
-  for (const { ids, className } of classAssignments) {
-    for (const id of ids) {
-      const target = nodes.get(id) ?? groups.get(id);
-      if (target && !target.classes.includes(className)) target.classes.push(className);
-    }
-  }
-  for (const { id, styles } of styleAssignments) {
-    const target = nodes.get(id) ?? groups.get(id);
-    if (target) target.styles.push(...styles);
-  }
-  return {
-    graph: {
-      direction,
-      nodes: [...nodes.values()],
-      edges,
-      groups: [...groups.values()],
-      classDefs,
-      title
-    },
-    diagnostics
-  };
-}
-function mergeData(a, b) {
-  const out = { ...a ?? {} };
-  for (const [k, v] of Object.entries(b)) {
-    if (Array.isArray(v) && Array.isArray(out[k])) out[k] = [...out[k], ...v];
-    else out[k] = v;
-  }
-  return out;
-}
-function parseLineDocument(grammar, source, ctx) {
-  const statements = grammar.joinLines(ctx.bodyLines).map((line) => grammar.parseLine(line));
-  const direction = grammar.headerDirection(ctx.header, statements);
-  const title = typeof ctx.preamble.frontmatter?.title === "string" ? ctx.preamble.frontmatter.title : void 0;
-  const { graph, diagnostics } = buildLineGraph(grammar, statements, direction, title);
-  return {
-    family: grammar.family,
-    tier: "editable",
-    source,
-    preamble: ctx.preamble,
-    header: ctx.header,
-    trailing: ctx.trailing,
-    eol: ctx.eol,
-    graph,
-    meta: ctx.meta,
-    metaCarrier: ctx.metaCarrier,
-    body: { statements },
-    diagnostics,
-    dirty: false
-  };
-}
-function serializeLineDocument(grammar, doc) {
-  const lines = [];
-  for (const stmt of doc.body.statements) {
-    if (stmt.kind === "raw") {
-      lines.push(stmt.raw);
-      continue;
-    }
-    if (!("dirty" in stmt) || !stmt.dirty) {
-      lines.push(stmt.raw);
-      if (stmt.kind === "node" && stmt.body) lines.push(...stmt.body);
-      continue;
-    }
-    lines.push(grammar.formatStatement(stmt));
-    if (stmt.kind === "node" && stmt.body) lines.push(...stmt.body);
-  }
-  const indent = detectIndent2(doc.body.statements);
-  return assembleDocument(doc, lines, indent);
-}
-function detectIndent2(statements) {
-  for (const s of statements) if (s.indent) return s.indent;
-  return "  ";
-}
-function parseFull(grammar, source, carrier) {
-  const split = splitSource(source);
-  const fromBody = extractMetaFromBody(split.bodyLines);
-  const fromFm = extractMetaFromFrontmatter(split.preamble);
-  let meta = emptyMeta();
-  if (fromFm) meta = mergeMeta(meta, fromFm);
-  if (fromBody.meta) meta = mergeMeta(meta, fromBody.meta);
-  return parseLineDocument(grammar, source, {
-    source,
-    eol: split.eol,
-    preamble: split.preamble,
-    header: split.header,
-    bodyLines: fromBody.bodyLines,
-    trailing: split.trailing,
-    meta,
-    metaCarrier: carrier ?? (fromFm && !fromBody.meta ? "frontmatter" : defaultCarrierFor(grammar.family)),
-    family: grammar.family
-  });
-}
-function applyLineEdit(grammar, doc, op) {
-  const statements = doc.body.statements.map((s) => ({
-    ...s,
-    ..."decl" in s ? {
-      decl: {
-        ...s.decl,
-        classes: [...s.decl.classes],
-        data: s.decl.data ? { ...s.decl.data } : void 0
-      }
-    } : {},
-    ..."source" in s ? {
-      source: { ...s.source, classes: [...s.source.classes] },
-      target: { ...s.target, classes: [...s.target.classes] }
-    } : {}
-  }));
-  const work = {
-    ...doc,
-    body: { statements },
-    meta: { ...doc.meta, layout: { ...doc.meta.layout }, sizes: { ...doc.meta.sizes } }
-  };
-  const indent = detectIndent2(statements);
-  const reparse2 = (structural) => {
-    const text = serializeLineDocument(grammar, work);
-    const next = parseFull(grammar, text, work.metaCarrier);
-    next.dirty = doc.dirty || structural;
-    return next;
-  };
-  switch (op.type) {
-    case "moveNodes":
-      for (const { id, position } of op.moves) work.meta.layout[id] = position;
-      return reparse2(false);
-    case "resizeNode":
-      if (op.size) work.meta.sizes[op.id] = op.size;
-      else delete work.meta.sizes[op.id];
-      return reparse2(false);
-    case "setViewport":
-      work.meta.viewport = op.viewport;
-      return reparse2(false);
-    case "setMetaExt":
-      work.meta.ext = { ...work.meta.ext ?? {}, [op.key]: op.value };
-      if (op.value === void 0) delete work.meta.ext[op.key];
-      return reparse2(false);
-    case "replaceSource":
-      return parseFull(grammar, op.source, work.metaCarrier);
-    case "setTitle": {
-      const lines = [...work.preamble.lines];
-      work.preamble = { ...work.preamble, lines: setTitle(lines, op.title) };
-      return reparse2(true);
-    }
-    case "setDirection": {
-      if (grammar.directionAsStatement) {
-        const idx = statements.findIndex(
-          (s, i) => s.kind === "direction" && depthAt2(statements, i) === 0
-        );
-        if (idx !== -1) {
-          const s = statements[idx];
-          s.direction = op.direction;
-          s.dirty = true;
-        } else {
-          statements.unshift({
-            kind: "direction",
-            raw: "",
-            indent,
-            direction: op.direction,
-            dirty: true
-          });
-        }
-      } else {
-        work.header = work.header.replace(/\s+(TB|TD|BT|LR|RL)\s*$/i, "") + ` ${op.direction}`;
-      }
-      return reparse2(true);
-    }
-    case "addNode": {
-      const decl = {
-        id: op.node.id,
-        label: op.node.label,
-        shape: op.node.shape,
-        classes: [...op.node.classes ?? []],
-        data: op.node.data
-      };
-      insertIntoGroup2(statements, [grammar.nodeStatement(decl, indent)], op.node.parentId, indent);
-      if (op.position) work.meta.layout[op.node.id] = op.position;
-      return reparse2(true);
-    }
-    case "removeNodes": {
-      const ids = new Set(op.ids);
-      filterInPlace2(statements, (s) => {
-        if (s.kind === "node") return !ids.has(s.decl.id);
-        if (s.kind === "edge") return !(ids.has(s.source.id) || ids.has(s.target.id));
-        if (s.kind === "style") return !ids.has(s.id);
-        if (s.kind === "class") {
-          s.ids = s.ids.filter((id) => !ids.has(id));
-          s.dirty = true;
-          return s.ids.length > 0;
-        }
-        return true;
-      });
-      for (const id of ids) {
-        const range = groupRange2(statements, id);
-        if (range) {
-          statements.splice(range.end, 1);
-          statements.splice(range.start, 1);
-        }
-        delete work.meta.layout[id];
-        delete work.meta.sizes[id];
-      }
-      return reparse2(true);
-    }
-    case "renameNode":
-    case "setNodeShape":
-    case "setNodeClasses":
-    case "setNodeData": {
-      const id = op.id;
-      let decl = findDecl(statements, id);
-      if (!decl) {
-        const node = doc.graph.nodes.find((n) => n.id === id);
-        const stmt = grammar.nodeStatement(
-          {
-            id,
-            label: node?.label !== id ? node?.label : void 0,
-            shape: node?.shape !== grammar.defaultShape ? node?.shape : void 0,
-            classes: []
-          },
-          indent
-        );
-        const first = statements.findIndex(
-          (s) => s.kind === "edge" && (s.source.id === id || s.target.id === id)
-        );
-        statements.splice(first === -1 ? statements.length : first, 0, stmt);
-        decl = findDecl(statements, id);
-      }
-      const target = decl.stmt;
-      if (op.type === "renameNode") decl.decl.label = op.label;
-      if (op.type === "setNodeShape") decl.decl.shape = op.shape;
-      if (op.type === "setNodeClasses") {
-        decl.decl.classes = [...op.classes];
-        filterInPlace2(statements, (s) => {
-          if (s.kind !== "class" || !s.ids.includes(id)) return true;
-          s.ids = s.ids.filter((x) => x !== id);
-          s.dirty = true;
-          return s.ids.length > 0;
-        });
-      }
-      if (op.type === "setNodeData") {
-        decl.decl.data = { ...decl.decl.data ?? {}, ...op.data };
-        if (target.kind === "node" && ("members" in op.data || "attributes" in op.data)) {
-          const fresh = grammar.nodeStatement(decl.decl, target.indent);
-          target.body = fresh.kind === "node" ? fresh.body : void 0;
-        }
-      }
-      target.dirty = true;
-      return reparse2(true);
-    }
-    case "setNodeStyles": {
-      filterInPlace2(statements, (s) => !(s.kind === "style" && s.id === op.id));
-      if (op.styles.length)
-        statements.push({
-          kind: "style",
-          raw: "",
-          indent,
-          id: op.id,
-          styles: [...op.styles],
-          dirty: true
-        });
-      return reparse2(true);
-    }
-    case "addEdge": {
-      const spec = {
-        ...grammar.defaultEdge,
-        ...op.edge.pattern ? { pattern: op.edge.pattern } : {},
-        ...op.edge.arrowStart ? { arrowStart: op.edge.arrowStart } : {},
-        ...op.edge.arrowEnd ? { arrowEnd: op.edge.arrowEnd } : {},
-        label: op.edge.label,
-        data: {
-          ...op.edge.data ?? {},
-          synthetic: {
-            source: isSyntheticEndpoint(doc, op.edge.source),
-            target: isSyntheticEndpoint(doc, op.edge.target)
-          }
-        }
-      };
-      const stmt = grammar.edgeStatement(op.edge.source, op.edge.target, spec, indent);
-      const sp = parentOf(doc, op.edge.source);
-      const tp = parentOf(doc, op.edge.target);
-      insertIntoGroup2(statements, [stmt], sp && sp === tp ? sp : void 0, indent);
-      return reparse2(true);
-    }
-    case "removeEdges": {
-      const targets = new Set(op.ids.map((id) => edgeOrdinal(doc, id)).filter((n) => n >= 0));
-      let ordinal = 0;
-      filterInPlace2(statements, (s) => {
-        if (s.kind !== "edge") return true;
-        const keep = !targets.has(ordinal);
-        ordinal++;
-        return keep;
-      });
-      return reparse2(true);
-    }
-    case "setEdgeLabel":
-    case "setEdgeStyle":
-    case "reconnectEdge": {
-      const stmt = edgeStatementFor(statements, doc, op.id);
-      if (!stmt) return doc;
-      if (op.type === "setEdgeLabel") stmt.label = op.label || void 0;
-      if (op.type === "setEdgeStyle") {
-        if (op.pattern) stmt.pattern = op.pattern;
-        if (op.arrowStart) stmt.arrowStart = op.arrowStart;
-        if (op.arrowEnd) stmt.arrowEnd = op.arrowEnd;
-      }
-      if (op.type === "reconnectEdge") {
-        stmt.source = { id: op.source, classes: [] };
-        stmt.target = { id: op.target, classes: [] };
-      }
-      stmt.dirty = true;
-      return reparse2(true);
-    }
-    case "groupNodes": {
-      if (grammar.supportsGroups === false) return doc;
-      const { open, close } = grammar.groupStatements(op.groupId, op.label, indent);
-      const moved = [];
-      const set = new Set(op.nodeIds);
-      filterInPlace2(statements, (s) => {
-        if (s.kind === "node" && set.has(s.decl.id)) {
-          moved.push(reindent(s, indent + indent));
-          return false;
-        }
-        if (s.kind === "edge" && set.has(s.source.id) && set.has(s.target.id)) {
-          moved.push(reindent(s, indent + indent));
-          return false;
-        }
-        return true;
-      });
-      for (const id of op.nodeIds) {
-        if (!moved.some((s) => s.kind === "node" && s.decl.id === id)) {
-          moved.push(grammar.nodeStatement({ id, classes: [] }, indent + indent));
-        }
-      }
-      insertIntoGroup2(statements, [open, ...moved, close], op.parentId, indent);
-      return reparse2(true);
-    }
-    case "ungroup": {
-      const range = groupRange2(statements, op.groupId);
-      if (!range) return doc;
-      const inner = statements.slice(range.start + 1, range.end).map((s) => reindent(s, statements[range.start].indent));
-      statements.splice(
-        range.start,
-        range.end - range.start + 1,
-        ...inner.filter((s) => s.kind !== "direction")
-      );
-      delete work.meta.layout[op.groupId];
-      return reparse2(true);
-    }
-    case "renameGroup": {
-      const range = groupRange2(statements, op.id);
-      if (!range) return doc;
-      const open = statements[range.start];
-      open.label = op.label;
-      open.dirty = true;
-      return reparse2(true);
-    }
-    case "setGroupDirection": {
-      const range = groupRange2(statements, op.id);
-      if (!range) return doc;
-      const idx = statements.findIndex(
-        (s, i) => i > range.start && i < range.end && s.kind === "direction" && depthAt2(statements, i) === depthAt2(statements, range.start) + 1
-      );
-      if (op.direction) {
-        if (idx !== -1) {
-          const s = statements[idx];
-          s.direction = op.direction;
-          s.dirty = true;
-        } else {
-          const inner = statements[range.start].indent + indent;
-          statements.splice(range.start + 1, 0, {
-            kind: "direction",
-            raw: "",
-            indent: inner,
-            direction: op.direction,
-            dirty: true
-          });
-        }
-      } else if (idx !== -1) statements.splice(idx, 1);
-      return reparse2(true);
-    }
-    case "setNodeParent": {
-      for (const id of op.ids) {
-        const found = findDecl(statements, id);
-        let stmt;
-        if (found) {
-          statements.splice(statements.indexOf(found.stmt), 1);
-          stmt = found.stmt;
-        } else {
-          stmt = grammar.nodeStatement({ id, classes: [] }, indent);
-        }
-        insertIntoGroup2(statements, [stmt], op.parentId, indent);
-      }
-      return reparse2(true);
-    }
-    case "setClassDef": {
-      let found = false;
-      for (const s of statements) {
-        if (s.kind !== "classDef") continue;
-        if (s.names.length === 1 && s.names[0] === op.name) {
-          found = true;
-          if (op.styles) {
-            s.styles = [...op.styles];
-            s.dirty = true;
-          }
-        }
-      }
-      if (!op.styles)
-        filterInPlace2(
-          statements,
-          (s) => !(s.kind === "classDef" && s.names.length === 1 && s.names[0] === op.name)
-        );
-      else if (!found)
-        statements.push({
-          kind: "classDef",
-          raw: "",
-          indent,
-          names: [op.name],
-          styles: [...op.styles],
-          dirty: true
-        });
-      return reparse2(true);
-    }
-    default:
-      return doc;
-  }
-}
-function isSyntheticEndpoint(doc, id) {
-  const node = doc.graph.nodes.find((n) => n.id === id);
-  if (node) return !!node.data?.synthetic;
-  const m = /^(.+)_(start|end)$/.exec(id);
-  if (!m) return false;
-  return m[1] === "root" || doc.graph.groups.some((g) => g.id === m[1]);
-}
-function reindent(s, indent) {
-  const next = { ...s, indent };
-  if (s.kind === "raw") return s;
-  next.dirty = true;
-  if (s.kind === "node" && s.body) {
-    const delta = indent.length - s.indent.length;
-    next.body = s.body.map(
-      (l) => delta >= 0 ? " ".repeat(delta) + l : l.slice(Math.min(-delta, l.length - l.trimStart().length))
-    );
-  }
-  return next;
-}
-function findDecl(statements, id) {
-  for (const s of statements) {
-    if (s.kind === "node" && s.decl.id === id) return { stmt: s, decl: s.decl };
-  }
-  for (const s of statements) {
-    if (s.kind === "edge") {
-      if (s.source.id === id && (s.source.label !== void 0 || s.source.shape || s.source.classes.length))
-        return { stmt: s, decl: s.source };
-      if (s.target.id === id && (s.target.label !== void 0 || s.target.shape || s.target.classes.length))
-        return { stmt: s, decl: s.target };
-    }
-  }
-  return null;
-}
-function parentOf(doc, id) {
-  return doc.graph.nodes.find((n) => n.id === id)?.parentId ?? doc.graph.groups.find((g) => g.id === id)?.parentId;
-}
-function edgeOrdinal(doc, edgeId) {
-  return doc.graph.edges.findIndex((e) => e.id === edgeId);
-}
-function edgeStatementFor(statements, doc, edgeId) {
-  const ordinal = edgeOrdinal(doc, edgeId);
-  if (ordinal < 0) return null;
-  let n = 0;
-  for (const s of statements) {
-    if (s.kind !== "edge") continue;
-    if (n === ordinal) return s;
-    n++;
-  }
-  return null;
-}
-function depthAt2(statements, index) {
-  let depth = 0;
-  for (let i = 0; i < index; i++) {
-    const s = statements[i];
-    if (s.kind === "groupOpen") depth++;
-    else if (s.kind === "groupClose") depth = Math.max(0, depth - 1);
-  }
-  return depth;
-}
-function groupRange2(statements, groupId) {
-  const start = statements.findIndex((s) => s.kind === "groupOpen" && s.id === groupId);
-  if (start === -1) return null;
-  let depth = 0;
-  for (let i = start; i < statements.length; i++) {
-    const s = statements[i];
-    if (s.kind === "groupOpen") depth++;
-    else if (s.kind === "groupClose") {
-      depth--;
-      if (depth === 0) return { start, end: i };
-    }
-  }
-  return { start, end: statements.length };
-}
-function insertIntoGroup2(statements, block, groupId, indent) {
-  const range = groupId ? groupRange2(statements, groupId) : null;
-  if (!range) {
-    statements.push(...block);
-    return;
-  }
-  const open = statements[range.start];
-  const inner = open.indent + indent;
-  const adjusted = block.map(
-    (s) => s.kind === "raw" ? s : reindent(s, inner + s.indent.slice(indent.length))
-  );
-  statements.splice(range.end, 0, ...adjusted);
-}
-function filterInPlace2(arr, keep) {
-  let j = 0;
-  for (let i = 0; i < arr.length; i++) if (keep(arr[i])) arr[j++] = arr[i];
-  arr.length = j;
-}
-function setTitle(lines, title) {
-  const out = [...lines];
-  const hasFm = out[0] !== void 0 && /^---\s*$/.test(out[0]);
-  if (!hasFm) return title === void 0 ? out : ["---", `title: ${title}`, "---", ...out];
-  const close = out.findIndex((l, i) => i > 0 && /^---\s*$/.test(l));
-  const end = close === -1 ? out.length : close;
-  const idx = out.findIndex((l, i) => i > 0 && i < end && /^title\s*:/.test(l));
-  if (title === void 0) {
-    if (idx !== -1) out.splice(idx, 1);
-    if (out.length >= 2 && /^---\s*$/.test(out[1])) out.splice(0, 2);
-    return out;
-  }
-  if (idx !== -1) out[idx] = `title: ${title}`;
-  else out.splice(end, 0, `title: ${title}`);
-  return out;
-}
-function setFrontmatterTitle2(lines, title) {
-  return setTitle(lines, title);
-}
-function createLineAdapter(grammar) {
-  return {
-    family: grammar.family,
-    tier: "editable",
-    parse: (source, ctx) => parseLineDocument(grammar, source, ctx),
-    serialize: (doc) => serializeLineDocument(grammar, doc),
-    apply: (doc, op) => applyLineEdit(grammar, doc, op)
-  };
-}
-function joinBraceBlocks(lines, extraBlock) {
-  const out = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    if (extraBlock && extraBlock.open.test(line)) {
-      let cur = line;
-      let j = i + 1;
-      while (j < lines.length && !extraBlock.close.test(lines[j])) {
-        cur += "\n" + lines[j];
-        j++;
-      }
-      if (j < lines.length) {
-        cur += "\n" + lines[j];
-        j++;
-      }
-      out.push(cur);
-      i = j;
-      continue;
-    }
-    const opens = (line.match(/\{/g) ?? []).length;
-    const closes = (line.match(/\}/g) ?? []).length;
-    if (opens > closes && /\{\s*$/.test(line)) {
-      let depth = opens - closes;
-      let j = i + 1;
-      const body = [];
-      let isSimpleBody = true;
-      while (j < lines.length && depth > 0) {
-        const l = lines[j];
-        depth += (l.match(/\{/g) ?? []).length - (l.match(/\}/g) ?? []).length;
-        if (depth > 0) body.push(l);
-        if (/-->|<\|--|\*--|o--|\.\.>|--\|>|\|\|--|\}o--|\}\|--|^\s*(state|class|namespace|note|direction)\b/.test(
-          l
-        ) && depth > 0)
-          isSimpleBody = false;
-        j++;
-      }
-      if (isSimpleBody && depth === 0) {
-        out.push([line, ...body, lines[j - 1]].join("\n"));
-        i = j;
-        continue;
-      }
-    }
-    out.push(line);
-    i++;
-  }
-  return out;
-}
-
-// src/diagram/passthrough.ts
-function createPassthroughAdapter(family, tier = "render-only") {
-  const adapter = {
-    family,
-    tier,
-    parse(source, ctx) {
-      const title = typeof ctx.preamble.frontmatter?.title === "string" ? ctx.preamble.frontmatter.title : void 0;
-      return {
-        family,
-        tier,
-        source,
-        preamble: ctx.preamble,
-        header: ctx.header,
-        trailing: ctx.trailing,
-        eol: ctx.eol,
-        graph: { direction: "TB", nodes: [], edges: [], groups: [], classDefs: {}, title },
-        meta: ctx.meta,
-        metaCarrier: ctx.metaCarrier,
-        body: { lines: ctx.bodyLines },
-        diagnostics: [],
-        dirty: false
-      };
-    },
-    serialize(doc) {
-      return assembleDocument(doc, doc.body.lines, "  ");
-    },
-    apply(doc, op) {
-      const next = { ...doc, meta: { ...doc.meta } };
-      switch (op.type) {
-        case "setViewport":
-          next.meta.viewport = op.viewport;
-          break;
-        case "setMetaExt":
-          next.meta.ext = { ...next.meta.ext ?? {}, [op.key]: op.value };
-          break;
-        case "moveNodes":
-          next.meta.layout = { ...next.meta.layout ?? {} };
-          for (const { id, position } of op.moves) next.meta.layout[id] = position;
-          break;
-        case "setTitle":
-          next.preamble = {
-            ...next.preamble,
-            lines: setFrontmatterTitle2(next.preamble.lines, op.title)
-          };
-          next.dirty = true;
-          break;
-        default:
-          return doc;
-      }
-      next.source = adapter.serialize(next);
-      return next;
-    }
-  };
-  return adapter;
-}
-
-// src/diagram/lines-grammar/state.ts
-var ID = String.raw`[A-Za-z0-9_À-￿.-]+`;
-var TRANSITION = new RegExp(
-  String.raw`^(\[\*\]|${ID}(?::::${ID})?)\s*-->\s*(\[\*\]|${ID}(?::::${ID})?)\s*(?::\s*(.*))?$`
-);
-var STATE_SHAPES = [
-  { name: "rect", title: "State" },
-  { name: "fork", title: "Fork" },
-  { name: "join", title: "Join" },
-  { name: "choice", title: "Choice" }
-];
-function splitClasses(token) {
-  const [id, ...classes] = token.split(":::");
-  return { id, classes };
-}
-var stateGrammar = {
-  family: "state",
-  defaultShape: "rect",
-  directionAsStatement: true,
-  defaultEdge: { arrowStart: "none", arrowEnd: "arrow_barb", pattern: "solid" },
-  joinLines(lines) {
-    return joinBraceBlocks(lines, {
-      open: /^\s*note\s+(left|right)\s+of\s+\S+\s*$/i,
-      close: /^\s*end\s+note\s*$/i
-    }).flatMap((logical) => {
-      if (/^\s*state\b.*\{\s*$/.test(logical.split("\n")[0]) && logical.includes("\n"))
-        return logical.split("\n");
-      return [logical];
-    });
-  },
-  parseLine(line) {
-    const indent = line.match(/^\s*/)[0];
-    const text = line.trim();
-    if (text === "" || text.startsWith("%%") || text.startsWith("note") || text === "--")
-      return { kind: "raw", raw: line, indent };
-    if (text === "}") return { kind: "groupClose", raw: line, indent };
-    let m;
-    if (m = /^direction\s+(TB|TD|BT|LR|RL)\s*$/i.exec(text))
-      return { kind: "direction", raw: line, indent, direction: m[1].toUpperCase() };
-    if (m = /^classDef\s+(\S+)\s+(.*)$/.exec(text))
-      return {
-        kind: "classDef",
-        raw: line,
-        indent,
-        names: m[1].split(","),
-        styles: m[2].split(",").map((s) => s.trim()).filter(Boolean)
-      };
-    if (m = /^class\s+(\S+)\s+(\S+)\s*$/.exec(text))
-      return { kind: "class", raw: line, indent, ids: m[1].split(","), className: m[2] };
-    if (m = /^style\s+(\S+)\s+(.*)$/.exec(text))
-      return {
-        kind: "style",
-        raw: line,
-        indent,
-        id: m[1],
-        styles: m[2].split(",").map((s) => s.trim()).filter(Boolean)
-      };
-    if (m = new RegExp(String.raw`^state\s+(?:"([^"]*)"\s+as\s+)?(${ID})\s*\{\s*$`).exec(text)) {
-      return { kind: "groupOpen", raw: line, indent, id: m[2], label: m[1] };
-    }
-    if (m = new RegExp(
-      String.raw`^state\s+(?:"([^"]*)"\s+as\s+)?(${ID})(?::::(${ID}))?(?:\s+<<(fork|join|choice|end)>>)?\s*$`
-    ).exec(text)) {
-      const decl = { id: m[2], label: m[1], classes: m[3] ? [m[3]] : [] };
-      if (m[4]) decl.shape = m[4] === "end" ? "stateEnd" : m[4];
-      return { kind: "node", raw: line, indent, decl };
-    }
-    if (m = TRANSITION.exec(text)) {
-      const s = splitClasses(m[1]);
-      const t = splitClasses(m[2]);
-      return {
-        kind: "edge",
-        raw: line,
-        indent,
-        source: { id: s.id, classes: s.classes },
-        target: { id: t.id, classes: t.classes },
-        label: m[3]?.trim() || void 0,
-        arrowStart: "none",
-        arrowEnd: "arrow_barb",
-        pattern: "solid"
-      };
-    }
-    if (m = new RegExp(String.raw`^(${ID})\s*:\s*(.*)$`).exec(text)) {
-      return {
-        kind: "node",
-        raw: line,
-        indent,
-        decl: { id: m[1], classes: [], data: { descriptions: [m[2].trim()] } }
-      };
-    }
-    if (m = new RegExp(String.raw`^(${ID})(?::::(${ID}))?\s*$`).exec(text)) {
-      return { kind: "node", raw: line, indent, decl: { id: m[1], classes: m[2] ? [m[2]] : [] } };
-    }
-    return { kind: "raw", raw: line, indent };
-  },
-  formatStatement(stmt) {
-    switch (stmt.kind) {
-      case "node": {
-        const d = stmt.decl;
-        const descriptions = d.data?.descriptions;
-        if (descriptions?.length && d.label === void 0 && !d.shape) {
-          return `${stmt.indent}${d.id} : ${descriptions[0]}`;
-        }
-        let out = `${stmt.indent}state `;
-        if (d.label !== void 0 && d.label !== d.id) out += `"${d.label.replace(/"/g, "'")}" as `;
-        out += d.id;
-        for (const c of d.classes) out += `:::${c}`;
-        if (d.shape && d.shape !== "rect")
-          out += ` <<${d.shape === "stateEnd" ? "end" : d.shape}>>`;
-        return out;
-      }
-      case "edge": {
-        const fmt = (n) => n.id + n.classes.map((c) => `:::${c}`).join("");
-        const src = fmt(stmt.source);
-        const tgt = fmt(stmt.target);
-        return `${stmt.indent}${src} --> ${tgt}${stmt.label ? ` : ${stmt.label}` : ""}`;
-      }
-      case "groupOpen":
-        return `${stmt.indent}state ${stmt.label !== void 0 && stmt.label !== stmt.id ? `"${stmt.label}" as ` : ""}${stmt.id} {`;
-      case "groupClose":
-        return `${stmt.indent}}`;
-      case "direction":
-        return `${stmt.indent}direction ${stmt.direction}`;
-      case "classDef":
-        return `${stmt.indent}classDef ${stmt.names.join(",")} ${stmt.styles.join(",")}`;
-      case "class":
-        return `${stmt.indent}class ${stmt.ids.join(",")} ${stmt.className}`;
-      case "style":
-        return `${stmt.indent}style ${stmt.id} ${stmt.styles.join(",")}`;
-      default:
-        return stmt.raw;
-    }
-  },
-  nodeStatement(decl, indent) {
-    return {
-      kind: "node",
-      raw: "",
-      indent,
-      decl: { ...decl, classes: [...decl.classes] },
-      dirty: true
-    };
-  },
-  edgeStatement(source, target, spec, indent) {
-    const synthetic = spec.data?.synthetic ?? {};
-    const endpoint = (id, isSynthetic) => isSynthetic ? { id: "[*]", classes: [] } : { id, classes: [] };
-    return {
-      kind: "edge",
-      raw: "",
-      indent,
-      source: endpoint(source, synthetic.source),
-      target: endpoint(target, synthetic.target),
-      label: spec.label,
-      arrowStart: "none",
-      arrowEnd: "arrow_barb",
-      pattern: "solid",
-      dirty: true
-    };
-  },
-  groupStatements(id, label, indent) {
-    return {
-      open: { kind: "groupOpen", raw: "", indent, id, label, dirty: true },
-      close: { kind: "groupClose", raw: `${indent}}`, indent }
-    };
-  },
-  headerDirection(_header, statements) {
-    const top = statements.find((s) => s.kind === "direction");
-    return top && top.kind === "direction" ? top.direction : "TB";
-  },
-  resolveEndpoint(id, stack, role) {
-    if (id !== "[*]") return null;
-    const scope = stack[stack.length - 1] ?? "root";
-    return role === "source" ? { id: `${scope}_start`, shape: "stateStart", label: "", synthetic: true } : { id: `${scope}_end`, shape: "stateEnd", label: "", synthetic: true };
-  }
-};
-
-// src/diagram/lines-grammar/class.ts
-var ID2 = String.raw`[A-Za-z0-9_À-￿.~-]+`;
-var CLASS_RELATIONS = [
-  {
-    token: "<|--",
-    arrowStart: "extension",
-    arrowEnd: "none",
-    pattern: "solid",
-    title: "Inheritance"
-  },
-  {
-    token: "--|>",
-    arrowStart: "none",
-    arrowEnd: "extension",
-    pattern: "solid",
-    title: "Inheritance (reversed)"
-  },
-  {
-    token: "<|..",
-    arrowStart: "extension",
-    arrowEnd: "none",
-    pattern: "dotted",
-    title: "Realization"
-  },
-  {
-    token: "..|>",
-    arrowStart: "none",
-    arrowEnd: "extension",
-    pattern: "dotted",
-    title: "Realization (reversed)"
-  },
-  {
-    token: "*--",
-    arrowStart: "composition",
-    arrowEnd: "none",
-    pattern: "solid",
-    title: "Composition"
-  },
-  {
-    token: "--*",
-    arrowStart: "none",
-    arrowEnd: "composition",
-    pattern: "solid",
-    title: "Composition (reversed)"
-  },
-  {
-    token: "o--",
-    arrowStart: "aggregation",
-    arrowEnd: "none",
-    pattern: "solid",
-    title: "Aggregation"
-  },
-  {
-    token: "--o",
-    arrowStart: "none",
-    arrowEnd: "aggregation",
-    pattern: "solid",
-    title: "Aggregation (reversed)"
-  },
-  {
-    token: "<--",
-    arrowStart: "dependency",
-    arrowEnd: "none",
-    pattern: "solid",
-    title: "Association (reversed)"
-  },
-  {
-    token: "-->",
-    arrowStart: "none",
-    arrowEnd: "dependency",
-    pattern: "solid",
-    title: "Association"
-  },
-  {
-    token: "<..",
-    arrowStart: "dependency",
-    arrowEnd: "none",
-    pattern: "dotted",
-    title: "Dependency (reversed)"
-  },
-  {
-    token: "..>",
-    arrowStart: "none",
-    arrowEnd: "dependency",
-    pattern: "dotted",
-    title: "Dependency"
-  },
-  { token: "()--", arrowStart: "lollipop", arrowEnd: "none", pattern: "solid", title: "Lollipop" },
-  {
-    token: "--()",
-    arrowStart: "none",
-    arrowEnd: "lollipop",
-    pattern: "solid",
-    title: "Lollipop (reversed)"
-  },
-  { token: "--", arrowStart: "none", arrowEnd: "none", pattern: "solid", title: "Link (solid)" },
-  { token: "..", arrowStart: "none", arrowEnd: "none", pattern: "dotted", title: "Link (dashed)" }
-];
-var REL_TOKENS = CLASS_RELATIONS.map((r) => r.token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(
-  "|"
-);
-var RELATION = new RegExp(
-  String.raw`^(${ID2})(?:\["([^"]*)"\])?(?::::(${ID2}))?\s*(?:"([^"]*)"\s*)?(${REL_TOKENS})\s*(?:"([^"]*)"\s*)?(${ID2})(?:\["([^"]*)"\])?(?::::(${ID2}))?\s*(?::\s*(.*))?$`
-);
-function relationFor(arrowStart, arrowEnd, pattern) {
-  return CLASS_RELATIONS.find(
-    (r) => r.arrowStart === arrowStart && r.arrowEnd === arrowEnd && r.pattern === pattern
-  ) ?? CLASS_RELATIONS.find((r) => r.token === "-->");
-}
-function parseMembers(bodyLines) {
-  const out = [];
-  for (const line of bodyLines) {
-    const t = line.trim();
-    if (!t || t === "}" || t.startsWith("%%") || /^<<.*>>$/.test(t)) continue;
-    const vis = /^[+\-#~]/.exec(t)?.[0];
-    out.push({ raw: t, visibility: vis, kind: /\(.*\)/.test(t) ? "method" : "attribute" });
-  }
-  return out;
-}
-function annotationsOf(bodyLines) {
-  return bodyLines.map((l) => l.trim()).filter((t) => /^<<.*>>$/.test(t)).map((t) => t.slice(2, -2));
-}
-var classGrammar = {
-  family: "class",
-  defaultShape: "classBox",
-  directionAsStatement: true,
-  defaultEdge: { arrowStart: "none", arrowEnd: "dependency", pattern: "solid" },
-  joinLines(lines) {
-    return joinBraceBlocks(lines, { open: /^\s*note\s+(for\s+\S+\s+)?"[^"]*$/i, close: /"\s*$/ });
-  },
-  parseLine(logical) {
-    const [line, ...bodyRest] = logical.split("\n");
-    const indent = line.match(/^\s*/)[0];
-    const text = line.trim();
-    if (text === "" || text.startsWith("%%") || /^(note|click|link|callback|<<)/.test(text))
-      return { kind: "raw", raw: logical, indent };
-    if (text === "}") return { kind: "groupClose", raw: line, indent };
-    let m;
-    if (m = /^direction\s+(TB|TD|BT|LR|RL)\s*$/i.exec(text))
-      return { kind: "direction", raw: line, indent, direction: m[1].toUpperCase() };
-    if (m = /^classDef\s+(\S+)\s+(.*)$/.exec(text))
-      return {
-        kind: "classDef",
-        raw: line,
-        indent,
-        names: m[1].split(","),
-        styles: m[2].split(",").map((s) => s.trim()).filter(Boolean)
-      };
-    if (m = /^cssClass\s+"([^"]+)"\s+(\S+)\s*$/.exec(text))
-      return {
-        kind: "class",
-        raw: line,
-        indent,
-        ids: m[1].split(",").map((s) => s.trim()),
-        className: m[2]
-      };
-    if (m = /^style\s+(\S+)\s+(.*)$/.exec(text))
-      return {
-        kind: "style",
-        raw: line,
-        indent,
-        id: m[1],
-        styles: m[2].split(",").map((s) => s.trim()).filter(Boolean)
-      };
-    if (m = new RegExp(String.raw`^namespace\s+(${ID2})\s*\{\s*$`).exec(text))
-      return { kind: "groupOpen", raw: line, indent, id: m[1] };
-    if (m = new RegExp(
-      String.raw`^class\s+(${ID2})(?:\["([^"]*)"\])?(?::::(${ID2}))?\s*(\{)?\s*$`
-    ).exec(text)) {
-      const decl = { id: m[1], label: m[2], classes: m[3] ? [m[3]] : [] };
-      if (m[4] && bodyRest.length) {
-        decl.data = { members: parseMembers(bodyRest), annotations: annotationsOf(bodyRest) };
-        return { kind: "node", raw: line, indent, decl, body: bodyRest };
-      }
-      if (m[4] && !bodyRest.length) {
-        return { kind: "raw", raw: line, indent };
-      }
-      return { kind: "node", raw: line, indent, decl };
-    }
-    if (m = RELATION.exec(text)) {
-      const rel = CLASS_RELATIONS.find((r) => r.token === m[5]);
-      return {
-        kind: "edge",
-        raw: line,
-        indent,
-        source: { id: m[1], label: m[2], classes: m[3] ? [m[3]] : [] },
-        target: { id: m[7], label: m[8], classes: m[9] ? [m[9]] : [] },
-        label: m[10]?.trim() || void 0,
-        arrowStart: rel.arrowStart,
-        arrowEnd: rel.arrowEnd,
-        pattern: rel.pattern,
-        data: { cardinalityStart: m[4], cardinalityEnd: m[6] }
-      };
-    }
-    if (m = new RegExp(String.raw`^(${ID2})\s*:\s*(.+)$`).exec(text)) {
-      return {
-        kind: "node",
-        raw: line,
-        indent,
-        decl: { id: m[1], classes: [], data: { members: parseMembers([m[2]]) } }
-      };
-    }
-    return { kind: "raw", raw: logical, indent };
-  },
-  formatStatement(stmt) {
-    switch (stmt.kind) {
-      case "node": {
-        const d = stmt.decl;
-        const members = d.data?.members;
-        if (!stmt.body && members?.length === 1 && d.label === void 0 && !d.classes.length && stmt.raw.includes(" : ")) {
-          return `${stmt.indent}${d.id} : ${members[0].raw}`;
-        }
-        let out = `${stmt.indent}class ${d.id}`;
-        if (d.label !== void 0 && d.label !== d.id) out += `["${d.label.replace(/"/g, "'")}"]`;
-        for (const c of d.classes) out += `:::${c}`;
-        if (stmt.body) out += " {";
-        return out;
-      }
-      case "edge": {
-        const rel = relationFor(stmt.arrowStart, stmt.arrowEnd, stmt.pattern);
-        const cs = stmt.data?.cardinalityStart;
-        const ce = stmt.data?.cardinalityEnd;
-        const fmt = (n) => n.id + (n.label !== void 0 ? `["${n.label}"]` : "") + n.classes.map((c) => `:::${c}`).join("");
-        return `${stmt.indent}${fmt(stmt.source)} ${cs ? `"${cs}" ` : ""}${rel.token} ${ce ? `"${ce}" ` : ""}${fmt(stmt.target)}${stmt.label ? ` : ${stmt.label}` : ""}`;
-      }
-      case "groupOpen":
-        return `${stmt.indent}namespace ${stmt.id} {`;
-      case "groupClose":
-        return `${stmt.indent}}`;
-      case "direction":
-        return `${stmt.indent}direction ${stmt.direction}`;
-      case "classDef":
-        return `${stmt.indent}classDef ${stmt.names.join(",")} ${stmt.styles.join(",")}`;
-      case "class":
-        return `${stmt.indent}cssClass "${stmt.ids.join(",")}" ${stmt.className}`;
-      case "style":
-        return `${stmt.indent}style ${stmt.id} ${stmt.styles.join(",")}`;
-      default:
-        return stmt.raw;
-    }
-  },
-  nodeStatement(decl, indent) {
-    const members = decl.data?.members;
-    const body = members?.length ? [...members.map((m) => `${indent}  ${m.raw}`), `${indent}}`] : void 0;
-    return {
-      kind: "node",
-      raw: "",
-      indent,
-      decl: { ...decl, classes: [...decl.classes] },
-      body,
-      dirty: true
-    };
-  },
-  edgeStatement(source, target, spec, indent) {
-    return {
-      kind: "edge",
-      raw: "",
-      indent,
-      source: { id: source, classes: [] },
-      target: { id: target, classes: [] },
-      label: spec.label,
-      arrowStart: spec.arrowStart,
-      arrowEnd: spec.arrowEnd,
-      pattern: spec.pattern,
-      data: spec.data,
-      dirty: true
-    };
-  },
-  groupStatements(id, _label, indent) {
-    return {
-      open: { kind: "groupOpen", raw: "", indent, id, dirty: true },
-      close: { kind: "groupClose", raw: `${indent}}`, indent }
-    };
-  },
-  headerDirection(_header, statements) {
-    const top = statements.find((s) => s.kind === "direction");
-    return top && top.kind === "direction" ? top.direction : "TB";
-  }
-};
-
-// src/diagram/lines-grammar/er.ts
-var ID3 = String.raw`[A-Za-z0-9_À-￿-]+|"[^"]+"`;
-var ER_CARDINALITIES = [
-  { token: "|o", head: "zero_or_one", side: "left", title: "Zero or one" },
-  { token: "||", head: "only_one", side: "left", title: "Exactly one" },
-  { token: "}o", head: "zero_or_more", side: "left", title: "Zero or more" },
-  { token: "}|", head: "one_or_more", side: "left", title: "One or more" },
-  { token: "o|", head: "zero_or_one", side: "right", title: "Zero or one" },
-  { token: "||", head: "only_one", side: "right", title: "Exactly one" },
-  { token: "o{", head: "zero_or_more", side: "right", title: "Zero or more" },
-  { token: "|{", head: "one_or_more", side: "right", title: "One or more" }
-];
-var LEFT = {
-  "|o": "zero_or_one",
-  "||": "only_one",
-  "}o": "zero_or_more",
-  "}|": "one_or_more"
-};
-var RIGHT = {
-  "o|": "zero_or_one",
-  "||": "only_one",
-  "o{": "zero_or_more",
-  "|{": "one_or_more"
-};
-var LEFT_TOKEN = {
-  zero_or_one: "|o",
-  only_one: "||",
-  zero_or_more: "}o",
-  one_or_more: "}|"
-};
-var RIGHT_TOKEN = {
-  zero_or_one: "o|",
-  only_one: "||",
-  zero_or_more: "o{",
-  one_or_more: "|{"
-};
-var RELATION2 = new RegExp(
-  String.raw`^(${ID3})(?:\[([^\]]*)\])?(?::::([\w-]+))?\s+(\|o|\|\||\}o|\}\|)(--|\.\.|\.-|-\.)(o\||\|\||o\{|\|\{)\s+(${ID3})(?:\[([^\]]*)\])?(?::::([\w-]+))?\s*:\s*(.*)$`
-);
-function parseAttributes(bodyLines) {
-  const out = [];
-  for (const line of bodyLines) {
-    const t = line.trim();
-    if (!t || t === "}" || t.startsWith("%%")) continue;
-    const m = /^(\S+)\s+(\S+)((?:\s+(?:PK|FK|UK)(?:\s*,\s*(?:PK|FK|UK))*)?)\s*(?:"([^"]*)")?\s*$/.exec(t);
-    if (m) {
-      out.push({
-        raw: t,
-        type: m[1],
-        name: m[2],
-        keys: (m[3] ?? "").split(/[\s,]+/).filter(Boolean),
-        comment: m[4]
-      });
-    } else {
-      out.push({ raw: t, type: "", name: t, keys: [] });
-    }
-  }
-  return out;
-}
-function unq(id) {
-  return id.startsWith('"') && id.endsWith('"') ? id.slice(1, -1) : id;
-}
-function fmtId(id) {
-  return /[\s]/.test(id) ? `"${id}"` : id;
-}
-var erGrammar = {
-  family: "er",
-  defaultShape: "erBox",
-  directionAsStatement: true,
-  supportsGroups: false,
-  defaultEdge: { arrowStart: "only_one", arrowEnd: "zero_or_more", pattern: "solid", label: "has" },
-  joinLines(lines) {
-    return joinBraceBlocks(lines);
-  },
-  parseLine(logical) {
-    const [line, ...bodyRest] = logical.split("\n");
-    const indent = line.match(/^\s*/)[0];
-    const text = line.trim();
-    if (text === "" || text.startsWith("%%")) return { kind: "raw", raw: logical, indent };
-    let m;
-    if (m = /^direction\s+(TB|TD|BT|LR|RL)\s*$/i.exec(text))
-      return { kind: "direction", raw: line, indent, direction: m[1].toUpperCase() };
-    if (m = /^classDef\s+(\S+)\s+(.*)$/.exec(text))
-      return {
-        kind: "classDef",
-        raw: line,
-        indent,
-        names: m[1].split(","),
-        styles: m[2].split(",").map((s) => s.trim()).filter(Boolean)
-      };
-    if (m = /^class\s+(\S+)\s+(\S+)\s*$/.exec(text))
-      return { kind: "class", raw: line, indent, ids: m[1].split(","), className: m[2] };
-    if (m = /^style\s+(\S+)\s+(.*)$/.exec(text))
-      return {
-        kind: "style",
-        raw: line,
-        indent,
-        id: m[1],
-        styles: m[2].split(",").map((s) => s.trim()).filter(Boolean)
-      };
-    if (m = RELATION2.exec(text)) {
-      const line_ = m[5];
-      return {
-        kind: "edge",
-        raw: line,
-        indent,
-        source: { id: unq(m[1]), label: m[2], classes: m[3] ? [m[3]] : [] },
-        target: { id: unq(m[7]), label: m[8], classes: m[9] ? [m[9]] : [] },
-        label: unq(m[10].trim()),
-        arrowStart: LEFT[m[4]],
-        arrowEnd: RIGHT[m[6]],
-        pattern: line_ === "--" ? "solid" : "dotted",
-        data: { identifying: line_ === "--" }
-      };
-    }
-    if (m = new RegExp(String.raw`^(${ID3})(?:\[([^\]]*)\])?(?::::([\w-]+))?\s*(\{)?\s*$`).exec(text)) {
-      const decl = {
-        id: unq(m[1]),
-        label: m[2] !== void 0 ? unq(m[2]) : void 0,
-        classes: m[3] ? [m[3]] : []
-      };
-      if (m[4]) {
-        decl.data = { attributes: parseAttributes(bodyRest) };
-        return { kind: "node", raw: line, indent, decl, body: bodyRest };
-      }
-      return { kind: "node", raw: line, indent, decl };
-    }
-    return { kind: "raw", raw: logical, indent };
-  },
-  formatStatement(stmt) {
-    switch (stmt.kind) {
-      case "node": {
-        const d = stmt.decl;
-        let out = `${stmt.indent}${fmtId(d.id)}`;
-        if (d.label !== void 0 && d.label !== d.id) out += `["${d.label}"]`;
-        for (const c of d.classes) out += `:::${c}`;
-        if (stmt.body) out += " {";
-        return out;
-      }
-      case "edge": {
-        const fmt = (n) => fmtId(n.id) + (n.label !== void 0 ? `["${n.label}"]` : "") + n.classes.map((c) => `:::${c}`).join("");
-        const l = LEFT_TOKEN[stmt.arrowStart] ?? "||";
-        const r = RIGHT_TOKEN[stmt.arrowEnd] ?? "o{";
-        const mid = stmt.pattern === "dotted" ? ".." : "--";
-        const label = stmt.label ?? "";
-        return `${stmt.indent}${fmt(stmt.source)} ${l}${mid}${r} ${fmt(stmt.target)} : ${/\s/.test(label) ? `"${label}"` : label || '""'}`;
-      }
-      case "direction":
-        return `${stmt.indent}direction ${stmt.direction}`;
-      case "classDef":
-        return `${stmt.indent}classDef ${stmt.names.join(",")} ${stmt.styles.join(",")}`;
-      case "class":
-        return `${stmt.indent}class ${stmt.ids.join(",")} ${stmt.className}`;
-      case "style":
-        return `${stmt.indent}style ${stmt.id} ${stmt.styles.join(",")}`;
-      default:
-        return stmt.raw;
-    }
-  },
-  nodeStatement(decl, indent) {
-    const attrs = decl.data?.attributes;
-    const body = attrs?.length ? [...attrs.map((a) => `${indent}  ${a.raw}`), `${indent}}`] : void 0;
-    return {
-      kind: "node",
-      raw: "",
-      indent,
-      decl: { ...decl, classes: [...decl.classes] },
-      body,
-      dirty: true
-    };
-  },
-  edgeStatement(source, target, spec, indent) {
-    return {
-      kind: "edge",
-      raw: "",
-      indent,
-      source: { id: source, classes: [] },
-      target: { id: target, classes: [] },
-      label: spec.label ?? "has",
-      arrowStart: spec.arrowStart,
-      arrowEnd: spec.arrowEnd,
-      pattern: spec.pattern,
-      data: spec.data,
-      dirty: true
-    };
-  },
-  groupStatements(id, _label, indent) {
-    return {
-      open: { kind: "raw", raw: `${indent}%% group ${id}`, indent },
-      close: { kind: "raw", raw: `${indent}%% end group ${id}`, indent }
-    };
-  },
-  headerDirection(_header, statements) {
-    const top = statements.find((s) => s.kind === "direction");
-    return top && top.kind === "direction" ? top.direction : "TB";
-  }
-};
-var ER_PATTERNS = [
-  { pattern: "solid", title: "Identifying" },
-  { pattern: "dotted", title: "Non-identifying" }
-];
-
-// src/diagram/registry.ts
-var adapters = /* @__PURE__ */ new Map();
-function registerDiagramAdapter(adapter) {
-  adapters.set(adapter.family, adapter);
-}
-function getDiagramAdapter(family) {
-  return adapters.get(family) ?? adapters.get("unknown");
-}
-function supportTierOf(family) {
-  return getDiagramAdapter(family).tier;
-}
-registerDiagramAdapter(flowchartAdapter);
-registerDiagramAdapter(createLineAdapter(stateGrammar));
-registerDiagramAdapter(createLineAdapter(classGrammar));
-registerDiagramAdapter(createLineAdapter(erGrammar));
-for (const family of [
-  "requirement",
-  "mindmap",
-  "sequence",
-  "gantt",
-  "pie",
-  "journey",
-  "timeline",
-  "gitGraph",
-  "c4",
-  "quadrant",
-  "sankey",
-  "xychart",
-  "block",
-  "architecture",
-  "packet",
-  "kanban",
-  "radar",
-  "treemap",
-  "info",
-  "unknown"
-]) {
-  registerDiagramAdapter(createPassthroughAdapter(family));
-}
-
-// src/diagram/document.ts
-function detectFamily(source) {
-  return detectFamilyFromHeader(splitSource(source).header);
-}
-function parseMermaid(source, options = {}) {
-  const split = splitSource(source);
-  const family = detectFamilyFromHeader(split.header);
-  const fromBody = extractMetaFromBody(split.bodyLines);
-  const fromFm = extractMetaFromFrontmatter(split.preamble);
-  let meta = emptyMeta();
-  if (fromFm) meta = mergeMeta(meta, fromFm);
-  if (fromBody.meta) meta = mergeMeta(meta, fromBody.meta);
-  const metaCarrier = options.metaCarrier ?? (fromFm && !fromBody.meta ? "frontmatter" : defaultCarrierFor(family));
-  const adapter = getDiagramAdapter(family);
-  const doc = adapter.parse(source, {
-    source,
-    eol: split.eol,
-    preamble: split.preamble,
-    header: split.header,
-    bodyLines: fromBody.bodyLines,
-    trailing: split.trailing,
-    meta,
-    metaCarrier,
-    family
-  });
-  return doc;
-}
-function serializeMermaid(doc) {
-  return getDiagramAdapter(doc.family).serialize(doc);
-}
-function applyEdit(doc, op) {
-  if (op.type === "replaceSource") {
-    const next2 = parseMermaid(op.source, { metaCarrier: doc.metaCarrier });
-    next2.dirty = true;
-    return next2;
-  }
-  const next = getDiagramAdapter(doc.family).apply(doc, op);
-  if (next !== doc && next.source === doc.source) {
-    next.source = serializeMermaid(next);
-  }
-  return next;
-}
-function applyEdits(doc, ops) {
-  return ops.reduce((d, op) => applyEdit(d, op), doc);
-}
-
-export {
-  detectFamilyFromHeader,
-  splitSource,
-  splitStatements,
-  META_COMMENT_PREFIX,
-  META_FRONTMATTER_KEY,
-  emptyMeta,
-  mergeMeta,
-  isMetaEmpty,
-  serializeMeta,
-  parseLink,
-  quoteLabelIfNeeded,
-  formatLink,
-  FLOWCHART_SHAPES,
-  resolveShape,
-  canonicalShape,
-  parseChain,
-  parseStatement,
-  formatNode,
-  formatChain,
-  parseFlowchartSource,
-  flowchartAdapter,
-  createLineAdapter,
-  createPassthroughAdapter,
-  STATE_SHAPES,
-  stateGrammar,
-  CLASS_RELATIONS,
-  relationFor,
-  parseMembers,
-  classGrammar,
-  ER_CARDINALITIES,
-  parseAttributes,
-  erGrammar,
-  ER_PATTERNS,
-  registerDiagramAdapter,
-  getDiagramAdapter,
-  supportTierOf,
-  detectFamily,
-  parseMermaid,
-  serializeMermaid,
-  applyEdit,
-  applyEdits
-};
-//# sourceMappingURL=chunk-WWJNC7SX.js.map