@oscherbakov/react-flow-automated-layout 1.3.4 → 1.3.5

package/dist/react-flow-automated-layout.es.js

@@ -1,9 +1,9 @@
-import { jsx as u, jsxs as T, Fragment as P } from "react/jsx-runtime";
-import { createContext as Ft, useContext as Vt, useState as B, useEffect as V, useRef as dt, useCallback as U } from "react";
-import { Position as A, useReactFlow as It, useNodes as Yt, useEdges as Pt, useOnSelectionChange as jt, ControlButton as D, Controls as Xt } from "@xyflow/react";
+import { jsx as u, jsxs as T, Fragment as j } from "react/jsx-runtime";
+import { createContext as Ut, useContext as Vt, useState as B, useEffect as Y, useRef as dt, useCallback as U } from "react";
+import { Position as A, useReactFlow as Yt, useNodes as Ft, useEdges as Pt, useOnSelectionChange as jt, ControlButton as D, Controls as Xt } from "@xyflow/react";
 import ut from "@dagrejs/dagre";
-const Lt = Ft(void 0);
-function I() {
+const Lt = Ut(void 0);
+function F() {
   const t = Vt(Lt);
   if (t === void 0)
     throw new Error("useLayoutContext must be used within a LayoutProvider");
@@ -22,7 +22,7 @@ const ft = (t) => {
     default:
       return "TB";
   }
-}, pt = (t) => {
+}, gt = (t) => {
   switch (t) {
     case "TB":
       return "DOWN";
@@ -74,472 +74,473 @@ const ft = (t) => {
 function Qt(t, r, e) {
   if (e)
     return { nodes: t, edges: r };
-  const o = t.filter((l) => !l.hidden), n = new Set(o.map((l) => l.id)), i = r.filter(
-    (l) => n.has(l.source) && n.has(l.target)
+  const s = t.filter((h) => !h.hidden), n = new Set(s.map((h) => h.id)), o = r.filter(
+    (h) => n.has(h.source) && n.has(h.target)
   );
-  return { nodes: o, edges: i };
+  return { nodes: s, edges: o };
 }
-const Wt = 172, Kt = 36, X = async (t, r, e, o = 0, n = 50, i = 50, l = Wt, c = Kt, h = !1) => {
-  const a = new ut.graphlib.Graph().setDefaultEdgeLabel(() => ({}));
-  a.setGraph({
+const It = 172, Wt = 36, J = async (t, r, e, s = 0, n = 50, o = 50, h = It, a = Wt, d = !1) => {
+  const l = new ut.graphlib.Graph().setDefaultEdgeLabel(() => ({}));
+  l.setGraph({
     rankdir: e,
-    marginx: o,
-    marginy: o,
+    marginx: s,
+    marginy: s,
     nodesep: n,
-    ranksep: i,
+    ranksep: o,
     edgesep: Math.max(20, n / 4),
     //When we have siblings, we want their top edges to be aligned
     ranker: "tight-tree"
   });
-  const s = h ? t : t.filter((f) => !f.hidden);
-  if (s.length === 0)
+  const i = d ? t : t.filter((p) => !p.hidden);
+  if (i.length === 0)
     return { nodes: [], edges: [], width: 0, height: 0 };
-  s.forEach((f) => {
-    var w, y;
-    const p = Number((w = f.style) == null ? void 0 : w.width) || l, m = Number((y = f.style) == null ? void 0 : y.height) || c;
-    a.setNode(f.id, { width: p, height: m });
-  }), r.forEach((f) => {
-    var C, b;
-    const p = f.sourceHandle, m = f.targetHandle, w = !!((C = f.data) != null && C.isReciprocal), y = !!((b = f.data) != null && b.isSyntheticBridge);
-    let g = {};
-    w ? g = { constraint: !1, minlen: 1, weight: 5 } : y ? g = { constraint: !0, minlen: 1, weight: 4 } : p === "right" && m === "left" ? g = { constraint: !1, minlen: 1 } : p === "bottom" && m === "top" ? g = { constraint: !0, minlen: 1 } : g = { constraint: !0, minlen: 2 }, a.setEdge(f.source, f.target, g);
-  }), ut.layout(a);
-  const d = a.graph().width || 0, x = a.graph().height || 0, N = Zt(pt(e)), L = qt(pt(e));
+  i.forEach((p) => {
+    var y, g;
+    const f = Number((y = p.style) == null ? void 0 : y.width) || h, m = Number((g = p.style) == null ? void 0 : g.height) || a;
+    l.setNode(p.id, { width: f, height: m });
+  }), r.forEach((p) => {
+    var E, L;
+    const f = p.sourceHandle, m = p.targetHandle, y = !!((E = p.data) != null && E.isReciprocal), g = !!((L = p.data) != null && L.isSyntheticBridge);
+    let w = {};
+    y ? w = { constraint: !1, minlen: 1, weight: 5 } : g ? w = { constraint: !0, minlen: 1, weight: 4 } : f === "right" && m === "left" ? w = { constraint: !1, minlen: 1 } : f === "bottom" && m === "top" ? w = { constraint: !0, minlen: 1 } : w = { constraint: !0, minlen: 2 }, l.setEdge(p.source, p.target, w);
+  }), ut.layout(l);
+  const c = l.graph().width || 0, x = l.graph().height || 0, N = Zt(gt(e)), b = qt(gt(e));
   return {
-    nodes: s.map((f) => {
-      var b;
-      const p = a.node(f.id), { width: m, height: w } = p, y = {
-        ...f,
+    nodes: i.map((p) => {
+      var L;
+      const f = l.node(p.id), { width: m, height: y } = f, g = {
+        ...p,
         sourcePosition: N,
-        targetPosition: L,
+        targetPosition: b,
         selected: !1
-      }, g = p.x, C = p.y;
-      switch ((b = f.data) == null ? void 0 : b.positionType) {
+      }, w = f.x, E = f.y;
+      switch ((L = p.data) == null ? void 0 : L.positionType) {
         case "center":
-          y.position = { x: g, y: C };
+          g.position = { x: w, y: E };
           break;
         case "topRight":
-          y.position = { x: g + m / 2, y: C - w / 2 };
+          g.position = { x: w + m / 2, y: E - y / 2 };
           break;
         case "bottomLeft":
-          y.position = { x: g - m / 2, y: C + w / 2 };
+          g.position = { x: w - m / 2, y: E + y / 2 };
           break;
         case "bottomRight":
-          y.position = { x: g + m / 2, y: C + w / 2 };
+          g.position = { x: w + m / 2, y: E + y / 2 };
           break;
         case "topLeft":
         default:
-          y.position = { x: g - m / 2, y: C - w / 2 };
+          g.position = { x: w - m / 2, y: E - y / 2 };
       }
-      return y;
+      return g;
     }),
     edges: r,
-    width: d,
+    width: c,
     height: x
   };
-}, te = {
+}, Kt = {
   calculate: async (t, r, e) => {
-    const o = e.nodes || t, n = e.edges || r, l = e.dagreDirection || typeof e.direction == "string" && (e.direction === "RIGHT" || e.direction === "LEFT" ? "LR" : "TB") || "TB", c = e.margin ?? (typeof e.padding == "number" ? e.padding : 0), h = e.nodeSpacing ?? 50, a = e.layerSpacing ?? 50, s = e.nodeWidth ?? 172, d = e.nodeHeight ?? 36, x = e.layoutHidden ?? !1;
-    return X(
-      o,
+    const s = e.nodes || t, n = e.edges || r, h = e.dagreDirection || typeof e.direction == "string" && (e.direction === "RIGHT" || e.direction === "LEFT" ? "LR" : "TB") || "TB", a = e.margin ?? (typeof e.padding == "number" ? e.padding : 0), d = e.nodeSpacing ?? 50, l = e.layerSpacing ?? 50, i = e.nodeWidth ?? 172, c = e.nodeHeight ?? 36, x = e.layoutHidden ?? !1;
+    return J(
+      s,
       n,
-      l,
-      c,
       h,
       a,
-      s,
       d,
+      l,
+      i,
+      c,
       x
     );
   }
-}, ee = {
-  dagre: te
+}, te = {
+  dagre: Kt
 };
-function re({
+function ee({
   initialDirection: t = "DOWN",
   initialAlgorithm: r = "layered",
   initialAutoLayout: e = !0,
-  initialPadding: o = 50,
+  initialPadding: s = 50,
   initialSpacing: n = { node: 50, layer: 50 },
-  initialNodeDimensions: i = { width: 172, height: 36 },
-  initialParentResizingOptions: l,
-  includeHidden: c = !1,
-  layoutEngines: h
+  initialNodeDimensions: o = { width: 172, height: 36 },
+  initialParentResizingOptions: h,
+  includeHidden: a = !1,
+  layoutEngines: d
 }) {
-  const [a, s] = B(t), [d, x] = B(r), [N, L] = B(e), [E, f] = B(!1), [p, m] = B(c), [w, y] = B({
-    ...ee,
-    ...h
-  }), [g, C] = B({}), [b, M] = B(o), [G, O] = B(n.node || 150), [k, v] = B(n.layer || 180), [S, R] = B(i.width || 100), [_, J] = B(i.height || 100), [Z, q] = B({
+  const [l, i] = B(t), [c, x] = B(r), [N, b] = B(e), [C, p] = B(!1), [f, m] = B(a), [y, g] = B({
+    ...te,
+    ...d
+  }), [w, E] = B({}), [L, M] = B(s), [G, O] = B(n.node || 150), [k, v] = B(n.layer || 180), [S, R] = B(o.width || 100), [_, Z] = B(o.height || 100), [q, Q] = B({
     ...Jt,
-    ...l,
+    ...h,
     enabled: e
-  }), [Y, Q] = B([]);
+  }), [P, I] = B([]);
   return {
     // State
-    direction: a,
-    algorithm: d,
+    direction: l,
+    algorithm: c,
     autoLayout: N,
-    layoutInProgress: E,
-    layoutHidden: p,
-    layoutEngines: w,
-    layoutEngineOptions: g,
-    padding: b,
+    layoutInProgress: C,
+    layoutHidden: f,
+    layoutEngines: y,
+    layoutEngineOptions: w,
+    padding: L,
     nodeSpacing: G,
     layerSpacing: k,
     nodeWidth: S,
     nodeHeight: _,
-    parentResizingOptions: Z,
-    selectedNodes: Y,
+    parentResizingOptions: q,
+    selectedNodes: P,
     // Setters
-    setDirection: s,
+    setDirection: i,
     setAlgorithm: x,
-    setAutoLayout: L,
-    setLayoutInProgress: f,
+    setAutoLayout: b,
+    setLayoutInProgress: p,
     setLayoutHidden: m,
-    setLayoutEngines: y,
-    setLayoutEngineOptions: C,
+    setLayoutEngines: g,
+    setLayoutEngineOptions: E,
     setPadding: M,
     setNodeSpacing: O,
     setLayerSpacing: v,
     setNodeWidth: R,
-    setNodeHeight: J,
-    setParentResizingOptionsState: q,
-    setSelectedNodes: Q
+    setNodeHeight: Z,
+    setParentResizingOptionsState: Q,
+    setSelectedNodes: I
   };
 }
-function ne({
+function re({
   nodes: t,
   externalNodeIdWithNode: r,
   externalNodeParentIdMapWithChildIdSet: e,
-  noParentKey: o = "no-parent"
+  noParentKey: s = "no-parent"
 }) {
-  const [n, i] = B(/* @__PURE__ */ new Map()), [l, c] = B(/* @__PURE__ */ new Map()), [h, a] = B({}), [s, d] = B(t.length), [x, N] = B(!1), [L, E] = B(!1), f = r || n, p = e || l, m = f.size;
-  return V(() => {
+  const [n, o] = B(/* @__PURE__ */ new Map()), [h, a] = B(/* @__PURE__ */ new Map()), [d, l] = B({}), [i, c] = B(t.length), [x, N] = B(!1), b = r || n, C = e || h, p = b.size;
+  return Y(() => {
     if (!r || !e) {
-      const w = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map();
-      E(!1), t.forEach((g) => {
-        var b;
-        w.set(g.id, g);
-        const C = g.parentId || o;
-        y.has(C) || y.set(C, /* @__PURE__ */ new Set()), (b = y.get(C)) == null || b.add(g.id);
-      }), r || i(w), e || c(y);
+      const f = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map();
+      t.forEach((y) => {
+        var w;
+        f.set(y.id, y);
+        const g = y.parentId || s;
+        m.has(g) || m.set(g, /* @__PURE__ */ new Set()), (w = m.get(g)) == null || w.add(y.id);
+      }), r || o(f), e || a(m);
     }
-  }, [t, r, e, o]), V(() => {
-    t.length !== s && d(t.length);
-  }, [t]), V(() => {
-    f.size > 0 && p.size > 0 && (x || N(!0), E(!0));
-  }, [f, p, x]), V(() => {
-    const w = {};
-    p.forEach((g, C) => {
-      w[C] = g.size;
+  }, [t, r, e, s]), Y(() => {
+    t.length !== i && c(t.length);
+  }, [t]), Y(() => {
+    b.size > 0 && C.size > 0 && !x && N(!0);
+  }, [b, C, x]), Y(() => {
+    const f = {};
+    C.forEach((y, g) => {
+      f[g] = y.size;
     });
-    let y = !1;
-    for (const g in w)
-      if (!h.hasOwnProperty(g) || w[g] !== h[g]) {
-        y = !0;
+    let m = !1;
+    for (const y in f)
+      if (!d.hasOwnProperty(y) || f[y] !== d[y]) {
+        m = !0;
         break;
       }
-    y && a(w);
-  }, [p]), {
-    nodeIdWithNode: f,
-    nodeParentIdMapWithChildIdSet: p,
-    numberOfNodes: m,
-    nodesLength: s,
-    nodesInitialized: L,
+    m && l(f);
+  }, [C]), {
+    nodeIdWithNode: b,
+    nodeParentIdMapWithChildIdSet: C,
+    numberOfNodes: p,
+    nodesLength: i,
     childrenInitialized: x,
-    parentChildStructure: h
+    parentChildStructure: d
   };
 }
-function oe({
+function ne({
   nodes: t,
   edges: r,
   selectedNodes: e,
-  layoutHidden: o,
+  layoutHidden: s,
   calculateLayout: n,
-  calculateContainerLayout: i,
-  updateNodes: l,
-  updateEdges: c,
-  setLayoutInProgress: h,
-  setNodeSpacing: a,
-  setLayerSpacing: s
+  calculateContainerLayout: o,
+  updateNodes: h,
+  updateEdges: a,
+  setLayoutInProgress: d,
+  setNodeSpacing: l,
+  setLayerSpacing: i
 }) {
-  const d = It(), x = dt(null), N = dt(null), L = U(async (f = [], p = []) => {
+  const c = Yt(), x = dt(null), N = dt(null), b = U(async (p = [], f = []) => {
     x.current && x.current.abort();
     const m = new AbortController();
     x.current = m;
-    const w = f.length > 0 ? f : t, y = p.length > 0 ? p : r;
-    if (w.length === 0)
-      return { nodes: w, edges: y };
+    const y = p.length > 0 ? p : (c == null ? void 0 : c.getNodes()) ?? t, g = f.length > 0 ? f : (c == null ? void 0 : c.getEdges()) ?? r;
+    if (y.length === 0)
+      return { nodes: y, edges: g };
     try {
-      if (h(!0), m.signal.aborted)
-        return { nodes: w, edges: y };
-      const { nodes: g, edges: C } = Qt(w, y, o), b = await n(g, C, e, m.signal);
-      return m.signal.aborted ? { nodes: w, edges: y } : (x.current === m && (l ? l(b.nodes) : d != null && d.setNodes && d.setNodes(b.nodes), c ? c(b.edges) : d != null && d.setEdges && d.setEdges(b.edges), N.current && (N.current.node !== void 0 && a(N.current.node), N.current.layer !== void 0 && s(N.current.layer), N.current = null)), b);
-    } catch (g) {
-      return m.signal.aborted || console.error("Error applying layout:", g), { nodes: w, edges: y };
+      if (d(!0), m.signal.aborted)
+        return { nodes: y, edges: g };
+      const { nodes: w, edges: E } = Qt(y, g, s), L = await n(w, E, e, m.signal);
+      return m.signal.aborted ? { nodes: y, edges: g } : (x.current === m && (h ? h(L.nodes) : c != null && c.setNodes && c.setNodes(L.nodes), a ? a(L.edges) : c != null && c.setEdges && c.setEdges(L.edges), N.current && (N.current.node !== void 0 && l(N.current.node), N.current.layer !== void 0 && i(N.current.layer), N.current = null)), L);
+    } catch (w) {
+      return m.signal.aborted || console.error("Error applying layout:", w), { nodes: y, edges: g };
     } finally {
-      x.current === m && (h(!1), x.current = null);
+      x.current === m && (d(!1), x.current = null);
     }
   }, [
     t,
     r,
     e,
     n,
-    l,
-    c,
-    d,
-    o,
     h,
     a,
-    s
-  ]), E = U(async (f) => {
+    c,
+    s,
+    d,
+    l,
+    i
+  ]), C = U(async (p) => {
     x.current && x.current.abort();
-    const p = new AbortController();
-    if (x.current = p, t.length === 0) return { nodes: t, edges: r };
+    const f = new AbortController();
+    x.current = f;
+    const m = (c == null ? void 0 : c.getNodes()) ?? t, y = (c == null ? void 0 : c.getEdges()) ?? r;
+    if (m.length === 0) return { nodes: m, edges: y };
     try {
-      if (h(!0), p.signal.aborted) return { nodes: t, edges: r };
-      const m = await i(f, t, r, p.signal);
-      return p.signal.aborted ? { nodes: t, edges: r } : (x.current === p && (l ? l(m.nodes) : d != null && d.setNodes && d.setNodes(m.nodes), c ? c(m.edges) : d != null && d.setEdges && d.setEdges(m.edges)), m);
-    } catch (m) {
-      return p.signal.aborted || console.error("Error applying container layout:", m), { nodes: t, edges: r };
+      if (d(!0), f.signal.aborted) return { nodes: m, edges: y };
+      const g = await o(p, m, y, f.signal);
+      return f.signal.aborted ? { nodes: m, edges: y } : (x.current === f && (h ? h(g.nodes) : c != null && c.setNodes && c.setNodes(g.nodes), a ? a(g.edges) : c != null && c.setEdges && c.setEdges(g.edges)), g);
+    } catch (g) {
+      return f.signal.aborted || console.error("Error applying container layout:", g), { nodes: m, edges: y };
     } finally {
-      x.current === p && (h(!1), x.current = null);
+      x.current === f && (d(!1), x.current = null);
     }
-  }, [t, r, i, l, c, d, h]);
+  }, [t, r, o, h, a, c, d]);
   return {
-    applyLayout: L,
-    applyContainerLayout: E,
+    applyLayout: b,
+    applyContainerLayout: C,
     pendingSpacingUpdateRef: N
   };
 }
-const ie = (t, r, e = "no-parent") => {
-  const o = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
-  t.forEach((c, h) => {
-    const a = r.get(h);
-    a && n.set(h, {
-      id: h,
-      node: a,
+const se = (t, r, e = "no-parent") => {
+  const s = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
+  t.forEach((a, d) => {
+    const l = r.get(d);
+    l && n.set(d, {
+      id: d,
+      node: l,
       children: [],
       depth: 0
     });
   });
-  const i = (c, h) => {
-    if (o.has(c) || !t.has(c) || !r.get(c)) return null;
-    o.add(c);
-    const s = n.get(c);
-    s.depth = h;
-    const d = t.get(c) || /* @__PURE__ */ new Set();
-    for (const x of d)
+  const o = (a, d) => {
+    if (s.has(a) || !t.has(a) || !r.get(a)) return null;
+    s.add(a);
+    const i = n.get(a);
+    i.depth = d;
+    const c = t.get(a) || /* @__PURE__ */ new Set();
+    for (const x of c)
       if (t.has(x) && r.get(x)) {
-        const L = i(x, h + 1);
-        L && s.children.push(L);
+        const b = o(x, d + 1);
+        b && i.children.push(b);
       }
-    return s;
-  }, l = [];
-  return t.forEach((c, h) => {
-    const a = r.get(h);
-    if (a) {
-      const s = a.parentId;
-      if (!s || s === e) {
-        const d = i(h, 0);
-        d && l.push(d);
+    return i;
+  }, h = [];
+  return t.forEach((a, d) => {
+    const l = r.get(d);
+    if (l) {
+      const i = l.parentId;
+      if (!i || i === e) {
+        const c = o(d, 0);
+        c && h.push(c);
       }
     }
-  }), l;
+  }), h;
 };
 function tt(t, r, e = "no-parent") {
-  const o = [];
+  const s = [];
   let n = t;
-  const i = /* @__PURE__ */ new Set();
+  const o = /* @__PURE__ */ new Set();
   for (; n && n !== e; ) {
-    if (i.has(n)) {
+    if (o.has(n)) {
       console.warn(`Cycle detected in ancestor path for node ${t}`);
       break;
     }
-    i.add(n), o.push(n);
-    const l = r.get(n);
-    if (!l || !l.parentId) {
+    o.add(n), s.push(n);
+    const h = r.get(n);
+    if (!h || !h.parentId) {
       n = e;
       break;
     }
-    n = l.parentId;
+    n = h.parentId;
   }
-  return n === e && o.push(e), o;
+  return n === e && s.push(e), s;
 }
-function z(t, r, e, o = "no-parent") {
+function z(t, r, e, s = "no-parent") {
   if (t === r)
     return t;
-  const n = tt(t, e, o), i = n.indexOf(r);
-  return i === -1 ? null : i === 0 ? t : n[i - 1] || null;
+  const n = tt(t, e, s), o = n.indexOf(r);
+  return o === -1 ? null : o === 0 ? t : n[o - 1] || null;
 }
-function F(t, r, e, o = "no-parent") {
-  const n = tt(t, e, o), i = tt(r, e, o), l = new Set(i);
-  let c = null, h = -1;
+function V(t, r, e, s = "no-parent") {
+  const n = tt(t, e, s), o = tt(r, e, s), h = new Set(o);
+  let a = null, d = -1;
   for (let x = 0; x < n.length; x++)
-    if (l.has(n[x])) {
-      c = n[x], h = x;
+    if (h.has(n[x])) {
+      a = n[x], d = x;
       break;
     }
-  if (!c)
+  if (!a)
     return { lca: null, sourceChild: null, targetChild: null };
-  const a = i.indexOf(c), s = h > 0 ? n[h - 1] : t, d = a > 0 ? i[a - 1] : r;
-  return { lca: c, sourceChild: s, targetChild: d };
+  const l = o.indexOf(a), i = d > 0 ? n[d - 1] : t, c = l > 0 ? o[l - 1] : r;
+  return { lca: a, sourceChild: i, targetChild: c };
 }
-const se = (t) => JSON.parse(JSON.stringify(t)), Et = (t, r, e, o, n) => {
-  const i = se(t);
-  return i.source = r, i.target = e, i.id = o, i.data = {
-    ...i.data,
+const oe = (t) => JSON.parse(JSON.stringify(t)), Et = (t, r, e, s, n) => {
+  const o = oe(t);
+  return o.source = r, o.target = e, o.id = s, o.data = {
+    ...o.data,
     ...n
-  }, i;
-}, ce = (t) => {
+  }, o;
+}, ie = (t) => {
   for (const r of t.values()) {
     const e = /* @__PURE__ */ new Map();
     r.forEach((n) => {
-      const i = `${n.source}->${n.target}`, l = e.get(i) || [];
-      l.push(n), e.set(i, l);
+      const o = `${n.source}->${n.target}`, h = e.get(o) || [];
+      h.push(n), e.set(o, h);
     });
-    const o = /* @__PURE__ */ new Set();
+    const s = /* @__PURE__ */ new Set();
     r.forEach((n) => {
-      const i = `${n.source}->${n.target}`, l = `${n.target}->${n.source}`;
-      if (o.has(i) || o.has(l))
+      const o = `${n.source}->${n.target}`, h = `${n.target}->${n.source}`;
+      if (s.has(o) || s.has(h))
         return;
-      const c = e.get(l);
-      if (!c || c.length === 0)
+      const a = e.get(h);
+      if (!a || a.length === 0)
         return;
-      [...e.get(i) || [], ...c].forEach((a) => {
-        a.data = {
-          ...a.data,
+      [...e.get(o) || [], ...a].forEach((l) => {
+        l.data = {
+          ...l.data,
           isReciprocal: !0
         };
-      }), o.add(i), o.add(l);
+      }), s.add(o), s.add(h);
     });
   }
-}, ae = (t, r, e, o) => {
-  const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-  t.forEach((c) => {
-    const h = n.get(c.target) || [];
-    h.push(c), n.set(c.target, h);
-    const a = i.get(c.source) || [];
-    a.push(c), i.set(c.source, a);
+}, ce = (t, r, e, s) => {
+  const n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  t.forEach((a) => {
+    const d = n.get(a.target) || [];
+    d.push(a), n.set(a.target, d);
+    const l = o.get(a.source) || [];
+    l.push(a), o.set(a.source, l);
   });
-  const l = /* @__PURE__ */ new Set();
-  i.forEach((c, h) => {
-    const a = n.get(h) || [];
-    a.length !== 0 && a.forEach((s) => {
-      c.forEach((d) => {
-        if (s.source === d.target)
+  const h = /* @__PURE__ */ new Set();
+  o.forEach((a, d) => {
+    const l = n.get(d) || [];
+    l.length !== 0 && l.forEach((i) => {
+      a.forEach((c) => {
+        if (i.source === c.target)
           return;
-        const { lca: x, sourceChild: N, targetChild: L } = F(
-          s.source,
-          d.target,
+        const { lca: x, sourceChild: N, targetChild: b } = V(
+          i.source,
+          c.target,
           r,
-          o
-        ), E = F(
-          s.source,
-          h,
+          s
+        ), C = V(
+          i.source,
+          d,
           r,
-          o
-        ).lca, f = F(
-          h,
-          d.target,
+          s
+        ).lca, p = V(
+          d,
+          c.target,
           r,
-          o
+          s
         ).lca;
-        if (!E || E !== f)
+        if (!C || C !== p)
           return;
-        const p = z(
-          s.source,
-          E,
+        const f = z(
+          i.source,
+          C,
           r,
-          o
+          s
         ), m = z(
-          d.target,
-          E,
+          c.target,
+          C,
           r,
-          o
-        ), w = z(
-          h,
-          E,
+          s
+        ), y = z(
+          d,
+          C,
           r,
-          o
+          s
         );
-        if (!p || !m || !w || p !== m || p === w)
+        if (!f || !m || !y || f !== m || f === y)
           return;
-        const y = p, g = z(
-          s.source,
-          y,
+        const g = f, w = z(
+          i.source,
+          g,
           r,
-          o
-        ), C = z(
-          d.target,
-          y,
+          s
+        ), E = z(
+          c.target,
+          g,
           r,
-          o
+          s
         );
-        if (!x || !N || !L || !g || !C || g === C)
+        if (!x || !N || !b || !w || !E || w === E)
           return;
-        const b = `synthetic_bridge_${s.id}_${h}_${d.id}_${y}`;
-        if (l.has(b))
+        const L = `synthetic_bridge_${i.id}_${d}_${c.id}_${g}`;
+        if (h.has(L))
           return;
         const M = Et(
-          s,
-          g,
-          C,
-          b,
+          i,
+          w,
+          E,
+          L,
           {
             isTemporary: !0,
             isSyntheticBridge: !0,
-            bridgeNode: h,
-            bridgeBranch: w,
-            anchorBranch: p,
-            originalSource: s.source,
-            originalTarget: d.target
+            bridgeNode: d,
+            bridgeBranch: y,
+            anchorBranch: f,
+            originalSource: i.source,
+            originalTarget: c.target
           }
         );
-        e.has(y) || e.set(y, []), e.get(y).push(M), l.add(b);
+        e.has(g) || e.set(g, []), e.get(g).push(M), h.add(L);
       });
     });
   });
 };
 function et(t, r, e = "no-parent") {
-  const o = /* @__PURE__ */ new Map();
+  const s = /* @__PURE__ */ new Map();
   for (const n of t) {
-    const { lca: i, sourceChild: l, targetChild: c } = F(
+    const { lca: o, sourceChild: h, targetChild: a } = V(
       n.source,
       n.target,
       r,
       e
     );
-    if (i && l && c && l !== c) {
-      const h = Et(
+    if (o && h && a && h !== a) {
+      const d = Et(
         n,
-        l,
-        c,
-        `temp_${n.id}_${i}`,
+        h,
+        a,
+        `temp_${n.id}_${o}`,
         {
           isTemporary: !0,
           originalSource: n.source,
           originalTarget: n.target
         }
       );
-      o.has(i) || o.set(i, []), o.get(i).push(h);
+      s.has(o) || s.set(o, []), s.get(o).push(d);
     }
   }
-  return ae(t, r, o, e), ce(o), o;
+  return ce(t, r, s, e), ie(s), s;
 }
-const rt = 10, gt = (t, r) => t.find((e) => e.id === r), yt = (t, r, e) => {
-  var c, h;
-  const o = e.get(t);
-  if (!o)
+const rt = 10, pt = (t, r) => t.find((e) => e.id === r), yt = (t, r, e) => {
+  var a, d;
+  const s = e.get(t);
+  if (!s)
     return null;
-  let n = o.position.x + (o.width || Number((c = o.style) == null ? void 0 : c.width) || 172) / 2, i = o.position.y + (o.height || Number((h = o.style) == null ? void 0 : h.height) || 36) / 2, l = o.parentId;
-  for (; l && l !== r; ) {
-    const a = e.get(l);
-    if (!a)
+  let n = s.position.x + (s.width || Number((a = s.style) == null ? void 0 : a.width) || 172) / 2, o = s.position.y + (s.height || Number((d = s.style) == null ? void 0 : d.height) || 36) / 2, h = s.parentId;
+  for (; h && h !== r; ) {
+    const l = e.get(h);
+    if (!l)
       break;
-    n += a.position.x, i += a.position.y, l = a.parentId;
+    n += l.position.x, o += l.position.y, h = l.parentId;
   }
-  return { x: n, y: i };
+  return { x: n, y: o };
 }, $ = (t) => {
   var r, e;
   return {
@@ -552,283 +553,283 @@ const rt = 10, gt = (t, r) => t.find((e) => e.id === r), yt = (t, r, e) => {
     x: t.position.x + r / 2,
     y: t.position.y + e / 2
   };
-}, le = (t, r) => {
+}, ae = (t, r) => {
   if (t.length === 0)
     return { nodes: t, width: 0, height: 0 };
-  let e = Number.POSITIVE_INFINITY, o = Number.POSITIVE_INFINITY, n = Number.NEGATIVE_INFINITY, i = Number.NEGATIVE_INFINITY;
-  t.forEach((s) => {
-    const { width: d, height: x } = $(s);
-    e = Math.min(e, s.position.x), o = Math.min(o, s.position.y), n = Math.max(n, s.position.x + d), i = Math.max(i, s.position.y + x);
+  let e = Number.POSITIVE_INFINITY, s = Number.POSITIVE_INFINITY, n = Number.NEGATIVE_INFINITY, o = Number.NEGATIVE_INFINITY;
+  t.forEach((i) => {
+    const { width: c, height: x } = $(i);
+    e = Math.min(e, i.position.x), s = Math.min(s, i.position.y), n = Math.max(n, i.position.x + c), o = Math.max(o, i.position.y + x);
   });
-  const l = r - e, c = r - o;
-  t.forEach((s) => {
-    s.position = {
-      x: s.position.x + l,
-      y: s.position.y + c
+  const h = r - e, a = r - s;
+  t.forEach((i) => {
+    i.position = {
+      x: i.position.x + h,
+      y: i.position.y + a
     };
   });
-  const h = n - e + r * 2, a = i - o + r * 2;
-  return { nodes: t, width: h, height: a };
-}, he = (t, r, e, o) => {
-  if (!(t.length < 2 || o.size === 0))
+  const d = n - e + r * 2, l = o - s + r * 2;
+  return { nodes: t, width: d, height: l };
+}, le = (t, r, e, s) => {
+  if (!(t.length < 2 || s.size === 0))
     if (r === "TB" || r === "BT") {
-      const n = [...t].sort((i, l) => i.position.x - l.position.x);
-      n.forEach((i, l) => {
-        if (!o.has(i.id))
+      const n = [...t].sort((o, h) => o.position.x - h.position.x);
+      n.forEach((o, h) => {
+        if (!s.has(o.id))
           return;
-        let c = i.position.x + $(i).width;
-        for (let h = l + 1; h < n.length; h++) {
-          const a = n[h], { width: s } = $(a), d = c + e;
-          a.position.x < d && (a.position.x = d), c = a.position.x + s;
+        let a = o.position.x + $(o).width;
+        for (let d = h + 1; d < n.length; d++) {
+          const l = n[d], { width: i } = $(l), c = a + e;
+          l.position.x < c && (l.position.x = c), a = l.position.x + i;
         }
       });
     } else {
-      const n = [...t].sort((i, l) => i.position.y - l.position.y);
-      n.forEach((i, l) => {
-        if (!o.has(i.id))
+      const n = [...t].sort((o, h) => o.position.y - h.position.y);
+      n.forEach((o, h) => {
+        if (!s.has(o.id))
           return;
-        let c = i.position.y + $(i).height;
-        for (let h = l + 1; h < n.length; h++) {
-          const a = n[h], { height: s } = $(a), d = c + e;
-          a.position.y < d && (a.position.y = d), c = a.position.y + s;
+        let a = o.position.y + $(o).height;
+        for (let d = h + 1; d < n.length; d++) {
+          const l = n[d], { height: i } = $(l), c = a + e;
+          l.position.y < c && (l.position.y = c), a = l.position.y + i;
         }
       });
     }
-}, de = (t, r, e, o) => {
-  const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-  r.forEach((c) => {
-    const h = n.get(c.target) || [];
-    h.push(c), n.set(c.target, h);
-    const a = i.get(c.source) || [];
-    a.push(c), i.set(c.source, a);
+}, he = (t, r, e, s) => {
+  const n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  r.forEach((a) => {
+    const d = n.get(a.target) || [];
+    d.push(a), n.set(a.target, d);
+    const l = o.get(a.source) || [];
+    l.push(a), o.set(a.source, l);
   });
-  const l = /* @__PURE__ */ new Map();
-  return i.forEach((c, h) => {
-    const a = n.get(h) || [];
-    a.length !== 0 && a.forEach((s) => {
-      c.forEach((d) => {
-        if (s.source === d.target)
+  const h = /* @__PURE__ */ new Map();
+  return o.forEach((a, d) => {
+    const l = n.get(d) || [];
+    l.length !== 0 && l.forEach((i) => {
+      a.forEach((c) => {
+        if (i.source === c.target)
           return;
-        const x = F(
-          s.source,
-          h,
+        const x = V(
+          i.source,
+          d,
           e,
-          o
-        ).lca, N = F(
-          h,
-          d.target,
+          s
+        ).lca, N = V(
+          d,
+          c.target,
           e,
-          o
+          s
         ).lca;
         if (x !== t || N !== t)
           return;
-        const L = z(
-          s.source,
+        const b = z(
+          i.source,
           t,
           e,
-          o
-        ), E = z(
-          d.target,
+          s
+        ), C = z(
+          c.target,
           t,
           e,
-          o
-        ), f = z(
-          h,
+          s
+        ), p = z(
+          d,
           t,
           e,
-          o
+          s
         );
-        if (!L || !E || !f || L !== E || L === f)
+        if (!b || !C || !p || b !== C || b === p)
           return;
-        const p = z(
-          s.source,
-          L,
+        const f = z(
+          i.source,
+          b,
           e,
-          o
+          s
         ), m = z(
-          d.target,
-          L,
+          c.target,
+          b,
           e,
-          o
+          s
         );
-        if (!p || !m || p === m)
+        if (!f || !m || f === m)
           return;
-        const w = `${L}:${f}:${p}:${m}`;
-        l.set(w, {
-          anchorContainerId: L,
-          bridgeContainerId: f,
-          sourceNodeId: p,
+        const y = `${b}:${p}:${f}:${m}`;
+        h.set(y, {
+          anchorContainerId: b,
+          bridgeContainerId: p,
+          sourceNodeId: f,
           targetNodeId: m
         });
       });
     });
-  }), [...l.values()];
-}, ue = (t, r, e, o, n, i, l) => {
-  const c = de(r, n, i, l), h = /* @__PURE__ */ new Set();
-  return c.forEach((a) => {
-    const s = gt(t, a.anchorContainerId), d = gt(t, a.bridgeContainerId);
-    if (!s || !d)
+  }), [...h.values()];
+}, de = (t, r, e, s, n, o, h) => {
+  const a = he(r, n, o, h), d = /* @__PURE__ */ new Set();
+  return a.forEach((l) => {
+    const i = pt(t, l.anchorContainerId), c = pt(t, l.bridgeContainerId);
+    if (!i || !c)
       return;
-    const x = yt(a.sourceNodeId, r, i), N = yt(a.targetNodeId, r, i);
+    const x = yt(l.sourceNodeId, r, o), N = yt(l.targetNodeId, r, o);
     if (!x || !N)
       return;
-    const { width: L, height: E } = $(d), { width: f, height: p } = $(s), m = xt(s), w = xt(d);
+    const { width: b, height: C } = $(c), { width: p, height: f } = $(i), m = xt(i), y = xt(c);
     if (e === "TB" || e === "BT") {
-      const y = (x.y + N.y) / 2;
-      d.position.y = y - E / 2;
-      const g = w.x >= m.x, C = g ? d.position.x - (s.position.x + f) : s.position.x - (d.position.x + L), b = Math.max(o, C);
-      d.position.x = g ? s.position.x + f + b : s.position.x - L - b;
+      const g = (x.y + N.y) / 2;
+      c.position.y = g - C / 2;
+      const w = y.x >= m.x, E = w ? c.position.x - (i.position.x + p) : i.position.x - (c.position.x + b), L = Math.max(s, E);
+      c.position.x = w ? i.position.x + p + L : i.position.x - b - L;
     } else {
-      const y = (x.x + N.x) / 2;
-      d.position.x = y - L / 2;
-      const g = w.y >= m.y, C = g ? d.position.y - (s.position.y + p) : s.position.y - (d.position.y + E), b = Math.max(o, C);
-      d.position.y = g ? s.position.y + p + b : s.position.y - E - b;
+      const g = (x.x + N.x) / 2;
+      c.position.x = g - b / 2;
+      const w = y.y >= m.y, E = w ? c.position.y - (i.position.y + f) : i.position.y - (c.position.y + C), L = Math.max(s, E);
+      c.position.y = w ? i.position.y + f + L : i.position.y - C - L;
     }
-    h.add(d.id);
-  }), h;
-}, Nt = async (t, r, e, o, n, i = rt, l = 50, c = 50, h = 172, a = 36, s = X, d = !1, x = "no-parent") => {
-  const N = et(n, o, x), { updatedNodes: L } = await j(
+    d.add(c.id);
+  }), d;
+}, Nt = async (t, r, e, s, n, o = rt, h = 50, a = 50, d = 172, l = 36, i = J, c = !1, x = "no-parent") => {
+  const N = et(n, s, x), { updatedNodes: b } = await X(
     t,
     r,
     e,
-    o,
+    s,
     n,
-    i,
-    l,
-    c,
+    o,
     h,
     a,
-    s,
     d,
+    l,
+    i,
+    c,
     N,
     x
-  ), E = o.get(t);
-  if (!E)
-    return { updatedNodes: L, updatedEdges: n };
-  const { updatedNodes: f } = await Nt(
-    E.parentId || x,
+  ), C = s.get(t);
+  if (!C)
+    return { updatedNodes: b, updatedEdges: n };
+  const { updatedNodes: p } = await Nt(
+    C.parentId || x,
     r,
     e,
-    o,
+    s,
     n,
-    i,
-    l,
-    c,
+    o,
     h,
     a,
-    s,
     d,
+    l,
+    i,
+    c,
     x
   );
   return {
-    updatedNodes: [...f, ...L],
+    updatedNodes: [...p, ...b],
     updatedEdges: n
     // Always return original edges unchanged
   };
-}, j = async (t, r, e, o, n, i = rt, l = 50, c = 50, h = 172, a = 36, s = X, d = !1, x = /* @__PURE__ */ new Map(), N = "no-parent") => {
-  const L = e.get(t);
-  if (!L || L.size === 0)
+}, X = async (t, r, e, s, n, o = rt, h = 50, a = 50, d = 172, l = 36, i = J, c = !1, x = /* @__PURE__ */ new Map(), N = "no-parent") => {
+  const b = e.get(t);
+  if (!b || b.size === 0)
     return { updatedNodes: [] };
-  const E = [];
-  if (L.forEach((b) => {
-    const M = o.get(b);
-    M && E.push(M);
-  }), E.length === 0)
+  const C = [];
+  if (b.forEach((L) => {
+    const M = s.get(L);
+    M && C.push(M);
+  }), C.length === 0)
     return { updatedNodes: [] };
-  let f = r;
-  const p = o.get(t);
-  p && p.data.layoutDirection && (f = p.data.layoutDirection);
-  const m = x.get(t) || [], { nodes: w, edges: y } = await s(
-    E,
+  let p = r;
+  const f = s.get(t);
+  f && f.data.layoutDirection && (p = f.data.layoutDirection);
+  const m = x.get(t) || [], { nodes: y, edges: g } = await i(
+    C,
     m,
     // Only use temporary edges for layout
-    f,
-    i,
-    l,
-    c,
+    p,
+    o,
     h,
     a,
-    d
+    d,
+    l,
+    c
   );
-  w.forEach((b) => {
-    o.set(b.id, b);
+  y.forEach((L) => {
+    s.set(L.id, L);
   });
-  const g = ue(
-    w,
+  const w = de(
+    y,
     t,
-    f,
-    l,
+    p,
+    h,
     n,
-    o,
+    s,
     N
   );
-  he(
-    w,
-    f,
-    l,
-    g
-  ), w.forEach((b) => {
-    o.set(b.id, b);
+  le(
+    y,
+    p,
+    h,
+    w
+  ), y.forEach((L) => {
+    s.set(L.id, L);
   });
-  const C = le(w, i);
-  return C.nodes.forEach((b) => {
-    o.set(b.id, b);
-  }), p && C.width && C.height && fe(p, C.width, C.height), {
-    updatedNodes: [...C.nodes],
-    udpatedParentNode: p || void 0
+  const E = ae(y, o);
+  return E.nodes.forEach((L) => {
+    s.set(L.id, L);
+  }), f && E.width && E.height && ue(f, E.width, E.height), {
+    updatedNodes: [...E.nodes],
+    udpatedParentNode: f || void 0
   };
-}, fe = (t, r, e) => (t.style || (t.style = {}), t.width = r, t.height = e, t.measured = {
+}, ue = (t, r, e) => (t.style || (t.style = {}), t.width = r, t.height = e, t.measured = {
   width: r,
   height: e
-}, t.style.width = r, t.style.height = e, t), pe = async (t, r, e, o, n, i = rt, l = 50, c = 50, h = 172, a = 36, s = X, d = !1, x = "no-parent") => {
+}, t.style.width = r, t.style.height = e, t), fe = async (t, r, e, s, n, o = rt, h = 50, a = 50, d = 172, l = 36, i = J, c = !1, x = "no-parent") => {
   let N = [];
-  const L = et(n, o, x), E = /* @__PURE__ */ new Map();
-  let f = 0;
-  const p = (w, y) => {
-    y > f && (f = y);
-    for (const g of w)
-      E.has(y) || E.set(y, []), E.get(y).push(g.id), g.children.length > 0 && p(g.children, y + 1);
+  const b = et(n, s, x), C = /* @__PURE__ */ new Map();
+  let p = 0;
+  const f = (y, g) => {
+    g > p && (p = g);
+    for (const w of y)
+      C.has(g) || C.set(g, []), C.get(g).push(w.id), w.children.length > 0 && f(w.children, g + 1);
   };
-  p(t, 0);
-  for (let w = f; w >= 0; w--) {
-    const y = E.get(w) || [], g = await Promise.all(y.map(
-      (C) => j(
-        C,
+  f(t, 0);
+  for (let y = p; y >= 0; y--) {
+    const g = C.get(y) || [], w = await Promise.all(g.map(
+      (E) => X(
+        E,
         r,
         e,
-        o,
+        s,
         n,
         // Pass original edges (only used for returning)
-        i,
-        l,
-        c,
+        o,
         h,
         a,
-        s,
         d,
-        L,
+        l,
+        i,
+        c,
+        b,
         // Pass the global temporary edges map
         x
       )
     ));
-    for (const { updatedNodes: C } of g)
-      N = [...C, ...N];
+    for (const { updatedNodes: E } of w)
+      N = [...E, ...N];
   }
-  const { updatedNodes: m } = await j(
+  const { updatedNodes: m } = await X(
     x,
     r,
     e,
-    o,
+    s,
     n,
     // Pass original edges (only used for returning)
-    i,
-    l,
-    c,
+    o,
     h,
     a,
-    s,
     d,
-    L,
+    l,
+    i,
+    c,
+    b,
     // Process root-level temporary edges
     x
   );
@@ -837,204 +838,204 @@ const rt = 10, gt = (t, r) => t.find((e) => e.id === r), yt = (t, r, e) => {
     updatedEdges: n
     // Always return original edges unchanged
   };
-}, ge = (t, r, e, o = "no-parent") => {
-  const n = t.map((a) => a.id), i = t.map((a) => {
-    var s;
-    return ((s = e.get(a.id)) == null ? void 0 : s.parentId) || a.parentId;
-  }).filter((a) => !!a), c = Array.from(
-    /* @__PURE__ */ new Set([...n, ...i])
-  ).filter((a) => r.has(a)), h = c.filter((a) => {
-    const s = e.get(a);
-    return s ? !s.parentId || !c.includes(s.parentId) : !0;
+}, ge = (t, r, e, s = "no-parent") => {
+  const n = t.map((l) => l.id), o = t.map((l) => {
+    var i;
+    return ((i = e.get(l.id)) == null ? void 0 : i.parentId) || l.parentId;
+  }).filter((l) => !!l), a = Array.from(
+    /* @__PURE__ */ new Set([...n, ...o])
+  ).filter((l) => r.has(l)), d = a.filter((l) => {
+    const i = e.get(l);
+    return i ? !i.parentId || !a.includes(i.parentId) : !0;
   });
-  return h.length === 0 ? [o] : h;
-}, ye = async (t, r, e) => {
+  return d.length === 0 ? [s] : d;
+}, pe = async (t, r, e) => {
   const {
-    dagreDirection: o,
+    dagreDirection: s,
     nodeParentIdMapWithChildIdSet: n,
-    nodeIdWithNode: i,
-    nodes: l,
-    edges: c,
-    margin: h,
-    nodeSpacing: a,
-    layerSpacing: s,
-    nodeWidth: d,
+    nodeIdWithNode: o,
+    nodes: h,
+    edges: a,
+    margin: d,
+    nodeSpacing: l,
+    layerSpacing: i,
+    nodeWidth: c,
     nodeHeight: x,
     layoutHidden: N = !1,
-    noParentKey: L = "no-parent"
-  } = r, E = ge(
+    noParentKey: b = "no-parent"
+  } = r, C = ge(
     t,
     n,
-    i,
-    L
+    o,
+    b
   );
-  if (E.length === 0)
-    return { nodes: l, edges: c };
-  const f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+  if (C.length === 0)
+    return { nodes: h, edges: a };
+  const p = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map();
   if (e != null && e.aborted)
-    return { nodes: l, edges: c };
+    return { nodes: h, edges: a };
   (await Promise.all(
-    E.map(async (g) => e != null && e.aborted ? { updatedNodes: [], updatedEdges: [] } : Nt(
-      g,
-      o,
+    C.map(async (w) => e != null && e.aborted ? { updatedNodes: [], updatedEdges: [] } : Nt(
+      w,
+      s,
       n,
-      i,
-      c,
-      h,
+      o,
       a,
-      s,
       d,
+      l,
+      i,
+      c,
       x,
       void 0,
       N
     ))
-  )).forEach(({ updatedNodes: g, updatedEdges: C }) => {
-    g.forEach((b) => {
-      f.set(b.id, b);
-    }), C.forEach((b) => {
-      p.set(b.id, b);
+  )).forEach(({ updatedNodes: w, updatedEdges: E }) => {
+    w.forEach((L) => {
+      p.set(L.id, L);
+    }), E.forEach((L) => {
+      f.set(L.id, L);
     });
   });
-  const w = l.map(
-    (g) => f.has(g.id) ? f.get(g.id) : g
-  ), y = c.map(
-    (g) => p.has(g.id) ? p.get(g.id) : g
+  const y = h.map(
+    (w) => p.has(w.id) ? p.get(w.id) : w
+  ), g = a.map(
+    (w) => f.has(w.id) ? f.get(w.id) : w
   );
-  return { nodes: w, edges: y };
-}, xe = (t, r, e, o, n, i, l, c, h = 172, a = 36, s = !1, d = "no-parent") => {
-  const x = U(async (L, E, f, p) => {
+  return { nodes: y, edges: g };
+}, ye = (t, r, e, s, n, o, h, a, d = 172, l = 36, i = !1, c = "no-parent") => {
+  const x = U(async (b, C, p, f) => {
     if (!(t[e] || t.dagre))
-      return console.error(`Layout engine "${e}" not found`), { nodes: L, edges: E };
-    const w = s ? L : L.filter((k) => !k.hidden), y = new Set(w.map((k) => k.id)), g = s ? E : E.filter(
-      (k) => y.has(k.source) && y.has(k.target)
-    ), C = ft(r), b = o.padding.horizontal;
+      return console.error(`Layout engine "${e}" not found`), { nodes: b, edges: C };
+    const y = i ? b : b.filter((k) => !k.hidden), g = new Set(y.map((k) => k.id)), w = i ? C : C.filter(
+      (k) => g.has(k.source) && g.has(k.target)
+    ), E = ft(r), L = s.padding.horizontal;
     let M = [], G = [];
-    if (f && f.length > 0) {
-      const k = s ? f : f.filter((S) => !S.hidden), v = await ye(
+    if (p && p.length > 0) {
+      const k = i ? p : p.filter((S) => !S.hidden), v = await pe(
         k,
         {
-          dagreDirection: C,
+          dagreDirection: E,
           nodeParentIdMapWithChildIdSet: n,
-          nodeIdWithNode: i,
-          nodes: w,
-          edges: g,
-          margin: b,
-          nodeSpacing: l,
-          layerSpacing: c,
-          nodeWidth: h,
-          nodeHeight: a,
-          layoutHidden: s,
-          noParentKey: d
+          nodeIdWithNode: o,
+          nodes: y,
+          edges: w,
+          margin: L,
+          nodeSpacing: h,
+          layerSpacing: a,
+          nodeWidth: d,
+          nodeHeight: l,
+          layoutHidden: i,
+          noParentKey: c
         },
-        p
+        f
       );
       M = v.nodes, G = v.edges;
     } else {
-      if (p != null && p.aborted)
-        return { nodes: L, edges: E };
-      const k = ie(n, i, d), v = await pe(
+      if (f != null && f.aborted)
+        return { nodes: b, edges: C };
+      const k = se(n, o, c), v = await fe(
         k,
-        C,
+        E,
         n,
-        i,
-        g,
-        b,
-        l,
-        c,
+        o,
+        w,
+        L,
         h,
         a,
+        d,
+        l,
         void 0,
-        s,
-        d
+        i,
+        c
       );
       M = v.updatedNodes, G = v.updatedEdges;
     }
     return {
-      nodes: L.map((k) => !s && k.hidden ? k : M.find((S) => S.id === k.id) || k),
+      nodes: b.map((k) => !i && k.hidden ? k : M.find((S) => S.id === k.id) || k),
       edges: G
     };
   }, [
     e,
     r,
     t,
-    o.padding.horizontal,
+    s.padding.horizontal,
     n,
-    i,
-    l,
-    c,
+    o,
     h,
     a,
-    s,
-    d
-  ]), N = U(async (L, E, f, p) => {
-    if (p != null && p.aborted) return { nodes: E, edges: f };
-    const m = ft(r), w = o.padding.horizontal, y = s ? E : E.filter((v) => !v.hidden), g = new Set(y.map((v) => v.id)), C = s ? f : f.filter((v) => g.has(v.source) && g.has(v.target)), b = et(C, i, d), M = (v) => {
+    d,
+    l,
+    i,
+    c
+  ]), N = U(async (b, C, p, f) => {
+    if (f != null && f.aborted) return { nodes: C, edges: p };
+    const m = ft(r), y = s.padding.horizontal, g = i ? C : C.filter((v) => !v.hidden), w = new Set(g.map((v) => v.id)), E = i ? p : p.filter((v) => w.has(v.source) && w.has(v.target)), L = et(E, o, c), M = (v) => {
       const S = [], R = n.get(v);
       if (R)
         for (const _ of R)
           n.has(_) && S.push(...M(_));
       return S.push(v), S;
-    }, G = M(L), O = /* @__PURE__ */ new Map();
+    }, G = M(b), O = /* @__PURE__ */ new Map();
     for (const v of G) {
-      if (p != null && p.aborted) return { nodes: E, edges: f };
-      const { updatedNodes: S, udpatedParentNode: R } = await j(
+      if (f != null && f.aborted) return { nodes: C, edges: p };
+      const { updatedNodes: S, udpatedParentNode: R } = await X(
         v,
         m,
         n,
-        i,
-        C,
-        w,
-        l,
-        c,
+        o,
+        E,
+        y,
         h,
         a,
+        d,
+        l,
         void 0,
-        s,
-        b,
-        d
+        i,
+        L,
+        c
       );
       S.forEach((_) => O.set(_.id, _)), R && O.set(R.id, { ...R });
     }
-    return { nodes: E.map((v) => O.get(v.id) ?? v), edges: f };
+    return { nodes: C.map((v) => O.get(v.id) ?? v), edges: p };
   }, [
     r,
-    o.padding.horizontal,
+    s.padding.horizontal,
     n,
-    i,
-    l,
-    c,
+    o,
     h,
     a,
-    s,
-    d
+    d,
+    l,
+    i,
+    c
   ]);
   return { calculateLayout: x, calculateContainerLayout: N };
 };
-function Le({
+function Ce({
   children: t,
   initialDirection: r = "DOWN",
   initialAlgorithm: e = "layered",
-  initialAutoLayout: o = !0,
+  initialAutoLayout: s = !0,
   initialPadding: n = 50,
-  initialSpacing: i = { node: 50, layer: 50 },
-  initialNodeDimensions: l = { width: 172, height: 36 },
-  initialParentResizingOptions: c,
-  includeHidden: h = !1,
-  layoutEngines: a,
-  updateNodes: s,
-  updateEdges: d,
+  initialSpacing: o = { node: 50, layer: 50 },
+  initialNodeDimensions: h = { width: 172, height: 36 },
+  initialParentResizingOptions: a,
+  includeHidden: d = !1,
+  layoutEngines: l,
+  updateNodes: i,
+  updateEdges: c,
   nodeParentIdMapWithChildIdSet: x,
   nodeIdWithNode: N,
-  noParentKey: L = "no-parent",
-  disableAutoLayoutEffect: E = !1
+  noParentKey: b = "no-parent",
+  disableAutoLayoutEffect: C = !1
 }) {
-  const f = Yt(), p = Pt(), {
+  const p = Ft(), f = Pt(), {
     direction: m,
-    algorithm: w,
-    autoLayout: y,
-    layoutInProgress: g,
-    layoutHidden: C,
-    layoutEngines: b,
+    algorithm: y,
+    autoLayout: g,
+    layoutInProgress: w,
+    layoutHidden: E,
+    layoutEngines: L,
     layoutEngineOptions: M,
     padding: G,
     nodeSpacing: O,
@@ -1043,53 +1044,52 @@ function Le({
     nodeHeight: S,
     parentResizingOptions: R,
     selectedNodes: _,
-    setDirection: J,
-    setAlgorithm: Z,
-    setAutoLayout: q,
-    setLayoutInProgress: Y,
-    setLayoutHidden: Q,
+    setDirection: Z,
+    setAlgorithm: q,
+    setAutoLayout: Q,
+    setLayoutInProgress: P,
+    setLayoutHidden: I,
     setLayoutEngines: nt,
     setLayoutEngineOptions: vt,
     setPadding: Tt,
-    setNodeSpacing: ot,
-    setLayerSpacing: it,
+    setNodeSpacing: st,
+    setLayerSpacing: ot,
     setNodeWidth: kt,
     setNodeHeight: Bt,
-    setParentResizingOptionsState: st,
+    setParentResizingOptionsState: it,
     setSelectedNodes: ct
-  } = re({
+  } = ee({
     initialDirection: r,
     initialAlgorithm: e,
-    initialAutoLayout: o,
+    initialAutoLayout: s,
     initialPadding: n,
-    initialSpacing: i,
-    initialNodeDimensions: l,
-    initialParentResizingOptions: c,
-    includeHidden: h,
-    layoutEngines: a
+    initialSpacing: o,
+    initialNodeDimensions: h,
+    initialParentResizingOptions: a,
+    includeHidden: d,
+    layoutEngines: l
   }), {
     nodeIdWithNode: W,
     nodeParentIdMapWithChildIdSet: at,
     numberOfNodes: Mt,
     nodesLength: St,
     childrenInitialized: lt,
-    nodesInitialized: Dt,
-    parentChildStructure: Rt
-  } = ne({
-    nodes: f,
+    parentChildStructure: Dt
+  } = re({
+    nodes: p,
     externalNodeIdWithNode: N,
     externalNodeParentIdMapWithChildIdSet: x,
-    noParentKey: L
-  }), Ot = U(({ nodes: H }) => {
+    noParentKey: b
+  }), Rt = U(({ nodes: H }) => {
     ct(H);
   }, [ct]);
   jt({
-    onChange: Ot
+    onChange: Rt
   });
-  const { calculateLayout: At, calculateContainerLayout: zt } = xe(
-    b,
+  const { calculateLayout: Ot, calculateContainerLayout: At } = ye(
+    L,
     m,
-    w,
+    y,
     R,
     at,
     W,
@@ -1097,72 +1097,71 @@ function Le({
     k,
     v,
     S,
-    C,
-    L
-  ), { applyLayout: ht, applyContainerLayout: Gt } = oe({
-    nodes: f,
-    edges: p,
+    E,
+    b
+  ), { applyLayout: ht, applyContainerLayout: zt } = ne({
+    nodes: p,
+    edges: f,
     selectedNodes: _,
-    layoutHidden: C,
-    calculateLayout: At,
-    calculateContainerLayout: zt,
-    updateNodes: s,
-    updateEdges: d,
-    setLayoutInProgress: Y,
-    setNodeSpacing: ot,
-    setLayerSpacing: it
-  }), _t = U((H, K) => {
-    nt((Ut) => ({ ...Ut, [H]: K }));
-  }, [nt]), Ht = U((H) => {
-    st((K) => ({
+    layoutHidden: E,
+    calculateLayout: Ot,
+    calculateContainerLayout: At,
+    updateNodes: i,
+    updateEdges: c,
+    setLayoutInProgress: P,
+    setNodeSpacing: st,
+    setLayerSpacing: ot
+  }), Gt = U((H, K) => {
+    nt(($t) => ({ ...$t, [H]: K }));
+  }, [nt]), _t = U((H) => {
+    it((K) => ({
       ...K,
       ...H,
-      enabled: y
+      enabled: g
     }));
-  }, [y, st]);
-  V(() => {
+  }, [g, it]);
+  Y(() => {
     var H;
-    E || W.has((H = f[f.length - 1]) == null ? void 0 : H.id) && lt && y && ht();
-  }, [lt, y, m, Mt, O, k, Rt, St]);
-  const $t = {
+    C || W.has((H = p[p.length - 1]) == null ? void 0 : H.id) && lt && g && ht();
+  }, [lt, g, m, Mt, O, k, Dt, St]);
+  const Ht = {
     direction: m,
-    algorithm: w,
-    autoLayout: y,
-    layoutInProgress: g,
-    nodesInitialized: Dt,
+    algorithm: y,
+    autoLayout: g,
+    layoutInProgress: w,
     padding: G,
     nodeSpacing: O,
     layerSpacing: k,
     nodeWidth: v,
     nodeHeight: S,
-    layoutHidden: C,
+    layoutHidden: E,
     parentResizingOptions: R,
-    layoutEngines: b,
+    layoutEngines: L,
     layoutEngineOptions: M,
     nodeParentIdMapWithChildIdSet: at,
     nodeIdWithNode: W,
-    noParentKey: L,
-    updateNodes: s,
-    updateEdges: d,
-    setDirection: J,
-    setAlgorithm: Z,
-    setAutoLayout: q,
-    setLayoutInProgress: Y,
+    noParentKey: b,
+    updateNodes: i,
+    updateEdges: c,
+    setDirection: Z,
+    setAlgorithm: q,
+    setAutoLayout: Q,
+    setLayoutInProgress: P,
     setPadding: Tt,
-    setNodeSpacing: ot,
-    setLayerSpacing: it,
+    setNodeSpacing: st,
+    setLayerSpacing: ot,
     setNodeWidth: kt,
     setNodeHeight: Bt,
-    setLayoutHidden: Q,
-    setParentResizingOptions: Ht,
+    setLayoutHidden: I,
+    setParentResizingOptions: _t,
     setLayoutEngineOptions: vt,
     applyLayout: ht,
-    applyContainerLayout: Gt,
+    applyContainerLayout: zt,
     clearLayoutCache: () => {
     },
-    registerLayoutEngine: _t
+    registerLayoutEngine: Gt
   };
-  return /* @__PURE__ */ u(Lt.Provider, { value: $t, children: t });
+  return /* @__PURE__ */ u(Lt.Provider, { value: Ht, children: t });
 }
 const wt = ({
   compact: t = !1
@@ -1170,9 +1169,9 @@ const wt = ({
   const {
     direction: r,
     setDirection: e,
-    clearLayoutCache: o
-  } = I(), n = (i) => {
-    e(i), o && o();
+    clearLayoutCache: s
+  } = F(), n = (o) => {
+    e(o), s && s();
   };
   return t ? /* @__PURE__ */ u(
     D,
@@ -1187,7 +1186,7 @@ const wt = ({
         /* @__PURE__ */ u("path", { d: "M12 4v16M6 16l6 6 6-6" })
       ) })
     }
-  ) : /* @__PURE__ */ T(P, { children: [
+  ) : /* @__PURE__ */ T(j, { children: [
     /* @__PURE__ */ u(
       D,
       {
@@ -1231,19 +1230,19 @@ const wt = ({
   const {
     nodeSpacing: r,
     layerSpacing: e,
-    setNodeSpacing: o,
+    setNodeSpacing: s,
     setLayerSpacing: n,
-    clearLayoutCache: i
-  } = I(), [l, c] = B(!1), h = (s) => {
-    o(s), i && i();
-  }, a = (s) => {
-    n(s), i && i();
+    clearLayoutCache: o
+  } = F(), [h, a] = B(!1), d = (i) => {
+    s(i), o && o();
+  }, l = (i) => {
+    n(i), o && o();
   };
   return t ? /* @__PURE__ */ T("div", { style: { position: "relative" }, children: [
     /* @__PURE__ */ u(
       D,
       {
-        onClick: () => c(!l),
+        onClick: () => a(!h),
         title: "Adjust node and layer spacing",
         children: /* @__PURE__ */ T("svg", { viewBox: "0 0 24 24", width: "16", height: "16", stroke: "currentColor", strokeWidth: "2", fill: "none", children: [
           /* @__PURE__ */ u("rect", { x: "3", y: "3", width: "7", height: "7", rx: "1" }),
@@ -1254,7 +1253,7 @@ const wt = ({
         ] })
       }
     ),
-    l && /* @__PURE__ */ T(
+    h && /* @__PURE__ */ T(
       "div",
       {
         className: "react-flow-spacing-dropdown",
@@ -1278,21 +1277,21 @@ const wt = ({
               r,
               "px"
             ] }),
-            /* @__PURE__ */ u("div", { style: { display: "flex", gap: "4px" }, children: [50, 100, 150, 200].map((s) => /* @__PURE__ */ u(
+            /* @__PURE__ */ u("div", { style: { display: "flex", gap: "4px" }, children: [50, 100, 150, 200].map((i) => /* @__PURE__ */ u(
               "button",
               {
-                onClick: () => h(s),
+                onClick: () => d(i),
                 style: {
-                  background: r === s ? "#0041d0" : "#f5f5f5",
-                  color: r === s ? "white" : "inherit",
+                  background: r === i ? "#0041d0" : "#f5f5f5",
+                  color: r === i ? "white" : "inherit",
                   border: "1px solid #ddd",
                   borderRadius: "4px",
                   padding: "4px 8px",
                   cursor: "pointer"
                 },
-                children: s
+                children: i
               },
-              s
+              i
             )) })
           ] }),
           /* @__PURE__ */ T("div", { children: [
@@ -1301,27 +1300,27 @@ const wt = ({
               e,
               "px"
             ] }),
-            /* @__PURE__ */ u("div", { style: { display: "flex", gap: "4px" }, children: [50, 100, 150, 200].map((s) => /* @__PURE__ */ u(
+            /* @__PURE__ */ u("div", { style: { display: "flex", gap: "4px" }, children: [50, 100, 150, 200].map((i) => /* @__PURE__ */ u(
               "button",
               {
-                onClick: () => a(s),
+                onClick: () => l(i),
                 style: {
-                  background: e === s ? "#0041d0" : "#f5f5f5",
-                  color: e === s ? "white" : "inherit",
+                  background: e === i ? "#0041d0" : "#f5f5f5",
+                  color: e === i ? "white" : "inherit",
                   border: "1px solid #ddd",
                   borderRadius: "4px",
                   padding: "4px 8px",
                   cursor: "pointer"
                 },
-                children: s
+                children: i
               },
-              s
+              i
             )) })
           ] }),
           /* @__PURE__ */ u("div", { style: { marginTop: "12px", textAlign: "right" }, children: /* @__PURE__ */ u(
             "button",
             {
-              onClick: () => c(!1),
+              onClick: () => a(!1),
               style: {
                 background: "#f5f5f5",
                 border: "1px solid #ddd",
@@ -1339,7 +1338,7 @@ const wt = ({
     /* @__PURE__ */ T(
       D,
       {
-        onClick: () => h(Math.max(50, r - 25)),
+        onClick: () => d(Math.max(50, r - 25)),
         title: "Decrease node spacing",
         children: [
           /* @__PURE__ */ T("svg", { viewBox: "0 0 24 24", width: "16", height: "16", stroke: "currentColor", strokeWidth: "2", fill: "none", children: [
@@ -1372,7 +1371,7 @@ const wt = ({
     /* @__PURE__ */ T(
       D,
       {
-        onClick: () => h(Math.min(300, r + 25)),
+        onClick: () => d(Math.min(300, r + 25)),
         title: "Increase node spacing",
         children: [
           /* @__PURE__ */ T("svg", { viewBox: "0 0 24 24", width: "16", height: "16", stroke: "currentColor", strokeWidth: "2", fill: "none", children: [
@@ -1393,7 +1392,7 @@ const wt = ({
     /* @__PURE__ */ T(
       D,
       {
-        onClick: () => a(Math.max(50, e - 25)),
+        onClick: () => l(Math.max(50, e - 25)),
         title: "Decrease layer spacing",
         children: [
           /* @__PURE__ */ T("svg", { viewBox: "0 0 24 24", width: "16", height: "16", stroke: "currentColor", strokeWidth: "2", fill: "none", children: [
@@ -1421,7 +1420,7 @@ const wt = ({
     /* @__PURE__ */ T(
       D,
       {
-        onClick: () => a(Math.min(300, e + 25)),
+        onClick: () => l(Math.min(300, e + 25)),
         title: "Increase layer spacing",
         children: [
           /* @__PURE__ */ T("svg", { viewBox: "0 0 24 24", width: "16", height: "16", stroke: "currentColor", strokeWidth: "2", fill: "none", children: [
@@ -1440,7 +1439,7 @@ const wt = ({
   const {
     autoLayout: r,
     setAutoLayout: e
-  } = I();
+  } = F();
   return /* @__PURE__ */ u(
     D,
     {
@@ -1454,11 +1453,11 @@ const wt = ({
         /* @__PURE__ */ u("rect", { x: "4", y: "4", width: "4", height: "4", rx: "1" }),
         /* @__PURE__ */ u("rect", { x: "4", y: "16", width: "4", height: "4", rx: "1" }),
         /* @__PURE__ */ u("rect", { x: "16", y: "10", width: "4", height: "4", rx: "1" }),
-        /* @__PURE__ */ T(P, { children: [
+        /* @__PURE__ */ T(j, { children: [
           /* @__PURE__ */ u("path", { d: "M8 6c6 0 3 8 8 6" }),
           /* @__PURE__ */ u("path", { d: "M8 18c3-3 2-8 6-6" })
         ] })
-      ] }) : /* @__PURE__ */ T(P, { children: [
+      ] }) : /* @__PURE__ */ T(j, { children: [
         "Auto-Layout ",
         r ? "ON" : "OFF"
       ] })
@@ -1470,17 +1469,17 @@ const wt = ({
   const {
     layoutInProgress: r,
     setLayoutInProgress: e,
-    applyLayout: o
-  } = I();
+    applyLayout: s
+  } = F();
   return /* @__PURE__ */ T(
     D,
     {
       onClick: async () => {
         if (!r)
           try {
-            e(!0), await o();
-          } catch (i) {
-            console.error("Error applying layout:", i);
+            e(!0), await s();
+          } catch (o) {
+            console.error("Error applying layout:", o);
           }
       },
       title: "Apply layout",
@@ -1500,20 +1499,20 @@ const wt = ({
       ]
     }
   );
-}, Ee = ({
+}, Le = ({
   showDirectionControls: t = !0,
   showSpacingControls: r = !0,
   showAutoLayoutToggle: e = !0,
-  showApplyLayoutButton: o = !0,
+  showApplyLayoutButton: s = !0,
   // Enable by default
   standalone: n = !1,
-  position: i = "top-right"
+  position: o = "top-right"
 }) => {
-  const l = I(), {
-    autoLayout: c
-  } = l;
-  return n ? /* @__PURE__ */ T(Xt, { position: i, showZoom: !1, showFitView: !1, showInteractive: !1, children: [
-    o && !c && /* @__PURE__ */ u(
+  const h = F(), {
+    autoLayout: a
+  } = h;
+  return n ? /* @__PURE__ */ T(Xt, { position: o, showZoom: !1, showFitView: !1, showInteractive: !1, children: [
+    s && !a && /* @__PURE__ */ u(
       Ct,
       {
         compact: !0
@@ -1537,8 +1536,8 @@ const wt = ({
         compact: !0
       }
     )
-  ] }) : /* @__PURE__ */ T(P, { children: [
-    o && !c && /* @__PURE__ */ u(
+  ] }) : /* @__PURE__ */ T(j, { children: [
+    s && !a && /* @__PURE__ */ u(
       Ct,
       {
         compact: !0
@@ -1566,11 +1565,11 @@ const wt = ({
 };
 export {
   bt as AutoLayoutToggle,
-  te as DagreEngine,
+  Kt as DagreEngine,
   wt as DirectionControls,
-  Ee as LayoutControls,
-  Le as LayoutProvider,
+  Le as LayoutControls,
+  Ce as LayoutProvider,
   mt as SpacingControls,
-  ee as engines,
-  I as useLayoutContext
+  te as engines,
+  F as useLayoutContext
 };