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

package/dist/node_modules/dagre-d3-es/src/dagre/greedy-fas.js

@@ -0,0 +1,69 @@
+import constant_default from "../../../lodash-es/constant.js";
+import flatten_default from "../../../lodash-es/flatten.js";
+import forEach_default from "../../../lodash-es/forEach.js";
+import map_default from "../../../lodash-es/map.js";
+import range_default from "../../../lodash-es/range.js";
+import { Graph } from "../graphlib/graph.js";
+import "../graphlib/index.js";
+import { List } from "./data/list.js";
+var DEFAULT_WEIGHT_FN = constant_default(1);
+function greedyFAS(e, i) {
+	if (e.nodeCount() <= 1) return [];
+	var o = buildState(e, i || DEFAULT_WEIGHT_FN);
+	return flatten_default(map_default(doGreedyFAS(o.graph, o.buckets, o.zeroIdx), function(r) {
+		return e.outEdges(r.v, r.w);
+	}));
+}
+function doGreedyFAS(e, r, i) {
+	for (var a = [], o = r[r.length - 1], s = r[0], c; e.nodeCount();) {
+		for (; c = s.dequeue();) removeNode(e, r, i, c);
+		for (; c = o.dequeue();) removeNode(e, r, i, c);
+		if (e.nodeCount()) {
+			for (var l = r.length - 2; l > 0; --l) if (c = r[l].dequeue(), c) {
+				a = a.concat(removeNode(e, r, i, c, !0));
+				break;
+			}
+		}
+	}
+	return a;
+}
+function removeNode(e, r, a, o, s) {
+	var c = s ? [] : void 0;
+	return forEach_default(e.inEdges(o.v), function(i) {
+		var o = e.edge(i), l = e.node(i.v);
+		s && c.push({
+			v: i.v,
+			w: i.w
+		}), l.out -= o, assignBucket(r, a, l);
+	}), forEach_default(e.outEdges(o.v), function(i) {
+		var o = e.edge(i), s = i.w, c = e.node(s);
+		c.in -= o, assignBucket(r, a, c);
+	}), e.removeNode(o.v), c;
+}
+function buildState(e, r) {
+	var a = new Graph(), l = 0, u = 0;
+	forEach_default(e.nodes(), function(e) {
+		a.setNode(e, {
+			v: e,
+			in: 0,
+			out: 0
+		});
+	}), forEach_default(e.edges(), function(e) {
+		var i = a.edge(e.v, e.w) || 0, o = r(e), s = i + o;
+		a.setEdge(e.v, e.w, s), u = Math.max(u, a.node(e.v).out += o), l = Math.max(l, a.node(e.w).in += o);
+	});
+	var d = range_default(u + l + 3).map(function() {
+		return new List();
+	}), f = l + 1;
+	return forEach_default(a.nodes(), function(e) {
+		assignBucket(d, f, a.node(e));
+	}), {
+		graph: a,
+		buckets: d,
+		zeroIdx: f
+	};
+}
+function assignBucket(e, r, i) {
+	i.out ? i.in ? e[i.out - i.in + r].enqueue(i) : e[e.length - 1].enqueue(i) : e[0].enqueue(i);
+}
+export { greedyFAS };

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

@@ -0,0 +1,4 @@
+import "./acyclic.js";
+import "./normalize.js";
+import { rank } from "./rank/index.js";
+import { layout } from "./layout.js";

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

