@belonguniverseai/react-sdk 0.6.2 → 0.6.3

package/dist/component/cynefinDiagram-MW4NZA55-CutZScTQ.js

@@ -0,0 +1,302 @@
+import { p as gt } from "./chunk-JWPE2WC7-BbwyDj9g.js";
+import { s as xt, g as bt, p as $t, o as wt, a as Ct, b as vt, _ as s, l as O, G as Dt, e as Tt, q as kt, D as U, z as Z, E as At, Z as ot } from "./mermaid-GHXKKRXX-BaBCeViM.js";
+import { p as Bt } from "./cynefin-VYW2F7L2-DAyxamLw.js";
+globalThis.process = globalThis.process || { env: {} };
+globalThis.global = globalThis.global || globalThis;
+var rt = /* @__PURE__ */ s(() => ({
+  domains: /* @__PURE__ */ new Map(),
+  transitions: []
+}), "createDefaultData"), G = rt(), St = /* @__PURE__ */ s(() => G.domains, "getDomains"), Mt = /* @__PURE__ */ s(() => G.transitions, "getTransitions"), zt = /* @__PURE__ */ s((t) => {
+  if (t)
+    for (const e of t) {
+      const n = e.domain, a = (e.items ?? []).map((c) => ({
+        label: c.label
+      }));
+      G.domains.set(n, {
+        name: n,
+        items: a
+      });
+    }
+}, "setDomains"), Lt = /* @__PURE__ */ s((t) => {
+  t && (G.transitions = t.filter((e) => e.from === e.to ? (O.warn(
+    `Cynefin: self-loop transition on domain "${e.from}" is not meaningful and will be skipped.`
+  ), !1) : !0).map((e) => ({
+    from: e.from,
+    to: e.to,
+    label: e.label || void 0
+  })));
+}, "setTransitions"), Nt = /* @__PURE__ */ s(() => U({
+  ...At.cynefin,
+  ...Z().cynefin
+}), "getConfig"), Pt = /* @__PURE__ */ s(() => {
+  kt(), G = rt();
+}, "clear"), Y = {
+  getDomains: St,
+  getTransitions: Mt,
+  setDomains: zt,
+  setTransitions: Lt,
+  getConfig: Nt,
+  clear: Pt,
+  setAccTitle: vt,
+  getAccTitle: Ct,
+  setDiagramTitle: wt,
+  getDiagramTitle: $t,
+  getAccDescription: bt,
+  setAccDescription: xt
+}, It = /* @__PURE__ */ s((t) => {
+  gt(t, Y), Y.setDomains(t.domains), Y.setTransitions(t.transitions);
+}, "populate"), Wt = {
+  parse: /* @__PURE__ */ s(async (t) => {
+    const e = await Bt("cynefin", t);
+    O.debug(e), It(e);
+  }, "parse")
+};
+function V(t) {
+  let e = t + 1831565813 | 0;
+  return e = Math.imul(e ^ e >>> 15, e | 1), e ^= e + Math.imul(e ^ e >>> 7, e | 61), ((e ^ e >>> 14) >>> 0) / 4294967296;
+}
+s(V, "seededRandom");
+function st(t) {
+  let e = 0;
+  for (let n = 0; n < t.length; n++) {
+    const a = t.charCodeAt(n);
+    e = (e << 5) - e + a, e |= 0;
+  }
+  return e;
+}
+s(st, "hashString");
+function it(t, e) {
+  return typeof t == "number" && Number.isFinite(t) && t !== 0 ? t : st(e);
+}
+s(it, "resolveSeed");
+function ct(t, e, n, a) {
+  const c = t / 2, m = a ?? t * 0.015, v = 7, W = e / v, d = [];
+  for (let o = 0; o <= v; o++) {
+    const p = V(n + o * 17) * m * 2 - m;
+    d.push({ x: c + p, y: o * W });
+  }
+  let D = `M${d[0].x},${d[0].y}`;
+  for (let o = 0; o < d.length - 1; o++) {
+    const p = d[o], i = d[o + 1], f = (p.y + i.y) / 2, $ = o % 2 === 0 ? 1 : -1, h = m * 1.5 * $ * V(n + o * 31 + 7), R = p.x + h, _ = f, E = i.x - h;
+    D += ` C${R},${_} ${E},${f} ${i.x},${i.y}`;
+  }
+  return D;
+}
+s(ct, "generateFoldPath");
+function lt(t, e, n, a) {
+  const c = e / 2, m = a ?? e * 0.015, v = 7, W = t / v, d = [];
+  for (let o = 0; o <= v; o++) {
+    const p = V(n + o * 23) * m * 2 - m;
+    d.push({ x: o * W, y: c + p });
+  }
+  let D = `M${d[0].x},${d[0].y}`;
+  for (let o = 0; o < d.length - 1; o++) {
+    const p = d[o], i = d[o + 1], f = (p.x + i.x) / 2, $ = o % 2 === 0 ? 1 : -1, h = m * 1.5 * $ * V(n + o * 37 + 11), R = f, _ = p.y + h, E = f, z = i.y - h;
+    D += ` C${R},${_} ${E},${z} ${i.x},${i.y}`;
+  }
+  return D;
+}
+s(lt, "generateHorizontalBoundary");
+function dt(t, e) {
+  const n = t / 2, a = e * 0.5, c = e, m = t * 0.03;
+  return [
+    `M${n},${a}`,
+    `C${n + m},${a + (c - a) * 0.2}`,
+    `${n - m * 1.5},${a + (c - a) * 0.55}`,
+    `${n + m * 0.5},${a + (c - a) * 0.75}`,
+    `C${n - m},${a + (c - a) * 0.85}`,
+    `${n + m * 0.3},${a + (c - a) * 0.95}`,
+    `${n},${c}`
+  ].join(" ");
+}
+s(dt, "generateCliffPath");
+function ft(t, e, n, a) {
+  return [
+    `M${t - n},${e}`,
+    `A${n},${a} 0 1,1 ${t + n},${e}`,
+    `A${n},${a} 0 1,1 ${t - n},${e}`,
+    "Z"
+  ].join(" ");
+}
+s(ft, "generateConfusionPath");
+var at = {
+  complex: { model: "Probe → Sense → Respond", practice: "Emergent Practices" },
+  complicated: { model: "Sense → Analyse → Respond", practice: "Good Practices" },
+  clear: { model: "Sense → Categorise → Respond", practice: "Best Practices" },
+  chaotic: { model: "Act → Sense → Respond", practice: "Novel Practices" },
+  confusion: { model: "", practice: "Disorder" }
+}, Rt = /* @__PURE__ */ s((t, e) => {
+  const n = t / 2, a = e / 2;
+  return {
+    complex: { cx: n / 2, cy: a / 2, x: 0, y: 0, w: n, h: a },
+    complicated: { cx: n + n / 2, cy: a / 2, x: n, y: 0, w: n, h: a },
+    chaotic: { cx: n / 2, cy: a + a / 2, x: 0, y: a, w: n, h: a },
+    clear: { cx: n + n / 2, cy: a + a / 2, x: n, y: a, w: n, h: a },
+    confusion: { cx: n, cy: a, x: n * 0.7, y: a * 0.7, w: n * 0.6, h: a * 0.6 }
+  };
+}, "getDomainLayouts"), _t = /* @__PURE__ */ s(() => {
+  const t = ot(), e = Z();
+  return U(t, e.themeVariables).cynefin;
+}, "getCynefinDomainColors"), q = 3, Et = /* @__PURE__ */ s((t, e, n, a) => {
+  const c = a.db, m = c.getDomains(), v = c.getTransitions(), W = c.getDiagramTitle(), d = c.getAccTitle(), D = c.getAccDescription(), o = c.getConfig(), p = _t();
+  O.debug("Rendering Cynefin diagram");
+  const i = o.width, f = o.height, $ = o.padding, h = o.showDomainDescriptions, R = o.boundaryAmplitude, _ = i + $ * 2, E = f + $ * 2, z = {
+    complex: p.complexBg,
+    complicated: p.complicatedBg,
+    clear: p.clearBg,
+    chaotic: p.chaoticBg,
+    confusion: p.confusionBg
+  }, T = Dt(e);
+  Tt(T, E, _, o.useMaxWidth ?? !0), T.attr("viewBox", `0 0 ${_} ${E}`), d && T.append("title").text(d), D && T.append("desc").text(D);
+  const k = T.append("g").attr("transform", `translate(${$}, ${$})`), F = Rt(i, f), Q = it(o.seed, e), mt = k.append("g").attr("class", "cynefin-backgrounds"), X = ["complex", "complicated", "chaotic", "clear"];
+  for (const l of X) {
+    const r = F[l];
+    mt.append("rect").attr("class", "cynefinDomain").attr("x", r.x).attr("y", r.y).attr("width", r.w).attr("height", r.h).attr("fill", z[l]).attr("fill-opacity", 0.4).attr("stroke", "none");
+  }
+  const j = k.append("g").attr("class", "cynefin-boundaries");
+  j.append("path").attr("class", "cynefinBoundary").attr("d", ct(i, f, Q, R)).attr("fill", "none"), j.append("path").attr("class", "cynefinBoundary").attr("d", lt(i, f, Q + 100, R)).attr("fill", "none"), j.append("path").attr("class", "cynefinCliff").attr("d", dt(i, f)).attr("fill", "none");
+  const pt = i * 0.15, yt = f * 0.15;
+  k.append("path").attr("class", "cynefinConfusion").attr("d", ft(i / 2, f / 2, pt, yt)).attr("fill", z.confusion).attr("fill-opacity", 0.5);
+  const J = k.append("g").attr("class", "cynefin-labels");
+  for (const l of X) {
+    const r = F[l];
+    J.append("text").attr("class", "cynefinDomainLabel").attr("x", r.cx).attr("y", h ? r.cy - 30 : r.cy).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(l.charAt(0).toUpperCase() + l.slice(1));
+  }
+  if (J.append("text").attr("class", "cynefinDomainLabel").attr("x", i / 2).attr("y", h ? f / 2 - 10 : f / 2).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text("Confusion"), h) {
+    const l = k.append("g").attr("class", "cynefin-subtitles");
+    for (const r of X) {
+      const u = F[r], y = at[r];
+      l.append("text").attr("class", "cynefinSubtitle").attr("x", u.cx).attr("y", u.cy - 10).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(y.model), l.append("text").attr("class", "cynefinSubtitle").attr("x", u.cx).attr("y", u.cy + 5).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(y.practice);
+    }
+    l.append("text").attr("class", "cynefinSubtitle").attr("x", i / 2).attr("y", f / 2 + 8).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(at.confusion.practice);
+  }
+  const K = k.append("g").attr("class", "cynefin-items"), A = 26, tt = 10, ut = ["complex", "complicated", "chaotic", "clear", "confusion"];
+  for (const l of ut) {
+    const r = m.get(l);
+    if (!r || r.items.length === 0)
+      continue;
+    const u = F[l], y = l === "confusion";
+    let L = r.items, N = 0;
+    y && r.items.length > q && (N = r.items.length - q, L = r.items.slice(0, q));
+    let B;
+    if (y) {
+      const x = h ? 22 : 14;
+      B = u.cy + x;
+    } else
+      B = u.cy + (h ? 25 : 15);
+    if ([...L].forEach((x, S) => {
+      const w = B + S * (A + 4), M = K.append("g"), P = M.append("text").attr("class", "cynefinItemText").attr("x", 0).attr("y", A / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").text(x.label);
+      let b = x.label.length * 7;
+      const g = P.node();
+      if (g && typeof g.getBBox == "function") {
+        const H = g.getBBox();
+        H.width > 0 && (b = H.width);
+      }
+      const C = b + tt * 2, I = u.cx - C / 2;
+      M.attr("transform", `translate(${I}, ${w})`), M.insert("rect", "text").attr("class", "cynefinItem").attr("x", 0).attr("y", 0).attr("width", C).attr("height", A).attr("rx", 4).attr("ry", 4).attr("fill", z[l]).attr("fill-opacity", 0.95), P.attr("x", C / 2).attr("y", A / 2);
+    }), N > 0) {
+      const x = B + L.length * (A + 4), S = `+${N} more`, w = K.append("g"), M = w.append("text").attr("class", "cynefinItemText").attr("x", 0).attr("y", A / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").text(S);
+      let P = S.length * 7;
+      const b = M.node();
+      if (b && typeof b.getBBox == "function") {
+        const I = b.getBBox();
+        I.width > 0 && (P = I.width);
+      }
+      const g = P + tt * 2, C = u.cx - g / 2;
+      w.attr("transform", `translate(${C}, ${x})`), w.insert("rect", "text").attr("class", "cynefinItemOverflow").attr("x", 0).attr("y", 0).attr("width", g).attr("height", A).attr("rx", 4).attr("ry", 4).attr("fill", z[l]).attr("fill-opacity", 0.6), M.attr("x", g / 2).attr("y", A / 2);
+    }
+  }
+  if (v.length > 0) {
+    const l = T.select("defs").empty() ? T.append("defs") : T.select("defs"), r = `cynefin-arrow-${e}`;
+    l.append("marker").attr("id", r).attr("viewBox", "0 0 10 10").attr("refX", 9).attr("refY", 5).attr("markerWidth", 6).attr("markerHeight", 6).attr("orient", "auto-start-reverse").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("class", "cynefinArrowHead");
+    const u = k.append("g").attr("class", "cynefin-arrows");
+    v.forEach((y) => {
+      const L = F[y.from], N = F[y.to];
+      if (!L || !N)
+        return;
+      if (y.from === y.to) {
+        O.warn(`Cynefin renderer: skipping self-loop on domain "${y.from}"`);
+        return;
+      }
+      const B = L.cx, x = L.cy, S = N.cx, w = N.cy, M = (B + S) / 2, P = (x + w) / 2, b = S - B, g = w - x, C = Math.sqrt(b * b + g * g), I = C * 0.15, H = -g / C, ht = b / C, et = M + H * I, nt = P + ht * I;
+      u.append("path").attr("class", "cynefinArrowLine").attr("d", `M${B},${x} Q${et},${nt} ${S},${w}`).attr("fill", "none").attr("marker-end", `url(#${r})`), y.label && u.append("text").attr("class", "cynefinArrowLabel").attr("x", et).attr("y", nt - 6).attr("text-anchor", "middle").attr("dominant-baseline", "auto").text(y.label);
+    });
+  }
+  W && k.append("text").attr("class", "cynefinTitle").attr("x", i / 2).attr("y", -$ / 2).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(W);
+}, "draw"), Ft = { draw: Et }, Vt = /* @__PURE__ */ s(() => {
+  const t = ot(), e = Z();
+  return U(t, e.themeVariables).cynefin;
+}, "getCynefinTheme"), Gt = /* @__PURE__ */ s(() => {
+  const t = Vt();
+  return `
+	.cynefinDomain {
+		stroke: none;
+	}
+	.cynefinDomainLabel {
+		font-size: ${t.domainFontSize}px;
+		font-weight: bold;
+		fill: ${t.labelColor};
+	}
+	.cynefinSubtitle {
+		font-size: ${t.itemFontSize - 1}px;
+		fill: ${t.textColor};
+		font-style: italic;
+	}
+	.cynefinItem {
+		fill-opacity: 0.95;
+		stroke: ${t.boundaryColor};
+		stroke-width: 1;
+	}
+	.cynefinItemText {
+		font-size: ${t.itemFontSize}px;
+		fill: ${t.textColor};
+	}
+	.cynefinItemOverflow {
+		fill-opacity: 0.6;
+		stroke: ${t.boundaryColor};
+		stroke-width: 1;
+		stroke-dasharray: 3 2;
+	}
+	.cynefinBoundary {
+		stroke: ${t.boundaryColor};
+		stroke-width: ${t.boundaryWidth};
+		stroke-dasharray: 6 3;
+	}
+	.cynefinCliff {
+		stroke: ${t.cliffColor};
+		stroke-width: ${t.cliffWidth};
+	}
+	.cynefinConfusion {
+		stroke: ${t.boundaryColor};
+		stroke-width: 1.5;
+		stroke-dasharray: 4 2;
+	}
+	.cynefinArrowLine {
+		stroke: ${t.arrowColor};
+		stroke-width: ${t.arrowWidth};
+		fill: none;
+	}
+	.cynefinArrowHead {
+		fill: ${t.arrowColor};
+		stroke: none;
+	}
+	.cynefinArrowLabel {
+		font-size: ${t.itemFontSize - 1}px;
+		fill: ${t.textColor};
+	}
+	.cynefinTitle {
+		font-size: ${t.domainFontSize + 2}px;
+		font-weight: bold;
+		fill: ${t.labelColor};
+	}
+	`;
+}, "styles"), Ht = Gt, jt = {
+  parser: Wt,
+  db: Y,
+  renderer: Ft,
+  styles: Ht
+};
+export {
+  jt as diagram
+};
+//# sourceMappingURL=cynefinDiagram-MW4NZA55-CutZScTQ.js.map

package/dist/component/dagre-VZM6K2ZE-CelPLP8N.js

@@ -0,0 +1,343 @@
+import { c as O, w as I, a as J, f as P, b as E, s as v } from "./chunk-RYQCIY6F-5eaMbXXL.js";
+import { _ as w, ap as A, aq as D, ar as H, as as Y, l as c, c as _, at as j, au as W, aj as $, av as q, ak as R, ai as F, aw as z, ax as K, ay as T } from "./mermaid-GHXKKRXX-BaBCeViM.js";
+import { G as Q } from "./graph-CWpEkm4G.js";
+import { l as U } from "./layout-Br2UjHRU.js";
+globalThis.process = globalThis.process || { env: {} };
+globalThis.global = globalThis.global || globalThis;
+var G = /* @__PURE__ */ w((n, t, g) => Math.max(t, Math.min(g, n)), "clamp"), C = /* @__PURE__ */ w((n = "TB") => {
+  switch (n) {
+    case "BT":
+      return "bottom";
+    case "LR":
+      return "right";
+    case "RL":
+      return "left";
+    default:
+      return "top";
+  }
+}, "getDefaultSelfLoopSide"), V = /* @__PURE__ */ w((n) => n === "flowchart" || n === "flowchart-v2" || n === "stateDiagram", "shouldMergeSelfLoopSegments"), Z = /* @__PURE__ */ w((n, t, g, y, l) => {
+  const o = [], r = /* @__PURE__ */ new Set();
+  if (g.forEach(({ start: i, end: s }) => {
+    i !== y && r.add(i), s !== y && r.add(s);
+  }), r.forEach((i) => {
+    const s = n.node(i);
+    typeof s?.x == "number" && typeof s?.y == "number" && o.push(s);
+  }), o.length === 0 && g.forEach(({ edge: i }) => {
+    (i.points ?? []).forEach((s) => {
+      typeof s?.x == "number" && typeof s?.y == "number" && o.push(s);
+    });
+  }), o.length === 0)
+    return C(l);
+  const f = o.reduce(
+    (i, s) => ({
+      x: i.x + s.x / o.length,
+      y: i.y + s.y / o.length
+    }),
+    { x: 0, y: 0 }
+  ), h = f.x - t.x, d = f.y - t.y;
+  return Math.abs(h) > Math.abs(d) ? h > 0 ? "right" : "left" : Math.abs(d) > 0 ? d > 0 ? "bottom" : "top" : C(l);
+}, "getSelfLoopSide"), ee = /* @__PURE__ */ w((n, t = "top", g = 0, y = 0) => {
+  const l = n.x, o = n.y - g, r = n.width / 2, f = n.height / 2, h = Math.max(36, Math.min(100, n.width * 0.8)), d = G(Math.max(y, n.width * 0.35), 36, h), i = G(Math.min(n.width, n.height) * 0.45, 24, 48);
+  switch (t) {
+    case "bottom": {
+      const s = o + f;
+      return [
+        { x: l - d / 2, y: s },
+        { x: l - d / 2, y: s + i },
+        { x: l + d / 2, y: s + i },
+        { x: l + d / 2, y: s }
+      ];
+    }
+    case "right": {
+      const s = l + r;
+      return [
+        { x: s, y: o - d / 2 },
+        { x: s + i, y: o - d / 2 },
+        { x: s + i, y: o + d / 2 },
+        { x: s, y: o + d / 2 }
+      ];
+    }
+    case "left": {
+      const s = l - r;
+      return [
+        { x: s, y: o - d / 2 },
+        { x: s - i, y: o - d / 2 },
+        { x: s - i, y: o + d / 2 },
+        { x: s, y: o + d / 2 }
+      ];
+    }
+    default: {
+      const s = o - f;
+      return [
+        { x: l - d / 2, y: s },
+        { x: l - d / 2, y: s - i },
+        { x: l + d / 2, y: s - i },
+        { x: l + d / 2, y: s }
+      ];
+    }
+  }
+}, "getSelfLoopPoints"), te = /* @__PURE__ */ w((n, t, g = "top", y = 0, l = {}) => {
+  const r = n.x, f = n.y - y, h = l.width ?? 0, d = l.height ?? 0;
+  switch (g) {
+    case "bottom":
+      return { x: r, y: Math.max(...t.map((i) => i.y)) + d / 2 + 4 };
+    case "right":
+      return { x: Math.max(...t.map((i) => i.x)) + h / 2 + 4, y: f };
+    case "left":
+      return { x: Math.min(...t.map((i) => i.x)) - h / 2 - 4, y: f };
+    default:
+      return { x: r, y: Math.min(...t.map((i) => i.y)) - d / 2 - 4 };
+  }
+}, "getSelfLoopLabelPosition"), se = /* @__PURE__ */ w((n, t = 0, { mergeSelfLoops: g = !0 } = {}) => {
+  const y = /* @__PURE__ */ new Map(), l = [], o = n.graph()?.rankdir;
+  return n.edges().forEach((r) => {
+    const f = n.edge(r);
+    if (g && f.selfLoop) {
+      const h = f.selfLoop.id;
+      y.has(h) || y.set(h, []), y.get(h).push({ edge: f, start: r.v, end: r.w });
+    } else
+      l.push({ edge: f, start: r.v, end: r.w });
+  }), y.forEach((r) => {
+    if (r.length !== 3) {
+      r.forEach((L) => l.push(L));
+      return;
+    }
+    r.sort((L, a) => L.edge.selfLoop.order - a.edge.selfLoop.order);
+    const [f, h, d] = r, i = f.edge.originalEdge ?? h.edge.originalEdge ?? d.edge.originalEdge ?? h.edge, s = n.node(i.start);
+    if (!s) {
+      r.forEach((L) => l.push(L));
+      return;
+    }
+    const p = {
+      width: h.edge.width,
+      height: h.edge.height
+    }, m = Z(n, s, r, i.start, o), X = ee(s, m, t, p.width ?? 0), S = te(s, X, m, t, p), b = {
+      ...h.edge,
+      ...i,
+      id: i.id,
+      points: X,
+      start: i.start,
+      end: i.end,
+      x: S.x,
+      y: S.y,
+      width: p.width,
+      height: p.height,
+      labelStyle: h.edge.labelStyle,
+      fromCluster: f.edge.fromCluster ?? h.edge.fromCluster ?? d.edge.fromCluster,
+      toCluster: f.edge.toCluster ?? h.edge.toCluster ?? d.edge.toCluster
+    };
+    delete b.selfLoop, delete b.originalEdge, l.push({ edge: b, start: b.start, end: b.end });
+  }), l;
+}, "getEdgesToRender"), k = /* @__PURE__ */ w(async (n, t, g, y, l, o) => {
+  c.warn("Graph in recursive render:XAX", I(t), l);
+  const r = t.graph().rankdir;
+  c.trace("Dir in recursive render - dir:", r);
+  const f = n.insert("g").attr("class", "root");
+  t.nodes() ? c.info("Recursive render XXX", t.nodes()) : c.info("No nodes found for", t), t.edges().length > 0 && c.info("Recursive edges", t.edge(t.edges()[0]));
+  const h = f.insert("g").attr("class", "clusters"), d = f.insert("g").attr("class", "edgePaths"), i = f.insert("g").attr("class", "edgeLabels"), s = f.insert("g").attr("class", "nodes"), p = V(g);
+  await Promise.all(
+    t.nodes().map(async function(a) {
+      const e = t.node(a);
+      if (l !== void 0) {
+        const u = JSON.parse(JSON.stringify(l.clusterData));
+        c.trace(
+          `Setting data for parent cluster XXX
+ Node.id = `,
+          a,
+          `
+ data=`,
+          u.height,
+          `
+Parent cluster`,
+          l.height
+        ), t.setNode(l.id, u), t.parent(a) || (c.trace("Setting parent", a, l.id), t.setParent(a, l.id, u));
+      }
+      if (c.info("(Insert) Node XXX" + a + ": " + JSON.stringify(t.node(a))), e?.clusterNode) {
+        c.info("Cluster identified XBX", a, e.width, t.node(a));
+        const { ranksep: u, nodesep: x } = t.graph();
+        e.graph.setGraph({
+          ...e.graph.graph(),
+          ranksep: u + 25,
+          nodesep: x
+        });
+        const N = await k(
+          s,
+          e.graph,
+          g,
+          y,
+          t.node(a),
+          o
+        ), M = N.elem;
+        j(e, M), e.diff = N.diff || 0, c.info(
+          "New compound node after recursive render XAX",
+          a,
+          "width",
+          // node,
+          e.width,
+          "height",
+          e.height
+          // node.x,
+          // node.y
+        ), W(M, e);
+      } else
+        t.children(a).length > 0 ? (c.trace(
+          "Cluster - the non recursive path XBX",
+          a,
+          e.id,
+          e,
+          e.width,
+          "Graph:",
+          t
+        ), c.trace(P(e.id, t)), E.set(e.id, { id: P(e.id, t), node: e })) : (c.trace("Node - the non recursive path XAX", a, s, t.node(a), r), await $(s, t.node(a), { config: o, dir: r }));
+    })
+  ), await (/* @__PURE__ */ w(async () => {
+    const a = t.edges().map(async function(e) {
+      const u = t.edge(e.v, e.w, e.name);
+      if (c.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e)), c.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(t.edge(e))), c.info(
+        "Fix",
+        E,
+        "ids:",
+        e.v,
+        e.w,
+        "Translating: ",
+        E.get(e.v),
+        E.get(e.w)
+      ), p && u.selfLoop) {
+        if (u.selfLoop.order !== 1)
+          return;
+        const x = u.id;
+        u.id = u.selfLoop.id, await T(i, u), u.id = x;
+        return;
+      }
+      await T(i, u);
+    });
+    await Promise.all(a);
+  }, "processEdges"))(), c.info("Graph before layout:", JSON.stringify(I(t))), c.info("############################################# XXX"), c.info("###                Layout                 ### XXX"), c.info("############################################# XXX"), U(t), c.info("Graph after layout:", JSON.stringify(I(t)));
+  let X = 0, { subGraphTitleTotalMargin: S } = q(o);
+  await Promise.all(
+    v(t).map(async function(a) {
+      const e = t.node(a);
+      if (c.info(
+        "Position XBX => " + a + ": (" + e.x,
+        "," + e.y,
+        ") width: ",
+        e.width,
+        " height: ",
+        e.height
+      ), e?.clusterNode)
+        e.y += S, c.info(
+          "A tainted cluster node XBX1",
+          a,
+          e.id,
+          e.width,
+          e.height,
+          e.x,
+          e.y,
+          t.parent(a)
+        ), E.get(e.id).node = e, R(e);
+      else if (t.children(a).length > 0) {
+        c.info(
+          "A pure cluster node XBX1",
+          a,
+          e.id,
+          e.x,
+          e.y,
+          e.width,
+          e.height,
+          t.parent(a)
+        ), e.height += S, t.node(e.parentId);
+        const u = e?.padding / 2 || 0, x = e?.labelBBox?.height || 0, N = x - u || 0;
+        c.debug("OffsetY", N, "labelHeight", x, "halfPadding", u), await F(h, e), E.get(e.id).node = e;
+      } else {
+        const u = t.node(e.parentId);
+        e.y += S / 2, c.info(
+          "A regular node XBX1 - using the padding",
+          e.id,
+          "parent",
+          e.parentId,
+          e.width,
+          e.height,
+          e.x,
+          e.y,
+          "offsetY",
+          e.offsetY,
+          "parent",
+          u,
+          u?.offsetY,
+          e
+        ), R(e);
+      }
+    })
+  );
+  const b = S / 2;
+  return se(t, b, { mergeSelfLoops: p }).forEach(function({ edge: a, start: e, end: u }) {
+    c.info("Edge " + e + " -> " + u + ": " + JSON.stringify(a), a), a.points.forEach((B) => B.y += b);
+    const x = t.node(e), N = t.node(u), M = z(d, a, E, g, x, N, y);
+    K(a, M);
+  }), t.nodes().forEach(function(a) {
+    const e = t.node(a);
+    c.info(a, e.type, e.diff), e.isGroup && (X = e.diff);
+  }), c.warn("Returning from recursive render XAX", f, X), { elem: f, diff: X };
+}, "recursiveRender"), ae = /* @__PURE__ */ w(async (n, t) => {
+  const g = new Q({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: n.direction,
+    nodesep: n.config?.nodeSpacing || n.config?.flowchart?.nodeSpacing || n.nodeSpacing,
+    ranksep: n.config?.rankSpacing || n.config?.flowchart?.rankSpacing || n.rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  }), y = t.select("g");
+  A(y, n.markers, n.type, n.diagramId), D(), H(), Y(), O(), n.nodes.forEach((o) => {
+    g.setNode(o.id, { ...o }), o.parentId && g.setParent(o.id, o.parentId);
+  }), c.debug("Edges:", n.edges), n.edges.forEach((o) => {
+    if (o.start === o.end) {
+      const r = o.start, f = r + "---" + r + "---1", h = r + "---" + r + "---2", d = g.node(r);
+      g.setNode(f, {
+        domId: f,
+        id: f,
+        parentId: d.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      }), g.setParent(f, d.parentId), g.setNode(h, {
+        domId: h,
+        id: h,
+        parentId: d.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      }), g.setParent(h, d.parentId);
+      const i = structuredClone(o), s = structuredClone(o), p = structuredClone(o), m = structuredClone(o);
+      s.originalEdge = i, s.selfLoop = { id: i.id, order: 0 }, p.originalEdge = i, p.selfLoop = { id: i.id, order: 1 }, m.originalEdge = i, m.selfLoop = { id: i.id, order: 2 }, s.label = "", s.arrowTypeEnd = "none", s.endLabelLeft = "", s.endLabelRight = "", s.startLabelLeft = "", s.id = r + "-cyclic-special-1", p.startLabelRight = "", p.startLabelLeft = "", p.endLabelLeft = "", p.endLabelRight = "", p.arrowTypeStart = "none", p.arrowTypeEnd = "none", p.id = r + "-cyclic-special-mid", m.label = "", m.startLabelRight = "", m.startLabelLeft = "", m.arrowTypeStart = "none", d.isGroup && (s.fromCluster = r, m.toCluster = r), m.id = r + "-cyclic-special-2", m.arrowTypeStart = "none", g.setEdge(r, f, s, r + "-cyclic-special-0"), g.setEdge(f, h, p, r + "-cyclic-special-1"), g.setEdge(h, r, m, r + "-cyclic-special-2");
+    } else
+      g.setEdge(o.start, o.end, { ...o }, o.id);
+  }), c.warn("Graph at first:", JSON.stringify(I(g))), J(g), c.warn("Graph after XAX:", JSON.stringify(I(g)));
+  const l = _();
+  await k(
+    y,
+    g,
+    n.type,
+    n.diagramId,
+    void 0,
+    l
+  );
+}, "render");
+export {
+  se as getEdgesToRender,
+  ae as render
+};
+//# sourceMappingURL=dagre-VZM6K2ZE-CelPLP8N.js.map