@loopstack/loopstack-studio 0.20.3 → 0.21.0-rc.0

package/dist/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js

@@ -0,0 +1,43 @@
+import flatten_default from "../../../../lodash-es/flatten.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import filter_default from "../../../../lodash-es/filter.js";
+import isUndefined_default from "../../../../lodash-es/isUndefined.js";
+import { barycenter } from "./barycenter.js";
+import { resolveConflicts } from "./resolve-conflicts.js";
+import { sort } from "./sort.js";
+function sortSubgraph(l, u, d, f) {
+	var p = l.children(u), m = l.node(u), h = m ? m.borderLeft : void 0, g = m ? m.borderRight : void 0, _ = {};
+	h && (p = filter_default(p, function(e) {
+		return e !== h && e !== g;
+	}));
+	var v = barycenter(l, p);
+	forEach_default(v, function(e) {
+		if (l.children(e.v).length) {
+			var s = sortSubgraph(l, e.v, d, f);
+			_[e.v] = s, Object.prototype.hasOwnProperty.call(s, "barycenter") && mergeBarycenters(e, s);
+		}
+	});
+	var y = resolveConflicts(v, d);
+	expandSubgraphs(y, _);
+	var b = sort(y, f);
+	if (h && (b.vs = flatten_default([
+		h,
+		b.vs,
+		g
+	]), l.predecessors(h).length)) {
+		var x = l.node(l.predecessors(h)[0]), S = l.node(l.predecessors(g)[0]);
+		Object.prototype.hasOwnProperty.call(b, "barycenter") || (b.barycenter = 0, b.weight = 0), b.barycenter = (b.barycenter * b.weight + x.order + S.order) / (b.weight + 2), b.weight += 2;
+	}
+	return b;
+}
+function expandSubgraphs(c, l) {
+	forEach_default(c, function(s) {
+		s.vs = flatten_default(s.vs.map(function(e) {
+			return l[e] ? l[e].vs : e;
+		}));
+	});
+}
+function mergeBarycenters(e, s) {
+	isUndefined_default(e.barycenter) ? (e.barycenter = s.barycenter, e.weight = s.weight) : (e.barycenter = (e.barycenter * e.weight + s.barycenter * s.weight) / (e.weight + s.weight), e.weight += s.weight);
+}
+export { sortSubgraph };

package/dist/node_modules/dagre-d3-es/src/dagre/order/sort.js

@@ -0,0 +1,27 @@
+import flatten_default from "../../../../lodash-es/flatten.js";
+import last_default from "../../../../lodash-es/last.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import sortBy_default from "../../../../lodash-es/sortBy.js";
+import { partition } from "../util.js";
+function sort(r, s) {
+	var c = partition(r, function(e) {
+		return Object.prototype.hasOwnProperty.call(e, "barycenter");
+	}), l = c.lhs, u = sortBy_default(c.rhs, function(e) {
+		return -e.i;
+	}), d = [], f = 0, p = 0, m = 0;
+	l.sort(compareWithBias(!!s)), m = consumeUnsortable(d, u, m), forEach_default(l, function(e) {
+		m += e.vs.length, d.push(e.vs), f += e.barycenter * e.weight, p += e.weight, m = consumeUnsortable(d, u, m);
+	});
+	var h = { vs: flatten_default(d) };
+	return p && (h.barycenter = f / p, h.weight = p), h;
+}
+function consumeUnsortable(e, i, a) {
+	for (var o; i.length && (o = last_default(i)).i <= a;) i.pop(), e.push(o.vs), a++;
+	return a;
+}
+function compareWithBias(e) {
+	return function(r, i) {
+		return r.barycenter < i.barycenter ? -1 : r.barycenter > i.barycenter ? 1 : e ? i.i - r.i : r.i - i.i;
+	};
+}
+export { sort };

package/dist/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js