@@ -0,0 +1,241 @@
+import merge_default from "../../../lodash-es/merge.js";
+import defaults_default from "../../../lodash-es/defaults.js";
+import last_default from "../../../lodash-es/last.js";
+import forEach_default from "../../../lodash-es/forEach.js";
+import mapValues_default from "../../../lodash-es/mapValues.js";
+import max_default from "../../../lodash-es/max.js";
+import pick_default from "../../../lodash-es/pick.js";
+import { Graph } from "../graphlib/graph.js";
+import "../graphlib/index.js";
+import { run, undo } from "./acyclic.js";
+import { addDummyNode, asNonCompoundGraph, buildLayerMatrix, intersectRect, normalizeRanks, notime, removeEmptyRanks, time } from "./util.js";
+import { addBorderSegments } from "./add-border-segments.js";
+import { adjust, undo as undo$1 } from "./coordinate-system.js";
+import { run as run$1, undo as undo$2 } from "./normalize.js";
+import { rank } from "./rank/index.js";
+import { cleanup, run as run$2 } from "./nesting-graph.js";
+import { order } from "./order/index.js";
+import { parentDummyChains } from "./parent-dummy-chains.js";
+import { position } from "./position/index.js";
+function layout(g, G) {
+	var K = G && G.debugTiming ? time : notime;
+	K("layout", () => {
+		var G = K("  buildLayoutGraph", () => buildLayoutGraph(g));
+		K("  runLayout", () => runLayout(G, K)), K("  updateInputGraph", () => updateInputGraph(g, G));
+	});
+}
+function runLayout(g, G) {
+	G("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g)), G("    removeSelfEdges", () => removeSelfEdges(g)), G("    acyclic", () => run(g)), G("    nestingGraph.run", () => run$2(g)), G("    rank", () => rank(asNonCompoundGraph(g))), G("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g)), G("    removeEmptyRanks", () => removeEmptyRanks(g)), G("    nestingGraph.cleanup", () => cleanup(g)), G("    normalizeRanks", () => normalizeRanks(g)), G("    assignRankMinMax", () => assignRankMinMax(g)), G("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g)), G("    normalize.run", () => run$1(g)), G("    parentDummyChains", () => parentDummyChains(g)), G("    addBorderSegments", () => addBorderSegments(g)), G("    order", () => order(g)), G("    insertSelfEdges", () => insertSelfEdges(g)), G("    adjustCoordinateSystem", () => adjust(g)), G("    position", () => position(g)), G("    positionSelfEdges", () => positionSelfEdges(g)), G("    removeBorderNodes", () => removeBorderNodes(g)), G("    normalize.undo", () => undo$2(g)), G("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g)), G("    undoCoordinateSystem", () => undo$1(g)), G("    translateGraph", () => translateGraph(g)), G("    assignNodeIntersects", () => assignNodeIntersects(g)), G("    reversePoints", () => reversePointsForReversedEdges(g)), G("    acyclic.undo", () => undo(g));
+}
+function updateInputGraph(g, G) {
+	forEach_default(g.nodes(), function(K) {
+		var q = g.node(K), J = G.node(K);
+		q && (q.x = J.x, q.y = J.y, G.children(K).length && (q.width = J.width, q.height = J.height));
+	}), forEach_default(g.edges(), function(K) {
+		var q = g.edge(K), J = G.edge(K);
+		q.points = J.points, Object.prototype.hasOwnProperty.call(J, "x") && (q.x = J.x, q.y = J.y);
+	}), g.graph().width = G.graph().width, g.graph().height = G.graph().height;
+}
+var graphNumAttrs = [
+	"nodesep",
+	"edgesep",
+	"ranksep",
+	"marginx",
+	"marginy"
+], graphDefaults = {
+	ranksep: 50,
+	edgesep: 20,
+	nodesep: 50,
+	rankdir: "tb"
+}, graphAttrs = [
+	"acyclicer",
+	"ranker",
+	"rankdir",
+	"align"
+], nodeNumAttrs = ["width", "height"], nodeDefaults = {
+	width: 0,
+	height: 0
+}, edgeNumAttrs = [
+	"minlen",
+	"weight",
+	"width",
+	"height",
+	"labeloffset"
+], edgeDefaults = {
+	minlen: 1,
+	weight: 1,
+	width: 0,
+	height: 0,
+	labeloffset: 10,
+	labelpos: "r"
+}, edgeAttrs = ["labelpos"];
+function buildLayoutGraph(K) {
+	var J = new Graph({
+		multigraph: !0,
+		compound: !0
+	}), Y = canonicalize(K.graph());
+	return J.setGraph(merge_default({}, graphDefaults, selectNumberAttrs(Y, graphNumAttrs), pick_default(Y, graphAttrs))), forEach_default(K.nodes(), function(g) {
+		var q = canonicalize(K.node(g));
+		J.setNode(g, defaults_default(selectNumberAttrs(q, nodeNumAttrs), nodeDefaults)), J.setParent(g, K.parent(g));
+	}), forEach_default(K.edges(), function(G) {
+		var q = canonicalize(K.edge(G));
+		J.setEdge(G, merge_default({}, edgeDefaults, selectNumberAttrs(q, edgeNumAttrs), pick_default(q, edgeAttrs)));
+	}), J;
+}
+function makeSpaceForEdgeLabels(g) {
+	var G = g.graph();
+	G.ranksep /= 2, forEach_default(g.edges(), function(K) {
+		var q = g.edge(K);
+		q.minlen *= 2, q.labelpos.toLowerCase() !== "c" && (G.rankdir === "TB" || G.rankdir === "BT" ? q.width += q.labeloffset : q.height += q.labeloffset);
+	});
+}
+function injectEdgeLabelProxies(g) {
+	forEach_default(g.edges(), function(G) {
+		var K = g.edge(G);
+		if (K.width && K.height) {
+			var q = g.node(G.v);
+			addDummyNode(g, "edge-proxy", {
+				rank: (g.node(G.w).rank - q.rank) / 2 + q.rank,
+				e: G
+			}, "_ep");
+		}
+	});
+}
+function assignRankMinMax(g) {
+	var G = 0;
+	forEach_default(g.nodes(), function(K) {
+		var q = g.node(K);
+		q.borderTop && (q.minRank = g.node(q.borderTop).rank, q.maxRank = g.node(q.borderBottom).rank, G = max_default(G, q.maxRank));
+	}), g.graph().maxRank = G;
+}
+function removeEdgeLabelProxies(g) {
+	forEach_default(g.nodes(), function(G) {
+		var K = g.node(G);
+		K.dummy === "edge-proxy" && (g.edge(K.e).labelRank = K.rank, g.removeNode(G));
+	});
+}
+function translateGraph(g) {
+	var G = Infinity, K = 0, J = Infinity, Y = 0, X = g.graph(), Z = X.marginx || 0, Q = X.marginy || 0;
+	function $(g) {
+		var q = g.x, X = g.y, Z = g.width, Q = g.height;
+		G = Math.min(G, q - Z / 2), K = Math.max(K, q + Z / 2), J = Math.min(J, X - Q / 2), Y = Math.max(Y, X + Q / 2);
+	}
+	forEach_default(g.nodes(), function(G) {
+		$(g.node(G));
+	}), forEach_default(g.edges(), function(G) {
+		var K = g.edge(G);
+		Object.prototype.hasOwnProperty.call(K, "x") && $(K);
+	}), G -= Z, J -= Q, forEach_default(g.nodes(), function(K) {
+		var q = g.node(K);
+		q.x -= G, q.y -= J;
+	}), forEach_default(g.edges(), function(K) {
+		var Y = g.edge(K);
+		forEach_default(Y.points, function(g) {
+			g.x -= G, g.y -= J;
+		}), Object.prototype.hasOwnProperty.call(Y, "x") && (Y.x -= G), Object.prototype.hasOwnProperty.call(Y, "y") && (Y.y -= J);
+	}), X.width = K - G + Z, X.height = Y - J + Q;
+}
+function assignNodeIntersects(g) {
+	forEach_default(g.edges(), function(G) {
+		var K = g.edge(G), q = g.node(G.v), J = g.node(G.w), Y, X;
+		K.points ? (Y = K.points[0], X = K.points[K.points.length - 1]) : (K.points = [], Y = J, X = q), K.points.unshift(intersectRect(q, Y)), K.points.push(intersectRect(J, X));
+	});
+}
+function fixupEdgeLabelCoords(g) {
+	forEach_default(g.edges(), function(G) {
+		var K = g.edge(G);
+		if (Object.prototype.hasOwnProperty.call(K, "x")) switch ((K.labelpos === "l" || K.labelpos === "r") && (K.width -= K.labeloffset), K.labelpos) {
+			case "l":
+				K.x -= K.width / 2 + K.labeloffset;
+				break;
+			case "r":
+				K.x += K.width / 2 + K.labeloffset;
+				break;
+		}
+	});
+}
+function reversePointsForReversedEdges(g) {
+	forEach_default(g.edges(), function(G) {
+		var K = g.edge(G);
+		K.reversed && K.points.reverse();
+	});
+}
+function removeBorderNodes(g) {
+	forEach_default(g.nodes(), function(G) {
+		if (g.children(G).length) {
+			var q = g.node(G), J = g.node(q.borderTop), Y = g.node(q.borderBottom), X = g.node(last_default(q.borderLeft)), Z = g.node(last_default(q.borderRight));
+			q.width = Math.abs(Z.x - X.x), q.height = Math.abs(Y.y - J.y), q.x = X.x + q.width / 2, q.y = J.y + q.height / 2;
+		}
+	}), forEach_default(g.nodes(), function(G) {
+		g.node(G).dummy === "border" && g.removeNode(G);
+	});
+}
+function removeSelfEdges(g) {
+	forEach_default(g.edges(), function(G) {
+		if (G.v === G.w) {
+			var K = g.node(G.v);
+			K.selfEdges ||= [], K.selfEdges.push({
+				e: G,
+				label: g.edge(G)
+			}), g.removeEdge(G);
+		}
+	});
+}
+function insertSelfEdges(g) {
+	forEach_default(buildLayerMatrix(g), function(G) {
+		var K = 0;
+		forEach_default(G, function(G, J) {
+			var Y = g.node(G);
+			Y.order = J + K, forEach_default(Y.selfEdges, function(G) {
+				addDummyNode(g, "selfedge", {
+					width: G.label.width,
+					height: G.label.height,
+					rank: Y.rank,
+					order: J + ++K,
+					e: G.e,
+					label: G.label
+				}, "_se");
+			}), delete Y.selfEdges;
+		});
+	});
+}
+function positionSelfEdges(g) {
+	forEach_default(g.nodes(), function(G) {
+		var K = g.node(G);
+		if (K.dummy === "selfedge") {
+			var q = g.node(K.e.v), J = q.x + q.width / 2, Y = q.y, X = K.x - J, Z = q.height / 2;
+			g.setEdge(K.e, K.label), g.removeNode(G), K.label.points = [
+				{
+					x: J + 2 * X / 3,
+					y: Y - Z
+				},
+				{
+					x: J + 5 * X / 6,
+					y: Y - Z
+				},
+				{
+					x: J + X,
+					y: Y
+				},
+				{
+					x: J + 5 * X / 6,
+					y: Y + Z
+				},
+				{
+					x: J + 2 * X / 3,
+					y: Y + Z
+				}
+			], K.label.x = K.x, K.label.y = K.y;
+		}
+	});
+}
+function selectNumberAttrs(g, G) {
+	return mapValues_default(pick_default(g, G), Number);
+}
+function canonicalize(g) {
+	var G = {};
+	return forEach_default(g, function(g, K) {
+		G[K.toLowerCase()] = g;
+	}), G;
+}
+export { layout };

