@draftably/markdown 0.2.3 → 0.2.4

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

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