@@ -0,0 +1,40 @@
+import forEach_default from "../../../lodash-es/forEach.js";
+function parentDummyChains(t) {
+	var i = postorder(t);
+	forEach_default(t.graph().dummyChains, function(e) {
+		for (var r = t.node(e), a = r.edgeObj, o = findPath(t, i, a.v, a.w), s = o.path, c = o.lca, l = 0, u = s[l], d = !0; e !== a.w;) {
+			if (r = t.node(e), d) {
+				for (; (u = s[l]) !== c && t.node(u).maxRank < r.rank;) l++;
+				u === c && (d = !1);
+			}
+			if (!d) {
+				for (; l < s.length - 1 && t.node(u = s[l + 1]).minRank <= r.rank;) l++;
+				u = s[l];
+			}
+			t.setParent(e, u), e = t.successors(e)[0];
+		}
+	});
+}
+function findPath(e, t, n, r) {
+	var i = [], a = [], o = Math.min(t[n].low, t[r].low), s = Math.max(t[n].lim, t[r].lim), c = n, l;
+	do
+		c = e.parent(c), i.push(c);
+	while (c && (t[c].low > o || s > t[c].lim));
+	for (l = c, c = r; (c = e.parent(c)) !== l;) a.push(c);
+	return {
+		path: i.concat(a.reverse()),
+		lca: l
+	};
+}
+function postorder(t) {
+	var n = {}, r = 0;
+	function i(a) {
+		var o = r;
+		forEach_default(t.children(a), i), n[a] = {
+			low: o,
+			lim: r++
+		};
+	}
+	return forEach_default(t.children(), i), n;
+}
+export { parentDummyChains };

package/dist/node_modules/dagre-d3-es/src/dagre/position/bk.js