package/dist/node_modules/dagre-d3-es/src/dagre/nesting-graph.js

@@ -0,0 +1,66 @@
+import forEach_default from "../../../lodash-es/forEach.js";
+import values_default from "../../../lodash-es/values.js";
+import max_default from "../../../lodash-es/max.js";
+import reduce_default from "../../../lodash-es/reduce.js";
+import { addBorderNode, addDummyNode } from "./util.js";
+function run(i) {
+	var a = addDummyNode(i, "root", {}, "_root"), s = treeDepths(i), u = max_default(values_default(s)) - 1, d = 2 * u + 1;
+	i.graph().nestingRoot = a, forEach_default(i.edges(), function(e) {
+		i.edge(e).minlen *= d;
+	});
+	var f = sumWeights(i) + 1;
+	forEach_default(i.children(), function(e) {
+		dfs(i, a, d, f, u, s, e);
+	}), i.graph().nodeRankFactor = d;
+}
+function dfs(n, r, i, o, s, c, l) {
+	var u = n.children(l);
+	if (!u.length) {
+		l !== r && n.setEdge(r, l, {
+			weight: 0,
+			minlen: i
+		});
+		return;
+	}
+	var d = addBorderNode(n, "_bt"), f = addBorderNode(n, "_bb"), p = n.node(l);
+	n.setParent(d, l), p.borderTop = d, n.setParent(f, l), p.borderBottom = f, forEach_default(u, function(e) {
+		dfs(n, r, i, o, s, c, e);
+		var a = n.node(e), u = a.borderTop ? a.borderTop : e, p = a.borderBottom ? a.borderBottom : e, m = a.borderTop ? o : 2 * o, h = u === p ? s - c[l] + 1 : 1;
+		n.setEdge(d, u, {
+			weight: m,
+			minlen: h,
+			nestingEdge: !0
+		}), n.setEdge(p, f, {
+			weight: m,
+			minlen: h,
+			nestingEdge: !0
+		});
+	}), n.parent(l) || n.setEdge(r, d, {
+		weight: 0,
+		minlen: s + c[l]
+	});
+}
+function treeDepths(n) {
+	var r = {};
+	function i(a, o) {
+		var s = n.children(a);
+		s && s.length && forEach_default(s, function(e) {
+			i(e, o + 1);
+		}), r[a] = o;
+	}
+	return forEach_default(n.children(), function(e) {
+		i(e, 1);
+	}), r;
+}
+function sumWeights(e) {
+	return reduce_default(e.edges(), function(n, r) {
+		return n + e.edge(r).weight;
+	}, 0);
+}
+function cleanup(n) {
+	var r = n.graph();
+	n.removeNode(r.nestingRoot), delete r.nestingRoot, forEach_default(n.edges(), function(e) {
+		n.edge(e).nestingEdge && n.removeEdge(e);
+	});
+}
+export { cleanup, run };

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

