@draftably/mermaid 0.2.1 → 0.2.2

package/dist/chunks/mermaid-importer-BHKoojYC.js

@@ -0,0 +1,4132 @@
+import { MERMAID_VERSION as cn } from "./mermaid-facade-BoLWBerE.js";
+const _o = {
+  "sans-500": { unitsPerEm: 1e3, fallback: 1003, advances: { 0: 646, 1: 415, 2: 616, 3: 627, 4: 656, 5: 603, 6: 630, 7: 571, 8: 629, 9: 630, " ": 267, "!": 304, '"': 494, "#": 639, $: 646, "%": 993, "&": 653, "'": 313, "(": 369, ")": 369, "*": 521, "+": 667, ",": 303, "-": 462, ".": 303, "/": 370, ":": 303, ";": 315, "<": 667, "=": 667, ">": 667, "?": 527, "@": 982, A: 709, B: 657, C: 733, D: 722, E: 603, F: 589, G: 748, H: 745, I: 272, J: 575, K: 688, L: 565, M: 913, N: 756, O: 767, P: 642, Q: 769, R: 648, S: 646, T: 653, U: 740, V: 709, W: 1003, X: 701, Y: 696, Z: 641, "[": 369, "\\": 370, "]": 369, "^": 477, _: 463, "`": 337, a: 568, b: 618, c: 577, d: 618, e: 587, f: 379, g: 620, h: 602, i: 252, j: 252, k: 559, l: 252, m: 888, n: 602, o: 604, p: 618, q: 618, r: 387, s: 539, t: 340, u: 602, v: 575, w: 829, x: 557, y: 575, z: 559, "{": 440, "|": 346, "}": 440, "~": 667, " ": 267, "¡": 304, "¢": 577, "£": 620, "¤": 737, "¥": 557, "¦": 293, "§": 568, "¨": 602, "©": 914, ª: 457, "«": 608, "¬": 667, "­": 0, "®": 665, "¯": 465, "°": 457, "±": 667, "²": 448, "³": 455, "´": 337, µ: 600, "¶": 601, "·": 303, "¸": 300, "¹": 314, º: 485, "»": 608, "¼": 817, "½": 858, "¾": 895, "¿": 527, À: 709, Á: 709, Â: 709, Ã: 709, Ä: 709, Å: 709, Æ: 1003, Ç: 733, È: 603, É: 603, Ê: 603, Ë: 603, Ì: 272, Í: 272, Î: 272, Ï: 272, Ð: 743, Ñ: 756, Ò: 767, Ó: 767, Ô: 767, Õ: 767, Ö: 767, "×": 667, Ø: 767, Ù: 740, Ú: 740, Û: 740, Ü: 740, Ý: 696, Þ: 647, ß: 630, à: 568, á: 568, â: 568, ã: 568, ä: 568, å: 568, æ: 915, ç: 577, è: 587, é: 587, ê: 587, ë: 587, ì: 252, í: 252, î: 252, ï: 252, ð: 588, ñ: 602, ò: 604, ó: 604, ô: 604, õ: 604, ö: 604, "÷": 667, ø: 604, ù: 602, ú: 602, û: 602, ü: 602, ý: 575, þ: 618, ÿ: 575, "‘": 277, "’": 277, "“": 474, "”": 471, "–": 500, "—": 1e3, "…": 910, "•": 533, "→": 1e3, "←": 1e3, "≤": 549, "≥": 549, "≠": 549, "€": 672 } },
+  "sans-600": { unitsPerEm: 1e3, fallback: 1020, advances: { 0: 660, 1: 423, 2: 623, 3: 636, 4: 666, 5: 612, 6: 640, 7: 576, 8: 640, 9: 640, " ": 252, "!": 321, '"': 523, "#": 644, $: 650, "%": 1004, "&": 663, "'": 326, "(": 373, ")": 373, "*": 540, "+": 673, ",": 319, "-": 465, ".": 319, "/": 379, ":": 319, ";": 329, "<": 673, "=": 673, ">": 673, "?": 543, "@": 999, A: 728, B: 659, C: 737, D: 722, E: 605, F: 588, G: 749, H: 746, I: 277, J: 580, K: 703, L: 565, M: 922, N: 759, O: 769, P: 645, Q: 773, R: 652, S: 650, T: 660, U: 736, V: 728, W: 1020, X: 720, Y: 713, Z: 652, "[": 373, "\\": 379, "]": 373, "^": 481, _: 469, "`": 351, a: 574, b: 624, c: 583, d: 624, e: 591, f: 389, g: 625, h: 612, i: 262, j: 262, k: 569, l: 262, m: 900, n: 612, o: 609, p: 624, q: 624, r: 397, s: 549, t: 353, u: 612, v: 587, w: 839, x: 569, y: 588, z: 566, "{": 455, "|": 359, "}": 455, "~": 673, " ": 252, "¡": 321, "¢": 583, "£": 629, "¤": 749, "¥": 563, "¦": 316, "§": 568, "¨": 612, "©": 914, ª: 460, "«": 634, "¬": 673, "­": 0, "®": 664, "¯": 452, "°": 458, "±": 673, "²": 454, "³": 463, "´": 351, µ: 614, "¶": 600, "·": 319, "¸": 332, "¹": 324, º: 487, "»": 634, "¼": 831, "½": 870, "¾": 907, "¿": 543, À: 728, Á: 728, Â: 728, Ã: 728, Ä: 728, Å: 728, Æ: 1013, Ç: 737, È: 605, É: 605, Ê: 605, Ë: 605, Ì: 277, Í: 277, Î: 277, Ï: 277, Ð: 751, Ñ: 759, Ò: 769, Ó: 769, Ô: 769, Õ: 769, Ö: 769, "×": 673, Ø: 769, Ù: 736, Ú: 736, Û: 736, Ü: 736, Ý: 713, Þ: 658, ß: 644, à: 574, á: 574, â: 574, ã: 574, ä: 574, å: 574, æ: 913, ç: 583, è: 591, é: 591, ê: 591, ë: 591, ì: 262, í: 262, î: 262, ï: 262, ð: 594, ñ: 612, ò: 609, ó: 609, ô: 609, õ: 609, ö: 609, "÷": 673, ø: 609, ù: 612, ú: 612, û: 612, ü: 612, ý: 588, þ: 624, ÿ: 588, "‘": 294, "’": 294, "“": 507, "”": 501, "–": 500, "—": 1e3, "…": 956, "•": 503, "→": 1e3, "←": 1e3, "≤": 549, "≥": 549, "≠": 549, "€": 679 } },
+  "serif-600": { unitsPerEm: 1e3, fallback: 1020, advances: { 0: 547, 1: 547, 2: 547, 3: 547, 4: 547, 5: 547, 6: 547, 7: 547, 8: 547, 9: 547, " ": 228, "!": 314, '"': 423, "#": 544, $: 538, "%": 949, "&": 739, "'": 206, "(": 384, ")": 384, "*": 458, "+": 548, ",": 307, "-": 335, ".": 307, "/": 364, ":": 307, ";": 307, "<": 548, "=": 548, ">": 548, "?": 430, "@": 867, A: 712, B: 668, C: 663, D: 744, E: 634, F: 610, G: 725, H: 809, I: 387, J: 394, K: 726, L: 616, M: 930, N: 757, O: 742, P: 637, Q: 742, R: 707, S: 560, T: 650, U: 757, V: 706, W: 1020, X: 678, Y: 667, Z: 592, "[": 356, "\\": 364, "]": 356, "^": 548, _: 528, "`": 400, a: 554, b: 630, c: 527, d: 623, e: 540, f: 374, g: 573, h: 650, i: 336, j: 313, k: 615, l: 337, m: 961, n: 652, o: 590, p: 632, q: 613, r: 475, s: 475, t: 368, u: 640, v: 581, w: 850, x: 585, y: 592, z: 497, "{": 365, "|": 301, "}": 365, "~": 548, " ": 228, "¡": 314, "¢": 538, "£": 539, "¤": 520, "¥": 538, "¦": 301, "§": 514, "¨": 400, "©": 750, ª: 385, "«": 572, "¬": 548, "­": 0, "®": 465, "¯": 400, "°": 344, "±": 548, "²": 390, "³": 390, "´": 400, µ: 626, "¶": 622, "·": 307, "¸": 400, "¹": 390, º: 409, "»": 572, "¼": 918, "½": 949, "¾": 918, "¿": 430, À: 712, Á: 712, Â: 712, Ã: 712, Ä: 712, Å: 712, Æ: 943, Ç: 663, È: 634, É: 634, Ê: 634, Ë: 634, Ì: 387, Í: 387, Î: 387, Ï: 387, Ð: 744, Ñ: 757, Ò: 742, Ó: 742, Ô: 742, Õ: 742, Ö: 742, "×": 548, Ø: 742, Ù: 757, Ú: 757, Û: 757, Ü: 757, Ý: 667, Þ: 638, ß: 656, à: 554, á: 554, â: 554, ã: 554, ä: 554, å: 554, æ: 831, ç: 527, è: 540, é: 540, ê: 540, ë: 540, ì: 336, í: 336, î: 336, ï: 336, ð: 577, ñ: 652, ò: 590, ó: 590, ô: 590, õ: 590, ö: 590, "÷": 548, ø: 590, ù: 640, ú: 640, û: 640, ü: 640, ý: 592, þ: 622, ÿ: 592, "‘": 236, "’": 236, "“": 460, "”": 459, "–": 528, "—": 828, "…": 853, "•": 320, "→": 1e3, "←": 1e3, "≤": 549, "≥": 549, "≠": 549, "€": 538 } },
+  "mono-500": { unitsPerEm: 1e3, fallback: 600, advances: { 0: 600, 1: 600, 2: 600, 3: 600, 4: 600, 5: 600, 6: 600, 7: 600, 8: 600, 9: 600, " ": 600, "!": 600, '"': 600, "#": 600, $: 600, "%": 600, "&": 600, "'": 600, "(": 600, ")": 600, "*": 600, "+": 600, ",": 600, "-": 600, ".": 600, "/": 600, ":": 600, ";": 600, "<": 600, "=": 600, ">": 600, "?": 600, "@": 600, A: 600, B: 600, C: 600, D: 600, E: 600, F: 600, G: 600, H: 600, I: 600, J: 600, K: 600, L: 600, M: 600, N: 600, O: 600, P: 600, Q: 600, R: 600, S: 600, T: 600, U: 600, V: 600, W: 600, X: 600, Y: 600, Z: 600, "[": 600, "\\": 600, "]": 600, "^": 600, _: 600, "`": 600, a: 600, b: 600, c: 600, d: 600, e: 600, f: 600, g: 600, h: 600, i: 600, j: 600, k: 600, l: 600, m: 600, n: 600, o: 600, p: 600, q: 600, r: 600, s: 600, t: 600, u: 600, v: 600, w: 600, x: 600, y: 600, z: 600, "{": 600, "|": 600, "}": 600, "~": 600, " ": 600, "¡": 600, "¢": 600, "£": 600, "¤": 600, "¥": 600, "¦": 600, "§": 600, "¨": 600, "©": 600, ª: 600, "«": 600, "¬": 600, "­": 0, "®": 600, "¯": 600, "°": 600, "±": 600, "²": 600, "³": 600, "´": 600, µ: 600, "¶": 600, "·": 600, "¸": 600, "¹": 600, º: 600, "»": 600, "¼": 600, "½": 600, "¾": 600, "¿": 600, À: 600, Á: 600, Â: 600, Ã: 600, Ä: 600, Å: 600, Æ: 600, Ç: 600, È: 600, É: 600, Ê: 600, Ë: 600, Ì: 600, Í: 600, Î: 600, Ï: 600, Ð: 600, Ñ: 600, Ò: 600, Ó: 600, Ô: 600, Õ: 600, Ö: 600, "×": 600, Ø: 600, Ù: 600, Ú: 600, Û: 600, Ü: 600, Ý: 600, Þ: 600, ß: 600, à: 600, á: 600, â: 600, ã: 600, ä: 600, å: 600, æ: 600, ç: 600, è: 600, é: 600, ê: 600, ë: 600, ì: 600, í: 600, î: 600, ï: 600, ð: 600, ñ: 600, ò: 600, ó: 600, ô: 600, õ: 600, ö: 600, "÷": 600, ø: 600, ù: 600, ú: 600, û: 600, ü: 600, ý: 600, þ: 600, ÿ: 600, "‘": 600, "’": 600, "“": 600, "”": 600, "–": 600, "—": 600, "…": 600, "•": 600, "→": 602, "←": 602, "≤": 549, "≥": 549, "≠": 549, "€": 600 } }
+}, Mt = "269b2d3580f4", Qn = {
+  "sans-500": {
+    family: `Draft Inter ${Mt}`,
+    weight: 500,
+    file: "inter-latin-500-normal.woff2"
+  },
+  "sans-600": {
+    family: `Draft Inter ${Mt}`,
+    weight: 600,
+    file: "inter-latin-600-normal.woff2"
+  },
+  "serif-600": {
+    family: `Draft Source Serif ${Mt}`,
+    weight: 600,
+    file: "source-serif-4-latin-600-normal.woff2"
+  },
+  "mono-500": {
+    family: `Draft JetBrains Mono ${Mt}`,
+    weight: 500,
+    file: "jetbrains-mono-latin-500-normal.woff2"
+  }
+}, Io = ["sans", "serif", "mono"], To = {
+  sans: "Inter, Arial, sans-serif",
+  serif: "'Source Serif 4', Georgia, serif",
+  mono: "'JetBrains Mono', Menlo, Consolas, monospace"
+}, Vn = (e, t) => e === "serif" ? "serif-600" : e === "mono" ? "mono-500" : t ? "sans-600" : "sans-500", Ro = (e) => `'${Qn[Vn(e, !0)].family}', ${To[e]}`;
+function ct(e, t, s, n) {
+  const o = Vn(e, t);
+  return { role: e, face: o, family: Ro(e), weight: Qn[o].weight, size: s, lineHeight: n };
+}
+const Lo = _o;
+function ye(e, t) {
+  const s = Lo[t.face];
+  let n = 0;
+  for (const o of e) n += s.advances[o] ?? s.fallback;
+  return n * t.size / s.unitsPerEm;
+}
+function Zn(e) {
+  const t = [];
+  let s = "";
+  for (const n of e.split(/(?<=[/._:-])(?=[^/._:-])|(?<=[a-z0-9])(?=[A-Z])/))
+    /[\p{L}\p{N}]/u.test(n) ? (t.push(s + n), s = "") : s += n;
+  return s && t.length ? t[t.length - 1] += s : s && t.push(s), t.length > 1 && t[t.length - 1].length <= 3 && t.splice(-2, 2, t[t.length - 2] + t[t.length - 1]), t;
+}
+function qt(e, t) {
+  return Math.max(
+    0,
+    ...String(e).split(/\s+/).flatMap(Zn).map((s) => ye(s, t))
+  );
+}
+function Oo(e, t, s) {
+  const n = [];
+  let o = "";
+  for (const r of e.split(/\s+/)) {
+    if (!r) continue;
+    const d = n[n.length - 1];
+    !o && d !== void 0 && /\d$/.test(d) && /^(%|[\p{L}µ]{1,3}[.,;:)]?)$/u.test(r) && ye(d + " " + r, s) <= t ? n[n.length - 1] = d + " " + r : o && ye(o + " " + r, s) <= t ? (n.push(o + " " + r), o = "") : (o && n.push(o), o = "", !/[\p{L}\p{N}]/u.test(r) && r.length <= 2 ? o = r : n.push(r));
+  }
+  if (o) {
+    const r = n[n.length - 1];
+    r !== void 0 && ye(r + " " + o, s) <= t ? n[n.length - 1] = r + " " + o : n.push(o);
+  }
+  return n;
+}
+function $o(e, t, s) {
+  const n = (d) => ye(d, s) <= t, o = [];
+  let r = "";
+  for (const d of e) {
+    if (!n(d)) {
+      r && o.push(r);
+      let h = "";
+      for (const c of Zn(d)) {
+        if (h && n(h + c)) {
+          h += c;
+          continue;
+        }
+        if (h && o.push(h), h = "", n(c)) {
+          h = c;
+          continue;
+        }
+        for (const y of c)
+          h && !n(h + y) && (o.push(h), h = ""), h += y;
+      }
+      r = h;
+      continue;
+    }
+    r && !n(r + " " + d) ? (o.push(r), r = d) : r += (r ? " " : "") + d;
+  }
+  return o.push(r), o;
+}
+function Do(e, t, s, n) {
+  const o = e.map((a) => ye(a, n)), r = ye(" ", n);
+  if (o.some((a) => a > s)) return;
+  const d = [0];
+  for (const a of o) d.push(d[d.length - 1] + a);
+  const h = (a, i) => d[i] - d[a] + (i - a - 1) * r, c = h(0, o.length) / t, y = (c / 10) ** 2, w = [[0, ...o.map(() => 1 / 0)]], l = [[]];
+  for (let a = 1; a <= t; a++) {
+    w.push(o.map(() => 1 / 0).concat(1 / 0)), l.push([]);
+    for (let i = a; i <= o.length; i++)
+      for (let g = i - 1; g >= a - 1 && h(g, i) <= s; g--) {
+        const f = w[a - 1][g] + (h(g, i) - c) ** 2;
+        f < w[a][i] - y && ([w[a][i], l[a][i]] = [f, g]);
+      }
+  }
+  if (!Number.isFinite(w[t][o.length])) return;
+  const u = [];
+  for (let a = t, i = o.length; a > 0; i = l[a][i], a--)
+    u.unshift(e.slice(l[a][i], i).join(" "));
+  return u;
+}
+function it(e, t, s, n = !1) {
+  const o = [];
+  for (const r of String(e).split(`
+`)) {
+    const d = n ? Oo(r, t, s) : r.split(/\s+/).filter(Boolean), h = $o(d, t, s);
+    o.push(
+      ...n && h.length > 1 ? Do(d, h.length, t, s) ?? h : h
+    );
+  }
+  return o.length ? o : [""];
+}
+const ln = ["drafting", "fieldnotes", "signal", "ink", "blueprint"], It = "drafting", Gt = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950], Ve = 500, No = (e) => Ze[e]?.dark ? 950 : 50, Po = (e) => Ze[e]?.dark ? 900 : 100, Ht = [
+  "primary",
+  "secondary",
+  "slate",
+  "stone",
+  "blue",
+  "sky",
+  "teal",
+  "mint",
+  "green",
+  "amber",
+  "orange",
+  "red",
+  "rose",
+  "violet"
+], Tt = (e) => Ht.includes(e), dn = ["dashed", "solid"], Jn = () => ({
+  theme: It,
+  overrides: {},
+  colors: []
+}), fn = {
+  paddingX: { min: 4, max: 48 },
+  paddingY: { min: 4, max: 48 },
+  radius: { min: 0, max: 24 }
+}, Fo = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i, Ze = {
+  drafting: {
+    label: "Drafting",
+    description: "Navy ink on cool paper, with drafting blue and marker gold",
+    dark: !1,
+    canvas: "#F7F7F4",
+    text: "#1B2433",
+    muted: "#586172",
+    connection: "#39414F",
+    node: { fill: "#FFFFFF", stroke: "#C3C8CF", ink: "#1B2433" },
+    group: { fill: "#EEEFEB", stroke: "#D5D8DC", ink: "#363F4D" },
+    paddingX: 12,
+    paddingY: 20,
+    radius: 4,
+    shadow: !1,
+    titleFont: "sans",
+    annotationFont: "sans",
+    titleSize: 13,
+    titleLine: 16,
+    annotationSize: 11,
+    chroma: 0.9,
+    primary: ["#2754A6", 700],
+    secondary: ["#F0B43C", 400]
+  },
+  fieldnotes: {
+    label: "Fieldnotes",
+    description: "Editorial serif titles on warm paper, indigo and terracotta",
+    dark: !1,
+    canvas: "#F6F1E6",
+    text: "#2F2B24",
+    muted: "#6B6559",
+    connection: "#57503F",
+    node: { fill: "#FFFCF5", stroke: "#CFC4AF", ink: "#2F2B24" },
+    group: { fill: "#EEE7D8", stroke: "#D8CDB8", ink: "#4A4539" },
+    paddingX: 18,
+    paddingY: 22,
+    radius: 3,
+    shadow: !1,
+    titleFont: "serif",
+    annotationFont: "sans",
+    titleSize: 15,
+    titleLine: 19,
+    annotationSize: 11,
+    chroma: 0.72,
+    primary: ["#34507F", 700],
+    secondary: ["#B5532F", 600],
+    hues: { green: [150, 0.1], amber: [80, 0.12], violet: [320, 0.1] }
+  },
+  signal: {
+    label: "Signal",
+    description: "Color-blind-safe Okabe–Ito hues on white, with monospace annotations",
+    dark: !1,
+    canvas: "#FFFFFF",
+    text: "#16202B",
+    muted: "#4F5B68",
+    connection: "#3B4652",
+    node: { fill: "#F5F7F9", stroke: "#C3CAD3", ink: "#16202B" },
+    group: { fill: "#F6F8FA", stroke: "#D9DEE4", ink: "#2A3644" },
+    paddingX: 16,
+    paddingY: 20,
+    radius: 6,
+    shadow: !1,
+    titleFont: "sans",
+    annotationFont: "mono",
+    titleSize: 13,
+    titleLine: 16,
+    annotationSize: 10.5,
+    chroma: 1,
+    primary: ["#0067A5", 600],
+    secondary: ["#E69F00", 500],
+    // After Okabe & Ito's set: blue, sky blue, bluish green, orange, vermilion, reddish purple.
+    hues: {
+      blue: [248, 0.15],
+      sky: [237, 0.11],
+      green: [163, 0.13],
+      mint: [172, 0.1],
+      amber: [72, 0.16],
+      orange: [55, 0.16],
+      red: [36, 0.18],
+      rose: [350, 0.13]
+    }
+  },
+  ink: {
+    label: "Ink",
+    description: "Sumi ink tones with indigo and a vermilion seal, generous spacing",
+    dark: !1,
+    canvas: "#F8F6F1",
+    text: "#1A1A1A",
+    muted: "#625F5A",
+    connection: "#3B3A38",
+    node: { fill: "#FFFFFF", stroke: "#C8C5BF", ink: "#1A1A1A" },
+    group: { fill: "#EFECE5", stroke: "#D9D5CC", ink: "#3F3D39" },
+    paddingX: 22,
+    paddingY: 26,
+    radius: 3,
+    shadow: !1,
+    titleFont: "sans",
+    annotationFont: "sans",
+    titleSize: 14,
+    titleLine: 19,
+    annotationSize: 11.5,
+    chroma: 0.6,
+    primary: ["#2B3A55", 900],
+    secondary: ["#C23B22", 600]
+  },
+  blueprint: {
+    label: "Blueprint",
+    description: "White lines on blueprint blue, cyan and yellow, monospace titles",
+    dark: !0,
+    canvas: "#13233D",
+    text: "#EAF1FB",
+    muted: "#A6B8D2",
+    connection: "#A9C2E6",
+    node: { fill: "#1B3154", stroke: "#45679B", ink: "#EAF1FB" },
+    group: { fill: "#172A48", stroke: "#2F4C78", ink: "#CFDCEF" },
+    paddingX: 16,
+    paddingY: 20,
+    radius: 3,
+    shadow: !1,
+    titleFont: "mono",
+    annotationFont: "sans",
+    titleSize: 12.5,
+    titleLine: 17,
+    annotationSize: 11,
+    chroma: 0.85,
+    primary: ["#7FC4F2", 300],
+    secondary: ["#F2C14E", 300]
+  }
+}, eo = (e) => e <= 0.04045 ? e / 12.92 : ((e + 0.055) / 1.055) ** 2.4, Co = (e) => e <= 31308e-7 ? 12.92 * e : 1.055 * e ** (1 / 2.4) - 0.055;
+function to(e) {
+  const t = e.length === 4 ? e.replace(/[0-9a-f]/gi, (s) => s + s) : e;
+  return [1, 3, 5].map((s) => parseInt(t.slice(s, s + 2), 16) / 255);
+}
+function on(e) {
+  const [t, s, n] = to(e).map(eo), o = Math.cbrt(0.4122214708 * t + 0.5363325363 * s + 0.0514459929 * n), r = Math.cbrt(0.2119034982 * t + 0.6806995451 * s + 0.1073969566 * n), d = Math.cbrt(0.0883024619 * t + 0.2817188376 * s + 0.6299787005 * n), h = 0.2104542553 * o + 0.793617785 * r - 0.0040720468 * d, c = 1.9779984951 * o - 2.428592205 * r + 0.4505937099 * d, y = 0.0259040371 * o + 0.7827717662 * r - 0.808675766 * d;
+  return [h, Math.hypot(c, y), (Math.atan2(y, c) * 180 / Math.PI + 360) % 360];
+}
+function hn([e, t, s]) {
+  const n = t * Math.cos(s * Math.PI / 180), o = t * Math.sin(s * Math.PI / 180), r = (e + 0.3963377774 * n + 0.2158037573 * o) ** 3, d = (e - 0.1055613458 * n - 0.0638541728 * o) ** 3, h = (e - 0.0894841775 * n - 1.291485548 * o) ** 3;
+  return [
+    4.0767416621 * r - 3.3077115913 * d + 0.2309699292 * h,
+    -1.2684380046 * r + 2.6097574011 * d - 0.3413193965 * h,
+    -0.0041960863 * r - 0.7034186147 * d + 1.707614701 * h
+  ];
+}
+function lt([e, t, s]) {
+  let n = t, o = hn([e, n, s]);
+  for (; n > 0 && o.some((r) => r < -5e-4 || r > 1.0005); )
+    n = Math.max(0, n - 4e-3), o = hn([e, n, s]);
+  return "#" + o.map(
+    (r) => Math.round(Math.min(1, Math.max(0, Co(Math.min(1, Math.max(0, r))))) * 255).toString(16).padStart(2, "0")
+  ).join("").toUpperCase();
+}
+function Yt(e) {
+  const [t, s, n] = to(e).map(eo);
+  return 0.2126 * t + 0.7152 * s + 0.0722 * n;
+}
+function Rt(e, t) {
+  const [s, n] = [Yt(e), Yt(t)].sort((o, r) => r - o);
+  return (s + 0.05) / (n + 0.05);
+}
+const un = {
+  50: 0.975,
+  100: 0.945,
+  200: 0.9,
+  300: 0.84,
+  400: 0.62,
+  500: 0.56,
+  600: 0.5,
+  700: 0.44,
+  800: 0.38,
+  900: 0.32,
+  950: 0.26
+}, sn = (e) => e <= 300, no = (e) => e >= 45 && e <= 110, Wt = { 400: 0.8, 500: 0.74 }, jo = (e, t) => Wt[e] === void 0 ? void 0 : Wt[e] - (t < 65 ? 0.07 : 0), Bo = (e, t) => sn(e) || no(t) && e in Wt, Ne = {
+  /** Dark title text on a pale fill. */
+  paleInk: 7,
+  /** White title text on a dark fill. */
+  darkInk: 4.5,
+  /** A shape's outline against the canvas when its fill alone does not separate it. */
+  outline: 3,
+  /** Connection lines and connection label text against the canvas. */
+  connection: 4.5,
+  /** A group's frame against the canvas. */
+  frame: 2
+}, St = (e) => Math.max(0.18, 1 - ((e - 0.6) / 0.42) ** 2), Uo = {
+  slate: [255, 0.03],
+  stone: [70, 0.02],
+  blue: [258, 0.14],
+  sky: [232, 0.1],
+  teal: [195, 0.085],
+  mint: [168, 0.09],
+  green: [155, 0.12],
+  amber: [78, 0.14],
+  orange: [50, 0.15],
+  red: [32, 0.17],
+  rose: [358, 0.12],
+  violet: [305, 0.13]
+}, zo = (e) => lt([0.24, 0.035, e]), qo = "#FFFFFF";
+function Ye(e, t, s) {
+  if (Rt(e, t) >= s) return e;
+  const [n, o, r] = on(e), d = Yt(t) > 0.18 ? -0.01 : 0.01;
+  let h = e;
+  for (let c = n; c > 0 && c < 1 && Rt(h, t) < s; c += d)
+    h = lt([c, o, r]);
+  return h;
+}
+function pn(e, t, s, n, o, r, d) {
+  const h = Bo(e, n), c = h ? zo(n) : qo, y = sn(e) ? Ne.paleInk : Ne.darkInk;
+  let w = d ? on(d)[0] : t, l = d ?? lt([w, s * St(w), n]);
+  for (; Rt(l, c) < y && w > 0.05 && w < 0.995; )
+    w += h ? 5e-3 : -0.01, l = lt([w, s * St(w), n]);
+  const u = h ? w - 0.2 : r ? w + 0.14 : w - 0.08;
+  let a = lt([u, s * St(u) * 1.1, n]);
+  return Rt(l, o) < Ne.outline && (a = Ye(a, o, Ne.outline)), { swatch: { fill: l, stroke: a, ink: c }, L: w };
+}
+const Go = 0.055;
+function oo(e, t, s, n, o) {
+  const r = /* @__PURE__ */ new Map();
+  let d = 1;
+  for (const h of Gt) {
+    const c = no(e) ? jo(h, e) : void 0, y = sn(h) ? un[h] : Math.min(c ?? un[h], d - Go);
+    let w = pn(
+      h,
+      y,
+      t,
+      e,
+      s,
+      n,
+      o?.[1] === h ? o[0] : void 0
+    );
+    w.L >= d - 0.01 && (w = pn(h, y, t, e, s, n)), d = w.L, r.set(h, w.swatch);
+  }
+  return r;
+}
+function gn([e, t], s, n) {
+  const [o, r, d] = on(e);
+  return oo(d, r / St(o), s, n, [e.toUpperCase(), t]);
+}
+const mn = /* @__PURE__ */ new Map();
+function Ho(e, t = Ze[e].canvas) {
+  const s = e + t;
+  let n = mn.get(s);
+  if (!n) {
+    const o = Ze[e];
+    n = /* @__PURE__ */ new Map([
+      ["primary", gn(o.primary, t, o.dark)],
+      ["secondary", gn(o.secondary, t, o.dark)]
+    ]);
+    for (const [r, d] of Object.entries(Uo)) {
+      const [h, c] = o.hues?.[r] ?? d;
+      n.set(r, oo(h, c * o.chroma, t, o.dark));
+    }
+    mn.set(s, n);
+  }
+  return n;
+}
+const Yo = (e) => Math.round(e + 32), xt = /* @__PURE__ */ new Map();
+function ut(e) {
+  const t = e ?? Jn(), s = JSON.stringify(t), n = xt.get(s);
+  if (n) return n;
+  const o = Ze[t.theme] ?? Ze[It], r = t.overrides, d = r.titleFont ?? o.titleFont, h = r.annotationFont ?? o.annotationFont, c = r.canvas ?? o.canvas, y = new Map(
+    [...Ho(t.theme, c)].map(([a, i]) => [a, new Map(i)])
+  ), w = /* @__PURE__ */ new Set();
+  for (const a of t.colors) {
+    y.has(a.family) || (y.set(a.family, /* @__PURE__ */ new Map()), w.add(a.family));
+    const i = y.get(a.family), g = i.get(a.shade);
+    (g || a.fill && a.stroke && a.ink) && i.set(a.shade, {
+      fill: a.fill ?? g.fill,
+      stroke: a.stroke ?? g.stroke,
+      ink: a.ink ?? g.ink
+    });
+  }
+  const l = ct(d, !0, o.titleSize, o.titleLine), u = {
+    theme: t.theme,
+    dark: o.dark,
+    // Preset colors are held to the contrast targets against the actual canvas; colors the file
+    // sets explicitly are used exactly as written.
+    canvas: c,
+    text: r.text ?? Ye(o.text, c, 7),
+    muted: Ye(o.muted, c, Ne.connection),
+    connection: r.connection ?? Ye(o.connection, c, Ne.connection),
+    node: {
+      fill: o.node.fill,
+      stroke: Ye(o.node.stroke, c, Ne.outline),
+      ink: r.text ?? Ye(o.node.ink, o.node.fill, Ne.paleInk)
+    },
+    group: {
+      fill: o.group.fill,
+      stroke: Ye(o.group.stroke, c, Ne.frame),
+      ink: Ye(o.group.ink, o.group.fill, Ne.paleInk)
+    },
+    paddingX: r.paddingX ?? o.paddingX,
+    paddingY: r.paddingY ?? o.paddingY,
+    radius: r.radius ?? o.radius,
+    shadow: o.shadow,
+    title: l,
+    detail: ct(d, !1, o.titleSize - 1, o.titleLine - 1),
+    groupTitle: l,
+    annotation: ct(
+      h,
+      !1,
+      o.annotationSize,
+      Math.round(o.annotationSize * 1.4)
+    ),
+    groupHeader: Yo(l.lineHeight),
+    families: y,
+    custom: w,
+    strikeRemoved: !!t.config?.strikeRemoved
+  };
+  return xt.size > 50 && xt.clear(), xt.set(s, u), u;
+}
+function wn(e, t = 0) {
+  if (!e.length) return { x: 70, y: 160, w: 240, h: 160 };
+  let s = 1 / 0, n = 1 / 0, o = -1 / 0, r = -1 / 0;
+  for (const d of e)
+    s = Math.min(s, d.x), n = Math.min(n, d.y), o = Math.max(o, d.x + d.w), r = Math.max(r, d.y + d.h);
+  return { x: s - t, y: n - t, w: o - s + t * 2, h: r - n + t * 2 };
+}
+const Se = 24, Wo = 48, Xt = 97, dt = 10, Lt = 18, so = (e, t = Wo) => ({
+  x: e.x + Se,
+  y: e.y + t
+}), Xo = 48;
+function io(e) {
+  return e === "circle" || e === "icon" ? { w: 80, h: 80 } : e === "diamond" ? { w: 112, h: 112 } : e === "text" ? { w: 164, h: 38 } : { w: 164, h: 56 };
+}
+function Ot(e, t, s, n, o = !1) {
+  if (e === "diamond") return { width: Math.max(40, t * 0.55), maxHeight: s * 0.45 };
+  if (e === "circle") return { width: Math.max(40, t * 0.7), maxHeight: s * 0.7 };
+  const r = e === "text" ? Math.min(n.paddingY, 11) : n.paddingY;
+  return {
+    width: Math.max(40, t - 2 * n.paddingX - (o ? 30 : 0) - (e === "pill" ? 8 : 0)),
+    maxHeight: s - 2 * r
+  };
+}
+function Ko(e, t, s, n) {
+  return e === "circle" ? Math.max(s, Math.ceil(t / 0.7)) : e === "text" ? t + 2 * Math.min(n.paddingY, 11) : t + 2 * n.paddingY;
+}
+function pt(e, t, s) {
+  const n = e.indexOf(`
+`), o = n < 0 ? e : e.slice(0, n), r = it(o, t, s.title, !0).map((d) => ({ text: d, detail: !1 }));
+  if (n >= 0)
+    for (const d of it(e.slice(n + 1), t, s.detail, !0))
+      r.push({ text: d, detail: !0 });
+  return r;
+}
+const Qo = (e, t) => e.detail ? t.detail : t.title, gt = (e, t) => e.reduce((s, n) => s + Qo(n, t).lineHeight, 0), Vo = 6;
+function Zo(e, t, s) {
+  const n = t - 2 * Vo;
+  for (let o = 1; o * s.title.lineHeight < n; o++) {
+    const r = n - o * s.title.lineHeight;
+    if (r >= 40 && gt(pt(e, r, s), s) <= o * s.title.lineHeight)
+      return r;
+  }
+}
+const yn = 3, _t = (e, t = 1) => e.groupHeader + (t - 1) * e.groupTitle.lineHeight, Jo = 168, ao = (e, t = !1) => t ? { ...e.annotation, size: e.annotation.size + 1.5, lineHeight: e.annotation.lineHeight + 2 } : e.annotation, es = 140, ts = (e, t, s = !1) => it(e, s ? Jo : es, ao(t, s)), We = { out: 36, down: 22, label: 4 };
+function Je(e, t = ut(), s = !1) {
+  const n = ao(t, s), o = ts(e, t, s), r = Math.max(...o.map((d) => ye(d, n))) + 16;
+  return {
+    w: Math.round(Math.max(36, r)),
+    h: Math.round(o.length * n.lineHeight + 6)
+  };
+}
+function Mn(e, t) {
+  if (!e) return { right: We.out, above: 0, below: We.down };
+  const { w: s, h: n } = Je(e, t, !0);
+  return {
+    right: We.out + We.label + s,
+    above: Math.max(0, n / 2 - We.down / 2),
+    below: Math.max(We.down, We.down / 2 + n / 2)
+  };
+}
+const Ft = 8, xn = 16, Kt = 10, ns = 64, os = 240, Qt = (e) => Math.round(e + 14);
+function ss(e, t) {
+  if (e.size?.height !== void 0) return { w: e.size.width, h: e.size.height };
+  if (e.size) {
+    const r = gt(pt(e.label, e.size.width - 2 * t.paddingX, t), t);
+    return {
+      w: e.size.width,
+      h: Math.max(r + 2 * Math.min(t.paddingY, Kt), e.size.minHeight ?? 0)
+    };
+  }
+  const s = 2 * t.paddingX, n = Math.min(os, Math.max(ns, Math.ceil(ye(e.label, t.title)) + s)), o = gt(pt(e.label, n - s, t), t);
+  return { w: n, h: o + 2 * Math.min(t.paddingY, Kt) };
+}
+function is(e, t, s, n = 0) {
+  const o = e.filter((D) => !D.marker), r = new Map(o.map((D) => [D.id, ss(D, s)])), d = Math.max(
+    1,
+    t.columns ?? (t.direction === "down" ? 1 : o.reduce((D, _) => D + (_.span ?? 1), 0))
+  ), h = /* @__PURE__ */ new Map();
+  let c = 0, y = 0;
+  for (const D of o) {
+    const _ = Math.min(D.span ?? 1, d);
+    y + _ > d && (c++, y = 0), h.set(D.id, { row: c, col: y, span: _ }), y += _;
+  }
+  const w = Array(d).fill(0), l = Array(o.length ? c + 1 : 0).fill(0);
+  for (const D of o) {
+    const { row: _, col: $, span: x } = h.get(D.id);
+    x === 1 && (w[$] = Math.max(w[$], r.get(D.id).w)), l[_] = Math.max(l[_], r.get(D.id).h);
+  }
+  for (const D of o) {
+    const { col: _, span: $ } = h.get(D.id), x = r.get(D.id).w - w.slice(_, _ + $).reduce((E, v) => E + v, 0);
+    x > 0 && (w[_ + $ - 1] += x);
+  }
+  const u = n - w.reduce((D, _) => D + _, 0);
+  u > 0 && (w[d - 1] += u);
+  const a = [0], i = [0];
+  for (const D of w) a.push(a.at(-1) + D);
+  for (const D of l) i.push(i.at(-1) + D);
+  const g = a.at(-1), f = i.at(-1), M = /* @__PURE__ */ new Map();
+  for (const D of o) {
+    const { row: _, col: $, span: x } = h.get(D.id);
+    M.set(D.id, { x: a[$], y: i[_], w: a[$ + x] - a[$], h: l[_] });
+  }
+  const k = Qt(s.groupTitle.lineHeight), S = d > 1 || t.direction === "right";
+  return e.forEach((D, _) => {
+    if (!D.marker) return;
+    const $ = e.slice(_ + 1).find((v) => !v.marker), x = $ ? M.get($.id) : void 0, E = Ft / 2;
+    M.set(
+      D.id,
+      S ? { x: (x?.x ?? g) - E, y: -k, w: Ft, h: f + k + xn } : { x: 0, y: (x?.y ?? f) - E, w: g + xn, h: Ft }
+    );
+  }), { boxes: M, w: g, h: f };
+}
+const as = { bit: 24, byte: 48 }, rs = { bit: 32, byte: 16 };
+function cs(e, t, s) {
+  const n = t.columns ?? rs[t.unit], o = t.unitWidth ?? as[t.unit], r = 2 * Math.min(s.paddingX, 6), d = /* @__PURE__ */ new Map();
+  let h = 0, c = 0;
+  for (const f of e) {
+    const M = [];
+    if (f.open)
+      M.push({ row: h, col: c, span: n - c }), h++, c = 0;
+    else
+      for (let k = f.span ?? 1; k > 0; ) {
+        const S = Math.min(k, n - c);
+        M.push({ row: h, col: c, span: S }), k -= S, c += S, c === n && (h++, c = 0);
+      }
+    d.set(f.id, M);
+  }
+  const y = c ? h + 1 : h, w = (f) => d.get(f).reduce((M, k) => k.span > M.span ? k : M), l = Math.max(
+    0,
+    ...e.map((f) => {
+      const M = pt(f.label, Math.max(8, w(f.id).span * o - r), s);
+      return gt(M, s) + 2 * Math.min(s.paddingY, Kt);
+    })
+  ), u = (f) => ({
+    x: f.col * o,
+    y: f.row * l,
+    w: f.span * o,
+    h: l
+  }), a = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  for (const f of e) {
+    const M = w(f.id), k = d.get(f.id).filter((S) => S !== M);
+    a.set(f.id, u(M)), k.length && i.set(f.id, k.map(u));
+  }
+  const g = t.ruler ? Math.round(s.annotation.lineHeight + 6) : 0;
+  return {
+    boxes: a,
+    pieces: i,
+    open: e.filter((f) => f.open).map((f) => f.id),
+    ...t.ruler ? {
+      ruler: {
+        h: g,
+        ticks: Array.from({ length: n }, (f, M) => ({
+          x: M * o + o / 2,
+          label: String(M)
+        }))
+      }
+    } : {},
+    w: n * o,
+    h: y * l
+  };
+}
+const ls = /\[([^\]\n]+)\]\(([^)\s]+)\)/g;
+function ds(e, t, s) {
+  let n = "";
+  const o = [];
+  let r = 0;
+  for (const c of e.matchAll(ls)) {
+    const y = e.slice(r, c.index);
+    n += y + c[1], o.push(
+      ...Array(y.length).fill(void 0),
+      ...Array(c[1].length).fill(c[2])
+    ), r = c.index + c[0].length;
+  }
+  n += e.slice(r), o.push(...Array(e.length - r).fill(void 0));
+  let d = 0;
+  const h = (c) => /\s/.test(n[c] ?? "");
+  return it(n, t, s).map((c) => {
+    for (; d < n.length && h(d); ) d++;
+    const y = [];
+    for (const u of c)
+      if (u === " " && h(d)) {
+        const a = o[d - 1];
+        for (; d < n.length && h(d); ) d++;
+        y.push(a && a === o[d] ? a : void 0);
+      } else y.push(o[d++]);
+    const w = [];
+    y.forEach((u, a) => {
+      const i = w.at(-1);
+      i && i.href === u ? i.text += c[a] : w.push({ text: c[a], href: u, x: 0, w: 0 });
+    });
+    let l = 0;
+    for (const u of w)
+      u.x = l, u.w = ye(u.text, s), l += u.w;
+    return w.length ? w : [{ text: "", x: 0, w: 0 }];
+  });
+}
+const fs = ["below", "above", "left", "right"], ro = 280, co = { x: 12, y: 8 }, bn = co.x, hs = co.y, us = 8;
+function ps(e, t) {
+  const s = e.annotation, n = ds(t.text, (t.width ?? ro) - bn * 2, s), o = Math.ceil(Math.max(...n.map((r) => r.reduce((d, h) => d + h.w, 0)))) + bn * 2;
+  return { note: t, lines: n, rect: { x: 0, y: 0, w: o, h: n.length * s.lineHeight + hs * 2 } };
+}
+function gs(e, t, s, { left: n, right: o, top: r }) {
+  const d = t.map(() => null);
+  for (const h of ["left", "right"]) {
+    let c = r;
+    t.map((y, w) => ({ note: y, i: w, row: s.get(y.near ?? "") })).filter((y) => y.row !== void 0 && (y.note.side ?? "right") === h).sort((y, w) => y.row - w.row).forEach(({ note: y, i: w, row: l }) => {
+      const { w: u, h: a } = ps(e, y).rect, i = Math.max(c, Math.round(l - a / 2));
+      d[w] = { x: h === "right" ? o : n - u, y: i, w: u, h: a }, c = i + a + us;
+    });
+  }
+  return d;
+}
+const ms = 1.1;
+function ws(e, t, s) {
+  const n = new Map(e), o = [...n].flatMap(
+    ([r, d]) => Object.keys(d.lines).filter((h) => d.lines[h]).map((h) => ({ id: r, side: h, n: d.lines[h] }))
+  );
+  o.sort((r, d) => r.n - d.n || (r.id < d.id ? 1 : -1));
+  for (const { id: r, side: d } of o) {
+    if (!n.size || s(n) <= t * ms) break;
+    const h = { ...n.get(r), lines: { ...n.get(r).lines, [d]: 0 } };
+    h[d] = d === "top" ? 0 : Se, Object.values(h.lines).some(Boolean) ? n.set(r, h) : n.delete(r);
+  }
+  return n;
+}
+const ys = 20, vn = 16, bt = 10;
+function Ms(e, t, s = {}) {
+  const n = new Map(e.map((i) => [i.id, i])), o = (i) => {
+    const g = [];
+    for (let f = n.get(i); f && f.parent !== "root"; f = n.get(f.parent))
+      g.push(f.parent);
+    return g;
+  }, r = (i, g) => i === g || o(i).includes(g), d = /* @__PURE__ */ new Map(), h = (i, g) => {
+    const f = d.get(i) ?? { left: 0, right: 0, top: 0, bottom: 0 };
+    f[g]++, d.set(i, f);
+  }, c = (i) => ({ x: i.x + i.w / 2, y: i.y + i.h / 2 }), y = (i, g, f, M) => e.some((k) => k.id === i.id || k.id === M || !r(k.id, g.id) || k.id === g.id || r(i.id, k.id) || r(M, k.id) || !(f === "left" || f === "right" ? k.y < i.y + i.h + bt && k.y + k.h > i.y - bt : k.x < i.x + i.w + bt && k.x + k.w > i.x - bt) ? !1 : f === "right" ? k.x >= i.x + i.w : f === "left" ? k.x + k.w <= i.x : f === "bottom" ? k.y >= i.y + i.h : k.y + k.h <= i.y), w = (i, g) => [
+    ...g.x > i.x + i.w ? ["right"] : [],
+    ...g.x < i.x ? ["left"] : [],
+    ...g.y > i.y + i.h ? ["bottom"] : [],
+    // A line leaves through the top only past the title band, which it may not cross.
+    ...g.y < i.y ? ["top"] : []
+  ];
+  for (const i of t) {
+    const g = n.get(i.source), f = n.get(i.target);
+    if (!g || !f || g === f || i.from !== "auto" || i.to !== "auto") continue;
+    const M = [g.id, ...o(g.id)], k = [f.id, ...o(f.id)].find((x) => M.includes(x) && x !== g.id && x !== f.id), S = k && n.get(k)?.type === "group" ? n.get(k) : void 0, D = (x) => {
+      let E = x;
+      for (; E.parent !== (S?.id ?? "root"); ) E = n.get(E.parent);
+      return E;
+    }, [_, $] = [D(g), D(f)];
+    if (S && _ !== $) {
+      const x = (P, X, B) => P === X || w(X, c(B)).some((G) => !y(P, X, G, ""));
+      if (!e.some(
+        (P) => P.parent === S.id && P !== _ && P !== $ && xs(_, $, P)
+      ) && x(g, _, f) && x(f, $, g)) continue;
+      const v = Math.abs(c(_).y - c($).y) > Math.abs(c(_).x - c($).x), p = (P, X, B) => (c(P)[B] - c(X)[B]) / Math.max(1, B === "x" ? X.w : X.h), A = v ? "x" : "y", m = p(g, _, A) + p(f, $, A), b = c($)[v ? "y" : "x"] > c(_)[v ? "y" : "x"], T = Math.abs(m) > 0.1 ? m > 0 : b;
+      h(S.id, v ? T ? "right" : "left" : T ? "bottom" : "top");
+      continue;
+    }
+    for (const [x, E] of [
+      [g, f],
+      [f, g]
+    ]) {
+      const v = x.parent === "root" ? void 0 : n.get(x.parent);
+      if (!v || S && v.id === S.id || r(E.id, v.id)) continue;
+      const p = w(v, c(E));
+      !p.length || p.some((A) => !y(x, v, A, E.id)) || (p.some((A) => A === "left" || A === "right") ? h(v.id, c(x).y < c(v).y + 24 ? "top" : "bottom") : h(v.id, c(E).x < c(x).x ? "left" : "right"));
+    }
+  }
+  const l = s.standoff ?? ys, u = Math.max(s.edgeGap ?? vn, s.portGap ?? vn), a = (i) => i ? 2 * l + (i - 1) * u : Se;
+  return new Map(
+    [...d].map(([i, g]) => [
+      i,
+      {
+        left: a(g.left),
+        right: a(g.right),
+        top: g.top ? l + (g.top - 1) * u : 0,
+        bottom: a(g.bottom),
+        lines: g
+      }
+    ])
+  );
+}
+function xs(e, t, s) {
+  const n = Math.min(e.x + e.w, t.x + t.w), o = Math.max(e.x, t.x), r = Math.min(e.y + e.h, t.y + t.h), d = Math.max(e.y, t.y), h = { x: Math.min(n, o), y: Math.min(r, d) }, c = { x: Math.max(n, o), y: Math.max(r, d) };
+  return s.x < c.x && s.x + s.w > h.x && s.y < c.y && s.y + s.h > h.y;
+}
+const kn = 20, vt = 20, bs = 12, vs = 16;
+function ks(e, t, s, n, o = (r) => Je(r)) {
+  const r = /* @__PURE__ */ new Map();
+  for (const d of e.filter((h) => h.scope === "root")) {
+    const h = d.axis === "right", c = (f) => h ? f.x : f.y, y = (f) => h ? f.x + f.w : f.y + f.h, w = (f) => h ? f.y : f.x, l = (f) => h ? f.y + f.h : f.x + f.w, u = (f) => (c(f) + y(f)) / 2, a = (f) => (w(f) + l(f)) / 2, i = [...s.values()].filter((f) => f.parent === d.scope);
+    (d.bands?.map((f) => f.map((M) => s.get(M))) ?? [i]).forEach((f) => {
+      const M = Math.min(...f.map(w)), k = Math.max(...f.map(l)), S = Math.min(...f.map(c)), D = Math.max(...f.map(y)), _ = new Set(f.map((v) => v.id)), $ = (v) => [...s.values()].some(
+        (p) => p.parent === d.scope && !_.has(p.id) && c(p) < D && y(p) > S && (v ? l(p) <= M : w(p) >= k)
+      ), x = { before: !$(!0), after: !$(!1) }, E = [];
+      for (const v of t) {
+        if (n.has(v.id) || v.from !== "auto" || v.to !== "auto") continue;
+        const p = s.get(v.source), A = s.get(v.target);
+        if (!p || !A || p === A || !_.has(p.id) || !_.has(A.id) || p.type === "group" || A.type === "group") continue;
+        const m = u(A) < u(p), [b, T] = m ? [A, p] : [p, A], P = Math.min(a(p), a(A)) - 8, X = Math.max(a(p), a(A)) + 8, B = f.filter(
+          (O) => O !== p && O !== A && c(O) >= y(b) - 1 && y(O) <= c(T) + 1
+        );
+        if (!B.some((O) => w(O) < X && l(O) > P) && !(m && B.length)) continue;
+        const F = (O, C) => !f.some(
+          (V) => V !== O && c(V) < y(O) && y(V) > c(O) && (C ? l(V) <= w(O) : w(V) >= l(O))
+        ), L = (O) => !x[O ? "before" : "after"] || !F(p, O) || !F(A, O) ? 1 / 0 : O ? w(p) - M + (w(A) - M) : k - l(p) + (k - l(A)), [N, z] = [L(!0), L(!1)];
+        if (!Number.isFinite(N) && !Number.isFinite(z)) continue;
+        const I = N === z ? !m : N < z;
+        E.push({ id: v.id, before: I, from: u(b), to: u(T), back: m });
+      }
+      for (const v of [!0, !1]) {
+        const p = E.filter((b) => b.before === v).sort((b, T) => b.to - b.from - (T.to - T.from) || b.from - T.from), A = [], m = /* @__PURE__ */ new Set();
+        for (const b of p) {
+          const T = t.find((O) => O.id === b.id);
+          if (m.has(T.source) || m.has(T.target)) continue;
+          m.add(T.source).add(T.target);
+          let P = 0;
+          for (; A[P]?.some(([O, C]) => b.from < C + vt && b.to > O - vt); ) P++;
+          (A[P] ??= []).push([b.from, b.to]);
+          const X = t.find((O) => O.id === b.id), B = s.get(X.target), G = v ? M - kn - P * vt : k + kn + P * vt, F = Es(B, f, !b.back, c, y), L = Math.min(vs, (l(B) - w(B)) / 2 - bs), N = As(B, f, !b.back, X.id, t, s, c, y, w, l), z = B.shape === "diamond" && N.length > 0 || N.some((O) => {
+            if (!O.label) return !1;
+            const { w: C, h: V } = o(O.label);
+            return (h ? V : C) / 2 + 2 > L;
+          }), I = z ? u(B) : b.back ? y(B) + F / 2 : c(B) - F / 2;
+          r.set(b.id, {
+            ...h ? { y: Math.round(G) } : { x: Math.round(G) },
+            enter: Math.round(I),
+            out: !0,
+            ...z ? { face: !0 } : {}
+          });
+        }
+      }
+    });
+  }
+  return r;
+}
+function Es(e, t, s, n, o) {
+  const r = t.filter((d) => d !== e && (s ? o(d) <= n(e) : n(d) >= o(e))).map((d) => s ? n(e) - o(d) : n(d) - o(e));
+  return Math.min(48, ...r);
+}
+function As(e, t, s, n, o, r, d, h, c, y) {
+  const w = new Set(
+    t.filter(
+      (u) => u !== e && (s ? h(u) <= d(e) : d(u) >= h(e)) && c(u) < y(e) && y(u) > c(e)
+    ).map((u) => u.id)
+  ), l = (u) => {
+    for (let a = r.get(u); a; a = r.get(a.parent)) if (w.has(a.id)) return !0;
+    return !1;
+  };
+  return o.filter(
+    (u) => u.id !== n && (u.source === e.id && l(u.target) || u.target === e.id && l(u.source))
+  );
+}
+const lo = { port: 16, track: 16 }, En = 12, fo = 20, Ct = 0.5;
+function Ss(e, t, s, n, o, r = lo) {
+  const d = e === "right", h = /* @__PURE__ */ new Map(), { rectOf: c, usable: y, outPort: w, inPort: l, gaps: u, runs: a } = ho(
+    e,
+    t,
+    s,
+    n,
+    o,
+    r
+  ), i = [], g = [];
+  for (const [f, M] of t.entries())
+    for (const k of M) {
+      const S = c(k);
+      S && (i[f] = Math.min(i[f] ?? 1 / 0, S.y), g[f] = Math.max(g[f] ?? -1 / 0, S.y + S.h));
+    }
+  for (const [f, { placed: M, level: k }] of u) {
+    const S = Math.max(0, ...k) + 1, D = (i[f + 1] ?? 0) - (g[f] ?? 0), _ = S > 1 ? Math.min(r.track, Math.max(0, D - 2 * fo) / (S - 1)) : 0, $ = (g[f] ?? 0) + (D - (S - 1) * _) / 2;
+    M.forEach((x, E) => x.y = ot($ + k[E] * _));
+  }
+  for (const f of y) {
+    const M = c(f.chain[0]), k = c(f.chain.at(-1)), S = w.get(f.id), D = l.get(f.id), _ = [{ x: S, y: M.y + M.h }];
+    for (const $ of a.get(f.id)) _.push({ x: $.up, y: $.y }, { x: $.low, y: $.y });
+    _.push({ x: D, y: k.y }), h.set(f.id, {
+      points: Is(_).map(($) => d ? { x: $.y, y: $.x } : $),
+      fromOffset: ot(S - (M.x + M.w / 2)),
+      toOffset: ot(D - (k.x + k.w / 2))
+    });
+  }
+  return h;
+}
+function _s(e, t, s, n, o, r = lo) {
+  const d = [];
+  for (const [h, { level: c }] of ho(e, t, s, n, o, r).gaps)
+    d[h] = 2 * fo + Math.max(0, ...c) * r.track;
+  return d;
+}
+function ho(e, t, s, n, o, r) {
+  const d = e === "right", h = (x) => {
+    const E = n(x);
+    return E && (d ? { x: E.y, y: E.x, w: E.h, h: E.w } : E);
+  }, c = new Map(t.flatMap((x, E) => x.map((v) => [v, E]))), y = s.filter(
+    (x) => x.chain.length >= 2 && h(x.chain[0]) && h(x.chain.at(-1)) && x.chain.slice(1, -1).every((E) => o(E) !== void 0) && x.chain.every((E, v) => v === 0 || c.get(E) === c.get(x.chain[v - 1]) + 1)
+  ), w = (x) => {
+    const E = h(x);
+    return E ? E.x + E.w / 2 : o(x);
+  }, l = (x, E, v) => {
+    const p = h(x), A = p.x + En, m = p.x + p.w - En, b = E.length;
+    E.sort((B, G) => B.want - G.want || (B.line < G.line ? -1 : 1));
+    const T = b > 1 ? Math.min(r.port, Math.max(0, m - A) / (b - 1)) : 0, P = [];
+    for (const [B, G] of E.entries())
+      for (P.push({ sum: Math.min(m, Math.max(A, G.want)) - B * T, n: 1 }); P.length > 1 && P.at(-2).sum / P.at(-2).n > P.at(-1).sum / P.at(-1).n; ) {
+        const F = P.pop();
+        P.at(-1).sum += F.sum, P.at(-1).n += F.n;
+      }
+    const X = [];
+    for (const B of P)
+      for (let G = 0; G < B.n; G++)
+        X.push(Math.max(A, Math.min(m - (b - 1) * T, B.sum / B.n)) + X.length * T);
+    E.forEach((B, G) => v.set(B.line, ot(X[G])));
+  }, u = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+  for (const x of y) {
+    const [E, v] = x.chain;
+    (u.get(E) ?? u.set(E, []).get(E)).push({ line: x.id, want: w(v) });
+  }
+  const i = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map();
+  for (const [x, E] of u) l(x, E, i);
+  for (const x of y) {
+    const E = x.chain.at(-1), v = x.chain.at(-2), p = x.chain.length === 2 ? i.get(x.id) : o(v);
+    (a.get(E) ?? a.set(E, []).get(E)).push({ line: x.id, want: p });
+  }
+  for (const [x, E] of a) l(x, E, g);
+  const f = (x, E) => E === 0 ? i.get(x.id) : E === x.chain.length - 1 ? g.get(x.id) : o(x.chain[E]), M = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map();
+  for (const x of y) {
+    const E = [];
+    for (let v = 0; v + 1 < x.chain.length; v++) {
+      const p = f(x, v), A = f(x, v + 1);
+      if (Math.abs(p - A) < Ct) continue;
+      const m = { line: x.id, up: p, low: A, lo: Math.min(p, A), hi: Math.max(p, A) }, b = c.get(x.chain[v]);
+      (M.get(b) ?? M.set(b, []).get(b)).push(m), E.push(m);
+    }
+    k.set(x.id, E);
+  }
+  const S = (x, E) => x > E.lo + Ct && x < E.hi - Ct, D = (x, E) => (S(x.low, E) ? 1 : 0) + (S(E.up, x) ? 1 : 0), _ = (x, E) => x.lo < E.hi + r.track && E.lo < x.hi + r.track, $ = /* @__PURE__ */ new Map();
+  for (const [x, E] of M) {
+    const v = [];
+    for (const A of [...E].sort((m, b) => m.lo - b.lo || m.hi - b.hi)) {
+      let m = 0, b = 1 / 0;
+      for (let T = 0; T <= v.length; T++) {
+        let P = 0;
+        for (let X = 0; X < v.length; X++)
+          _(A, v[X]) && (P += X < T ? D(v[X], A) : D(A, v[X]));
+        P < b && ([m, b] = [T, P]);
+      }
+      v.splice(m, 0, A);
+    }
+    const p = v.map(() => 0);
+    for (let A = 0; A < v.length; A++)
+      for (let m = 0; m < A; m++)
+        _(v[A], v[m]) && (p[A] = Math.max(p[A], p[m] + 1));
+    $.set(x, { placed: v, level: p });
+  }
+  return { rectOf: h, usable: y, outPort: i, inPort: g, gaps: $, runs: k };
+}
+const ot = (e) => Math.round(e * 100) / 100;
+function Is(e) {
+  const t = [];
+  for (const s of e) {
+    const n = { x: ot(s.x), y: ot(s.y) }, o = t.at(-1);
+    if (o && Math.abs(o.x - n.x) < 0.01 && Math.abs(o.y - n.y) < 0.01) continue;
+    const r = t.at(-2);
+    o && r && (Math.abs(r.x - o.x) < 0.01 && Math.abs(o.x - n.x) < 0.01 || Math.abs(r.y - o.y) < 0.01 && Math.abs(o.y - n.y) < 0.01) && t.pop(), t.push(n);
+  }
+  return t;
+}
+const Ts = ["vscode", "vscode-insiders", "cursor", "windsurf", "zed"], An = [
+  "arrow",
+  "none",
+  "triangle",
+  "open-triangle",
+  "diamond",
+  "open-diamond",
+  "circle",
+  "cross"
+];
+function uo(e) {
+  return {
+    title: ct(e.title.role, !0, 20, 26),
+    subtitle: ct(e.annotation.role, !1, 13, 18)
+  };
+}
+const Sn = 360, Rs = 70;
+function Ls(e, t) {
+  const s = uo(e).subtitle, n = ye("abcdefghijklmnopqrstuvwxyz ", s) / 27 * Rs;
+  return Math.round(Math.min(Math.max(t, Sn), Math.max(n, Sn)));
+}
+const Os = uo;
+function $s(e) {
+  return [...Ns(e), ...Cs(e), ...js(e)];
+}
+const Ds = /* @__PURE__ */ new Set(["slate", "stone"]);
+function Ns(e) {
+  if (e.objects.some((r) => r.status) || e.edges.some((r) => r.status)) return [];
+  const t = e.appearance.legend ?? [], s = [];
+  if (t.length) {
+    const r = new Set(t.map((c) => c.family)), d = e.objects.filter(
+      (c) => c.color !== "auto" && !Ds.has(c.color) && !r.has(c.color)
+    ), h = [...new Set(d.map((c) => c.color))];
+    h.length && s.push({
+      level: "warning",
+      code: "legend-missing",
+      message: `The legend has no row for ${h.join(", ")}. Add a \`legend <color> "meaning"\` line for each color the drawing uses, or draw those objects in slate.`,
+      line: e.legendLines[0],
+      ids: d.map((c) => c.id)
+    });
+  }
+  const n = e.layouts.some((r) => r.algorithm === "sequence"), o = e.edges.filter((r) => r.dashed);
+  return !n && o.length && o.length < e.edges.length && !t.some((r) => r.line) && s.push({
+    level: "info",
+    code: "legend-lines",
+    message: 'Some lines are dashed (kind=async) and some solid. Say what each style means with `legend line dashed "meaning"` and `legend line solid "meaning"`.',
+    line: o[0].line,
+    ids: o.map((r) => r.id)
+  }), s;
+}
+function Ps(e, t) {
+  if (!Tt(t)) return Ve;
+  const s = new Map(e.objects.map((c) => [c.id, c])), n = !!Ze[e.appearance.theme]?.dark, o = (c) => {
+    for (let y = s.get(s.get(c)?.parent ?? ""); y; y = s.get(y.parent))
+      if (y.color !== "auto") return y;
+  }, r = e.objects.filter((c) => c.type === "node");
+  if (r.some((c) => c.color === t)) return Ve;
+  const d = r.filter((c) => c.color === "auto" && o(c.id)?.color === t), h = d.every((c) => {
+    const y = o(c.id).shade;
+    return y === void 0 || (n ? y >= 700 : y <= 300);
+  });
+  return d.length && h ? No(e.appearance.theme) : Ve;
+}
+function Fs(e) {
+  for (const t of e.appearance.legend ?? [])
+    t.family && t.shade === void 0 && (t.shade = Ps(e, t.family));
+}
+function Cs(e) {
+  return (e.appearance.legend ?? []).flatMap((t, s) => {
+    if (!t.family) return [];
+    const n = e.objects.filter((d) => d.type === "node" && d.color === t.family), o = t.shade ?? Ve, r = [...new Set(n.map((d) => d.shade ?? Ve))].sort((d, h) => d - h);
+    return !n.length || r.includes(o) ? [] : [
+      {
+        level: "warning",
+        code: "legend-shade",
+        message: `legend ${t.family} is shade ${o}; ${t.family} nodes use ${r.join(", ")}. Add \`shade=${r[0]}\`${r.length > 1 ? " or another of them" : ""}.`,
+        line: e.legendLines[s],
+        ids: n.map((d) => d.id)
+      }
+    ];
+  });
+}
+function js(e) {
+  const t = [], s = e.appearance.heading?.subtitle;
+  if (s) {
+    const n = ut(e.appearance), o = it(s, Ls(n, 1 / 0), Os(n).subtitle);
+    o.length > 1 && t.push({
+      level: "warning",
+      code: "heading-prose",
+      message: `The subtitle takes ${o.length} lines. Cut it to one short takeaway, about 10 words; let the drawing say the rest.`,
+      ids: []
+    });
+  }
+  return (e.appearance.notes ?? []).forEach((n, o) => {
+    n.near || t.push({
+      level: "warning",
+      code: "heading-prose",
+      message: "This note has no near=, so it sits under the heading as prose. Anchor it with near=<id> to the object it explains, or make it a footnote under the drawing.",
+      line: e.noteLines[o],
+      ids: []
+    });
+  }), [...t, ...Bs(e)];
+}
+function Bs(e) {
+  const t = new Set((e.appearance.footnotes ?? []).flatMap((n) => n.mark ? [n.mark] : []));
+  return t.size ? [
+    ...e.objects.map((n) => ({ id: n.id, text: n.label, line: n.line })),
+    ...e.edges.map((n) => ({ id: n.id, text: n.label, line: n.line }))
+  ].flatMap(
+    (n) => [...n.text.matchAll(/\[([A-Za-z0-9*]{1,3})\]/g)].filter((o) => !t.has(o[1])).map((o) => ({
+      level: "warning",
+      code: "footnote-missing",
+      message: `${n.id} points at [${o[1]}], but no footnote has that marker. Add footnote ${o[1]} "…" or fix the label.`,
+      line: n.line,
+      ids: [n.id]
+    }))
+  ) : [];
+}
+class Re extends Error {
+  constructor(t, s = 0, n = 0) {
+    super((s ? `Line ${s}${n ? `, column ${n}` : ""}: ` : "") + t), this.line = s, this.column = n, this.name = "DslError";
+  }
+}
+const po = { "+": "added", "-": "removed", "~": "changed", ".": "context" }, Us = (e) => ({ value: String(e), quoted: !1 }), zs = (e) => ({ value: e, quoted: !0 }), qs = 'A quote inside a quoted string needs a backslash: write \\" for each inner quote.';
+function Gs(e, t = 0) {
+  const s = [], n = [];
+  let o = "", r = 0, d = 0, h = !1, c = !1;
+  const y = () => {
+    o && (s.push(o), n.push(r + 1)), o = "";
+  };
+  for (let w = 0; w < e.length; w++) {
+    const l = e[w];
+    if (o || (r = w), c) {
+      o += l, c = !1;
+      continue;
+    }
+    if (h && l === "\\") {
+      o += l, c = !0;
+      continue;
+    }
+    if (l === '"') {
+      if (h && w + 1 < e.length && !/[\s#]/.test(e[w + 1]) && !e.startsWith("//", w + 1))
+        throw new Re(qs, t, w + 1);
+      h || (d = w), h = !h, o += l;
+      continue;
+    }
+    const u = l === "/" && e[w + 1] === "/" && !/[^\s"]/.test(e[w - 1] ?? " ");
+    if (!h && (l === "#" || u))
+      return y(), { tokens: s, columns: n, comment: e.slice(w).trim() };
+    !h && /\s/.test(l) ? y() : o += l;
+  }
+  if (h) throw new Re("Unclosed quoted string.", t, d + 1);
+  return y(), { tokens: s, columns: n };
+}
+function _n(e, t, s) {
+  if (!e.startsWith('"')) return Us(e);
+  try {
+    return zs(JSON.parse(e));
+  } catch {
+    throw new Re(
+      'Invalid escape in a quoted string. Use \\" for a quote, \\\\ for a backslash and \\n for a line break.',
+      t,
+      s
+    );
+  }
+}
+function Hs(e) {
+  if (typeof e != "string") throw new Re("Source must be text.");
+  if (e.length > 3e5) throw new Re("Limit: 300,000 source characters.");
+  return { lines: e.split(/\r?\n/).map((s, n) => {
+    const o = n + 1, { tokens: r, columns: d, comment: h } = Gs(s, o);
+    if (!r.length) return h ? { kind: "comment", text: h } : { kind: "blank" };
+    const [c, ...y] = r, w = po[c[0]] && c.length > 1 ? c[0] : void 0, l = w ? c.slice(1) : c, u = [], a = [];
+    return y.forEach((i, g) => {
+      const f = i.indexOf("="), M = d[g + 1];
+      if (f > 0 && !i.startsWith('"')) {
+        const k = i.slice(0, f);
+        if (a.some(([S]) => S === k)) throw new Re(`Duplicate attribute ${k}.`, o);
+        a.push([k, _n(i.slice(f + 1), o, M + f + 1)]);
+      } else u.push(_n(i, o, M));
+    }), { kind: "statement", command: l, ...w ? { mark: w } : {}, args: u, attrs: a, comment: h, line: o };
+  }) };
+}
+const Ys = { wide: 2, slide: 1.78, square: 1, page: 0.77, tall: 0.6 };
+function Vt(e, t, s) {
+  const n = st(e, t);
+  for (let o = s; o && o !== "root"; o = st(e, o))
+    if (st(e, o) === n) return o === t ? void 0 : o;
+}
+const Ws = ["near", "nudge", "stay", "pin"], In = {
+  "link-base": "linkBase",
+  editor: "editor",
+  "strike-removed": "strikeRemoved"
+}, Tn = {
+  "padding-x": "paddingX",
+  "padding-y": "paddingY",
+  radius: "radius",
+  "title-font": "titleFont",
+  "annotation-font": "annotationFont",
+  canvas: "canvas",
+  text: "text",
+  connection: "connection"
+}, Rn = [
+  "compound-flow",
+  "boundary-align",
+  "compound-spring",
+  "tidy",
+  "stress",
+  "force",
+  "flow",
+  "layered",
+  "tree",
+  "grid"
+], Zt = {
+  "rank-gap": { key: "rankGap", min: 12, max: 220 },
+  "group-gap": { key: "groupGap", min: 12, max: 180 },
+  "node-gap": { key: "nodeGap", min: 4, max: 160 },
+  "boundary-pull": { key: "boundaryPull", min: 0, max: 100 },
+  "hierarchy-sweeps": { key: "hierarchySweeps", min: 1, max: 4 },
+  "edge-length": { key: "edgeLength", min: 20, max: 260 },
+  repulsion: { key: "repulsion", min: 0, max: 100 },
+  "flow-strength": { key: "flowStrength", min: 0, max: 100 },
+  alignment: { key: "alignment", min: 0, max: 100 },
+  compactness: { key: "compactness", min: 0, max: 100 },
+  "grid-strength": { key: "gridStrength", min: 0, max: 100 },
+  ordering: { key: "ordering", choices: ["stable", "crossings"] },
+  fold: { key: "fold", choices: ["auto", "never"] },
+  aspect: { key: "aspect", choices: ["1", "1.333", "1.6", "2", "0.75"] },
+  root: { key: "rootId", choices: [] }
+}, Ln = {
+  clearance: { key: "clearance", min: 4, max: 30 },
+  "port-gap": { key: "portGap", min: 6, max: 28 },
+  "edge-gap": { key: "edgeGap", min: 4, max: 48 },
+  "bend-penalty": { key: "bendPenalty", min: 0, max: 100 },
+  "crossing-penalty": { key: "crossingPenalty", min: 0, max: 1200 },
+  "shared-penalty": { key: "sharedPenalty", min: 0, max: 20 },
+  "parallel-penalty": { key: "parallelPenalty", min: 0, max: 60 },
+  "port-stability": { key: "portStability", min: 0, max: 150 },
+  "fanout-penalty": { key: "fanoutPenalty", min: 0, max: 160 },
+  passes: { key: "passes", min: 1, max: 5 },
+  "corner-radius": { key: "cornerRadius", min: 0, max: 16 },
+  standoff: { key: "standoff", min: 0, max: 40 }
+};
+function Xs(e, t) {
+  return t && e === "gap" ? "Engine lines space boxes with node-gap= and rank-gap=." : !t && e in Zt ? `${e}= needs an engine: add engine=layered or another engine.` : e === "fit" ? "fit= goes on the layout root line." : "draftably skill print lists the layout settings.";
+}
+const Ks = /^[A-Za-z_][A-Za-z0-9_.-]*$/, jt = /^[A-Za-z_][A-Za-z0-9_-]*$/, go = ["box", "pill", "circle", "diamond", "text", "marker"], Qs = go.filter((e) => e !== "marker"), On = ["box", "soft", "none"], Vs = /^[A-Za-z]{1,8}$/, $n = ["auto", "left", "right", "top", "bottom"];
+function Zs(e) {
+  const t = typeof e == "string" ? Hs(e) : e, s = {
+    title: "Untitled diagram",
+    objects: [],
+    edges: [],
+    layouts: [],
+    hints: [],
+    routing: {},
+    appearance: Jn(),
+    themeLine: 0,
+    colorLines: /* @__PURE__ */ new Map(),
+    legendLines: [],
+    noteLines: [],
+    footnoteLines: [],
+    stateLines: /* @__PURE__ */ new Map(),
+    phases: [],
+    warnings: []
+  }, n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+  let h = 0;
+  for (const c of t.lines) {
+    if (c.kind !== "statement") continue;
+    const y = c.line, { command: w, args: l } = c, u = new Map(c.attrs), a = (m) => {
+      throw new Re(m, y);
+    }, i = (m, b) => {
+      m || a(b);
+    }, g = (m) => {
+      for (const b of u.keys())
+        i(m.includes(b), `Unknown ${w} attribute: ${b}.`);
+    }, f = (m, b = m) => i(l.length >= m && l.length <= b, `Wrong number of arguments for ${w}.`), M = (m) => (i(
+      m && !m.quoted && Ks.test(m.value),
+      "Expected a stable identifier (letters, digits, _, . or -)."
+    ), m.value), k = (m) => m?.value ?? "", S = (m, b, T = -1e5, P = 1e5) => {
+      const X = u.get(m);
+      if (X === void 0) return b;
+      const B = Number(X.value);
+      return i(
+        !X.quoted && Number.isFinite(B) && B >= T && B <= P,
+        `Expected ${m} from ${T} to ${P}; got ${X.value}.`
+      ), B;
+    }, D = (m, b) => {
+      const T = u.get(m);
+      return !T.quoted && Vs.test(T.value) ? T.value : S(m, b, b, 1e6);
+    }, _ = (m, b, T) => {
+      const P = u.get(m)?.value ?? b;
+      return i(T.includes(P), `Expected ${m}=${T.join("|")}; got ${P}.`), P;
+    }, $ = (m) => {
+      const b = Number(m.value);
+      return i(
+        !m.quoted && Gt.includes(b),
+        `Expected shade=${Gt.join("|")}; got ${m.value}.`
+      ), b;
+    }, x = (m) => {
+      const b = u.get(m);
+      return i(
+        b.quoted && Fo.test(b.value),
+        `Expected ${m}="#rrggbb" in double quotes; got ${b.value || "nothing"}.`
+      ), b.value.toUpperCase();
+    }, E = (m) => {
+      i(!d.has(m), `Duplicate declaration: ${m}. Edit the existing line instead.`), d.add(m);
+    }, v = c.mark && po[c.mark];
+    i(
+      !c.mark || ["node", "group", "edge"].includes(w),
+      `Only node, group and edge lines take a ${c.mark} mark.`
+    );
+    const p = () => {
+      for (const m of ["was", "was-shape", "was-count"])
+        i(!u.has(m) || c.mark === "~", `${m}= belongs on a changed (~) line.`);
+      return {
+        ...u.has("was") ? { was: u.get("was").value } : {},
+        ...u.has("was-shape") ? { wasShape: _("was-shape", "box", Qs) } : {},
+        ...u.has("was-count") ? { wasCount: D("was-count", 1) } : {}
+      };
+    }, A = (m) => {
+      const b = {};
+      for (const [T, P] of Object.entries(m))
+        u.has(T) && ("min" in P ? b[P.key] = S(T, 0, P.min, P.max) : P.choices.length ? b[P.key] = _(T, P.choices[0], P.choices) : b[P.key] = M(u.get(T)));
+      return b;
+    };
+    switch (w) {
+      case "diagram":
+        f(1), g(["version", "width"]), i(!h, "Only one diagram declaration is allowed."), h = y, s.title = k(l[0]), S("version", 1, 1, 1), s.title && ((s.appearance.heading ??= {}).title = s.title), u.has("width") && ((s.appearance.heading ??= {}).width = S("width", 0, 160, 8e3));
+        break;
+      case "compare": {
+        f(0, 2), g(["direction", "aspect"]), E("compare");
+        const m = _("direction", "auto", ["auto", "right", "down"]);
+        s.appearance.compare = {
+          before: k(l[0]) || "Before",
+          after: k(l[1]) || "After",
+          ...m !== "auto" ? { direction: m } : {},
+          ...u.has("aspect") ? { aspect: S("aspect", 1.6, 0.25, 8) } : {}
+        };
+        break;
+      }
+      case "config": {
+        f(0), g(Object.keys(In)), i(u.size, `config needs a setting: ${Object.keys(In).join(", ")}.`);
+        const m = s.appearance.config ??= {};
+        for (const [b, T] of u) {
+          const P = n.get(b);
+          P && s.warnings.push({
+            code: "config-repeated",
+            message: `config ${b} is also set on line ${P}; this line wins.`,
+            line: y
+          }), n.set(b, y), b === "editor" ? m.editor = _("editor", "vscode", Ts) : b === "strike-removed" ? m.strikeRemoved = _(b, "off", ["on", "off"]) === "on" : (i(T.quoted, `Expected ${b}="path" in double quotes.`), m.linkBase = T.value);
+        }
+        break;
+      }
+      case "state": {
+        i(l.length >= 1, 'A state needs an ID: state write "Write path" api orders.'), g(["rest"]);
+        const m = M(l[0]), b = l[1]?.quoted ? l[1].value : void 0, T = l.slice(b === void 0 ? 1 : 2).map((B) => M(B)), P = s.appearance.states ??= [];
+        let X = P.find((B) => B.id === m);
+        X || (X = { id: m, label: b ?? m, ids: [], rest: "dim" }, P.push(X)), u.has("rest") && (X.rest = _("rest", "dim", ["dim", "plain"]));
+        for (const B of T)
+          i(!X.ids.includes(B), `${B} is already in state ${m}.`), X.ids.push(B), s.stateLines.set(`${m}:${B}`, y);
+        break;
+      }
+      case "phase": {
+        i(
+          l.length >= 3 && l[1]?.quoted,
+          'A phase needs an ID, a label and its messages: phase preview "Preview" m1 m2.'
+        ), g([]);
+        const m = M(l[0]);
+        i(!s.phases.some((b) => b.id === m), `Duplicate phase ${m}.`), s.phases.push({ id: m, label: l[1].value, ids: l.slice(2).map((b) => M(b)), line: y });
+        break;
+      }
+      case "was-order":
+        i(l.length, "was-order lists the older message order: was-order m2 m1."), g([]), E("was-order"), s.wasOrder = { ids: l.map((m) => M(m)), line: y };
+        break;
+      case "subtitle":
+        f(1), g([]), E("subtitle"), i(k(l[0]).trim(), "A subtitle needs its text in quotes."), (s.appearance.heading ??= {}).subtitle = k(l[0]);
+        break;
+      case "node":
+      case "group": {
+        f(2), g(
+          w === "node" ? [
+            "in",
+            "color",
+            "shade",
+            "shape",
+            "was",
+            "was-shape",
+            "was-count",
+            "href",
+            "count",
+            "span"
+          ] : ["in", "color", "shade", "was", "href", "frame", "fold"]
+        );
+        const m = M(l[0]);
+        i(m !== "root", "root is reserved for the outer layout scope."), i(!o.has(m), `Duplicate node/group id ${m}.`), o.add(m);
+        const b = u.get("color")?.value ?? "auto";
+        i(
+          !u.get("color")?.quoted && jt.test(b),
+          `Expected color=auto, a built-in color (${Ht.join(", ")}) or a theme-color name; got ${b}.`
+        );
+        const T = u.has("shade") ? $(u.get("shade")) : void 0;
+        s.objects.push({
+          id: m,
+          type: w,
+          label: k(l[1]),
+          parent: u.has("in") ? M(u.get("in")) : "root",
+          color: b,
+          ...T !== void 0 ? { shade: T } : {},
+          shape: w === "node" ? _("shape", "box", go) : "box",
+          ...c.mark ? { status: v } : {},
+          ...p(),
+          ...u.has("href") ? { href: k(u.get("href")) } : {},
+          ...u.has("count") ? { count: D("count", 2) } : {},
+          ...w === "group" && _("fold", "auto", ["auto", "never"]) === "never" ? { fold: "never" } : {},
+          ...w === "group" && _("frame", "box", On) !== "box" ? { frame: _("frame", "box", On) } : {},
+          ...u.has("span") ? {
+            span: u.get("span").value === "var" ? "var" : S("span", 1, 1, 4096)
+          } : {},
+          line: y
+        });
+        break;
+      }
+      case "edge": {
+        f(4, 5), g(["kind", "from", "to", "was", "constraint", "directed", "head", "tail"]), i(
+          l[2]?.value === "->" && !l[2].quoted,
+          'Edges use: edge id source -> target "label".'
+        );
+        const m = M(l[0]);
+        i(!r.has(m), `Duplicate edge id ${m}.`), r.add(m);
+        const b = _("directed", "true", ["true", "false"]) === "false", T = _("head", "arrow", An), P = _("tail", "none", An);
+        i(
+          !b || !(u.has("head") || u.has("tail")),
+          `Edge ${m} has directed=false, so it has no ends to mark. Remove head= and tail=, or remove directed=false.`
+        ), s.edges.push({
+          id: m,
+          source: M(l[1]),
+          target: M(l[3]),
+          label: k(l[4]),
+          dashed: _("kind", "sync", ["sync", "async"]) === "async",
+          from: _("from", "auto", $n),
+          to: _("to", "auto", $n),
+          ...b ? { directed: !1 } : {},
+          ...T !== "arrow" ? { head: T } : {},
+          ...P !== "none" ? { tail: P } : {},
+          ..._("constraint", "true", ["true", "false"]) === "false" ? { constraint: !1 } : {},
+          ...c.mark ? { status: v } : {},
+          ...p(),
+          line: y
+        });
+        break;
+      }
+      case "layout": {
+        const m = M(l[0]), b = u.get("engine")?.value, T = s.layouts.findIndex((F) => F.scope === m);
+        T >= 0 && (s.warnings.push({
+          code: "layout-repeated",
+          message: `layout ${m} is also set on line ${s.layouts[T].line}; this line wins.`,
+          line: y
+        }), s.layouts.splice(T, 1));
+        const P = (F) => {
+          for (const L of [...u.keys()])
+            F.includes(L) || (s.warnings.push({
+              code: "layout-attribute",
+              message: `This layout line does not take ${L}=, so it is ignored. ${Xs(L, b !== void 0)}`,
+              line: y
+            }), u.delete(L));
+        }, X = [
+          "direction",
+          "min-width",
+          "min-height",
+          ...m === "root" ? ["fit"] : []
+        ];
+        let B;
+        if (b !== void 0)
+          f(1), i(
+            Rn.includes(b),
+            `Unknown layout engine ${b}; use ${Rn.join(", ")}.`
+          ), P(["engine", ...X, ...Object.keys(Zt)]), B = { algorithm: b, params: A(Zt) };
+        else {
+          f(2);
+          const F = l[1]?.value;
+          P(
+            F === "cells" ? ["columns", "unit", "unit-width", "ruler", ...X] : ["gap", ...F === "flow" ? ["fold"] : [], ...X]
+          );
+        }
+        const G = b ? "flow" : l[1]?.value;
+        i(
+          ["flow", "row", "column", "lanes", "sequence", "cells"].includes(G),
+          `The ${G} recipe is not supported; use flow, row, column, lanes, sequence or cells, or engine=.`
+        ), i(
+          !["lanes", "sequence"].includes(G) || m === "root",
+          `${G} arranges the whole diagram: write layout root ${G}.`
+        ), i(
+          G !== "cells" || m !== "root",
+          "Cells lay out a group; give the cells a group and use layout <group> cells."
+        ), s.layouts.push({
+          scope: m,
+          algorithm: G,
+          ...B ? { engine: B } : {},
+          direction: _("direction", "auto", ["auto", "right", "down"]),
+          fold: b ? "auto" : _("fold", "auto", ["auto", "never"]),
+          ...u.has("fit") ? { fit: _("fit", "slide", Object.keys(Ys)) } : {},
+          ...u.has("columns") ? { columns: S("columns", 1, 1, 512) } : {},
+          ...u.has("unit") ? {
+            unit: _("unit", "byte", ["bit", "byte"]),
+            ruler: _("ruler", "on", ["on", "off"]) === "on",
+            ...u.has("unit-width") ? { unitWidth: S("unit-width", 24, 8, 200) } : {}
+          } : {},
+          gap: S("gap", 28, 8, 300),
+          minWidth: S("min-width", 0, 0, 1e4),
+          minHeight: S("min-height", 0, 0, 1e4),
+          line: y
+        });
+        break;
+      }
+      case "theme": {
+        f(1), g(Object.keys(Tn)), E("theme");
+        const m = l[0].value;
+        i(ln.includes(m), `Unknown theme ${m}; use ${ln.join(", ")}.`), s.appearance.theme = m, s.themeLine = y;
+        const b = s.appearance.overrides;
+        for (const [T, P] of Object.entries(Tn))
+          u.has(T) && (P === "paddingX" || P === "paddingY" || P === "radius" ? b[P] = S(T, 0, fn[P].min, fn[P].max) : P === "titleFont" || P === "annotationFont" ? b[P] = _(T, "sans", Io) : b[P] = x(T));
+        break;
+      }
+      case "theme-color": {
+        f(1), g(["shade", "fill", "stroke", "ink"]);
+        const m = l[0].value;
+        i(
+          !l[0].quoted && jt.test(m) && m !== "auto",
+          "Expected a color family name (letters, digits, _ or -)."
+        );
+        const b = u.has("shade") ? $(u.get("shade")) : 500;
+        E(`theme-color:${m}:${b}`);
+        const T = { family: m, shade: b };
+        for (const P of ["fill", "stroke", "ink"])
+          u.has(P) && (T[P] = x(P));
+        i(
+          Tt(m) || T.fill && T.stroke && T.ink,
+          `${m} is not a built-in color, so shade ${b} needs fill, stroke and ink.`
+        ), i(T.fill || T.stroke || T.ink, "Set at least one of fill, stroke and ink."), s.appearance.colors.push(T), s.colorLines.set(`${m}:${b}`, y);
+        break;
+      }
+      case "legend": {
+        if (l[0]?.value === "line" && !l[0].quoted) {
+          f(3), g([]);
+          const T = l[1].value;
+          i(
+            !l[1].quoted && dn.includes(T),
+            `Expected legend line ${dn.join("|")} "meaning".`
+          ), E(`legend:line:${T}`), i(k(l[2]).trim(), "A legend entry needs its meaning in quotes."), (s.appearance.legend ??= []).push({ line: T, label: k(l[2]) }), s.legendLines.push(y);
+          break;
+        }
+        f(2), g(["shade"]);
+        const m = l[0].value;
+        i(
+          !l[0].quoted && jt.test(m) && m !== "auto",
+          `Expected legend family "meaning", with a built-in color (${Ht.join(", ")}) or a theme-color name.`
+        ), E(`legend:${m}:${u.get("shade")?.value ?? ""}`);
+        const b = u.has("shade") ? $(u.get("shade")) : void 0;
+        i(k(l[1]).trim(), "A legend entry needs its meaning in quotes."), (s.appearance.legend ??= []).push({
+          family: m,
+          label: k(l[1]),
+          ...b !== void 0 ? { shade: b } : {}
+        }), s.legendLines.push(y);
+        break;
+      }
+      case "note": {
+        f(1), g(["near", "side", "width"]), i(l[0].quoted && l[0].value.trim(), "A note needs its text in quotes."), i(u.has("near") || !u.has("side"), "side= places a note beside near=<id>."), (s.appearance.notes ??= []).push({
+          text: l[0].value,
+          ...u.has("near") ? { near: M(u.get("near")) } : {},
+          ...u.has("side") ? { side: _("side", "below", fs) } : {},
+          ...u.has("width") ? { width: S("width", ro, 80, 1200) } : {}
+        }), s.noteLines.push(y);
+        break;
+      }
+      case "footnote": {
+        f(1, 2), g([]);
+        const m = l[l.length - 1], b = l.length === 2 ? l[0] : void 0;
+        i(m.quoted && m.value.trim(), "A footnote needs its text in quotes."), i(
+          !b || !b.quoted && /^[A-Za-z0-9*]{1,3}$/.test(b.value),
+          'A footnote marker is a short word: footnote 1 "text".'
+        ), b && E(`footnote:${b.value}`), (s.appearance.footnotes ??= []).push({
+          text: m.value,
+          ...b ? { mark: b.value } : {}
+        }), s.footnoteLines.push(y);
+        break;
+      }
+      case "routing":
+        f(0), g(Object.keys(Ln)), E("routing"), s.routing = A(Ln);
+        break;
+      case "order":
+        f(2, 300), g([]), s.hints.push({ type: "order", scope: M(l[0]), ids: l.slice(1).map(M), line: y }), E("order:" + l[0].value);
+        break;
+      case "align": {
+        f(3, 300), g(["strength"]);
+        const m = l[0]?.value;
+        i(m === "x" || m === "y", "Expected align x or align y.");
+        const b = l.slice(1).map(M);
+        E(`align:${m}:${b.join(",")}`), s.hints.push({
+          type: "align",
+          axis: m,
+          ids: b,
+          strength: _("strength", "prefer", ["prefer", "required"]),
+          line: y
+        });
+        break;
+      }
+      case "near":
+      case "nudge":
+      case "stay":
+      case "pin":
+      case "size": {
+        f(w === "near" ? 2 : 1);
+        const m = M(l[0]);
+        if (E(`${w}:${m}`), w === "near") {
+          g(["side", "gap", "offset", "strength"]);
+          const b = M(l[1]);
+          i(b !== m, "An object cannot be placed relative to itself."), s.hints.push({
+            type: "near",
+            id: m,
+            ref: b,
+            side: _("side", "right", ["right", "left", "above", "below"]),
+            gap: S("gap", 28, 0, 2e3),
+            offset: S("offset", 0),
+            strength: _("strength", "prefer", ["prefer", "required"]),
+            line: y
+          });
+        } else if (w === "nudge")
+          g(["dx", "dy"]), s.hints.push({ type: "nudge", id: m, dx: S("dx", 0), dy: S("dy", 0), line: y });
+        else if (w === "stay")
+          g(["x", "y", "weight"]), s.hints.push({
+            type: "stay",
+            id: m,
+            // The root has no frame, so an arrangement can place objects left of or above 0,0.
+            x: S("x", 0),
+            y: S("y", 0),
+            weight: S("weight", 8, 1, 100),
+            line: y
+          });
+        else if (w === "pin")
+          g(["x", "y"]), s.hints.push({ type: "pin", id: m, x: S("x", 0, 0), y: S("y", 0, 0), line: y });
+        else {
+          g(["width", "height", "min-height"]);
+          const b = u.get("height")?.value === "auto";
+          i(
+            b || !u.has("min-height"),
+            "min-height is a floor under height=auto. Write height=auto, or remove min-height."
+          ), s.hints.push({
+            type: "size",
+            id: m,
+            width: S("width", 164, 40, 1200),
+            ...b ? {} : { height: S("height", 56, 24, 1200) },
+            ...u.has("min-height") ? { minHeight: S("min-height", 24, 24, 1200) } : {},
+            line: y
+          });
+        }
+        break;
+      }
+      case "view":
+      case "snapshot":
+      case "box":
+        a(`${w} statements are not supported yet. Remove them to open this file.`);
+        break;
+      default:
+        a(`Unknown statement ${w}.`);
+    }
+  }
+  if (s.objects.length > 500) throw new Re("Limit: 500 nodes and groups.");
+  if (s.edges.length > 1200) throw new Re("Limit: 1,200 edges.");
+  return Js(s), s;
+}
+function st(e, t) {
+  let s = e.get(t)?.parent ?? "root";
+  for (; s !== "root" && e.get(s)?.frame; ) s = e.get(s).parent;
+  return s;
+}
+function Js(e) {
+  const t = new Map(e.objects.map((a) => [a.id, a])), s = (a, i, g) => o(
+    !t.get(a)?.frame,
+    `${a} is a ${t.get(a)?.frame} group, so it has no ${g} of its own. Use frame=box, or ${g === "layout" ? "set the layout of the container around it" : "place its members"}.`,
+    i
+  ), n = (a) => st(t, a), o = (a, i, g) => {
+    if (!a) throw new Re(i, g);
+  }, r = (a, i) => o(t.has(a), `Unknown node/group ${a}.`, i), d = (a, i) => o(a === "root" || t.get(a)?.type === "group", `Unknown container ${a}.`, i), h = /* @__PURE__ */ new Map();
+  for (const a of e.appearance.colors)
+    h.has(a.family) || h.set(a.family, /* @__PURE__ */ new Set()), h.get(a.family).add(a.shade);
+  (e.appearance.legend ?? []).forEach((a, i) => {
+    if (!a.family || Tt(a.family)) return;
+    const g = h.get(a.family), f = a.shade ?? Ve;
+    o(
+      g?.has(f),
+      g ? `${a.family} has no shade ${f}; it defines ${[...g].sort((M, k) => M - k).join(", ")}.` : `Unknown color ${a.family}. Define it with theme-color ${a.family} shade=… fill= stroke= ink=.`,
+      e.legendLines[i]
+    );
+  });
+  for (const a of e.objects) {
+    if (a.color !== "auto" && !Tt(a.color)) {
+      const g = h.get(a.color), f = a.shade ?? (a.type === "group" ? Po(e.appearance.theme) : Ve);
+      o(
+        g,
+        `Unknown color ${a.color}. Define it with theme-color ${a.color} shade=… fill= stroke= ink=.`,
+        a.line
+      ), o(
+        g.has(f),
+        `${a.color} has no shade ${f}${a.shade === void 0 ? " (the default)" : ""}; it defines ${[...g].sort((M, k) => M - k).join(", ")}.`,
+        a.line
+      );
+    }
+    d(a.parent, a.line);
+    const i = /* @__PURE__ */ new Set();
+    for (let g = a; g; g = t.get(g.parent))
+      o(!i.has(g.id), `Containment cycle at ${g.id}.`, a.line), i.add(g.id), o(i.size <= 12, "Limit: 12 nesting levels.", a.line);
+  }
+  if (e.layouts.some((a) => a.scope === "root" && a.algorithm === "lanes"))
+    for (const a of e.objects)
+      a.parent === "root" && (o(
+        a.type === "group",
+        `In a lanes diagram every node sits in a lane; put ${a.id} in= one of the top-level groups.`,
+        a.line
+      ), o(!a.frame, `${a.id} is a lane, so it needs its frame; remove frame=.`, a.line));
+  const c = e.layouts.some((a) => a.scope === "root" && a.algorithm === "sequence");
+  if (c)
+    for (const a of e.objects)
+      o(
+        a.type === "node" ? t.get(a.parent)?.type !== "node" : a.parent === "root" && !a.frame,
+        `In a sequence diagram a group is a band of participants: put ${a.id} at the top level and its participants in=${a.id}.`,
+        a.line
+      ), o(
+        a.type === "node" || e.objects.some((i) => i.parent === a.id),
+        `Group ${a.id} has no participants, so it has no band to draw. Put a participant in=${a.id} or remove the group.`,
+        a.line
+      );
+  const y = new Set(e.edges.map((a) => a.id)), w = /* @__PURE__ */ new Set();
+  for (const a of e.phases) {
+    o(
+      c,
+      "A phase groups messages in a sequence diagram; use layout root sequence.",
+      a.line
+    );
+    for (const f of a.ids)
+      o(
+        y.has(f),
+        `Unknown message ${f} in phase ${a.id}; a phase lists edge IDs.`,
+        a.line
+      ), o(!w.has(f), `${f} is already in another phase.`, a.line), w.add(f);
+    const i = e.edges.flatMap((f, M) => a.ids.includes(f.id) ? [M] : []), g = e.edges.slice(i[0], i[i.length - 1] + 1).filter((f) => !a.ids.includes(f.id) && f.status !== "removed").map((f) => f.id);
+    o(
+      !g.length,
+      `Phase ${a.id} skips ${g.join(", ")}: a phase is a run of consecutive messages. Include it or split the phase.`,
+      a.line
+    );
+  }
+  if (e.wasOrder) {
+    const { ids: a, line: i } = e.wasOrder, g = (M) => e.edges.find((k) => k.id === M), f = (M) => e.warnings.push({ code: "was-order", message: M, line: i });
+    o(
+      e.layouts.some((M) => M.scope === "root" && M.algorithm === "sequence"),
+      "was-order gives the older order of a sequence diagram; use layout root sequence.",
+      i
+    ), o(new Set(a).size === a.length, "was-order lists a message twice.", i);
+    for (const M of a)
+      o(g(M)?.status !== "added", `${M} is added, so was-order can't list it.`, i), g(M) || f(`was-order lists ${M}, which is not a message. The panels skip it.`);
+    for (const M of e.edges)
+      M.status !== "added" && !a.includes(M.id) && f(`was-order leaves out ${M.id}, so the older panel keeps it on its new row.`);
+  }
+  for (const a of e.edges)
+    for (const i of [a.source, a.target]) {
+      r(i, a.line);
+      const g = t.get(i), f = i === a.source ? a.target : a.source;
+      o(
+        !c || g.type === "node",
+        `A message joins participants, and ${i} is a group. End ${a.id} on one of its participants.`,
+        a.line
+      ), o(
+        g.type === "node" || !g.frame,
+        `${i} is a ${g.frame} group, which has no frame for a line to end on. Connect to one of its members, or use frame=box.`,
+        a.line
+      );
+      let M = !1;
+      for (let k = t.get(f)?.parent; k && k !== "root"; k = t.get(k)?.parent)
+        k === i && (M = !0);
+      o(
+        !M,
+        `${f} is inside ${i}, so a line between them has nowhere to go.`,
+        a.line
+      );
+    }
+  (e.appearance.notes ?? []).forEach((a, i) => {
+    if (!(!a.near || t.has(a.near))) {
+      if (!y.has(a.near)) return r(a.near, e.noteLines[i]);
+      o(
+        c,
+        `near=${a.near} names a connection. Only a sequence diagram anchors a note to a message; use a node or group here.`,
+        e.noteLines[i]
+      );
+    }
+  });
+  const l = new Set(e.edges.map((a) => a.id));
+  for (const a of e.appearance.states ?? [])
+    for (const i of a.ids) {
+      const g = e.stateLines.get(`${a.id}:${i}`);
+      o(
+        t.has(i) || l.has(i),
+        `Unknown node, group or edge ${i} in state ${a.id}.`,
+        g
+      );
+    }
+  const u = new Map(e.layouts.filter((a) => a.algorithm === "cells").map((a) => [a.scope, a]));
+  for (const a of e.objects) {
+    const i = u.get(a.parent);
+    i ? (o(
+      a.type === "node",
+      `Cells are nodes; ${a.id} is a group inside cells ${a.parent}.`,
+      a.line
+    ), o(
+      a.shape !== "marker" || (i.columns ?? 0) <= 1 && !i.unit,
+      i.unit ? `A marker cuts a sequence of cells; ${a.parent} is a ${i.unit} layout.` : `A marker cuts one row or column of cells; ${a.parent} has ${i.columns} columns.`,
+      a.line
+    ), o(
+      a.span !== "var" || !!i.unit,
+      `span=var is for a byte or bit layout; give ${a.parent} unit=byte or unit=bit.`,
+      a.line
+    )) : (o(
+      a.shape !== "marker",
+      `A marker sits between cells; put ${a.id} in a group with layout cells.`,
+      a.line
+    ), o(a.span === void 0, `span= is for cells; ${a.parent} has no layout cells.`, a.line));
+  }
+  for (const a of e.layouts) {
+    d(a.scope, a.line), s(a.scope, a.line, "layout");
+    const i = a.engine?.params.rootId;
+    i && (r(i, a.line), o(t.get(i).type === "node", `The tree root ${i} must be a node.`, a.line));
+  }
+  for (const a of e.hints)
+    if (a.type === "order") {
+      d(a.scope, a.line), s(a.scope, a.line, "layout");
+      for (const i of a.ids)
+        r(i, a.line), s(i, a.line, "position"), o(n(i) === a.scope, `${i} is not a direct child of ${a.scope}.`, a.line);
+    } else if (a.type === "align") {
+      a.ids.forEach((g) => r(g, a.line)), a.ids.forEach((g) => s(g, a.line, "position")), o(new Set(a.ids).size === a.ids.length, "Duplicate member in align.", a.line);
+      const i = n(a.ids[0]);
+      o(
+        a.ids.every((g) => n(g) === i),
+        "Members of align must be direct siblings.",
+        a.line
+      );
+    } else
+      r(a.id, a.line), s(a.id, a.line, "position"), a.type === "near" && (r(a.ref, a.line), s(a.ref, a.line, "position"), o(
+        Vt(t, a.id, a.ref) !== void 0,
+        `Relative placement is between siblings, or with something inside a sibling group. ${a.id} is inside ${n(a.id)}; place ${n(a.id)} relative to ${a.ref} instead.`,
+        a.line
+      )), a.type === "size" && o(
+        t.get(a.id).type === "node",
+        "Use layout min-width/min-height to reserve room in a group.",
+        a.line
+      );
+}
+const $t = { width: 1100, height: 720 }, ft = 12, ei = 56, Dn = 24, Nn = 0, ti = 56, Pn = { w: 260, h: 110 }, Fn = (e, t) => Math.max(t.x - e.x - e.w, e.x - t.x - t.w, t.y - e.y - e.h, e.y - t.y - t.h), re = (e) => Math.round(e);
+function ni(e) {
+  if (!e.appearance.compare || !e.edges.some((n) => n.was)) return e;
+  const t = ut(e.appearance), s = (n) => n ? Je(n, t).w : 0;
+  return {
+    ...e,
+    edges: e.edges.map((n) => n.was && s(n.was) > s(n.label) ? { ...n, label: n.was } : n)
+  };
+}
+function oi(e, t) {
+  if (e.model.edges === t.edges) return e;
+  const s = new Map(t.edges.map((n) => [n.id, n.label]));
+  return {
+    ...e,
+    model: { ...e.model, edges: t.edges },
+    edges: e.edges.map((n) => ({ ...n, label: s.get(n.id) }))
+  };
+}
+function si(e) {
+  const t = Zs(e), s = hi(t);
+  return fi(
+    mo(mi(oi(tn(ni(s)), s), t))
+  );
+}
+const ii = 24, ai = 0, Cn = 36, ri = 40, ci = 16, jn = 8, $e = 16, tt = 20, Bn = 8, li = 104;
+function di(e, t) {
+  const s = Math.ceil(ye(e.label, t.title));
+  if (e.label.includes(`
+`) || Ot(e.shape, e.w, e.h, t).width < s) return e.w;
+  let n = li;
+  for (; n < e.w && Ot(e.shape, n, e.h, t).width < s; ) n += 4;
+  return Math.min(n, e.w);
+}
+function mo(e) {
+  if (!e.model.layouts.some((I) => I.scope === "root" && I.algorithm === "sequence"))
+    return e;
+  const t = e.look, s = new Set(e.model.hints.flatMap((I) => I.type === "size" ? [I.id] : [])), n = e.objects.filter((I) => I.type === "node"), o = e.objects.filter((I) => I.type === "group");
+  if (!n.length) return e;
+  const r = (I, O) => {
+    const C = e.model.hints.find((oe) => oe.type === "order" && oe.scope === I), V = C?.type === "order" ? C.ids : [];
+    return [...V, ...O.filter((oe) => !V.includes(oe))];
+  }, d = [...new Set(n.map((I) => I.parent === "root" ? I.id : I.parent))], c = r("root", d).flatMap(
+    (I) => e.byId.get(I).type === "node" ? [I] : r(
+      I,
+      n.filter((O) => O.parent === I).map((O) => O.id)
+    )
+  ).map((I) => e.byId.get(I)).map((I) => s.has(I.id) ? I : { ...I, w: di(I, t) }), y = new Map(c.map((I, O) => [I.id, O])), w = e.model.phases.length ? Math.max(...e.model.phases.map((I) => ye(I.label, t.annotation))) + 2 * $e : 0, l = o.length ? t.groupHeader : 0, u = (I) => c[I - 1].parent !== c[I].parent, a = !!e.model.appearance.compare, i = (I) => [I.label, a ? I.was : ""].filter((O) => !!O), g = (I) => {
+    const O = i(I).map((C) => Je(C, t, !0));
+    return { w: Math.max(0, ...O.map((C) => C.w)), h: Math.max(0, ...O.map((C) => C.h)) };
+  }, f = (I) => {
+    const O = i(I).map((C) => Mn(C, t));
+    return O.length ? {
+      right: Math.max(...O.map((C) => C.right)),
+      above: Math.max(...O.map((C) => C.above)),
+      below: Math.max(...O.map((C) => C.below))
+    } : Mn(void 0, t);
+  }, M = /* @__PURE__ */ new Map(), k = c.map(() => []);
+  for (const I of e.edges) {
+    const [O, C] = [y.get(I.source), y.get(I.target)].sort((oe, ae) => oe - ae);
+    if (O < C) {
+      const { w: oe } = g(I);
+      oe && k[C].push({ from: O, room: oe + ci });
+      continue;
+    }
+    const { right: V } = f(I);
+    M.set(I.source, Math.max(M.get(I.source) ?? 0, V)), O + 1 < c.length && k[O + 1].push({
+      from: O,
+      room: V + jn + (u(O + 1) ? 2 * $e + c[O + 1].w / 2 : 0)
+    });
+  }
+  const S = [];
+  c.forEach((I, O) => {
+    if (!O) return void S.push(w + $e + I.w / 2);
+    const C = c[O - 1].w / 2 + ri + (u(O) ? 2 * $e : 0) + I.w / 2;
+    S.push(Math.max(S[O - 1] + C, ...k[O].map((V) => S[V.from] + V.room)));
+  });
+  let D = l + Math.max(0, ...c.map((I) => I.h)) - ai, _ = 0;
+  const $ = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map();
+  for (const I of e.edges) {
+    const O = g(I).h, C = I.source === I.target ? f(I) : void 0, V = C ? C.above : O && O + 1;
+    D = Math.ceil(
+      Math.max(D + Math.max(Cn, O ? O + 8 : 0), _ + jn + V)
+    ), $.set(I.id, D), _ = C ? D + C.below : 0, x.set(I.id, { from: D - Math.max(O, Cn / 2) - 4, to: Math.max(D, _) + 8 }), C && (D += We.down);
+  }
+  const E = Math.max(D, _) + ii, v = new Map(
+    c.map((I) => {
+      const O = re(S[y.get(I.id)] - I.w / 2);
+      return [I.id, { x: O, w: I.w }];
+    })
+  ), p = (I) => Math.max(v.get(I.id).x + I.w, S[y.get(I.id)] + (M.get(I.id) ?? 0)), A = e.objects.map((I) => {
+    if (I.type === "group") {
+      const V = c.filter((le) => le.parent === I.id), oe = re(Math.min(...V.map((le) => v.get(le.id).x)) - $e), ae = re(Math.max(...V.map((le) => p(le))) + $e - oe);
+      return {
+        ...I,
+        shade: I.shade ?? 50,
+        x: oe,
+        y: 0,
+        w: ae,
+        h: E + $e,
+        localX: oe,
+        localY: 0,
+        baseX: oe,
+        baseY: 0
+      };
+    }
+    const { x: O, w: C } = v.get(I.id);
+    return {
+      ...I,
+      w: C,
+      x: O,
+      y: l,
+      localX: O,
+      localY: l,
+      baseX: O,
+      baseY: l,
+      lifeline: E - l - I.h
+    };
+  }), m = Math.min(0, ...A.map((I) => I.x)) - (w ? 0 : $e), b = Math.max(
+    ...A.map((I) => I.x + I.w + $e),
+    ...c.map((I) => S[y.get(I.id)] + (M.get(I.id) ?? 0))
+  ), T = {
+    x: m - tt,
+    y: -tt,
+    w: b - m + 2 * tt,
+    h: E + $e + 2 * tt
+  }, P = e.model.appearance.notes ?? [], X = new Map([...$].filter(([I]) => !e.byId.has(I))), B = gs(t, P, X, {
+    left: m - (w ? tt : Bn),
+    right: b + Bn,
+    top: 0
+  }), G = B.filter((I) => I !== null), F = G.length ? wn([T, wn(G, tt)]) : T, L = F.x < T.x ? T.x : void 0, N = e.model.phases.map((I) => {
+    const O = I.ids.map((C) => x.get(C));
+    return {
+      id: I.id,
+      label: I.label,
+      from: re(Math.min(...O.map((C) => C.from))),
+      to: re(Math.max(...O.map((C) => C.to)))
+    };
+  }).sort((I, O) => I.from - O.from), z = N.map(({ id: I, label: O, from: C, to: V }, oe) => ({
+    id: I,
+    label: O,
+    y: C,
+    h: Math.min(V, N[oe + 1]?.from ?? V) - C
+  }));
+  return {
+    ...e,
+    objects: A,
+    byId: new Map(A.map((I) => [I.id, I])),
+    edges: e.edges.map((I) => ({ ...I, lane: void 0, row: $.get(I.id) })),
+    sequence: {
+      panel: F,
+      phases: z,
+      ...L !== void 0 ? { phaseX: L } : {},
+      ...G.length ? { notes: B, inner: T } : {}
+    }
+  };
+}
+function fi(e) {
+  const t = e.model.wasOrder?.ids.flatMap((r) => e.edges.filter((d) => d.id === r));
+  if (!t || !e.sequence) return e;
+  const s = [...t], n = mo({
+    ...e,
+    edges: e.edges.map((r) => t.includes(r) ? s.shift() : r)
+  }), o = (r) => r.objects.find((d) => d.type === "node")?.lifeline ?? 0;
+  return {
+    ...e,
+    sequence: {
+      ...e.sequence,
+      before: {
+        rows: Object.fromEntries(n.edges.map((r) => [r.id, r.row])),
+        phases: n.sequence.phases,
+        grow: Math.max(0, o(n) - o(e))
+      }
+    }
+  };
+}
+function hi(e) {
+  if (!e.objects.some((n) => n.frame)) return e;
+  const t = new Map(e.objects.map((n) => [n.id, n])), s = (n) => {
+    const o = [];
+    for (let r = t.get(n).parent; r !== "root" && t.get(r).frame; r = t.get(r).parent)
+      o.unshift(r);
+    return o;
+  };
+  return {
+    ...e,
+    objects: e.objects.filter((n) => !n.frame).map((n) => ({ ...n, parent: st(t, n.id), soft: s(n.id) }))
+  };
+}
+function an(e, t, s = 0) {
+  if (!e.some((o) => t(o)?.[s])) return e;
+  const n = /* @__PURE__ */ new Map();
+  return e.forEach((o, r) => {
+    const d = t(o)?.[s] ?? `\0${o}`, h = n.get(d) ?? { at: 0, ids: [] };
+    h.at += r, h.ids.push(o), n.set(d, h);
+  }), [...n].sort(([, o], [, r]) => o.at / o.ids.length - r.at / r.ids.length).flatMap(([o, r]) => o.startsWith("\0") ? r.ids : an(r.ids, t, s + 1));
+}
+const ui = 8;
+function Dt(e = [], t = [], s) {
+  const n = e.filter((r) => !t.includes(r)).length, o = t.filter((r) => !e.includes(r)).length;
+  return !n && !o ? 0 : (n + o) * dt + (s && o ? Lt : 0) + ui;
+}
+function wo(e, t, s, n) {
+  const o = new Set(e.flatMap((c) => s(c) ?? [])), r = (c, y) => (s(c) ?? []).filter((w) => !y.has(w)), d = new Set(t.flatMap((c) => s(c) ?? []));
+  let h = 0;
+  for (const c of e)
+    for (const y of t) h = Math.max(h, Dt(r(c, d), r(y, o), n));
+  return h;
+}
+const kt = (e, t) => e.x < t.x + t.w && e.x + e.w > t.x && e.y < t.y + t.h && e.y + e.h > t.y, pi = (e, t) => ({
+  x: e.x - t,
+  y: e.y - t,
+  w: e.w + 2 * t,
+  h: e.h + 2 * t
+});
+function gi(e, t) {
+  const s = Math.max(e.x, t.x), n = Math.min(e.x + e.w, t.x + t.w), o = Math.max(e.y, t.y), r = Math.min(e.y + e.h, t.y + t.h);
+  if (n > s) {
+    const c = Math.min(e.y + e.h, t.y + t.h);
+    return { x: s, y: c, w: n - s, h: Math.max(e.y, t.y) - c };
+  }
+  if (r > o) {
+    const c = Math.min(e.x + e.w, t.x + t.w);
+    return { x: c, y: o, w: Math.max(e.x, t.x) - c, h: r - o };
+  }
+  const d = Math.min(e.x, t.x), h = Math.min(e.y, t.y);
+  return { x: d, y: h, w: Math.max(e.x + e.w, t.x + t.w) - d, h: Math.max(e.y + e.h, t.y + t.h) - h };
+}
+function mi(e, t) {
+  const s = t.objects.filter((l) => l.frame);
+  if (!s.length) return e;
+  const n = new Map(t.objects.map((l) => [l.id, l])), o = new Map(
+    e.objects.map((l) => [l.id, { ...l, parent: n.get(l.id).parent, soft: void 0 }])
+  ), r = [...e.diagnostics], d = (l, u) => {
+    for (let a = n.get(l)?.parent; a && a !== "root"; a = n.get(a)?.parent)
+      if (a === u) return !0;
+    return !1;
+  }, h = (l) => {
+    let u = 0;
+    for (let a = n.get(l).parent; a !== "root"; a = n.get(a).parent) u++;
+    return u;
+  }, c = (l) => l.frame === "soft" ? (l.hull ?? []).map((u) => ({ ...u, x: u.x + l.x, y: u.y + l.y })) : l.frame ? [] : [l];
+  for (const l of [...s].sort((u, a) => h(a.id) - h(u.id))) {
+    const u = [...o.values()].filter((v) => d(v.id, l.id)), a = o.get(st(n, l.id)), i = a ? so(a, _t(e.look, a.titleLines)) : { x: 0, y: 0 }, g = [...o.values()].filter(
+      (v) => !v.frame && !d(v.id, l.id) && !d(l.id, v.id)
+    ), f = u.flatMap((v) => c(v).map((p) => pi(p, dt)));
+    let M = [], k = 0;
+    if (f.length) {
+      const v = f.reduce((B, G) => G.y < B.y || G.y === B.y && G.x < B.x ? G : B);
+      v.y -= Lt, v.h += Lt, M = [v, ...f.filter((B) => B !== v)];
+      const p = Math.min(...M.map((B) => B.x)), A = Math.min(...M.map((B) => B.y)), m = {
+        x: p,
+        y: A,
+        w: Math.max(...M.map((B) => B.x + B.w)) - p,
+        h: Math.max(...M.map((B) => B.y + B.h)) - A
+      };
+      g.some((B) => kt(B, m)) || (M = [m]);
+      const b = (B, G) => Math.max(G.x - (B.x + B.w), B.x - (G.x + G.w), G.y - (B.y + B.h), B.y - (G.y + G.h), 0), T = [M[0]], P = M.slice(1), X = [];
+      for (; P.length; ) {
+        let B = { gap: 1 / 0, a: M[0], i: 0 };
+        for (const L of T)
+          P.forEach((N, z) => {
+            const I = b(L, N);
+            I < B.gap && (B = { gap: I, a: L, i: z });
+          });
+        const [G] = P.splice(B.i, 1);
+        if (T.push(G), kt(B.a, G)) continue;
+        const F = gi(B.a, G);
+        g.some((L) => kt(L, F)) ? k++ : X.push(F);
+      }
+      M.push(...X);
+    }
+    const S = M.length ? Math.min(...M.map((v) => v.x)) : i.x, D = M.length ? Math.min(...M.map((v) => v.y)) : i.y, _ = M.length ? Math.max(...M.map((v) => v.x + v.w)) : i.x, $ = M.length ? Math.max(...M.map((v) => v.y + v.h)) : i.y, x = { x: S - i.x, y: D - i.y };
+    if (o.set(l.id, {
+      ...l,
+      x: S,
+      y: D,
+      w: _ - S,
+      h: $ - D,
+      localX: x.x,
+      localY: x.y,
+      baseX: x.x,
+      baseY: x.y,
+      depth: h(l.id),
+      hull: M.map((v) => ({ x: v.x - S, y: v.y - D, w: v.w, h: v.h }))
+    }), l.frame !== "soft") continue;
+    const E = g.filter((v) => M.some((p) => kt(v, p)));
+    E.length && r.push({
+      level: "warning",
+      code: "soft-overlap",
+      message: `${l.id}'s tint covers ${E.map((v) => v.id).join(", ")}, which ${E.length > 1 ? "are" : "is"} not in it. Place its members together, or use frame=box.`,
+      line: l.line,
+      ids: [l.id, ...E.map((v) => v.id)]
+    }), k && r.push({
+      level: "info",
+      code: "soft-split",
+      message: `${l.id}'s members are apart, so its tint is drawn in ${k + 1} pieces. Place its members together, or use frame=box.`,
+      line: l.line,
+      ids: [l.id]
+    });
+  }
+  const y = new Map(t.objects.map((l, u) => [l.id, u])), w = [...o.values()].sort((l, u) => y.get(l.id) - y.get(u.id));
+  return { ...e, model: t, objects: w, byId: new Map(w.map((l) => [l.id, l])), diagnostics: r };
+}
+const Un = 4, wi = /* @__PURE__ */ new Set(["slate", "stone"]);
+function yi(e) {
+  const t = [], s = e.objects.filter((d) => d.color !== "auto"), n = [...new Set(s.map((d) => d.color))].filter((d) => !wi.has(d));
+  n.length > Un && t.push({
+    level: "info",
+    code: "many-colors",
+    message: `${n.length} accent colors (${n.join(", ")}). Use two to four, each for one role, with slate or stone for the rest, and say what each one means with legend lines.`,
+    line: s.find((d) => d.color === n[Un])?.line,
+    ids: s.filter((d) => n.includes(d.color)).map((d) => d.id)
+  });
+  const o = new Map(e.objects.map((d) => [d.id, d])), r = s.filter((d) => o.get(d.parent)?.color === d.color);
+  return r.length && t.push({
+    level: "info",
+    code: "color-matches-container",
+    message: `${r.map((d) => d.id).join(", ")} ${r.length > 1 ? "repeat their containers’ colors" : "repeats its container’s color"}. Drop the color to inherit it, or give the member a family of its own.`,
+    line: r[0].line,
+    ids: r.map((d) => d.id)
+  }), t;
+}
+function nt(e) {
+  return e.direction !== "auto" ? e.direction : "right";
+}
+function Mi(e, t) {
+  const s = new Map(e.objects.map((n) => [n.id, n.parent]));
+  for (let n = t; n; n = n === "root" ? void 0 : s.get(n)) {
+    const o = e.layouts.find((r) => r.scope === n);
+    if (o) return n === t || o.engine ? o : void 0;
+  }
+}
+const xi = 240, bi = 1.25;
+function vi(e, t, s) {
+  const n = Math.ceil(ye(e, s.groupTitle)) + Xt;
+  let o = Math.max(t, xi);
+  if (n <= o * bi) return { w: n, lines: 1 };
+  const r = () => it(e, o - Xt, s.groupTitle, !0).length;
+  for (; r() > yn && o < n; ) o += 8;
+  return { w: Math.min(o, n), lines: Math.min(r(), yn) };
+}
+const zn = 16, ki = 1.5, Pe = 14;
+function Bt(e, t, s, n) {
+  const o = Je(s, n);
+  return { a: e, b: t, w: o.w + 2 * Pe, h: o.h + 2 * Pe };
+}
+function Jt(e, t, s, n, o) {
+  let r = n;
+  for (const d of e)
+    (d.a === t && d.b === s || d.a === s && d.b === t) && (r = Math.max(r, o ? d.w : d.h));
+  return r;
+}
+function Ut(e, t) {
+  return e.layouts.find((s) => s.scope === t) ?? {
+    scope: t,
+    algorithm: t === "root" ? "flow" : "column",
+    direction: "auto",
+    fold: "auto",
+    gap: t === "root" ? 48 : 24,
+    minWidth: 0,
+    minHeight: 0,
+    line: 0
+  };
+}
+const qn = 2;
+function Ei(e, t, s) {
+  const n = e.label.includes(`
+`) && e.shape !== "circle" ? e.label.split(`
+`) : [], o = (y) => y ? s.detail : s.title, r = e.label.split(`
+`)[0], d = e.label.slice(r.length + 1), h = Math.max(
+    qt(r, s.title),
+    d ? qt(d, s.detail) : 0,
+    ...n.map((y, w) => ye(y, o(w)))
+  );
+  let c = t.w;
+  for (; Ot(e.shape, c, t.h, s).width < h && c < t.w * qn; ) c += 4;
+  return Math.min(c, t.w * qn);
+}
+function Et(e, t, s) {
+  const n = io(e.shape);
+  if (e.shape === "diamond") return Ai(e, t, n, s);
+  const o = t?.width ?? Ei(e, n, s), r = Ot(e.shape, o, t?.height ?? n.h, s), d = gt(pt(e.label, r.width, s), s);
+  return t?.height !== void 0 ? { w: o, h: t.height, overflow: d > r.maxHeight + 0.5 } : {
+    w: o,
+    h: Math.max(
+      Ko(e.shape, d, e.shape === "circle" ? n.h : 0, s),
+      t?.minHeight ?? 0
+    ),
+    overflow: !1
+  };
+}
+function Ai(e, t, s, n) {
+  const o = qt(e.label, n.title), r = (h) => (Zo(e.label, h, n) ?? 0) >= o;
+  if (t) {
+    const h = Math.max(t.width, t.height ?? t.minHeight ?? 0);
+    return { w: h, h, overflow: !r(h) };
+  }
+  let d = s.w;
+  for (; !r(d); ) d += 4;
+  return { w: d, h: d, overflow: !1 };
+}
+const Si = 1.4;
+function ht(e, t) {
+  const s = new Map(e.map((u) => [u, []]));
+  for (const [u, a] of t)
+    u !== a && s.has(u) && s.has(a) && !s.get(u).includes(a) && s.get(u).push(a);
+  const n = new Set([...s.values()].flat()), o = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), d = (u) => {
+    o.set(u, "open");
+    for (const a of s.get(u))
+      o.get(a) === "open" ? r.add(u + "\0" + a) : o.has(a) || d(a);
+    o.set(u, "done");
+  };
+  for (const u of [...e.filter((a) => !n.has(a)), ...e]) o.has(u) || d(u);
+  const h = new Map(e.map((u) => [u, 0])), c = new Map(e.map((u) => [u, 0])), y = (u) => s.get(u).filter((a) => !r.has(u + "\0" + a));
+  for (const u of e) for (const a of y(u)) h.set(a, h.get(a) + 1);
+  const w = e.filter((u) => !h.get(u));
+  for (; w.length; ) {
+    const u = w.shift();
+    for (const a of y(u))
+      c.set(a, Math.max(c.get(a), c.get(u) + 1)), h.set(a, h.get(a) - 1), h.get(a) || w.push(a);
+  }
+  const l = [];
+  for (const u of e) (l[c.get(u)] ||= []).push(u);
+  return l.filter(Boolean);
+}
+const yo = 3, Gn = 5, Hn = 1.25, Qe = 20, _i = 3, Ii = 2, Ti = 1;
+function Ri(e, t) {
+  const s = new Map(e.map((h) => [h, []]));
+  for (const [h, c] of t) s.get(h)?.push(c);
+  const n = (h) => {
+    const c = /* @__PURE__ */ new Set([h]), y = [h];
+    for (; y.length; )
+      for (const w of s.get(y.shift()) ?? [])
+        c.has(w) || (c.add(w), y.push(w));
+    return c;
+  }, o = new Map(e.map((h) => [h, n(h)])), r = [], d = /* @__PURE__ */ new Set();
+  for (const h of e) {
+    if (d.has(h)) continue;
+    const c = e.filter((y) => o.get(h).has(y) && o.get(y).has(h));
+    c.forEach((y) => d.add(y)), c.length > 1 && r.push(c);
+  }
+  return r;
+}
+function zt(e, t, s, n, o, r = [], d = /* @__PURE__ */ new Set(), h = t, {
+  aspect: c = yo,
+  fewest: y = 4,
+  room: w = s === "right" ? $t.width : $t.height
+} = {}) {
+  const l = new Map(e.map((F) => [F.id, F])), u = s === "right" ? "x" : "y", a = s === "right" ? "y" : "x", i = (F, L) => L === "x" ? F.w : F.h, g = (F) => {
+    const L = [...e].sort((z, I) => F.get(z.id)[u] - F.get(I.id)[u]), N = [];
+    for (const z of L) {
+      const I = F.get(z.id)[u], O = I + i(z, u), C = N[N.length - 1];
+      C && I < C.end ? (C.end = Math.max(C.end, O), C.ids.push(z.id)) : N.push({ start: I, end: O, ids: [z.id] });
+    }
+    return N;
+  }, f = g(t);
+  let M = g(h);
+  const k = (F) => F.map((L) => [...L.ids].sort().join(",")).join("|");
+  k(M) !== k(f) && (h = t, M = f);
+  const S = (F, L) => {
+    const N = Math.min(...e.map((I) => F.get(I.id)[L]));
+    return Math.max(...e.map((I) => F.get(I.id)[L] + i(I, L))) - N;
+  }, D = (F, L, N = 1) => F <= w * N || F <= c * L * N, _ = (F) => D(S(F, u), S(F, a)), $ = (F) => _(F) || S(F, u) <= w * Hn;
+  if (e.length < y || _(h) && $(t)) return { positions: t };
+  const x = new Map(f.flatMap((F, L) => F.ids.map((N) => [N, L]))), E = (F, L, N) => {
+    const [z, I] = [x.get(L), x.get(N)];
+    return z !== void 0 && I !== void 0 && Math.min(z, I) < F && Math.max(z, I) >= F;
+  }, v = (F) => o.filter(([L, N]) => E(F, L, N)).length, p = Ri(
+    e.map((F) => F.id),
+    o
+  ), A = (F) => _i * [...d].filter((L) => o.some((N) => N[0] === L && E(F, ...N))).length + Ii * p.filter((L) => L.some((N) => E(F, L[0], N))).length, m = (F, L) => {
+    const N = (L ? r : []).filter((z) => E(F, z.a, z.b)).map((z) => (s === "right" ? z.h : z.w) - 2 * Pe);
+    return Math.max(
+      n + 40,
+      84,
+      N.length ? Math.max(...N) + 2 * Pe : 0,
+      (v(F) + 1) * Qe + N.reduce((z, I) => z + I, 0)
+    );
+  }, b = (F, L) => {
+    const N = L[L.length - 1].end - L[0].start, z = [], I = new Map(L.flatMap((O) => O.ids.map((C) => [C, O.start])));
+    for (let O = 1; O < F; O++) {
+      const C = (te) => o.filter((Me) => E(te, ...Me)).reduce((Me, [R, j]) => {
+        const [q, W] = x.get(R) < x.get(j) ? [R, j] : [j, R];
+        return Me + Math.abs(I.get(q) - ae - (I.get(W) - L[te].start));
+      }, 0) / (N / F), V = L[0].start + N * O / F, oe = (te) => v(te) + A(te) + C(te) * Ti + Math.abs(L[te].start - V) / (N / F) * 2, ae = L[z.at(-1) ?? 0].start, le = N / F, he = (te, Me, R) => L[te - 1].end - ae >= le * R && L[te - 1].end - ae <= le * (1 + Me) && L[L.length - 1].end - L[te].start <= le * (F - O) * (1 + Me), we = (te) => !A(te) && he(te, 0.25, 0.5) ? 0 : !A(te) && he(te, 0.5, 0) ? 1 : he(te, 0.25, 0.5) ? 2 : 3;
+      let fe = 0;
+      for (let te = (z.at(-1) ?? 0) + 1; te < L.length; te++)
+        (!fe || we(te) < we(fe) || we(te) === we(fe) && oe(te) < oe(fe)) && (fe = te);
+      fe && z.push(fe);
+    }
+    return z;
+  }, T = new Set(
+    f.flatMap(
+      (F) => F.ids.length > 1 ? F.ids.filter((L) => !o.some(([N, z]) => N === L && z !== L)) : []
+    )
+  ), P = (F, L) => {
+    const N = [];
+    return L.forEach((z, I) => I === 0 || F.includes(I) ? N.push([z]) : N.at(-1).push(z)), N;
+  }, X = (F, L) => {
+    const N = P(F, L), z = new Map(N.flatMap((C, V) => C.flatMap((oe) => oe.ids.map((ae) => [ae, V])))), I = new Map(L.flatMap((C) => C.ids.map((V) => [V, C.start]))), O = /* @__PURE__ */ new Map();
+    for (const [C, V] of N.entries()) {
+      if (!C) continue;
+      const oe = [];
+      for (const ae of V[0].ids) {
+        if (d.has(ae)) continue;
+        const le = o.filter(([R, j]) => j === ae && R !== ae).map(([R]) => R), he = o.filter(([R, j]) => R === ae && j !== ae).map(([, R]) => R);
+        if (!le.length || le.some((R) => z.get(R) !== C - 1)) continue;
+        const we = (R, j) => I.get(R) - N[j][0].start, fe = (R) => le.reduce((j, q) => j + Math.abs(we(q, C - 1) - we(ae, R)), 0) + he.reduce((j, q) => j + Math.abs(we(ae, R) - we(q, z.get(q))), 0), te = (R) => (R === C - 1 ? 0 : le.length) + he.filter((j) => z.get(j) !== R).length;
+        if (te(C - 1) > te(C) || fe(C - 1) >= fe(C)) continue;
+        const Me = le.reduce((R, j) => I.get(j) > I.get(R) ? j : R);
+        oe.push({ id: ae, source: Me, saves: fe(C) - fe(C - 1) });
+      }
+      oe.sort((ae, le) => le.saves - ae.saves);
+      for (const ae of oe.slice(0, V[0].ids.length - 1)) O.set(ae.id, ae.source);
+    }
+    return O;
+  }, B = (F, L, N, z, I = /* @__PURE__ */ new Map()) => {
+    const O = P(F, L);
+    if (I.size) {
+      N = new Map(N);
+      const he = [];
+      for (const [we, fe] of I) {
+        const te = l.get(we);
+        let R = N.get(fe)[a] + (i(l.get(fe), a) - i(te, a)) / 2;
+        for (const j of he) R < j.hi + n && R + i(te, a) > j.lo && (R = j.hi + n);
+        he.push({ lo: R, hi: R + i(te, a) }), N.set(we, { ...N.get(we), [a]: R });
+      }
+    }
+    const C = /* @__PURE__ */ new Map(), V = [];
+    let oe = 0, ae = 0, le = 0;
+    for (const [he, we] of O.entries()) {
+      const fe = O[he + 1]?.[0].ids ?? [], te = [
+        ...we.flatMap((Y) => Y.ids).filter((Y) => !I.has(Y)),
+        ...fe.filter((Y) => I.has(Y))
+      ], Me = Math.min(...te.map((Y) => N.get(Y)[u])), R = Math.min(...te.map((Y) => N.get(Y)[a])), j = Math.max(...te.map((Y) => N.get(Y)[a] + i(l.get(Y), a)));
+      for (const Y of te) {
+        const H = N.get(Y), J = H[u] - Me, se = H[a] - R + oe;
+        C.set(Y, s === "right" ? { x: J, y: se } : { x: se, y: J });
+      }
+      const q = he < F.length ? m(F[he], z) : 0, W = te.filter((Y) => !T.has(Y)), ee = W.length ? W : te;
+      oe += j - R + q, le += Math.max(...ee.map((Y) => N.get(Y)[a] + i(l.get(Y), a))) - Math.min(...ee.map((Y) => N.get(Y)[a])) + q, ae = Math.max(
+        ae,
+        Math.max(...te.map((Y) => N.get(Y)[u] + i(l.get(Y), u))) - Me
+      ), V.push(te);
+    }
+    return {
+      out: C,
+      length: ae,
+      // The depth that decides the count leaves side leaves out.
+      depth: le,
+      count: O.length,
+      bands: V
+    };
+  };
+  let G = 0;
+  if (!_(h))
+    for (let F = 2; F <= f.length && !G; F++) {
+      const L = B(b(F, M), M, h, !1);
+      L.count === F && D(L.length, L.depth) && (G = F);
+    }
+  for (let F = Math.max(2, G); F <= f.length; F++) {
+    const L = b(F, M), N = B(L, f, t, !0), z = F === G ? Hn : 1;
+    if (N.count !== F || !D(N.length, N.depth, z)) continue;
+    const I = X(L, M), O = I.size ? B(L, f, t, !0, I) : void 0, C = O && D(O.length, O.depth, z) ? O : N;
+    return { positions: C.out, fold: { bands: C.bands, axis: s } };
+  }
+  return { positions: t };
+}
+function Li(e, t, s, n, o) {
+  const r = /* @__PURE__ */ new Map();
+  for (const { scope: d, fold: h } of e) {
+    const c = h.axis === "right", y = (S) => c ? S.y : S.x, w = (S) => c ? S.y + S.h : S.x + S.w, l = (S) => c ? S.x : S.y, u = (S) => c ? S.x + S.w : S.y + S.h, a = (S) => (l(S) + u(S)) / 2, i = (S) => (y(S) + w(S)) / 2, g = (S, D) => l(S) < u(D) && u(S) > l(D), f = new Map(h.bands.flatMap((S, D) => S.map((_) => [_, D]))), M = (S) => f.get(n(S.id, d) ?? ""), k = (S) => [...s.values()].filter((D) => D.type !== "group" && M(D) === S);
+    for (let S = 0; S + 1 < h.bands.length; S++) {
+      const D = h.bands[S].map((G) => s.get(G)), _ = h.bands[S + 1].map((G) => s.get(G)), $ = Math.max(...D.map(w)), x = Math.min(..._.map(y)), E = Math.max(...D.map(u)) + Qe, v = Math.min(..._.map(l)) - Qe, [p, A] = [k(S), k(S + 1)], m = t.flatMap((G) => {
+        const F = s.get(G.source), L = s.get(G.target);
+        if (M(F) !== S || M(L) !== S + 1) return [];
+        if (G.from !== "auto" || G.to !== "auto") return [];
+        const N = p.some((O) => y(O) > y(F) && g(O, F)), z = n(G.target, d) !== G.target || A.some((O) => y(O) < y(L) && g(O, L)), I = (O, C) => y(O) < w(C) && w(O) > y(C);
+        return N && p.some((O) => I(O, F) && l(O) >= u(F)) ? [] : z && A.some((O) => I(O, L) && u(O) <= l(L)) ? [] : [{ id: G.id, source: F, target: L, leave: N, enter: z }];
+      }), b = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map();
+      for (const G of m)
+        G.leave || T.set(G.source.id, [...T.get(G.source.id) ?? [], G]);
+      for (const G of T.values()) {
+        const F = (L) => Math.abs(a(L.target) - a(L.source)) + Math.abs(i(L.target) - i(L.source));
+        G.sort((L, N) => F(L) - F(N) || (L.id < N.id ? -1 : 1)), G.forEach((L, N) => {
+          const z = a(L.target) < a(L.source) ? -1 : 1, I = Math.ceil(N / 2) * o * (N % 2 ? z : -z);
+          b.set(L.id, a(L.source) + I);
+        });
+      }
+      if (!m.length || x - $ < (m.length + 1) * Qe) continue;
+      const P = (G) => {
+        const F = G.filter((N) => N.leave), L = G.filter((N) => N.enter);
+        return G.map((N, z) => ({
+          w: N,
+          at: re($ + (x - $) * (z + 1) / (G.length + 1)),
+          leave: N.leave ? re(E + Qe * F.indexOf(N)) : void 0,
+          enter: N.enter ? re(v - Qe * (L.length - 1 - L.indexOf(N))) : void 0
+        }));
+      }, X = (G) => P(G).map(({ w: F, at: L, leave: N, enter: z }) => [
+        ...N !== void 0 ? [
+          { u: u(F.source), v: i(F.source) },
+          { u: N, v: i(F.source) },
+          { u: N, v: L }
+        ] : [
+          { u: b.get(F.id), v: $ },
+          { u: b.get(F.id), v: L }
+        ],
+        ...z !== void 0 ? [
+          { u: z, v: L },
+          { u: z, v: i(F.target) },
+          { u: l(F.target), v: i(F.target) }
+        ] : [
+          { u: a(F.target), v: L },
+          { u: a(F.target), v: x }
+        ]
+      ]), B = $i(
+        [...m].sort((G, F) => a(F.source) - a(G.source)),
+        (G) => Oi(X(G))
+      );
+      for (const { w: G, at: F, leave: L, enter: N } of P(B))
+        r.set(G.id, {
+          ...c ? { y: F } : { x: F },
+          ...L !== void 0 ? { leave: L } : {},
+          ...N !== void 0 ? { enter: N } : {}
+        });
+    }
+  }
+  return r;
+}
+function Oi(e) {
+  const t = e.map((n) => n.slice(1).map((o, r) => [n[r], o]));
+  let s = 0;
+  for (let n = 0; n < t.length; n++)
+    for (let o = n + 1; o < t.length; o++)
+      for (const [r, d] of t[n])
+        for (const [h, c] of t[o]) {
+          const [y, w] = r.v === d.v && h.u === c.u ? [
+            [r, d],
+            [h, c]
+          ] : h.v === c.v && r.u === d.u ? [
+            [h, c],
+            [r, d]
+          ] : [];
+          if (!y || !w) continue;
+          const l = w[0].u, u = y[0].v;
+          l > Math.min(y[0].u, y[1].u) && l < Math.max(y[0].u, y[1].u) && u > Math.min(w[0].v, w[1].v) && u < Math.max(w[0].v, w[1].v) && s++;
+        }
+  return s;
+}
+function $i(e, t) {
+  if (e.length > 6) return e;
+  let s = e, n = t(e);
+  const o = (r, d) => {
+    if (n) {
+      if (!d.length) {
+        const h = t(r);
+        h < n && ([s, n] = [r, h]);
+        return;
+      }
+      d.forEach((h, c) => o([...r, h], [...d.slice(0, c), ...d.slice(c + 1)]));
+    }
+  };
+  return o([], e), s;
+}
+const Ge = 4;
+function Di(e, t, s) {
+  const n = t === "right" ? "x" : "y", o = t === "right" ? "y" : "x", r = (c, y) => y === "x" ? c.w : c.h, d = [], h = /* @__PURE__ */ new Set();
+  for (const c of s) {
+    let [y, w] = [e.get(c.a), e.get(c.b)];
+    if (!y || !w) continue;
+    w[n] < y[n] && ([y, w] = [w, y]);
+    const l = y[n] + r(y, n), u = w[n];
+    if (u <= l) continue;
+    const a = (t === "right" ? c.w : c.h) - 2 * Pe, i = (t === "right" ? c.h : c.w) - 2 * Pe, g = l - a / 2 - Ge, f = u + a / 2 + Ge, M = y[o] + r(y, o) / 2, k = w[o] + r(w, o) / 2, S = Math.min(M, k) + Ge, D = Math.max(M, k) - Ge;
+    if (D - S < i) continue;
+    const _ = [
+      ...[...e.values()].filter((v) => v[n] < f && v[n] + r(v, n) > g).map((v) => ({
+        lo: v[o] - Ge,
+        hi: v[o] + r(v, o) + Ge
+      })),
+      ...d.filter((v) => v.from < f && v.to > g)
+    ], $ = (v) => _.every((p) => v + i <= p.lo || v >= p.hi), x = (S + D - i) / 2, E = [S, x, ..._.map((v) => v.hi)].filter((v) => v >= S && v + i <= D && $(v)).sort((v, p) => Math.abs(v - x) - Math.abs(p - x))[0];
+    E !== void 0 && (h.add(c), d.push({ lo: E - Ge, hi: E + i + Ge, from: g, to: f }));
+  }
+  return h;
+}
+const Ni = 96, Pi = 1.25;
+function Fi(e, t, s, n, o) {
+  const r = new Map(e.flatMap((w, l) => w.map((u) => [u, l]))), d = (w) => !t.some(([l, u]) => l === w && u !== w), h = (w) => [
+    ...new Set(t.filter(([l, u]) => u === w && l !== w).map((l) => l[0]))
+  ], c = /* @__PURE__ */ new Set(), y = Math.max(...e.map(o));
+  for (const [w, l] of e.entries())
+    if (w)
+      for (const u of l) {
+        const a = h(u);
+        if (!s(u) || !d(u) || !a.length || a.some((M) => r.get(M) !== w - 1)) continue;
+        const i = [...new Set(t.filter(([M]) => a.includes(M)).map((M) => M[1]))].filter(
+          (M) => M !== u && r.get(M) === w
+        ), g = [u, ...i].filter(d).sort((M, k) => n(k) - n(M))[0], f = [...e[w - 1], ...l.filter((M) => c.has(M)), u];
+        o(f) > Pi * y || (i.some((M) => !d(M)) || g !== u) && c.add(u);
+      }
+  return c.size ? e.map((w, l) => [
+    ...w.filter((u) => !c.has(u)),
+    ...(e[l + 1] ?? []).filter((u) => c.has(u))
+  ]).filter((w) => w.length) : e;
+}
+function Ci(e, t, s, n, o, r, d = !1, h = [], c = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), w = () => {
+}) {
+  const l = new Map(e.map((L) => [L.id, L])), u = e.map((L) => L.id), a = s === "right", i = (L) => a ? l.get(L).w : l.get(L).h, g = (L) => a ? l.get(L).h : l.get(L).w, f = (L) => l.get(L).type === "group", M = (L) => a ? L.y + L.h / 2 : L.x + L.w / 2, k = new Set(n.flat()), S = (L) => {
+    const N = !k.size || k.has(L) ? [] : (c.get(L) ?? []).flatMap((I) => t.get(I) ?? []);
+    if (N.length) return N.reduce((I, O) => I + M(O), 0) / N.length;
+    const z = t.get(L);
+    return a ? z.y + l.get(L).h / 2 : z.x + l.get(L).w / 2;
+  }, D = (L, N) => Math.max(
+    Jt(o, L, N, f(L) || f(N) ? r.group : r.node, !a),
+    Dt(l.get(L).soft, l.get(N).soft, a)
+  ), _ = (L) => L.reduce((N, z, I) => N + g(z) + (I ? D(L[I - 1], z) : 0), 0), $ = Fi(
+    ht(u, n),
+    n,
+    d ? f : () => !1,
+    i,
+    _
+  ).map(
+    (L) => an(
+      [...L].sort((N, z) => S(N) - S(z) || u.indexOf(N) - u.indexOf(z)),
+      (N) => l.get(N).soft
+    )
+  ), x = new Map($.flatMap((L, N) => L.map((z) => [z, N]))), E = $.map(_), v = Math.max(...E), p = new Map(u.map((L) => [L, /* @__PURE__ */ new Set()])), A = new Map(u.map((L) => [L, /* @__PURE__ */ new Set()]));
+  for (const [L, N] of n)
+    x.get(N) > x.get(L) && (p.get(L).add(N), A.get(N).add(L));
+  const m = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
+  for (const [L, N] of $.entries()) {
+    let z = (v - E[L]) / 2, I = -1 / 0;
+    for (const [O, C] of N.entries()) {
+      const [V] = A.get(C), oe = A.get(C).size === 1 && p.get(V).size === 1, ae = oe ? w(V, C) : void 0, le = ae !== void 0 ? m.get(V) + ae : oe ? b.get(V) - g(C) / 2 : z, he = O ? Math.max(le, I + D(N[O - 1], C)) : le;
+      m.set(C, he), b.set(C, he + g(C) / 2), I = he + g(C), z = Math.max(z + g(C), I) + (N[O + 1] ? D(C, N[O + 1]) : 0);
+    }
+  }
+  const T = $.length === 1 && P($[0]);
+  function P(L) {
+    const N = L.map((C) => y.get(C));
+    if (L.length < 2 || N.some((C, V) => C === void 0 || V && C < N[V - 1]))
+      return !1;
+    const z = [];
+    let I = -1 / 0;
+    for (const [C, V] of L.entries()) {
+      const oe = N[C] - N[0] + g(L[0]) / 2 - g(V) / 2;
+      z.push(C ? Math.max(oe, I + D(L[C - 1], V)) : oe), I = z[C] + g(V);
+    }
+    const O = N.at(-1) - N[0] + (g(L[0]) + g(L.at(-1))) / 2;
+    return I - z[0] > Math.max(E[0] * 1.25, O + 1) ? !1 : (L.forEach((C, V) => m.set(C, z[V])), !0);
+  }
+  const X = Math.min(...m.values()), B = en($, h, o, s), G = /* @__PURE__ */ new Map();
+  let F = 0;
+  for (const [L, N] of $.entries()) {
+    for (const O of N) {
+      const C = re(m.get(O) - X);
+      G.set(O, a ? { x: F, y: C } : { x: C, y: F });
+    }
+    const z = $[L + 1];
+    if (!z) break;
+    let I = Math.max(
+      N.some(f) || z.some(f) ? r.group : r.rank,
+      B[L],
+      wo(N, z, (O) => l.get(O).soft, !a)
+    );
+    for (const O of o)
+      Math.min(x.get(O.a), x.get(O.b)) === L && Math.abs(x.get(O.a) - x.get(O.b)) === 1 && (I = Math.max(I, a ? O.w : O.h));
+    F += Math.max(...N.map(i)) + I;
+  }
+  return { positions: G, axis: s, followed: T };
+}
+const Nt = 20;
+function en(e, t, s, n) {
+  const o = new Map(e.flatMap((h, c) => h.map((y) => [y, c]))), r = (h) => n === "right" ? 2 * Pe : h.h, d = 2 * Pe;
+  return e.slice(0, -1).map((h, c) => {
+    let y = 0, w = 0;
+    const l = [...s], u = [], a = [];
+    for (const g of t) {
+      const f = g.a !== void 0 ? o.get(g.a) : void 0, M = g.b !== void 0 ? o.get(g.b) : void 0;
+      let k;
+      if (f !== void 0 && M !== void 0) {
+        const S = Math.min(f, M), D = Math.max(f, M);
+        if (k = S <= c && D > c && (S === c || D === c + 1), !k) continue;
+        const _ = l.findIndex(
+          ($) => $.a === g.a && $.b === g.b || $.a === g.b && $.b === g.a
+        );
+        _ >= 0 && (w += r(l.splice(_, 1)[0]) - d, S === c && D === c + 1 && a.push(g));
+      } else {
+        if (k = f !== void 0 ? f === c : M === c + 1, !k) continue;
+        g.label && s.length && (w += r(g.label) - (n === "right" ? d : 0));
+      }
+      y++, u.push(g);
+    }
+    return a.some(
+      (g) => u.some((f) => !(f.a && f.b) && [f.a, f.b].some((M) => M && (M === g.a || M === g.b)))
+    ) ? 2 * Nt + (y - 1) * Qe + w : 0;
+  });
+}
+function ji(e, t, s, n, o) {
+  const r = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map();
+  for (const [w, l] of t) {
+    const u = s.get(w), a = s.get(l);
+    if (u === void 0 || a === void 0 || u === a) continue;
+    const [i, g] = u < a ? [w, l] : [l, w];
+    r.set(g, [...r.get(g) ?? [], i]), d.set(i, [...d.get(i) ?? [], g]);
+  }
+  const h = (w) => n.get(w) + o(w) / 2, c = (w, l) => {
+    if (!w.some((M) => l.get(M)?.length)) return;
+    const u = [];
+    for (const [M, k] of w.entries())
+      u.push(M ? u[M - 1] + n.get(k) - n.get(w[M - 1]) : 0);
+    const a = w.map((M, k) => {
+      const S = (l.get(M) ?? []).map(h).sort((_, $) => _ - $);
+      return (S.length ? S[S.length - 1 >> 1] : h(M)) - o(M) / 2 - u[k];
+    }), i = [], g = (M) => M[M.length >> 1];
+    for (const M of a)
+      for (i.push([M]); i.length > 1 && g(i.at(-2)) > g(i.at(-1)); ) {
+        const k = i.pop();
+        i.push([...i.pop(), ...k].sort((S, D) => S - D));
+      }
+    let f = 0;
+    for (const M of i)
+      for (let k = 0; k < M.length; k++, f++) n.set(w[f], re(g(M) + u[f]));
+  };
+  for (const w of e.slice(1)) c(w, r);
+  for (const w of [...e].reverse().slice(1)) c(w, d);
+  for (const w of e.slice(1)) c(w, r);
+  const y = Math.min(...n.values());
+  for (const [w, l] of n) n.set(w, l - y);
+}
+const Mo = 16;
+function Bi(e, t, s, n) {
+  const o = Array.from({ length: e }, () => []);
+  for (const [r, d] of t) {
+    const h = s.get(r), c = s.get(d);
+    if (h === void 0 || c === void 0 || h === c) continue;
+    const y = Math.min(n(r), n(d)), w = Math.max(n(r), n(d));
+    w - y < 1 || (o[Math.min(h, c)].push([y, w]), Math.abs(h - c) > 1 && o[Math.max(h, c) - 1].push([y, w]));
+  }
+  return o.map((r) => {
+    const d = r.flatMap(([y, w]) => [
+      [y, 1],
+      [w, -1]
+    ]);
+    d.sort((y, w) => y[0] - w[0] || y[1] - w[1]);
+    let h = 0, c = 0;
+    for (const [, y] of d) c = Math.max(c, h += y);
+    return c > 1 ? 2 * Nt + (c - 1) * Mo : 0;
+  });
+}
+function Ui(e, t, s, n = [], o = [], r) {
+  const d = /* @__PURE__ */ new Map(), h = t.gap, c = nt(t);
+  let y;
+  const w = new Map(e.map((l) => [l.id, l]));
+  if (t.algorithm === "row" || t.algorithm === "column") {
+    const l = t.algorithm === "row", u = en(
+      e.map((i) => [i.id]),
+      o,
+      n,
+      l ? "right" : "down"
+    );
+    let a = 0;
+    for (const [i, g] of e.entries()) {
+      const f = e[i + 1]?.id ?? "";
+      d.set(g.id, l ? { x: a, y: 0 } : { x: 0, y: a }), a += (l ? g.w : g.h) + Math.max(
+        Jt(n, g.id, f, h, l),
+        u[i] ?? 0,
+        Dt(g.soft, e[i + 1]?.soft, !l)
+      );
+    }
+  } else {
+    const l = e.map((v) => v.id), u = (v) => w.get(v).soft, a = s.length ? qi(ht(l, s), s, (v) => an(v, u)) : null, i = a ? a.layers : l.map((v) => [v]), g = !!a && a.chains.size >= Gi && a.crossings <= 2 * a.chains.size && !e.some((v) => v.soft?.length), f = g ? a.order : i, M = g ? s.flatMap(([v, p], A) => {
+      const m = [v, ...a.chains.get(A) ?? [], p];
+      return m.slice(1).map((b, T) => [m[T], b]);
+    }) : s, k = (v) => je(v) ? 0 : c === "right" ? w.get(v).w : w.get(v).h, S = (v) => je(v) ? 0 : c === "right" ? w.get(v).h : w.get(v).w, D = new Map(f.flatMap((v, p) => v.map((A) => [A, p]))), _ = en(i, o, n, c), $ = /* @__PURE__ */ new Map();
+    for (const v of f) {
+      let p = 0, A;
+      for (const [m, b] of v.entries()) {
+        const T = v[m - 1];
+        T !== void 0 && je(T) ? p += je(b) ? Mo : Nt : T !== void 0 && je(b) && (p += Nt), !je(b) && A !== void 0 && (p = Math.max(
+          p,
+          $.get(A) + S(A) + Math.max(
+            Jt(n, A, b, h, c !== "right"),
+            Dt(u(A), u(b), c === "right")
+          )
+        )), $.set(b, p), p += S(b), je(b) || (A = b);
+      }
+    }
+    s.length && ji(f, M, D, $, S);
+    const x = Bi(f.length, M, D, (v) => $.get(v) + S(v) / 2);
+    g && _s(
+      c,
+      f,
+      s.flatMap(
+        ([p, A], m) => D.get(p) < D.get(A) ? [{ id: String(m), chain: [p, ...a.chains.get(m) ?? [], A] }] : []
+      ),
+      (p) => je(p) ? void 0 : c === "right" ? { x: 0, y: $.get(p), w: k(p), h: S(p) } : { x: $.get(p), y: 0, w: S(p), h: k(p) },
+      (p) => $.get(p),
+      r
+    ).forEach((p, A) => x[A] = Math.max(x[A] ?? 0, p));
+    let E = 0;
+    for (const [v, p] of i.entries()) {
+      let A = Math.max(h, _[v] ?? 0, x[v] ?? 0);
+      for (const m of p) {
+        const b = $.get(m);
+        d.set(m, c === "right" ? { x: E, y: b } : { x: b, y: E });
+      }
+      i[v + 1] && (A = Math.max(A, wo(p, i[v + 1], u, c === "down")));
+      for (const m of n)
+        Math.min(D.get(m.a), D.get(m.b)) === v && Math.abs(D.get(m.a) - D.get(m.b)) === 1 && (A = Math.max(A, c === "right" ? m.w : m.h));
+      E += Math.max(...p.map(k)) + A;
+    }
+    g && (y = {
+      order: f,
+      chains: a.chains,
+      across: new Map(f.flat().flatMap((v) => je(v) ? [[v, $.get(v)]] : []))
+    });
+  }
+  return { positions: d, axis: c, corridors: y };
+}
+function xo(e, t, s = (n) => n) {
+  const n = [s(e[0])];
+  for (let o = 1; o < e.length; o++) {
+    const r = new Map(n[o - 1].map((l, u) => [l, u])), h = e[o].map((l, u) => {
+      const a = t.flatMap(([i, g]) => i === l ? [g] : g === l ? [i] : []).filter((i) => r.has(i)).map((i) => r.get(i));
+      return {
+        id: l,
+        key: a.length ? a.reduce((i, g) => i + g, 0) / a.length : null,
+        k: u
+      };
+    }).filter((l) => l.key !== null), c = [...h].sort((l, u) => l.key - u.key || l.k - u.k), y = h.map((l) => l.k), w = [...e[o]];
+    c.forEach((l, u) => w[y[u]] = l.id), n.push(s(w));
+  }
+  return n;
+}
+const zi = 8;
+function qi(e, t, s = (n) => n) {
+  const n = xo(e, t, s), o = new Map(n.flatMap((_, $) => _.map((x) => [x, $]))), r = n.map((_) => [..._]), d = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), c = (_, $) => {
+    h.set(_, [...h.get(_) ?? [], $]), d.set($, [...d.get($) ?? [], _]);
+  }, y = new Set(o.keys()), w = /* @__PURE__ */ new Map();
+  for (const [_, [$, x]] of t.entries()) {
+    const E = o.get($), v = o.get(x);
+    if (E === void 0 || v === void 0 || E >= v) continue;
+    let p = $;
+    w.set(_, []);
+    for (let A = E + 1; A < v; A++) {
+      const m = `\0${_}:${A}`;
+      w.get(_).push(m);
+      const b = r[A].indexOf(p);
+      r[A].splice(b < 0 ? r[A].length : b + 1, 0, m), c(p, m), p = m;
+    }
+    c(p, x);
+  }
+  if (r.length < 2) return { layers: n, order: n, chains: w, crossings: 0 };
+  const l = (_) => s(_.filter(($) => y.has($))), u = (_) => {
+    const $ = l(_);
+    let x = 0;
+    return _.map((E) => y.has(E) ? $[x++] : E);
+  }, a = (_) => {
+    const $ = new Map(r[_ + 1].map((v, p) => [v, p])), x = r[_].flatMap(
+      (v) => (h.get(v) ?? []).map((p) => $.get(p)).sort((p, A) => p - A)
+    );
+    let E = 0;
+    for (let v = 0; v < x.length; v++)
+      for (let p = v + 1; p < x.length; p++) x[v] > x[p] && E++;
+    return E;
+  }, i = () => r.slice(1).reduce((_, $, x) => _ + a(x), 0), g = (_, $, x, E) => {
+    let v = 0;
+    for (const p of x.get(_) ?? [])
+      for (const A of x.get($) ?? []) E.get(p) > E.get(A) && v++;
+    return v;
+  }, f = (_) => new Map((r[_] ?? []).map(($, x) => [$, x])), M = (_) => {
+    const $ = r[_], x = f(_ - 1), E = f(_ + 1), v = (p, A) => g(p, A, d, x) + g(p, A, h, E);
+    for (let p = !0, A = 0; p && A < $.length; A++) {
+      p = !1;
+      for (let m = 0; m + 1 < $.length; m++) {
+        const b = $[m], T = $[m + 1];
+        if (!(v(T, b) >= v(b, T))) {
+          if ([$[m], $[m + 1]] = [T, b], l($).join(`
+`) !== $.filter((P) => y.has(P)).join(`
+`)) {
+            [$[m], $[m + 1]] = [b, T];
+            continue;
+          }
+          p = !0;
+        }
+      }
+    }
+  }, k = (_, $, x) => {
+    const v = r[_].map((m, b) => {
+      const T = ($.get(m) ?? []).map((P) => x.get(P));
+      return { id: m, k: b, key: T.length ? T.reduce((P, X) => P + X, 0) / T.length : null };
+    }).filter((m) => m.key !== null), p = v.map((m) => m.k), A = [...r[_]];
+    [...v].sort((m, b) => m.key - b.key || m.k - b.k).forEach((m, b) => A[p[b]] = m.id), r[_] = u(A);
+  };
+  let S = r.map((_) => [..._]), D = i();
+  for (let _ = 0, $ = 0; _ < zi && D && $ < 2; _++) {
+    const x = _ % 2 === 0, E = x ? r.map((p, A) => A).slice(1) : r.map((p, A) => A).reverse().slice(1);
+    for (const p of E)
+      k(p, x ? d : h, f(x ? p - 1 : p + 1)), M(p);
+    const v = i();
+    v < D ? [S, D, $] = [r.map((p) => [...p]), v, 0] : $++;
+  }
+  return {
+    layers: S.map((_) => _.filter(($) => y.has($))),
+    order: S,
+    chains: w,
+    crossings: D
+  };
+}
+const Gi = 40, je = (e) => e.charCodeAt(0) === 0;
+class Yn {
+  parent;
+  constructor(t) {
+    this.parent = new Map(t.map((s) => [s, s]));
+  }
+  find(t) {
+    let s = t;
+    for (; this.parent.get(s) !== s; ) s = this.parent.get(s);
+    return s;
+  }
+  join(t, s) {
+    t = this.find(t), s = this.find(s), t !== s && this.parent.set(s, t);
+  }
+}
+function Hi(e, t, s, n) {
+  const o = s.filter((l) => l.type === "stay");
+  if (!o.length) return [];
+  const r = new Map(o.map((l) => [l.id, { x: l.x, y: l.y }])), d = /* @__PURE__ */ new Set(), h = n === "right" ? "x" : "y", c = n === "right" ? "y" : "x", y = (l, u) => u === "x" ? l.w : l.h, w = (l, u, a, i, g) => Math.min(u[g] + y(l, g), i[g] + y(a, g)) - Math.max(u[g], i[g]);
+  for (let l = 0; l < e.length; l++)
+    for (let u = l + 1; u < e.length; u++) {
+      const a = e[l], i = e[u], g = r.get(a.id), f = r.get(i.id), M = t.get(a.id), k = t.get(i.id);
+      !g || !f || !M || !k || w(a, M, i, k, h) > 0 || w(a, g, i, f, c) > 0 && w(a, g, i, f, h) >= Math.min(y(a, h), y(i, h)) / 2 && (d.add(a.id), d.add(i.id));
+    }
+  return o.filter((l) => d.has(l.id));
+}
+function Yi(e, t, s, n, o, r) {
+  const d = e.map((p) => p.id), h = new Map(e.map((p) => [p.id, p])), c = new Map(e.map((p) => [p.id, { ...t.get(p.id) }])), y = new Map(d.map((p) => [p, 1])), w = s.filter(
+    (p) => "ids" in p ? p.type === "align" && p.ids.every((A) => h.has(A)) : "id" in p && h.has(p.id)
+  ), l = /* @__PURE__ */ new Map(), u = Hi(e, t, w, r);
+  u.length && o.push({
+    level: "info",
+    code: "stale-stay",
+    message: `The stays on ${u.map((p) => p.id).join(", ")} no longer fit ${n}'s arrangement, so they were ignored. Drag again to anchor the new layout.`,
+    line: u[0].line,
+    ids: u.map((p) => p.id)
+  });
+  for (const p of w)
+    p.type === "stay" && !u.includes(p) && (c.set(p.id, { x: p.x, y: p.y }), y.set(p.id, p.weight), l.set(p.id, { pos: { x: p.x, y: p.y }, hint: p }));
+  for (const p of w)
+    if (p.type === "nudge") {
+      const A = t.get(p.id), m = { x: A.x + p.dx, y: A.y + p.dy };
+      c.set(p.id, m), y.set(p.id, 4), l.set(p.id, { pos: m, hint: p });
+    }
+  const a = new Map(
+    w.flatMap((p) => p.type === "near" && h.has(p.ref) ? [[p.id, p]] : [])
+  ), i = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Set(), f = (p) => {
+    const A = a.get(p);
+    if (i.has(p) || !A) return;
+    if (g.has(p))
+      throw new Re(
+        `Relative placement cycle in ${n}. Replace one near with nudge.`,
+        A.line
+      );
+    g.add(p), f(A.ref);
+    const m = h.get(p), b = h.get(A.ref), T = c.get(A.ref);
+    let P = T.x + (b.w - m.w) / 2, X = T.y + (b.h - m.h) / 2;
+    A.side === "right" || A.side === "left" ? (P = A.side === "right" ? T.x + b.w + A.gap : T.x - m.w - A.gap, X += A.offset) : (X = A.side === "below" ? T.y + b.h + A.gap : T.y - m.h - A.gap, P += A.offset), c.set(p, { x: P, y: X }), y.set(p, 5), l.set(p, { pos: { x: P, y: X }, hint: A }), g.delete(p), i.add(p);
+  };
+  d.forEach(f);
+  for (const p of w)
+    if (p.type === "align" && p.strength === "prefer") {
+      const A = h.get(p.ids[0]), m = c.get(A.id), b = (P) => p.axis === "x" ? P.w : P.h, T = m[p.axis] + b(A) / 2;
+      for (const P of p.ids.slice(1)) c.get(P)[p.axis] = T - b(h.get(P)) / 2;
+    }
+  const M = new Map(w.flatMap((p) => p.type === "pin" ? [[p.id, p]] : []));
+  for (const [p, A] of M) c.set(p, { x: A.x, y: A.y });
+  const k = (p, A) => (p === "x" ? h.get(A).w : h.get(A).h) / 2, S = { x: new Yn(d), y: new Yn(d) };
+  for (const p of w)
+    if (p.type === "align" && p.strength === "required")
+      for (const A of p.ids.slice(1)) {
+        const m = /* @__PURE__ */ new Set([S[p.axis].find(p.ids[0]), S[p.axis].find(A)]), b = d.filter((T) => M.has(T) && m.has(S[p.axis].find(T))).map((T) => c.get(T)[p.axis] + k(p.axis, T));
+        b.length > 1 && Math.max(...b) - Math.min(...b) > 0.01 ? o.push({
+          level: "error",
+          code: "pin-align-conflict",
+          message: `Pins conflict with required ${p.axis} alignment in ${n}. The pins were kept.`,
+          line: p.line,
+          ids: p.ids
+        }) : S[p.axis].join(p.ids[0], A);
+      }
+  const D = { x: /* @__PURE__ */ new Map(), y: /* @__PURE__ */ new Map() };
+  for (const p of ["x", "y"])
+    for (const A of d) {
+      const m = S[p].find(A), b = c.get(A)[p] + k(p, A);
+      D[p].has(m) || D[p].set(m, { sum: 0, weight: 0, value: 0, fixed: null, members: [] });
+      const T = D[p].get(m);
+      T.sum += b * y.get(A), T.weight += y.get(A), T.members.push(A), M.has(A) && (T.fixed = b);
+    }
+  for (const p of ["x", "y"])
+    for (const A of D[p].values()) A.value = A.fixed ?? A.sum / A.weight;
+  const _ = (p, A) => D[p].get(S[p].find(A)), $ = (p, A) => _(p, A).value, x = (p, A, m, b) => {
+    const T = _(p, A), P = _(p, m), X = b - (T.value - P.value);
+    if (X <= 5e-3 || T === P || T.fixed !== null && P.fixed !== null) return 0;
+    if (T.fixed !== null) P.value -= X;
+    else if (P.fixed !== null) T.value += X;
+    else {
+      const B = T.weight + P.weight;
+      T.value += X * P.weight / B, P.value -= X * T.weight / B;
+    }
+    return X;
+  }, E = w.flatMap(
+    (p) => p.type === "near" && p.strength === "required" && h.has(p.ref) ? [p] : []
+  ), v = r === "right" ? "x" : "y";
+  for (let p = 0; p < 48; p++) {
+    let A = 0;
+    for (const m of E) {
+      const b = m.side === "right" || m.side === "left" ? "x" : "y", T = m.side === "right" || m.side === "below";
+      A += x(
+        b,
+        T ? m.id : m.ref,
+        T ? m.ref : m.id,
+        k(b, m.id) + k(b, m.ref) + m.gap
+      );
+    }
+    for (let m = 0; m < e.length; m++)
+      for (let b = m + 1; b < e.length; b++) {
+        const T = e[m], P = e[b], X = $("x", P.id) - $("x", T.id), B = $("y", P.id) - $("y", T.id), G = (T.w + P.w) / 2 + ft - Math.abs(X), F = (T.h + P.h) / 2 + ft - Math.abs(B);
+        if (G <= 5e-3 || F <= 5e-3) continue;
+        const L = ["x", "y"].filter(
+          (O) => _(O, T.id) !== _(O, P.id) && !(_(O, T.id).fixed !== null && _(O, P.id).fixed !== null)
+        );
+        if (!L.length) continue;
+        const N = (O) => (O === "x" ? G : F) + (O === v ? 0 : 3), z = [...L].sort((O, C) => N(O) - N(C))[0], I = z === "x" ? X : B;
+        A += x(
+          z,
+          I >= 0 ? P.id : T.id,
+          I >= 0 ? T.id : P.id,
+          (z === "x" ? T.w + P.w : T.h + P.h) / 2 + ft
+        );
+      }
+    if (n !== "root")
+      for (const m of ["x", "y"])
+        for (const b of D[m].values()) {
+          const T = Math.max(...b.members.map((P) => k(m, P)));
+          b.value < T && b.fixed === null && (A += T - b.value, b.value = T);
+        }
+    if (A < 0.01) break;
+  }
+  for (const p of e)
+    c.set(p.id, {
+      x: re($("x", p.id) - p.w / 2),
+      y: re($("y", p.id) - p.h / 2)
+    });
+  for (let p = 0; p < e.length; p++)
+    for (let A = p + 1; A < e.length; A++) {
+      const m = e[p], b = e[A], T = c.get(m.id), P = c.get(b.id);
+      T.x + m.w > P.x + 0.1 && P.x + b.w > T.x + 0.1 && T.y + m.h > P.y + 0.1 && P.y + b.h > T.y + 0.1 && o.push({
+        level: "error",
+        code: "overlap",
+        message: `${m.id} overlaps ${b.id}. Release a pin or give ${n} more room.`,
+        ids: [m.id, b.id]
+      });
+    }
+  for (const p of E) {
+    const A = h.get(p.id), m = h.get(p.ref), b = c.get(A.id), T = c.get(m.id);
+    (p.side === "right" ? b.x - T.x - m.w : p.side === "left" ? T.x - b.x - A.w : p.side === "below" ? b.y - T.y - m.h : T.y - b.y - A.h) < p.gap - 0.5 && o.push({
+      level: "error",
+      code: "unsatisfied-near",
+      message: `Required: ${p.id} ${p.side} of ${p.ref} is not satisfied.`,
+      line: p.line,
+      ids: [p.id, p.ref]
+    });
+  }
+  for (const [p, { pos: A, hint: m }] of l) {
+    if (M.has(p) || m.type === "near" && m.strength === "required") continue;
+    const b = c.get(p), T = Math.round(Math.hypot(b.x - A.x, b.y - A.y));
+    T >= 2 && o.push({
+      level: T >= zn ? "warning" : "info",
+      code: "relaxed",
+      message: `${m.type} ${p} gave way by ${T} px to keep ${n} clear.${T >= zn ? ` Remove line ${m.line}, or run format --drop-stale.` : ""}`,
+      line: m.line,
+      ids: [p]
+    });
+  }
+  return c;
+}
+const Wi = 0.5, Xi = 16, Wn = (e) => Math.min(e * Wi, Math.max(0, e - Xi));
+function tn(e, t, s = !1) {
+  if (s) return At(e, t, !0);
+  const n = new Map(e.objects.map((l) => [l.id, l])), o = e.hints.filter(
+    (l) => l.type === "near" && Vt(n, l.id, l.ref) !== l.ref
+  );
+  if (o.length) {
+    const l = tn(
+      { ...e, hints: e.hints.filter((i) => !o.includes(i)) },
+      t
+    ), u = (i, g) => {
+      const f = l.byId.get(i);
+      return g === "x" ? f.x + f.w / 2 : f.y + f.h / 2;
+    }, a = e.hints.map((i) => {
+      if (!o.includes(i) || i.type !== "near") return i;
+      const g = Vt(n, i.id, i.ref), f = i.side === "left" || i.side === "right" ? "y" : "x";
+      return { ...i, ref: g, offset: i.offset + u(i.ref, f) - u(g, f) };
+    });
+    return tn({ ...e, hints: a }, t);
+  }
+  const r = { ...e, hints: e.hints.filter((l) => l.type === "size" || l.type === "order") }, d = At(r, t), h = d, c = bo.get(h), y = (l) => (Math.max(...l.map((u) => u.x + u.w)) - Math.min(...l.map((u) => u.x))) * (Math.max(...l.map((u) => u.y + u.h)) - Math.min(...l.map((u) => u.y))), w = ws(
+    Ms(h.objects, e.edges, e.routing),
+    y(h.objects),
+    (l) => y(At(r, t, !1, l, c).objects)
+  );
+  return At(e, t, !1, w.size ? w : void 0, c);
+}
+const bo = /* @__PURE__ */ new WeakMap();
+function At(e, t, s = !1, n, o) {
+  const r = e.edges.filter((R) => R.constraint !== !1 && R.directed !== !1), d = new Set(r.filter((R) => !R.dashed).map((R) => R.target)), h = r.filter((R) => !R.dashed || !d.has(R.target)), c = {
+    port: Math.max(e.routing.portGap ?? 16, e.routing.edgeGap ?? 16),
+    track: e.routing.edgeGap ?? 16
+  }, y = [], w = /* @__PURE__ */ new Map([["root", []]]);
+  for (const R of e.objects)
+    w.has(R.parent) || w.set(R.parent, []), w.get(R.parent).push(R);
+  const l = ut(e.appearance), u = l.groupHeader, a = /* @__PURE__ */ new Map(), i = l.theme === It ? l : ut({ ...e.appearance, theme: It }), g = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map(), _ = new Map(e.objects.map((R) => [R.id, R])), $ = /* @__PURE__ */ new Map(), x = (R, j) => {
+    let q = _.get(R);
+    for (; q && q.parent !== j; ) q = _.get(q.parent);
+    return q?.id;
+  }, E = [], v = [], p = /* @__PURE__ */ new Map(), A = new Set(o?.groups);
+  let m = o?.wrap ?? !1;
+  const b = (R) => {
+    const j = /* @__PURE__ */ new Map();
+    for (const q of h) {
+      const W = x(q.source, R);
+      W && x(q.target, R) !== W && j.set(W, [...j.get(W) ?? [], q]);
+    }
+    return new Set(
+      [...j].filter(
+        ([q, W]) => W.length > 1 && (_.get(q).shape === "diamond" || W.filter((ee) => ee.label).length > 1)
+      ).map(([q]) => q)
+    );
+  }, T = (R) => h.map((j) => [x(j.source, R), x(j.target, R)]).filter((j) => !!j[0] && !!j[1] && j[0] !== j[1]), P = (R, j, q) => {
+    const W = (se) => x(se, R) !== void 0, ee = e.objects.filter((se) => W(se.id)).map((se) => se.id), Y = new Map(
+      ht(
+        ee,
+        h.filter((se) => W(se.source) && W(se.target)).map((se) => [se.source, se.target])
+      ).flatMap((se, ue) => se.map((ve) => [ve, ue]))
+    ), H = new Map(j.map((se) => [se, 1 / 0]));
+    for (const se of ee) {
+      const ue = x(se, R);
+      H.set(ue, Math.min(H.get(ue), Y.get(se)));
+    }
+    const J = (se, ue) => {
+      const ve = /* @__PURE__ */ new Set([se]), xe = [se];
+      for (; xe.length; ) {
+        const Be = xe.pop();
+        if (Be === ue) return !0;
+        for (const [Xe, Le] of q)
+          Xe === Be && !ve.has(Le) && (ve.add(Le), xe.push(Le));
+      }
+      return !1;
+    };
+    return q.filter(([se, ue]) => !(H.get(ue) < H.get(se) && J(ue, se)));
+  }, X = (R) => {
+    w.get(R);
+  };
+  let B = 0, G = 0;
+  for (const R of w.keys()) {
+    const j = X(R);
+    if (!j) continue;
+    B = Math.max(B, j.groupGap);
+    const q = T(R), W = new Map(
+      ht(
+        (w.get(R) ?? []).map((Y) => Y.id),
+        q
+      ).flatMap((Y, H) => Y.map((J) => [J, H]))
+    ), ee = Math.max(0, ...W.values());
+    for (let Y = 0; Y < ee; Y++)
+      G = Math.max(
+        G,
+        q.filter(
+          ([H, J]) => Math.min(W.get(H), W.get(J)) <= Y && Math.max(W.get(H), W.get(J)) > Y
+        ).length
+      );
+  }
+  B = Math.min(Ni, Math.max(B, (G + 1) * (e.routing.edgeGap ?? 16)));
+  function F(R) {
+    const j = Ut(e, R);
+    return j.algorithm === "row" ? "right" : j.algorithm === "column" ? "down" : nt(j);
+  }
+  function L(R, j) {
+    const q = nt(j) === "right", W = Math.max(j.gap, ei), ee = /* @__PURE__ */ new Map();
+    for (const Z of R) for (const me of w.get(Z.id) ?? []) ee.set(me.id, Z.id);
+    const Y = [...ee.keys()], H = (Z) => g.get(Z) ?? k.get(Z), J = (Z) => q ? H(Z).w : H(Z).h, se = (Z) => q ? H(Z).h : H(Z).w, ue = (Z) => {
+      let me = _.get(Z);
+      for (; me && !ee.has(me.id); ) me = _.get(me.parent);
+      return me?.id;
+    }, ve = h.map((Z) => [ue(Z.source), ue(Z.target)]).filter((Z) => !!Z[0] && !!Z[1] && Z[0] !== Z[1]), xe = Y.length ? xo(ht(Y, ve), ve) : [], Be = new Map(xe.flatMap((Z, me) => Z.map((ke) => [ke, me]))), Xe = xe.map((Z) => Math.max(...Z.map(J))), Le = [];
+    let Ue = 0;
+    for (const [Z, me] of xe.entries()) {
+      Le.push(Ue);
+      let ke = W;
+      for (const Oe of e.edges) {
+        const Ee = Be.get(ue(Oe.source) ?? ""), Ae = Be.get(ue(Oe.target) ?? "");
+        if (Oe.label && Ee !== void 0 && Ae !== void 0 && Math.min(Ee, Ae) === Z && Ee !== Ae) {
+          const _e = Bt("", "", Oe.label, l);
+          ke = Math.max(ke, q ? _e.w : _e.h);
+        }
+      }
+      Ue += Xe[Z] + (me === xe.at(-1) ? 0 : ke);
+    }
+    const Ie = Ue, mt = /* @__PURE__ */ new Map();
+    for (const Z of R) {
+      const me = xe.map((Ee) => Ee.filter((Ae) => ee.get(Ae) === Z.id)), ke = (Ee) => Ee.reduce((Ae, _e, qe) => Ae + se(_e) + (qe ? Dn : 0), 0), Oe = Math.max(ti, ...me.map(ke));
+      mt.set(Z.id, Oe), me.forEach((Ee, Ae) => {
+        let _e = (Oe - ke(Ee)) / 2;
+        for (const qe of Ee) {
+          const pe = Le[Ae] + (Xe[Ae] - J(qe)) / 2, et = q ? { x: pe, y: _e } : { x: _e, y: pe };
+          S.set(qe, { x: re(et.x), y: re(et.y) }), D.set(qe, et), _e += se(qe) + Dn;
+        }
+      });
+    }
+    const wt = (Z) => Math.ceil(ye(Z.label, l.groupTitle)) + Xt, Fe = Math.max(Ie + 2 * Se, ...R.map(wt));
+    let Ke = 0;
+    for (const Z of R) {
+      const me = mt.get(Z.id);
+      Z.w = q ? Fe : Math.max(me + 2 * Se, wt(Z)), Z.h = u + (q ? me : Ie) + Se;
+      const ke = q ? { x: 0, y: Ke } : { x: Ke, y: 0 };
+      S.set(Z.id, ke), D.set(Z.id, ke), Ke += (q ? Z.h : Z.w) + Nn;
+    }
+    const ze = Math.max(0, Ke - Nn);
+    return q ? { w: R.length ? Fe : 0, h: ze } : { w: ze, h: R.length ? u + Ie + Se : 0 };
+  }
+  function N(R, j) {
+    const q = R.filter((H) => H.type === "node" && (H.shape === "box" || H.shape === "pill"));
+    if (q.length < 2) return;
+    const W = (H) => e.hints.some((J) => J.type === "size" && J.id === H.id), ee = Math.max(...q.map((H) => H.w)), Y = Math.max(...q.map((H) => j.get(H.id)?.ref.w ?? H.w));
+    for (const H of q) {
+      if (W(H) || H.w === ee) continue;
+      const J = Et(H, { width: ee }, l);
+      if (H.w = re(J.w), H.h = re(J.h), !j.get(H.id)) continue;
+      const ue = Et(H, { width: Y }, i);
+      j.set(H.id, {
+        look: { w: H.w, h: H.h },
+        ref: { w: re(ue.w), h: re(ue.h) }
+      });
+    }
+  }
+  function z(R) {
+    const j = Ut(e, R), q = e.hints.find((U) => U.type === "order" && U.scope === R);
+    let W = w.get(R) ?? [];
+    if (q?.type === "order" && (W = [...q.ids.flatMap((Q) => W.filter((K) => K.id === Q)), ...W.filter((Q) => !q.ids.includes(Q.id))]), j.algorithm === "cells") return I(R, W, j);
+    const ee = /* @__PURE__ */ new Map(), Y = W.map((U) => {
+      let Q;
+      if (U.type === "group") {
+        const ie = z(U.id), ne = Ut(e, U.id), ge = !w.get(U.id)?.length, de = f.get(U.id);
+        Q = de !== void 0 ? {
+          w: Math.max(ie.w, ne.minWidth),
+          h: Math.max(ie.h + de, ne.minHeight)
+        } : (() => {
+          const be = Math.max(
+            ge ? Pn.w : 0,
+            ie.w + Se + (n?.get(U.id)?.right ?? Se),
+            ne.minWidth
+          ), Ce = vi(U.label, be, l);
+          return Ce.lines > 1 && a.set(U.id, Ce.lines), {
+            w: Math.max(be, Ce.w),
+            h: Math.max(
+              ge ? Pn.h : 0,
+              ie.h + _t(l, Ce.lines) + (n?.get(U.id)?.bottom ?? Se),
+              ne.minHeight
+            )
+          };
+        })();
+      } else {
+        const ie = e.hints.find((ge) => ge.type === "size" && ge.id === U.id), ne = Et(U, ie?.type === "size" ? ie : void 0, l);
+        if (Q = ne, i !== l) {
+          const ge = Et(U, ie?.type === "size" ? ie : void 0, i);
+          ee.set(U.id, {
+            look: { w: re(ne.w), h: re(ne.h) },
+            ref: { w: re(ge.w), h: re(ge.h) }
+          });
+        }
+        U.shape === "diamond" && !ie && ne.w > io("diamond").w * Si && y.push({
+          level: "info",
+          code: "big-diamond",
+          message: `${U.id}'s question makes its diamond ${re(ne.w)}px square, much larger than the shapes around it. Shorten the question, or move the detail onto its edges' labels.`,
+          line: U.line,
+          ids: [U.id]
+        }), ne.overflow && y.push({
+          level: "warning",
+          code: "text-overflow",
+          message: `${U.id}'s title does not fit in its requested size. Make it larger or remove the size line.`,
+          line: ie?.line,
+          ids: [U.id]
+        });
+      }
+      const K = { ...U, w: re(Q.w), h: re(Q.h) };
+      return k.set(U.id, K), K;
+    });
+    if (j.algorithm === "column" && N(Y, ee), R === "root" && j.algorithm === "lanes") return L(Y, j);
+    const H = T(R), J = _.get(R)?.parent, se = J !== void 0 && F(J) === F(R), ue = (R === "root" ? [] : e.edges).flatMap((U) => {
+      const Q = x(U.source, R), K = x(U.target, R);
+      return !Q && !K || Q === K || !(Q && K) && !se ? [] : [{ a: Q, b: K, label: U.label && !(Q && K) ? Je(U.label, l) : void 0 }];
+    }), ve = /* @__PURE__ */ new Map();
+    for (const U of h) {
+      const Q = x(U.source, R), K = x(U.target, R);
+      Q && !K && ve.set(Q, [...ve.get(Q) ?? [], U.target]), K && !Q && ve.set(K, [...ve.get(K) ?? [], U.source]);
+    }
+    const xe = (U, Q) => {
+      const K = S.get(U), ie = g.get(U) ?? k.get(U);
+      return Q ? K.y + ie.h / 2 : K.x + ie.w / 2;
+    }, Be = /* @__PURE__ */ new Map(), Xe = _.get(R)?.parent, Le = Xe !== void 0 && w.get(Xe) || [], Ue = Y.map((U) => ve.get(U.id) ?? []), Ie = Ue[0]?.length === 1 ? _.get(Ue[0][0])?.parent : void 0, mt = Le.findIndex((U) => U.id === Ie) < Le.findIndex((U) => U.id === R);
+    if (Ie !== void 0 && Ie !== R && Le.some((U) => U.id === Ie) && mt && Ue.every((U) => U.length === 1 && _.get(U[0])?.parent === Ie && S.has(U[0])))
+      for (const [U, Q] of Y.entries())
+        Be.set(Q.id, xe(Ue[U][0], F(Ie) === "right"));
+    const wt = (U, Q) => {
+      if ($.get(Q) !== U) return;
+      const K = F(R) === "right", ie = (de) => K ? _t(l, a.get(de)) : Se, ge = e.edges.filter(
+        (de) => _.get(de.source)?.parent === U && _.get(de.target)?.parent === Q
+      ).sort((de, be) => xe(de.target, K) - xe(be.target, K))[0];
+      return ge ? ie(U) + xe(ge.source, K) - ie(Q) - xe(ge.target, K) : void 0;
+    }, Fe = e.edges.flatMap((U) => {
+      const Q = x(U.source, R), K = x(U.target, R);
+      if (!U.label || !Q || !K || Q === K) return [];
+      const ie = Bt(Q, K, U.label, l);
+      if (i === l) return [ie];
+      const ne = Bt(Q, K, U.label, i);
+      return [{ a: Q, b: K, w: Math.max(ne.w, ie.w - Pe), h: Math.max(ne.h, ie.h - Pe) }];
+    }), Ke = t, ze = X(R), Z = ze ? { node: ze.nodeGap, rank: ze.rankGap, group: B } : void 0, me = ze ? P(
+      R,
+      Y.map((U) => U.id),
+      H
+    ) : void 0, ke = (U, Q) => {
+      const K = j.algorithm === "row" ? "right" : j.algorithm === "column" ? "down" : U, ie = {
+        x: K === "right",
+        y: K === "down"
+      }, ne = (de) => s ? de : ee.get(de.id)?.look ?? de, ge = /* @__PURE__ */ new Map();
+      return new Map(
+        Y.map((de) => {
+          const be = ne(de);
+          return [
+            de.id,
+            {
+              x: ie.x ? (de.w - be.w) / 2 : 0,
+              y: ge.get(de.id) ?? (ie.y ? (de.h - be.h) / 2 : 0),
+              w: be.w,
+              h: be.h
+            }
+          ];
+        })
+      );
+    }, Oe = (U) => {
+      for (const ce of Y) {
+        const Te = ee.get(ce.id);
+        Te && (ce.w = Math.max(Te.ref.w, Te.look.w - U.w), ce.h = Math.max(Te.ref.h, Te.look.h - U.h));
+      }
+      const Q = (ce) => Z ? Ci(
+        Y,
+        t,
+        nt(Ke),
+        me,
+        ce,
+        Z,
+        R === "root",
+        ue,
+        ve,
+        Be,
+        wt
+      ) : Ui(Y, j, H, ce, ue, c), K = Fe.length ? Q([]) : void 0, ie = K ? Di(
+        new Map(
+          Y.map((ce) => {
+            const Te = K.positions.get(ce.id), yt = ke(K.axis, K.positions).get(ce.id);
+            return [ce.id, { x: Te.x + yt.x, y: Te.y + yt.y, w: yt.w, h: yt.h }];
+          })
+        ),
+        K.axis,
+        Fe
+      ) : /* @__PURE__ */ new Set(), ne = Q(Fe.filter((ce) => !ie.has(ce)));
+      let ge;
+      if (j.algorithm === "flow" && j.fold === "auto") {
+        const ce = zt(
+          Y,
+          ne.positions,
+          ne.axis,
+          j.gap,
+          H,
+          Fe,
+          b(R),
+          (K ?? ne).positions
+        );
+        ne.positions = ce.positions, ge = ce.fold;
+      }
+      const de = !ge && ze && Ke?.engine?.params.fold !== "never";
+      if (de && A.has(R)) {
+        const ce = zt(
+          Y,
+          ne.positions,
+          ne.axis,
+          Z.rank,
+          H,
+          Fe,
+          b(R),
+          (K ?? ne).positions,
+          { fewest: 2, room: 0 }
+        );
+        ne.positions = ce.positions, ge = ce.fold;
+      }
+      if (de && R === "root" && m) {
+        const ce = zt(
+          Y,
+          ne.positions,
+          ne.axis,
+          Z.rank,
+          H,
+          Fe,
+          b(R),
+          (K ?? ne).positions,
+          { aspect: Gn, fewest: 2 }
+        );
+        ne.positions = ce.positions, ge = ce.fold;
+      }
+      const be = n?.get(R);
+      if (be && (be.left > Se || be.top))
+        for (const [ce, Te] of ne.positions)
+          ne.positions.set(ce, { x: Te.x + be.left - Se, y: Te.y + be.top });
+      const Ce = ke(ne.axis, ne.positions), Ao = ee.size ? e.hints.map(
+        (ce) => (ce.type === "stay" || ce.type === "pin") && Ce.has(ce.id) ? { ...ce, x: ce.x - Ce.get(ce.id).x, y: ce.y - Ce.get(ce.id).y } : ce
+      ) : e.hints, So = Yi(Y, ne.positions, Ao, R, y, ne.axis);
+      return "followed" in ne && ne.followed ? $.set(R, Ie) : $.delete(R), { base: ne, fold: ge, pos: So, off: Ce };
+    }, Ee = (U, Q) => {
+      const K = Q.pos.get(U.id), ie = Q.off.get(U.id);
+      return { x: K.x + ie.x, y: K.y + ie.y, w: ie.w, h: ie.h };
+    }, Ae = (U, Q) => ({
+      ...Q.pos.get(U.id),
+      w: U.w,
+      h: U.h
+    }), _e = ee.size ? { w: Wn(j.gap), h: Wn(j.gap) } : { w: 0, h: 0 }, qe = y.length;
+    let pe = Oe(_e);
+    !s && (_e.w || _e.h) && Y.some(
+      (U, Q) => Y.slice(Q + 1).some(
+        (K) => Fn(Ae(U, pe), Ae(K, pe)) >= ft - 0.5 && Fn(Ee(U, pe), Ee(K, pe)) < ft - 0.5
+      )
+    ) && (y.length = qe, pe = Oe({ w: 0, h: 0 })), pe.fold && E.push({ scope: R, fold: pe.fold });
+    const et = pe.base.corridors;
+    et && R === "root" && !pe.fold && !n?.get(R) && Y.every((U) => {
+      const Q = pe.pos.get(U.id), K = pe.base.positions.get(U.id);
+      return Q && K && Math.abs(Q.x - K.x) < 0.01 && Math.abs(Q.y - K.y) < 0.01;
+    }) && p.set(R, { axis: pe.base.axis, corridors: et }), j.algorithm === "flow" && v.push({ scope: R, axis: pe.base.axis });
+    const at = Y.map((U) => Ee(U, pe)), Pt = R === "root" ? 0 : Math.max(0, ...Y.map((U) => U.soft?.length ?? 0)), rt = R === "root" || !Y.length ? { x: 0, y: 0 } : {
+      x: Math.max(0, -Math.min(...at.map((U) => U.x))) + Pt * dt,
+      y: Math.max(0, -Math.min(...at.map((U) => U.y))) + Pt * (dt + Lt)
+    };
+    for (const [U, Q] of Y.entries()) {
+      const K = at[U], ie = pe.off.get(Q.id), ne = pe.base.positions.get(Q.id);
+      S.set(Q.id, { x: re(K.x + rt.x), y: re(K.y + rt.y) }), D.set(Q.id, { x: ne.x + ie.x + rt.x, y: ne.y + ie.y + rt.y }), ee.has(Q.id) && g.set(Q.id, { w: re(K.w), h: re(K.h) });
+    }
+    const rn = (U, Q) => Y.length ? Math.max(
+      ...Y.map(
+        (K, ie) => Math.max(pe.pos.get(K.id)[U] + K[Q], at[ie][U] + at[ie][Q])
+      )
+    ) + rt[U] + Pt * dt : 0;
+    return { w: rn("x", "w"), h: rn("y", "h") };
+  }
+  function I(R, j, q) {
+    if (q.unit) return O(R, j, q);
+    const W = Math.ceil(ye(_.get(R).label, l.groupTitle)) + Xo, ee = (H) => e.hints.find((J) => J.type === "size" && J.id === H), Y = is(
+      j.map((H) => {
+        const J = ee(H.id);
+        return {
+          id: H.id,
+          label: H.label,
+          marker: H.shape === "marker",
+          ...typeof H.span == "number" ? { span: H.span } : {},
+          ...J?.type === "size" ? { size: { width: J.width, height: J.height, minHeight: J.minHeight } } : {}
+        };
+      }),
+      {
+        direction: q.direction === "down" ? "down" : "right",
+        ...q.columns ? { columns: q.columns } : {}
+      },
+      l,
+      W
+    );
+    return C(R, j, Y.boxes), f.set(R, Qt(l.groupTitle.lineHeight)), { w: Math.max(Y.w, W), h: Y.h };
+  }
+  function O(R, j, q) {
+    const W = cs(
+      j.map((H) => ({
+        id: H.id,
+        label: H.label,
+        marker: !1,
+        ...typeof H.span == "number" ? { span: H.span } : {},
+        open: H.span === "var"
+      })),
+      {
+        unit: q.unit,
+        ruler: q.ruler !== !1,
+        ...q.columns ? { columns: q.columns } : {},
+        ...q.unitWidth ? { unitWidth: q.unitWidth } : {}
+      },
+      l
+    ), ee = Qt(l.groupTitle.lineHeight), Y = ee + (W.ruler?.h ?? 0);
+    return C(R, j, W.boxes), f.set(R, Y), M.set(R, {
+      ...W.ruler ? { ruler: { y: ee, ...W.ruler } } : {},
+      ...W.pieces.size ? {
+        pieces: Object.fromEntries(
+          [...W.pieces].map(([H, J]) => [H, J.map((se) => ({ ...se, y: se.y + Y }))])
+        )
+      } : {},
+      ...W.open.length ? { open: W.open } : {}
+    }), { w: W.w, h: W.h };
+  }
+  function C(R, j, q) {
+    for (const W of j) {
+      const ee = q.get(W.id);
+      k.set(W.id, { ...W, w: re(ee.w), h: re(ee.h) }), S.set(W.id, { x: re(ee.x), y: re(ee.y) }), D.set(W.id, { x: ee.x, y: ee.y });
+      const Y = e.hints.find(
+        (H) => Ws.includes(H.type) && "id" in H && H.id === W.id
+      );
+      Y && y.push({
+        level: "warning",
+        code: "cell-position",
+        message: `${W.id} is a cell of ${R}, so it stays in its place. Move ${R} instead, or reorder its cells with order.`,
+        line: Y.line,
+        ids: [W.id]
+      });
+    }
+  }
+  const V = y.length, oe = X("root") && Mi(e, "root");
+  let ae = z("root");
+  if (!o && oe && oe.engine?.params.fold !== "never") {
+    let R = function(H) {
+      return q(H) > yo * W(H);
+    };
+    const j = nt(oe) === "right", q = (H) => j ? H.w : H.h, W = (H) => j ? H.h : H.w, ee = j ? $t.width : $t.height, Y = (H) => q(H) > ee && q(H) > Gn * W(H);
+    for (; Y(ae) && !m; ) {
+      const H = [...k.values()].filter(
+        (J) => J.type === "group" && !A.has(J.id) && X(J.id) && R(J)
+      ).sort((J, se) => q(se) - q(J))[0];
+      H ? A.add(H.id) : m = !0, y.length = V, E.length = v.length = 0, g.clear(), ae = z("root");
+    }
+  }
+  if (!o && oe && nt(oe) === "down" && oe.engine?.params.fold !== "never") {
+    const R = (q) => q.h, j = (q) => q.w * q.h;
+    for (; ; ) {
+      const q = (w.get("root") ?? []).map((H) => k.get(H.id)).filter(Boolean).sort((H, J) => R(J) - R(H)), [W, ee] = q;
+      if (!W || !ee || W.type !== "group" || W.fold === "never" || A.has(W.id) || !X(W.id) || R(W) < ki * R(ee))
+        break;
+      const Y = ae;
+      if (A.add(W.id), y.length = V, E.length = v.length = 0, g.clear(), ae = z("root"), !(j(ae) < j(Y))) {
+        A.delete(W.id), y.length = V, E.length = v.length = 0, g.clear(), z("root");
+        break;
+      }
+    }
+  }
+  const le = [], he = (R, j, q) => {
+    for (const W of w.get(R) ?? []) {
+      const ee = g.get(W.id) ?? k.get(W.id), Y = S.get(W.id), H = D.get(W.id), J = {
+        ...W,
+        x: j.x + Y.x,
+        y: j.y + Y.y,
+        w: ee.w,
+        h: ee.h,
+        localX: Y.x,
+        localY: Y.y,
+        baseX: re(H.x),
+        baseY: re(H.y),
+        depth: q,
+        ...a.has(W.id) ? { titleLines: a.get(W.id) } : {}
+      };
+      le.push(J), W.type === "group" && he(
+        W.id,
+        f.has(W.id) ? { x: J.x, y: J.y + f.get(W.id) } : so(J, _t(l, J.titleLines)),
+        q + 1
+      );
+    }
+  };
+  he("root", { x: 0, y: 0 }, 0);
+  const we = Ki(p, le, h, x, c), fe = Li(
+    E,
+    e.edges,
+    new Map(le.map((R) => [R.id, R])),
+    x,
+    Math.max(e.routing.portGap ?? 16, e.routing.edgeGap ?? 16)
+  );
+  for (const [R, j] of ks(
+    v.map((q) => ({ ...q, bands: E.find((W) => W.scope === q.scope)?.fold.bands })),
+    e.edges,
+    new Map(le.map((q) => [q.id, q])),
+    new Set(fe.keys()),
+    (q) => Je(q, l)
+  ))
+    fe.set(R, j);
+  for (const R of e.layouts) {
+    const j = le.find((q) => q.id === R.scope);
+    !j || !R.minWidth && !R.minHeight || (R.minWidth && j.w > R.minWidth + 0.5 || R.minHeight && j.h > R.minHeight + 0.5) && y.push({
+      level: "info",
+      code: "group-grew",
+      message: `${j.id} needs at least ${j.w}×${j.h} for its contents.`,
+      line: R.line,
+      ids: [j.id]
+    });
+  }
+  Fs(e), y.push(...yi(e), ...$s(e));
+  for (const R of e.warnings) y.push({ level: "warning", ...R, ids: [] });
+  const te = new Map(e.objects.map((R, j) => [R.id, j]));
+  le.sort((R, j) => te.get(R.id) - te.get(j.id));
+  const Me = {
+    model: e,
+    title: e.title,
+    objects: le,
+    byId: new Map(le.map((R) => [R.id, R])),
+    edges: e.edges.map((R) => {
+      const j = fe.get(R.id), q = j ? void 0 : we.get(R.id);
+      return j ? { ...R, lane: j } : q ? { ...R, plan: q } : R;
+    }),
+    diagnostics: y,
+    look: l,
+    cells: M
+  };
+  return bo.set(Me, { groups: A, wrap: m }), Me;
+}
+function Ki(e, t, s, n, o) {
+  const r = /* @__PURE__ */ new Map(), d = new Map(t.map((h) => [h.id, h]));
+  for (const [h, { axis: c, corridors: y }] of e) {
+    const w = s.filter((i) => {
+      const g = n(i.source, h), f = n(i.target, h);
+      return !!g && !!f && g !== f;
+    }), l = new Map(y.order.flatMap((i, g) => i.map((f) => [f, g]))), u = (i) => {
+      const g = d.get(i);
+      return !!g && g.type === "node" && (g.shape ?? "box") === "box";
+    }, a = [];
+    for (const [i, g] of w.entries()) {
+      const f = g.source, M = g.target;
+      n(f, h) !== f || n(M, h) !== M || !u(f) || !u(M) || l.get(f) < l.get(M) && a.push({ id: g.id, chain: [f, ...y.chains.get(i) ?? [], M] });
+    }
+    for (const [i, g] of Ss(
+      c,
+      y.order,
+      a,
+      (f) => d.get(f),
+      (f) => y.across.get(f),
+      o
+    ))
+      r.set(i, g);
+  }
+  return r;
+}
+const De = Object.freeze({
+  sourceBytes: 256 * 1024,
+  objects: 500,
+  edges: 1200,
+  depth: 12,
+  labelChars: 16 * 1024,
+  totalLabelBytes: 1024 * 1024,
+  outputBytes: 1024 * 1024,
+  nativeSourceChars: 3e5
+}), nn = /* @__PURE__ */ new Set(["root", "__proto__", "constructor", "prototype"]);
+class vo {
+  entries = [];
+  byForeign = /* @__PURE__ */ new Map();
+  taken = new Set(nn);
+  get(t, s, n = s) {
+    const o = JSON.stringify([t, s]), r = this.byForeign.get(o);
+    if (r) return r;
+    let d = [...n].map((c) => /[A-Za-z0-9_.-]/.test(c) ? c : "_u" + c.codePointAt(0).toString(16) + "_").join("");
+    /^[A-Za-z_]/.test(d) || (d = t + "_" + d), (!d || nn.has(d)) && (d = t + "_" + (d || "item"));
+    let h = d;
+    for (let c = 2; this.taken.has(h); c++) h = d + "__" + c;
+    return this.byForeign.set(o, h), this.taken.add(h), this.entries.push({ kind: t, foreign: s, native: h }), h;
+  }
+}
+const He = (e) => JSON.stringify(e), ko = (e) => ({
+  title: e,
+  objects: [],
+  edges: [],
+  layouts: [],
+  colors: []
+});
+function Eo(e, t, s, n, o) {
+  const r = (i, g, f = "semantics") => n.push({ code: i, severity: "error", impact: f, message: g });
+  (s.objects.length > De.objects || s.edges.length > De.edges) && r(
+    "IMPORT_GRAPH_LIMIT",
+    "Native source allows at most 500 nodes plus groups, and 1,200 edges.",
+    "limit"
+  );
+  const d = new TextEncoder();
+  [s.title, ...s.objects.map((i) => i.label), ...s.edges.map((i) => i.label)].reduce((i, g) => i + d.encode(g).length, 0) > De.totalLabelBytes && r(
+    "IMPORT_TOTAL_LABEL_LIMIT",
+    "Expanded native labels exceed a combined 1 MiB of UTF-8 text.",
+    "limit"
+  ), s.title.length > De.labelChars && r("IMPORT_LABEL_LIMIT", "Diagram title exceeds 16,384 characters.", "limit");
+  const c = new Map(s.objects.map((i) => [i.id, i])), y = [...s.objects.map((i) => i.id), ...s.edges.map((i) => i.id)];
+  (new Set(y).size !== y.length || y.some((i) => nn.has(i) || !/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(i))) && r("IMPORT_ID_INVARIANT", "Generated IDs must be safe, globally unique native identifiers.");
+  const w = (i) => {
+    const g = [];
+    let f = c.get(i)?.parent;
+    for (; f; ) {
+      if (g.includes(f) || g.length >= De.depth) {
+        r("IMPORT_HIERARCHY", "Containment cycle or excessive nesting.");
+        break;
+      }
+      if (g.push(f), c.get(f)?.kind !== "group") {
+        r("IMPORT_PARENT", "Missing or non-group parent: " + f);
+        break;
+      }
+      f = c.get(f)?.parent;
+    }
+    return g;
+  };
+  for (const i of s.objects)
+    w(i.id).length + 1 > De.depth && r("IMPORT_DEPTH", "Native source permits 12 nesting levels.", "limit"), i.label.length > De.labelChars && r("IMPORT_LABEL_LIMIT", "Label exceeds 16,384 characters.", "limit");
+  for (const i of s.edges)
+    (!c.has(i.from) || !c.has(i.to)) && r("IMPORT_ENDPOINT", "Missing endpoint for " + i.id), (w(i.from).includes(i.to) || w(i.to).includes(i.from)) && r(
+      "IMPORT_ANCESTOR_EDGE",
+      "Native source cannot connect a group to one of its descendants."
+    ), i.label.length > De.labelChars && r("IMPORT_LABEL_LIMIT", "Edge label exceeds 16,384 characters.", "limit");
+  const l = s.edges.some((i) => !i.directed) ? ["IMP-02-native-undirected"] : [];
+  if (n.some((i) => i.severity === "error"))
+    return { status: "failed", format: e, family: t, diagnostics: n, ids: o.entries, requires: l };
+  const u = ["diagram " + He(s.title) + " version=1"];
+  for (const i of s.colors)
+    u.push(
+      "theme-color " + i.name + " shade=500 fill=" + He(i.fill) + " stroke=" + He(i.stroke) + " ink=" + He(i.ink)
+    );
+  for (const i of s.objects) {
+    let g = i.kind + " " + i.id + " " + He(i.label);
+    i.parent && (g += " in=" + i.parent), i.shape && i.shape !== "box" && i.kind === "node" && (g += " shape=" + i.shape), i.color && (g += " color=" + i.color + " shade=" + (i.shade ?? 500)), u.push(g);
+  }
+  for (const i of s.edges) {
+    let g = "edge " + i.id + " " + i.from + " -> " + i.to + " " + He(i.label);
+    i.directed || (g += " directed=false"), i.head && i.head !== "arrow" && (g += " head=" + i.head), i.tail && i.tail !== "none" && (g += " tail=" + i.tail), i.dashed && (g += " kind=async"), i.constraint === !1 && (g += " constraint=false"), i.fromSide && (g += " from=" + i.fromSide), i.toSide && (g += " to=" + i.toSide), u.push(g);
+  }
+  for (const i of s.layouts)
+    u.push(
+      "layout " + i.scope + " " + i.kind + (i.direction ? " direction=" + i.direction : "")
+    );
+  for (const i of s.phases ?? [])
+    u.push(["phase", i.id, He(i.label), ...i.members].join(" "));
+  for (const i of s.notes ?? []) {
+    let g = "note " + He(i.text);
+    i.near && (g += " near=" + i.near), i.side && (g += " side=" + i.side), u.push(g);
+  }
+  const a = u.join(`
+`) + `
+`;
+  return a.length > De.nativeSourceChars && r(
+    "IMPORT_NATIVE_SOURCE_LIMIT",
+    "Generated source exceeds the native parser limit of 300,000 source characters.",
+    "limit"
+  ), d.encode(a).length > De.outputBytes && r("IMPORT_OUTPUT_LIMIT", "Generated native source exceeds 1 MiB of UTF-8 text.", "limit"), n.some((i) => i.severity === "error") ? { status: "failed", format: e, family: t, diagnostics: n, ids: o.entries, requires: l } : {
+    status: n.some((i) => i.severity === "warning") ? "needs-review" : "ready",
+    format: e,
+    family: t,
+    diagnostics: n,
+    ids: o.entries,
+    requires: l,
+    nativeSource: a,
+    facts: s
+  };
+}
+function Qi(e) {
+  if (e) {
+    if (/^#[a-f0-9]{6}$/i.test(e)) return e.toLowerCase();
+    if (/^#[a-f0-9]{3}$/i.test(e))
+      return "#" + [...e.slice(1)].map((t) => t + t).join("").toLowerCase();
+  }
+}
+function Vi(e, t, s, n, o) {
+  if (!s && !n && !o) return;
+  const r = { fill: s ?? "#ffffff", stroke: n ?? "#64748b", ink: o ?? "#172033" };
+  let d = e.colors.find((h) => h.fill === r.fill && h.stroke === r.stroke && h.ink === r.ink);
+  d || (d = { name: "import_" + (e.colors.length + 1), ...r }, e.colors.push(d)), t.color = d.name, t.shade = 500;
+}
+const Zi = {
+  SOLID: {},
+  DOTTED: { dashed: !0 },
+  SOLID_OPEN: { head: "none" },
+  DOTTED_OPEN: { head: "none", dashed: !0 },
+  SOLID_CROSS: { head: "cross" },
+  DOTTED_CROSS: { head: "cross", dashed: !0 },
+  SOLID_POINT: {},
+  DOTTED_POINT: { dashed: !0 },
+  BIDIRECTIONAL_SOLID: { tail: "arrow" },
+  BIDIRECTIONAL_DOTTED: { tail: "arrow", dashed: !0 }
+}, Xn = {
+  LOOP_START: "loop",
+  ALT_START: "alt",
+  OPT_START: "opt",
+  PAR_START: "par",
+  PAR_OVER_START: "par",
+  CRITICAL_START: "critical",
+  BREAK_START: "break"
+}, Kn = {
+  ALT_ELSE: "else",
+  PAR_AND: "and",
+  CRITICAL_OPTION: "option"
+}, Ji = ["LOOP_END", "ALT_END", "OPT_END", "PAR_END", "CRITICAL_END", "BREAK_END"];
+function ea(e, t, s, n) {
+  const o = ko(e.title ? t(e.title) : s), r = new vo(), d = /* @__PURE__ */ new Set(), h = (M, k, S = "semantics") => {
+    d.has(M) || (d.add(M), n.push({ code: M, severity: "warning", impact: S, message: k }));
+  }, c = e.boxes.map((M, k) => {
+    const S = r.get("group", "box_" + (k + 1));
+    return o.objects.push({ id: S, kind: "group", label: t(M.name ?? "") }), M.fill && M.fill !== "transparent" && h("MERMAID_SEQUENCE_BOX_COLOR", "Box colors are omitted.", "appearance"), S;
+  }), y = /* @__PURE__ */ new Map();
+  for (const M of e.actors) {
+    const k = r.get("node", M.id);
+    y.set(M.id, k), o.objects.push({
+      id: k,
+      kind: "node",
+      // `participant p as "Name"` keeps its quotes in the DB.
+      label: t(M.name).replace(/^"(.*)"$/s, "$1"),
+      ...M.box != null && M.box >= 0 ? { parent: c[M.box] } : {}
+    }), M.type !== "participant" && h(
+      "MERMAID_SEQUENCE_ACTOR_TYPE",
+      "Participant symbols such as actor or database become ordinary boxes.",
+      "appearance"
+    ), M.links.length && h(
+      "MERMAID_LINK_OMITTED",
+      "Participant link menus are omitted; native participants have no menu.",
+      "security"
+    );
+  }
+  (e.created.length || e.destroyed.length) && h(
+    "MERMAID_SEQUENCE_LIFELINE",
+    "create and destroy are omitted: native participants span the whole diagram."
+  ), o.layouts.push({ scope: "root", kind: "sequence" });
+  const w = [], l = [];
+  let u = 0, a, i;
+  const g = (M, k) => {
+    const S = t(k).trim();
+    a = {
+      id: r.get("phase", String(w.length + 1), "phase_" + (w.length + 1)),
+      label: S ? `${M}: ${S}` : M,
+      members: []
+    }, w.push(a);
+  }, f = (M) => {
+    const k = [M.from, M.to].filter((_) => _ != null), S = i && k.every((_) => i.ends.includes(_)), D = M.placement === "left" ? "left" : M.placement === "right" ? "right" : void 0;
+    l.push({
+      text: t(M.text),
+      near: S ? i.id : y.get(k[0]),
+      side: D ?? (S ? "right" : "below")
+    });
+  };
+  for (const [M, k] of e.events.entries())
+    if (Xn[k.kind])
+      u++, u === 1 ? g(Xn[k.kind], k.text) : h(
+        "MERMAID_SEQUENCE_NESTED_BLOCK",
+        "A nested block has no band of its own; its messages stay in the outer band."
+      ), h(
+        "MERMAID_SEQUENCE_BLOCK",
+        "Native sequences have no fragments. Each block branch becomes a phase band, so the branch logic is only in its label."
+      );
+    else if (Kn[k.kind])
+      u === 1 && g(Kn[k.kind], k.text);
+    else if (Ji.includes(k.kind))
+      u--, u || (a = void 0);
+    else if (k.kind === "NOTE") f(k);
+    else if (k.kind === "ACTIVE_START" || k.kind === "ACTIVE_END")
+      h("MERMAID_SEQUENCE_ACTIVATION", "Activation bars are omitted.", "appearance");
+    else if (k.kind === "AUTONUMBER")
+      h("MERMAID_SEQUENCE_AUTONUMBER", "Message numbers are omitted.", "appearance");
+    else if (k.kind === "RECT_START" || k.kind === "RECT_END")
+      h("MERMAID_SEQUENCE_RECT", "Background rectangles are omitted.", "appearance");
+    else {
+      const S = Zi[k.kind], D = y.get(k.from ?? ""), _ = y.get(k.to ?? "");
+      if (!S || !D || !_ || k.central) {
+        n.push({
+          code: "MERMAID_SEQUENCE_ARROW_UNSUPPORTED",
+          severity: "error",
+          impact: "semantics",
+          message: "Message line type is unsupported: " + (k.central ? "central connection" : k.kind) + ". The import is blocked rather than replacing it with an ordinary arrow."
+        });
+        continue;
+      }
+      k.kind === "SOLID_POINT" && h(
+        "MERMAID_SEQUENCE_ASYNC_ARROW",
+        "The open async arrow `-)` becomes an ordinary solid message, because native async draws dashed."
+      );
+      const $ = r.get("edge-occurrence", String(M + 1), "m" + (o.edges.length + 1));
+      o.edges.push({ id: $, from: D, to: _, label: t(k.text), directed: !0, ...S }), a?.members.push($), i = { id: $, ends: [k.from, k.to] };
+    }
+  return o.phases = w.filter((M) => M.members.length), o.notes = l, Eo("mermaid", "sequence", o, n, r);
+}
+const ta = {
+  arrow_point: {},
+  arrow_open: {},
+  arrow_circle: { head: "circle" },
+  arrow_cross: { head: "cross" },
+  double_arrow_point: { tail: "arrow" },
+  double_arrow_circle: { head: "circle", tail: "circle" },
+  double_arrow_cross: { head: "cross", tail: "cross" }
+};
+function na(e, t, s = "Imported Mermaid") {
+  const n = ko(s), o = new vo(), r = e.diagnostics.map((f) => ({
+    code: f.code,
+    severity: f.severity,
+    impact: f.code.includes("LIMIT") || f.code.includes("TIMEOUT") ? "limit" : f.code.includes("CONFIGURATION") || f.code.includes("INTERACTION") ? "security" : "syntax",
+    message: f.message + (f.locationKind === "parser-relative" && f.line != null ? ` (Parser-relative line ${f.line}, column ${f.column ?? 1}; original-source mapping is unavailable.)` : ""),
+    ...f.locationKind === "source" && f.line != null ? { line: f.line, column: f.column } : {}
+  })), d = (f, M, k = "appearance", S = "warning", D) => r.push({ code: f, message: M, impact: k, severity: S, ...D ? { foreignIds: D } : {} }), h = () => Eo("mermaid", "flowchart", n, r, o);
+  if (!e.ok) return h();
+  const c = e.snapshot;
+  if (c.parserVersion !== cn)
+    return d(
+      "MERMAID_VERSION_MISMATCH",
+      "This adapter is verified only against Mermaid " + cn + ".",
+      "syntax",
+      "error"
+    ), h();
+  if (c.family === "sequence")
+    return ea(c, t, s, r);
+  const y = (f, M, k) => (/<\/?[a-z][\s\S]*?>/i.test(f) && d(
+    "MERMAID_HTML_LABEL",
+    "HTML label formatting was reduced to plain text; line breaks are retained and no HTML is inserted into the diagram.",
+    "appearance",
+    "warning",
+    [k]
+  ), M === "markdown" && d(
+    "MERMAID_MARKDOWN_LABEL",
+    "Markdown label markers remain literal text in this profile.",
+    "appearance",
+    "warning",
+    [k]
+  ), t(f)), w = (f, M) => {
+    if (f) {
+      if (f === "LR") return "right";
+      if (f === "TB" || f === "TD") return "down";
+      if (f === "RL" || f === "BT")
+        return d(
+          "MERMAID_REVERSED_LAYOUT",
+          `${f} layout is normalized to ${f === "RL" ? "right" : "down"}; edge endpoints keep their semantic order.`,
+          "layout",
+          "warning",
+          [M]
+        ), f === "RL" ? "right" : "down";
+      d("MERMAID_DIRECTION", "Unsupported Mermaid layout direction: " + f, "layout", "error", [
+        M
+      ]);
+    }
+  }, l = new Map(c.classes.map((f) => [f.id, f])), u = (f, M, k, S) => {
+    const D = [];
+    for (const _ of [...k ? ["default", "node"] : [], ...f]) {
+      const $ = l.get(_);
+      $ ? D.push($) : ["default", "node", "clickable"].includes(_) || d(
+        "MERMAID_CLASS_UNRESOLVED",
+        "CSS class has no in-diagram definition and was not imported: " + _,
+        "appearance",
+        "warning",
+        [S]
+      );
+    }
+    return [...D.flatMap((_) => [..._.styles, ..._.textStyles]), ...M];
+  }, a = (f, M, k) => {
+    const S = /* @__PURE__ */ new Map();
+    for (const D of M.flatMap((_) => _.split(";"))) {
+      if (!D.trim()) continue;
+      const _ = /^\s*([a-z-]+)\s*:\s*(.*?)\s*$/i.exec(D), $ = _?.[1]?.toLowerCase(), x = _?.[2];
+      if (!$ || !["fill", "stroke", "color"].includes($)) {
+        d(
+          "MERMAID_STYLE_PROPERTY",
+          "Unsupported style declaration was omitted: " + D,
+          /url\s*\(|javascript:|expression\s*\(/i.test(D) ? "security" : "appearance",
+          "warning",
+          [k]
+        );
+        continue;
+      }
+      const E = Qi(x);
+      if (!E) {
+        d(
+          "MERMAID_COLOR_VALUE",
+          "Only #RGB or #RRGGBB colors are imported: " + D,
+          "appearance",
+          "warning",
+          [k]
+        );
+        continue;
+      }
+      S.set($, E);
+    }
+    Vi(n, f, S.get("fill"), S.get("stroke"), S.get("color"));
+  }, i = {
+    square: "box",
+    rect: "box",
+    rectangle: "box",
+    box: "box",
+    stadium: "pill",
+    circle: "circle",
+    diamond: "diamond",
+    text: "text"
+  }, g = (f, M) => {
+    if (!f) return "box";
+    if (Object.hasOwn(i, f)) return i[f];
+    const k = f === "doublecircle" || f === "ellipse" ? "circle" : f === "round" ? "pill" : "box";
+    return d(
+      "MERMAID_SHAPE_APPROXIMATION",
+      `Mermaid shape ${f} becomes native ${k}; the shape-specific visual meaning is not fully preserved.`,
+      "semantics",
+      "warning",
+      [M]
+    ), k;
+  };
+  try {
+    const f = new Map(c.groups.map((x) => [x.id, x])), M = new Map(c.vertices.map((x) => [x.id, x]));
+    if (f.size !== c.groups.length || M.size !== c.vertices.length)
+      return d(
+        "MERMAID_DUPLICATE_DB_ID",
+        "The parser snapshot contains duplicate group or node identities.",
+        "semantics",
+        "error"
+      ), h();
+    const k = /* @__PURE__ */ new Map();
+    for (const x of c.groups)
+      k.set(x.id, {
+        id: o.get("group", x.id),
+        kind: "group",
+        label: y(x.title, x.labelType, x.id)
+      });
+    for (const x of c.vertices)
+      f.has(x.id) || k.set(x.id, {
+        id: o.get("node", x.id),
+        kind: "node",
+        label: y(x.text, x.labelType, x.id),
+        shape: g(x.type, x.id)
+      });
+    const S = /* @__PURE__ */ new Map();
+    for (const x of c.groups)
+      for (const E of x.nodes) {
+        if (!k.has(E)) {
+          d(
+            "MERMAID_UNKNOWN_MEMBER",
+            "Subgraph references an absent member: " + E,
+            "semantics",
+            "error",
+            [x.id, E]
+          );
+          continue;
+        }
+        const v = S.get(E);
+        if (v && v !== x.id) {
+          d(
+            "MERMAID_MULTIPLE_PARENTS",
+            "A member belongs to multiple native parents; containment was not guessed.",
+            "semantics",
+            "error",
+            [E, v, x.id]
+          );
+          continue;
+        }
+        S.set(E, x.id), k.get(E).parent = k.get(x.id).id;
+      }
+    const D = w(c.direction, "root");
+    D && n.layouts.push({ scope: "root", kind: "flow", direction: D });
+    const _ = /* @__PURE__ */ new Map();
+    for (const x of c.groups) {
+      const E = w(x.dir, x.id);
+      E && _.set(x.id, E);
+    }
+    const $ = (x) => {
+      const E = /* @__PURE__ */ new Set();
+      let v = x;
+      for (; v && !E.has(v); ) {
+        E.add(v);
+        const p = _.get(v);
+        if (p) return p;
+        v = S.get(v);
+      }
+      return D ?? "down";
+    };
+    for (const x of c.groups) {
+      const E = k.get(x.id), v = M.get(x.id);
+      a(
+        E,
+        u([...x.classes, ...v?.classes ?? []], v?.styles ?? [], !1, x.id),
+        x.id
+      ), n.layouts.push({
+        scope: E.id,
+        kind: "flow",
+        direction: $(x.id)
+      }), x.dir ? d(
+        "MERMAID_SUBGRAPH_LAYOUT",
+        "The native group retains its declared direction. Mermaid can ignore a subgraph direction when its members connect outside, so the resulting layout may differ.",
+        "layout",
+        "warning",
+        [x.id]
+      ) : d(
+        "MERMAID_INHERITED_LAYOUT",
+        "This group has no declared direction. Native flow layout uses the nearest declared ancestor/root direction; Mermaid can use another direction depending on its layout engine and external connections.",
+        "layout",
+        "warning",
+        [x.id]
+      ), x.metadata && Object.keys(x.metadata).length && d(
+        "MERMAID_GROUP_METADATA",
+        "Group metadata (including collapsed view and engine hints) is omitted: " + Object.keys(x.metadata).join(", "),
+        "layout",
+        "warning",
+        [x.id]
+      );
+    }
+    for (const x of c.vertices) {
+      const E = k.get(x.id);
+      f.has(x.id) || a(E, u(x.classes, x.styles, !0, x.id), x.id), x.link && d(
+        "MERMAID_LINK_OMITTED",
+        "External link was omitted; the native object has no active link.",
+        "security",
+        "warning",
+        [x.id]
+      ), (x.img || x.icon) && d(
+        "MERMAID_ASSET_OMITTED",
+        "Image/icon references are not fetched or embedded; the object remains a labeled native shape.",
+        "security",
+        "warning",
+        [x.id]
+      ), x.props && Object.keys(x.props).length && d(
+        "MERMAID_NODE_METADATA",
+        "Node properties are omitted: " + Object.keys(x.props).join(", "),
+        "semantics",
+        "warning",
+        [x.id]
+      );
+    }
+    n.objects.push(...k.values());
+    for (const [x, E] of c.edges.entries()) {
+      const v = ta[String(E.type)];
+      if (!v) {
+        d(
+          "MERMAID_ARROW_UNSUPPORTED",
+          "Edge terminal semantics are unsupported: " + String(E.type) + ". The import is blocked rather than replacing them with ordinary arrows.",
+          "semantics",
+          "error",
+          [E.id ?? String(x + 1)]
+        );
+        continue;
+      }
+      if (E.stroke === "invisible") {
+        d(
+          "MERMAID_INVISIBLE_EDGE",
+          "Invisible links express layout constraints, not visible relationships; this profile cannot preserve them.",
+          "layout",
+          "error",
+          [E.id ?? String(x + 1)]
+        );
+        continue;
+      }
+      if (!["normal", "thick", "dotted"].includes(E.stroke ?? "normal")) {
+        d(
+          "MERMAID_EDGE_STROKE",
+          "Unsupported edge stroke: " + String(E.stroke),
+          "appearance",
+          "error",
+          [E.id ?? String(x + 1)]
+        );
+        continue;
+      }
+      const p = k.get(E.start), A = k.get(E.end);
+      if (!p || !A) {
+        d("MERMAID_ENDPOINT", "A parsed edge has a missing endpoint.", "semantics", "error", [
+          E.start,
+          E.end
+        ]);
+        continue;
+      }
+      const m = E.isUserDefinedId && E.id ? o.get("edge-id", E.id, E.id) : o.get("edge-occurrence", String(x + 1), "edge_" + (x + 1)), b = E.id ?? String(x + 1);
+      n.edges.push({
+        id: m,
+        from: p.id,
+        to: A.id,
+        label: y(E.text, E.labelType, b),
+        directed: E.type !== "arrow_open",
+        ...v,
+        ...E.stroke === "dotted" ? { dashed: !0 } : {}
+      }), E.stroke === "dotted" && d(
+        "MERMAID_DASH_STYLE",
+        "Dotted Mermaid stroke uses native kind=async only for its dashed visual treatment; no asynchronous execution semantics are inferred.",
+        "appearance",
+        "info",
+        [b]
+      ), E.stroke === "thick" && d(
+        "MERMAID_THICK_EDGE",
+        "Thick edge emphasis is omitted by this native-source profile.",
+        "appearance",
+        "warning",
+        [b]
+      ), (E.length ?? 1) > 1 && d(
+        "MERMAID_MIN_RANK_LENGTH",
+        "Minimum rank-length hint is omitted; native layout chooses spacing.",
+        "layout",
+        "warning",
+        [b]
+      ), (E.animate || E.animation) && d("MERMAID_EDGE_ANIMATION", "Edge animation is omitted.", "appearance", "warning", [
+        b
+      ]), (E.interpolate || c.defaultEdgeInterpolate) && d(
+        "MERMAID_EDGE_CURVE",
+        "Mermaid curve hints are omitted; native routing is used.",
+        "layout",
+        "warning",
+        [b]
+      );
+      const T = u(
+        E.classes,
+        [...c.defaultEdgeStyle, ...E.style],
+        !1,
+        b
+      );
+      T.length && d(
+        "MERMAID_EDGE_STYLE",
+        "Per-edge CSS is omitted because native edge appearance is not a general CSS style map: " + T.join("; "),
+        "appearance",
+        "warning",
+        [b]
+      );
+    }
+    return h();
+  } catch (f) {
+    return d(
+      "MERMAID_MAPPING_ERROR",
+      "Could not map the parser snapshot: " + (f instanceof Error ? f.message : String(f)),
+      "semantics",
+      "error"
+    ), h();
+  }
+}
+function sa(e, t, s) {
+  const n = na(e, t, s);
+  if (!n.nativeSource) return n;
+  try {
+    return si(n.nativeSource), n;
+  } catch (o) {
+    return {
+      ...n,
+      status: "failed",
+      nativeSource: void 0,
+      facts: void 0,
+      diagnostics: [
+        ...n.diagnostics,
+        {
+          code: "IMPORT_NATIVE_INVALID",
+          severity: "error",
+          impact: "semantics",
+          message: "The converted diagram cannot be represented in native source: " + (o instanceof Error ? o.message : String(o))
+        }
+      ]
+    };
+  }
+}
+export {
+  sa as importMermaidFlow
+};