@@ -0,0 +1,216 @@
+import merge_default from "../../../../lodash-es/merge.js";
+import last_default from "../../../../lodash-es/last.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import find_default from "../../../../lodash-es/find.js";
+import map_default from "../../../../lodash-es/map.js";
+import forIn_default from "../../../../lodash-es/forIn.js";
+import values_default from "../../../../lodash-es/values.js";
+import mapValues_default from "../../../../lodash-es/mapValues.js";
+import max_default from "../../../../lodash-es/max.js";
+import min_default from "../../../../lodash-es/min.js";
+import minBy_default from "../../../../lodash-es/minBy.js";
+import range_default from "../../../../lodash-es/range.js";
+import reduce_default from "../../../../lodash-es/reduce.js";
+import sortBy_default from "../../../../lodash-es/sortBy.js";
+import { Graph } from "../../graphlib/graph.js";
+import "../../graphlib/index.js";
+import { buildLayerMatrix } from "../util.js";
+function findType1Conflicts(e, y) {
+	var b = {};
+	function x(y, x) {
+		var S = 0, C = 0, w = y.length, T = last_default(x);
+		return forEach_default(x, function(_, y) {
+			var E = findOtherInnerSegmentNode(e, _), D = E ? e.node(E).order : w;
+			(E || _ === T) && (forEach_default(x.slice(C, y + 1), function(_) {
+				forEach_default(e.predecessors(_), function(v) {
+					var y = e.node(v), x = y.order;
+					(x < S || D < x) && !(y.dummy && e.node(_).dummy) && addConflict(b, v, _);
+				});
+			}), C = y + 1, S = D);
+		}), x;
+	}
+	return reduce_default(y, x), b;
+}
+function findType2Conflicts(e, _) {
+	var y = {};
+	function b(_, b, x, S, C) {
+		var w;
+		forEach_default(range_default(b, x), function(b) {
+			w = _[b], e.node(w).dummy && forEach_default(e.predecessors(w), function(_) {
+				var v = e.node(_);
+				v.dummy && (v.order < S || v.order > C) && addConflict(y, _, w);
+			});
+		});
+	}
+	function x(_, y) {
+		var x = -1, S, C = 0;
+		return forEach_default(y, function(v, w) {
+			if (e.node(v).dummy === "border") {
+				var T = e.predecessors(v);
+				T.length && (S = e.node(T[0]).order, b(y, C, w, x, S), C = w, x = S);
+			}
+			b(y, C, y.length, S, _.length);
+		}), y;
+	}
+	return reduce_default(_, x), y;
+}
+function findOtherInnerSegmentNode(e, _) {
+	if (e.node(_).dummy) return find_default(e.predecessors(_), function(_) {
+		return e.node(_).dummy;
+	});
+}
+function addConflict(e, _, v) {
+	if (_ > v) {
+		var y = _;
+		_ = v, v = y;
+	}
+	Object.prototype.hasOwnProperty.call(e, _) || Object.defineProperty(e, _, {
+		enumerable: !0,
+		configurable: !0,
+		value: {},
+		writable: !0
+	});
+	var b = e[_];
+	Object.defineProperty(b, v, {
+		enumerable: !0,
+		configurable: !0,
+		value: !0,
+		writable: !0
+	});
+}
+function hasConflict(e, _, v) {
+	if (_ > v) {
+		var y = _;
+		_ = v, v = y;
+	}
+	return !!e[_] && Object.prototype.hasOwnProperty.call(e[_], v);
+}
+function verticalAlignment(e, _, y, b) {
+	var x = {}, S = {}, C = {};
+	return forEach_default(_, function(e) {
+		forEach_default(e, function(e, _) {
+			x[e] = e, S[e] = e, C[e] = _;
+		});
+	}), forEach_default(_, function(e) {
+		var _ = -1;
+		forEach_default(e, function(e) {
+			var v = b(e);
+			if (v.length) {
+				v = sortBy_default(v, function(e) {
+					return C[e];
+				});
+				for (var w = (v.length - 1) / 2, T = Math.floor(w), E = Math.ceil(w); T <= E; ++T) {
+					var D = v[T];
+					S[e] === e && _ < C[D] && !hasConflict(y, e, D) && (S[D] = e, S[e] = x[e] = x[D], _ = C[D]);
+				}
+			}
+		});
+	}), {
+		root: x,
+		align: S
+	};
+}
+function horizontalCompaction(e, _, y, b, x) {
+	var S = {}, C = buildBlockGraph(e, _, y, x), w = x ? "borderLeft" : "borderRight";
+	function T(e, _) {
+		for (var v = C.nodes(), y = v.pop(), b = {}; y;) b[y] ? e(y) : (b[y] = !0, v.push(y), v = v.concat(_(y))), y = v.pop();
+	}
+	function E(e) {
+		S[e] = C.inEdges(e).reduce(function(e, _) {
+			return Math.max(e, S[_.v] + C.edge(_));
+		}, 0);
+	}
+	function D(_) {
+		var v = C.outEdges(_).reduce(function(e, _) {
+			return Math.min(e, S[_.w] - C.edge(_));
+		}, Infinity), y = e.node(_);
+		v !== Infinity && y.borderType !== w && (S[_] = Math.max(S[_], v));
+	}
+	return T(E, C.predecessors.bind(C)), T(D, C.successors.bind(C)), forEach_default(b, function(e) {
+		S[e] = S[y[e]];
+	}), S;
+}
+function buildBlockGraph(e, _, y, b) {
+	var x = new Graph(), S = e.graph(), C = sep(S.nodesep, S.edgesep, b);
+	return forEach_default(_, function(_) {
+		var b;
+		forEach_default(_, function(_) {
+			var v = y[_];
+			if (x.setNode(v), b) {
+				var S = y[b], w = x.edge(S, v);
+				x.setEdge(S, v, Math.max(C(e, _, b), w || 0));
+			}
+			b = _;
+		});
+	}), x;
+}
+function findSmallestWidthAlignment(e, _) {
+	return minBy_default(values_default(_), function(_) {
+		var v = -Infinity, y = Infinity;
+		return forIn_default(_, function(_, b) {
+			var x = width(e, b) / 2;
+			v = Math.max(_ + x, v), y = Math.min(_ - x, y);
+		}), v - y;
+	});
+}
+function alignCoordinates(e, _) {
+	var y = values_default(_), b = min_default(y), x = max_default(y);
+	forEach_default(["u", "d"], function(y) {
+		forEach_default(["l", "r"], function(v) {
+			var E = y + v, D = e[E], O;
+			if (D !== _) {
+				var k = values_default(D);
+				O = v === "l" ? b - min_default(k) : x - max_default(k), O && (e[E] = mapValues_default(D, function(e) {
+					return e + O;
+				}));
+			}
+		});
+	});
+}
+function balance(e, _) {
+	return mapValues_default(e.ul, function(v, y) {
+		if (_) return e[_.toLowerCase()][y];
+		var x = sortBy_default(map_default(e, y));
+		return (x[1] + x[2]) / 2;
+	});
+}
+function positionX(_) {
+	var y = buildLayerMatrix(_), x = merge_default(findType1Conflicts(_, y), findType2Conflicts(_, y)), w = {}, T;
+	return forEach_default(["u", "d"], function(e) {
+		T = e === "u" ? y : values_default(y).reverse(), forEach_default(["l", "r"], function(v) {
+			v === "r" && (T = map_default(T, function(e) {
+				return values_default(e).reverse();
+			}));
+			var y = (e === "u" ? _.predecessors : _.successors).bind(_), E = verticalAlignment(_, T, x, y), D = horizontalCompaction(_, T, E.root, E.align, v === "r");
+			v === "r" && (D = mapValues_default(D, function(e) {
+				return -e;
+			})), w[e + v] = D;
+		});
+	}), alignCoordinates(w, findSmallestWidthAlignment(_, w)), balance(w, _.graph().align);
+}
+function sep(e, _, v) {
+	return function(y, b, x) {
+		var S = y.node(b), C = y.node(x), w = 0, T;
+		if (w += S.width / 2, Object.prototype.hasOwnProperty.call(S, "labelpos")) switch (S.labelpos.toLowerCase()) {
+			case "l":
+				T = -S.width / 2;
+				break;
+			case "r":
+				T = S.width / 2;
+				break;
+		}
+		if (T && (w += v ? T : -T), T = 0, w += (S.dummy ? _ : e) / 2, w += (C.dummy ? _ : e) / 2, w += C.width / 2, Object.prototype.hasOwnProperty.call(C, "labelpos")) switch (C.labelpos.toLowerCase()) {
+			case "l":
+				T = C.width / 2;
+				break;
+			case "r":
+				T = -C.width / 2;
+				break;
+		}
+		return T && (w += v ? T : -T), T = 0, w;
+	};
+}
+function width(e, _) {
+	return e.node(_).width;
+}
+export { positionX };