@@ -0,0 +1,32 @@
+import forEach_default from "../../../lodash-es/forEach.js";
+import { addDummyNode } from "./util.js";
+function run(t) {
+	t.graph().dummyChains = [], forEach_default(t.edges(), function(e) {
+		normalizeEdge(t, e);
+	});
+}
+function normalizeEdge(e, n) {
+	var r = n.v, i = e.node(r).rank, a = n.w, o = e.node(a).rank, s = n.name, c = e.edge(n), l = c.labelRank;
+	if (o !== i + 1) {
+		e.removeEdge(n);
+		var u = void 0, d, f;
+		for (f = 0, ++i; i < o; ++f, ++i) c.points = [], u = {
+			width: 0,
+			height: 0,
+			edgeLabel: c,
+			edgeObj: n,
+			rank: i
+		}, d = addDummyNode(e, "edge", u, "_d"), i === l && (u.width = c.width, u.height = c.height, u.dummy = "edge-label", u.labelpos = c.labelpos), e.setEdge(r, d, { weight: c.weight }, s), f === 0 && e.graph().dummyChains.push(d), r = d;
+		e.setEdge(r, a, { weight: c.weight }, s);
+	}
+}
+function undo(t) {
+	forEach_default(t.graph().dummyChains, function(e) {
+		var n = t.node(e), r = n.edgeLabel, i;
+		for (t.setEdge(n.edgeObj, r); n.dummy;) i = t.successors(e)[0], t.removeNode(e), r.points.push({
+			x: n.x,
+			y: n.y
+		}), n.dummy === "edge-label" && (r.x = n.x, r.y = n.y, r.width = n.width, r.height = n.height), e = i, n = t.node(e);
+	});
+}
+export { run, undo };

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

