@draftably/mermaid 0.0.0-stage → 0.1.0

package/dist/cdn/mermaid-importer-SlRnjUhj.mjs

@@ -0,0 +1,3753 @@
+import { MERMAID_VERSION as Wt } from "./mermaid-facade-BoLWBerE.mjs";
+const co = {
+  "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 } }
+}, rt = "269b2d3580f4", Pn = {
+  "sans-500": {
+    family: `Draft Inter ${rt}`,
+    weight: 500,
+    file: "inter-latin-500-normal.woff2"
+  },
+  "sans-600": {
+    family: `Draft Inter ${rt}`,
+    weight: 600,
+    file: "inter-latin-600-normal.woff2"
+  },
+  "serif-600": {
+    family: `Draft Source Serif ${rt}`,
+    weight: 600,
+    file: "source-serif-4-latin-600-normal.woff2"
+  },
+  "mono-500": {
+    family: `Draft JetBrains Mono ${rt}`,
+    weight: 500,
+    file: "jetbrains-mono-latin-500-normal.woff2"
+  }
+}, fo = ["sans", "serif", "mono"], ho = {
+  sans: "Inter, Arial, sans-serif",
+  serif: "'Source Serif 4', Georgia, serif",
+  mono: "'JetBrains Mono', Menlo, Consolas, monospace"
+}, Fn = (e, t) => e === "serif" ? "serif-600" : e === "mono" ? "mono-500" : t ? "sans-600" : "sans-500", uo = (e) => `'${Pn[Fn(e, !0)].family}', ${ho[e]}`;
+function gt(e, t, i, o) {
+  const s = Fn(e, t);
+  return { role: e, face: s, family: uo(e), weight: Pn[s].weight, size: i, lineHeight: o };
+}
+const po = co;
+function pe(e, t) {
+  const i = po[t.face];
+  let o = 0;
+  for (const s of e) o += i.advances[s] ?? i.fallback;
+  return o * t.size / i.unitsPerEm;
+}
+function Cn(e) {
+  const t = [];
+  let i = "";
+  for (const o of e.split(/(?<=[/._:-])(?=[^/._:-])|(?<=[a-z0-9])(?=[A-Z])/))
+    /[\p{L}\p{N}]/u.test(o) ? (t.push(i + o), i = "") : i += o;
+  return i && t.length ? t[t.length - 1] += i : i && t.push(i), t.length > 1 && t[t.length - 1].length <= 3 && t.splice(-2, 2, t[t.length - 2] + t[t.length - 1]), t;
+}
+function jn(e, t) {
+  return Math.max(
+    0,
+    ...String(e).split(/\s+/).flatMap(Cn).map((i) => pe(i, t))
+  );
+}
+function go(e, t, i) {
+  const o = [];
+  let s = "";
+  for (const r of e.split(/\s+/)) {
+    if (!r) continue;
+    const l = o[o.length - 1];
+    !s && l !== void 0 && /\d$/.test(l) && /^(%|[\p{L}µ]{1,3}[.,;:)]?)$/u.test(r) && pe(l + " " + r, i) <= t ? o[o.length - 1] = l + " " + r : s && pe(s + " " + r, i) <= t ? (o.push(s + " " + r), s = "") : (s && o.push(s), s = "", !/[\p{L}\p{N}]/u.test(r) && r.length <= 2 ? s = r : o.push(r));
+  }
+  if (s) {
+    const r = o[o.length - 1];
+    r !== void 0 && pe(r + " " + s, i) <= t ? o[o.length - 1] = r + " " + s : o.push(s);
+  }
+  return o;
+}
+function mo(e, t, i) {
+  const o = (l) => pe(l, i) <= t, s = [];
+  let r = "";
+  for (const l of e) {
+    if (!o(l)) {
+      r && s.push(r);
+      let h = "";
+      for (const c of Cn(l)) {
+        if (h && o(h + c)) {
+          h += c;
+          continue;
+        }
+        if (h && s.push(h), h = "", o(c)) {
+          h = c;
+          continue;
+        }
+        for (const M of c)
+          h && !o(h + M) && (s.push(h), h = ""), h += M;
+      }
+      r = h;
+      continue;
+    }
+    r && !o(r + " " + l) ? (s.push(r), r = l) : r += (r ? " " : "") + l;
+  }
+  return s.push(r), s;
+}
+function wo(e, t, i, o) {
+  const s = e.map((n) => pe(n, o)), r = pe(" ", o);
+  if (s.some((n) => n > i)) return;
+  const l = [0];
+  for (const n of s) l.push(l[l.length - 1] + n);
+  const h = (n, a) => l[a] - l[n] + (a - n - 1) * r, c = h(0, s.length) / t, M = (c / 10) ** 2, m = [[0, ...s.map(() => 1 / 0)]], d = [[]];
+  for (let n = 1; n <= t; n++) {
+    m.push(s.map(() => 1 / 0).concat(1 / 0)), d.push([]);
+    for (let a = n; a <= s.length; a++)
+      for (let p = a - 1; p >= n - 1 && h(p, a) <= i; p--) {
+        const u = m[n - 1][p] + (h(p, a) - c) ** 2;
+        u < m[n][a] - M && ([m[n][a], d[n][a]] = [u, p]);
+      }
+  }
+  if (!Number.isFinite(m[t][s.length])) return;
+  const f = [];
+  for (let n = t, a = s.length; n > 0; a = d[n][a], n--)
+    f.unshift(e.slice(d[n][a], a).join(" "));
+  return f;
+}
+function ot(e, t, i, o = !1) {
+  const s = [];
+  for (const r of String(e).split(`
+`)) {
+    const l = o ? go(r, t, i) : r.split(/\s+/).filter(Boolean), h = mo(l, t, i);
+    s.push(
+      ...o && h.length > 1 ? wo(l, h.length, t, i) ?? h : h
+    );
+  }
+  return s.length ? s : [""];
+}
+const Xt = ["drafting", "fieldnotes", "signal", "ink", "blueprint"], mt = "drafting", Tt = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950], wt = 500, yo = (e) => et[e]?.dark ? 900 : 100, Lt = [
+  "primary",
+  "secondary",
+  "slate",
+  "stone",
+  "blue",
+  "sky",
+  "teal",
+  "mint",
+  "green",
+  "amber",
+  "orange",
+  "red",
+  "rose",
+  "violet"
+], Rt = (e) => Lt.includes(e), Kt = ["dashed", "solid"], Bn = () => ({
+  theme: mt,
+  overrides: {},
+  colors: []
+}), Qt = {
+  paddingX: { min: 4, max: 48 },
+  paddingY: { min: 4, max: 48 },
+  radius: { min: 0, max: 24 }
+}, Mo = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i, et = {
+  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]
+  }
+}, Un = (e) => e <= 0.04045 ? e / 12.92 : ((e + 0.055) / 1.055) ** 2.4, xo = (e) => e <= 31308e-7 ? 12.92 * e : 1.055 * e ** (1 / 2.4) - 0.055;
+function zn(e) {
+  const t = e.length === 4 ? e.replace(/[0-9a-f]/gi, (i) => i + i) : e;
+  return [1, 3, 5].map((i) => parseInt(t.slice(i, i + 2), 16) / 255);
+}
+function qt(e) {
+  const [t, i, o] = zn(e).map(Un), s = Math.cbrt(0.4122214708 * t + 0.5363325363 * i + 0.0514459929 * o), r = Math.cbrt(0.2119034982 * t + 0.6806995451 * i + 0.1073969566 * o), l = Math.cbrt(0.0883024619 * t + 0.2817188376 * i + 0.6299787005 * o), h = 0.2104542553 * s + 0.793617785 * r - 0.0040720468 * l, c = 1.9779984951 * s - 2.428592205 * r + 0.4505937099 * l, M = 0.0259040371 * s + 0.7827717662 * r - 0.808675766 * l;
+  return [h, Math.hypot(c, M), (Math.atan2(M, c) * 180 / Math.PI + 360) % 360];
+}
+function Vt([e, t, i]) {
+  const o = t * Math.cos(i * Math.PI / 180), s = t * Math.sin(i * Math.PI / 180), r = (e + 0.3963377774 * o + 0.2158037573 * s) ** 3, l = (e - 0.1055613458 * o - 0.0638541728 * s) ** 3, h = (e - 0.0894841775 * o - 1.291485548 * s) ** 3;
+  return [
+    4.0767416621 * r - 3.3077115913 * l + 0.2309699292 * h,
+    -1.2684380046 * r + 2.6097574011 * l - 0.3413193965 * h,
+    -0.0041960863 * r - 0.7034186147 * l + 1.707614701 * h
+  ];
+}
+function Qe([e, t, i]) {
+  let o = t, s = Vt([e, o, i]);
+  for (; o > 0 && s.some((r) => r < -5e-4 || r > 1.0005); )
+    o = Math.max(0, o - 4e-3), s = Vt([e, o, i]);
+  return "#" + s.map(
+    (r) => Math.round(Math.min(1, Math.max(0, xo(Math.min(1, Math.max(0, r))))) * 255).toString(16).padStart(2, "0")
+  ).join("").toUpperCase();
+}
+function Ot(e) {
+  const [t, i, o] = zn(e).map(Un);
+  return 0.2126 * t + 0.7152 * i + 0.0722 * o;
+}
+function yt(e, t) {
+  const [i, o] = [Ot(e), Ot(t)].sort((s, r) => r - s);
+  return (i + 0.05) / (o + 0.05);
+}
+const Zt = {
+  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
+}, Gt = (e) => e <= 300, qn = (e) => e >= 45 && e <= 110, $t = { 400: 0.8, 500: 0.74 }, bo = (e, t) => $t[e] === void 0 ? void 0 : $t[e] - (t < 65 ? 0.07 : 0), vo = (e, t) => Gt(e) || qn(t) && e in $t, Re = {
+  /** 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
+}, ut = (e) => Math.max(0.18, 1 - ((e - 0.6) / 0.42) ** 2), ko = {
+  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]
+}, Eo = (e) => Qe([0.24, 0.035, e]), Ao = "#FFFFFF";
+function Ue(e, t, i) {
+  if (yt(e, t) >= i) return e;
+  const [o, s, r] = qt(e), l = Ot(t) > 0.18 ? -0.01 : 0.01;
+  let h = e;
+  for (let c = o; c > 0 && c < 1 && yt(h, t) < i; c += l)
+    h = Qe([c, s, r]);
+  return h;
+}
+function Jt(e, t, i, o, s, r, l) {
+  const h = vo(e, o), c = h ? Eo(o) : Ao, M = Gt(e) ? Re.paleInk : Re.darkInk;
+  let m = l ? qt(l)[0] : t, d = l ?? Qe([m, i * ut(m), o]);
+  for (; yt(d, c) < M && m > 0.05 && m < 0.995; )
+    m += h ? 5e-3 : -0.01, d = Qe([m, i * ut(m), o]);
+  const f = h ? m - 0.2 : r ? m + 0.14 : m - 0.08;
+  let n = Qe([f, i * ut(f) * 1.1, o]);
+  return yt(d, s) < Re.outline && (n = Ue(n, s, Re.outline)), { swatch: { fill: d, stroke: n, ink: c }, L: m };
+}
+const _o = 0.055;
+function Gn(e, t, i, o, s) {
+  const r = /* @__PURE__ */ new Map();
+  let l = 1;
+  for (const h of Tt) {
+    const c = qn(e) ? bo(h, e) : void 0, M = Gt(h) ? Zt[h] : Math.min(c ?? Zt[h], l - _o);
+    let m = Jt(
+      h,
+      M,
+      t,
+      e,
+      i,
+      o,
+      s?.[1] === h ? s[0] : void 0
+    );
+    m.L >= l - 0.01 && (m = Jt(h, M, t, e, i, o)), l = m.L, r.set(h, m.swatch);
+  }
+  return r;
+}
+function en([e, t], i, o) {
+  const [s, r, l] = qt(e);
+  return Gn(l, r / ut(s), i, o, [e.toUpperCase(), t]);
+}
+const tn = /* @__PURE__ */ new Map();
+function So(e, t = et[e].canvas) {
+  const i = e + t;
+  let o = tn.get(i);
+  if (!o) {
+    const s = et[e];
+    o = /* @__PURE__ */ new Map([
+      ["primary", en(s.primary, t, s.dark)],
+      ["secondary", en(s.secondary, t, s.dark)]
+    ]);
+    for (const [r, l] of Object.entries(ko)) {
+      const [h, c] = s.hues?.[r] ?? l;
+      o.set(r, Gn(h, c * s.chroma, t, s.dark));
+    }
+    tn.set(i, o);
+  }
+  return o;
+}
+const Io = (e) => Math.round(e + 32), lt = /* @__PURE__ */ new Map();
+function tt(e) {
+  const t = e ?? Bn(), i = JSON.stringify(t), o = lt.get(i);
+  if (o) return o;
+  const s = et[t.theme] ?? et[mt], r = t.overrides, l = r.titleFont ?? s.titleFont, h = r.annotationFont ?? s.annotationFont, c = r.canvas ?? s.canvas, M = new Map(
+    [...So(t.theme, c)].map(([n, a]) => [n, new Map(a)])
+  ), m = /* @__PURE__ */ new Set();
+  for (const n of t.colors) {
+    M.has(n.family) || (M.set(n.family, /* @__PURE__ */ new Map()), m.add(n.family));
+    const a = M.get(n.family), p = a.get(n.shade);
+    (p || n.fill && n.stroke && n.ink) && a.set(n.shade, {
+      fill: n.fill ?? p.fill,
+      stroke: n.stroke ?? p.stroke,
+      ink: n.ink ?? p.ink
+    });
+  }
+  const d = gt(l, !0, s.titleSize, s.titleLine), f = {
+    theme: t.theme,
+    dark: s.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 ?? Ue(s.text, c, 7),
+    muted: Ue(s.muted, c, Re.connection),
+    connection: r.connection ?? Ue(s.connection, c, Re.connection),
+    node: {
+      fill: s.node.fill,
+      stroke: Ue(s.node.stroke, c, Re.outline),
+      ink: r.text ?? Ue(s.node.ink, s.node.fill, Re.paleInk)
+    },
+    group: {
+      fill: s.group.fill,
+      stroke: Ue(s.group.stroke, c, Re.frame),
+      ink: Ue(s.group.ink, s.group.fill, Re.paleInk)
+    },
+    paddingX: r.paddingX ?? s.paddingX,
+    paddingY: r.paddingY ?? s.paddingY,
+    radius: r.radius ?? s.radius,
+    shadow: s.shadow,
+    title: d,
+    groupTitle: d,
+    annotation: gt(
+      h,
+      !1,
+      s.annotationSize,
+      Math.round(s.annotationSize * 1.4)
+    ),
+    groupHeader: Io(d.lineHeight),
+    families: M,
+    custom: m,
+    strikeRemoved: !!t.config?.strikeRemoved
+  };
+  return lt.size > 50 && lt.clear(), lt.set(i, f), f;
+}
+function nn(e, t = 0) {
+  if (!e.length) return { x: 70, y: 160, w: 240, h: 160 };
+  let i = 1 / 0, o = 1 / 0, s = -1 / 0, r = -1 / 0;
+  for (const l of e)
+    i = Math.min(i, l.x), o = Math.min(o, l.y), s = Math.max(s, l.x + l.w), r = Math.max(r, l.y + l.h);
+  return { x: i - t, y: o - t, w: s - i + t * 2, h: r - o + t * 2 };
+}
+const be = 24, To = 48, Dt = 97, Ve = 10, Mt = 18, Hn = (e, t = To) => ({
+  x: e.x + be,
+  y: e.y + t
+}), Lo = 48;
+function Yn(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 xt(e, t, i, o, s = !1) {
+  if (e === "diamond") return { width: Math.max(40, t * 0.55), maxHeight: i * 0.45 };
+  if (e === "circle") return { width: Math.max(40, t * 0.7), maxHeight: i * 0.7 };
+  const r = e === "text" ? Math.min(o.paddingY, 11) : o.paddingY;
+  return {
+    width: Math.max(40, t - 2 * o.paddingX - (s ? 30 : 0) - (e === "pill" ? 8 : 0)),
+    maxHeight: i - 2 * r
+  };
+}
+function Ro(e, t, i, o) {
+  const s = t * o.title.lineHeight;
+  return e === "circle" ? Math.max(i, Math.ceil(s / 0.7)) : e === "text" ? s + 2 * Math.min(o.paddingY, 11) : s + 2 * o.paddingY;
+}
+const nt = (e, t, i) => ot(e, t, i.title, !0), Oo = 6;
+function $o(e, t, i) {
+  const o = t - 2 * Oo;
+  for (let s = 1; s * i.title.lineHeight < o; s++) {
+    const r = o - s * i.title.lineHeight;
+    if (r >= 40 && nt(e, r, i).length <= s) return r;
+  }
+}
+const on = 3, pt = (e, t = 1) => e.groupHeader + (t - 1) * e.groupTitle.lineHeight, Do = 168, Wn = (e, t = !1) => t ? { ...e.annotation, size: e.annotation.size + 1.5, lineHeight: e.annotation.lineHeight + 2 } : e.annotation, No = 140, Po = (e, t, i = !1) => ot(e, i ? Do : No, Wn(t, i)), ze = { out: 36, down: 22, label: 4 };
+function He(e, t = tt(), i = !1) {
+  const o = Wn(t, i), s = Po(e, t, i), r = Math.max(...s.map((l) => pe(l, o))) + 16;
+  return {
+    w: Math.round(Math.max(36, r)),
+    h: Math.round(s.length * o.lineHeight + 6)
+  };
+}
+function sn(e, t) {
+  if (!e) return { right: ze.out, above: 0, below: ze.down };
+  const { w: i, h: o } = He(e, t, !0);
+  return {
+    right: ze.out + ze.label + i,
+    above: Math.max(0, o / 2 - ze.down / 2),
+    below: Math.max(ze.down, ze.down / 2 + o / 2)
+  };
+}
+const Et = 8, an = 16, Nt = 10, Fo = 64, Co = 240, Pt = (e) => Math.round(e + 14);
+function jo(e, t) {
+  if (e.size?.height !== void 0) return { w: e.size.width, h: e.size.height };
+  if (e.size) {
+    const r = nt(e.label, e.size.width - 2 * t.paddingX, t).length;
+    return {
+      w: e.size.width,
+      h: r * t.title.lineHeight + 2 * Math.min(t.paddingY, Nt)
+    };
+  }
+  const i = 2 * t.paddingX, o = Math.min(Co, Math.max(Fo, Math.ceil(pe(e.label, t.title)) + i)), s = nt(e.label, o - i, t).length;
+  return { w: o, h: s * t.title.lineHeight + 2 * Math.min(t.paddingY, Nt) };
+}
+function Bo(e, t, i, o = 0) {
+  const s = e.filter((R) => !R.marker), r = new Map(s.map((R) => [R.id, jo(R, i)])), l = Math.max(
+    1,
+    t.columns ?? (t.direction === "down" ? 1 : s.reduce((R, L) => R + (L.span ?? 1), 0))
+  ), h = /* @__PURE__ */ new Map();
+  let c = 0, M = 0;
+  for (const R of s) {
+    const L = Math.min(R.span ?? 1, l);
+    M + L > l && (c++, M = 0), h.set(R.id, { row: c, col: M, span: L }), M += L;
+  }
+  const m = Array(l).fill(0), d = Array(s.length ? c + 1 : 0).fill(0);
+  for (const R of s) {
+    const { row: L, col: H, span: I } = h.get(R.id);
+    I === 1 && (m[H] = Math.max(m[H], r.get(R.id).w)), d[L] = Math.max(d[L], r.get(R.id).h);
+  }
+  for (const R of s) {
+    const { col: L, span: H } = h.get(R.id), I = r.get(R.id).w - m.slice(L, L + H).reduce((P, O) => P + O, 0);
+    I > 0 && (m[L + H - 1] += I);
+  }
+  const f = o - m.reduce((R, L) => R + L, 0);
+  f > 0 && (m[l - 1] += f);
+  const n = [0], a = [0];
+  for (const R of m) n.push(n.at(-1) + R);
+  for (const R of d) a.push(a.at(-1) + R);
+  const p = n.at(-1), u = a.at(-1), g = /* @__PURE__ */ new Map();
+  for (const R of s) {
+    const { row: L, col: H, span: I } = h.get(R.id);
+    g.set(R.id, { x: n[H], y: a[L], w: n[H + I] - n[H], h: d[L] });
+  }
+  const x = Pt(i.groupTitle.lineHeight), E = l > 1 || t.direction === "right";
+  return e.forEach((R, L) => {
+    if (!R.marker) return;
+    const H = e.slice(L + 1).find((O) => !O.marker), I = H ? g.get(H.id) : void 0, P = Et / 2;
+    g.set(
+      R.id,
+      E ? { x: (I?.x ?? p) - P, y: -x, w: Et, h: u + x + an } : { x: 0, y: (I?.y ?? u) - P, w: p + an, h: Et }
+    );
+  }), { boxes: g, w: p, h: u };
+}
+const Uo = { bit: 24, byte: 48 }, zo = { bit: 32, byte: 16 };
+function qo(e, t, i) {
+  const o = t.columns ?? zo[t.unit], s = t.unitWidth ?? Uo[t.unit], r = 2 * Math.min(i.paddingX, 6), l = /* @__PURE__ */ new Map();
+  let h = 0, c = 0;
+  for (const u of e) {
+    const g = [];
+    if (u.open)
+      g.push({ row: h, col: c, span: o - c }), h++, c = 0;
+    else
+      for (let x = u.span ?? 1; x > 0; ) {
+        const E = Math.min(x, o - c);
+        g.push({ row: h, col: c, span: E }), x -= E, c += E, c === o && (h++, c = 0);
+      }
+    l.set(u.id, g);
+  }
+  const M = c ? h + 1 : h, m = (u) => l.get(u).reduce((g, x) => x.span > g.span ? x : g), d = Math.max(
+    0,
+    ...e.map((u) => nt(u.label, Math.max(8, m(u.id).span * s - r), i).length * i.title.lineHeight + 2 * Math.min(i.paddingY, Nt))
+  ), f = (u) => ({
+    x: u.col * s,
+    y: u.row * d,
+    w: u.span * s,
+    h: d
+  }), n = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+  for (const u of e) {
+    const g = m(u.id), x = l.get(u.id).filter((E) => E !== g);
+    n.set(u.id, f(g)), x.length && a.set(u.id, x.map(f));
+  }
+  const p = t.ruler ? Math.round(i.annotation.lineHeight + 6) : 0;
+  return {
+    boxes: n,
+    pieces: a,
+    open: e.filter((u) => u.open).map((u) => u.id),
+    ...t.ruler ? {
+      ruler: {
+        h: p,
+        ticks: Array.from({ length: o }, (u, g) => ({
+          x: g * s + s / 2,
+          label: String(g)
+        }))
+      }
+    } : {},
+    w: o * s,
+    h: M * d
+  };
+}
+const Go = /\[([^\]\n]+)\]\(([^)\s]+)\)/g;
+function Ho(e, t, i) {
+  let o = "";
+  const s = [];
+  let r = 0;
+  for (const c of e.matchAll(Go)) {
+    const M = e.slice(r, c.index);
+    o += M + c[1], s.push(
+      ...Array(M.length).fill(void 0),
+      ...Array(c[1].length).fill(c[2])
+    ), r = c.index + c[0].length;
+  }
+  o += e.slice(r), s.push(...Array(e.length - r).fill(void 0));
+  let l = 0;
+  const h = (c) => /\s/.test(o[c] ?? "");
+  return ot(o, t, i).map((c) => {
+    for (; l < o.length && h(l); ) l++;
+    const M = [];
+    for (const f of c)
+      if (f === " " && h(l)) {
+        const n = s[l - 1];
+        for (; l < o.length && h(l); ) l++;
+        M.push(n && n === s[l] ? n : void 0);
+      } else M.push(s[l++]);
+    const m = [];
+    M.forEach((f, n) => {
+      const a = m.at(-1);
+      a && a.href === f ? a.text += c[n] : m.push({ text: c[n], href: f, x: 0, w: 0 });
+    });
+    let d = 0;
+    for (const f of m)
+      f.x = d, f.w = pe(f.text, i), d += f.w;
+    return m.length ? m : [{ text: "", x: 0, w: 0 }];
+  });
+}
+const Yo = ["below", "above", "left", "right"], Xn = 280, Kn = { x: 12, y: 8 }, rn = Kn.x, Wo = Kn.y, Xo = 8;
+function Ko(e, t) {
+  const i = e.annotation, o = Ho(t.text, (t.width ?? Xn) - rn * 2, i), s = Math.ceil(Math.max(...o.map((r) => r.reduce((l, h) => l + h.w, 0)))) + rn * 2;
+  return { note: t, lines: o, rect: { x: 0, y: 0, w: s, h: o.length * i.lineHeight + Wo * 2 } };
+}
+function Qo(e, t, i, { left: o, right: s, top: r }) {
+  const l = t.map(() => null);
+  for (const h of ["left", "right"]) {
+    let c = r;
+    t.map((M, m) => ({ note: M, i: m, row: i.get(M.near ?? "") })).filter((M) => M.row !== void 0 && (M.note.side ?? "right") === h).sort((M, m) => M.row - m.row).forEach(({ note: M, i: m, row: d }) => {
+      const { w: f, h: n } = Ko(e, M).rect, a = Math.max(c, Math.round(d - n / 2));
+      l[m] = { x: h === "right" ? s : o - f, y: a, w: f, h: n }, c = a + n + Xo;
+    });
+  }
+  return l;
+}
+const Vo = 1.1;
+function Zo(e, t, i) {
+  const o = new Map(e), s = [...o].flatMap(
+    ([r, l]) => Object.keys(l.lines).filter((h) => l.lines[h]).map((h) => ({ id: r, side: h, n: l.lines[h] }))
+  );
+  s.sort((r, l) => r.n - l.n || (r.id < l.id ? 1 : -1));
+  for (const { id: r, side: l } of s) {
+    if (!o.size || i(o) <= t * Vo) break;
+    const h = { ...o.get(r), lines: { ...o.get(r).lines, [l]: 0 } };
+    h[l] = l === "top" ? 0 : be, Object.values(h.lines).some(Boolean) ? o.set(r, h) : o.delete(r);
+  }
+  return o;
+}
+const Jo = 20, ln = 16, ct = 10;
+function es(e, t, i = {}) {
+  const o = new Map(e.map((a) => [a.id, a])), s = (a) => {
+    const p = [];
+    for (let u = o.get(a); u && u.parent !== "root"; u = o.get(u.parent))
+      p.push(u.parent);
+    return p;
+  }, r = (a, p) => a === p || s(a).includes(p), l = /* @__PURE__ */ new Map(), h = (a, p) => {
+    const u = l.get(a) ?? { left: 0, right: 0, top: 0, bottom: 0 };
+    u[p]++, l.set(a, u);
+  }, c = (a) => ({ x: a.x + a.w / 2, y: a.y + a.h / 2 }), M = (a, p, u, g) => e.some((x) => x.id === a.id || x.id === g || !r(x.id, p.id) || x.id === p.id || r(a.id, x.id) || r(g, x.id) || !(u === "left" || u === "right" ? x.y < a.y + a.h + ct && x.y + x.h > a.y - ct : x.x < a.x + a.w + ct && x.x + x.w > a.x - ct) ? !1 : u === "right" ? x.x >= a.x + a.w : u === "left" ? x.x + x.w <= a.x : u === "bottom" ? x.y >= a.y + a.h : x.y + x.h <= a.y), m = (a, p) => [
+    ...p.x > a.x + a.w ? ["right"] : [],
+    ...p.x < a.x ? ["left"] : [],
+    ...p.y > a.y + a.h ? ["bottom"] : [],
+    // A line leaves through the top only past the title band, which it may not cross.
+    ...p.y < a.y ? ["top"] : []
+  ];
+  for (const a of t) {
+    const p = o.get(a.source), u = o.get(a.target);
+    if (!p || !u || p === u || a.from !== "auto" || a.to !== "auto") continue;
+    const g = [p.id, ...s(p.id)], x = [u.id, ...s(u.id)].find((I) => g.includes(I) && I !== p.id && I !== u.id), E = x && o.get(x)?.type === "group" ? o.get(x) : void 0, R = (I) => {
+      let P = I;
+      for (; P.parent !== (E?.id ?? "root"); ) P = o.get(P.parent);
+      return P;
+    }, [L, H] = [R(p), R(u)];
+    if (E && L !== H) {
+      const I = (N, Q, z) => N === Q || m(Q, c(z)).some((Y) => !M(N, Q, Y, ""));
+      if (!e.some(
+        (N) => N.parent === E.id && N !== L && N !== H && ts(L, H, N)
+      ) && I(p, L, u) && I(u, H, p)) continue;
+      const O = Math.abs(c(L).y - c(H).y) > Math.abs(c(L).x - c(H).x), y = (N, Q, z) => (c(N)[z] - c(Q)[z]) / Math.max(1, z === "x" ? Q.w : Q.h), D = O ? "x" : "y", w = y(p, L, D) + y(u, H, D), b = c(H)[O ? "y" : "x"] > c(L)[O ? "y" : "x"], _ = Math.abs(w) > 0.1 ? w > 0 : b;
+      h(E.id, O ? _ ? "right" : "left" : _ ? "bottom" : "top");
+      continue;
+    }
+    for (const [I, P] of [
+      [p, u],
+      [u, p]
+    ]) {
+      const O = I.parent === "root" ? void 0 : o.get(I.parent);
+      if (!O || E && O.id === E.id || r(P.id, O.id)) continue;
+      const y = m(O, c(P));
+      !y.length || y.some((D) => !M(I, O, D, P.id)) || (y.some((D) => D === "left" || D === "right") ? h(O.id, c(I).y < c(O).y + 24 ? "top" : "bottom") : h(O.id, c(P).x < c(I).x ? "left" : "right"));
+    }
+  }
+  const d = i.standoff ?? Jo, f = Math.max(i.edgeGap ?? ln, i.portGap ?? ln), n = (a) => a ? 2 * d + (a - 1) * f : be;
+  return new Map(
+    [...l].map(([a, p]) => [
+      a,
+      {
+        left: n(p.left),
+        right: n(p.right),
+        top: p.top ? d + (p.top - 1) * f : 0,
+        bottom: n(p.bottom),
+        lines: p
+      }
+    ])
+  );
+}
+function ts(e, t, i) {
+  const o = Math.min(e.x + e.w, t.x + t.w), s = Math.max(e.x, t.x), r = Math.min(e.y + e.h, t.y + t.h), l = Math.max(e.y, t.y), h = { x: Math.min(o, s), y: Math.min(r, l) }, c = { x: Math.max(o, s), y: Math.max(r, l) };
+  return i.x < c.x && i.x + i.w > h.x && i.y < c.y && i.y + i.h > h.y;
+}
+const cn = 20, dt = 20, ns = 12, os = 16;
+function ss(e, t, i, o, s = (r) => He(r)) {
+  const r = /* @__PURE__ */ new Map();
+  for (const l of e.filter((h) => h.scope === "root")) {
+    const h = l.axis === "right", c = (u) => h ? u.x : u.y, M = (u) => h ? u.x + u.w : u.y + u.h, m = (u) => h ? u.y : u.x, d = (u) => h ? u.y + u.h : u.x + u.w, f = (u) => (c(u) + M(u)) / 2, n = (u) => (m(u) + d(u)) / 2, a = [...i.values()].filter((u) => u.parent === l.scope);
+    (l.bands?.map((u) => u.map((g) => i.get(g))) ?? [a]).forEach((u) => {
+      const g = Math.min(...u.map(m)), x = Math.max(...u.map(d)), E = Math.min(...u.map(c)), R = Math.max(...u.map(M)), L = new Set(u.map((O) => O.id)), H = (O) => [...i.values()].some(
+        (y) => y.parent === l.scope && !L.has(y.id) && c(y) < R && M(y) > E && (O ? d(y) <= g : m(y) >= x)
+      ), I = { before: !H(!0), after: !H(!1) }, P = [];
+      for (const O of t) {
+        if (o.has(O.id) || O.from !== "auto" || O.to !== "auto") continue;
+        const y = i.get(O.source), D = i.get(O.target);
+        if (!y || !D || y === D || !L.has(y.id) || !L.has(D.id) || y.type === "group" || D.type === "group") continue;
+        const w = f(D) < f(y), [b, _] = w ? [D, y] : [y, D], N = Math.min(n(y), n(D)) - 8, Q = Math.max(n(y), n(D)) + 8, z = u.filter(
+          (A) => A !== y && A !== D && c(A) >= M(b) - 1 && M(A) <= c(_) + 1
+        );
+        if (!z.some((A) => m(A) < Q && d(A) > N) && !(w && z.length)) continue;
+        const $ = (A, F) => !u.some(
+          (Z) => Z !== A && c(Z) < M(A) && M(Z) > c(A) && (F ? d(Z) <= m(A) : m(Z) >= d(A))
+        ), k = (A) => !I[A ? "before" : "after"] || !$(y, A) || !$(D, A) ? 1 / 0 : A ? m(y) - g + (m(D) - g) : x - d(y) + (x - d(D)), [T, j] = [k(!0), k(!1)];
+        if (!Number.isFinite(T) && !Number.isFinite(j)) continue;
+        const v = T === j ? !w : T < j;
+        P.push({ id: O.id, before: v, from: f(b), to: f(_), back: w });
+      }
+      for (const O of [!0, !1]) {
+        const y = P.filter((b) => b.before === O).sort((b, _) => b.to - b.from - (_.to - _.from) || b.from - _.from), D = [], w = /* @__PURE__ */ new Set();
+        for (const b of y) {
+          const _ = t.find((A) => A.id === b.id);
+          if (w.has(_.source) || w.has(_.target)) continue;
+          w.add(_.source).add(_.target);
+          let N = 0;
+          for (; D[N]?.some(([A, F]) => b.from < F + dt && b.to > A - dt); ) N++;
+          (D[N] ??= []).push([b.from, b.to]);
+          const Q = t.find((A) => A.id === b.id), z = i.get(Q.target), Y = O ? g - cn - N * dt : x + cn + N * dt, $ = is(z, u, !b.back, c, M), k = Math.min(os, (d(z) - m(z)) / 2 - ns), T = as(z, u, !b.back, Q.id, t, i, c, M, m, d), j = z.shape === "diamond" && T.length > 0 || T.some((A) => {
+            if (!A.label) return !1;
+            const { w: F, h: Z } = s(A.label);
+            return (h ? Z : F) / 2 + 2 > k;
+          }), v = j ? f(z) : b.back ? M(z) + $ / 2 : c(z) - $ / 2;
+          r.set(b.id, {
+            ...h ? { y: Math.round(Y) } : { x: Math.round(Y) },
+            enter: Math.round(v),
+            out: !0,
+            ...j ? { face: !0 } : {}
+          });
+        }
+      }
+    });
+  }
+  return r;
+}
+function is(e, t, i, o, s) {
+  const r = t.filter((l) => l !== e && (i ? s(l) <= o(e) : o(l) >= s(e))).map((l) => i ? o(e) - s(l) : o(l) - s(e));
+  return Math.min(48, ...r);
+}
+function as(e, t, i, o, s, r, l, h, c, M) {
+  const m = new Set(
+    t.filter(
+      (f) => f !== e && (i ? h(f) <= l(e) : l(f) >= h(e)) && c(f) < M(e) && M(f) > c(e)
+    ).map((f) => f.id)
+  ), d = (f) => {
+    for (let n = r.get(f); n; n = r.get(n.parent)) if (m.has(n.id)) return !0;
+    return !1;
+  };
+  return s.filter(
+    (f) => f.id !== o && (f.source === e.id && d(f.target) || f.target === e.id && d(f.source))
+  );
+}
+const rs = ["vscode", "vscode-insiders", "cursor", "windsurf", "zed"], dn = [
+  "arrow",
+  "none",
+  "triangle",
+  "open-triangle",
+  "diamond",
+  "open-diamond",
+  "circle",
+  "cross"
+];
+function Qn(e) {
+  return {
+    title: gt(e.title.role, !0, 20, 26),
+    subtitle: gt(e.annotation.role, !1, 13, 18)
+  };
+}
+const fn = 360, ls = 70;
+function cs(e, t) {
+  const i = Qn(e).subtitle, o = pe("abcdefghijklmnopqrstuvwxyz ", i) / 27 * ls;
+  return Math.round(Math.min(Math.max(t, fn), Math.max(o, fn)));
+}
+const ds = Qn;
+function fs(e) {
+  return [...us(e), ...ps(e), ...gs(e)];
+}
+const hs = /* @__PURE__ */ new Set(["slate", "stone"]);
+function us(e) {
+  if (e.objects.some((r) => r.status) || e.edges.some((r) => r.status)) return [];
+  const t = e.appearance.legend ?? [], i = [];
+  if (t.length) {
+    const r = new Set(t.map((c) => c.family)), l = e.objects.filter(
+      (c) => c.color !== "auto" && !hs.has(c.color) && !r.has(c.color)
+    ), h = [...new Set(l.map((c) => c.color))];
+    h.length && i.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: l.map((c) => c.id)
+    });
+  }
+  const o = e.layouts.some((r) => r.algorithm === "sequence"), s = e.edges.filter((r) => r.dashed);
+  return !o && s.length && s.length < e.edges.length && !t.some((r) => r.line) && i.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: s[0].line,
+    ids: s.map((r) => r.id)
+  }), i;
+}
+function ps(e) {
+  return (e.appearance.legend ?? []).flatMap((t, i) => {
+    if (!t.family) return [];
+    const o = e.objects.filter((l) => l.type === "node" && l.color === t.family), s = t.shade ?? wt, r = [...new Set(o.map((l) => l.shade ?? wt))].sort((l, h) => l - h);
+    return !o.length || r.includes(s) ? [] : [
+      {
+        level: "warning",
+        code: "legend-shade",
+        message: `legend ${t.family} is shade ${s}; ${t.family} nodes use ${r.join(", ")}. Add \`shade=${r[0]}\`${r.length > 1 ? " or another of them" : ""}.`,
+        line: e.legendLines[i],
+        ids: o.map((l) => l.id)
+      }
+    ];
+  });
+}
+function gs(e) {
+  const t = [], i = e.appearance.heading?.subtitle;
+  if (i) {
+    const o = tt(e.appearance), s = ot(i, cs(o, 1 / 0), ds(o).subtitle);
+    s.length > 1 && t.push({
+      level: "warning",
+      code: "heading-prose",
+      message: `The subtitle takes ${s.length} lines. Cut it to one short takeaway, about 10 words; let the drawing say the rest.`,
+      ids: []
+    });
+  }
+  return (e.appearance.notes ?? []).forEach((o, s) => {
+    o.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[s],
+      ids: []
+    });
+  }), [...t, ...ms(e)];
+}
+function ms(e) {
+  const t = new Set((e.appearance.footnotes ?? []).flatMap((o) => o.mark ? [o.mark] : []));
+  return t.size ? [
+    ...e.objects.map((o) => ({ id: o.id, text: o.label, line: o.line })),
+    ...e.edges.map((o) => ({ id: o.id, text: o.label, line: o.line }))
+  ].flatMap(
+    (o) => [...o.text.matchAll(/\[([A-Za-z0-9*]{1,3})\]/g)].filter((s) => !t.has(s[1])).map((s) => ({
+      level: "warning",
+      code: "footnote-missing",
+      message: `${o.id} points at [${s[1]}], but no footnote has that marker. Add footnote ${s[1]} "…" or fix the label.`,
+      line: o.line,
+      ids: [o.id]
+    }))
+  ) : [];
+}
+class _e extends Error {
+  constructor(t, i = 0, o = 0) {
+    super((i ? `Line ${i}${o ? `, column ${o}` : ""}: ` : "") + t), this.line = i, this.column = o, this.name = "DslError";
+  }
+}
+const Vn = { "+": "added", "-": "removed", "~": "changed", ".": "context" }, ws = (e) => ({ value: String(e), quoted: !1 }), ys = (e) => ({ value: e, quoted: !0 }), Ms = 'A quote inside a quoted string needs a backslash: write \\" for each inner quote.';
+function xs(e, t = 0) {
+  const i = [], o = [];
+  let s = "", r = 0, l = 0, h = !1, c = !1;
+  const M = () => {
+    s && (i.push(s), o.push(r + 1)), s = "";
+  };
+  for (let m = 0; m < e.length; m++) {
+    const d = e[m];
+    if (s || (r = m), c) {
+      s += d, c = !1;
+      continue;
+    }
+    if (h && d === "\\") {
+      s += d, c = !0;
+      continue;
+    }
+    if (d === '"') {
+      if (h && m + 1 < e.length && !/[\s#]/.test(e[m + 1]) && !e.startsWith("//", m + 1))
+        throw new _e(Ms, t, m + 1);
+      h || (l = m), h = !h, s += d;
+      continue;
+    }
+    const f = d === "/" && e[m + 1] === "/" && !/[^\s"]/.test(e[m - 1] ?? " ");
+    if (!h && (d === "#" || f))
+      return M(), { tokens: i, columns: o, comment: e.slice(m).trim() };
+    !h && /\s/.test(d) ? M() : s += d;
+  }
+  if (h) throw new _e("Unclosed quoted string.", t, l + 1);
+  return M(), { tokens: i, columns: o };
+}
+function hn(e, t, i) {
+  if (!e.startsWith('"')) return ws(e);
+  try {
+    return ys(JSON.parse(e));
+  } catch {
+    throw new _e(
+      'Invalid escape in a quoted string. Use \\" for a quote, \\\\ for a backslash and \\n for a line break.',
+      t,
+      i
+    );
+  }
+}
+function bs(e) {
+  if (typeof e != "string") throw new _e("Source must be text.");
+  if (e.length > 3e5) throw new _e("Limit: 300,000 source characters.");
+  return { lines: e.split(/\r?\n/).map((i, o) => {
+    const s = o + 1, { tokens: r, columns: l, comment: h } = xs(i, s);
+    if (!r.length) return h ? { kind: "comment", text: h } : { kind: "blank" };
+    const [c, ...M] = r, m = Vn[c[0]] && c.length > 1 ? c[0] : void 0, d = m ? c.slice(1) : c, f = [], n = [];
+    return M.forEach((a, p) => {
+      const u = a.indexOf("="), g = l[p + 1];
+      if (u > 0 && !a.startsWith('"')) {
+        const x = a.slice(0, u);
+        if (n.some(([E]) => E === x)) throw new _e(`Duplicate attribute ${x}.`, s);
+        n.push([x, hn(a.slice(u + 1), s, g + u + 1)]);
+      } else f.push(hn(a, s, g));
+    }), { kind: "statement", command: d, ...m ? { mark: m } : {}, args: f, attrs: n, comment: h, line: s };
+  }) };
+}
+const vs = { wide: 2, slide: 1.78, square: 1, page: 0.77, tall: 0.6 };
+function Ft(e, t, i) {
+  const o = Xe(e, t);
+  for (let s = i; s && s !== "root"; s = Xe(e, s))
+    if (Xe(e, s) === o) return s === t ? void 0 : s;
+}
+const ks = ["near", "nudge", "stay", "pin"], un = {
+  "link-base": "linkBase",
+  editor: "editor",
+  "strike-removed": "strikeRemoved"
+}, pn = {
+  "padding-x": "paddingX",
+  "padding-y": "paddingY",
+  radius: "radius",
+  "title-font": "titleFont",
+  "annotation-font": "annotationFont",
+  canvas: "canvas",
+  text: "text",
+  connection: "connection"
+}, gn = [
+  "compound-flow",
+  "boundary-align",
+  "compound-spring",
+  "tidy",
+  "stress",
+  "force",
+  "flow",
+  "layered",
+  "tree",
+  "grid"
+], Ct = {
+  "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: [] }
+}, mn = {
+  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 Es(e, t) {
+  return t && e === "gap" ? "Engine lines space boxes with node-gap= and rank-gap=." : !t && e in Ct ? `${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 As = /^[A-Za-z_][A-Za-z0-9_.-]*$/, At = /^[A-Za-z_][A-Za-z0-9_-]*$/, Zn = ["box", "pill", "circle", "diamond", "text", "marker"], _s = Zn.filter((e) => e !== "marker"), wn = ["box", "soft", "none"], Ss = /^[A-Za-z]{1,8}$/, yn = ["auto", "left", "right", "top", "bottom"];
+function Is(e) {
+  const t = typeof e == "string" ? bs(e) : e, i = {
+    title: "Untitled diagram",
+    objects: [],
+    edges: [],
+    layouts: [],
+    hints: [],
+    routing: {},
+    appearance: Bn(),
+    themeLine: 0,
+    colorLines: /* @__PURE__ */ new Map(),
+    legendLines: [],
+    noteLines: [],
+    footnoteLines: [],
+    stateLines: /* @__PURE__ */ new Map(),
+    phases: [],
+    warnings: []
+  }, o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set();
+  let h = 0;
+  for (const c of t.lines) {
+    if (c.kind !== "statement") continue;
+    const M = c.line, { command: m, args: d } = c, f = new Map(c.attrs), n = (w) => {
+      throw new _e(w, M);
+    }, a = (w, b) => {
+      w || n(b);
+    }, p = (w) => {
+      for (const b of f.keys())
+        a(w.includes(b), `Unknown ${m} attribute: ${b}.`);
+    }, u = (w, b = w) => a(d.length >= w && d.length <= b, `Wrong number of arguments for ${m}.`), g = (w) => (a(
+      w && !w.quoted && As.test(w.value),
+      "Expected a stable identifier (letters, digits, _, . or -)."
+    ), w.value), x = (w) => w?.value ?? "", E = (w, b, _ = -1e5, N = 1e5) => {
+      const Q = f.get(w);
+      if (Q === void 0) return b;
+      const z = Number(Q.value);
+      return a(
+        !Q.quoted && Number.isFinite(z) && z >= _ && z <= N,
+        `Expected ${w} from ${_} to ${N}; got ${Q.value}.`
+      ), z;
+    }, R = (w, b) => {
+      const _ = f.get(w);
+      return !_.quoted && Ss.test(_.value) ? _.value : E(w, b, b, 1e6);
+    }, L = (w, b, _) => {
+      const N = f.get(w)?.value ?? b;
+      return a(_.includes(N), `Expected ${w}=${_.join("|")}; got ${N}.`), N;
+    }, H = (w) => {
+      const b = Number(w.value);
+      return a(
+        !w.quoted && Tt.includes(b),
+        `Expected shade=${Tt.join("|")}; got ${w.value}.`
+      ), b;
+    }, I = (w) => {
+      const b = f.get(w);
+      return a(
+        b.quoted && Mo.test(b.value),
+        `Expected ${w}="#rrggbb" in double quotes; got ${b.value || "nothing"}.`
+      ), b.value.toUpperCase();
+    }, P = (w) => {
+      a(!l.has(w), `Duplicate declaration: ${w}. Edit the existing line instead.`), l.add(w);
+    }, O = c.mark && Vn[c.mark];
+    a(
+      !c.mark || ["node", "group", "edge"].includes(m),
+      `Only node, group and edge lines take a ${c.mark} mark.`
+    );
+    const y = () => {
+      for (const w of ["was", "was-shape", "was-count"])
+        a(!f.has(w) || c.mark === "~", `${w}= belongs on a changed (~) line.`);
+      return {
+        ...f.has("was") ? { was: f.get("was").value } : {},
+        ...f.has("was-shape") ? { wasShape: L("was-shape", "box", _s) } : {},
+        ...f.has("was-count") ? { wasCount: R("was-count", 1) } : {}
+      };
+    }, D = (w) => {
+      const b = {};
+      for (const [_, N] of Object.entries(w))
+        f.has(_) && ("min" in N ? b[N.key] = E(_, 0, N.min, N.max) : N.choices.length ? b[N.key] = L(_, N.choices[0], N.choices) : b[N.key] = g(f.get(_)));
+      return b;
+    };
+    switch (m) {
+      case "diagram":
+        u(1), p(["version", "width"]), a(!h, "Only one diagram declaration is allowed."), h = M, i.title = x(d[0]), E("version", 1, 1, 1), i.title && ((i.appearance.heading ??= {}).title = i.title), f.has("width") && ((i.appearance.heading ??= {}).width = E("width", 0, 160, 8e3));
+        break;
+      case "compare": {
+        u(0, 2), p(["direction", "aspect"]), P("compare");
+        const w = L("direction", "auto", ["auto", "right", "down"]);
+        i.appearance.compare = {
+          before: x(d[0]) || "Before",
+          after: x(d[1]) || "After",
+          ...w !== "auto" ? { direction: w } : {},
+          ...f.has("aspect") ? { aspect: E("aspect", 1.6, 0.25, 8) } : {}
+        };
+        break;
+      }
+      case "config": {
+        u(0), p(Object.keys(un)), a(f.size, `config needs a setting: ${Object.keys(un).join(", ")}.`);
+        const w = i.appearance.config ??= {};
+        for (const [b, _] of f) {
+          const N = o.get(b);
+          N && i.warnings.push({
+            code: "config-repeated",
+            message: `config ${b} is also set on line ${N}; this line wins.`,
+            line: M
+          }), o.set(b, M), b === "editor" ? w.editor = L("editor", "vscode", rs) : b === "strike-removed" ? w.strikeRemoved = L(b, "off", ["on", "off"]) === "on" : (a(_.quoted, `Expected ${b}="path" in double quotes.`), w.linkBase = _.value);
+        }
+        break;
+      }
+      case "state": {
+        a(d.length >= 1, 'A state needs an ID: state write "Write path" api orders.'), p(["rest"]);
+        const w = g(d[0]), b = d[1]?.quoted ? d[1].value : void 0, _ = d.slice(b === void 0 ? 1 : 2).map((z) => g(z)), N = i.appearance.states ??= [];
+        let Q = N.find((z) => z.id === w);
+        Q || (Q = { id: w, label: b ?? w, ids: [], rest: "dim" }, N.push(Q)), f.has("rest") && (Q.rest = L("rest", "dim", ["dim", "plain"]));
+        for (const z of _)
+          a(!Q.ids.includes(z), `${z} is already in state ${w}.`), Q.ids.push(z), i.stateLines.set(`${w}:${z}`, M);
+        break;
+      }
+      case "phase": {
+        a(
+          d.length >= 3 && d[1]?.quoted,
+          'A phase needs an ID, a label and its messages: phase preview "Preview" m1 m2.'
+        ), p([]);
+        const w = g(d[0]);
+        a(!i.phases.some((b) => b.id === w), `Duplicate phase ${w}.`), i.phases.push({ id: w, label: d[1].value, ids: d.slice(2).map((b) => g(b)), line: M });
+        break;
+      }
+      case "was-order":
+        a(d.length, "was-order lists the older message order: was-order m2 m1."), p([]), P("was-order"), i.wasOrder = { ids: d.map((w) => g(w)), line: M };
+        break;
+      case "subtitle":
+        u(1), p([]), P("subtitle"), a(x(d[0]).trim(), "A subtitle needs its text in quotes."), (i.appearance.heading ??= {}).subtitle = x(d[0]);
+        break;
+      case "node":
+      case "group": {
+        u(2), p(
+          m === "node" ? [
+            "in",
+            "color",
+            "shade",
+            "shape",
+            "was",
+            "was-shape",
+            "was-count",
+            "href",
+            "count",
+            "span"
+          ] : ["in", "color", "shade", "was", "href", "frame", "fold"]
+        );
+        const w = g(d[0]);
+        a(w !== "root", "root is reserved for the outer layout scope."), a(!s.has(w), `Duplicate node/group id ${w}.`), s.add(w);
+        const b = f.get("color")?.value ?? "auto";
+        a(
+          !f.get("color")?.quoted && At.test(b),
+          `Expected color=auto, a built-in color (${Lt.join(", ")}) or a theme-color name; got ${b}.`
+        );
+        const _ = f.has("shade") ? H(f.get("shade")) : void 0;
+        i.objects.push({
+          id: w,
+          type: m,
+          label: x(d[1]),
+          parent: f.has("in") ? g(f.get("in")) : "root",
+          color: b,
+          ..._ !== void 0 ? { shade: _ } : {},
+          shape: m === "node" ? L("shape", "box", Zn) : "box",
+          ...c.mark ? { status: O } : {},
+          ...y(),
+          ...f.has("href") ? { href: x(f.get("href")) } : {},
+          ...f.has("count") ? { count: R("count", 2) } : {},
+          ...m === "group" && L("fold", "auto", ["auto", "never"]) === "never" ? { fold: "never" } : {},
+          ...m === "group" && L("frame", "box", wn) !== "box" ? { frame: L("frame", "box", wn) } : {},
+          ...f.has("span") ? {
+            span: f.get("span").value === "var" ? "var" : E("span", 1, 1, 4096)
+          } : {},
+          line: M
+        });
+        break;
+      }
+      case "edge": {
+        u(4, 5), p(["kind", "from", "to", "was", "constraint", "directed", "head", "tail"]), a(
+          d[2]?.value === "->" && !d[2].quoted,
+          'Edges use: edge id source -> target "label".'
+        );
+        const w = g(d[0]);
+        a(!r.has(w), `Duplicate edge id ${w}.`), r.add(w);
+        const b = L("directed", "true", ["true", "false"]) === "false", _ = L("head", "arrow", dn), N = L("tail", "none", dn);
+        a(
+          !b || !(f.has("head") || f.has("tail")),
+          `Edge ${w} has directed=false, so it has no ends to mark. Remove head= and tail=, or remove directed=false.`
+        ), i.edges.push({
+          id: w,
+          source: g(d[1]),
+          target: g(d[3]),
+          label: x(d[4]),
+          dashed: L("kind", "sync", ["sync", "async"]) === "async",
+          from: L("from", "auto", yn),
+          to: L("to", "auto", yn),
+          ...b ? { directed: !1 } : {},
+          ..._ !== "arrow" ? { head: _ } : {},
+          ...N !== "none" ? { tail: N } : {},
+          ...L("constraint", "true", ["true", "false"]) === "false" ? { constraint: !1 } : {},
+          ...c.mark ? { status: O } : {},
+          ...y(),
+          line: M
+        });
+        break;
+      }
+      case "layout": {
+        const w = g(d[0]), b = f.get("engine")?.value, _ = i.layouts.findIndex(($) => $.scope === w);
+        _ >= 0 && (i.warnings.push({
+          code: "layout-repeated",
+          message: `layout ${w} is also set on line ${i.layouts[_].line}; this line wins.`,
+          line: M
+        }), i.layouts.splice(_, 1));
+        const N = ($) => {
+          for (const k of [...f.keys()])
+            $.includes(k) || (i.warnings.push({
+              code: "layout-attribute",
+              message: `This layout line does not take ${k}=, so it is ignored. ${Es(k, b !== void 0)}`,
+              line: M
+            }), f.delete(k));
+        }, Q = [
+          "direction",
+          "min-width",
+          "min-height",
+          ...w === "root" ? ["fit"] : []
+        ];
+        let z;
+        if (b !== void 0)
+          u(1), a(
+            gn.includes(b),
+            `Unknown layout engine ${b}; use ${gn.join(", ")}.`
+          ), N(["engine", ...Q, ...Object.keys(Ct)]), z = { algorithm: b, params: D(Ct) };
+        else {
+          u(2);
+          const $ = d[1]?.value;
+          N(
+            $ === "cells" ? ["columns", "unit", "unit-width", "ruler", ...Q] : ["gap", ...$ === "flow" ? ["fold"] : [], ...Q]
+          );
+        }
+        const Y = b ? "flow" : d[1]?.value;
+        a(
+          ["flow", "row", "column", "lanes", "sequence", "cells"].includes(Y),
+          `The ${Y} recipe is not supported; use flow, row, column, lanes, sequence or cells, or engine=.`
+        ), a(
+          !["lanes", "sequence"].includes(Y) || w === "root",
+          `${Y} arranges the whole diagram: write layout root ${Y}.`
+        ), a(
+          Y !== "cells" || w !== "root",
+          "Cells lay out a group; give the cells a group and use layout <group> cells."
+        ), i.layouts.push({
+          scope: w,
+          algorithm: Y,
+          ...z ? { engine: z } : {},
+          direction: L("direction", "auto", ["auto", "right", "down"]),
+          fold: b ? "auto" : L("fold", "auto", ["auto", "never"]),
+          ...f.has("fit") ? { fit: L("fit", "slide", Object.keys(vs)) } : {},
+          ...f.has("columns") ? { columns: E("columns", 1, 1, 512) } : {},
+          ...f.has("unit") ? {
+            unit: L("unit", "byte", ["bit", "byte"]),
+            ruler: L("ruler", "on", ["on", "off"]) === "on",
+            ...f.has("unit-width") ? { unitWidth: E("unit-width", 24, 8, 200) } : {}
+          } : {},
+          gap: E("gap", 28, 8, 300),
+          minWidth: E("min-width", 0, 0, 1e4),
+          minHeight: E("min-height", 0, 0, 1e4),
+          line: M
+        });
+        break;
+      }
+      case "theme": {
+        u(1), p(Object.keys(pn)), P("theme");
+        const w = d[0].value;
+        a(Xt.includes(w), `Unknown theme ${w}; use ${Xt.join(", ")}.`), i.appearance.theme = w, i.themeLine = M;
+        const b = i.appearance.overrides;
+        for (const [_, N] of Object.entries(pn))
+          f.has(_) && (N === "paddingX" || N === "paddingY" || N === "radius" ? b[N] = E(_, 0, Qt[N].min, Qt[N].max) : N === "titleFont" || N === "annotationFont" ? b[N] = L(_, "sans", fo) : b[N] = I(_));
+        break;
+      }
+      case "theme-color": {
+        u(1), p(["shade", "fill", "stroke", "ink"]);
+        const w = d[0].value;
+        a(
+          !d[0].quoted && At.test(w) && w !== "auto",
+          "Expected a color family name (letters, digits, _ or -)."
+        );
+        const b = f.has("shade") ? H(f.get("shade")) : 500;
+        P(`theme-color:${w}:${b}`);
+        const _ = { family: w, shade: b };
+        for (const N of ["fill", "stroke", "ink"])
+          f.has(N) && (_[N] = I(N));
+        a(
+          Rt(w) || _.fill && _.stroke && _.ink,
+          `${w} is not a built-in color, so shade ${b} needs fill, stroke and ink.`
+        ), a(_.fill || _.stroke || _.ink, "Set at least one of fill, stroke and ink."), i.appearance.colors.push(_), i.colorLines.set(`${w}:${b}`, M);
+        break;
+      }
+      case "legend": {
+        if (d[0]?.value === "line" && !d[0].quoted) {
+          u(3), p([]);
+          const _ = d[1].value;
+          a(
+            !d[1].quoted && Kt.includes(_),
+            `Expected legend line ${Kt.join("|")} "meaning".`
+          ), P(`legend:line:${_}`), a(x(d[2]).trim(), "A legend entry needs its meaning in quotes."), (i.appearance.legend ??= []).push({ line: _, label: x(d[2]) }), i.legendLines.push(M);
+          break;
+        }
+        u(2), p(["shade"]);
+        const w = d[0].value;
+        a(
+          !d[0].quoted && At.test(w) && w !== "auto",
+          `Expected legend family "meaning", with a built-in color (${Lt.join(", ")}) or a theme-color name.`
+        ), P(`legend:${w}:${f.get("shade")?.value ?? ""}`);
+        const b = f.has("shade") ? H(f.get("shade")) : void 0;
+        a(x(d[1]).trim(), "A legend entry needs its meaning in quotes."), (i.appearance.legend ??= []).push({
+          family: w,
+          label: x(d[1]),
+          ...b !== void 0 ? { shade: b } : {}
+        }), i.legendLines.push(M);
+        break;
+      }
+      case "note": {
+        u(1), p(["near", "side", "width"]), a(d[0].quoted && d[0].value.trim(), "A note needs its text in quotes."), a(f.has("near") || !f.has("side"), "side= places a note beside near=<id>."), (i.appearance.notes ??= []).push({
+          text: d[0].value,
+          ...f.has("near") ? { near: g(f.get("near")) } : {},
+          ...f.has("side") ? { side: L("side", "below", Yo) } : {},
+          ...f.has("width") ? { width: E("width", Xn, 80, 1200) } : {}
+        }), i.noteLines.push(M);
+        break;
+      }
+      case "footnote": {
+        u(1, 2), p([]);
+        const w = d[d.length - 1], b = d.length === 2 ? d[0] : void 0;
+        a(w.quoted && w.value.trim(), "A footnote needs its text in quotes."), a(
+          !b || !b.quoted && /^[A-Za-z0-9*]{1,3}$/.test(b.value),
+          'A footnote marker is a short word: footnote 1 "text".'
+        ), b && P(`footnote:${b.value}`), (i.appearance.footnotes ??= []).push({
+          text: w.value,
+          ...b ? { mark: b.value } : {}
+        }), i.footnoteLines.push(M);
+        break;
+      }
+      case "routing":
+        u(0), p(Object.keys(mn)), P("routing"), i.routing = D(mn);
+        break;
+      case "order":
+        u(2, 300), p([]), i.hints.push({ type: "order", scope: g(d[0]), ids: d.slice(1).map(g), line: M }), P("order:" + d[0].value);
+        break;
+      case "align": {
+        u(3, 300), p(["strength"]);
+        const w = d[0]?.value;
+        a(w === "x" || w === "y", "Expected align x or align y.");
+        const b = d.slice(1).map(g);
+        P(`align:${w}:${b.join(",")}`), i.hints.push({
+          type: "align",
+          axis: w,
+          ids: b,
+          strength: L("strength", "prefer", ["prefer", "required"]),
+          line: M
+        });
+        break;
+      }
+      case "near":
+      case "nudge":
+      case "stay":
+      case "pin":
+      case "size": {
+        u(m === "near" ? 2 : 1);
+        const w = g(d[0]);
+        if (P(`${m}:${w}`), m === "near") {
+          p(["side", "gap", "offset", "strength"]);
+          const b = g(d[1]);
+          a(b !== w, "An object cannot be placed relative to itself."), i.hints.push({
+            type: "near",
+            id: w,
+            ref: b,
+            side: L("side", "right", ["right", "left", "above", "below"]),
+            gap: E("gap", 28, 0, 2e3),
+            offset: E("offset", 0),
+            strength: L("strength", "prefer", ["prefer", "required"]),
+            line: M
+          });
+        } else m === "nudge" ? (p(["dx", "dy"]), i.hints.push({ type: "nudge", id: w, dx: E("dx", 0), dy: E("dy", 0), line: M })) : m === "stay" ? (p(["x", "y", "weight"]), i.hints.push({
+          type: "stay",
+          id: w,
+          // The root has no frame, so an arrangement can place objects left of or above 0,0.
+          x: E("x", 0),
+          y: E("y", 0),
+          weight: E("weight", 8, 1, 100),
+          line: M
+        })) : m === "pin" ? (p(["x", "y"]), i.hints.push({ type: "pin", id: w, x: E("x", 0, 0), y: E("y", 0, 0), line: M })) : (p(["width", "height"]), i.hints.push({
+          type: "size",
+          id: w,
+          width: E("width", 164, 40, 1200),
+          ...f.get("height")?.value === "auto" ? {} : { height: E("height", 56, 24, 1200) },
+          line: M
+        }));
+        break;
+      }
+      case "view":
+      case "snapshot":
+      case "box":
+        n(`${m} statements are not supported yet. Remove them to open this file.`);
+        break;
+      default:
+        n(`Unknown statement ${m}.`);
+    }
+  }
+  if (i.objects.length > 500) throw new _e("Limit: 500 nodes and groups.");
+  if (i.edges.length > 1200) throw new _e("Limit: 1,200 edges.");
+  return Ts(i), i;
+}
+function Xe(e, t) {
+  let i = e.get(t)?.parent ?? "root";
+  for (; i !== "root" && e.get(i)?.frame; ) i = e.get(i).parent;
+  return i;
+}
+function Ts(e) {
+  const t = new Map(e.objects.map((n) => [n.id, n])), i = (n, a, p) => s(
+    !t.get(n)?.frame,
+    `${n} is a ${t.get(n)?.frame} group, so it has no ${p} of its own. Use frame=box, or ${p === "layout" ? "set the layout of the container around it" : "place its members"}.`,
+    a
+  ), o = (n) => Xe(t, n), s = (n, a, p) => {
+    if (!n) throw new _e(a, p);
+  }, r = (n, a) => s(t.has(n), `Unknown node/group ${n}.`, a), l = (n, a) => s(n === "root" || t.get(n)?.type === "group", `Unknown container ${n}.`, a), h = /* @__PURE__ */ new Map();
+  for (const n of e.appearance.colors)
+    h.has(n.family) || h.set(n.family, /* @__PURE__ */ new Set()), h.get(n.family).add(n.shade);
+  (e.appearance.legend ?? []).forEach((n, a) => {
+    if (!n.family || Rt(n.family)) return;
+    const p = h.get(n.family), u = n.shade ?? wt;
+    s(
+      p?.has(u),
+      p ? `${n.family} has no shade ${u}; it defines ${[...p].sort((g, x) => g - x).join(", ")}.` : `Unknown color ${n.family}. Define it with theme-color ${n.family} shade=… fill= stroke= ink=.`,
+      e.legendLines[a]
+    );
+  });
+  for (const n of e.objects) {
+    if (n.color !== "auto" && !Rt(n.color)) {
+      const p = h.get(n.color), u = n.shade ?? (n.type === "group" ? yo(e.appearance.theme) : wt);
+      s(
+        p,
+        `Unknown color ${n.color}. Define it with theme-color ${n.color} shade=… fill= stroke= ink=.`,
+        n.line
+      ), s(
+        p.has(u),
+        `${n.color} has no shade ${u}${n.shade === void 0 ? " (the default)" : ""}; it defines ${[...p].sort((g, x) => g - x).join(", ")}.`,
+        n.line
+      );
+    }
+    l(n.parent, n.line);
+    const a = /* @__PURE__ */ new Set();
+    for (let p = n; p; p = t.get(p.parent))
+      s(!a.has(p.id), `Containment cycle at ${p.id}.`, n.line), a.add(p.id), s(a.size <= 12, "Limit: 12 nesting levels.", n.line);
+  }
+  if (e.layouts.some((n) => n.scope === "root" && n.algorithm === "lanes"))
+    for (const n of e.objects)
+      n.parent === "root" && (s(
+        n.type === "group",
+        `In a lanes diagram every node sits in a lane; put ${n.id} in= one of the top-level groups.`,
+        n.line
+      ), s(!n.frame, `${n.id} is a lane, so it needs its frame; remove frame=.`, n.line));
+  const c = e.layouts.some((n) => n.scope === "root" && n.algorithm === "sequence");
+  if (c)
+    for (const n of e.objects)
+      s(
+        n.type === "node" ? t.get(n.parent)?.type !== "node" : n.parent === "root" && !n.frame,
+        `In a sequence diagram a group is a band of participants: put ${n.id} at the top level and its participants in=${n.id}.`,
+        n.line
+      ), s(
+        n.type === "node" || e.objects.some((a) => a.parent === n.id),
+        `Group ${n.id} has no participants, so it has no band to draw. Put a participant in=${n.id} or remove the group.`,
+        n.line
+      );
+  const M = new Set(e.edges.map((n) => n.id)), m = /* @__PURE__ */ new Set();
+  for (const n of e.phases) {
+    s(
+      c,
+      "A phase groups messages in a sequence diagram; use layout root sequence.",
+      n.line
+    );
+    for (const u of n.ids)
+      s(
+        M.has(u),
+        `Unknown message ${u} in phase ${n.id}; a phase lists edge IDs.`,
+        n.line
+      ), s(!m.has(u), `${u} is already in another phase.`, n.line), m.add(u);
+    const a = e.edges.flatMap((u, g) => n.ids.includes(u.id) ? [g] : []), p = e.edges.slice(a[0], a[a.length - 1] + 1).filter((u) => !n.ids.includes(u.id) && u.status !== "removed").map((u) => u.id);
+    s(
+      !p.length,
+      `Phase ${n.id} skips ${p.join(", ")}: a phase is a run of consecutive messages. Include it or split the phase.`,
+      n.line
+    );
+  }
+  if (e.wasOrder) {
+    const { ids: n, line: a } = e.wasOrder, p = (g) => e.edges.find((x) => x.id === g), u = (g) => e.warnings.push({ code: "was-order", message: g, line: a });
+    s(
+      e.layouts.some((g) => g.scope === "root" && g.algorithm === "sequence"),
+      "was-order gives the older order of a sequence diagram; use layout root sequence.",
+      a
+    ), s(new Set(n).size === n.length, "was-order lists a message twice.", a);
+    for (const g of n)
+      s(p(g)?.status !== "added", `${g} is added, so was-order can't list it.`, a), p(g) || u(`was-order lists ${g}, which is not a message. The panels skip it.`);
+    for (const g of e.edges)
+      g.status !== "added" && !n.includes(g.id) && u(`was-order leaves out ${g.id}, so the older panel keeps it on its new row.`);
+  }
+  for (const n of e.edges)
+    for (const a of [n.source, n.target]) {
+      r(a, n.line);
+      const p = t.get(a), u = a === n.source ? n.target : n.source;
+      s(
+        !c || p.type === "node",
+        `A message joins participants, and ${a} is a group. End ${n.id} on one of its participants.`,
+        n.line
+      ), s(
+        p.type === "node" || !p.frame,
+        `${a} is a ${p.frame} group, which has no frame for a line to end on. Connect to one of its members, or use frame=box.`,
+        n.line
+      );
+      let g = !1;
+      for (let x = t.get(u)?.parent; x && x !== "root"; x = t.get(x)?.parent)
+        x === a && (g = !0);
+      s(
+        !g,
+        `${u} is inside ${a}, so a line between them has nowhere to go.`,
+        n.line
+      );
+    }
+  (e.appearance.notes ?? []).forEach((n, a) => {
+    if (!(!n.near || t.has(n.near))) {
+      if (!M.has(n.near)) return r(n.near, e.noteLines[a]);
+      s(
+        c,
+        `near=${n.near} names a connection. Only a sequence diagram anchors a note to a message; use a node or group here.`,
+        e.noteLines[a]
+      );
+    }
+  });
+  const d = new Set(e.edges.map((n) => n.id));
+  for (const n of e.appearance.states ?? [])
+    for (const a of n.ids) {
+      const p = e.stateLines.get(`${n.id}:${a}`);
+      s(
+        t.has(a) || d.has(a),
+        `Unknown node, group or edge ${a} in state ${n.id}.`,
+        p
+      );
+    }
+  const f = new Map(e.layouts.filter((n) => n.algorithm === "cells").map((n) => [n.scope, n]));
+  for (const n of e.objects) {
+    const a = f.get(n.parent);
+    a ? (s(
+      n.type === "node",
+      `Cells are nodes; ${n.id} is a group inside cells ${n.parent}.`,
+      n.line
+    ), s(
+      n.shape !== "marker" || (a.columns ?? 0) <= 1 && !a.unit,
+      a.unit ? `A marker cuts a sequence of cells; ${n.parent} is a ${a.unit} layout.` : `A marker cuts one row or column of cells; ${n.parent} has ${a.columns} columns.`,
+      n.line
+    ), s(
+      n.span !== "var" || !!a.unit,
+      `span=var is for a byte or bit layout; give ${n.parent} unit=byte or unit=bit.`,
+      n.line
+    )) : (s(
+      n.shape !== "marker",
+      `A marker sits between cells; put ${n.id} in a group with layout cells.`,
+      n.line
+    ), s(n.span === void 0, `span= is for cells; ${n.parent} has no layout cells.`, n.line));
+  }
+  for (const n of e.layouts) {
+    l(n.scope, n.line), i(n.scope, n.line, "layout");
+    const a = n.engine?.params.rootId;
+    a && (r(a, n.line), s(t.get(a).type === "node", `The tree root ${a} must be a node.`, n.line));
+  }
+  for (const n of e.hints)
+    if (n.type === "order") {
+      l(n.scope, n.line), i(n.scope, n.line, "layout");
+      for (const a of n.ids)
+        r(a, n.line), i(a, n.line, "position"), s(o(a) === n.scope, `${a} is not a direct child of ${n.scope}.`, n.line);
+    } else if (n.type === "align") {
+      n.ids.forEach((p) => r(p, n.line)), n.ids.forEach((p) => i(p, n.line, "position")), s(new Set(n.ids).size === n.ids.length, "Duplicate member in align.", n.line);
+      const a = o(n.ids[0]);
+      s(
+        n.ids.every((p) => o(p) === a),
+        "Members of align must be direct siblings.",
+        n.line
+      );
+    } else
+      r(n.id, n.line), i(n.id, n.line, "position"), n.type === "near" && (r(n.ref, n.line), i(n.ref, n.line, "position"), s(
+        Ft(t, n.id, n.ref) !== void 0,
+        `Relative placement is between siblings, or with something inside a sibling group. ${n.id} is inside ${o(n.id)}; place ${o(n.id)} relative to ${n.ref} instead.`,
+        n.line
+      )), n.type === "size" && s(
+        t.get(n.id).type === "node",
+        "Use layout min-width/min-height to reserve room in a group.",
+        n.line
+      );
+}
+const bt = { width: 1100, height: 720 }, Ze = 12, Ls = 56, Mn = 24, xn = 0, Rs = 56, bn = { w: 260, h: 110 }, vn = (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), le = (e) => Math.round(e);
+function Os(e) {
+  if (!e.appearance.compare || !e.edges.some((o) => o.was)) return e;
+  const t = tt(e.appearance), i = (o) => o ? He(o, t).w : 0;
+  return {
+    ...e,
+    edges: e.edges.map((o) => o.was && i(o.was) > i(o.label) ? { ...o, label: o.was } : o)
+  };
+}
+function $s(e, t) {
+  if (e.model.edges === t.edges) return e;
+  const i = new Map(t.edges.map((o) => [o.id, o.label]));
+  return {
+    ...e,
+    model: { ...e.model, edges: t.edges },
+    edges: e.edges.map((o) => ({ ...o, label: i.get(o.id) }))
+  };
+}
+function Ds(e) {
+  const t = Is(e), i = zs(t);
+  return Us(
+    Jn(Ys($s(Ut(Os(i)), i), t))
+  );
+}
+const Ns = 24, Ps = 0, kn = 36, Fs = 40, Cs = 16, En = 8, Te = 16, Ye = 20, An = 8, js = 104;
+function Bs(e, t) {
+  const i = Math.ceil(pe(e.label, t.title));
+  if (e.label.includes(`
+`) || xt(e.shape, e.w, e.h, t).width < i) return e.w;
+  let o = js;
+  for (; o < e.w && xt(e.shape, o, e.h, t).width < i; ) o += 4;
+  return Math.min(o, e.w);
+}
+function Jn(e) {
+  if (!e.model.layouts.some((v) => v.scope === "root" && v.algorithm === "sequence"))
+    return e;
+  const t = e.look, i = new Set(e.model.hints.flatMap((v) => v.type === "size" ? [v.id] : [])), o = e.objects.filter((v) => v.type === "node"), s = e.objects.filter((v) => v.type === "group");
+  if (!o.length) return e;
+  const r = (v, A) => {
+    const F = e.model.hints.find((se) => se.type === "order" && se.scope === v), Z = F?.type === "order" ? F.ids : [];
+    return [...Z, ...A.filter((se) => !Z.includes(se))];
+  }, l = [...new Set(o.map((v) => v.parent === "root" ? v.id : v.parent))], c = r("root", l).flatMap(
+    (v) => e.byId.get(v).type === "node" ? [v] : r(
+      v,
+      o.filter((A) => A.parent === v).map((A) => A.id)
+    )
+  ).map((v) => e.byId.get(v)).map((v) => i.has(v.id) ? v : { ...v, w: Bs(v, t) }), M = new Map(c.map((v, A) => [v.id, A])), m = e.model.phases.length ? Math.max(...e.model.phases.map((v) => pe(v.label, t.annotation))) + 2 * Te : 0, d = s.length ? t.groupHeader : 0, f = (v) => c[v - 1].parent !== c[v].parent, n = !!e.model.appearance.compare, a = (v) => [v.label, n ? v.was : ""].filter((A) => !!A), p = (v) => {
+    const A = a(v).map((F) => He(F, t, !0));
+    return { w: Math.max(0, ...A.map((F) => F.w)), h: Math.max(0, ...A.map((F) => F.h)) };
+  }, u = (v) => {
+    const A = a(v).map((F) => sn(F, t));
+    return A.length ? {
+      right: Math.max(...A.map((F) => F.right)),
+      above: Math.max(...A.map((F) => F.above)),
+      below: Math.max(...A.map((F) => F.below))
+    } : sn(void 0, t);
+  }, g = /* @__PURE__ */ new Map(), x = c.map(() => []);
+  for (const v of e.edges) {
+    const [A, F] = [M.get(v.source), M.get(v.target)].sort((se, ae) => se - ae);
+    if (A < F) {
+      const { w: se } = p(v);
+      se && x[F].push({ from: A, room: se + Cs });
+      continue;
+    }
+    const { right: Z } = u(v);
+    g.set(v.source, Math.max(g.get(v.source) ?? 0, Z)), A + 1 < c.length && x[A + 1].push({
+      from: A,
+      room: Z + En + (f(A + 1) ? 2 * Te + c[A + 1].w / 2 : 0)
+    });
+  }
+  const E = [];
+  c.forEach((v, A) => {
+    if (!A) return void E.push(m + Te + v.w / 2);
+    const F = c[A - 1].w / 2 + Fs + (f(A) ? 2 * Te : 0) + v.w / 2;
+    E.push(Math.max(E[A - 1] + F, ...x[A].map((Z) => E[Z.from] + Z.room)));
+  });
+  let R = d + Math.max(0, ...c.map((v) => v.h)) - Ps, L = 0;
+  const H = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map();
+  for (const v of e.edges) {
+    const A = p(v).h, F = v.source === v.target ? u(v) : void 0, Z = F ? F.above : A && A + 1;
+    R = Math.ceil(
+      Math.max(R + Math.max(kn, A ? A + 8 : 0), L + En + Z)
+    ), H.set(v.id, R), L = F ? R + F.below : 0, I.set(v.id, { from: R - Math.max(A, kn / 2) - 4, to: Math.max(R, L) + 8 }), F && (R += ze.down);
+  }
+  const P = Math.max(R, L) + Ns, O = new Map(
+    c.map((v) => {
+      const A = le(E[M.get(v.id)] - v.w / 2);
+      return [v.id, { x: A, w: v.w }];
+    })
+  ), y = (v) => Math.max(O.get(v.id).x + v.w, E[M.get(v.id)] + (g.get(v.id) ?? 0)), D = e.objects.map((v) => {
+    if (v.type === "group") {
+      const Z = c.filter((S) => S.parent === v.id), se = le(Math.min(...Z.map((S) => O.get(S.id).x)) - Te), ae = le(Math.max(...Z.map((S) => y(S))) + Te - se);
+      return {
+        ...v,
+        shade: v.shade ?? 50,
+        x: se,
+        y: 0,
+        w: ae,
+        h: P + Te,
+        localX: se,
+        localY: 0,
+        baseX: se,
+        baseY: 0
+      };
+    }
+    const { x: A, w: F } = O.get(v.id);
+    return {
+      ...v,
+      w: F,
+      x: A,
+      y: d,
+      localX: A,
+      localY: d,
+      baseX: A,
+      baseY: d,
+      lifeline: P - d - v.h
+    };
+  }), w = Math.min(0, ...D.map((v) => v.x)) - (m ? 0 : Te), b = Math.max(
+    ...D.map((v) => v.x + v.w + Te),
+    ...c.map((v) => E[M.get(v.id)] + (g.get(v.id) ?? 0))
+  ), _ = {
+    x: w - Ye,
+    y: -Ye,
+    w: b - w + 2 * Ye,
+    h: P + Te + 2 * Ye
+  }, N = e.model.appearance.notes ?? [], Q = new Map([...H].filter(([v]) => !e.byId.has(v))), z = Qo(t, N, Q, {
+    left: w - (m ? Ye : An),
+    right: b + An,
+    top: 0
+  }), Y = z.filter((v) => v !== null), $ = Y.length ? nn([_, nn(Y, Ye)]) : _, k = $.x < _.x ? _.x : void 0, T = e.model.phases.map((v) => {
+    const A = v.ids.map((F) => I.get(F));
+    return {
+      id: v.id,
+      label: v.label,
+      from: le(Math.min(...A.map((F) => F.from))),
+      to: le(Math.max(...A.map((F) => F.to)))
+    };
+  }).sort((v, A) => v.from - A.from), j = T.map(({ id: v, label: A, from: F, to: Z }, se) => ({
+    id: v,
+    label: A,
+    y: F,
+    h: Math.min(Z, T[se + 1]?.from ?? Z) - F
+  }));
+  return {
+    ...e,
+    objects: D,
+    byId: new Map(D.map((v) => [v.id, v])),
+    edges: e.edges.map((v) => ({ ...v, lane: void 0, row: H.get(v.id) })),
+    sequence: {
+      panel: $,
+      phases: j,
+      ...k !== void 0 ? { phaseX: k } : {},
+      ...Y.length ? { notes: z, inner: _ } : {}
+    }
+  };
+}
+function Us(e) {
+  const t = e.model.wasOrder?.ids.flatMap((r) => e.edges.filter((l) => l.id === r));
+  if (!t || !e.sequence) return e;
+  const i = [...t], o = Jn({
+    ...e,
+    edges: e.edges.map((r) => t.includes(r) ? i.shift() : r)
+  }), s = (r) => r.objects.find((l) => l.type === "node")?.lifeline ?? 0;
+  return {
+    ...e,
+    sequence: {
+      ...e.sequence,
+      before: {
+        rows: Object.fromEntries(o.edges.map((r) => [r.id, r.row])),
+        phases: o.sequence.phases,
+        grow: Math.max(0, s(o) - s(e))
+      }
+    }
+  };
+}
+function zs(e) {
+  if (!e.objects.some((o) => o.frame)) return e;
+  const t = new Map(e.objects.map((o) => [o.id, o])), i = (o) => {
+    const s = [];
+    for (let r = t.get(o).parent; r !== "root" && t.get(r).frame; r = t.get(r).parent)
+      s.unshift(r);
+    return s;
+  };
+  return {
+    ...e,
+    objects: e.objects.filter((o) => !o.frame).map((o) => ({ ...o, parent: Xe(t, o.id), soft: i(o.id) }))
+  };
+}
+function Ht(e, t, i = 0) {
+  if (!e.some((s) => t(s)?.[i])) return e;
+  const o = /* @__PURE__ */ new Map();
+  return e.forEach((s, r) => {
+    const l = t(s)?.[i] ?? `\0${s}`, h = o.get(l) ?? { at: 0, ids: [] };
+    h.at += r, h.ids.push(s), o.set(l, h);
+  }), [...o].sort(([, s], [, r]) => s.at / s.ids.length - r.at / r.ids.length).flatMap(([s, r]) => s.startsWith("\0") ? r.ids : Ht(r.ids, t, i + 1));
+}
+const qs = 8;
+function vt(e = [], t = [], i) {
+  const o = e.filter((r) => !t.includes(r)).length, s = t.filter((r) => !e.includes(r)).length;
+  return !o && !s ? 0 : (o + s) * Ve + (i && s ? Mt : 0) + qs;
+}
+function eo(e, t, i, o) {
+  const s = new Set(e.flatMap((c) => i(c) ?? [])), r = (c, M) => (i(c) ?? []).filter((m) => !M.has(m)), l = new Set(t.flatMap((c) => i(c) ?? []));
+  let h = 0;
+  for (const c of e)
+    for (const M of t) h = Math.max(h, vt(r(c, l), r(M, s), o));
+  return h;
+}
+const ft = (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, Gs = (e, t) => ({
+  x: e.x - t,
+  y: e.y - t,
+  w: e.w + 2 * t,
+  h: e.h + 2 * t
+});
+function Hs(e, t) {
+  const i = Math.max(e.x, t.x), o = Math.min(e.x + e.w, t.x + t.w), s = Math.max(e.y, t.y), r = Math.min(e.y + e.h, t.y + t.h);
+  if (o > i) {
+    const c = Math.min(e.y + e.h, t.y + t.h);
+    return { x: i, y: c, w: o - i, h: Math.max(e.y, t.y) - c };
+  }
+  if (r > s) {
+    const c = Math.min(e.x + e.w, t.x + t.w);
+    return { x: c, y: s, w: Math.max(e.x, t.x) - c, h: r - s };
+  }
+  const l = Math.min(e.x, t.x), h = Math.min(e.y, t.y);
+  return { x: l, y: h, w: Math.max(e.x + e.w, t.x + t.w) - l, h: Math.max(e.y + e.h, t.y + t.h) - h };
+}
+function Ys(e, t) {
+  const i = t.objects.filter((d) => d.frame);
+  if (!i.length) return e;
+  const o = new Map(t.objects.map((d) => [d.id, d])), s = new Map(
+    e.objects.map((d) => [d.id, { ...d, parent: o.get(d.id).parent, soft: void 0 }])
+  ), r = [...e.diagnostics], l = (d, f) => {
+    for (let n = o.get(d)?.parent; n && n !== "root"; n = o.get(n)?.parent)
+      if (n === f) return !0;
+    return !1;
+  }, h = (d) => {
+    let f = 0;
+    for (let n = o.get(d).parent; n !== "root"; n = o.get(n).parent) f++;
+    return f;
+  }, c = (d) => d.frame === "soft" ? (d.hull ?? []).map((f) => ({ ...f, x: f.x + d.x, y: f.y + d.y })) : d.frame ? [] : [d];
+  for (const d of [...i].sort((f, n) => h(n.id) - h(f.id))) {
+    const f = [...s.values()].filter((O) => l(O.id, d.id)), n = s.get(Xe(o, d.id)), a = n ? Hn(n, pt(e.look, n.titleLines)) : { x: 0, y: 0 }, p = [...s.values()].filter(
+      (O) => !O.frame && !l(O.id, d.id) && !l(d.id, O.id)
+    ), u = f.flatMap((O) => c(O).map((y) => Gs(y, Ve)));
+    let g = [], x = 0;
+    if (u.length) {
+      const O = u.reduce((z, Y) => Y.y < z.y || Y.y === z.y && Y.x < z.x ? Y : z);
+      O.y -= Mt, O.h += Mt, g = [O, ...u.filter((z) => z !== O)];
+      const y = Math.min(...g.map((z) => z.x)), D = Math.min(...g.map((z) => z.y)), w = {
+        x: y,
+        y: D,
+        w: Math.max(...g.map((z) => z.x + z.w)) - y,
+        h: Math.max(...g.map((z) => z.y + z.h)) - D
+      };
+      p.some((z) => ft(z, w)) || (g = [w]);
+      const b = (z, Y) => Math.max(Y.x - (z.x + z.w), z.x - (Y.x + Y.w), Y.y - (z.y + z.h), z.y - (Y.y + Y.h), 0), _ = [g[0]], N = g.slice(1), Q = [];
+      for (; N.length; ) {
+        let z = { gap: 1 / 0, a: g[0], i: 0 };
+        for (const k of _)
+          N.forEach((T, j) => {
+            const v = b(k, T);
+            v < z.gap && (z = { gap: v, a: k, i: j });
+          });
+        const [Y] = N.splice(z.i, 1);
+        if (_.push(Y), ft(z.a, Y)) continue;
+        const $ = Hs(z.a, Y);
+        p.some((k) => ft(k, $)) ? x++ : Q.push($);
+      }
+      g.push(...Q);
+    }
+    const E = g.length ? Math.min(...g.map((O) => O.x)) : a.x, R = g.length ? Math.min(...g.map((O) => O.y)) : a.y, L = g.length ? Math.max(...g.map((O) => O.x + O.w)) : a.x, H = g.length ? Math.max(...g.map((O) => O.y + O.h)) : a.y, I = { x: E - a.x, y: R - a.y };
+    if (s.set(d.id, {
+      ...d,
+      x: E,
+      y: R,
+      w: L - E,
+      h: H - R,
+      localX: I.x,
+      localY: I.y,
+      baseX: I.x,
+      baseY: I.y,
+      depth: h(d.id),
+      hull: g.map((O) => ({ x: O.x - E, y: O.y - R, w: O.w, h: O.h }))
+    }), d.frame !== "soft") continue;
+    const P = p.filter((O) => g.some((y) => ft(O, y)));
+    P.length && r.push({
+      level: "warning",
+      code: "soft-overlap",
+      message: `${d.id}'s tint covers ${P.map((O) => O.id).join(", ")}, which ${P.length > 1 ? "are" : "is"} not in it. Place its members together, or use frame=box.`,
+      line: d.line,
+      ids: [d.id, ...P.map((O) => O.id)]
+    }), x && r.push({
+      level: "info",
+      code: "soft-split",
+      message: `${d.id}'s members are apart, so its tint is drawn in ${x + 1} pieces. Place its members together, or use frame=box.`,
+      line: d.line,
+      ids: [d.id]
+    });
+  }
+  const M = new Map(t.objects.map((d, f) => [d.id, f])), m = [...s.values()].sort((d, f) => M.get(d.id) - M.get(f.id));
+  return { ...e, model: t, objects: m, byId: new Map(m.map((d) => [d.id, d])), diagnostics: r };
+}
+const _n = 4, Ws = /* @__PURE__ */ new Set(["slate", "stone"]);
+function Xs(e) {
+  const t = [], i = e.objects.filter((l) => l.color !== "auto"), o = [...new Set(i.map((l) => l.color))].filter((l) => !Ws.has(l));
+  o.length > _n && t.push({
+    level: "info",
+    code: "many-colors",
+    message: `${o.length} accent colors (${o.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: i.find((l) => l.color === o[_n])?.line,
+    ids: i.filter((l) => o.includes(l.color)).map((l) => l.id)
+  });
+  const s = new Map(e.objects.map((l) => [l.id, l])), r = i.filter((l) => s.get(l.parent)?.color === l.color);
+  return r.length && t.push({
+    level: "info",
+    code: "color-matches-container",
+    message: `${r.map((l) => l.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((l) => l.id)
+  }), t;
+}
+function We(e) {
+  return e.direction !== "auto" ? e.direction : "right";
+}
+function Ks(e, t) {
+  const i = new Map(e.objects.map((o) => [o.id, o.parent]));
+  for (let o = t; o; o = o === "root" ? void 0 : i.get(o)) {
+    const s = e.layouts.find((r) => r.scope === o);
+    if (s) return o === t || s.engine ? s : void 0;
+  }
+}
+const Qs = 240;
+function Vs(e, t, i) {
+  const o = Math.ceil(pe(e, i.groupTitle)) + Dt;
+  let s = Math.max(t, Qs);
+  if (o <= s) return { w: o, lines: 1 };
+  const r = () => ot(e, s - Dt, i.groupTitle, !0).length;
+  for (; r() > on && s < o; ) s += 8;
+  return { w: Math.min(s, o), lines: Math.min(r(), on) };
+}
+const Sn = 16, Zs = 1.5, Oe = 14;
+function _t(e, t, i, o) {
+  const s = He(i, o);
+  return { a: e, b: t, w: s.w + 2 * Oe, h: s.h + 2 * Oe };
+}
+function jt(e, t, i, o, s) {
+  let r = o;
+  for (const l of e)
+    (l.a === t && l.b === i || l.a === i && l.b === t) && (r = Math.max(r, s ? l.w : l.h));
+  return r;
+}
+function St(e, t) {
+  return e.layouts.find((i) => i.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 In = 2;
+function Js(e, t, i) {
+  const o = e.label.includes(`
+`) && e.shape !== "circle" ? e.label.split(`
+`) : [], s = Math.max(jn(e.label, i.title), ...o.map((l) => pe(l, i.title)));
+  let r = t.w;
+  for (; xt(e.shape, r, t.h, i).width < s && r < t.w * In; ) r += 4;
+  return Math.min(r, t.w * In);
+}
+function Tn(e, t, i) {
+  const o = Yn(e.shape);
+  if (e.shape === "diamond") return ei(e, t, o, i);
+  const s = t?.width ?? Js(e, o, i), r = xt(e.shape, s, t?.height ?? o.h, i), l = nt(e.label, r.width, i).length;
+  return t?.height !== void 0 ? { w: s, h: t.height, overflow: l * i.title.lineHeight > r.maxHeight + 0.5 } : {
+    w: s,
+    h: Ro(e.shape, l, e.shape === "circle" ? o.h : 0, i),
+    overflow: !1
+  };
+}
+function ei(e, t, i, o) {
+  const s = jn(e.label, o.title), r = (h) => ($o(e.label, h, o) ?? 0) >= s;
+  if (t) {
+    const h = Math.max(t.width, t.height ?? 0);
+    return { w: h, h, overflow: !r(h) };
+  }
+  let l = i.w;
+  for (; !r(l); ) l += 4;
+  return { w: l, h: l, overflow: !1 };
+}
+const ti = 1.4;
+function Je(e, t) {
+  const i = new Map(e.map((f) => [f, []]));
+  for (const [f, n] of t)
+    f !== n && i.has(f) && i.has(n) && !i.get(f).includes(n) && i.get(f).push(n);
+  const o = new Set([...i.values()].flat()), s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), l = (f) => {
+    s.set(f, "open");
+    for (const n of i.get(f))
+      s.get(n) === "open" ? r.add(f + "\0" + n) : s.has(n) || l(n);
+    s.set(f, "done");
+  };
+  for (const f of [...e.filter((n) => !o.has(n)), ...e]) s.has(f) || l(f);
+  const h = new Map(e.map((f) => [f, 0])), c = new Map(e.map((f) => [f, 0])), M = (f) => i.get(f).filter((n) => !r.has(f + "\0" + n));
+  for (const f of e) for (const n of M(f)) h.set(n, h.get(n) + 1);
+  const m = e.filter((f) => !h.get(f));
+  for (; m.length; ) {
+    const f = m.shift();
+    for (const n of M(f))
+      c.set(n, Math.max(c.get(n), c.get(f) + 1)), h.set(n, h.get(n) - 1), h.get(n) || m.push(n);
+  }
+  const d = [];
+  for (const f of e) (d[c.get(f)] ||= []).push(f);
+  return d.filter(Boolean);
+}
+const to = 3, Ln = 5, Rn = 1.25, Ge = 20, ni = 3, oi = 2, si = 1;
+function ii(e, t) {
+  const i = new Map(e.map((h) => [h, []]));
+  for (const [h, c] of t) i.get(h)?.push(c);
+  const o = (h) => {
+    const c = /* @__PURE__ */ new Set([h]), M = [h];
+    for (; M.length; )
+      for (const m of i.get(M.shift()) ?? [])
+        c.has(m) || (c.add(m), M.push(m));
+    return c;
+  }, s = new Map(e.map((h) => [h, o(h)])), r = [], l = /* @__PURE__ */ new Set();
+  for (const h of e) {
+    if (l.has(h)) continue;
+    const c = e.filter((M) => s.get(h).has(M) && s.get(M).has(h));
+    c.forEach((M) => l.add(M)), c.length > 1 && r.push(c);
+  }
+  return r;
+}
+function It(e, t, i, o, s, r = [], l = /* @__PURE__ */ new Set(), h = t, {
+  aspect: c = to,
+  fewest: M = 4,
+  room: m = i === "right" ? bt.width : bt.height
+} = {}) {
+  const d = new Map(e.map(($) => [$.id, $])), f = i === "right" ? "x" : "y", n = i === "right" ? "y" : "x", a = ($, k) => k === "x" ? $.w : $.h, p = ($) => {
+    const k = [...e].sort((j, v) => $.get(j.id)[f] - $.get(v.id)[f]), T = [];
+    for (const j of k) {
+      const v = $.get(j.id)[f], A = v + a(j, f), F = T[T.length - 1];
+      F && v < F.end ? (F.end = Math.max(F.end, A), F.ids.push(j.id)) : T.push({ start: v, end: A, ids: [j.id] });
+    }
+    return T;
+  }, u = p(t);
+  let g = p(h);
+  const x = ($) => $.map((k) => [...k.ids].sort().join(",")).join("|");
+  x(g) !== x(u) && (h = t, g = u);
+  const E = ($, k) => {
+    const T = Math.min(...e.map((v) => $.get(v.id)[k]));
+    return Math.max(...e.map((v) => $.get(v.id)[k] + a(v, k))) - T;
+  }, R = ($, k, T = 1) => $ <= m * T || $ <= c * k * T, L = ($) => R(E($, f), E($, n)), H = ($) => L($) || E($, f) <= m * Rn;
+  if (e.length < M || L(h) && H(t)) return { positions: t };
+  const I = new Map(u.flatMap(($, k) => $.ids.map((T) => [T, k]))), P = ($, k, T) => {
+    const [j, v] = [I.get(k), I.get(T)];
+    return j !== void 0 && v !== void 0 && Math.min(j, v) < $ && Math.max(j, v) >= $;
+  }, O = ($) => s.filter(([k, T]) => P($, k, T)).length, y = ii(
+    e.map(($) => $.id),
+    s
+  ), D = ($) => ni * [...l].filter((k) => s.some((T) => T[0] === k && P($, ...T))).length + oi * y.filter((k) => k.some((T) => P($, k[0], T))).length, w = ($, k) => {
+    const T = (k ? r : []).filter((j) => P($, j.a, j.b)).map((j) => (i === "right" ? j.h : j.w) - 2 * Oe);
+    return Math.max(
+      o + 40,
+      84,
+      T.length ? Math.max(...T) + 2 * Oe : 0,
+      (O($) + 1) * Ge + T.reduce((j, v) => j + v, 0)
+    );
+  }, b = ($, k) => {
+    const T = k[k.length - 1].end - k[0].start, j = [], v = new Map(k.flatMap((A) => A.ids.map((F) => [F, A.start])));
+    for (let A = 1; A < $; A++) {
+      const F = (W) => s.filter((X) => P(W, ...X)).reduce((X, [C, K]) => {
+        const [te, ce] = I.get(C) < I.get(K) ? [C, K] : [K, C];
+        return X + Math.abs(v.get(te) - ae - (v.get(ce) - k[W].start));
+      }, 0) / (T / $), Z = k[0].start + T * A / $, se = (W) => O(W) + D(W) + F(W) * si + Math.abs(k[W].start - Z) / (T / $) * 2, ae = k[j.at(-1) ?? 0].start, S = T / $, q = (W, X, C) => k[W - 1].end - ae >= S * C && k[W - 1].end - ae <= S * (1 + X) && k[k.length - 1].end - k[W].start <= S * ($ - A) * (1 + X), G = (W) => !D(W) && q(W, 0.25, 0.5) ? 0 : !D(W) && q(W, 0.5, 0) ? 1 : q(W, 0.25, 0.5) ? 2 : 3;
+      let U = 0;
+      for (let W = (j.at(-1) ?? 0) + 1; W < k.length; W++)
+        (!U || G(W) < G(U) || G(W) === G(U) && se(W) < se(U)) && (U = W);
+      U && j.push(U);
+    }
+    return j;
+  }, _ = new Set(
+    u.flatMap(
+      ($) => $.ids.length > 1 ? $.ids.filter((k) => !s.some(([T, j]) => T === k && j !== k)) : []
+    )
+  ), N = ($, k) => {
+    const T = [];
+    return k.forEach((j, v) => v === 0 || $.includes(v) ? T.push([j]) : T.at(-1).push(j)), T;
+  }, Q = ($, k) => {
+    const T = N($, k), j = new Map(T.flatMap((F, Z) => F.flatMap((se) => se.ids.map((ae) => [ae, Z])))), v = new Map(k.flatMap((F) => F.ids.map((Z) => [Z, F.start]))), A = /* @__PURE__ */ new Map();
+    for (const [F, Z] of T.entries()) {
+      if (!F) continue;
+      const se = [];
+      for (const ae of Z[0].ids) {
+        if (l.has(ae)) continue;
+        const S = s.filter(([C, K]) => K === ae && C !== ae).map(([C]) => C), q = s.filter(([C, K]) => C === ae && K !== ae).map(([, C]) => C);
+        if (!S.length || S.some((C) => j.get(C) !== F - 1)) continue;
+        const G = (C, K) => v.get(C) - T[K][0].start, U = (C) => S.reduce((K, te) => K + Math.abs(G(te, F - 1) - G(ae, C)), 0) + q.reduce((K, te) => K + Math.abs(G(ae, C) - G(te, j.get(te))), 0), W = (C) => (C === F - 1 ? 0 : S.length) + q.filter((K) => j.get(K) !== C).length;
+        if (W(F - 1) > W(F) || U(F - 1) >= U(F)) continue;
+        const X = S.reduce((C, K) => v.get(K) > v.get(C) ? K : C);
+        se.push({ id: ae, source: X, saves: U(F) - U(F - 1) });
+      }
+      se.sort((ae, S) => S.saves - ae.saves);
+      for (const ae of se.slice(0, Z[0].ids.length - 1)) A.set(ae.id, ae.source);
+    }
+    return A;
+  }, z = ($, k, T, j, v = /* @__PURE__ */ new Map()) => {
+    const A = N($, k);
+    if (v.size) {
+      T = new Map(T);
+      const q = [];
+      for (const [G, U] of v) {
+        const W = d.get(G);
+        let C = T.get(U)[n] + (a(d.get(U), n) - a(W, n)) / 2;
+        for (const K of q) C < K.hi + o && C + a(W, n) > K.lo && (C = K.hi + o);
+        q.push({ lo: C, hi: C + a(W, n) }), T.set(G, { ...T.get(G), [n]: C });
+      }
+    }
+    const F = /* @__PURE__ */ new Map(), Z = [];
+    let se = 0, ae = 0, S = 0;
+    for (const [q, G] of A.entries()) {
+      const U = A[q + 1]?.[0].ids ?? [], W = [
+        ...G.flatMap((oe) => oe.ids).filter((oe) => !v.has(oe)),
+        ...U.filter((oe) => v.has(oe))
+      ], X = Math.min(...W.map((oe) => T.get(oe)[f])), C = Math.min(...W.map((oe) => T.get(oe)[n])), K = Math.max(...W.map((oe) => T.get(oe)[n] + a(d.get(oe), n)));
+      for (const oe of W) {
+        const ke = T.get(oe), Se = ke[f] - X, Me = ke[n] - C + se;
+        F.set(oe, i === "right" ? { x: Se, y: Me } : { x: Me, y: Se });
+      }
+      const te = q < $.length ? w($[q], j) : 0, ce = W.filter((oe) => !_.has(oe)), ue = ce.length ? ce : W;
+      se += K - C + te, S += Math.max(...ue.map((oe) => T.get(oe)[n] + a(d.get(oe), n))) - Math.min(...ue.map((oe) => T.get(oe)[n])) + te, ae = Math.max(
+        ae,
+        Math.max(...W.map((oe) => T.get(oe)[f] + a(d.get(oe), f))) - X
+      ), Z.push(W);
+    }
+    return {
+      out: F,
+      length: ae,
+      // The depth that decides the count leaves side leaves out.
+      depth: S,
+      count: A.length,
+      bands: Z
+    };
+  };
+  let Y = 0;
+  if (!L(h))
+    for (let $ = 2; $ <= u.length && !Y; $++) {
+      const k = z(b($, g), g, h, !1);
+      k.count === $ && R(k.length, k.depth) && (Y = $);
+    }
+  for (let $ = Math.max(2, Y); $ <= u.length; $++) {
+    const k = b($, g), T = z(k, u, t, !0), j = $ === Y ? Rn : 1;
+    if (T.count !== $ || !R(T.length, T.depth, j)) continue;
+    const v = Q(k, g), A = v.size ? z(k, u, t, !0, v) : void 0, F = A && R(A.length, A.depth, j) ? A : T;
+    return { positions: F.out, fold: { bands: F.bands, axis: i } };
+  }
+  return { positions: t };
+}
+function ai(e, t, i, o, s) {
+  const r = /* @__PURE__ */ new Map();
+  for (const { scope: l, fold: h } of e) {
+    const c = h.axis === "right", M = (E) => c ? E.y : E.x, m = (E) => c ? E.y + E.h : E.x + E.w, d = (E) => c ? E.x : E.y, f = (E) => c ? E.x + E.w : E.y + E.h, n = (E) => (d(E) + f(E)) / 2, a = (E) => (M(E) + m(E)) / 2, p = (E, R) => d(E) < f(R) && f(E) > d(R), u = new Map(h.bands.flatMap((E, R) => E.map((L) => [L, R]))), g = (E) => u.get(o(E.id, l) ?? ""), x = (E) => [...i.values()].filter((R) => R.type !== "group" && g(R) === E);
+    for (let E = 0; E + 1 < h.bands.length; E++) {
+      const R = h.bands[E].map((Y) => i.get(Y)), L = h.bands[E + 1].map((Y) => i.get(Y)), H = Math.max(...R.map(m)), I = Math.min(...L.map(M)), P = Math.max(...R.map(f)) + Ge, O = Math.min(...L.map(d)) - Ge, [y, D] = [x(E), x(E + 1)], w = t.flatMap((Y) => {
+        const $ = i.get(Y.source), k = i.get(Y.target);
+        if (g($) !== E || g(k) !== E + 1) return [];
+        if (Y.from !== "auto" || Y.to !== "auto") return [];
+        const T = y.some((A) => M(A) > M($) && p(A, $)), j = o(Y.target, l) !== Y.target || D.some((A) => M(A) < M(k) && p(A, k)), v = (A, F) => M(A) < m(F) && m(A) > M(F);
+        return T && y.some((A) => v(A, $) && d(A) >= f($)) ? [] : j && D.some((A) => v(A, k) && f(A) <= d(k)) ? [] : [{ id: Y.id, source: $, target: k, leave: T, enter: j }];
+      }), b = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map();
+      for (const Y of w)
+        Y.leave || _.set(Y.source.id, [..._.get(Y.source.id) ?? [], Y]);
+      for (const Y of _.values()) {
+        const $ = (k) => Math.abs(n(k.target) - n(k.source)) + Math.abs(a(k.target) - a(k.source));
+        Y.sort((k, T) => $(k) - $(T) || (k.id < T.id ? -1 : 1)), Y.forEach((k, T) => {
+          const j = n(k.target) < n(k.source) ? -1 : 1, v = Math.ceil(T / 2) * s * (T % 2 ? j : -j);
+          b.set(k.id, n(k.source) + v);
+        });
+      }
+      if (!w.length || I - H < (w.length + 1) * Ge) continue;
+      const N = (Y) => {
+        const $ = Y.filter((T) => T.leave), k = Y.filter((T) => T.enter);
+        return Y.map((T, j) => ({
+          w: T,
+          at: le(H + (I - H) * (j + 1) / (Y.length + 1)),
+          leave: T.leave ? le(P + Ge * $.indexOf(T)) : void 0,
+          enter: T.enter ? le(O - Ge * (k.length - 1 - k.indexOf(T))) : void 0
+        }));
+      }, Q = (Y) => N(Y).map(({ w: $, at: k, leave: T, enter: j }) => [
+        ...T !== void 0 ? [
+          { u: f($.source), v: a($.source) },
+          { u: T, v: a($.source) },
+          { u: T, v: k }
+        ] : [
+          { u: b.get($.id), v: H },
+          { u: b.get($.id), v: k }
+        ],
+        ...j !== void 0 ? [
+          { u: j, v: k },
+          { u: j, v: a($.target) },
+          { u: d($.target), v: a($.target) }
+        ] : [
+          { u: n($.target), v: k },
+          { u: n($.target), v: I }
+        ]
+      ]), z = li(
+        [...w].sort((Y, $) => n($.source) - n(Y.source)),
+        (Y) => ri(Q(Y))
+      );
+      for (const { w: Y, at: $, leave: k, enter: T } of N(z))
+        r.set(Y.id, {
+          ...c ? { y: $ } : { x: $ },
+          ...k !== void 0 ? { leave: k } : {},
+          ...T !== void 0 ? { enter: T } : {}
+        });
+    }
+  }
+  return r;
+}
+function ri(e) {
+  const t = e.map((o) => o.slice(1).map((s, r) => [o[r], s]));
+  let i = 0;
+  for (let o = 0; o < t.length; o++)
+    for (let s = o + 1; s < t.length; s++)
+      for (const [r, l] of t[o])
+        for (const [h, c] of t[s]) {
+          const [M, m] = r.v === l.v && h.u === c.u ? [
+            [r, l],
+            [h, c]
+          ] : h.v === c.v && r.u === l.u ? [
+            [h, c],
+            [r, l]
+          ] : [];
+          if (!M || !m) continue;
+          const d = m[0].u, f = M[0].v;
+          d > Math.min(M[0].u, M[1].u) && d < Math.max(M[0].u, M[1].u) && f > Math.min(m[0].v, m[1].v) && f < Math.max(m[0].v, m[1].v) && i++;
+        }
+  return i;
+}
+function li(e, t) {
+  if (e.length > 6) return e;
+  let i = e, o = t(e);
+  const s = (r, l) => {
+    if (o) {
+      if (!l.length) {
+        const h = t(r);
+        h < o && ([i, o] = [r, h]);
+        return;
+      }
+      l.forEach((h, c) => s([...r, h], [...l.slice(0, c), ...l.slice(c + 1)]));
+    }
+  };
+  return s([], e), i;
+}
+const je = 4;
+function ci(e, t, i) {
+  const o = t === "right" ? "x" : "y", s = t === "right" ? "y" : "x", r = (c, M) => M === "x" ? c.w : c.h, l = [], h = /* @__PURE__ */ new Set();
+  for (const c of i) {
+    let [M, m] = [e.get(c.a), e.get(c.b)];
+    if (!M || !m) continue;
+    m[o] < M[o] && ([M, m] = [m, M]);
+    const d = M[o] + r(M, o), f = m[o];
+    if (f <= d) continue;
+    const n = (t === "right" ? c.w : c.h) - 2 * Oe, a = (t === "right" ? c.h : c.w) - 2 * Oe, p = d - n / 2 - je, u = f + n / 2 + je, g = M[s] + r(M, s) / 2, x = m[s] + r(m, s) / 2, E = Math.min(g, x) + je, R = Math.max(g, x) - je;
+    if (R - E < a) continue;
+    const L = [
+      ...[...e.values()].filter((O) => O[o] < u && O[o] + r(O, o) > p).map((O) => ({
+        lo: O[s] - je,
+        hi: O[s] + r(O, s) + je
+      })),
+      ...l.filter((O) => O.from < u && O.to > p)
+    ], H = (O) => L.every((y) => O + a <= y.lo || O >= y.hi), I = (E + R - a) / 2, P = [E, I, ...L.map((O) => O.hi)].filter((O) => O >= E && O + a <= R && H(O)).sort((O, y) => Math.abs(O - I) - Math.abs(y - I))[0];
+    P !== void 0 && (h.add(c), l.push({ lo: P - je, hi: P + a + je, from: p, to: u }));
+  }
+  return h;
+}
+const di = 96, fi = 1.25;
+function hi(e, t, i, o, s) {
+  const r = new Map(e.flatMap((m, d) => m.map((f) => [f, d]))), l = (m) => !t.some(([d, f]) => d === m && f !== m), h = (m) => [
+    ...new Set(t.filter(([d, f]) => f === m && d !== m).map((d) => d[0]))
+  ], c = /* @__PURE__ */ new Set(), M = Math.max(...e.map(s));
+  for (const [m, d] of e.entries())
+    if (m)
+      for (const f of d) {
+        const n = h(f);
+        if (!i(f) || !l(f) || !n.length || n.some((g) => r.get(g) !== m - 1)) continue;
+        const a = [...new Set(t.filter(([g]) => n.includes(g)).map((g) => g[1]))].filter(
+          (g) => g !== f && r.get(g) === m
+        ), p = [f, ...a].filter(l).sort((g, x) => o(x) - o(g))[0], u = [...e[m - 1], ...d.filter((g) => c.has(g)), f];
+        s(u) > fi * M || (a.some((g) => !l(g)) || p !== f) && c.add(f);
+      }
+  return c.size ? e.map((m, d) => [
+    ...m.filter((f) => !c.has(f)),
+    ...(e[d + 1] ?? []).filter((f) => c.has(f))
+  ]).filter((m) => m.length) : e;
+}
+function ui(e, t, i, o, s, r, l = !1, h = [], c = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), m = () => {
+}) {
+  const d = new Map(e.map((k) => [k.id, k])), f = e.map((k) => k.id), n = i === "right", a = (k) => n ? d.get(k).w : d.get(k).h, p = (k) => n ? d.get(k).h : d.get(k).w, u = (k) => d.get(k).type === "group", g = (k) => n ? k.y + k.h / 2 : k.x + k.w / 2, x = new Set(o.flat()), E = (k) => {
+    const T = !x.size || x.has(k) ? [] : (c.get(k) ?? []).flatMap((v) => t.get(v) ?? []);
+    if (T.length) return T.reduce((v, A) => v + g(A), 0) / T.length;
+    const j = t.get(k);
+    return n ? j.y + d.get(k).h / 2 : j.x + d.get(k).w / 2;
+  }, R = (k, T) => Math.max(
+    jt(s, k, T, u(k) || u(T) ? r.group : r.node, !n),
+    vt(d.get(k).soft, d.get(T).soft, n)
+  ), L = (k) => k.reduce((T, j, v) => T + p(j) + (v ? R(k[v - 1], j) : 0), 0), H = hi(
+    Je(f, o),
+    o,
+    l ? u : () => !1,
+    a,
+    L
+  ).map(
+    (k) => Ht(
+      [...k].sort((T, j) => E(T) - E(j) || f.indexOf(T) - f.indexOf(j)),
+      (T) => d.get(T).soft
+    )
+  ), I = new Map(H.flatMap((k, T) => k.map((j) => [j, T]))), P = H.map(L), O = Math.max(...P), y = new Map(f.map((k) => [k, /* @__PURE__ */ new Set()])), D = new Map(f.map((k) => [k, /* @__PURE__ */ new Set()]));
+  for (const [k, T] of o)
+    I.get(T) > I.get(k) && (y.get(k).add(T), D.get(T).add(k));
+  const w = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
+  for (const [k, T] of H.entries()) {
+    let j = (O - P[k]) / 2, v = -1 / 0;
+    for (const [A, F] of T.entries()) {
+      const [Z] = D.get(F), se = D.get(F).size === 1 && y.get(Z).size === 1, ae = se ? m(Z, F) : void 0, S = ae !== void 0 ? w.get(Z) + ae : se ? b.get(Z) - p(F) / 2 : j, q = A ? Math.max(S, v + R(T[A - 1], F)) : S;
+      w.set(F, q), b.set(F, q + p(F) / 2), v = q + p(F), j = Math.max(j + p(F), v) + (T[A + 1] ? R(F, T[A + 1]) : 0);
+    }
+  }
+  const _ = H.length === 1 && N(H[0]);
+  function N(k) {
+    const T = k.map((F) => M.get(F));
+    if (k.length < 2 || T.some((F, Z) => F === void 0 || Z && F < T[Z - 1]))
+      return !1;
+    const j = [];
+    let v = -1 / 0;
+    for (const [F, Z] of k.entries()) {
+      const se = T[F] - T[0] + p(k[0]) / 2 - p(Z) / 2;
+      j.push(F ? Math.max(se, v + R(k[F - 1], Z)) : se), v = j[F] + p(Z);
+    }
+    const A = T.at(-1) - T[0] + (p(k[0]) + p(k.at(-1))) / 2;
+    return v - j[0] > Math.max(P[0] * 1.25, A + 1) ? !1 : (k.forEach((F, Z) => w.set(F, j[Z])), !0);
+  }
+  const Q = Math.min(...w.values()), z = Bt(H, h, s, i), Y = /* @__PURE__ */ new Map();
+  let $ = 0;
+  for (const [k, T] of H.entries()) {
+    for (const A of T) {
+      const F = le(w.get(A) - Q);
+      Y.set(A, n ? { x: $, y: F } : { x: F, y: $ });
+    }
+    const j = H[k + 1];
+    if (!j) break;
+    let v = Math.max(
+      T.some(u) || j.some(u) ? r.group : r.rank,
+      z[k],
+      eo(T, j, (A) => d.get(A).soft, !n)
+    );
+    for (const A of s)
+      Math.min(I.get(A.a), I.get(A.b)) === k && Math.abs(I.get(A.a) - I.get(A.b)) === 1 && (v = Math.max(v, n ? A.w : A.h));
+    $ += Math.max(...T.map(a)) + v;
+  }
+  return { positions: Y, axis: i, followed: _ };
+}
+const pi = 20;
+function Bt(e, t, i, o) {
+  const s = new Map(e.flatMap((h, c) => h.map((M) => [M, c]))), r = (h) => o === "right" ? 2 * Oe : h.h, l = 2 * Oe;
+  return e.slice(0, -1).map((h, c) => {
+    let M = 0, m = 0;
+    const d = [...i], f = [], n = [];
+    for (const p of t) {
+      const u = p.a !== void 0 ? s.get(p.a) : void 0, g = p.b !== void 0 ? s.get(p.b) : void 0;
+      let x;
+      if (u !== void 0 && g !== void 0) {
+        const E = Math.min(u, g), R = Math.max(u, g);
+        if (x = E <= c && R > c && (E === c || R === c + 1), !x) continue;
+        const L = d.findIndex(
+          (H) => H.a === p.a && H.b === p.b || H.a === p.b && H.b === p.a
+        );
+        L >= 0 && (m += r(d.splice(L, 1)[0]) - l, E === c && R === c + 1 && n.push(p));
+      } else {
+        if (x = u !== void 0 ? u === c : g === c + 1, !x) continue;
+        p.label && i.length && (m += r(p.label) - (o === "right" ? l : 0));
+      }
+      M++, f.push(p);
+    }
+    return n.some(
+      (p) => f.some((u) => !(u.a && u.b) && [u.a, u.b].some((g) => g && (g === p.a || g === p.b)))
+    ) ? 2 * pi + (M - 1) * Ge + m : 0;
+  });
+}
+function gi(e, t, i, o = [], s = []) {
+  const r = /* @__PURE__ */ new Map(), l = t.gap, h = We(t), c = new Map(e.map((M) => [M.id, M]));
+  if (t.algorithm === "row" || t.algorithm === "column") {
+    const M = t.algorithm === "row", m = Bt(
+      e.map((f) => [f.id]),
+      s,
+      o,
+      M ? "right" : "down"
+    );
+    let d = 0;
+    for (const [f, n] of e.entries()) {
+      const a = e[f + 1]?.id ?? "";
+      r.set(n.id, M ? { x: d, y: 0 } : { x: 0, y: d }), d += (M ? n.w : n.h) + Math.max(
+        jt(o, n.id, a, l, M),
+        m[f] ?? 0,
+        vt(n.soft, e[f + 1]?.soft, !M)
+      );
+    }
+  } else {
+    const M = e.map((g) => g.id), m = (g) => c.get(g).soft, d = i.length ? no(Je(M, i), i, (g) => Ht(g, m)) : M.map((g) => [g]), f = (g) => h === "right" ? c.get(g).w : c.get(g).h, n = (g) => h === "right" ? c.get(g).h : c.get(g).w, a = new Map(d.flatMap((g, x) => g.map((E) => [E, x]))), p = Bt(d, s, o, h);
+    let u = 0;
+    for (const [g, x] of d.entries()) {
+      let E = 0, R = Math.max(l, p[g] ?? 0);
+      for (const [L, H] of x.entries())
+        r.set(H, h === "right" ? { x: u, y: E } : { x: E, y: u }), E += n(H) + Math.max(
+          jt(o, H, x[L + 1] ?? "", l, h !== "right"),
+          x[L + 1] ? vt(m(H), m(x[L + 1]), h === "right") : 0
+        );
+      d[g + 1] && (R = Math.max(R, eo(x, d[g + 1], m, h === "down")));
+      for (const L of o)
+        Math.min(a.get(L.a), a.get(L.b)) === g && Math.abs(a.get(L.a) - a.get(L.b)) === 1 && (R = Math.max(R, h === "right" ? L.w : L.h));
+      u += Math.max(...x.map(f)) + R;
+    }
+  }
+  return { positions: r, axis: h };
+}
+function no(e, t, i = (o) => o) {
+  const o = [i(e[0])];
+  for (let s = 1; s < e.length; s++) {
+    const r = new Map(o[s - 1].map((d, f) => [d, f])), h = e[s].map((d, f) => {
+      const n = t.flatMap(([a, p]) => a === d ? [p] : p === d ? [a] : []).filter((a) => r.has(a)).map((a) => r.get(a));
+      return {
+        id: d,
+        key: n.length ? n.reduce((a, p) => a + p, 0) / n.length : null,
+        k: f
+      };
+    }).filter((d) => d.key !== null), c = [...h].sort((d, f) => d.key - f.key || d.k - f.k), M = h.map((d) => d.k), m = [...e[s]];
+    c.forEach((d, f) => m[M[f]] = d.id), o.push(i(m));
+  }
+  return o;
+}
+class On {
+  parent;
+  constructor(t) {
+    this.parent = new Map(t.map((i) => [i, i]));
+  }
+  find(t) {
+    let i = t;
+    for (; this.parent.get(i) !== i; ) i = this.parent.get(i);
+    return i;
+  }
+  join(t, i) {
+    t = this.find(t), i = this.find(i), t !== i && this.parent.set(i, t);
+  }
+}
+function mi(e, t, i, o) {
+  const s = i.filter((d) => d.type === "stay");
+  if (!s.length) return [];
+  const r = new Map(s.map((d) => [d.id, { x: d.x, y: d.y }])), l = /* @__PURE__ */ new Set(), h = o === "right" ? "x" : "y", c = o === "right" ? "y" : "x", M = (d, f) => f === "x" ? d.w : d.h, m = (d, f, n, a, p) => Math.min(f[p] + M(d, p), a[p] + M(n, p)) - Math.max(f[p], a[p]);
+  for (let d = 0; d < e.length; d++)
+    for (let f = d + 1; f < e.length; f++) {
+      const n = e[d], a = e[f], p = r.get(n.id), u = r.get(a.id), g = t.get(n.id), x = t.get(a.id);
+      !p || !u || !g || !x || m(n, g, a, x, h) > 0 || m(n, p, a, u, c) > 0 && m(n, p, a, u, h) >= Math.min(M(n, h), M(a, h)) / 2 && (l.add(n.id), l.add(a.id));
+    }
+  return s.filter((d) => l.has(d.id));
+}
+function wi(e, t, i, o, s, r) {
+  const l = e.map((y) => y.id), h = new Map(e.map((y) => [y.id, y])), c = new Map(e.map((y) => [y.id, { ...t.get(y.id) }])), M = new Map(l.map((y) => [y, 1])), m = i.filter(
+    (y) => "ids" in y ? y.type === "align" && y.ids.every((D) => h.has(D)) : "id" in y && h.has(y.id)
+  ), d = /* @__PURE__ */ new Map(), f = mi(e, t, m, r);
+  f.length && s.push({
+    level: "info",
+    code: "stale-stay",
+    message: `The stays on ${f.map((y) => y.id).join(", ")} no longer fit ${o}'s arrangement, so they were ignored. Drag again to anchor the new layout.`,
+    line: f[0].line,
+    ids: f.map((y) => y.id)
+  });
+  for (const y of m)
+    y.type === "stay" && !f.includes(y) && (c.set(y.id, { x: y.x, y: y.y }), M.set(y.id, y.weight), d.set(y.id, { pos: { x: y.x, y: y.y }, hint: y }));
+  for (const y of m)
+    if (y.type === "nudge") {
+      const D = t.get(y.id), w = { x: D.x + y.dx, y: D.y + y.dy };
+      c.set(y.id, w), M.set(y.id, 4), d.set(y.id, { pos: w, hint: y });
+    }
+  const n = new Map(
+    m.flatMap((y) => y.type === "near" && h.has(y.ref) ? [[y.id, y]] : [])
+  ), a = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), u = (y) => {
+    const D = n.get(y);
+    if (a.has(y) || !D) return;
+    if (p.has(y))
+      throw new _e(
+        `Relative placement cycle in ${o}. Replace one near with nudge.`,
+        D.line
+      );
+    p.add(y), u(D.ref);
+    const w = h.get(y), b = h.get(D.ref), _ = c.get(D.ref);
+    let N = _.x + (b.w - w.w) / 2, Q = _.y + (b.h - w.h) / 2;
+    D.side === "right" || D.side === "left" ? (N = D.side === "right" ? _.x + b.w + D.gap : _.x - w.w - D.gap, Q += D.offset) : (Q = D.side === "below" ? _.y + b.h + D.gap : _.y - w.h - D.gap, N += D.offset), c.set(y, { x: N, y: Q }), M.set(y, 5), d.set(y, { pos: { x: N, y: Q }, hint: D }), p.delete(y), a.add(y);
+  };
+  l.forEach(u);
+  for (const y of m)
+    if (y.type === "align" && y.strength === "prefer") {
+      const D = h.get(y.ids[0]), w = c.get(D.id), b = (N) => y.axis === "x" ? N.w : N.h, _ = w[y.axis] + b(D) / 2;
+      for (const N of y.ids.slice(1)) c.get(N)[y.axis] = _ - b(h.get(N)) / 2;
+    }
+  const g = new Map(m.flatMap((y) => y.type === "pin" ? [[y.id, y]] : []));
+  for (const [y, D] of g) c.set(y, { x: D.x, y: D.y });
+  const x = (y, D) => (y === "x" ? h.get(D).w : h.get(D).h) / 2, E = { x: new On(l), y: new On(l) };
+  for (const y of m)
+    if (y.type === "align" && y.strength === "required")
+      for (const D of y.ids.slice(1)) {
+        const w = /* @__PURE__ */ new Set([E[y.axis].find(y.ids[0]), E[y.axis].find(D)]), b = l.filter((_) => g.has(_) && w.has(E[y.axis].find(_))).map((_) => c.get(_)[y.axis] + x(y.axis, _));
+        b.length > 1 && Math.max(...b) - Math.min(...b) > 0.01 ? s.push({
+          level: "error",
+          code: "pin-align-conflict",
+          message: `Pins conflict with required ${y.axis} alignment in ${o}. The pins were kept.`,
+          line: y.line,
+          ids: y.ids
+        }) : E[y.axis].join(y.ids[0], D);
+      }
+  const R = { x: /* @__PURE__ */ new Map(), y: /* @__PURE__ */ new Map() };
+  for (const y of ["x", "y"])
+    for (const D of l) {
+      const w = E[y].find(D), b = c.get(D)[y] + x(y, D);
+      R[y].has(w) || R[y].set(w, { sum: 0, weight: 0, value: 0, fixed: null, members: [] });
+      const _ = R[y].get(w);
+      _.sum += b * M.get(D), _.weight += M.get(D), _.members.push(D), g.has(D) && (_.fixed = b);
+    }
+  for (const y of ["x", "y"])
+    for (const D of R[y].values()) D.value = D.fixed ?? D.sum / D.weight;
+  const L = (y, D) => R[y].get(E[y].find(D)), H = (y, D) => L(y, D).value, I = (y, D, w, b) => {
+    const _ = L(y, D), N = L(y, w), Q = b - (_.value - N.value);
+    if (Q <= 5e-3 || _ === N || _.fixed !== null && N.fixed !== null) return 0;
+    if (_.fixed !== null) N.value -= Q;
+    else if (N.fixed !== null) _.value += Q;
+    else {
+      const z = _.weight + N.weight;
+      _.value += Q * N.weight / z, N.value -= Q * _.weight / z;
+    }
+    return Q;
+  }, P = m.flatMap(
+    (y) => y.type === "near" && y.strength === "required" && h.has(y.ref) ? [y] : []
+  ), O = r === "right" ? "x" : "y";
+  for (let y = 0; y < 48; y++) {
+    let D = 0;
+    for (const w of P) {
+      const b = w.side === "right" || w.side === "left" ? "x" : "y", _ = w.side === "right" || w.side === "below";
+      D += I(
+        b,
+        _ ? w.id : w.ref,
+        _ ? w.ref : w.id,
+        x(b, w.id) + x(b, w.ref) + w.gap
+      );
+    }
+    for (let w = 0; w < e.length; w++)
+      for (let b = w + 1; b < e.length; b++) {
+        const _ = e[w], N = e[b], Q = H("x", N.id) - H("x", _.id), z = H("y", N.id) - H("y", _.id), Y = (_.w + N.w) / 2 + Ze - Math.abs(Q), $ = (_.h + N.h) / 2 + Ze - Math.abs(z);
+        if (Y <= 5e-3 || $ <= 5e-3) continue;
+        const k = ["x", "y"].filter(
+          (A) => L(A, _.id) !== L(A, N.id) && !(L(A, _.id).fixed !== null && L(A, N.id).fixed !== null)
+        );
+        if (!k.length) continue;
+        const T = (A) => (A === "x" ? Y : $) + (A === O ? 0 : 3), j = [...k].sort((A, F) => T(A) - T(F))[0], v = j === "x" ? Q : z;
+        D += I(
+          j,
+          v >= 0 ? N.id : _.id,
+          v >= 0 ? _.id : N.id,
+          (j === "x" ? _.w + N.w : _.h + N.h) / 2 + Ze
+        );
+      }
+    if (o !== "root")
+      for (const w of ["x", "y"])
+        for (const b of R[w].values()) {
+          const _ = Math.max(...b.members.map((N) => x(w, N)));
+          b.value < _ && b.fixed === null && (D += _ - b.value, b.value = _);
+        }
+    if (D < 0.01) break;
+  }
+  for (const y of e)
+    c.set(y.id, {
+      x: le(H("x", y.id) - y.w / 2),
+      y: le(H("y", y.id) - y.h / 2)
+    });
+  for (let y = 0; y < e.length; y++)
+    for (let D = y + 1; D < e.length; D++) {
+      const w = e[y], b = e[D], _ = c.get(w.id), N = c.get(b.id);
+      _.x + w.w > N.x + 0.1 && N.x + b.w > _.x + 0.1 && _.y + w.h > N.y + 0.1 && N.y + b.h > _.y + 0.1 && s.push({
+        level: "error",
+        code: "overlap",
+        message: `${w.id} overlaps ${b.id}. Release a pin or give ${o} more room.`,
+        ids: [w.id, b.id]
+      });
+    }
+  for (const y of P) {
+    const D = h.get(y.id), w = h.get(y.ref), b = c.get(D.id), _ = c.get(w.id);
+    (y.side === "right" ? b.x - _.x - w.w : y.side === "left" ? _.x - b.x - D.w : y.side === "below" ? b.y - _.y - w.h : _.y - b.y - D.h) < y.gap - 0.5 && s.push({
+      level: "error",
+      code: "unsatisfied-near",
+      message: `Required: ${y.id} ${y.side} of ${y.ref} is not satisfied.`,
+      line: y.line,
+      ids: [y.id, y.ref]
+    });
+  }
+  for (const [y, { pos: D, hint: w }] of d) {
+    if (g.has(y) || w.type === "near" && w.strength === "required") continue;
+    const b = c.get(y), _ = Math.round(Math.hypot(b.x - D.x, b.y - D.y));
+    _ >= 2 && s.push({
+      level: _ >= Sn ? "warning" : "info",
+      code: "relaxed",
+      message: `${w.type} ${y} gave way by ${_} px to keep ${o} clear.${_ >= Sn ? ` Remove line ${w.line}, or run format --drop-stale.` : ""}`,
+      line: w.line,
+      ids: [y]
+    });
+  }
+  return c;
+}
+const yi = 0.5, Mi = 16, $n = (e) => Math.min(e * yi, Math.max(0, e - Mi));
+function Ut(e, t, i = !1) {
+  if (i) return ht(e, t, !0);
+  const o = new Map(e.objects.map((d) => [d.id, d])), s = e.hints.filter(
+    (d) => d.type === "near" && Ft(o, d.id, d.ref) !== d.ref
+  );
+  if (s.length) {
+    const d = Ut(
+      { ...e, hints: e.hints.filter((a) => !s.includes(a)) },
+      t
+    ), f = (a, p) => {
+      const u = d.byId.get(a);
+      return p === "x" ? u.x + u.w / 2 : u.y + u.h / 2;
+    }, n = e.hints.map((a) => {
+      if (!s.includes(a) || a.type !== "near") return a;
+      const p = Ft(o, a.id, a.ref), u = a.side === "left" || a.side === "right" ? "y" : "x";
+      return { ...a, ref: p, offset: a.offset + f(a.ref, u) - f(p, u) };
+    });
+    return Ut({ ...e, hints: n }, t);
+  }
+  const r = { ...e, hints: e.hints.filter((d) => d.type === "size" || d.type === "order") }, l = ht(r, t), h = l, c = oo.get(h), M = (d) => (Math.max(...d.map((f) => f.x + f.w)) - Math.min(...d.map((f) => f.x))) * (Math.max(...d.map((f) => f.y + f.h)) - Math.min(...d.map((f) => f.y))), m = Zo(
+    es(h.objects, e.edges, e.routing),
+    M(h.objects),
+    (d) => M(ht(r, t, !1, d, c).objects)
+  );
+  return ht(e, t, !1, m.size ? m : void 0, c);
+}
+const oo = /* @__PURE__ */ new WeakMap();
+function ht(e, t, i = !1, o, s) {
+  const r = e.edges.filter((S) => S.constraint !== !1 && S.directed !== !1), l = [], h = /* @__PURE__ */ new Map([["root", []]]);
+  for (const S of e.objects)
+    h.has(S.parent) || h.set(S.parent, []), h.get(S.parent).push(S);
+  const c = tt(e.appearance), M = c.groupHeader, m = /* @__PURE__ */ new Map(), d = c.theme === mt ? c : tt({ ...e.appearance, theme: mt }), f = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), x = new Map(e.objects.map((S) => [S.id, S])), E = /* @__PURE__ */ new Map(), R = (S, q) => {
+    let G = x.get(S);
+    for (; G && G.parent !== q; ) G = x.get(G.parent);
+    return G?.id;
+  }, L = [], H = [], I = new Set(s?.groups);
+  let P = s?.wrap ?? !1;
+  const O = (S) => {
+    const q = /* @__PURE__ */ new Map();
+    for (const G of r) {
+      const U = R(G.source, S);
+      U && R(G.target, S) !== U && q.set(U, [...q.get(U) ?? [], G]);
+    }
+    return new Set(
+      [...q].filter(
+        ([G, U]) => U.length > 1 && (x.get(G).shape === "diamond" || U.filter((W) => W.label).length > 1)
+      ).map(([G]) => G)
+    );
+  }, y = (S) => r.map((q) => [R(q.source, S), R(q.target, S)]).filter((q) => !!q[0] && !!q[1] && q[0] !== q[1]), D = (S, q, G) => {
+    const U = (te) => R(te, S) !== void 0, W = e.objects.filter((te) => U(te.id)).map((te) => te.id), X = new Map(
+      Je(
+        W,
+        r.filter((te) => U(te.source) && U(te.target)).map((te) => [te.source, te.target])
+      ).flatMap((te, ce) => te.map((ue) => [ue, ce]))
+    ), C = new Map(q.map((te) => [te, 1 / 0]));
+    for (const te of W) {
+      const ce = R(te, S);
+      C.set(ce, Math.min(C.get(ce), X.get(te)));
+    }
+    const K = (te, ce) => {
+      const ue = /* @__PURE__ */ new Set([te]), oe = [te];
+      for (; oe.length; ) {
+        const ke = oe.pop();
+        if (ke === ce) return !0;
+        for (const [Se, Me] of G)
+          Se === ke && !ue.has(Me) && (ue.add(Me), oe.push(Me));
+      }
+      return !1;
+    };
+    return G.filter(([te, ce]) => !(C.get(ce) < C.get(te) && K(ce, te)));
+  }, w = (S) => {
+    h.get(S);
+  };
+  let b = 0, _ = 0;
+  for (const S of h.keys()) {
+    const q = w(S);
+    if (!q) continue;
+    b = Math.max(b, q.groupGap);
+    const G = y(S), U = new Map(
+      Je(
+        (h.get(S) ?? []).map((X) => X.id),
+        G
+      ).flatMap((X, C) => X.map((K) => [K, C]))
+    ), W = Math.max(0, ...U.values());
+    for (let X = 0; X < W; X++)
+      _ = Math.max(
+        _,
+        G.filter(
+          ([C, K]) => Math.min(U.get(C), U.get(K)) <= X && Math.max(U.get(C), U.get(K)) > X
+        ).length
+      );
+  }
+  b = Math.min(di, Math.max(b, (_ + 1) * (e.routing.edgeGap ?? 16)));
+  function N(S) {
+    const q = St(e, S);
+    return q.algorithm === "row" ? "right" : q.algorithm === "column" ? "down" : We(q);
+  }
+  function Q(S, q) {
+    const G = We(q) === "right", U = Math.max(q.gap, Ls), W = /* @__PURE__ */ new Map();
+    for (const ee of S) for (const he of h.get(ee.id) ?? []) W.set(he.id, ee.id);
+    const X = [...W.keys()], C = (ee) => f.get(ee) ?? p.get(ee), K = (ee) => G ? C(ee).w : C(ee).h, te = (ee) => G ? C(ee).h : C(ee).w, ce = (ee) => {
+      let he = x.get(ee);
+      for (; he && !W.has(he.id); ) he = x.get(he.parent);
+      return he?.id;
+    }, ue = r.map((ee) => [ce(ee.source), ce(ee.target)]).filter((ee) => !!ee[0] && !!ee[1] && ee[0] !== ee[1]), oe = X.length ? no(Je(X, ue), ue) : [], ke = new Map(oe.flatMap((ee, he) => ee.map((we) => [we, he]))), Se = oe.map((ee) => Math.max(...ee.map(K))), Me = [];
+    let Pe = 0;
+    for (const [ee, he] of oe.entries()) {
+      Me.push(Pe);
+      let we = U;
+      for (const Ie of e.edges) {
+        const ye = ke.get(ce(Ie.source) ?? ""), xe = ke.get(ce(Ie.target) ?? "");
+        if (Ie.label && ye !== void 0 && xe !== void 0 && Math.min(ye, xe) === ee && ye !== xe) {
+          const ve = _t("", "", Ie.label, c);
+          we = Math.max(we, G ? ve.w : ve.h);
+        }
+      }
+      Pe += Se[ee] + (he === oe.at(-1) ? 0 : we);
+    }
+    const Ee = Pe, st = /* @__PURE__ */ new Map();
+    for (const ee of S) {
+      const he = oe.map((ye) => ye.filter((xe) => W.get(xe) === ee.id)), we = (ye) => ye.reduce((xe, ve, Ce) => xe + te(ve) + (Ce ? Mn : 0), 0), Ie = Math.max(Rs, ...he.map(we));
+      st.set(ee.id, Ie), he.forEach((ye, xe) => {
+        let ve = (Ie - we(ye)) / 2;
+        for (const Ce of ye) {
+          const ge = Me[xe] + (Se[xe] - K(Ce)) / 2, De = G ? { x: ge, y: ve } : { x: ve, y: ge };
+          u.set(Ce, { x: le(De.x), y: le(De.y) }), g.set(Ce, De), ve += te(Ce) + Mn;
+        }
+      });
+    }
+    const it = (ee) => Math.ceil(pe(ee.label, c.groupTitle)) + Dt, $e = Math.max(Ee + 2 * be, ...S.map(it));
+    let qe = 0;
+    for (const ee of S) {
+      const he = st.get(ee.id);
+      ee.w = G ? $e : Math.max(he + 2 * be, it(ee)), ee.h = M + (G ? he : Ee) + be;
+      const we = G ? { x: 0, y: qe } : { x: qe, y: 0 };
+      u.set(ee.id, we), g.set(ee.id, we), qe += (G ? ee.h : ee.w) + xn;
+    }
+    const Fe = Math.max(0, qe - xn);
+    return G ? { w: S.length ? $e : 0, h: Fe } : { w: Fe, h: S.length ? M + Ee + be : 0 };
+  }
+  function z(S) {
+    const q = St(e, S), G = e.hints.find((B) => B.type === "order" && B.scope === S);
+    let U = h.get(S) ?? [];
+    if (G?.type === "order" && (U = [...G.ids.flatMap((J) => U.filter((V) => V.id === J)), ...U.filter((J) => !G.ids.includes(J.id))]), q.algorithm === "cells") return Y(S, U, q);
+    const W = /* @__PURE__ */ new Map(), X = U.map((B) => {
+      let J;
+      if (B.type === "group") {
+        const ie = z(B.id), ne = St(e, B.id), fe = !h.get(B.id)?.length, de = n.get(B.id);
+        J = de !== void 0 ? {
+          w: Math.max(ie.w, ne.minWidth),
+          h: Math.max(ie.h + de, ne.minHeight)
+        } : (() => {
+          const me = Math.max(
+            fe ? bn.w : 0,
+            ie.w + be + (o?.get(B.id)?.right ?? be),
+            ne.minWidth
+          ), Ne = Vs(B.label, me, c);
+          return Ne.lines > 1 && m.set(B.id, Ne.lines), {
+            w: Math.max(me, Ne.w),
+            h: Math.max(
+              fe ? bn.h : 0,
+              ie.h + pt(c, Ne.lines) + (o?.get(B.id)?.bottom ?? be),
+              ne.minHeight
+            )
+          };
+        })();
+      } else {
+        const ie = e.hints.find((fe) => fe.type === "size" && fe.id === B.id), ne = Tn(B, ie?.type === "size" ? ie : void 0, c);
+        if (J = ne, d !== c) {
+          const fe = Tn(B, ie?.type === "size" ? ie : void 0, d);
+          W.set(B.id, {
+            look: { w: le(ne.w), h: le(ne.h) },
+            ref: { w: le(fe.w), h: le(fe.h) }
+          });
+        }
+        B.shape === "diamond" && !ie && ne.w > Yn("diamond").w * ti && l.push({
+          level: "info",
+          code: "big-diamond",
+          message: `${B.id}'s question makes its diamond ${le(ne.w)}px square, much larger than the shapes around it. Shorten the question, or move the detail onto its edges' labels.`,
+          line: B.line,
+          ids: [B.id]
+        }), ne.overflow && l.push({
+          level: "warning",
+          code: "text-overflow",
+          message: `${B.id}'s title does not fit in its requested size. Make it larger or remove the size line.`,
+          line: ie?.line,
+          ids: [B.id]
+        });
+      }
+      const V = { ...B, w: le(J.w), h: le(J.h) };
+      return p.set(B.id, V), V;
+    });
+    if (S === "root" && q.algorithm === "lanes") return Q(X, q);
+    const C = y(S), K = x.get(S)?.parent, te = K !== void 0 && N(K) === N(S), ce = (S === "root" ? [] : e.edges).flatMap((B) => {
+      const J = R(B.source, S), V = R(B.target, S);
+      return !J && !V || J === V || !(J && V) && !te ? [] : [{ a: J, b: V, label: B.label && !(J && V) ? He(B.label, c) : void 0 }];
+    }), ue = /* @__PURE__ */ new Map();
+    for (const B of r) {
+      const J = R(B.source, S), V = R(B.target, S);
+      J && !V && ue.set(J, [...ue.get(J) ?? [], B.target]), V && !J && ue.set(V, [...ue.get(V) ?? [], B.source]);
+    }
+    const oe = (B, J) => {
+      const V = u.get(B), ie = f.get(B) ?? p.get(B);
+      return J ? V.y + ie.h / 2 : V.x + ie.w / 2;
+    }, ke = /* @__PURE__ */ new Map(), Se = x.get(S)?.parent, Me = Se !== void 0 && h.get(Se) || [], Pe = X.map((B) => ue.get(B.id) ?? []), Ee = Pe[0]?.length === 1 ? x.get(Pe[0][0])?.parent : void 0, st = Me.findIndex((B) => B.id === Ee) < Me.findIndex((B) => B.id === S);
+    if (Ee !== void 0 && Ee !== S && Me.some((B) => B.id === Ee) && st && Pe.every((B) => B.length === 1 && x.get(B[0])?.parent === Ee && u.has(B[0])))
+      for (const [B, J] of X.entries())
+        ke.set(J.id, oe(Pe[B][0], N(Ee) === "right"));
+    const it = (B, J) => {
+      if (E.get(J) !== B) return;
+      const V = N(S) === "right", ie = (de) => V ? pt(c, m.get(de)) : be, fe = e.edges.filter(
+        (de) => x.get(de.source)?.parent === B && x.get(de.target)?.parent === J
+      ).sort((de, me) => oe(de.target, V) - oe(me.target, V))[0];
+      return fe ? ie(B) + oe(fe.source, V) - ie(J) - oe(fe.target, V) : void 0;
+    }, $e = e.edges.flatMap((B) => {
+      const J = R(B.source, S), V = R(B.target, S);
+      if (!B.label || !J || !V || J === V) return [];
+      const ie = _t(J, V, B.label, c);
+      if (d === c) return [ie];
+      const ne = _t(J, V, B.label, d);
+      return [{ a: J, b: V, w: Math.max(ne.w, ie.w - Oe), h: Math.max(ne.h, ie.h - Oe) }];
+    }), qe = t, Fe = w(S), ee = Fe ? { node: Fe.nodeGap, rank: Fe.rankGap, group: b } : void 0, he = Fe ? D(
+      S,
+      X.map((B) => B.id),
+      C
+    ) : void 0, we = (B, J) => {
+      const V = q.algorithm === "row" ? "right" : q.algorithm === "column" ? "down" : B, ie = {
+        x: V === "right",
+        y: V === "down"
+      }, ne = (de) => i ? de : W.get(de.id)?.look ?? de, fe = /* @__PURE__ */ new Map();
+      return new Map(
+        X.map((de) => {
+          const me = ne(de);
+          return [
+            de.id,
+            {
+              x: ie.x ? (de.w - me.w) / 2 : 0,
+              y: fe.get(de.id) ?? (ie.y ? (de.h - me.h) / 2 : 0),
+              w: me.w,
+              h: me.h
+            }
+          ];
+        })
+      );
+    }, Ie = (B) => {
+      for (const re of X) {
+        const Ae = W.get(re.id);
+        Ae && (re.w = Math.max(Ae.ref.w, Ae.look.w - B.w), re.h = Math.max(Ae.ref.h, Ae.look.h - B.h));
+      }
+      const J = (re) => ee ? ui(
+        X,
+        t,
+        We(qe),
+        he,
+        re,
+        ee,
+        S === "root",
+        ce,
+        ue,
+        ke,
+        it
+      ) : gi(X, q, C, re, ce), V = $e.length ? J([]) : void 0, ie = V ? ci(
+        new Map(
+          X.map((re) => {
+            const Ae = V.positions.get(re.id), at = we(V.axis, V.positions).get(re.id);
+            return [re.id, { x: Ae.x + at.x, y: Ae.y + at.y, w: at.w, h: at.h }];
+          })
+        ),
+        V.axis,
+        $e
+      ) : /* @__PURE__ */ new Set(), ne = J($e.filter((re) => !ie.has(re)));
+      let fe;
+      if (q.algorithm === "flow" && q.fold === "auto") {
+        const re = It(
+          X,
+          ne.positions,
+          ne.axis,
+          q.gap,
+          C,
+          $e,
+          O(S),
+          (V ?? ne).positions
+        );
+        ne.positions = re.positions, fe = re.fold;
+      }
+      const de = !fe && Fe && qe?.engine?.params.fold !== "never";
+      if (de && I.has(S)) {
+        const re = It(
+          X,
+          ne.positions,
+          ne.axis,
+          ee.rank,
+          C,
+          $e,
+          O(S),
+          (V ?? ne).positions,
+          { fewest: 2, room: 0 }
+        );
+        ne.positions = re.positions, fe = re.fold;
+      }
+      if (de && S === "root" && P) {
+        const re = It(
+          X,
+          ne.positions,
+          ne.axis,
+          ee.rank,
+          C,
+          $e,
+          O(S),
+          (V ?? ne).positions,
+          { aspect: Ln, fewest: 2 }
+        );
+        ne.positions = re.positions, fe = re.fold;
+      }
+      const me = o?.get(S);
+      if (me && (me.left > be || me.top))
+        for (const [re, Ae] of ne.positions)
+          ne.positions.set(re, { x: Ae.x + me.left - be, y: Ae.y + me.top });
+      const Ne = we(ne.axis, ne.positions), ro = W.size ? e.hints.map(
+        (re) => (re.type === "stay" || re.type === "pin") && Ne.has(re.id) ? { ...re, x: re.x - Ne.get(re.id).x, y: re.y - Ne.get(re.id).y } : re
+      ) : e.hints, lo = wi(X, ne.positions, ro, S, l, ne.axis);
+      return "followed" in ne && ne.followed ? E.set(S, Ee) : E.delete(S), { base: ne, fold: fe, pos: lo, off: Ne };
+    }, ye = (B, J) => {
+      const V = J.pos.get(B.id), ie = J.off.get(B.id);
+      return { x: V.x + ie.x, y: V.y + ie.y, w: ie.w, h: ie.h };
+    }, xe = (B, J) => ({
+      ...J.pos.get(B.id),
+      w: B.w,
+      h: B.h
+    }), ve = W.size ? { w: $n(q.gap), h: $n(q.gap) } : { w: 0, h: 0 }, Ce = l.length;
+    let ge = Ie(ve);
+    !i && (ve.w || ve.h) && X.some(
+      (B, J) => X.slice(J + 1).some(
+        (V) => vn(xe(B, ge), xe(V, ge)) >= Ze - 0.5 && vn(ye(B, ge), ye(V, ge)) < Ze - 0.5
+      )
+    ) && (l.length = Ce, ge = Ie({ w: 0, h: 0 })), ge.fold && L.push({ scope: S, fold: ge.fold }), q.algorithm === "flow" && H.push({ scope: S, axis: ge.base.axis });
+    const De = X.map((B) => ye(B, ge)), kt = S === "root" ? 0 : Math.max(0, ...X.map((B) => B.soft?.length ?? 0)), Ke = S === "root" || !X.length ? { x: 0, y: 0 } : {
+      x: Math.max(0, -Math.min(...De.map((B) => B.x))) + kt * Ve,
+      y: Math.max(0, -Math.min(...De.map((B) => B.y))) + kt * (Ve + Mt)
+    };
+    for (const [B, J] of X.entries()) {
+      const V = De[B], ie = ge.off.get(J.id), ne = ge.base.positions.get(J.id);
+      u.set(J.id, { x: le(V.x + Ke.x), y: le(V.y + Ke.y) }), g.set(J.id, { x: ne.x + ie.x + Ke.x, y: ne.y + ie.y + Ke.y }), W.has(J.id) && f.set(J.id, { w: le(V.w), h: le(V.h) });
+    }
+    const Yt = (B, J) => X.length ? Math.max(
+      ...X.map(
+        (V, ie) => Math.max(ge.pos.get(V.id)[B] + V[J], De[ie][B] + De[ie][J])
+      )
+    ) + Ke[B] + kt * Ve : 0;
+    return { w: Yt("x", "w"), h: Yt("y", "h") };
+  }
+  function Y(S, q, G) {
+    if (G.unit) return $(S, q, G);
+    const U = Math.ceil(pe(x.get(S).label, c.groupTitle)) + Lo, W = (C) => e.hints.find((K) => K.type === "size" && K.id === C), X = Bo(
+      q.map((C) => {
+        const K = W(C.id);
+        return {
+          id: C.id,
+          label: C.label,
+          marker: C.shape === "marker",
+          ...typeof C.span == "number" ? { span: C.span } : {},
+          ...K?.type === "size" ? { size: { width: K.width, height: K.height } } : {}
+        };
+      }),
+      {
+        direction: G.direction === "down" ? "down" : "right",
+        ...G.columns ? { columns: G.columns } : {}
+      },
+      c,
+      U
+    );
+    return k(S, q, X.boxes), n.set(S, Pt(c.groupTitle.lineHeight)), { w: Math.max(X.w, U), h: X.h };
+  }
+  function $(S, q, G) {
+    const U = qo(
+      q.map((C) => ({
+        id: C.id,
+        label: C.label,
+        marker: !1,
+        ...typeof C.span == "number" ? { span: C.span } : {},
+        open: C.span === "var"
+      })),
+      {
+        unit: G.unit,
+        ruler: G.ruler !== !1,
+        ...G.columns ? { columns: G.columns } : {},
+        ...G.unitWidth ? { unitWidth: G.unitWidth } : {}
+      },
+      c
+    ), W = Pt(c.groupTitle.lineHeight), X = W + (U.ruler?.h ?? 0);
+    return k(S, q, U.boxes), n.set(S, X), a.set(S, {
+      ...U.ruler ? { ruler: { y: W, ...U.ruler } } : {},
+      ...U.pieces.size ? {
+        pieces: Object.fromEntries(
+          [...U.pieces].map(([C, K]) => [C, K.map((te) => ({ ...te, y: te.y + X }))])
+        )
+      } : {},
+      ...U.open.length ? { open: U.open } : {}
+    }), { w: U.w, h: U.h };
+  }
+  function k(S, q, G) {
+    for (const U of q) {
+      const W = G.get(U.id);
+      p.set(U.id, { ...U, w: le(W.w), h: le(W.h) }), u.set(U.id, { x: le(W.x), y: le(W.y) }), g.set(U.id, { x: W.x, y: W.y });
+      const X = e.hints.find(
+        (C) => ks.includes(C.type) && "id" in C && C.id === U.id
+      );
+      X && l.push({
+        level: "warning",
+        code: "cell-position",
+        message: `${U.id} is a cell of ${S}, so it stays in its place. Move ${S} instead, or reorder its cells with order.`,
+        line: X.line,
+        ids: [U.id]
+      });
+    }
+  }
+  const T = l.length, j = w("root") && Ks(e, "root");
+  let v = z("root");
+  if (!s && j && j.engine?.params.fold !== "never") {
+    let S = function(C) {
+      return G(C) > to * U(C);
+    };
+    const q = We(j) === "right", G = (C) => q ? C.w : C.h, U = (C) => q ? C.h : C.w, W = q ? bt.width : bt.height, X = (C) => G(C) > W && G(C) > Ln * U(C);
+    for (; X(v) && !P; ) {
+      const C = [...p.values()].filter(
+        (K) => K.type === "group" && !I.has(K.id) && w(K.id) && S(K)
+      ).sort((K, te) => G(te) - G(K))[0];
+      C ? I.add(C.id) : P = !0, l.length = T, L.length = H.length = 0, f.clear(), v = z("root");
+    }
+  }
+  if (!s && j && We(j) === "down" && j.engine?.params.fold !== "never") {
+    const S = (G) => G.h, q = (G) => G.w * G.h;
+    for (; ; ) {
+      const G = (h.get("root") ?? []).map((C) => p.get(C.id)).filter(Boolean).sort((C, K) => S(K) - S(C)), [U, W] = G;
+      if (!U || !W || U.type !== "group" || U.fold === "never" || I.has(U.id) || !w(U.id) || S(U) < Zs * S(W))
+        break;
+      const X = v;
+      if (I.add(U.id), l.length = T, L.length = H.length = 0, f.clear(), v = z("root"), !(q(v) < q(X))) {
+        I.delete(U.id), l.length = T, L.length = H.length = 0, f.clear(), z("root");
+        break;
+      }
+    }
+  }
+  const A = [], F = (S, q, G) => {
+    for (const U of h.get(S) ?? []) {
+      const W = f.get(U.id) ?? p.get(U.id), X = u.get(U.id), C = g.get(U.id), K = {
+        ...U,
+        x: q.x + X.x,
+        y: q.y + X.y,
+        w: W.w,
+        h: W.h,
+        localX: X.x,
+        localY: X.y,
+        baseX: le(C.x),
+        baseY: le(C.y),
+        depth: G,
+        ...m.has(U.id) ? { titleLines: m.get(U.id) } : {}
+      };
+      A.push(K), U.type === "group" && F(
+        U.id,
+        n.has(U.id) ? { x: K.x, y: K.y + n.get(U.id) } : Hn(K, pt(c, K.titleLines)),
+        G + 1
+      );
+    }
+  };
+  F("root", { x: 0, y: 0 }, 0);
+  const Z = ai(
+    L,
+    e.edges,
+    new Map(A.map((S) => [S.id, S])),
+    R,
+    Math.max(e.routing.portGap ?? 16, e.routing.edgeGap ?? 16)
+  );
+  for (const [S, q] of ss(
+    H.map((G) => ({ ...G, bands: L.find((U) => U.scope === G.scope)?.fold.bands })),
+    e.edges,
+    new Map(A.map((G) => [G.id, G])),
+    new Set(Z.keys()),
+    (G) => He(G, c)
+  ))
+    Z.set(S, q);
+  for (const S of e.layouts) {
+    const q = A.find((G) => G.id === S.scope);
+    !q || !S.minWidth && !S.minHeight || (S.minWidth && q.w > S.minWidth + 0.5 || S.minHeight && q.h > S.minHeight + 0.5) && l.push({
+      level: "info",
+      code: "group-grew",
+      message: `${q.id} needs at least ${q.w}×${q.h} for its contents.`,
+      line: S.line,
+      ids: [q.id]
+    });
+  }
+  l.push(...Xs(e), ...fs(e));
+  for (const S of e.warnings) l.push({ level: "warning", ...S, ids: [] });
+  const se = new Map(e.objects.map((S, q) => [S.id, q]));
+  A.sort((S, q) => se.get(S.id) - se.get(q.id));
+  const ae = {
+    model: e,
+    title: e.title,
+    objects: A,
+    byId: new Map(A.map((S) => [S.id, S])),
+    edges: e.edges.map((S) => Z.has(S.id) ? { ...S, lane: Z.get(S.id) } : S),
+    diagnostics: l,
+    look: c,
+    cells: a
+  };
+  return oo.set(ae, { groups: I, wrap: P }), ae;
+}
+const Le = Object.freeze({
+  sourceBytes: 256 * 1024,
+  objects: 500,
+  edges: 1200,
+  depth: 12,
+  labelChars: 16 * 1024,
+  totalLabelBytes: 1024 * 1024,
+  outputBytes: 1024 * 1024,
+  nativeSourceChars: 3e5
+}), zt = /* @__PURE__ */ new Set(["root", "__proto__", "constructor", "prototype"]);
+class so {
+  entries = [];
+  byForeign = /* @__PURE__ */ new Map();
+  taken = new Set(zt);
+  get(t, i, o = i) {
+    const s = JSON.stringify([t, i]), r = this.byForeign.get(s);
+    if (r) return r;
+    let l = [...o].map((c) => /[A-Za-z0-9_.-]/.test(c) ? c : "_u" + c.codePointAt(0).toString(16) + "_").join("");
+    /^[A-Za-z_]/.test(l) || (l = t + "_" + l), (!l || zt.has(l)) && (l = t + "_" + (l || "item"));
+    let h = l;
+    for (let c = 2; this.taken.has(h); c++) h = l + "__" + c;
+    return this.byForeign.set(s, h), this.taken.add(h), this.entries.push({ kind: t, foreign: i, native: h }), h;
+  }
+}
+const Be = (e) => JSON.stringify(e), io = (e) => ({
+  title: e,
+  objects: [],
+  edges: [],
+  layouts: [],
+  colors: []
+});
+function ao(e, t, i, o, s) {
+  const r = (a, p, u = "semantics") => o.push({ code: a, severity: "error", impact: u, message: p });
+  (i.objects.length > Le.objects || i.edges.length > Le.edges) && r(
+    "IMPORT_GRAPH_LIMIT",
+    "Native source allows at most 500 nodes plus groups, and 1,200 edges.",
+    "limit"
+  );
+  const l = new TextEncoder();
+  [i.title, ...i.objects.map((a) => a.label), ...i.edges.map((a) => a.label)].reduce((a, p) => a + l.encode(p).length, 0) > Le.totalLabelBytes && r(
+    "IMPORT_TOTAL_LABEL_LIMIT",
+    "Expanded native labels exceed a combined 1 MiB of UTF-8 text.",
+    "limit"
+  ), i.title.length > Le.labelChars && r("IMPORT_LABEL_LIMIT", "Diagram title exceeds 16,384 characters.", "limit");
+  const c = new Map(i.objects.map((a) => [a.id, a])), M = [...i.objects.map((a) => a.id), ...i.edges.map((a) => a.id)];
+  (new Set(M).size !== M.length || M.some((a) => zt.has(a) || !/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(a))) && r("IMPORT_ID_INVARIANT", "Generated IDs must be safe, globally unique native identifiers.");
+  const m = (a) => {
+    const p = [];
+    let u = c.get(a)?.parent;
+    for (; u; ) {
+      if (p.includes(u) || p.length >= Le.depth) {
+        r("IMPORT_HIERARCHY", "Containment cycle or excessive nesting.");
+        break;
+      }
+      if (p.push(u), c.get(u)?.kind !== "group") {
+        r("IMPORT_PARENT", "Missing or non-group parent: " + u);
+        break;
+      }
+      u = c.get(u)?.parent;
+    }
+    return p;
+  };
+  for (const a of i.objects)
+    m(a.id).length + 1 > Le.depth && r("IMPORT_DEPTH", "Native source permits 12 nesting levels.", "limit"), a.label.length > Le.labelChars && r("IMPORT_LABEL_LIMIT", "Label exceeds 16,384 characters.", "limit");
+  for (const a of i.edges)
+    (!c.has(a.from) || !c.has(a.to)) && r("IMPORT_ENDPOINT", "Missing endpoint for " + a.id), (m(a.from).includes(a.to) || m(a.to).includes(a.from)) && r(
+      "IMPORT_ANCESTOR_EDGE",
+      "Native source cannot connect a group to one of its descendants."
+    ), a.label.length > Le.labelChars && r("IMPORT_LABEL_LIMIT", "Edge label exceeds 16,384 characters.", "limit");
+  const d = i.edges.some((a) => !a.directed) ? ["IMP-02-native-undirected"] : [];
+  if (o.some((a) => a.severity === "error"))
+    return { status: "failed", format: e, family: t, diagnostics: o, ids: s.entries, requires: d };
+  const f = ["diagram " + Be(i.title) + " version=1"];
+  for (const a of i.colors)
+    f.push(
+      "theme-color " + a.name + " shade=500 fill=" + Be(a.fill) + " stroke=" + Be(a.stroke) + " ink=" + Be(a.ink)
+    );
+  for (const a of i.objects) {
+    let p = a.kind + " " + a.id + " " + Be(a.label);
+    a.parent && (p += " in=" + a.parent), a.shape && a.shape !== "box" && a.kind === "node" && (p += " shape=" + a.shape), a.color && (p += " color=" + a.color + " shade=" + (a.shade ?? 500)), f.push(p);
+  }
+  for (const a of i.edges) {
+    let p = "edge " + a.id + " " + a.from + " -> " + a.to + " " + Be(a.label);
+    a.directed || (p += " directed=false"), a.head && a.head !== "arrow" && (p += " head=" + a.head), a.tail && a.tail !== "none" && (p += " tail=" + a.tail), a.dashed && (p += " kind=async"), a.constraint === !1 && (p += " constraint=false"), a.fromSide && (p += " from=" + a.fromSide), a.toSide && (p += " to=" + a.toSide), f.push(p);
+  }
+  for (const a of i.layouts)
+    f.push(
+      "layout " + a.scope + " " + a.kind + (a.direction ? " direction=" + a.direction : "")
+    );
+  for (const a of i.phases ?? [])
+    f.push(["phase", a.id, Be(a.label), ...a.members].join(" "));
+  for (const a of i.notes ?? []) {
+    let p = "note " + Be(a.text);
+    a.near && (p += " near=" + a.near), a.side && (p += " side=" + a.side), f.push(p);
+  }
+  const n = f.join(`
+`) + `
+`;
+  return n.length > Le.nativeSourceChars && r(
+    "IMPORT_NATIVE_SOURCE_LIMIT",
+    "Generated source exceeds the native parser limit of 300,000 source characters.",
+    "limit"
+  ), l.encode(n).length > Le.outputBytes && r("IMPORT_OUTPUT_LIMIT", "Generated native source exceeds 1 MiB of UTF-8 text.", "limit"), o.some((a) => a.severity === "error") ? { status: "failed", format: e, family: t, diagnostics: o, ids: s.entries, requires: d } : {
+    status: o.some((a) => a.severity === "warning") ? "needs-review" : "ready",
+    format: e,
+    family: t,
+    diagnostics: o,
+    ids: s.entries,
+    requires: d,
+    nativeSource: n,
+    facts: i
+  };
+}
+function xi(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 bi(e, t, i, o, s) {
+  if (!i && !o && !s) return;
+  const r = { fill: i ?? "#ffffff", stroke: o ?? "#64748b", ink: s ?? "#172033" };
+  let l = e.colors.find((h) => h.fill === r.fill && h.stroke === r.stroke && h.ink === r.ink);
+  l || (l = { name: "import_" + (e.colors.length + 1), ...r }, e.colors.push(l)), t.color = l.name, t.shade = 500;
+}
+const vi = {
+  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 }
+}, Dn = {
+  LOOP_START: "loop",
+  ALT_START: "alt",
+  OPT_START: "opt",
+  PAR_START: "par",
+  PAR_OVER_START: "par",
+  CRITICAL_START: "critical",
+  BREAK_START: "break"
+}, Nn = {
+  ALT_ELSE: "else",
+  PAR_AND: "and",
+  CRITICAL_OPTION: "option"
+}, ki = ["LOOP_END", "ALT_END", "OPT_END", "PAR_END", "CRITICAL_END", "BREAK_END"];
+function Ei(e, t, i, o) {
+  const s = io(e.title ? t(e.title) : i), r = new so(), l = /* @__PURE__ */ new Set(), h = (g, x, E = "semantics") => {
+    l.has(g) || (l.add(g), o.push({ code: g, severity: "warning", impact: E, message: x }));
+  }, c = e.boxes.map((g, x) => {
+    const E = r.get("group", "box_" + (x + 1));
+    return s.objects.push({ id: E, kind: "group", label: t(g.name ?? "") }), g.fill && g.fill !== "transparent" && h("MERMAID_SEQUENCE_BOX_COLOR", "Box colors are omitted.", "appearance"), E;
+  }), M = /* @__PURE__ */ new Map();
+  for (const g of e.actors) {
+    const x = r.get("node", g.id);
+    M.set(g.id, x), s.objects.push({
+      id: x,
+      kind: "node",
+      // `participant p as "Name"` keeps its quotes in the DB.
+      label: t(g.name).replace(/^"(.*)"$/s, "$1"),
+      ...g.box != null && g.box >= 0 ? { parent: c[g.box] } : {}
+    }), g.type !== "participant" && h(
+      "MERMAID_SEQUENCE_ACTOR_TYPE",
+      "Participant symbols such as actor or database become ordinary boxes.",
+      "appearance"
+    ), g.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."
+  ), s.layouts.push({ scope: "root", kind: "sequence" });
+  const m = [], d = [];
+  let f = 0, n, a;
+  const p = (g, x) => {
+    const E = t(x).trim();
+    n = {
+      id: r.get("phase", String(m.length + 1), "phase_" + (m.length + 1)),
+      label: E ? `${g}: ${E}` : g,
+      members: []
+    }, m.push(n);
+  }, u = (g) => {
+    const x = [g.from, g.to].filter((L) => L != null), E = a && x.every((L) => a.ends.includes(L)), R = g.placement === "left" ? "left" : g.placement === "right" ? "right" : void 0;
+    d.push({
+      text: t(g.text),
+      near: E ? a.id : M.get(x[0]),
+      side: R ?? (E ? "right" : "below")
+    });
+  };
+  for (const [g, x] of e.events.entries())
+    if (Dn[x.kind])
+      f++, f === 1 ? p(Dn[x.kind], x.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 (Nn[x.kind])
+      f === 1 && p(Nn[x.kind], x.text);
+    else if (ki.includes(x.kind))
+      f--, f || (n = void 0);
+    else if (x.kind === "NOTE") u(x);
+    else if (x.kind === "ACTIVE_START" || x.kind === "ACTIVE_END")
+      h("MERMAID_SEQUENCE_ACTIVATION", "Activation bars are omitted.", "appearance");
+    else if (x.kind === "AUTONUMBER")
+      h("MERMAID_SEQUENCE_AUTONUMBER", "Message numbers are omitted.", "appearance");
+    else if (x.kind === "RECT_START" || x.kind === "RECT_END")
+      h("MERMAID_SEQUENCE_RECT", "Background rectangles are omitted.", "appearance");
+    else {
+      const E = vi[x.kind], R = M.get(x.from ?? ""), L = M.get(x.to ?? "");
+      if (!E || !R || !L || x.central) {
+        o.push({
+          code: "MERMAID_SEQUENCE_ARROW_UNSUPPORTED",
+          severity: "error",
+          impact: "semantics",
+          message: "Message line type is unsupported: " + (x.central ? "central connection" : x.kind) + ". The import is blocked rather than replacing it with an ordinary arrow."
+        });
+        continue;
+      }
+      x.kind === "SOLID_POINT" && h(
+        "MERMAID_SEQUENCE_ASYNC_ARROW",
+        "The open async arrow `-)` becomes an ordinary solid message, because native async draws dashed."
+      );
+      const H = r.get("edge-occurrence", String(g + 1), "m" + (s.edges.length + 1));
+      s.edges.push({ id: H, from: R, to: L, label: t(x.text), directed: !0, ...E }), n?.members.push(H), a = { id: H, ends: [x.from, x.to] };
+    }
+  return s.phases = m.filter((g) => g.members.length), s.notes = d, ao("mermaid", "sequence", s, o, r);
+}
+const Ai = {
+  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 _i(e, t, i = "Imported Mermaid") {
+  const o = io(i), s = new so(), r = e.diagnostics.map((u) => ({
+    code: u.code,
+    severity: u.severity,
+    impact: u.code.includes("LIMIT") || u.code.includes("TIMEOUT") ? "limit" : u.code.includes("CONFIGURATION") || u.code.includes("INTERACTION") ? "security" : "syntax",
+    message: u.message + (u.locationKind === "parser-relative" && u.line != null ? ` (Parser-relative line ${u.line}, column ${u.column ?? 1}; original-source mapping is unavailable.)` : ""),
+    ...u.locationKind === "source" && u.line != null ? { line: u.line, column: u.column } : {}
+  })), l = (u, g, x = "appearance", E = "warning", R) => r.push({ code: u, message: g, impact: x, severity: E, ...R ? { foreignIds: R } : {} }), h = () => ao("mermaid", "flowchart", o, r, s);
+  if (!e.ok) return h();
+  const c = e.snapshot;
+  if (c.parserVersion !== Wt)
+    return l(
+      "MERMAID_VERSION_MISMATCH",
+      "This adapter is verified only against Mermaid " + Wt + ".",
+      "syntax",
+      "error"
+    ), h();
+  if (c.family === "sequence")
+    return Ei(c, t, i, r);
+  const M = (u, g, x) => (/<\/?[a-z][\s\S]*?>/i.test(u) && l(
+    "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",
+    [x]
+  ), g === "markdown" && l(
+    "MERMAID_MARKDOWN_LABEL",
+    "Markdown label markers remain literal text in this profile.",
+    "appearance",
+    "warning",
+    [x]
+  ), t(u)), m = (u, g) => {
+    if (u) {
+      if (u === "LR") return "right";
+      if (u === "TB" || u === "TD") return "down";
+      if (u === "RL" || u === "BT")
+        return l(
+          "MERMAID_REVERSED_LAYOUT",
+          `${u} layout is normalized to ${u === "RL" ? "right" : "down"}; edge endpoints keep their semantic order.`,
+          "layout",
+          "warning",
+          [g]
+        ), u === "RL" ? "right" : "down";
+      l("MERMAID_DIRECTION", "Unsupported Mermaid layout direction: " + u, "layout", "error", [
+        g
+      ]);
+    }
+  }, d = new Map(c.classes.map((u) => [u.id, u])), f = (u, g, x, E) => {
+    const R = [];
+    for (const L of [...x ? ["default", "node"] : [], ...u]) {
+      const H = d.get(L);
+      H ? R.push(H) : ["default", "node", "clickable"].includes(L) || l(
+        "MERMAID_CLASS_UNRESOLVED",
+        "CSS class has no in-diagram definition and was not imported: " + L,
+        "appearance",
+        "warning",
+        [E]
+      );
+    }
+    return [...R.flatMap((L) => [...L.styles, ...L.textStyles]), ...g];
+  }, n = (u, g, x) => {
+    const E = /* @__PURE__ */ new Map();
+    for (const R of g.flatMap((L) => L.split(";"))) {
+      if (!R.trim()) continue;
+      const L = /^\s*([a-z-]+)\s*:\s*(.*?)\s*$/i.exec(R), H = L?.[1]?.toLowerCase(), I = L?.[2];
+      if (!H || !["fill", "stroke", "color"].includes(H)) {
+        l(
+          "MERMAID_STYLE_PROPERTY",
+          "Unsupported style declaration was omitted: " + R,
+          /url\s*\(|javascript:|expression\s*\(/i.test(R) ? "security" : "appearance",
+          "warning",
+          [x]
+        );
+        continue;
+      }
+      const P = xi(I);
+      if (!P) {
+        l(
+          "MERMAID_COLOR_VALUE",
+          "Only #RGB or #RRGGBB colors are imported: " + R,
+          "appearance",
+          "warning",
+          [x]
+        );
+        continue;
+      }
+      E.set(H, P);
+    }
+    bi(o, u, E.get("fill"), E.get("stroke"), E.get("color"));
+  }, a = {
+    square: "box",
+    rect: "box",
+    rectangle: "box",
+    box: "box",
+    stadium: "pill",
+    circle: "circle",
+    diamond: "diamond",
+    text: "text"
+  }, p = (u, g) => {
+    if (!u) return "box";
+    if (Object.hasOwn(a, u)) return a[u];
+    const x = u === "doublecircle" || u === "ellipse" ? "circle" : u === "round" ? "pill" : "box";
+    return l(
+      "MERMAID_SHAPE_APPROXIMATION",
+      `Mermaid shape ${u} becomes native ${x}; the shape-specific visual meaning is not fully preserved.`,
+      "semantics",
+      "warning",
+      [g]
+    ), x;
+  };
+  try {
+    const u = new Map(c.groups.map((I) => [I.id, I])), g = new Map(c.vertices.map((I) => [I.id, I]));
+    if (u.size !== c.groups.length || g.size !== c.vertices.length)
+      return l(
+        "MERMAID_DUPLICATE_DB_ID",
+        "The parser snapshot contains duplicate group or node identities.",
+        "semantics",
+        "error"
+      ), h();
+    const x = /* @__PURE__ */ new Map();
+    for (const I of c.groups)
+      x.set(I.id, {
+        id: s.get("group", I.id),
+        kind: "group",
+        label: M(I.title, I.labelType, I.id)
+      });
+    for (const I of c.vertices)
+      u.has(I.id) || x.set(I.id, {
+        id: s.get("node", I.id),
+        kind: "node",
+        label: M(I.text, I.labelType, I.id),
+        shape: p(I.type, I.id)
+      });
+    const E = /* @__PURE__ */ new Map();
+    for (const I of c.groups)
+      for (const P of I.nodes) {
+        if (!x.has(P)) {
+          l(
+            "MERMAID_UNKNOWN_MEMBER",
+            "Subgraph references an absent member: " + P,
+            "semantics",
+            "error",
+            [I.id, P]
+          );
+          continue;
+        }
+        const O = E.get(P);
+        if (O && O !== I.id) {
+          l(
+            "MERMAID_MULTIPLE_PARENTS",
+            "A member belongs to multiple native parents; containment was not guessed.",
+            "semantics",
+            "error",
+            [P, O, I.id]
+          );
+          continue;
+        }
+        E.set(P, I.id), x.get(P).parent = x.get(I.id).id;
+      }
+    const R = m(c.direction, "root");
+    R && o.layouts.push({ scope: "root", kind: "flow", direction: R });
+    const L = /* @__PURE__ */ new Map();
+    for (const I of c.groups) {
+      const P = m(I.dir, I.id);
+      P && L.set(I.id, P);
+    }
+    const H = (I) => {
+      const P = /* @__PURE__ */ new Set();
+      let O = I;
+      for (; O && !P.has(O); ) {
+        P.add(O);
+        const y = L.get(O);
+        if (y) return y;
+        O = E.get(O);
+      }
+      return R ?? "down";
+    };
+    for (const I of c.groups) {
+      const P = x.get(I.id), O = g.get(I.id);
+      n(
+        P,
+        f([...I.classes, ...O?.classes ?? []], O?.styles ?? [], !1, I.id),
+        I.id
+      ), o.layouts.push({
+        scope: P.id,
+        kind: "flow",
+        direction: H(I.id)
+      }), I.dir ? l(
+        "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",
+        [I.id]
+      ) : l(
+        "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",
+        [I.id]
+      ), I.metadata && Object.keys(I.metadata).length && l(
+        "MERMAID_GROUP_METADATA",
+        "Group metadata (including collapsed view and engine hints) is omitted: " + Object.keys(I.metadata).join(", "),
+        "layout",
+        "warning",
+        [I.id]
+      );
+    }
+    for (const I of c.vertices) {
+      const P = x.get(I.id);
+      u.has(I.id) || n(P, f(I.classes, I.styles, !0, I.id), I.id), I.link && l(
+        "MERMAID_LINK_OMITTED",
+        "External link was omitted; the native object has no active link.",
+        "security",
+        "warning",
+        [I.id]
+      ), (I.img || I.icon) && l(
+        "MERMAID_ASSET_OMITTED",
+        "Image/icon references are not fetched or embedded; the object remains a labeled native shape.",
+        "security",
+        "warning",
+        [I.id]
+      ), I.props && Object.keys(I.props).length && l(
+        "MERMAID_NODE_METADATA",
+        "Node properties are omitted: " + Object.keys(I.props).join(", "),
+        "semantics",
+        "warning",
+        [I.id]
+      );
+    }
+    o.objects.push(...x.values());
+    for (const [I, P] of c.edges.entries()) {
+      const O = Ai[String(P.type)];
+      if (!O) {
+        l(
+          "MERMAID_ARROW_UNSUPPORTED",
+          "Edge terminal semantics are unsupported: " + String(P.type) + ". The import is blocked rather than replacing them with ordinary arrows.",
+          "semantics",
+          "error",
+          [P.id ?? String(I + 1)]
+        );
+        continue;
+      }
+      if (P.stroke === "invisible") {
+        l(
+          "MERMAID_INVISIBLE_EDGE",
+          "Invisible links express layout constraints, not visible relationships; this profile cannot preserve them.",
+          "layout",
+          "error",
+          [P.id ?? String(I + 1)]
+        );
+        continue;
+      }
+      if (!["normal", "thick", "dotted"].includes(P.stroke ?? "normal")) {
+        l(
+          "MERMAID_EDGE_STROKE",
+          "Unsupported edge stroke: " + String(P.stroke),
+          "appearance",
+          "error",
+          [P.id ?? String(I + 1)]
+        );
+        continue;
+      }
+      const y = x.get(P.start), D = x.get(P.end);
+      if (!y || !D) {
+        l("MERMAID_ENDPOINT", "A parsed edge has a missing endpoint.", "semantics", "error", [
+          P.start,
+          P.end
+        ]);
+        continue;
+      }
+      const w = P.isUserDefinedId && P.id ? s.get("edge-id", P.id, P.id) : s.get("edge-occurrence", String(I + 1), "edge_" + (I + 1)), b = P.id ?? String(I + 1);
+      o.edges.push({
+        id: w,
+        from: y.id,
+        to: D.id,
+        label: M(P.text, P.labelType, b),
+        directed: P.type !== "arrow_open",
+        ...O,
+        ...P.stroke === "dotted" ? { dashed: !0 } : {}
+      }), P.stroke === "dotted" && l(
+        "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]
+      ), P.stroke === "thick" && l(
+        "MERMAID_THICK_EDGE",
+        "Thick edge emphasis is omitted by this native-source profile.",
+        "appearance",
+        "warning",
+        [b]
+      ), (P.length ?? 1) > 1 && l(
+        "MERMAID_MIN_RANK_LENGTH",
+        "Minimum rank-length hint is omitted; native layout chooses spacing.",
+        "layout",
+        "warning",
+        [b]
+      ), (P.animate || P.animation) && l("MERMAID_EDGE_ANIMATION", "Edge animation is omitted.", "appearance", "warning", [
+        b
+      ]), (P.interpolate || c.defaultEdgeInterpolate) && l(
+        "MERMAID_EDGE_CURVE",
+        "Mermaid curve hints are omitted; native routing is used.",
+        "layout",
+        "warning",
+        [b]
+      );
+      const _ = f(
+        P.classes,
+        [...c.defaultEdgeStyle, ...P.style],
+        !1,
+        b
+      );
+      _.length && l(
+        "MERMAID_EDGE_STYLE",
+        "Per-edge CSS is omitted because native edge appearance is not a general CSS style map: " + _.join("; "),
+        "appearance",
+        "warning",
+        [b]
+      );
+    }
+    return h();
+  } catch (u) {
+    return l(
+      "MERMAID_MAPPING_ERROR",
+      "Could not map the parser snapshot: " + (u instanceof Error ? u.message : String(u)),
+      "semantics",
+      "error"
+    ), h();
+  }
+}
+function Ii(e, t, i) {
+  const o = _i(e, t, i);
+  if (!o.nativeSource) return o;
+  try {
+    return Ds(o.nativeSource), o;
+  } catch (s) {
+    return {
+      ...o,
+      status: "failed",
+      nativeSource: void 0,
+      facts: void 0,
+      diagnostics: [
+        ...o.diagnostics,
+        {
+          code: "IMPORT_NATIVE_INVALID",
+          severity: "error",
+          impact: "semantics",
+          message: "The converted diagram cannot be represented in native source: " + (s instanceof Error ? s.message : String(s))
+        }
+      ]
+    };
+  }
+}
+export {
+  Ii as importMermaidFlow
+};