package/dist/node_modules/dagre-d3-es/src/dagre/position/index.js

@@ -0,0 +1,23 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import map_default from "../../../../lodash-es/map.js";
+import forOwn_default from "../../../../lodash-es/forOwn.js";
+import max_default from "../../../../lodash-es/max.js";
+import { asNonCompoundGraph, buildLayerMatrix } from "../util.js";
+import { positionX } from "./bk.js";
+function position(e) {
+	e = asNonCompoundGraph(e), positionY(e), forOwn_default(positionX(e), function(r, i) {
+		e.node(i).x = r;
+	});
+}
+function positionY(i) {
+	var a = buildLayerMatrix(i), s = i.graph().ranksep, c = 0;
+	forEach_default(a, function(a) {
+		var o = max_default(map_default(a, function(e) {
+			return i.node(e).height;
+		}));
+		forEach_default(a, function(e) {
+			i.node(e).y = c + o / 2;
+		}), c += o + s;
+	});
+}
+export { position };

package/dist/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js

@@ -0,0 +1,31 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import minBy_default from "../../../../lodash-es/minBy.js";
+import { Graph } from "../../graphlib/graph.js";
+import "../../graphlib/index.js";
+import { slack } from "./util.js";
+function feasibleTree(e) {
+	var t = new Graph({ directed: !1 }), i = e.nodes()[0], c = e.nodeCount();
+	t.setNode(i, {});
+	for (var l, u; tightTree(t, e) < c;) l = findMinSlackEdge(t, e), u = t.hasNode(l.v) ? slack(e, l) : -slack(e, l), shiftRanks(t, e, u);
+	return t;
+}
+function tightTree(t, n) {
+	function i(a) {
+		forEach_default(n.nodeEdges(a), function(e) {
+			var o = e.v, s = a === o ? e.w : o;
+			!t.hasNode(s) && !slack(n, e) && (t.setNode(s, {}), t.setEdge(a, s, {}), i(s));
+		});
+	}
+	return forEach_default(t.nodes(), i), t.nodeCount();
+}
+function findMinSlackEdge(e, n) {
+	return minBy_default(n.edges(), function(t) {
+		if (e.hasNode(t.v) !== e.hasNode(t.w)) return slack(n, t);
+	});
+}
+function shiftRanks(t, n, r) {
+	forEach_default(t.nodes(), function(e) {
+		n.node(e).rank += r;
+	});
+}
+export { feasibleTree };