@@ -0,0 +1,14 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+function addSubgraphConstraints(t, n, r) {
+	var i = {}, a;
+	forEach_default(r, function(e) {
+		for (var r = t.parent(e), o, s; r;) {
+			if (o = t.parent(r), o ? (s = i[o], i[o] = r) : (s = a, a = r), s && s !== r) {
+				n.setEdge(s, r);
+				return;
+			}
+			r = o;
+		}
+	});
+}
+export { addSubgraphConstraints };

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

@@ -0,0 +1,25 @@
+import map_default from "../../../../lodash-es/map.js";
+import reduce_default from "../../../../lodash-es/reduce.js";
+function barycenter(n, r) {
+	return map_default(r, function(e) {
+		var r = n.inEdges(e);
+		if (r.length) {
+			var i = reduce_default(r, function(e, t) {
+				var r = n.edge(t), i = n.node(t.v);
+				return {
+					sum: e.sum + r.weight * i.order,
+					weight: e.weight + r.weight
+				};
+			}, {
+				sum: 0,
+				weight: 0
+			});
+			return {
+				v: e,
+				barycenter: i.sum / i.weight,
+				weight: i.weight
+			};
+		} else return { v: e };
+	});
+}
+export { barycenter };

package/dist/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js

@@ -0,0 +1,25 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import isUndefined_default from "../../../../lodash-es/isUndefined.js";
+import uniqueId_default from "../../../../lodash-es/uniqueId.js";
+import { Graph } from "../../graphlib/graph.js";
+import "../../graphlib/index.js";
+function buildLayerGraph(n, i, o) {
+	var s = createRootNode(n), c = new Graph({ compound: !0 }).setGraph({ root: s }).setDefaultNodeLabel(function(e) {
+		return n.node(e);
+	});
+	return forEach_default(n.nodes(), function(r) {
+		var a = n.node(r), l = n.parent(r);
+		(a.rank === i || a.minRank <= i && i <= a.maxRank) && (c.setNode(r), c.setParent(r, l || s), forEach_default(n[o](r), function(e) {
+			var i = e.v === r ? e.w : e.v, a = c.edge(i, r), o = isUndefined_default(a) ? 0 : a.weight;
+			c.setEdge(i, r, { weight: n.edge(e).weight + o });
+		}), Object.prototype.hasOwnProperty.call(a, "minRank") && c.setNode(r, {
+			borderLeft: a.borderLeft[i],
+			borderRight: a.borderRight[i]
+		}));
+	}), c;
+}
+function createRootNode(e) {
+	for (var t; e.hasNode(t = uniqueId_default("_root")););
+	return t;
+}
+export { buildLayerGraph };

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

