@dagrejs/dagre 3.0.0 → 3.1.1

package/dist/dagre.js

@@ -23,25 +23,25 @@ var dagre = (() => {
   // index.ts
   var index_exports = {};
   __export(index_exports, {
-    Graph: () => p,
+    Graph: () => Graph,
     debug: () => debugOrdering,
     default: () => index_default,
-    graphlib: () => graphlib_esm_exports,
+    graphlib: () => graph_lib_exports,
     layout: () => layout,
     util: () => util,
     version: () => version
   });
 
-  // node_modules/@dagrejs/graphlib/dist/graphlib.esm.js
-  var graphlib_esm_exports = {};
-  __export(graphlib_esm_exports, {
-    Graph: () => p,
-    alg: () => v,
-    json: () => G,
-    version: () => H
+  // lib/graph-lib.ts
+  var graph_lib_exports = {};
+  __export(graph_lib_exports, {
+    Graph: () => Graph,
+    alg: () => F
   });
+
+  // node_modules/@dagrejs/graphlib/dist/graphlib.esm.js
   var V = Object.defineProperty;
-  var F = (s, e) => {
+  var x = (s, e) => {
     for (var t in e) V(s, t, { get: e[t], enumerable: true });
   };
   var p = class {
@@ -95,8 +95,8 @@ var dagre = (() => {
       return this.nodes().filter((e) => Object.keys(this._out[e]).length === 0);
     }
     setNodes(e, t) {
-      return e.forEach((n) => {
-        t !== void 0 ? this.setNode(n, t) : this.setNode(n);
+      return e.forEach((r) => {
+        t !== void 0 ? this.setNode(r, t) : this.setNode(r);
       }), this;
     }
     setNode(e, t) {
@@ -110,9 +110,9 @@ var dagre = (() => {
     }
     removeNode(e) {
       if (e in this._nodes) {
-        let t = (n) => this.removeEdge(this._edgeObjs[n]);
-        delete this._nodes[e], this._isCompound && (this._removeFromParentsChildList(e), delete this._parent[e], this.children(e).forEach((n) => {
-          this.setParent(n);
+        let t = (r) => this.removeEdge(this._edgeObjs[r]);
+        delete this._nodes[e], this._isCompound && (this._removeFromParentsChildList(e), delete this._parent[e], this.children(e).forEach((r) => {
+          this.setParent(r);
         }), delete this._children[e]), Object.keys(this._in[e]).forEach(t), delete this._in[e], delete this._preds[e], Object.keys(this._out[e]).forEach(t), delete this._out[e], delete this._sucs[e], --this._nodeCount;
       }
       return this;
@@ -122,7 +122,7 @@ var dagre = (() => {
       if (t === void 0) t = "\0";
       else {
         t += "";
-        for (let n = t; n !== void 0; n = this.parent(n)) if (n === e) throw new Error("Setting " + t + " as parent of " + e + " would create a cycle");
+        for (let r = t; r !== void 0; r = this.parent(r)) if (r === e) throw new Error("Setting " + t + " as parent of " + e + " would create a cycle");
         this.setNode(t);
       }
       return this.setNode(e), this._removeFromParentsChildList(e), this._parent[e] = t, this._children[t][e] = true, this;
@@ -154,27 +154,28 @@ var dagre = (() => {
     neighbors(e) {
       let t = this.predecessors(e);
       if (t) {
-        let n = new Set(t);
-        for (let i of this.successors(e)) n.add(i);
-        return Array.from(n.values());
+        let r = new Set(t), i = this.successors(e);
+        if (i) for (let n of i) r.add(n);
+        return Array.from(r.values());
       }
     }
     isLeaf(e) {
+      var r;
       let t;
-      return this.isDirected() ? t = this.successors(e) : t = this.neighbors(e), t.length === 0;
+      return this.isDirected() ? t = this.successors(e) : t = this.neighbors(e), ((r = t == null ? void 0 : t.length) != null ? r : 0) === 0;
     }
     filterNodes(e) {
       let t = new this.constructor({ directed: this._isDirected, multigraph: this._isMultigraph, compound: this._isCompound });
-      t.setGraph(this.graph()), Object.entries(this._nodes).forEach(([r, o]) => {
-        e(r) && t.setNode(r, o);
-      }), Object.values(this._edgeObjs).forEach((r) => {
-        t.hasNode(r.v) && t.hasNode(r.w) && t.setEdge(r, this.edge(r));
+      t.setGraph(this.graph()), Object.entries(this._nodes).forEach(([n, o]) => {
+        e(n) && t.setNode(n, o);
+      }), Object.values(this._edgeObjs).forEach((n) => {
+        t.hasNode(n.v) && t.hasNode(n.w) && t.setEdge(n, this.edge(n));
       });
-      let n = {}, i = (r) => {
-        let o = this.parent(r);
-        return !o || t.hasNode(o) ? (n[r] = o != null ? o : void 0, o != null ? o : void 0) : o in n ? n[o] : i(o);
+      let r = {}, i = (n) => {
+        let o = this.parent(n);
+        return !o || t.hasNode(o) ? (r[n] = o, o) : o in r ? r[o] : i(o);
       };
-      return this._isCompound && t.nodes().forEach((r) => t.setParent(r, i(r))), t;
+      return this._isCompound && t.nodes().forEach((n) => t.setParent(n, i(n))), t;
     }
     setDefaultEdgeLabel(e) {
       return typeof e != "function" ? this._defaultEdgeLabelFn = () => e : this._defaultEdgeLabelFn = e, this;
@@ -186,34 +187,34 @@ var dagre = (() => {
       return Object.values(this._edgeObjs);
     }
     setPath(e, t) {
-      return e.reduce((n, i) => (t !== void 0 ? this.setEdge(n, i, t) : this.setEdge(n, i), i)), this;
+      return e.reduce((r, i) => (t !== void 0 ? this.setEdge(r, i, t) : this.setEdge(r, i), i)), this;
     }
-    setEdge(e, t, n, i) {
-      let r, o, d, a, c = false;
-      typeof e == "object" && e !== null && "v" in e ? (r = e.v, o = e.w, d = e.name, arguments.length === 2 && (a = t, c = true)) : (r = e, o = t, d = i, arguments.length > 2 && (a = n, c = true)), r = "" + r, o = "" + o, d !== void 0 && (d = "" + d);
-      let h = b(this._isDirected, r, o, d);
-      if (h in this._edgeLabels) return c && (this._edgeLabels[h] = a), this;
+    setEdge(e, t, r, i) {
+      let n, o, d, h, c = false;
+      typeof e == "object" && e !== null && "v" in e ? (n = e.v, o = e.w, d = e.name, arguments.length === 2 && (h = t, c = true)) : (n = e, o = t, d = i, arguments.length > 2 && (h = r, c = true)), n = "" + n, o = "" + o, d !== void 0 && (d = "" + d);
+      let a = _(this._isDirected, n, o, d);
+      if (a in this._edgeLabels) return c && (this._edgeLabels[a] = h), this;
       if (d !== void 0 && !this._isMultigraph) throw new Error("Cannot set a named edge when isMultigraph = false");
-      this.setNode(r), this.setNode(o), this._edgeLabels[h] = c ? a : this._defaultEdgeLabelFn(r, o, d);
-      let u = J(this._isDirected, r, o, d);
-      return r = u.v, o = u.w, Object.freeze(u), this._edgeObjs[h] = u, k(this._preds[o], r), k(this._sucs[r], o), this._in[o][h] = u, this._out[r][h] = u, this._edgeCount++, this;
+      this.setNode(n), this.setNode(o), this._edgeLabels[a] = c ? h : this._defaultEdgeLabelFn(n, o, d);
+      let u = J(this._isDirected, n, o, d);
+      return n = u.v, o = u.w, Object.freeze(u), this._edgeObjs[a] = u, R(this._preds[o], n), R(this._sucs[n], o), this._in[o][a] = u, this._out[n][a] = u, this._edgeCount++, this;
     }
-    edge(e, t, n) {
-      let i = arguments.length === 1 ? N(this._isDirected, e) : b(this._isDirected, e, t, n);
+    edge(e, t, r) {
+      let i = arguments.length === 1 ? G(this._isDirected, e) : _(this._isDirected, e, t, r);
       return this._edgeLabels[i];
     }
-    edgeAsObj(e, t, n) {
-      let i = arguments.length === 1 ? this.edge(e) : this.edge(e, t, n);
-      return typeof i != "object" ? { label: i } : i;
+    edgeAsObj(e, t, r) {
+      let i = arguments.length === 1 ? this.edge(e) : this.edge(e, t, r);
+      return typeof i != "object" || i === null ? { label: i } : i;
     }
-    hasEdge(e, t, n) {
-      return (arguments.length === 1 ? N(this._isDirected, e) : b(this._isDirected, e, t, n)) in this._edgeLabels;
+    hasEdge(e, t, r) {
+      return (arguments.length === 1 ? G(this._isDirected, e) : _(this._isDirected, e, t, r)) in this._edgeLabels;
     }
-    removeEdge(e, t, n) {
-      let i = arguments.length === 1 ? N(this._isDirected, e) : b(this._isDirected, e, t, n), r = this._edgeObjs[i];
-      if (r) {
-        let o = r.v, d = r.w;
-        delete this._edgeLabels[i], delete this._edgeObjs[i], x(this._preds[d], o), x(this._sucs[o], d), delete this._in[d][i], delete this._out[o][i], this._edgeCount--;
+    removeEdge(e, t, r) {
+      let i = arguments.length === 1 ? G(this._isDirected, e) : _(this._isDirected, e, t, r), n = this._edgeObjs[i];
+      if (n) {
+        let o = n.v, d = n.w;
+        delete this._edgeLabels[i], delete this._edgeObjs[i], k(this._preds[d], o), k(this._sucs[o], d), delete this._in[d][i], delete this._out[o][i], this._edgeCount--;
       }
       return this;
     }
@@ -229,58 +230,57 @@ var dagre = (() => {
     _removeFromParentsChildList(e) {
       delete this._children[this._parent[e]][e];
     }
-    filterEdges(e, t, n) {
+    filterEdges(e, t, r) {
       if (!e) return;
       let i = Object.values(e);
-      return n ? i.filter((r) => r.v === t && r.w === n || r.v === n && r.w === t) : i;
+      return r ? i.filter((n) => n.v === t && n.w === r || n.v === r && n.w === t) : i;
     }
   };
-  function k(s, e) {
+  function R(s, e) {
     s[e] ? s[e]++ : s[e] = 1;
   }
-  function x(s, e) {
+  function k(s, e) {
     s[e] !== void 0 && !--s[e] && delete s[e];
   }
-  function b(s, e, t, n) {
-    let i = "" + e, r = "" + t;
-    if (!s && i > r) {
+  function _(s, e, t, r) {
+    let i = "" + e, n = "" + t;
+    if (!s && i > n) {
       let o = i;
-      i = r, r = o;
+      i = n, n = o;
     }
-    return i + "
" + r + "
" + (n === void 0 ? "\0" : n);
+    return i + "
" + n + "
" + (r === void 0 ? "\0" : r);
   }
-  function J(s, e, t, n) {
-    let i = "" + e, r = "" + t;
-    if (!s && i > r) {
+  function J(s, e, t, r) {
+    let i = "" + e, n = "" + t;
+    if (!s && i > n) {
       let d = i;
-      i = r, r = d;
+      i = n, n = d;
     }
-    let o = { v: i, w: r };
-    return n && (o.name = n), o;
+    let o = { v: i, w: n };
+    return r && (o.name = r), o;
   }
-  function N(s, e) {
-    return b(s, e.v, e.w, e.name);
+  function G(s, e) {
+    return _(s, e.v, e.w, e.name);
   }
-  var H = "4.0.1";
-  var G = {};
-  F(G, { read: () => z, write: () => U });
+  var v = {};
+  x(v, { read: () => K, write: () => U });
   function U(s) {
-    let e = { options: { directed: s.isDirected(), multigraph: s.isMultigraph(), compound: s.isCompound() }, nodes: Y(s), edges: K(s) }, t = s.graph();
+    let e = { options: { directed: s.isDirected(), multigraph: s.isMultigraph(), compound: s.isCompound() }, nodes: Y(s), edges: z(s) }, t = s.graph();
     return t !== void 0 && (e.value = structuredClone(t)), e;
   }
   function Y(s) {
     return s.nodes().map((e) => {
-      let t = s.node(e), n = s.parent(e), i = { v: e };
-      return t !== void 0 && (i.value = t), n !== void 0 && (i.parent = n), i;
+      let t = s.node(e), r = s.parent(e), i = { v: e };
+      return t !== void 0 && (i.value = t), r !== void 0 && (i.parent = r), i;
     });
   }
-  function K(s) {
+  function z(s) {
     return s.edges().map((e) => {
-      let t = s.edge(e), n = { v: e.v, w: e.w };
-      return e.name !== void 0 && (n.name = e.name), t !== void 0 && (n.value = t), n;
+      let t = s.edge(e), r = { v: e.v, w: e.w };
+      return e.name !== void 0 && (r.name = e.name), t !== void 0 && (r.value = t), r;
     });
   }
-  function z(s) {
+  function K(s) {
     let e = new p(s.options);
     return s.value !== void 0 && e.setGraph(s.value), s.nodes.forEach((t) => {
       e.setNode(t.v, t.value), t.parent && e.setParent(t.v, t.parent);
@@ -288,23 +288,26 @@ var dagre = (() => {
       e.setEdge({ v: t.v, w: t.w, name: t.name }, t.value);
     }), e;
   }
-  var v = {};
-  F(v, { CycleException: () => l, bellmanFord: () => m, components: () => R, dijkstra: () => E, dijkstraAll: () => P, findCycles: () => I, floydWarshall: () => D, isAcyclic: () => O, postorder: () => T, preorder: () => A, prim: () => W, shortestPaths: () => S, tarjan: () => y, topsort: () => L });
+  var F = {};
+  x(F, { CycleException: () => l, bellmanFord: () => y, components: () => P, dijkstra: () => E, dijkstraAll: () => I, findCycles: () => D, floydWarshall: () => O, isAcyclic: () => j, postorder: () => A, preorder: () => W, prim: () => S, shortestPaths: () => M, tarjan: () => L, topsort: () => w });
   var Q = () => 1;
-  function m(s, e, t, n) {
-    return $(s, String(e), t || Q, n || function(i) {
-      return s.outEdges(i);
-    });
-  }
-  function $(s, e, t, n) {
-    let i = {}, r, o = 0, d = s.nodes(), a = function(u) {
-      let g = t(u);
-      i[u.v].distance + g < i[u.w].distance && (i[u.w] = { distance: i[u.v].distance + g, predecessor: u.v }, r = true);
+  function y(s, e, t, r) {
+    return $(s, String(e), t || Q, r || function(i) {
+      var n;
+      return (n = s.outEdges(i)) != null ? n : [];
+    });
+  }
+  function $(s, e, t, r) {
+    let i = {}, n, o = 0, d = s.nodes(), h = function(u) {
+      let g = i[u.v], f = i[u.w];
+      if (!g || !f) return;
+      let m = t(u);
+      g.distance + m < f.distance && (i[u.w] = { distance: g.distance + m, predecessor: u.v }, n = true);
     }, c = function() {
       d.forEach(function(u) {
-        n(u).forEach(function(g) {
-          let f = g.v === u ? g.v : g.w, M = f === g.v ? g.w : g.v;
-          a({ v: f, w: M });
+        r(u).forEach(function(g) {
+          let f = g.v === u ? g.v : g.w, m = f === g.v ? g.w : g.v;
+          h({ v: f, w: m });
         });
       });
     };
@@ -312,21 +315,22 @@ var dagre = (() => {
       let g = u === e ? 0 : Number.POSITIVE_INFINITY;
       i[u] = { distance: g, predecessor: "" };
     });
-    let h = d.length;
-    for (let u = 1; u < h && (r = false, o++, c(), !!r); u++) ;
-    if (o === h - 1 && (r = false, c(), r)) throw new Error("The graph contains a negative weight cycle");
+    let a = d.length;
+    for (let u = 1; u < a && (n = false, o++, c(), !!n); u++) ;
+    if (o === a - 1 && (n = false, c(), n)) throw new Error("The graph contains a negative weight cycle");
     return i;
   }
-  function R(s) {
-    let e = {}, t = [], n;
-    function i(r) {
-      r in e || (e[r] = true, n.push(r), s.successors(r).forEach(i), s.predecessors(r).forEach(i));
+  function P(s) {
+    let e = {}, t = [], r;
+    function i(n) {
+      var o, d;
+      n in e || (e[n] = true, r.push(n), (o = s.successors(n)) == null || o.forEach(i), (d = s.predecessors(n)) == null || d.forEach(i));
     }
-    return s.nodes().forEach(function(r) {
-      n = [], i(r), n.length && t.push(n);
+    return s.nodes().forEach(function(n) {
+      r = [], i(n), r.length && t.push(r);
     }), t;
   }
-  var _ = class {
+  var b = class {
     constructor() {
       this._arr = [];
       this._keyIndices = {};
@@ -349,205 +353,242 @@ var dagre = (() => {
       return this._arr[0].key;
     }
     add(e, t) {
-      let n = this._keyIndices, i = String(e);
-      if (!(i in n)) {
-        let r = this._arr, o = r.length;
-        return n[i] = o, r.push({ key: i, priority: t }), this._decrease(o), true;
+      let r = this._keyIndices, i = String(e);
+      if (!(i in r)) {
+        let n = this._arr, o = n.length;
+        return r[i] = o, n.push({ key: i, priority: t }), this._decrease(o), true;
       }
       return false;
     }
     removeMin() {
+      if (this.size() === 0) throw new Error("Queue underflow");
       this._swap(0, this._arr.length - 1);
       let e = this._arr.pop();
       return delete this._keyIndices[e.key], this._heapify(0), e.key;
     }
     decrease(e, t) {
-      let n = this._keyIndices[e];
-      if (n === void 0) throw new Error(`Key not found: ${e}`);
-      let i = this._arr[n].priority;
+      let r = this._keyIndices[e];
+      if (r === void 0) throw new Error(`Key not found: ${e}`);
+      let i = this._arr[r].priority;
       if (t > i) throw new Error(`New priority is greater than current priority. Key: ${e} Old: ${i} New: ${t}`);
-      this._arr[n].priority = t, this._decrease(n);
+      this._arr[r].priority = t, this._decrease(r);
     }
     _heapify(e) {
-      let t = this._arr, n = 2 * e, i = n + 1, r = e;
-      n < t.length && (r = t[n].priority < t[r].priority ? n : r, i < t.length && (r = t[i].priority < t[r].priority ? i : r), r !== e && (this._swap(e, r), this._heapify(r)));
+      let t = this._arr, r = 2 * e, i = r + 1, n = e;
+      r < t.length && (n = t[r].priority < t[n].priority ? r : n, i < t.length && (n = t[i].priority < t[n].priority ? i : n), n !== e && (this._swap(e, n), this._heapify(n)));
     }
     _decrease(e) {
-      let t = this._arr, n = t[e].priority, i;
-      for (; e !== 0 && (i = e >> 1, !(t[i].priority < n)); ) this._swap(e, i), e = i;
+      let t = this._arr, r = t[e].priority, i;
+      for (; e !== 0 && (i = e >> 1, !(t[i].priority < r)); ) this._swap(e, i), e = i;
     }
     _swap(e, t) {
-      let n = this._arr, i = this._keyIndices, r = n[e], o = n[t];
-      n[e] = o, n[t] = r, i[o.key] = e, i[r.key] = t;
+      let r = this._arr, i = this._keyIndices, n = r[e], o = r[t];
+      r[e] = o, r[t] = n, i[o.key] = e, i[n.key] = t;
     }
   };
   var q = () => 1;
-  function E(s, e, t, n) {
-    let i = function(r) {
-      return s.outEdges(r);
+  function E(s, e, t, r) {
+    let i = function(n) {
+      var o;
+      return (o = s.outEdges(n)) != null ? o : [];
     };
-    return B(s, String(e), t || q, n || i);
+    return B(s, String(e), t || q, r || i);
   }
-  function B(s, e, t, n) {
-    let i = {}, r = new _(), o, d, a = function(c) {
-      let h = c.v !== o ? c.v : c.w, u = i[h], g = t(c), f = d.distance + g;
+  function B(s, e, t, r) {
+    let i = {}, n = new b(), o, d, h = function(c) {
+      let a = c.v !== o ? c.v : c.w, u = i[a];
+      if (!u) return;
+      let g = t(c), f = d.distance + g;
       if (g < 0) throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + c + " Weight: " + g);
-      f < u.distance && (u.distance = f, u.predecessor = o, r.decrease(h, f));
+      f < u.distance && (u.distance = f, u.predecessor = o, n.decrease(a, f));
     };
     for (s.nodes().forEach(function(c) {
-      let h = c === e ? 0 : Number.POSITIVE_INFINITY;
-      i[c] = { distance: h, predecessor: "" }, r.add(c, h);
-    }); r.size() > 0 && (o = r.removeMin(), d = i[o], d.distance !== Number.POSITIVE_INFINITY); ) n(o).forEach(a);
+      let a = c === e ? 0 : Number.POSITIVE_INFINITY;
+      i[c] = { distance: a, predecessor: "" }, n.add(c, a);
+    }); n.size() > 0; ) {
+      o = n.removeMin();
+      let c = i[o];
+      if (!c || c.distance === Number.POSITIVE_INFINITY) break;
+      d = c, r(o).forEach(h);
+    }
     return i;
   }
-  function P(s, e, t) {
-    return s.nodes().reduce(function(n, i) {
-      return n[i] = E(s, i, e, t), n;
+  function I(s, e, t) {
+    return s.nodes().reduce(function(r, i) {
+      return r[i] = E(s, i, e, t), r;
     }, {});
   }
-  function y(s) {
-    let e = 0, t = [], n = {}, i = [];
-    function r(o) {
-      let d = n[o] = { onStack: true, lowlink: e, index: e++ };
-      if (t.push(o), s.successors(o).forEach(function(a) {
-        a in n ? n[a].onStack && (d.lowlink = Math.min(d.lowlink, n[a].index)) : (r(a), d.lowlink = Math.min(d.lowlink, n[a].lowlink));
+  function L(s) {
+    let e = 0, t = [], r = {}, i = [];
+    function n(o) {
+      var h;
+      let d = r[o] = { onStack: true, lowlink: e, index: e++ };
+      if (t.push(o), (h = s.successors(o)) == null || h.forEach(function(c) {
+        if (c in r) {
+          let a = r[c];
+          a != null && a.onStack && (d.lowlink = Math.min(d.lowlink, a.index));
+        } else {
+          n(c);
+          let a = r[c];
+          a && (d.lowlink = Math.min(d.lowlink, a.lowlink));
+        }
       }), d.lowlink === d.index) {
-        let a = [], c;
-        do
-          c = t.pop(), n[c].onStack = false, a.push(c);
-        while (o !== c);
-        i.push(a);
+        let c = [], a;
+        do {
+          a = t.pop();
+          let u = r[a];
+          u && (u.onStack = false), c.push(a);
+        } while (o !== a);
+        i.push(c);
       }
     }
     return s.nodes().forEach(function(o) {
-      o in n || r(o);
+      o in r || n(o);
     }), i;
   }
-  function I(s) {
-    return y(s).filter(function(e) {
-      return e.length > 1 || e.length === 1 && s.hasEdge(e[0], e[0]);
+  function D(s) {
+    return L(s).filter(function(e) {
+      var r;
+      let t = e[0];
+      return t ? e.length > 1 || e.length === 1 && ((r = s.outEdges(t, t)) != null ? r : []).length > 0 : false;
     });
   }
   var X = () => 1;
-  function D(s, e, t) {
-    return Z(s, e || X, t || function(n) {
-      return s.outEdges(n);
+  function O(s, e, t) {
+    return Z(s, e || X, t || function(r) {
+      var i;
+      return (i = s.outEdges(r)) != null ? i : [];
     });
   }
   function Z(s, e, t) {
-    let n = {}, i = s.nodes();
-    return i.forEach(function(r) {
-      n[r] = {}, n[r][r] = { distance: 0, predecessor: "" }, i.forEach(function(o) {
-        r !== o && (n[r][o] = { distance: Number.POSITIVE_INFINITY, predecessor: "" });
-      }), t(r).forEach(function(o) {
-        let d = o.v === r ? o.w : o.v, a = e(o);
-        n[r][d] = { distance: a, predecessor: r };
+    let r = {}, i = s.nodes();
+    return i.forEach(function(n) {
+      let o = {};
+      r[n] = o, o[n] = { distance: 0, predecessor: "" }, i.forEach(function(d) {
+        n !== d && (o[d] = { distance: Number.POSITIVE_INFINITY, predecessor: "" });
+      }), t(n).forEach(function(d) {
+        let h = d.v === n ? d.w : d.v, c = e(d);
+        o[h] = { distance: c, predecessor: n };
       });
-    }), i.forEach(function(r) {
-      let o = n[r];
-      i.forEach(function(d) {
-        let a = n[d];
-        i.forEach(function(c) {
-          let h = a[r], u = o[c], g = a[c], f = h.distance + u.distance;
-          f < g.distance && (g.distance = f, g.predecessor = u.predecessor);
+    }), i.forEach(function(n) {
+      let o = r[n];
+      o && i.forEach(function(d) {
+        let h = r[d];
+        h && i.forEach(function(c) {
+          let a = h[n], u = o[c], g = h[c];
+          if (a && u && g) {
+            let f = a.distance + u.distance;
+            f < g.distance && (g.distance = f, g.predecessor = u.predecessor);
+          }
         });
       });
-    }), n;
+    }), r;
   }
   var l = class extends Error {
-    constructor(...e) {
-      super(...e);
+    constructor(e) {
+      super(e), this.name = "CycleException";
     }
   };
-  function L(s) {
-    let e = {}, t = {}, n = [];
-    function i(r) {
-      if (r in t) throw new l();
-      r in e || (t[r] = true, e[r] = true, s.predecessors(r).forEach(i), delete t[r], n.push(r));
+  function w(s) {
+    let e = {}, t = {}, r = [];
+    function i(n) {
+      var o;
+      if (n in t) throw new l();
+      n in e || (t[n] = true, e[n] = true, (o = s.predecessors(n)) == null || o.forEach(i), delete t[n], r.push(n));
     }
     if (s.sinks().forEach(i), Object.keys(e).length !== s.nodeCount()) throw new l();
-    return n;
+    return r;
   }
-  function O(s) {
+  function j(s) {
     try {
-      L(s);
+      w(s);
     } catch (e) {
       if (e instanceof l) return false;
       throw e;
     }
     return true;
   }
-  function j(s, e, t, n, i) {
+  function C(s, e, t, r, i) {
     Array.isArray(e) || (e = [e]);
-    let r = ((d) => {
-      var a;
-      return (a = s.isDirected() ? s.successors(d) : s.neighbors(d)) != null ? a : [];
+    let n = ((d) => {
+      var h;
+      return (h = s.isDirected() ? s.successors(d) : s.neighbors(d)) != null ? h : [];
     }), o = {};
     return e.forEach(function(d) {
       if (!s.hasNode(d)) throw new Error("Graph does not have node: " + d);
-      i = C(s, d, t === "post", o, r, n, i);
+      i = T(s, d, t === "post", o, n, r, i);
     }), i;
   }
-  function C(s, e, t, n, i, r, o) {
-    return e in n || (n[e] = true, t || (o = r(o, e)), i(e).forEach(function(d) {
-      o = C(s, d, t, n, i, r, o);
-    }), t && (o = r(o, e))), o;
+  function T(s, e, t, r, i, n, o) {
+    return e in r || (r[e] = true, t || (o = n(o, e)), i(e).forEach(function(d) {
+      o = T(s, d, t, r, i, n, o);
+    }), t && (o = n(o, e))), o;
   }
-  function w(s, e, t) {
-    return j(s, e, t, function(n, i) {
-      return n.push(i), n;
+  function N(s, e, t) {
+    return C(s, e, t, function(r, i) {
+      return r.push(i), r;
     }, []);
   }
-  function T(s, e) {
-    return w(s, e, "post");
-  }
   function A(s, e) {
-    return w(s, e, "pre");
+    return N(s, e, "post");
   }
   function W(s, e) {
-    let t = new p(), n = {}, i = new _(), r;
+    return N(s, e, "pre");
+  }
+  function S(s, e) {
+    var c;
+    let t = new p(), r = {}, i = new b(), n;
     function o(a) {
-      let c = a.v === r ? a.w : a.v, h = i.priority(c);
-      if (h !== void 0) {
-        let u = e(a);
-        u < h && (n[c] = r, i.decrease(c, u));
+      let u = a.v === n ? a.w : a.v, g = i.priority(u);
+      if (g !== void 0) {
+        let f = e(a);
+        f < g && (r[u] = n, i.decrease(u, f));
       }
     }
     if (s.nodeCount() === 0) return t;
     s.nodes().forEach(function(a) {
       i.add(a, Number.POSITIVE_INFINITY), t.setNode(a);
-    }), i.decrease(s.nodes()[0], 0);
-    let d = false;
+    });
+    let d = s.nodes()[0];
+    d !== void 0 && i.decrease(d, 0);
+    let h = false;
     for (; i.size() > 0; ) {
-      if (r = i.removeMin(), r in n) t.setEdge(r, n[r]);
+      if (n = i.removeMin(), n in r) t.setEdge(n, r[n]);
       else {
-        if (d) throw new Error("Input graph is not connected: " + s);
-        d = true;
+        if (h) throw new Error("Input graph is not connected: " + s);
+        h = true;
       }
-      s.nodeEdges(r).forEach(o);
+      (c = s.nodeEdges(n)) == null || c.forEach(o);
     }
     return t;
   }
-  function S(s, e, t, n) {
-    return ee(s, e, t, n != null ? n : ((i) => {
-      let r = s.outEdges(i);
-      return r != null ? r : [];
+  function M(s, e, t, r) {
+    return ee(s, e, t, r != null ? r : ((i) => {
+      var n;
+      return (n = s.outEdges(i)) != null ? n : [];
     }));
   }
-  function ee(s, e, t, n) {
-    if (t === void 0) return E(s, e, t, n);
-    let i = false, r = s.nodes();
-    for (let o = 0; o < r.length; o++) {
-      let d = n(r[o]);
-      for (let a = 0; a < d.length; a++) {
-        let c = d[a], h = c.v === r[o] ? c.v : c.w, u = h === c.v ? c.w : c.v;
-        t({ v: h, w: u }) < 0 && (i = true);
+  function ee(s, e, t, r) {
+    if (t === void 0) return E(s, e, t, r);
+    let i = false, n = s.nodes();
+    for (let o = 0; o < n.length; o++) {
+      let d = n[o];
+      if (d === void 0) continue;
+      let h = r(d);
+      for (let c = 0; c < h.length; c++) {
+        let a = h[c];
+        if (!a) continue;
+        let u = a.v === d ? a.v : a.w, g = u === a.v ? a.w : a.v;
+        t({ v: u, w: g }) < 0 && (i = true);
       }
-      if (i) return m(s, e, t, n);
+      if (i) return y(s, e, t, r);
     }
-    return E(s, e, t, n);
+    return E(s, e, t, r);
   }
 
+  // lib/graph-lib.ts
+  var Graph = p;
+
   // lib/util.ts
   function addDummyNode(graph, type, attrs, name) {
     let v2 = name;
@@ -559,7 +600,7 @@ var dagre = (() => {
     return v2;
   }
   function simplify(graph) {
-    const simplified = new p().setGraph(graph.graph());
+    const simplified = new Graph().setGraph(graph.graph());
     graph.nodes().forEach((v2) => simplified.setNode(v2, graph.node(v2)));
     graph.edges().forEach((e) => {
       const simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
@@ -572,7 +613,7 @@ var dagre = (() => {
     return simplified;
   }
   function asNonCompoundGraph(graph) {
-    const simplified = new p({ multigraph: graph.isMultigraph() }).setGraph(graph.graph());
+    const simplified = new Graph({ multigraph: graph.isMultigraph() }).setGraph(graph.graph());
     graph.nodes().forEach((v2) => {
       if (!graph.children(v2).length) {
         simplified.setNode(v2, graph.node(v2));
@@ -769,9 +810,34 @@ var dagre = (() => {
     }, {});
   }
   var GRAPH_NODE = "\0";
+  function compareByOldOrder(oldNodes, nodeA, nodeB) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!(oldNodes && nodeA && nodeB && nodeA.dummy === "edge" && nodeB.dummy === "edge" && nodeA.edgeObj && nodeB.edgeObj && oldNodes[nodeA.edgeObj.v] && oldNodes[nodeB.edgeObj.v] && oldNodes[nodeA.edgeObj.w] && oldNodes[nodeB.edgeObj.w])) {
+      return 0;
+    }
+    let isForward = true;
+    if (nodeA.edgeObj.w === nodeB.edgeObj.w) {
+      isForward = false;
+    }
+    const targetRank = isForward ? (_b = (_a = oldNodes[nodeA.edgeObj.v]) == null ? void 0 : _a.rank) != null ? _b : NaN + 1 : (_d = (_c = oldNodes[nodeA.edgeObj.w]) == null ? void 0 : _c.rank) != null ? _d : NaN - 1;
+    const oldA = Object.entries(oldNodes).find((n) => {
+      var _a2, _b2;
+      return ((_a2 = n[1].edgeObj) == null ? void 0 : _a2.v) === nodeA.edgeObj.v && ((_b2 = n[1].edgeObj) == null ? void 0 : _b2.w) === nodeA.edgeObj.w && n[1].rank === targetRank;
+    });
+    const oldB = Object.entries(oldNodes).find((n) => {
+      var _a2, _b2;
+      return ((_a2 = n[1].edgeObj) == null ? void 0 : _a2.v) === nodeB.edgeObj.v && ((_b2 = n[1].edgeObj) == null ? void 0 : _b2.w) === nodeB.edgeObj.w && n[1].rank === targetRank;
+    });
+    if (!oldA || !oldB) {
+      return 0;
+    }
+    const oldOrderA = (_e = oldA[1].order) != null ? _e : NaN;
+    const oldOrderB = (_f = oldB[1].order) != null ? _f : NaN;
+    return isNaN(oldOrderA - oldOrderB) ? 0 : oldOrderA - oldOrderB;
+  }
 
   // lib/version.ts
-  var version = "3.0.0";
+  var version = "3.1.1";
 
   // lib/data/list.ts
   var List = class {
@@ -883,7 +949,7 @@ var dagre = (() => {
     return results;
   }
   function buildState(graph, weightFn) {
-    const fasGraph = new p();
+    const fasGraph = new Graph();
     let maxIn = 0;
     let maxOut = 0;
     graph.nodes().forEach((v2) => {
@@ -925,8 +991,8 @@ var dagre = (() => {
   }
 
   // lib/acyclic.ts
-  function run(graph) {
-    const fas = graph.graph().acyclicer === "greedy" ? greedyFAS(graph, weightFn(graph)) : dfsFAS(graph);
+  function run(graph, oldGraph) {
+    const fas = graph.graph().acyclicer === "greedy" ? greedyFAS(graph, weightFn(graph)) : dfsFAS(graph, oldGraph != null ? oldGraph : null);
     fas.forEach((e) => {
       const label = graph.edge(e);
       graph.removeEdge(e);
@@ -940,7 +1006,7 @@ var dagre = (() => {
       };
     }
   }
-  function dfsFAS(graph) {
+  function dfsFAS(graph, oldGraph) {
     const fas = [];
     const stack = {};
     const visited = {};
@@ -959,7 +1025,29 @@ var dagre = (() => {
       });
       delete stack[v2];
     }
-    graph.nodes().forEach(dfs2);
+    function dfsDynamic(v2) {
+      var _a;
+      if (Object.hasOwn(visited, v2)) {
+        return;
+      }
+      visited[v2] = true;
+      stack[v2] = true;
+      (_a = graph.outEdges(v2)) == null ? void 0 : _a.forEach((e) => {
+        var _a2, _b;
+        if (Object.hasOwn(stack, e.w) || ((_a2 = oldGraph.node(v2)) == null ? void 0 : _a2.rank) > ((_b = oldGraph.node(e.w)) == null ? void 0 : _b.rank) && isReachedFromStartWithoutEdge(graph, e.w, e)) {
+          fas.push(e);
+        } else {
+          dfsDynamic(e.w);
+        }
+      });
+      delete stack[v2];
+    }
+    let dfsFn = dfs2;
+    if (oldGraph && typeof oldGraph.node === "function") {
+      dfsFn = dfsDynamic;
+    }
+    graph.sources().forEach(dfsFn);
+    graph.nodes().forEach(dfsFn);
     return fas;
   }
   function undo(graph) {
@@ -974,6 +1062,25 @@ var dagre = (() => {
       }
     });
   }
+  function isReachedFromStartWithoutEdge(graph, node, ignoreEdge) {
+    const localVisited = /* @__PURE__ */ new Set();
+    function reverseDfs(v2) {
+      var _a;
+      if (graph.sources().includes(v2)) {
+        return true;
+      }
+      localVisited.add(v2);
+      for (const e of (_a = graph.inEdges(v2)) != null ? _a : []) {
+        if (!(e.v === ignoreEdge.v && e.w === ignoreEdge.w) && !localVisited.has(e.v)) {
+          if (reverseDfs(e.v)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return reverseDfs(node);
+  }
 
   // lib/normalize.ts
   function run2(graph) {
@@ -1070,7 +1177,7 @@ var dagre = (() => {
   // lib/rank/feasible-tree.ts
   var feasible_tree_default = feasibleTree;
   function feasibleTree(graph) {
-    const tree = new p({ directed: false });
+    const tree = new Graph({ directed: false });
     const nodes = graph.nodes();
     if (nodes.length === 0) {
       throw new Error("Graph must have at least one node");
@@ -1124,7 +1231,7 @@ var dagre = (() => {
   }
 
   // lib/rank/network-simplex.ts
-  var { preorder, postorder } = v;
+  var { preorder, postorder } = F;
   var network_simplex_default = networkSimplex;
   networkSimplex.initLowLimValues = initLowLimValues;
   networkSimplex.initCutValues = initCutValues;
@@ -1316,7 +1423,10 @@ var dagre = (() => {
   var parent_dummy_chains_default = parentDummyChains;
   function parentDummyChains(graph) {
     const postorderNums = postorder2(graph);
-    graph.graph().dummyChains.forEach((v2) => {
+    const graphData = graph.graph();
+    if (!Array.isArray(graphData.dummyChains)) return;
+    const dummyChains = graphData.dummyChains;
+    dummyChains.forEach((v2) => {
       let node = graph.node(v2);
       const edgeObj = node.edgeObj;
       const pathData = findPath(graph, postorderNums, edgeObj.v, edgeObj.w);
@@ -1388,7 +1498,9 @@ var dagre = (() => {
     graph.graph().nestingRoot = root;
     graph.edges().forEach((e) => graph.edge(e).minlen *= nodeSep);
     const weight = sumWeights(graph) + 1;
-    graph.children(GRAPH_NODE).forEach((child) => dfs(graph, root, nodeSep, weight, height, depths, child));
+    graph.children(GRAPH_NODE).forEach((child) => {
+      dfs(graph, root, nodeSep, weight, height, depths, child);
+    });
     graph.graph().nodeRankFactor = nodeSep;
   }
   function dfs(graph, root, nodeSep, weight, height, depths, v2) {
@@ -1466,7 +1578,7 @@ var dagre = (() => {
       if (children.length) {
         children.forEach(dfs2);
       }
-      if (Object.hasOwn(node, "minRank")) {
+      if (node && Object.hasOwn(node, "minRank")) {
         node.borderLeft = [];
         node.borderRight = [];
         for (let rank2 = node.minRank, maxRank2 = node.maxRank + 1; rank2 < maxRank2; ++rank2) {
@@ -1548,7 +1660,7 @@ var dagre = (() => {
   }
 
   // lib/order/init-order.ts
-  function initOrder(graph) {
+  function initOrder(graph, oldNodes = null) {
     const visited = {};
     const simpleNodes = graph.nodes().filter((v2) => !graph.children(v2).length);
     const simpleNodesRanks = simpleNodes.map((v2) => graph.node(v2).rank);
@@ -1561,11 +1673,17 @@ var dagre = (() => {
       layers[node.rank].push(v2);
       const successors = graph.successors(v2);
       if (successors) {
-        successors.forEach(dfs2);
+        const sortedSuccessors = [...successors].sort((a, b2) => compareOldOrder(a, b2));
+        sortedSuccessors.forEach(dfs2);
       }
     }
     const orderedVs = simpleNodes.sort((a, b2) => graph.node(a).rank - graph.node(b2).rank);
     orderedVs.forEach(dfs2);
+    function compareOldOrder(a, b2) {
+      const nodeA = graph.node(a);
+      const nodeB = graph.node(b2);
+      return compareByOldOrder(oldNodes, nodeA, nodeB);
+    }
     return layers;
   }
 
@@ -1709,7 +1827,19 @@ var dagre = (() => {
   }
 
   // lib/order/sort.ts
-  function sort(entries, biasRight) {
+  function sort(entries, reversedPairs, oldNodes, graph, biasRight) {
+    let resolvedReversedPairs = {};
+    let resolvedOldNodes = null;
+    let resolvedGraph = null;
+    let resolvedBiasRight = biasRight;
+    if (typeof reversedPairs === "boolean") {
+      resolvedBiasRight = reversedPairs;
+      resolvedReversedPairs = {};
+    } else if (reversedPairs) {
+      resolvedReversedPairs = reversedPairs;
+      resolvedOldNodes = oldNodes != null ? oldNodes : null;
+      resolvedGraph = graph != null ? graph : null;
+    }
     const parts = partition(entries, (entry) => {
       return Object.hasOwn(entry, "barycenter");
     });
@@ -1719,7 +1849,11 @@ var dagre = (() => {
     let sum = 0;
     let weight = 0;
     let vsIndex = 0;
-    sortable.sort(compareWithBias(!!biasRight));
+    sortable.sort(compareWithOldOrder(resolvedGraph, resolvedOldNodes, !!resolvedBiasRight));
+    for (const [key, value] of Object.entries(resolvedReversedPairs)) {
+      const keyIndex = sortable.findIndex((entry) => entry.vs[0] === key);
+      sortable.splice(keyIndex + 1, 0, value);
+    }
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
     sortable.forEach((entry) => {
       vsIndex += entry.vs.length;
@@ -1744,19 +1878,36 @@ var dagre = (() => {
     }
     return index;
   }
-  function compareWithBias(bias) {
+  function compareWithOldOrder(graph, oldNodes, bias) {
     return (entryV, entryW) => {
       if (entryV.barycenter < entryW.barycenter) {
         return -1;
       } else if (entryV.barycenter > entryW.barycenter) {
         return 1;
       }
+      if (graph && (typeof entryV.vs[0] === "string" || typeof entryW.vs[0] === "string")) {
+        const nodeV = graph.node(entryV.vs[0]);
+        const nodeW = graph.node(entryW.vs[0]);
+        const byOldOrder = compareByOldOrder(oldNodes, nodeV, nodeW);
+        if (byOldOrder !== 0) {
+          return byOldOrder;
+        }
+      }
       return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
     };
   }
 
   // lib/order/sort-subgraph.ts
-  function sortSubgraph(graph, v2, constraintGraph, biasRight) {
+  function sortSubgraph(graph, v2, constraintGraph, oldNodes, biasRight) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    let resolvedOldNodes = null;
+    let resolvedBiasRight = biasRight;
+    if (typeof oldNodes === "boolean") {
+      resolvedBiasRight = oldNodes;
+      resolvedOldNodes = null;
+    } else if (oldNodes !== void 0) {
+      resolvedOldNodes = oldNodes;
+    }
     let movable = graph.children(v2);
     const node = graph.node(v2);
     const bl = node ? node.borderLeft : void 0;
@@ -1768,7 +1919,7 @@ var dagre = (() => {
     const barycenters = barycenter(graph, movable);
     barycenters.forEach((entry) => {
       if (graph.children(entry.v).length) {
-        const subgraphResult = sortSubgraph(graph, entry.v, constraintGraph, biasRight);
+        const { result: subgraphResult } = sortSubgraph(graph, entry.v, constraintGraph, resolvedOldNodes, resolvedBiasRight);
         subgraphs[entry.v] = subgraphResult;
         if (Object.hasOwn(subgraphResult, "barycenter")) {
           mergeBarycenters(entry, subgraphResult);
@@ -1777,7 +1928,36 @@ var dagre = (() => {
     });
     const entries = resolveConflicts(barycenters, constraintGraph);
     expandSubgraphs(entries, subgraphs);
-    const result = sort(entries, biasRight);
+    const reversedPairs = {};
+    let usedBias = false;
+    for (let i = 0; i < entries.length; i++) {
+      for (let j2 = i + 1; j2 < entries.length; j2++) {
+        if (!entries[i] || !entries[j2] || !((_a = entries[i]) == null ? void 0 : _a.barycenter) || !((_b = entries[j2]) == null ? void 0 : _b.barycenter)) {
+          continue;
+        }
+        if (((_c = entries[i]) == null ? void 0 : _c.barycenter) === entries[j2].barycenter) {
+          const nameI = (_e = (_d = entries[i]) == null ? void 0 : _d.vs[0]) != null ? _e : "";
+          const nameJ = (_g = (_f = entries[j2]) == null ? void 0 : _f.vs[0]) != null ? _g : "";
+          const nodeI = graph.node(nameI);
+          const nodeJ = graph.node(nameJ);
+          if (nodeI.dummy === "edge" && nodeJ.dummy === "edge" && ((_h = nodeI.edgeObj) == null ? void 0 : _h.v) === ((_i = nodeJ.edgeObj) == null ? void 0 : _i.v) && ((_j = nodeI.edgeObj) == null ? void 0 : _j.w) === ((_k = nodeJ.edgeObj) == null ? void 0 : _k.w)) {
+            if (nodeI.edgeLabel.reversed) {
+              reversedPairs[nameJ] = entries[i];
+              entries.splice(i, 1);
+              i--;
+              break;
+            } else {
+              reversedPairs[nameI] = entries[j2];
+              entries.splice(j2, 1);
+              j2--;
+            }
+          } else {
+            usedBias = true;
+          }
+        }
+      }
+    }
+    const result = sort(entries, reversedPairs, resolvedOldNodes, graph, resolvedBiasRight);
     if (bl && br) {
       result.vs = [bl, result.vs, br].flat(1);
       const blPredecessors = graph.predecessors(bl);
@@ -1793,6 +1973,8 @@ var dagre = (() => {
         result.weight += 2;
       }
     }
+    Object.defineProperty(result, "result", { value: result, enumerable: false, configurable: true, writable: true });
+    Object.defineProperty(result, "usedBias", { value: usedBias, enumerable: false, configurable: true, writable: true });
     return result;
   }
   function expandSubgraphs(entries, subgraphs) {
@@ -1821,7 +2003,7 @@ var dagre = (() => {
       nodesWithRank = graph.nodes();
     }
     const root = createRootNode(graph);
-    const result = new p({ compound: true }).setGraph({ root }).setDefaultNodeLabel((v2) => graph.node(v2));
+    const result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel((v2) => graph.node(v2));
     nodesWithRank.forEach((v2) => {
       const node = graph.node(v2);
       const parent = graph.parent(v2);
@@ -1880,7 +2062,7 @@ var dagre = (() => {
   }
 
   // lib/order/index.ts
-  function order(graph, opts = {}) {
+  function order(graph, opts = {}, oldNodes = null) {
     if (typeof opts.customOrder === "function") {
       opts.customOrder(graph, order);
       return;
@@ -1888,7 +2070,7 @@ var dagre = (() => {
     const maxRank2 = maxRank(graph);
     const downLayerGraphs = buildLayerGraphs(graph, range(1, maxRank2 + 1), "inEdges");
     const upLayerGraphs = buildLayerGraphs(graph, range(maxRank2 - 1, -1, -1), "outEdges");
-    let layering = initOrder(graph);
+    let layering = initOrder(graph, oldNodes);
     assignOrder(graph, layering);
     if (opts.disableOptimalOrderHeuristic) {
       return;
@@ -1897,7 +2079,7 @@ var dagre = (() => {
     let best;
     const constraints = opts.constraints || [];
     for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
-      sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2, constraints);
+      sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2, constraints, oldNodes);
       layering = buildLayerMatrix(graph);
       const cc = crossCount(graph, layering);
       if (cc < bestCC) {
@@ -1935,12 +2117,16 @@ var dagre = (() => {
       return buildLayerGraph(graph, rank2, relationship, nodesByRank.get(rank2) || []);
     });
   }
-  function sweepLayerGraphs(layerGraphs, biasRight, constraints) {
-    const cg = new p();
+  function sweepLayerGraphs(layerGraphs, switchBias, constraints, oldNodes) {
+    let biasRight = true;
+    const cg = new Graph();
     layerGraphs.forEach(function(lg) {
       constraints.forEach((con) => cg.setEdge(con.left, con.right));
       const root = lg.graph().root;
-      const sorted = sortSubgraph(lg, root, cg, biasRight);
+      const { result: sorted, usedBias } = sortSubgraph(lg, root, cg, oldNodes, biasRight);
+      if (switchBias && usedBias) {
+        biasRight = !biasRight;
+      }
       sorted.vs.forEach((v2, i) => lg.node(v2).order = i);
       addSubgraphConstraints(lg, cg, sorted.vs);
     });
@@ -2057,7 +2243,7 @@ var dagre = (() => {
     const conflictsV = conflicts[v2];
     return conflictsV !== void 0 && Object.hasOwn(conflictsV, w2);
   }
-  function verticalAlignment(graph, layering, conflicts, neighborFn) {
+  function verticalAlignment(graph, layering, conflicts, neighborFn, corePath) {
     const root = {};
     const align = {};
     const pos = {};
@@ -2070,9 +2256,25 @@ var dagre = (() => {
     });
     layering.forEach((layer) => {
       let prevIdx = -1;
-      layer.forEach((v2) => {
-        const wsRaw = neighborFn(v2);
+      let alreadyAlignedIndex = -1;
+      let hasShifted = false;
+      let modifiedLayer = layer;
+      const coreNodeIndex = layer.findIndex((v2) => {
+        return (corePath == null ? void 0 : corePath.includes(v2)) || isInCorePath(v2, graph, corePath);
+      });
+      if (coreNodeIndex > 0) {
+        modifiedLayer = [layer[coreNodeIndex], ...layer.slice(0, coreNodeIndex), ...layer.slice(coreNodeIndex + 1)];
+        hasShifted = true;
+      }
+      modifiedLayer.forEach((v2) => {
+        var _a;
+        let wsRaw = neighborFn(v2);
         if (wsRaw && wsRaw.length) {
+          if (corePath == null ? void 0 : corePath.includes(v2)) {
+            wsRaw = wsRaw.filter((w2) => {
+              return isInCorePath(w2, graph, corePath);
+            });
+          }
           const ws = wsRaw.sort((a, b2) => {
             const posA = pos[a];
             const posB = pos[b2];
@@ -2083,12 +2285,17 @@ var dagre = (() => {
             const w2 = ws[i];
             if (w2 === void 0) continue;
             const posW = pos[w2];
-            if (posW !== void 0 && align[v2] === v2 && prevIdx < posW && !hasConflict(conflicts, v2, w2)) {
+            if (posW !== void 0 && align[v2] === v2 && prevIdx < posW && pos[w2] !== alreadyAlignedIndex && !hasConflict(conflicts, v2, w2)) {
               const rootW = root[w2];
               if (rootW !== void 0) {
                 align[w2] = v2;
                 align[v2] = root[v2] = rootW;
                 prevIdx = posW;
+                if (hasShifted) {
+                  prevIdx = -1;
+                  alreadyAlignedIndex = (_a = pos[w2]) != null ? _a : -1;
+                  hasShifted = false;
+                }
               }
             }
           }
@@ -2164,7 +2371,7 @@ var dagre = (() => {
     return xs;
   }
   function buildBlockGraph(graph, layering, root, reverseSep) {
-    const blockGraph = new p();
+    const blockGraph = new Graph();
     const graphLabel = graph.graph();
     const sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
     layering.forEach((layer) => {
@@ -2243,7 +2450,7 @@ var dagre = (() => {
       return (((_a = xs[1]) != null ? _a : 0) + ((_b = xs[2]) != null ? _b : 0)) / 2;
     });
   }
-  function positionX(graph) {
+  function positionX(graph, corePath) {
     const layering = buildLayerMatrix(graph);
     const conflicts = Object.assign(
       findType1Conflicts(graph, layering),
@@ -2263,7 +2470,7 @@ var dagre = (() => {
           const result = vert === "u" ? graph.predecessors(v2) : graph.successors(v2);
           return result || [];
         };
-        const align = verticalAlignment(graph, adjustedLayering, conflicts, neighborFn);
+        const align = verticalAlignment(graph, adjustedLayering, conflicts, neighborFn, corePath);
         let xs = horizontalCompaction(
           graph,
           adjustedLayering,
@@ -2324,12 +2531,21 @@ var dagre = (() => {
   function width(graph, v2) {
     return graph.node(v2).width;
   }
+  function isInCorePath(v2, graph, corePath) {
+    var _a;
+    if (!corePath) return false;
+    const edge = (_a = graph.node(v2)) == null ? void 0 : _a.edgeObj;
+    if (!edge || graph.node(v2).edgeLabel.reversed) return false;
+    const sourceIndex = corePath.indexOf(edge == null ? void 0 : edge.v);
+    const targetIndex = corePath.indexOf(edge == null ? void 0 : edge.w);
+    return sourceIndex !== -1 && targetIndex !== -1 && sourceIndex === (targetIndex + 1) % corePath.length || sourceIndex === (targetIndex - 1) % corePath.length;
+  }
 
   // lib/position/index.ts
-  function position(graph) {
+  function position(graph, corePath) {
     graph = asNonCompoundGraph(graph);
     positionY(graph);
-    Object.entries(positionX(graph)).forEach(([v2, x2]) => graph.node(v2).x = x2);
+    Object.entries(positionX(graph, corePath)).forEach(([v2, x2]) => graph.node(v2).x = x2);
   }
   function positionY(graph) {
     const layering = buildLayerMatrix(graph);
@@ -2362,19 +2578,234 @@ var dagre = (() => {
   }
 
   // lib/layout.ts
+  var previousLayouts = /* @__PURE__ */ new WeakMap();
   function layout(g, opts = {}) {
-    const time2 = opts.debugTiming ? time : notime;
-    return time2("layout", () => {
-      const layoutGraph = time2("  buildLayoutGraph", () => buildLayoutGraph(g));
-      time2("  runLayout", () => runLayout(layoutGraph, time2, opts));
-      time2("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
-      return layoutGraph;
+    recursiveClusterLayout(g, notime, opts);
+    return g;
+  }
+  function topLevelChildOf(g, node, cluster) {
+    let current = node;
+    while (current !== void 0) {
+      const parent = g.parent(current);
+      if (parent === cluster) return current;
+      current = parent;
+    }
+    return void 0;
+  }
+  function recursiveClusterLayout(g, time2, opts) {
+    var _a;
+    const clusterNodes = g.nodes().filter((v2) => g.children(v2).length);
+    const clusterBounds = {};
+    clusterNodes.forEach((v2) => {
+      const node = g.node(v2);
+      if (node && node.rankdir) {
+        const subgraph = new Graph({ multigraph: true, compound: true });
+        subgraph.setGraph({ rankdir: node.rankdir });
+        const children = g.children(v2);
+        children.forEach((childId) => {
+          const childNode = { ...g.node(childId) };
+          subgraph.setNode(childId, childNode);
+          const parent = g.parent(childId);
+          if (parent && parent !== v2 && children.includes(parent)) {
+            subgraph.setParent(childId, parent);
+          }
+        });
+        const proxiedEdges = /* @__PURE__ */ new Set();
+        g.edges().forEach((e) => {
+          const srcChild = topLevelChildOf(g, e.v, v2);
+          const tgtChild = topLevelChildOf(g, e.w, v2);
+          if (srcChild && tgtChild && srcChild !== tgtChild) {
+            const key = `${srcChild}\0${tgtChild}`;
+            if (!proxiedEdges.has(key)) {
+              proxiedEdges.add(key);
+              subgraph.setEdge(srcChild, tgtChild, { ...g.edge(e) });
+            }
+          }
+        });
+        recursiveClusterLayout(subgraph, time2, opts);
+        const subLayoutG = buildLayoutGraph(subgraph);
+        runLayout(subLayoutG, time2, opts, null);
+        updateInputGraph(subgraph, subLayoutG);
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        subgraph.nodes().forEach((u) => {
+          if (u === v2) return;
+          const n = subgraph.node(u);
+          if (n && typeof n.x === "number" && typeof n.y === "number" && typeof n.width === "number" && typeof n.height === "number") {
+            minX = Math.min(minX, n.x - n.width / 2);
+            maxX = Math.max(maxX, n.x + n.width / 2);
+            minY = Math.min(minY, n.y - n.height / 2);
+            maxY = Math.max(maxY, n.y + n.height / 2);
+          }
+        });
+        if (!isFinite(minX) || !isFinite(minY) || !isFinite(maxX) || !isFinite(maxY)) {
+          minX = minY = 0;
+          maxX = maxY = 0;
+        }
+        const width2 = maxX - minX;
+        const height = maxY - minY;
+        clusterBounds[v2] = {
+          minX,
+          minY,
+          maxX,
+          maxY,
+          width: width2,
+          height,
+          offsetX: minX,
+          offsetY: minY
+        };
+        node._dagreClusterSubgraph = subgraph;
+      }
+    });
+    const isolatedClusters = [];
+    const getAllDescendants = (nodeId) => {
+      const result2 = [];
+      const queue = (g.children(nodeId) || []).filter((c) => c !== nodeId);
+      while (queue.length > 0) {
+        const curr = queue.shift();
+        result2.push(curr);
+        (g.children(curr) || []).filter((c) => c !== curr).forEach((c) => queue.push(c));
+      }
+      return result2;
+    };
+    const rawClusterMap = /* @__PURE__ */ new Map();
+    clusterNodes.forEach((v2) => {
+      const node = g.node(v2);
+      if (node && node.rankdir && clusterBounds[v2]) {
+        rawClusterMap.set(v2, (g.children(v2) || []).filter((c) => c !== v2));
+      }
+    });
+    const allDirectChildrenFlat = new Set([...rawClusterMap.values()].flat());
+    const clusterChildrenMap = /* @__PURE__ */ new Map();
+    rawClusterMap.forEach((_2, v2) => {
+      if (!allDirectChildrenFlat.has(v2)) {
+        clusterChildrenMap.set(v2, getAllDescendants(v2));
+      }
+    });
+    const allIsolatedChildren = new Set(
+      [...clusterChildrenMap.values()].flat()
+    );
+    const topLevelNode = (id) => {
+      for (const [cId, ch] of clusterChildrenMap) {
+        if (ch.includes(id)) return cId;
+      }
+      return id;
+    };
+    const allSavedEdges = [];
+    g.edges().forEach((e) => {
+      if (allIsolatedChildren.has(e.v) || allIsolatedChildren.has(e.w)) {
+        allSavedEdges.push({ edge: e, label: g.edge(e) });
+      }
+    });
+    const savedParents = /* @__PURE__ */ new Map();
+    allIsolatedChildren.forEach((id) => {
+      const p2 = g.parent(id);
+      savedParents.set(id, typeof p2 === "string" ? p2 : void 0);
+    });
+    clusterChildrenMap.forEach((children, v2) => {
+      const node = g.node(v2);
+      const removedNodes = [];
+      children.forEach((childId) => {
+        const childNode = g.node(childId);
+        if (!childNode) return;
+        removedNodes.push({ id: childId, node: childNode, parent: savedParents.get(childId) });
+        g.removeNode(childId);
+      });
+      const removedEdges = allSavedEdges.filter(
+        ({ edge }) => children.includes(edge.v) || children.includes(edge.w)
+      );
+      const bounds = clusterBounds[v2];
+      if (!node) return;
+      isolatedClusters.push({
+        clusterId: v2,
+        subgraph: node._dagreClusterSubgraph,
+        bounds,
+        children,
+        removedNodes,
+        removedEdges
+      });
+      node.width = bounds.width;
+      node.height = bounds.height;
+    });
+    const proxyEdgeKeys = /* @__PURE__ */ new Set();
+    allSavedEdges.forEach(({ edge, label }) => {
+      const effV = topLevelNode(edge.v);
+      const effW = topLevelNode(edge.w);
+      if (effV !== effW && g.hasNode(effV) && g.hasNode(effW)) {
+        const key = `${effV}\0${effW}`;
+        if (!proxyEdgeKeys.has(key)) {
+          proxyEdgeKeys.add(key);
+          g.setEdge(effV, effW, { ...label, width: 0, height: 0 });
+        }
+      }
+    });
+    const layoutG = buildLayoutGraph(g);
+    const result = runLayout(layoutG, time2, opts, (_a = previousLayouts.get(g)) != null ? _a : null);
+    previousLayouts.set(g, result);
+    updateInputGraph(g, layoutG);
+    proxyEdgeKeys.forEach((key) => {
+      const sep2 = key.indexOf("\0");
+      const effV = key.slice(0, sep2);
+      const effW = key.slice(sep2 + 1);
+      if (g.hasEdge(effV, effW)) g.removeEdge(effV, effW);
+    });
+    isolatedClusters.forEach(({ clusterId, subgraph, bounds, removedNodes, removedEdges }) => {
+      var _a2, _b;
+      const clusterNode = g.node(clusterId);
+      const clusterX = (_a2 = clusterNode == null ? void 0 : clusterNode.x) != null ? _a2 : 0;
+      const clusterY = (_b = clusterNode == null ? void 0 : clusterNode.y) != null ? _b : 0;
+      const subgraphCenterX = (bounds.minX + bounds.maxX) / 2;
+      const subgraphCenterY = (bounds.minY + bounds.maxY) / 2;
+      removedNodes.forEach(({ id, node, parent }) => {
+        g.setNode(id, node);
+        if (parent !== void 0) g.setParent(id, parent);
+      });
+      removedEdges.forEach(({ edge, label }) => {
+        g.setEdge(edge, label);
+      });
+      subgraph.nodes().forEach((u) => {
+        if (u === clusterId) return;
+        const subNode = subgraph.node(u);
+        const mainNode = g.node(u);
+        if (mainNode && subNode && typeof subNode.x === "number" && typeof subNode.y === "number") {
+          mainNode.x = clusterX + (subNode.x - subgraphCenterX);
+          mainNode.y = clusterY + (subNode.y - subgraphCenterY);
+        }
+      });
+      delete clusterNode._dagreClusterSubgraph;
+    });
+    clusterNodes.forEach((v2) => {
+      var _a2, _b;
+      const node = g.node(v2);
+      const bounds = clusterBounds[v2];
+      if (node && node.rankdir && node._dagreClusterSubgraph && bounds) {
+        const subgraph = node._dagreClusterSubgraph;
+        const parentX = (_a2 = node.x) != null ? _a2 : 0;
+        const parentY = (_b = node.y) != null ? _b : 0;
+        const subgraphCenterX = (bounds.minX + bounds.maxX) / 2;
+        const subgraphCenterY = (bounds.minY + bounds.maxY) / 2;
+        subgraph.nodes().forEach((u) => {
+          if (u === v2) return;
+          const subNode = subgraph.node(u);
+          const mainNode = g.node(u);
+          if (mainNode && subNode && typeof subNode.x === "number" && typeof subNode.y === "number") {
+            const dx = subNode.x - subgraphCenterX;
+            const dy = subNode.y - subgraphCenterY;
+            mainNode.x = parentX + dx;
+            mainNode.y = parentY + dy;
+          }
+        });
+        delete node._dagreClusterSubgraph;
+      }
     });
   }
-  function runLayout(g, time2, opts) {
+  function runLayout(g, time2, opts, previous = null) {
+    var _a, _b;
+    const dynamic = (opts == null ? void 0 : opts.useDynamic) !== false;
+    const oldGraph = dynamic ? (_a = previous == null ? void 0 : previous.graph) != null ? _a : null : null;
+    const rawOldNodes = dynamic ? (_b = previous == null ? void 0 : previous.rawNodes) != null ? _b : null : null;
     time2("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
     time2("    removeSelfEdges", () => removeSelfEdges(g));
-    time2("    acyclic", () => run(g));
+    time2("    acyclic", () => run(g, oldGraph));
     time2("    nestingGraph.run", () => run3(g));
     time2("    rank", () => rank_default(asNonCompoundGraph(g)));
     time2("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
@@ -2386,11 +2817,12 @@ var dagre = (() => {
     time2("    normalize.run", () => run2(g));
     time2("    parentDummyChains", () => parent_dummy_chains_default(g));
     time2("    addBorderSegments", () => add_border_segments_default(g));
-    time2("    order", () => order(g, opts));
+    time2("    order", () => order(g, opts, rawOldNodes));
     time2("    insertSelfEdges", () => insertSelfEdges(g));
     time2("    adjustCoordinateSystem", () => adjust(g));
-    time2("    position", () => position(g));
+    time2("    position", () => position(g, opts.corePath));
     time2("    positionSelfEdges", () => positionSelfEdges(g));
+    const rawNodes = JSON.parse(JSON.stringify(g._nodes));
     time2("    removeBorderNodes", () => removeBorderNodes(g));
     time2("    normalize.undo", () => undo2(g));
     time2("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
@@ -2399,6 +2831,7 @@ var dagre = (() => {
     time2("    assignNodeIntersects", () => assignNodeIntersects(g));
     time2("    reversePoints", () => reversePointsForReversedEdges(g));
     time2("    acyclic.undo", () => undo(g));
+    return { graph: g, rawNodes };
   }
   function updateInputGraph(inputGraph, layoutGraph) {
     inputGraph.nodes().forEach((v2) => {
@@ -2443,7 +2876,7 @@ var dagre = (() => {
   };
   var edgeAttrs = ["labelpos"];
   function buildLayoutGraph(inputGraph) {
-    const g = new p({ multigraph: true, compound: true });
+    const g = new Graph({ multigraph: true, compound: true });
     const graph = canonicalize(inputGraph.graph());
     g.setGraph(Object.assign(
       {},
@@ -2480,9 +2913,10 @@ var dagre = (() => {
     const graph = g.graph();
     graph.ranksep /= 2;
     g.edges().forEach((e) => {
+      var _a;
       const edge = g.edge(e);
       edge.minlen *= 2;
-      if (edge.labelpos.toLowerCase() !== "c") {
+      if (((_a = edge.labelpos) != null ? _a : "r").toLowerCase() !== "c") {
         if (graph.rankdir === "TB" || graph.rankdir === "BT") {
           edge.width += edge.labeloffset;
         } else {
@@ -2574,6 +3008,7 @@ var dagre = (() => {
   }
   function assignNodeIntersects(g) {
     g.edges().forEach((e) => {
+      if (e.v === e.w) return;
       const edge = g.edge(e);
       const nodeV = g.node(e.v);
       const nodeW = g.node(e.w);
@@ -2654,6 +3089,7 @@ var dagre = (() => {
       let orderShift = 0;
       layer.forEach((v2, i) => {
         const node = g.node(v2);
+        if (typeof node.rank !== "number") node.rank = 0;
         node.order = i + orderShift;
         (node.selfEdges || []).forEach((selfEdge) => {
           addDummyNode(g, "selfedge", {
@@ -2662,8 +3098,19 @@ var dagre = (() => {
             rank: node.rank,
             order: i + ++orderShift,
             e: selfEdge.e,
-            label: selfEdge.label
+            edgeLabel: selfEdge.label
           }, "_se");
+          if (!Array.isArray(selfEdge.label.points) || selfEdge.label.points.length !== 7) {
+            selfEdge.label.points = [
+              { x: 0, y: -10 },
+              { x: 0, y: -10 },
+              { x: 0, y: 0 },
+              { x: 0, y: 10 },
+              { x: 0, y: 10 },
+              { x: 0, y: 0 },
+              { x: 0, y: 0 }
+            ];
+          }
         });
         delete node.selfEdges;
       });
@@ -2672,24 +3119,51 @@ var dagre = (() => {
   function positionSelfEdges(g) {
     g.nodes().forEach((v2) => {
       const node = g.node(v2);
+      const valid = (val) => typeof val === "number" && isFinite(val);
       if (node.dummy === "selfedge") {
         const selfEdgeNode = node;
         const selfNode = g.node(selfEdgeNode.e.v);
-        const x2 = selfNode.x + selfNode.width / 2;
-        const y2 = selfNode.y;
-        const dx = node.x - x2;
-        const dy = selfNode.height / 2;
-        g.setEdge(selfEdgeNode.e, selfEdgeNode.label);
-        g.removeNode(v2);
-        selfEdgeNode.label.points = [
-          { x: x2 + 2 * dx / 3, y: y2 - dy },
-          { x: x2 + 5 * dx / 6, y: y2 - dy },
-          { x: x2 + dx, y: y2 },
-          { x: x2 + 5 * dx / 6, y: y2 + dy },
-          { x: x2 + 2 * dx / 3, y: y2 + dy }
+        const xVal = valid(selfNode == null ? void 0 : selfNode.x) ? selfNode.x : 0;
+        const yVal = valid(selfNode == null ? void 0 : selfNode.y) ? selfNode.y : 0;
+        const widthVal = valid(selfNode == null ? void 0 : selfNode.width) ? selfNode.width : 0;
+        const heightVal = valid(selfNode == null ? void 0 : selfNode.height) ? selfNode.height : 0;
+        const nodeX = valid(node.x) ? node.x : xVal;
+        const nodeY = valid(node.y) ? node.y : yVal;
+        const dx = widthVal / 2;
+        const dy = heightVal / 2;
+        selfEdgeNode.edgeLabel.points = [
+          { x: nodeX + dx, y: nodeY - dy },
+          { x: nodeX + dx, y: nodeY - dy },
+          { x: nodeX, y: nodeY },
+          { x: nodeX - dx, y: nodeY + dy },
+          { x: nodeX - dx, y: nodeY + dy },
+          { x: nodeX, y: nodeY },
+          { x: nodeX, y: nodeY }
         ];
-        selfEdgeNode.label.x = node.x;
-        selfEdgeNode.label.y = node.y;
+        selfEdgeNode.edgeLabel.x = nodeX;
+        selfEdgeNode.edgeLabel.y = nodeY;
+        g.setEdge(selfEdgeNode.e, selfEdgeNode.edgeLabel);
+        g.removeNode(v2);
+      } else if (node && Array.isArray(node.selfEdges)) {
+        node.selfEdges.forEach((selfEdge) => {
+          if (!Array.isArray(selfEdge.label.points) || selfEdge.label.points.length !== 7) {
+            const xVal = valid(node.x) ? node.x : 0;
+            const yVal = valid(node.y) ? node.y : 0;
+            const widthVal = valid(node.width) ? node.width : 0;
+            const heightVal = valid(node.height) ? node.height : 0;
+            const dx = widthVal / 2;
+            const dy = heightVal / 2;
+            selfEdge.label.points = [
+              { x: xVal + dx, y: yVal - dy },
+              { x: xVal + dx, y: yVal - dy },
+              { x: xVal, y: yVal },
+              { x: xVal - dx, y: yVal + dy },
+              { x: xVal - dx, y: yVal + dy },
+              { x: xVal, y: yVal },
+              { x: xVal, y: yVal }
+            ];
+          }
+        });
       }
     });
   }
@@ -2712,7 +3186,7 @@ var dagre = (() => {
   // lib/debug.ts
   function debugOrdering(graph) {
     const layerMatrix = buildLayerMatrix(graph);
-    const h = new p({ compound: true, multigraph: true }).setGraph({});
+    const h = new Graph({ compound: true, multigraph: true }).setGraph({});
     graph.nodes().forEach((node) => {
       h.setNode(node, { label: node });
       h.setParent(node, "layer" + graph.node(node).rank);
@@ -2732,7 +3206,7 @@ var dagre = (() => {
   // index.ts
   var util = { time, notime };
   var dagre = {
-    graphlib: graphlib_esm_exports,
+    graphlib: graph_lib_exports,
     version,
     layout,
     debug: debugOrdering,