package/dist/node_modules/dagre-d3-es/src/dagre/rank/index.js

@@ -0,0 +1,25 @@
+import { longestPath } from "./util.js";
+import { feasibleTree } from "./feasible-tree.js";
+import { networkSimplex } from "./network-simplex.js";
+function rank(e) {
+	switch (e.graph().ranker) {
+		case "network-simplex":
+			networkSimplexRanker(e);
+			break;
+		case "tight-tree":
+			tightTreeRanker(e);
+			break;
+		case "longest-path":
+			longestPathRanker(e);
+			break;
+		default: networkSimplexRanker(e);
+	}
+}
+var longestPathRanker = longestPath;
+function tightTreeRanker(o) {
+	longestPath(o), feasibleTree(o);
+}
+function networkSimplexRanker(e) {
+	networkSimplex(e);
+}
+export { rank };

package/dist/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js

@@ -0,0 +1,84 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import filter_default from "../../../../lodash-es/filter.js";
+import find_default from "../../../../lodash-es/find.js";
+import minBy_default from "../../../../lodash-es/minBy.js";
+import { simplify } from "../util.js";
+import { longestPath, slack } from "./util.js";
+import { feasibleTree } from "./feasible-tree.js";
+import { postorder } from "../../graphlib/alg/postorder.js";
+import { preorder } from "../../graphlib/alg/preorder.js";
+import "../../graphlib/alg/index.js";
+networkSimplex.initLowLimValues = initLowLimValues, networkSimplex.initCutValues = initCutValues, networkSimplex.calcCutValue = calcCutValue, networkSimplex.leaveEdge = leaveEdge, networkSimplex.enterEdge = enterEdge, networkSimplex.exchangeEdges = exchangeEdges;
+function networkSimplex(e) {
+	e = simplify(e), longestPath(e);
+	var d = feasibleTree(e);
+	initLowLimValues(d), initCutValues(d, e);
+	for (var f, p; f = leaveEdge(d);) p = enterEdge(d, e, f), exchangeEdges(d, e, f, p);
+}
+function initCutValues(d, f) {
+	var p = postorder(d, d.nodes());
+	p = p.slice(0, p.length - 1), forEach_default(p, function(e) {
+		assignCutValue(d, f, e);
+	});
+}
+function assignCutValue(e, d, f) {
+	var p = e.node(f).parent;
+	e.edge(f, p).cutvalue = calcCutValue(e, d, f);
+}
+function calcCutValue(d, f, p) {
+	var m = d.node(p).parent, h = !0, g = f.edge(p, m), _ = 0;
+	return g ||= (h = !1, f.edge(m, p)), _ = g.weight, forEach_default(f.nodeEdges(p), function(e) {
+		var g = e.v === p, v = g ? e.w : e.v;
+		if (v !== m) {
+			var y = g === h, b = f.edge(e).weight;
+			if (_ += y ? b : -b, isTreeEdge(d, p, v)) {
+				var x = d.edge(p, v).cutvalue;
+				_ += y ? -x : x;
+			}
+		}
+	}), _;
+}
+function initLowLimValues(e, d) {
+	arguments.length < 2 && (d = e.nodes()[0]), dfsAssignLowLim(e, {}, 1, d);
+}
+function dfsAssignLowLim(d, f, p, m, h) {
+	var g = p, _ = d.node(m);
+	return f[m] = !0, forEach_default(d.neighbors(m), function(e) {
+		Object.prototype.hasOwnProperty.call(f, e) || (p = dfsAssignLowLim(d, f, p, e, m));
+	}), _.low = g, _.lim = p++, h ? _.parent = h : delete _.parent, p;
+}
+function leaveEdge(e) {
+	return find_default(e.edges(), function(d) {
+		return e.edge(d).cutvalue < 0;
+	});
+}
+function enterEdge(e, f, m) {
+	var h = m.v, _ = m.w;
+	f.hasEdge(h, _) || (h = m.w, _ = m.v);
+	var v = e.node(h), y = e.node(_), b = v, x = !1;
+	return v.lim > y.lim && (b = y, x = !0), minBy_default(filter_default(f.edges(), function(d) {
+		return x === isDescendant(e, e.node(d.v), b) && x !== isDescendant(e, e.node(d.w), b);
+	}), function(e) {
+		return slack(f, e);
+	});
+}
+function exchangeEdges(e, d, f, p) {
+	var m = f.v, h = f.w;
+	e.removeEdge(m, h), e.setEdge(p.v, p.w, {}), initLowLimValues(e), initCutValues(e, d), updateRanks(e, d);
+}
+function updateRanks(d, p) {
+	var m = preorder(d, find_default(d.nodes(), function(e) {
+		return !p.node(e).parent;
+	}));
+	m = m.slice(1), forEach_default(m, function(e) {
+		var f = d.node(e).parent, m = p.edge(e, f), h = !1;
+		m || (m = p.edge(f, e), h = !0), p.node(e).rank = p.node(f).rank + (h ? m.minlen : -m.minlen);
+	});
+}
+function isTreeEdge(e, d, f) {
+	return e.hasEdge(d, f);
+}
+function isDescendant(e, d, f) {
+	return f.low <= d.lim && d.lim <= f.lim;
+}
+export { networkSimplex };