@@ -0,0 +1,33 @@
+import flatten_default from "../../../../lodash-es/flatten.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import map_default from "../../../../lodash-es/map.js";
+import sortBy_default from "../../../../lodash-es/sortBy.js";
+import zipObject_default from "../../../../lodash-es/zipObject.js";
+function crossCount(e, n) {
+	for (var r = 0, i = 1; i < n.length; ++i) r += twoLayerCrossCount(e, n[i - 1], n[i]);
+	return r;
+}
+function twoLayerCrossCount(a, o, s) {
+	for (var c = zipObject_default(s, map_default(s, function(e, n) {
+		return n;
+	})), l = flatten_default(map_default(o, function(e) {
+		return sortBy_default(map_default(a.outEdges(e), function(e) {
+			return {
+				pos: c[e.w],
+				weight: a.edge(e).weight
+			};
+		}), "pos");
+	})), u = 1; u < s.length;) u <<= 1;
+	var d = 2 * u - 1;
+	--u;
+	var f = map_default(Array(d), function() {
+		return 0;
+	}), p = 0;
+	return forEach_default(l.forEach(function(e) {
+		var n = e.pos + u;
+		f[n] += e.weight;
+		for (var r = 0; n > 0;) n % 2 && (r += f[n + 1]), n = n - 1 >> 1, f[n] += e.weight;
+		p += e.weight * r;
+	})), p;
+}
+export { crossCount };

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

@@ -0,0 +1,44 @@
+import cloneDeep_default from "../../../../lodash-es/cloneDeep.js";
+import forEach_default from "../../../../lodash-es/forEach.js";
+import map_default from "../../../../lodash-es/map.js";
+import range_default from "../../../../lodash-es/range.js";
+import { Graph } from "../../graphlib/graph.js";
+import "../../graphlib/index.js";
+import { buildLayerMatrix, maxRank } from "../util.js";
+import { addSubgraphConstraints } from "./add-subgraph-constraints.js";
+import { buildLayerGraph } from "./build-layer-graph.js";
+import { crossCount } from "./cross-count.js";
+import { initOrder } from "./init-order.js";
+import { sortSubgraph } from "./sort-subgraph.js";
+function order(s) {
+	var c = maxRank(s), u = buildLayerGraphs(s, range_default(1, c + 1), "inEdges"), f = buildLayerGraphs(s, range_default(c - 1, -1, -1), "outEdges"), p = initOrder(s);
+	assignOrder(s, p);
+	for (var m = Infinity, h, g = 0, _ = 0; _ < 4; ++g, ++_) {
+		sweepLayerGraphs(g % 2 ? u : f, g % 4 >= 2), p = buildLayerMatrix(s);
+		var v = crossCount(s, p);
+		v < m && (_ = 0, h = cloneDeep_default(p), m = v);
+	}
+	assignOrder(s, h);
+}
+function buildLayerGraphs(e, s, l) {
+	return map_default(s, function(s) {
+		return buildLayerGraph(e, s, l);
+	});
+}
+function sweepLayerGraphs(e, c) {
+	var l = new Graph();
+	forEach_default(e, function(e) {
+		var u = e.graph().root, d = sortSubgraph(e, u, l, c);
+		forEach_default(d.vs, function(s, c) {
+			e.node(s).order = c;
+		}), addSubgraphConstraints(e, l, d.vs);
+	});
+}
+function assignOrder(e, c) {
+	forEach_default(c, function(c) {
+		forEach_default(c, function(s, c) {
+			e.node(s).order = c;
+		});
+	});
+}
+export { order };

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

