@draftably/mermaid 0.1.0 → 0.2.1

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

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