package/dist/node_modules/dagre-d3-es/src/dagre/rank/util.js

@@ -0,0 +1,20 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import map_default from "../../../../lodash-es/map.js";
+import min_default from "../../../../lodash-es/min.js";
+function longestPath(r) {
+	var i = {};
+	function a(e) {
+		var o = r.node(e);
+		if (Object.prototype.hasOwnProperty.call(i, e)) return o.rank;
+		i[e] = !0;
+		var s = min_default(map_default(r.outEdges(e), function(e) {
+			return a(e.w) - r.edge(e).minlen;
+		}));
+		return (s === Infinity || s == null) && (s = 0), o.rank = s;
+	}
+	forEach_default(r.sources(), a);
+}
+function slack(e, n) {
+	return e.node(n.w).rank - e.node(n.v).rank - e.edge(n).minlen;
+}
+export { longestPath, slack };

package/dist/node_modules/dagre-d3-es/src/dagre/util.js

@@ -0,0 +1,117 @@
+import now_default from "../../../lodash-es/now.js";
+import forEach_default from "../../../lodash-es/forEach.js";
+import map_default from "../../../lodash-es/map.js";
+import has_default from "../../../lodash-es/has.js";
+import isUndefined_default from "../../../lodash-es/isUndefined.js";
+import max_default from "../../../lodash-es/max.js";
+import min_default from "../../../lodash-es/min.js";
+import range_default from "../../../lodash-es/range.js";
+import uniqueId_default from "../../../lodash-es/uniqueId.js";
+import { Graph } from "../graphlib/graph.js";
+import "../graphlib/index.js";
+function addDummyNode(e, p, m, h) {
+	var g;
+	do
+		g = uniqueId_default(h);
+	while (e.hasNode(g));
+	return m.dummy = p, e.setNode(g, m), g;
+}
+function simplify(e) {
+	var m = new Graph().setGraph(e.graph());
+	return forEach_default(e.nodes(), function(p) {
+		m.setNode(p, e.node(p));
+	}), forEach_default(e.edges(), function(p) {
+		var h = m.edge(p.v, p.w) || {
+			weight: 0,
+			minlen: 1
+		}, g = e.edge(p);
+		m.setEdge(p.v, p.w, {
+			weight: h.weight + g.weight,
+			minlen: Math.max(h.minlen, g.minlen)
+		});
+	}), m;
+}
+function asNonCompoundGraph(e) {
+	var m = new Graph({ multigraph: e.isMultigraph() }).setGraph(e.graph());
+	return forEach_default(e.nodes(), function(p) {
+		e.children(p).length || m.setNode(p, e.node(p));
+	}), forEach_default(e.edges(), function(p) {
+		m.setEdge(p, e.edge(p));
+	}), m;
+}
+function intersectRect(e, p) {
+	var m = e.x, h = e.y, g = p.x - m, _ = p.y - h, v = e.width / 2, y = e.height / 2;
+	if (!g && !_) throw Error("Not possible to find intersection inside of the rectangle");
+	var b, x;
+	return Math.abs(_) * v > Math.abs(g) * y ? (_ < 0 && (y = -y), b = y * g / _, x = y) : (g < 0 && (v = -v), b = v, x = v * _ / g), {
+		x: m + b,
+		y: h + x
+	};
+}
+function buildLayerMatrix(e) {
+	var h = map_default(range_default(maxRank(e) + 1), function() {
+		return [];
+	});
+	return forEach_default(e.nodes(), function(p) {
+		var m = e.node(p), _ = m.rank;
+		isUndefined_default(_) || (h[_][m.order] = p);
+	}), h;
+}
+function normalizeRanks(e) {
+	var g = min_default(map_default(e.nodes(), function(p) {
+		return e.node(p).rank;
+	}));
+	forEach_default(e.nodes(), function(p) {
+		var m = e.node(p);
+		has_default(m, "rank") && (m.rank -= g);
+	});
+}
+function removeEmptyRanks(e) {
+	var h = min_default(map_default(e.nodes(), function(p) {
+		return e.node(p).rank;
+	})), _ = [];
+	forEach_default(e.nodes(), function(p) {
+		var m = e.node(p).rank - h;
+		_[m] || (_[m] = []), _[m].push(p);
+	});
+	var y = 0, b = e.graph().nodeRankFactor;
+	forEach_default(_, function(m, h) {
+		isUndefined_default(m) && h % b !== 0 ? --y : y && forEach_default(m, function(p) {
+			e.node(p).rank += y;
+		});
+	});
+}
+function addBorderNode(e, p, m, h) {
+	var g = {
+		width: 0,
+		height: 0
+	};
+	return arguments.length >= 4 && (g.rank = m, g.order = h), addDummyNode(e, "border", g, p);
+}
+function maxRank(e) {
+	return max_default(map_default(e.nodes(), function(p) {
+		var m = e.node(p).rank;
+		if (!isUndefined_default(m)) return m;
+	}));
+}
+function partition(e, m) {
+	var h = {
+		lhs: [],
+		rhs: []
+	};
+	return forEach_default(e, function(e) {
+		m(e) ? h.lhs.push(e) : h.rhs.push(e);
+	}), h;
+}
+function time(p, m) {
+	var h = now_default();
+	try {
+		return m();
+	} finally {
+		console.log(p + " time: " + (now_default() - h) + "ms");
+	}
+}
+function notime(e, p) {
+	return p();
+}
+export { addBorderNode, addDummyNode, asNonCompoundGraph, buildLayerMatrix, intersectRect, maxRank, normalizeRanks, notime, partition, removeEmptyRanks, simplify, time };

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/dfs.js