@@ -0,0 +1,23 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import filter_default from "../../../../lodash-es/filter.js";
+import map_default from "../../../../lodash-es/map.js";
+import has_default from "../../../../lodash-es/has.js";
+import max_default from "../../../../lodash-es/max.js";
+import range_default from "../../../../lodash-es/range.js";
+import sortBy_default from "../../../../lodash-es/sortBy.js";
+function initOrder(s) {
+	var c = {}, l = filter_default(s.nodes(), function(e) {
+		return !s.children(e).length;
+	}), u = map_default(range_default(max_default(map_default(l, function(e) {
+		return s.node(e).rank;
+	})) + 1), function() {
+		return [];
+	});
+	function d(o) {
+		has_default(c, o) || (c[o] = !0, u[s.node(o).rank].push(o), forEach_default(s.successors(o), d));
+	}
+	return forEach_default(sortBy_default(l, function(e) {
+		return s.node(e).rank;
+	}), d), u;
+}
+export { initOrder };

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

@@ -0,0 +1,55 @@
+import forEach_default from "../../../../lodash-es/forEach.js";
+import filter_default from "../../../../lodash-es/filter.js";
+import map_default from "../../../../lodash-es/map.js";
+import isUndefined_default from "../../../../lodash-es/isUndefined.js";
+import pick_default from "../../../../lodash-es/pick.js";
+function resolveConflicts(r, a) {
+	var o = {};
+	return forEach_default(r, function(e, n) {
+		var r = o[e.v] = {
+			indegree: 0,
+			in: [],
+			out: [],
+			vs: [e.v],
+			i: n
+		};
+		isUndefined_default(e.barycenter) || (r.barycenter = e.barycenter, r.weight = e.weight);
+	}), forEach_default(a.edges(), function(e) {
+		var n = o[e.v], r = o[e.w];
+		!isUndefined_default(n) && !isUndefined_default(r) && (r.indegree++, n.out.push(o[e.w]));
+	}), doResolveConflicts(filter_default(o, function(e) {
+		return !e.indegree;
+	}));
+}
+function doResolveConflicts(o) {
+	var s = [];
+	function c(e) {
+		return function(n) {
+			n.merged || (isUndefined_default(n.barycenter) || isUndefined_default(e.barycenter) || n.barycenter >= e.barycenter) && mergeEntries(e, n);
+		};
+	}
+	function l(e) {
+		return function(n) {
+			n.in.push(e), --n.indegree === 0 && o.push(n);
+		};
+	}
+	for (; o.length;) {
+		var u = o.pop();
+		s.push(u), forEach_default(u.in.reverse(), c(u)), forEach_default(u.out, l(u));
+	}
+	return map_default(filter_default(s, function(e) {
+		return !e.merged;
+	}), function(e) {
+		return pick_default(e, [
+			"vs",
+			"i",
+			"barycenter",
+			"weight"
+		]);
+	});
+}
+function mergeEntries(e, n) {
+	var r = 0, i = 0;
+	e.weight && (r += e.barycenter * e.weight, i += e.weight), n.weight && (r += n.barycenter * n.weight, i += n.weight), e.vs = n.vs.concat(e.vs), e.barycenter = r / i, e.weight = i, e.i = Math.min(n.i, e.i), n.merged = !0;
+}
+export { resolveConflicts };