@@ -0,0 +1,16 @@
+import isArray_default from "../../../../lodash-es/isArray.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+function dfs(r, i, a) {
+	isArray_default(i) || (i = [i]);
+	var o = (r.isDirected() ? r.successors : r.neighbors).bind(r), s = [], c = {};
+	return forEach_default(i, function(e) {
+		if (!r.hasNode(e)) throw Error("Graph does not have node: " + e);
+		doDfs(r, e, a === "post", c, o, s);
+	}), s;
+}
+function doDfs(e, r, i, a, o, s) {
+	Object.prototype.hasOwnProperty.call(a, r) || (a[r] = !0, i || s.push(r), forEach_default(o(r), function(n) {
+		doDfs(e, n, i, a, o, s);
+	}), i && s.push(r));
+}
+export { dfs };

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra-all.js

@@ -0,0 +1 @@
+import "./dijkstra.js";

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra.js

@@ -0,0 +1,2 @@
+import constant_default from "../../../../lodash-es/constant.js";
+constant_default(1);

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/floyd-warshall.js

@@ -0,0 +1,2 @@
+import constant_default from "../../../../lodash-es/constant.js";
+constant_default(1);

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/index.js

@@ -0,0 +1,8 @@
+import "./dijkstra.js";
+import "./dijkstra-all.js";
+import "./floyd-warshall.js";
+import { topsort } from "./topsort.js";
+import "./is-acyclic.js";
+import { postorder } from "./postorder.js";
+import { preorder } from "./preorder.js";
+import "./prim.js";

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/is-acyclic.js

@@ -0,0 +1 @@
+import "./topsort.js";

package/dist/node_modules/dagre-d3-es/src/graphlib/alg/postorder.js

@@ -0,0 +1,5 @@
+import { dfs } from "./dfs.js";
+function postorder(t, n) {
+	return dfs(t, n, "post");
+}
+export { postorder };