@statewalker/fsm-charts 0.2.5 → 0.2.7

package/dist/layout-Dp671N6q.js

@@ -0,0 +1,2465 @@
+import { t as getPadding } from "./getPadding-Cw0e7G2v.js";
+//#region src/lodash-es/index.ts
+let _ = { constant: (value) => () => value };
+function setLodash(lib) {
+	_ = lib;
+}
+function getLodash() {
+	return _;
+}
+//#endregion
+//#region src/graphlib/graph.js
+var DEFAULT_EDGE_NAME = "\0";
+var GRAPH_NODE = "\0";
+var EDGE_KEY_DELIM = "
";
+var Graph = class {
+	constructor(opts = {}) {
+		this._isDirected = _.has(opts, "directed") ? opts.directed : true;
+		this._isMultigraph = _.has(opts, "multigraph") ? opts.multigraph : false;
+		this._isCompound = _.has(opts, "compound") ? opts.compound : false;
+		this._label = void 0;
+		this._defaultNodeLabelFn = _.constant(void 0);
+		this._defaultEdgeLabelFn = _.constant(void 0);
+		this._nodes = {};
+		if (this._isCompound) {
+			this._parent = {};
+			this._children = {};
+			this._children[GRAPH_NODE] = {};
+		}
+		this._in = {};
+		this._preds = {};
+		this._out = {};
+		this._sucs = {};
+		this._edgeObjs = {};
+		this._edgeLabels = {};
+	}
+	isDirected() {
+		return this._isDirected;
+	}
+	isMultigraph() {
+		return this._isMultigraph;
+	}
+	isCompound() {
+		return this._isCompound;
+	}
+	setGraph(label) {
+		this._label = label;
+		return this;
+	}
+	graph() {
+		return this._label;
+	}
+	setDefaultNodeLabel(newDefault) {
+		if (!_.isFunction(newDefault)) newDefault = _.constant(newDefault);
+		this._defaultNodeLabelFn = newDefault;
+		return this;
+	}
+	nodeCount() {
+		return this._nodeCount;
+	}
+	nodes() {
+		return _.keys(this._nodes);
+	}
+	sources() {
+		return _.filter(this.nodes(), (v) => _.isEmpty(this._in[v]));
+	}
+	sinks() {
+		return _.filter(this.nodes(), (v) => _.isEmpty(this._out[v]));
+	}
+	setNodes(vs, value) {
+		var args = arguments;
+		_.each(vs, (v) => {
+			if (args.length > 1) this.setNode(v, value);
+			else this.setNode(v);
+		});
+		return this;
+	}
+	setNode(v, value) {
+		if (_.has(this._nodes, v)) {
+			if (arguments.length > 1) this._nodes[v] = value;
+			return this;
+		}
+		this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
+		if (this._isCompound) {
+			this._parent[v] = GRAPH_NODE;
+			this._children[v] = {};
+			this._children[GRAPH_NODE][v] = true;
+		}
+		this._in[v] = {};
+		this._preds[v] = {};
+		this._out[v] = {};
+		this._sucs[v] = {};
+		++this._nodeCount;
+		return this;
+	}
+	node(v) {
+		return this._nodes[v];
+	}
+	hasNode(v) {
+		return _.has(this._nodes, v);
+	}
+	removeNode(v) {
+		if (_.has(this._nodes, v)) {
+			var removeEdge = (e) => {
+				this.removeEdge(this._edgeObjs[e]);
+			};
+			delete this._nodes[v];
+			if (this._isCompound) {
+				this._removeFromParentsChildList(v);
+				delete this._parent[v];
+				_.each(this.children(v), (child) => {
+					this.setParent(child);
+				});
+				delete this._children[v];
+			}
+			_.each(_.keys(this._in[v]), removeEdge);
+			delete this._in[v];
+			delete this._preds[v];
+			_.each(_.keys(this._out[v]), removeEdge);
+			delete this._out[v];
+			delete this._sucs[v];
+			--this._nodeCount;
+		}
+		return this;
+	}
+	setParent(v, parent) {
+		if (!this._isCompound) throw new Error("Cannot set parent in a non-compound graph");
+		if (_.isUndefined(parent)) parent = GRAPH_NODE;
+		else {
+			parent += "";
+			for (var ancestor = parent; !_.isUndefined(ancestor); ancestor = this.parent(ancestor)) if (ancestor === v) throw new Error(`Setting ${parent} as parent of ${v} would create a cycle`);
+			this.setNode(parent);
+		}
+		this.setNode(v);
+		this._removeFromParentsChildList(v);
+		this._parent[v] = parent;
+		this._children[parent][v] = true;
+		return this;
+	}
+	_removeFromParentsChildList(v) {
+		delete this._children[this._parent[v]][v];
+	}
+	parent(v) {
+		if (this._isCompound) {
+			var parent = this._parent[v];
+			if (parent !== GRAPH_NODE) return parent;
+		}
+	}
+	children(v) {
+		if (_.isUndefined(v)) v = GRAPH_NODE;
+		if (this._isCompound) {
+			var children = this._children[v];
+			if (children) return _.keys(children);
+		} else if (v === GRAPH_NODE) return this.nodes();
+		else if (this.hasNode(v)) return [];
+	}
+	predecessors(v) {
+		var predsV = this._preds[v];
+		if (predsV) return _.keys(predsV);
+	}
+	successors(v) {
+		var sucsV = this._sucs[v];
+		if (sucsV) return _.keys(sucsV);
+	}
+	neighbors(v) {
+		var preds = this.predecessors(v);
+		if (preds) return _.union(preds, this.successors(v));
+	}
+	isLeaf(v) {
+		var neighbors;
+		if (this.isDirected()) neighbors = this.successors(v);
+		else neighbors = this.neighbors(v);
+		return neighbors.length === 0;
+	}
+	filterNodes(filter) {
+		var copy = new this.constructor({
+			directed: this._isDirected,
+			multigraph: this._isMultigraph,
+			compound: this._isCompound
+		});
+		copy.setGraph(this.graph());
+		var self = this;
+		_.each(this._nodes, (value, v) => {
+			if (filter(v)) copy.setNode(v, value);
+		});
+		_.each(this._edgeObjs, (e) => {
+			if (copy.hasNode(e.v) && copy.hasNode(e.w)) copy.setEdge(e, self.edge(e));
+		});
+		var parents = {};
+		function findParent(v) {
+			var parent = self.parent(v);
+			if (parent === void 0 || copy.hasNode(parent)) {
+				parents[v] = parent;
+				return parent;
+			} else if (parent in parents) return parents[parent];
+			else return findParent(parent);
+		}
+		if (this._isCompound) _.each(copy.nodes(), (v) => {
+			copy.setParent(v, findParent(v));
+		});
+		return copy;
+	}
+	setDefaultEdgeLabel(newDefault) {
+		if (!_.isFunction(newDefault)) newDefault = _.constant(newDefault);
+		this._defaultEdgeLabelFn = newDefault;
+		return this;
+	}
+	edgeCount() {
+		return this._edgeCount;
+	}
+	edges() {
+		return _.values(this._edgeObjs);
+	}
+	setPath(vs, value) {
+		var args = arguments;
+		_.reduce(vs, (v, w) => {
+			if (args.length > 1) this.setEdge(v, w, value);
+			else this.setEdge(v, w);
+			return w;
+		});
+		return this;
+	}
+	setEdge() {
+		var v, w, name, value;
+		var valueSpecified = false;
+		var arg0 = arguments[0];
+		if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) {
+			v = arg0.v;
+			w = arg0.w;
+			name = arg0.name;
+			if (arguments.length === 2) {
+				value = arguments[1];
+				valueSpecified = true;
+			}
+		} else {
+			v = arg0;
+			w = arguments[1];
+			name = arguments[3];
+			if (arguments.length > 2) {
+				value = arguments[2];
+				valueSpecified = true;
+			}
+		}
+		v = `${v}`;
+		w = `${w}`;
+		if (!_.isUndefined(name)) name = `${name}`;
+		var e = edgeArgsToId(this._isDirected, v, w, name);
+		if (_.has(this._edgeLabels, e)) {
+			if (valueSpecified) this._edgeLabels[e] = value;
+			return this;
+		}
+		if (!_.isUndefined(name) && !this._isMultigraph) throw new Error("Cannot set a named edge when isMultigraph = false");
+		this.setNode(v);
+		this.setNode(w);
+		this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
+		var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
+		v = edgeObj.v;
+		w = edgeObj.w;
+		Object.freeze(edgeObj);
+		this._edgeObjs[e] = edgeObj;
+		incrementOrInitEntry(this._preds[w], v);
+		incrementOrInitEntry(this._sucs[v], w);
+		this._in[w][e] = edgeObj;
+		this._out[v][e] = edgeObj;
+		this._edgeCount++;
+		return this;
+	}
+	edge(v, w, name) {
+		var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+		return this._edgeLabels[e];
+	}
+	hasEdge(v, w, name) {
+		var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+		return _.has(this._edgeLabels, e);
+	}
+	removeEdge(v, w, name) {
+		var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+		var edge = this._edgeObjs[e];
+		if (edge) {
+			v = edge.v;
+			w = edge.w;
+			delete this._edgeLabels[e];
+			delete this._edgeObjs[e];
+			decrementOrRemoveEntry(this._preds[w], v);
+			decrementOrRemoveEntry(this._sucs[v], w);
+			delete this._in[w][e];
+			delete this._out[v][e];
+			this._edgeCount--;
+		}
+		return this;
+	}
+	inEdges(v, u) {
+		var inV = this._in[v];
+		if (inV) {
+			var edges = _.values(inV);
+			if (!u) return edges;
+			return _.filter(edges, (edge) => edge.v === u);
+		}
+	}
+	outEdges(v, w) {
+		var outV = this._out[v];
+		if (outV) {
+			var edges = _.values(outV);
+			if (!w) return edges;
+			return _.filter(edges, (edge) => edge.w === w);
+		}
+	}
+	nodeEdges(v, w) {
+		var inEdges = this.inEdges(v, w);
+		if (inEdges) return inEdges.concat(this.outEdges(v, w));
+	}
+};
+Graph.prototype._nodeCount = 0;
+Graph.prototype._edgeCount = 0;
+function incrementOrInitEntry(map, k) {
+	if (map[k]) map[k]++;
+	else map[k] = 1;
+}
+function decrementOrRemoveEntry(map, k) {
+	if (!--map[k]) delete map[k];
+}
+function edgeArgsToId(isDirected, v_, w_, name) {
+	var v = `${v_}`;
+	var w = `${w_}`;
+	if (!isDirected && v > w) {
+		var tmp = v;
+		v = w;
+		w = tmp;
+	}
+	return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name);
+}
+function edgeArgsToObj(isDirected, v_, w_, name) {
+	var v = `${v_}`;
+	var w = `${w_}`;
+	if (!isDirected && v > w) {
+		var tmp = v;
+		v = w;
+		w = tmp;
+	}
+	var edgeObj = {
+		v,
+		w
+	};
+	if (name) edgeObj.name = name;
+	return edgeObj;
+}
+function edgeObjToId(isDirected, edgeObj) {
+	return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
+}
+//#endregion
+//#region src/dagre/data/list.js
+var List = class {
+	constructor() {
+		var sentinel = {};
+		sentinel._next = sentinel._prev = sentinel;
+		this._sentinel = sentinel;
+	}
+	dequeue() {
+		var sentinel = this._sentinel;
+		var entry = sentinel._prev;
+		if (entry !== sentinel) {
+			unlink(entry);
+			return entry;
+		}
+	}
+	enqueue(entry) {
+		var sentinel = this._sentinel;
+		if (entry._prev && entry._next) unlink(entry);
+		entry._next = sentinel._next;
+		sentinel._next._prev = entry;
+		sentinel._next = entry;
+		entry._prev = sentinel;
+	}
+	toString() {
+		var strs = [];
+		var sentinel = this._sentinel;
+		var curr = sentinel._prev;
+		while (curr !== sentinel) {
+			strs.push(JSON.stringify(curr, filterOutLinks));
+			curr = curr._prev;
+		}
+		return `[${strs.join(", ")}]`;
+	}
+};
+function unlink(entry) {
+	entry._prev._next = entry._next;
+	entry._next._prev = entry._prev;
+	delete entry._next;
+	delete entry._prev;
+}
+function filterOutLinks(k, v) {
+	if (k !== "_next" && k !== "_prev") return v;
+}
+//#endregion
+//#region src/dagre/greedy-fas.js
+var DEFAULT_WEIGHT_FN = _.constant(1);
+function greedyFAS(g, weightFn) {
+	if (g.nodeCount() <= 1) return [];
+	var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+	var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+	return _.flatten(_.map(results, (e) => g.outEdges(e.v, e.w)));
+}
+function doGreedyFAS(g, buckets, zeroIdx) {
+	var results = [];
+	var sources = buckets[buckets.length - 1];
+	var sinks = buckets[0];
+	var entry;
+	while (g.nodeCount()) {
+		while (entry = sinks.dequeue()) removeNode(g, buckets, zeroIdx, entry);
+		while (entry = sources.dequeue()) removeNode(g, buckets, zeroIdx, entry);
+		if (g.nodeCount()) for (var i = buckets.length - 2; i > 0; --i) {
+			entry = buckets[i].dequeue();
+			if (entry) {
+				results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
+				break;
+			}
+		}
+	}
+	return results;
+}
+function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
+	var results = collectPredecessors ? [] : void 0;
+	_.forEach(g.inEdges(entry.v), (edge) => {
+		var weight = g.edge(edge);
+		var uEntry = g.node(edge.v);
+		if (collectPredecessors) results.push({
+			v: edge.v,
+			w: edge.w
+		});
+		uEntry.out -= weight;
+		assignBucket(buckets, zeroIdx, uEntry);
+	});
+	_.forEach(g.outEdges(entry.v), (edge) => {
+		var weight = g.edge(edge);
+		var w = edge.w;
+		var wEntry = g.node(w);
+		wEntry.in -= weight;
+		assignBucket(buckets, zeroIdx, wEntry);
+	});
+	g.removeNode(entry.v);
+	return results;
+}
+function buildState(g, weightFn) {
+	var fasGraph = new Graph();
+	var maxIn = 0;
+	var maxOut = 0;
+	_.forEach(g.nodes(), (v) => {
+		fasGraph.setNode(v, {
+			v,
+			in: 0,
+			out: 0
+		});
+	});
+	_.forEach(g.edges(), (e) => {
+		var prevWeight = fasGraph.edge(e.v, e.w) || 0;
+		var weight = weightFn(e);
+		var edgeWeight = prevWeight + weight;
+		fasGraph.setEdge(e.v, e.w, edgeWeight);
+		maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
+		maxIn = Math.max(maxIn, fasGraph.node(e.w).in += weight);
+	});
+	var buckets = _.range(maxOut + maxIn + 3).map(() => new List());
+	var zeroIdx = maxIn + 1;
+	_.forEach(fasGraph.nodes(), (v) => {
+		assignBucket(buckets, zeroIdx, fasGraph.node(v));
+	});
+	return {
+		graph: fasGraph,
+		buckets,
+		zeroIdx
+	};
+}
+function assignBucket(buckets, zeroIdx, entry) {
+	if (!entry.out) buckets[0].enqueue(entry);
+	else if (!entry.in) buckets[buckets.length - 1].enqueue(entry);
+	else buckets[entry.out - entry.in + zeroIdx].enqueue(entry);
+}
+//#endregion
+//#region src/dagre/acyclic.js
+function run$2(g) {
+	var fas = g.graph().acyclicer === "greedy" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+	_.forEach(fas, (e) => {
+		var label = g.edge(e);
+		g.removeEdge(e);
+		label.forwardName = e.name;
+		label.reversed = true;
+		g.setEdge(e.w, e.v, label, _.uniqueId("rev"));
+	});
+	function weightFn(g) {
+		return (e) => g.edge(e).weight;
+	}
+}
+function dfsFAS(g) {
+	var fas = [];
+	var stack = {};
+	var visited = {};
+	function dfs(v) {
+		if (_.has(visited, v)) return;
+		visited[v] = true;
+		stack[v] = true;
+		_.forEach(g.outEdges(v), (e) => {
+			if (_.has(stack, e.w)) fas.push(e);
+			else dfs(e.w);
+		});
+		delete stack[v];
+	}
+	_.forEach(g.nodes(), dfs);
+	return fas;
+}
+function undo$2(g) {
+	_.forEach(g.edges(), (e) => {
+		var label = g.edge(e);
+		if (label.reversed) {
+			g.removeEdge(e);
+			var forwardName = label.forwardName;
+			delete label.reversed;
+			delete label.forwardName;
+			g.setEdge(e.w, e.v, label, forwardName);
+		}
+	});
+}
+//#endregion
+//#region src/dagre/util.js
+function addDummyNode(g, type, attrs, name) {
+	var v;
+	do
+		v = _.uniqueId(name);
+	while (g.hasNode(v));
+	attrs.dummy = type;
+	g.setNode(v, attrs);
+	return v;
+}
+function simplify(g) {
+	var simplified = new Graph().setGraph(g.graph());
+	_.forEach(g.nodes(), (v) => {
+		simplified.setNode(v, g.node(v));
+	});
+	_.forEach(g.edges(), (e) => {
+		var simpleLabel = simplified.edge(e.v, e.w) || {
+			weight: 0,
+			minlen: 1
+		};
+		var label = g.edge(e);
+		simplified.setEdge(e.v, e.w, {
+			weight: simpleLabel.weight + label.weight,
+			minlen: Math.max(simpleLabel.minlen, label.minlen)
+		});
+	});
+	return simplified;
+}
+function asNonCompoundGraph(g) {
+	var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+	_.forEach(g.nodes(), (v) => {
+		if (!g.children(v).length) simplified.setNode(v, g.node(v));
+	});
+	_.forEach(g.edges(), (e) => {
+		simplified.setEdge(e, g.edge(e));
+	});
+	return simplified;
+}
+function intersectRect(rect, point) {
+	var x = rect.x;
+	var y = rect.y;
+	var dx = point.x - x;
+	var dy = point.y - y;
+	var w = rect.width / 2;
+	var h = rect.height / 2;
+	if (!dx && !dy) throw new Error("Not possible to find intersection inside of the rectangle");
+	var sx, sy;
+	if (Math.abs(dy) * w > Math.abs(dx) * h) {
+		if (dy < 0) h = -h;
+		sx = h * dx / dy;
+		sy = h;
+	} else {
+		if (dx < 0) w = -w;
+		sx = w;
+		sy = w * dy / dx;
+	}
+	return {
+		x: x + sx,
+		y: y + sy
+	};
+}
+function buildLayerMatrix(g) {
+	var layering = _.map(_.range(maxRank(g) + 1), () => []);
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v);
+		var rank = node.rank;
+		if (!_.isUndefined(rank)) layering[rank][node.order] = v;
+	});
+	return layering;
+}
+function normalizeRanks(g) {
+	var min = _.min(_.map(g.nodes(), (v) => g.node(v).rank));
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v);
+		if (_.has(node, "rank")) node.rank -= min;
+	});
+}
+function removeEmptyRanks(g) {
+	var offset = _.min(_.map(g.nodes(), (v) => g.node(v).rank));
+	var layers = [];
+	_.forEach(g.nodes(), (v) => {
+		var rank = g.node(v).rank - offset;
+		if (!layers[rank]) layers[rank] = [];
+		layers[rank].push(v);
+	});
+	var delta = 0;
+	var nodeRankFactor = g.graph().nodeRankFactor;
+	_.forEach(layers, (vs, i) => {
+		if (_.isUndefined(vs) && i % nodeRankFactor !== 0) --delta;
+		else if (delta) _.forEach(vs, (v) => {
+			g.node(v).rank += delta;
+		});
+	});
+}
+function addBorderNode$1(g, prefix, rank, order) {
+	var node = {
+		width: 0,
+		height: 0
+	};
+	if (arguments.length >= 4) {
+		node.rank = rank;
+		node.order = order;
+	}
+	return addDummyNode(g, "border", node, prefix);
+}
+function maxRank(g) {
+	return _.max(_.map(g.nodes(), (v) => {
+		var rank = g.node(v).rank;
+		if (!_.isUndefined(rank)) return rank;
+	}));
+}
+function partition(collection, fn) {
+	var result = {
+		lhs: [],
+		rhs: []
+	};
+	_.forEach(collection, (value) => {
+		if (fn(value)) result.lhs.push(value);
+		else result.rhs.push(value);
+	});
+	return result;
+}
+function time(name, fn) {
+	var start = _.now();
+	try {
+		return fn();
+	} finally {
+		console.log(`${name} time: ${_.now() - start}ms`);
+	}
+}
+function notime(_name, fn) {
+	return fn();
+}
+//#endregion
+//#region src/dagre/add-border-segments.js
+function addBorderSegments(g) {
+	function dfs(v) {
+		var children = g.children(v);
+		var node = g.node(v);
+		if (children.length) _.forEach(children, dfs);
+		if (_.has(node, "minRank")) {
+			node.borderLeft = [];
+			node.borderRight = [];
+			for (var rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
+				addBorderNode(g, "borderLeft", "_bl", v, node, rank);
+				addBorderNode(g, "borderRight", "_br", v, node, rank);
+			}
+		}
+	}
+	_.forEach(g.children(), dfs);
+}
+function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
+	var label = {
+		width: 0,
+		height: 0,
+		rank,
+		borderType: prop
+	};
+	var prev = sgNode[prop][rank - 1];
+	var curr = addDummyNode(g, "border", label, prefix);
+	sgNode[prop][rank] = curr;
+	g.setParent(curr, sg);
+	if (prev) g.setEdge(prev, curr, { weight: 1 });
+}
+//#endregion
+//#region src/dagre/coordinate-system.js
+function adjust(g) {
+	var rankDir = g.graph().rankdir.toLowerCase();
+	if (rankDir === "lr" || rankDir === "rl") swapWidthHeight(g);
+}
+function undo$1(g) {
+	var rankDir = g.graph().rankdir.toLowerCase();
+	if (rankDir === "bt" || rankDir === "rl") reverseY(g);
+	if (rankDir === "lr" || rankDir === "rl") {
+		swapXY(g);
+		swapWidthHeight(g);
+	}
+}
+function swapWidthHeight(g) {
+	_.forEach(g.nodes(), (v) => {
+		swapWidthHeightOne(g.node(v));
+	});
+	_.forEach(g.edges(), (e) => {
+		swapWidthHeightOne(g.edge(e));
+	});
+}
+function swapWidthHeightOne(attrs) {
+	var w = attrs.width;
+	attrs.width = attrs.height;
+	attrs.height = w;
+}
+function reverseY(g) {
+	_.forEach(g.nodes(), (v) => {
+		reverseYOne(g.node(v));
+	});
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		_.forEach(edge.points, reverseYOne);
+		if (_.has(edge, "y")) reverseYOne(edge);
+	});
+}
+function reverseYOne(attrs) {
+	attrs.y = -attrs.y;
+}
+function swapXY(g) {
+	_.forEach(g.nodes(), (v) => {
+		swapXYOne(g.node(v));
+	});
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		_.forEach(edge.points, swapXYOne);
+		if (_.has(edge, "x")) swapXYOne(edge);
+	});
+}
+function swapXYOne(attrs) {
+	var x = attrs.x;
+	attrs.x = attrs.y;
+	attrs.y = x;
+}
+//#endregion
+//#region src/dagre/nesting-graph.js
+function run$1(g) {
+	var root = addDummyNode(g, "root", {}, "_root");
+	var depths = treeDepths(g);
+	var height = _.max(_.values(depths)) - 1;
+	var nodeSep = 2 * height + 1;
+	g.graph().nestingRoot = root;
+	_.forEach(g.edges(), (e) => {
+		g.edge(e).minlen *= nodeSep;
+	});
+	var weight = sumWeights(g) + 1;
+	_.forEach(g.children(), (child) => {
+		dfs$1(g, root, nodeSep, weight, height, depths, child);
+	});
+	g.graph().nodeRankFactor = nodeSep;
+}
+function dfs$1(g, root, nodeSep, weight, height, depths, v) {
+	var children = g.children(v);
+	if (!children.length) {
+		if (v !== root) g.setEdge(root, v, {
+			weight: 0,
+			minlen: nodeSep
+		});
+		return;
+	}
+	var top = addBorderNode$1(g, "_bt");
+	var bottom = addBorderNode$1(g, "_bb");
+	var label = g.node(v);
+	g.setParent(top, v);
+	label.borderTop = top;
+	g.setParent(bottom, v);
+	label.borderBottom = bottom;
+	_.forEach(children, (child) => {
+		dfs$1(g, root, nodeSep, weight, height, depths, child);
+		var childNode = g.node(child);
+		var childTop = childNode.borderTop ? childNode.borderTop : child;
+		var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+		var thisWeight = childNode.borderTop ? weight : 2 * weight;
+		var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+		g.setEdge(top, childTop, {
+			weight: thisWeight,
+			minlen,
+			nestingEdge: true
+		});
+		g.setEdge(childBottom, bottom, {
+			weight: thisWeight,
+			minlen,
+			nestingEdge: true
+		});
+	});
+	if (!g.parent(v)) g.setEdge(root, top, {
+		weight: 0,
+		minlen: height + depths[v]
+	});
+}
+function treeDepths(g) {
+	var depths = {};
+	function dfs(v, depth) {
+		var children = g.children(v);
+		if (children?.length) _.forEach(children, (child) => {
+			dfs(child, depth + 1);
+		});
+		depths[v] = depth;
+	}
+	_.forEach(g.children(), (v) => {
+		dfs(v, 1);
+	});
+	return depths;
+}
+function sumWeights(g) {
+	return _.reduce(g.edges(), (acc, e) => acc + g.edge(e).weight, 0);
+}
+function cleanup(g) {
+	var graphLabel = g.graph();
+	g.removeNode(graphLabel.nestingRoot);
+	delete graphLabel.nestingRoot;
+	_.forEach(g.edges(), (e) => {
+		if (g.edge(e).nestingEdge) g.removeEdge(e);
+	});
+}
+//#endregion
+//#region src/dagre/normalize.js
+function run(g) {
+	g.graph().dummyChains = [];
+	_.forEach(g.edges(), (edge) => {
+		normalizeEdge(g, edge);
+	});
+}
+function normalizeEdge(g, e) {
+	var v = e.v;
+	var vRank = g.node(v).rank;
+	var w = e.w;
+	var wRank = g.node(w).rank;
+	var name = e.name;
+	var edgeLabel = g.edge(e);
+	var labelRank = edgeLabel.labelRank;
+	if (wRank === vRank + 1) return;
+	g.removeEdge(e);
+	var dummy, attrs, i = 0;
+	for (++vRank; vRank < wRank; ++i, ++vRank) {
+		edgeLabel.points = [];
+		attrs = {
+			width: 0,
+			height: 0,
+			edgeLabel,
+			edgeObj: e,
+			rank: vRank
+		};
+		dummy = addDummyNode(g, "edge", attrs, "_d");
+		if (vRank === labelRank) {
+			attrs.width = edgeLabel.width;
+			attrs.height = edgeLabel.height;
+			attrs.dummy = "edge-label";
+			attrs.labelpos = edgeLabel.labelpos;
+		}
+		g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
+		if (i === 0) g.graph().dummyChains.push(dummy);
+		v = dummy;
+	}
+	g.setEdge(v, w, { weight: edgeLabel.weight }, name);
+}
+function undo(g) {
+	_.forEach(g.graph().dummyChains, (v) => {
+		var node = g.node(v);
+		var origLabel = node.edgeLabel;
+		var w;
+		g.setEdge(node.edgeObj, origLabel);
+		while (node.dummy) {
+			w = g.successors(v)[0];
+			g.removeNode(v);
+			origLabel.points.push({
+				x: node.x,
+				y: node.y
+			});
+			if (node.dummy === "edge-label") {
+				origLabel.x = node.x;
+				origLabel.y = node.y;
+				origLabel.width = node.width;
+				origLabel.height = node.height;
+			}
+			v = w;
+			node = g.node(v);
+		}
+	});
+}
+//#endregion
+//#region src/dagre/order/add-subgraph-constraints.js
+function addSubgraphConstraints(g, cg, vs) {
+	var prev = {}, rootPrev;
+	_.forEach(vs, (v) => {
+		var child = g.parent(v), parent, prevChild;
+		while (child) {
+			parent = g.parent(child);
+			if (parent) {
+				prevChild = prev[parent];
+				prev[parent] = child;
+			} else {
+				prevChild = rootPrev;
+				rootPrev = child;
+			}
+			if (prevChild && prevChild !== child) {
+				cg.setEdge(prevChild, child);
+				return;
+			}
+			child = parent;
+		}
+	});
+}
+//#endregion
+//#region src/dagre/order/build-layer-graph.js
+function buildLayerGraph(g, rank, relationship) {
+	var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel((v) => g.node(v));
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v), parent = g.parent(v);
+		if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
+			result.setNode(v);
+			result.setParent(v, parent || root);
+			_.forEach(g[relationship](v), (e) => {
+				var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !_.isUndefined(edge) ? edge.weight : 0;
+				result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+			});
+			if (_.has(node, "minRank")) result.setNode(v, {
+				borderLeft: node.borderLeft[rank],
+				borderRight: node.borderRight[rank]
+			});
+		}
+	});
+	return result;
+}
+function createRootNode(g) {
+	var v;
+	while (g.hasNode(v = _.uniqueId("_root")));
+	return v;
+}
+//#endregion
+//#region src/dagre/order/cross-count.js
+function crossCount(g, layering) {
+	var cc = 0;
+	for (var i = 1; i < layering.length; ++i) cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+	return cc;
+}
+function twoLayerCrossCount(g, northLayer, southLayer) {
+	var southPos = _.zipObject(southLayer, _.map(southLayer, (_v, i) => i));
+	var southEntries = _.flatten(_.map(northLayer, (v) => _.sortBy(_.map(g.outEdges(v), (e) => ({
+		pos: southPos[e.w],
+		weight: g.edge(e).weight
+	})), "pos")));
+	var firstIndex = 1;
+	while (firstIndex < southLayer.length) firstIndex <<= 1;
+	var treeSize = 2 * firstIndex - 1;
+	firstIndex -= 1;
+	var tree = _.map(new Array(treeSize), () => 0);
+	var cc = 0;
+	_.forEach(southEntries.forEach((entry) => {
+		var index = entry.pos + firstIndex;
+		tree[index] += entry.weight;
+		var weightSum = 0;
+		while (index > 0) {
+			if (index % 2) weightSum += tree[index + 1];
+			index = index - 1 >> 1;
+			tree[index] += entry.weight;
+		}
+		cc += entry.weight * weightSum;
+	}));
+	return cc;
+}
+//#endregion
+//#region src/dagre/order/init-order.js
+function initOrder(g) {
+	var visited = {};
+	var simpleNodes = _.filter(g.nodes(), (v) => !g.children(v).length);
+	var maxRank = _.max(_.map(simpleNodes, (v) => g.node(v).rank));
+	var layers = _.map(_.range(maxRank + 1), () => []);
+	function dfs(v) {
+		if (_.has(visited, v)) return;
+		visited[v] = true;
+		layers[g.node(v).rank].push(v);
+		_.forEach(g.successors(v), dfs);
+	}
+	var orderedVs = _.sortBy(simpleNodes, (v) => g.node(v).rank);
+	_.forEach(orderedVs, dfs);
+	return layers;
+}
+//#endregion
+//#region src/dagre/order/barycenter.js
+function barycenter(g, movable) {
+	return _.map(movable, (v) => {
+		var inV = g.inEdges(v);
+		if (!inV.length) return { v };
+		else {
+			var result = _.reduce(inV, (acc, e) => {
+				var edge = g.edge(e), nodeU = g.node(e.v);
+				return {
+					sum: acc.sum + edge.weight * nodeU.order,
+					weight: acc.weight + edge.weight
+				};
+			}, {
+				sum: 0,
+				weight: 0
+			});
+			return {
+				v,
+				barycenter: result.sum / result.weight,
+				weight: result.weight
+			};
+		}
+	});
+}
+//#endregion
+//#region src/dagre/order/resolve-conflicts.js
+function resolveConflicts(entries, cg) {
+	var mappedEntries = {};
+	_.forEach(entries, (entry, i) => {
+		var tmp = mappedEntries[entry.v] = {
+			indegree: 0,
+			in: [],
+			out: [],
+			vs: [entry.v],
+			i
+		};
+		if (!_.isUndefined(entry.barycenter)) {
+			tmp.barycenter = entry.barycenter;
+			tmp.weight = entry.weight;
+		}
+	});
+	_.forEach(cg.edges(), (e) => {
+		var entryV = mappedEntries[e.v];
+		var entryW = mappedEntries[e.w];
+		if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
+			entryW.indegree++;
+			entryV.out.push(mappedEntries[e.w]);
+		}
+	});
+	return doResolveConflicts(_.filter(mappedEntries, (entry) => {
+		return !entry.indegree;
+	}));
+}
+function doResolveConflicts(sourceSet) {
+	var entries = [];
+	function handleIn(vEntry) {
+		return (uEntry) => {
+			if (uEntry.merged) return;
+			if (_.isUndefined(uEntry.barycenter) || _.isUndefined(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) mergeEntries(vEntry, uEntry);
+		};
+	}
+	function handleOut(vEntry) {
+		return (wEntry) => {
+			wEntry.in.push(vEntry);
+			if (--wEntry.indegree === 0) sourceSet.push(wEntry);
+		};
+	}
+	while (sourceSet.length) {
+		var entry = sourceSet.pop();
+		entries.push(entry);
+		_.forEach(entry.in.reverse(), handleIn(entry));
+		_.forEach(entry.out, handleOut(entry));
+	}
+	return _.map(_.filter(entries, (entry) => !entry.merged), (entry) => _.pick(entry, [
+		"vs",
+		"i",
+		"barycenter",
+		"weight"
+	]));
+}
+function mergeEntries(target, source) {
+	var sum = 0;
+	var weight = 0;
+	if (target.weight) {
+		sum += target.barycenter * target.weight;
+		weight += target.weight;
+	}
+	if (source.weight) {
+		sum += source.barycenter * source.weight;
+		weight += source.weight;
+	}
+	target.vs = source.vs.concat(target.vs);
+	target.barycenter = sum / weight;
+	target.weight = weight;
+	target.i = Math.min(source.i, target.i);
+	source.merged = true;
+}
+//#endregion
+//#region src/dagre/order/sort.js
+function sort(entries, biasRight) {
+	var parts = partition(entries, (entry) => _.has(entry, "barycenter"));
+	var sortable = parts.lhs, unsortable = _.sortBy(parts.rhs, (entry) => -entry.i), vs = [], sum = 0, weight = 0, vsIndex = 0;
+	sortable.sort(compareWithBias(!!biasRight));
+	vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+	_.forEach(sortable, (entry) => {
+		vsIndex += entry.vs.length;
+		vs.push(entry.vs);
+		sum += entry.barycenter * entry.weight;
+		weight += entry.weight;
+		vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+	});
+	var result = { vs: _.flatten(vs) };
+	if (weight) {
+		result.barycenter = sum / weight;
+		result.weight = weight;
+	}
+	return result;
+}
+function consumeUnsortable(vs, unsortable, index) {
+	var last;
+	while (unsortable.length && (last = _.last(unsortable)).i <= index) {
+		unsortable.pop();
+		vs.push(last.vs);
+		index++;
+	}
+	return index;
+}
+function compareWithBias(bias) {
+	return (entryV, entryW) => {
+		if (entryV.barycenter < entryW.barycenter) return -1;
+		else if (entryV.barycenter > entryW.barycenter) return 1;
+		return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
+	};
+}
+//#endregion
+//#region src/dagre/order/sort-subgraph.js
+function sortSubgraph(g, v, cg, biasRight) {
+	var movable = g.children(v);
+	var node = g.node(v);
+	var bl = node ? node.borderLeft : void 0;
+	var br = node ? node.borderRight : void 0;
+	var subgraphs = {};
+	if (bl) movable = _.filter(movable, (w) => w !== bl && w !== br);
+	var barycenters = barycenter(g, movable);
+	_.forEach(barycenters, (entry) => {
+		if (g.children(entry.v).length) {
+			var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+			subgraphs[entry.v] = subgraphResult;
+			if (_.has(subgraphResult, "barycenter")) mergeBarycenters(entry, subgraphResult);
+		}
+	});
+	var entries = resolveConflicts(barycenters, cg);
+	expandSubgraphs(entries, subgraphs);
+	var result = sort(entries, biasRight);
+	if (bl) {
+		result.vs = _.flatten([
+			bl,
+			result.vs,
+			br
+		]);
+		if (g.predecessors(bl).length) {
+			var blPred = g.node(g.predecessors(bl)[0]), brPred = g.node(g.predecessors(br)[0]);
+			if (!_.has(result, "barycenter")) {
+				result.barycenter = 0;
+				result.weight = 0;
+			}
+			result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+			result.weight += 2;
+		}
+	}
+	return result;
+}
+function expandSubgraphs(entries, subgraphs) {
+	_.forEach(entries, (entry) => {
+		entry.vs = _.flatten(entry.vs.map((v) => {
+			if (subgraphs[v]) return subgraphs[v].vs;
+			return v;
+		}));
+	});
+}
+function mergeBarycenters(target, other) {
+	if (!_.isUndefined(target.barycenter)) {
+		target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
+		target.weight += other.weight;
+	} else {
+		target.barycenter = other.barycenter;
+		target.weight = other.weight;
+	}
+}
+//#endregion
+//#region src/dagre/order/index.js
+function order(g) {
+	var maxRank$1 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank$1 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g, _.range(maxRank$1 - 1, -1, -1), "outEdges");
+	var layering = initOrder(g);
+	assignOrder(g, layering);
+	var bestCC = Number.POSITIVE_INFINITY, best;
+	for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+		sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+		layering = buildLayerMatrix(g);
+		var cc = crossCount(g, layering);
+		if (cc < bestCC) {
+			lastBest = 0;
+			best = _.cloneDeep(layering);
+			bestCC = cc;
+		}
+	}
+	assignOrder(g, best);
+}
+function buildLayerGraphs(g, ranks, relationship) {
+	return _.map(ranks, (rank) => buildLayerGraph(g, rank, relationship));
+}
+function sweepLayerGraphs(layerGraphs, biasRight) {
+	var cg = new Graph();
+	_.forEach(layerGraphs, (lg) => {
+		var root = lg.graph().root;
+		var sorted = sortSubgraph(lg, root, cg, biasRight);
+		_.forEach(sorted.vs, (v, i) => {
+			lg.node(v).order = i;
+		});
+		addSubgraphConstraints(lg, cg, sorted.vs);
+	});
+}
+function assignOrder(g, layering) {
+	_.forEach(layering, (layer) => {
+		_.forEach(layer, (v, i) => {
+			g.node(v).order = i;
+		});
+	});
+}
+//#endregion
+//#region src/dagre/parent-dummy-chains.js
+function parentDummyChains(g) {
+	var postorderNums = postorder$1(g);
+	_.forEach(g.graph().dummyChains, (v) => {
+		var node = g.node(v);
+		var edgeObj = node.edgeObj;
+		var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+		var path = pathData.path;
+		var lca = pathData.lca;
+		var pathIdx = 0;
+		var pathV = path[pathIdx];
+		var ascending = true;
+		while (v !== edgeObj.w) {
+			node = g.node(v);
+			if (ascending) {
+				while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) pathIdx++;
+				if (pathV === lca) ascending = false;
+			}
+			if (!ascending) {
+				while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) pathIdx++;
+				pathV = path[pathIdx];
+			}
+			g.setParent(v, pathV);
+			v = g.successors(v)[0];
+		}
+	});
+}
+function findPath(g, postorderNums, v, w) {
+	var vPath = [];
+	var wPath = [];
+	var low = Math.min(postorderNums[v].low, postorderNums[w].low);
+	var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+	var parent;
+	var lca;
+	parent = v;
+	do {
+		parent = g.parent(parent);
+		vPath.push(parent);
+	} while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+	lca = parent;
+	parent = w;
+	while ((parent = g.parent(parent)) !== lca) wPath.push(parent);
+	return {
+		path: vPath.concat(wPath.reverse()),
+		lca
+	};
+}
+function postorder$1(g) {
+	var result = {};
+	var lim = 0;
+	function dfs(v) {
+		var low = lim;
+		_.forEach(g.children(v), dfs);
+		result[v] = {
+			low,
+			lim: lim++
+		};
+	}
+	_.forEach(g.children(), dfs);
+	return result;
+}
+//#endregion
+//#region src/dagre/position/bk.js
+function findType1Conflicts(g, layering) {
+	var conflicts = {};
+	function visitLayer(prevLayer, layer) {
+		var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = _.last(layer);
+		_.forEach(layer, (v, i) => {
+			var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
+			if (w || v === lastNode) {
+				_.forEach(layer.slice(scanPos, i + 1), (scanNode) => {
+					_.forEach(g.predecessors(scanNode), (u) => {
+						var uLabel = g.node(u), uPos = uLabel.order;
+						if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) addConflict(conflicts, u, scanNode);
+					});
+				});
+				scanPos = i + 1;
+				k0 = k1;
+			}
+		});
+		return layer;
+	}
+	_.reduce(layering, visitLayer);
+	return conflicts;
+}
+function findType2Conflicts(g, layering) {
+	var conflicts = {};
+	function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+		var v;
+		_.forEach(_.range(southPos, southEnd), (i) => {
+			v = south[i];
+			if (g.node(v).dummy) _.forEach(g.predecessors(v), (u) => {
+				var uNode = g.node(u);
+				if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) addConflict(conflicts, u, v);
+			});
+		});
+	}
+	function visitLayer(north, south) {
+		var prevNorthPos = -1, nextNorthPos, southPos = 0;
+		_.forEach(south, (v, southLookahead) => {
+			if (g.node(v).dummy === "border") {
+				var predecessors = g.predecessors(v);
+				if (predecessors.length) {
+					nextNorthPos = g.node(predecessors[0]).order;
+					scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
+					southPos = southLookahead;
+					prevNorthPos = nextNorthPos;
+				}
+			}
+			scan(south, southPos, south.length, nextNorthPos, north.length);
+		});
+		return south;
+	}
+	_.reduce(layering, visitLayer);
+	return conflicts;
+}
+function findOtherInnerSegmentNode(g, v) {
+	if (g.node(v).dummy) return _.find(g.predecessors(v), (u) => g.node(u).dummy);
+}
+function addConflict(conflicts, v, w) {
+	if (v > w) {
+		var tmp = v;
+		v = w;
+		w = tmp;
+	}
+	var conflictsV = conflicts[v];
+	if (!conflictsV) conflicts[v] = conflictsV = {};
+	conflictsV[w] = true;
+}
+function hasConflict(conflicts, v, w) {
+	if (v > w) {
+		var tmp = v;
+		v = w;
+		w = tmp;
+	}
+	return _.has(conflicts[v], w);
+}
+function verticalAlignment(_g, layering, conflicts, neighborFn) {
+	var root = {}, align = {}, pos = {};
+	_.forEach(layering, (layer) => {
+		_.forEach(layer, (v, order) => {
+			root[v] = v;
+			align[v] = v;
+			pos[v] = order;
+		});
+	});
+	_.forEach(layering, (layer) => {
+		var prevIdx = -1;
+		_.forEach(layer, (v) => {
+			var ws = neighborFn(v);
+			if (ws.length) {
+				ws = _.sortBy(ws, (w) => pos[w]);
+				var mp = (ws.length - 1) / 2;
+				for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+					var w = ws[i];
+					if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+						align[w] = v;
+						align[v] = root[v] = root[w];
+						prevIdx = pos[w];
+					}
+				}
+			}
+		});
+	});
+	return {
+		root,
+		align
+	};
+}
+function horizontalCompaction(g, layering, root, align, reverseSep) {
+	var xs = {}, blockG = buildBlockGraph(g, layering, root, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
+	function iterate(setXsFunc, nextNodesFunc) {
+		var stack = blockG.nodes();
+		var elem = stack.pop();
+		var visited = {};
+		while (elem) {
+			if (visited[elem]) setXsFunc(elem);
+			else {
+				visited[elem] = true;
+				stack.push(elem);
+				stack = stack.concat(nextNodesFunc(elem));
+			}
+			elem = stack.pop();
+		}
+	}
+	function pass1(elem) {
+		xs[elem] = blockG.inEdges(elem).reduce((acc, e) => Math.max(acc, xs[e.v] + blockG.edge(e)), 0);
+	}
+	function pass2(elem) {
+		var min = blockG.outEdges(elem).reduce((acc, e) => Math.min(acc, xs[e.w] - blockG.edge(e)), Number.POSITIVE_INFINITY);
+		var node = g.node(elem);
+		if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) xs[elem] = Math.max(xs[elem], min);
+	}
+	iterate(pass1, blockG.predecessors.bind(blockG));
+	iterate(pass2, blockG.successors.bind(blockG));
+	_.forEach(align, (v) => {
+		xs[v] = xs[root[v]];
+	});
+	return xs;
+}
+function buildBlockGraph(g, layering, root, reverseSep) {
+	var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+	_.forEach(layering, (layer) => {
+		var u;
+		_.forEach(layer, (v) => {
+			var vRoot = root[v];
+			blockGraph.setNode(vRoot);
+			if (u) {
+				var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
+				blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
+			}
+			u = v;
+		});
+	});
+	return blockGraph;
+}
+function findSmallestWidthAlignment(g, xss) {
+	return _.minBy(_.values(xss), (xs) => {
+		var max = Number.NEGATIVE_INFINITY;
+		var min = Number.POSITIVE_INFINITY;
+		_.forIn(xs, (x, v) => {
+			var halfWidth = width(g, v) / 2;
+			max = Math.max(x + halfWidth, max);
+			min = Math.min(x - halfWidth, min);
+		});
+		return max - min;
+	});
+}
+function alignCoordinates(xss, alignTo) {
+	var alignToVals = _.values(alignTo), alignToMin = _.min(alignToVals), alignToMax = _.max(alignToVals);
+	_.forEach(["u", "d"], (vert) => {
+		_.forEach(["l", "r"], (horiz) => {
+			var alignment = vert + horiz, xs = xss[alignment], delta;
+			if (xs === alignTo) return;
+			var xsVals = _.values(xs);
+			delta = horiz === "l" ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);
+			if (delta) xss[alignment] = _.mapValues(xs, (x) => x + delta);
+		});
+	});
+}
+function balance(xss, align) {
+	return _.mapValues(xss.ul, (_ignore, v) => {
+		if (align) return xss[align.toLowerCase()][v];
+		else {
+			var xs = _.sortBy(_.map(xss, v));
+			return (xs[1] + xs[2]) / 2;
+		}
+	});
+}
+function positionX(g) {
+	var layering = buildLayerMatrix(g);
+	var conflicts = _.merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+	var xss = {};
+	var adjustedLayering;
+	_.forEach(["u", "d"], (vert) => {
+		adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
+		_.forEach(["l", "r"], (horiz) => {
+			if (horiz === "r") adjustedLayering = _.map(adjustedLayering, (inner) => _.values(inner).reverse());
+			var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
+			var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+			var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === "r");
+			if (horiz === "r") xs = _.mapValues(xs, (x) => -x);
+			xss[vert + horiz] = xs;
+		});
+	});
+	alignCoordinates(xss, findSmallestWidthAlignment(g, xss));
+	return balance(xss, g.graph().align);
+}
+function sep(nodeSep, edgeSep, reverseSep) {
+	return (g, v, w) => {
+		var vLabel = g.node(v);
+		var wLabel = g.node(w);
+		var sum = 0;
+		var delta;
+		sum += vLabel.width / 2;
+		if (_.has(vLabel, "labelpos")) switch (vLabel.labelpos.toLowerCase()) {
+			case "l":
+				delta = -vLabel.width / 2;
+				break;
+			case "r": delta = vLabel.width / 2;
+		}
+		if (delta) sum += reverseSep ? delta : -delta;
+		delta = 0;
+		sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
+		sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
+		sum += wLabel.width / 2;
+		if (_.has(wLabel, "labelpos")) switch (wLabel.labelpos.toLowerCase()) {
+			case "l":
+				delta = wLabel.width / 2;
+				break;
+			case "r": delta = -wLabel.width / 2;
+		}
+		if (delta) sum += reverseSep ? delta : -delta;
+		delta = 0;
+		return sum;
+	};
+}
+function width(g, v) {
+	return g.node(v).width;
+}
+//#endregion
+//#region src/dagre/position/index.js
+function position(g) {
+	g = asNonCompoundGraph(g);
+	positionY(g);
+	_.forOwn(positionX(g), (x, v) => {
+		g.node(v).x = x;
+	});
+}
+function positionY(g) {
+	var layering = buildLayerMatrix(g);
+	var rankSep = g.graph().ranksep;
+	var prevY = 0;
+	_.forEach(layering, (layer) => {
+		var maxHeight = _.max(_.map(layer, (v) => g.node(v).height));
+		_.forEach(layer, (v) => {
+			g.node(v).y = prevY + maxHeight / 2;
+		});
+		prevY += maxHeight + rankSep;
+	});
+}
+//#endregion
+//#region src/dagre/rank/util.js
+function longestPath(g) {
+	var visited = {};
+	function dfs(v) {
+		var label = g.node(v);
+		if (_.has(visited, v)) return label.rank;
+		visited[v] = true;
+		var rank = _.min(_.map(g.outEdges(v), (e) => dfs(e.w) - g.edge(e).minlen));
+		if (rank === Number.POSITIVE_INFINITY || rank === void 0 || rank === null) rank = 0;
+		return label.rank = rank;
+	}
+	_.forEach(g.sources(), dfs);
+}
+function slack(g, e) {
+	return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+}
+//#endregion
+//#region src/dagre/rank/feasible-tree.js
+function feasibleTree(g) {
+	var t = new Graph({ directed: false });
+	var start = g.nodes()[0];
+	var size = g.nodeCount();
+	t.setNode(start, {});
+	var edge, delta;
+	while (tightTree(t, g) < size) {
+		edge = findMinSlackEdge(t, g);
+		delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+		shiftRanks(t, g, delta);
+	}
+	return t;
+}
+function tightTree(t, g) {
+	function dfs(v) {
+		_.forEach(g.nodeEdges(v), (e) => {
+			var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
+			if (!t.hasNode(w) && !slack(g, e)) {
+				t.setNode(w, {});
+				t.setEdge(v, w, {});
+				dfs(w);
+			}
+		});
+	}
+	_.forEach(t.nodes(), dfs);
+	return t.nodeCount();
+}
+function findMinSlackEdge(t, g) {
+	return _.minBy(g.edges(), (e) => {
+		if (t.hasNode(e.v) !== t.hasNode(e.w)) return slack(g, e);
+	});
+}
+function shiftRanks(t, g, delta) {
+	_.forEach(t.nodes(), (v) => {
+		g.node(v).rank += delta;
+	});
+}
+_.constant(1);
+_.constant(1);
+//#endregion
+//#region src/graphlib/alg/topsort.js
+topsort.CycleException = CycleException;
+function topsort(g) {
+	var visited = {};
+	var stack = {};
+	var results = [];
+	function visit(node) {
+		if (_.has(stack, node)) throw new CycleException();
+		if (!_.has(visited, node)) {
+			stack[node] = true;
+			visited[node] = true;
+			_.each(g.predecessors(node), visit);
+			delete stack[node];
+			results.push(node);
+		}
+	}
+	_.each(g.sinks(), visit);
+	if (_.size(visited) !== g.nodeCount()) throw new CycleException();
+	return results;
+}
+function CycleException() {}
+CycleException.prototype = /* @__PURE__ */ new Error();
+//#endregion
+//#region src/graphlib/alg/dfs.js
+function dfs(g, vs, order) {
+	if (!_.isArray(vs)) vs = [vs];
+	var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
+	var acc = [];
+	var visited = {};
+	_.each(vs, (v) => {
+		if (!g.hasNode(v)) throw new Error(`Graph does not have node: ${v}`);
+		doDfs(g, v, order === "post", visited, navigation, acc);
+	});
+	return acc;
+}
+function doDfs(g, v, postorder, visited, navigation, acc) {
+	if (!_.has(visited, v)) {
+		visited[v] = true;
+		if (!postorder) acc.push(v);
+		_.each(navigation(v), (w) => {
+			doDfs(g, w, postorder, visited, navigation, acc);
+		});
+		if (postorder) acc.push(v);
+	}
+}
+//#endregion
+//#region src/graphlib/alg/postorder.js
+function postorder(g, vs) {
+	return dfs(g, vs, "post");
+}
+//#endregion
+//#region src/graphlib/alg/preorder.js
+function preorder(g, vs) {
+	return dfs(g, vs, "pre");
+}
+//#endregion
+//#region src/dagre/rank/network-simplex.js
+networkSimplex.initLowLimValues = initLowLimValues;
+networkSimplex.initCutValues = initCutValues;
+networkSimplex.calcCutValue = calcCutValue;
+networkSimplex.leaveEdge = leaveEdge;
+networkSimplex.enterEdge = enterEdge;
+networkSimplex.exchangeEdges = exchangeEdges;
+function networkSimplex(g) {
+	g = simplify(g);
+	longestPath(g);
+	var t = feasibleTree(g);
+	initLowLimValues(t);
+	initCutValues(t, g);
+	var e, f;
+	while (e = leaveEdge(t)) {
+		f = enterEdge(t, g, e);
+		exchangeEdges(t, g, e, f);
+	}
+}
+function initCutValues(t, g) {
+	var vs = postorder(t, t.nodes());
+	vs = vs.slice(0, vs.length - 1);
+	_.forEach(vs, (v) => {
+		assignCutValue(t, g, v);
+	});
+}
+function assignCutValue(t, g, child) {
+	var parent = t.node(child).parent;
+	t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+}
+function calcCutValue(t, g, child) {
+	var parent = t.node(child).parent;
+	var childIsTail = true;
+	var graphEdge = g.edge(child, parent);
+	var cutValue = 0;
+	if (!graphEdge) {
+		childIsTail = false;
+		graphEdge = g.edge(parent, child);
+	}
+	cutValue = graphEdge.weight;
+	_.forEach(g.nodeEdges(child), (e) => {
+		var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
+		if (other !== parent) {
+			var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
+			cutValue += pointsToHead ? otherWeight : -otherWeight;
+			if (isTreeEdge(t, child, other)) {
+				var otherCutValue = t.edge(child, other).cutvalue;
+				cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+			}
+		}
+	});
+	return cutValue;
+}
+function initLowLimValues(tree, root) {
+	if (arguments.length < 2) root = tree.nodes()[0];
+	dfsAssignLowLim(tree, {}, 1, root);
+}
+function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+	var low = nextLim;
+	var label = tree.node(v);
+	visited[v] = true;
+	_.forEach(tree.neighbors(v), (w) => {
+		if (!_.has(visited, w)) nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+	});
+	label.low = low;
+	label.lim = nextLim++;
+	if (parent) label.parent = parent;
+	else delete label.parent;
+	return nextLim;
+}
+function leaveEdge(tree) {
+	return _.find(tree.edges(), (e) => tree.edge(e).cutvalue < 0);
+}
+function enterEdge(t, g, edge) {
+	var v = edge.v;
+	var w = edge.w;
+	if (!g.hasEdge(v, w)) {
+		v = edge.w;
+		w = edge.v;
+	}
+	var vLabel = t.node(v);
+	var wLabel = t.node(w);
+	var tailLabel = vLabel;
+	var flip = false;
+	if (vLabel.lim > wLabel.lim) {
+		tailLabel = wLabel;
+		flip = true;
+	}
+	var candidates = _.filter(g.edges(), (edge) => flip === isDescendant(t, t.node(edge.v), tailLabel) && flip !== isDescendant(t, t.node(edge.w), tailLabel));
+	return _.minBy(candidates, (edge) => slack(g, edge));
+}
+function exchangeEdges(t, g, e, f) {
+	var v = e.v;
+	var w = e.w;
+	t.removeEdge(v, w);
+	t.setEdge(f.v, f.w, {});
+	initLowLimValues(t);
+	initCutValues(t, g);
+	updateRanks(t, g);
+}
+function updateRanks(t, g) {
+	var vs = preorder(t, _.find(t.nodes(), (v) => !g.node(v).parent));
+	vs = vs.slice(1);
+	_.forEach(vs, (v) => {
+		var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
+		if (!edge) {
+			edge = g.edge(parent, v);
+			flipped = true;
+		}
+		g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+	});
+}
+function isTreeEdge(tree, u, v) {
+	return tree.hasEdge(u, v);
+}
+function isDescendant(_tree, vLabel, rootLabel) {
+	return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
+}
+//#endregion
+//#region src/dagre/rank/index.js
+function rank(g) {
+	switch (g.graph().ranker) {
+		case "network-simplex":
+			networkSimplexRanker(g);
+			break;
+		case "tight-tree":
+			tightTreeRanker(g);
+			break;
+		case "longest-path":
+			longestPathRanker(g);
+			break;
+		default: networkSimplexRanker(g);
+	}
+}
+var longestPathRanker = longestPath;
+function tightTreeRanker(g) {
+	longestPath(g);
+	feasibleTree(g);
+}
+function networkSimplexRanker(g) {
+	networkSimplex(g);
+}
+//#endregion
+//#region src/dagre/layout.js
+function layout(g, opts) {
+	var time$1 = opts?.debugTiming ? time : notime;
+	time$1("layout", () => {
+		var layoutGraph = time$1("  buildLayoutGraph", () => buildLayoutGraph(g));
+		time$1("  runLayout", () => {
+			runLayout(layoutGraph, time$1);
+		});
+		time$1("  updateInputGraph", () => {
+			updateInputGraph(g, layoutGraph);
+		});
+	});
+}
+function runLayout(g, time) {
+	time("    makeSpaceForEdgeLabels", () => {
+		makeSpaceForEdgeLabels(g);
+	});
+	time("    removeSelfEdges", () => {
+		removeSelfEdges(g);
+	});
+	time("    acyclic", () => {
+		run$2(g);
+	});
+	time("    nestingGraph.run", () => {
+		run$1(g);
+	});
+	time("    rank", () => {
+		rank(asNonCompoundGraph(g));
+	});
+	time("    injectEdgeLabelProxies", () => {
+		injectEdgeLabelProxies(g);
+	});
+	time("    removeEmptyRanks", () => {
+		removeEmptyRanks(g);
+	});
+	time("    nestingGraph.cleanup", () => {
+		cleanup(g);
+	});
+	time("    normalizeRanks", () => {
+		normalizeRanks(g);
+	});
+	time("    assignRankMinMax", () => {
+		assignRankMinMax(g);
+	});
+	time("    removeEdgeLabelProxies", () => {
+		removeEdgeLabelProxies(g);
+	});
+	time("    normalize.run", () => {
+		run(g);
+	});
+	time("    parentDummyChains", () => {
+		parentDummyChains(g);
+	});
+	time("    addBorderSegments", () => {
+		addBorderSegments(g);
+	});
+	time("    order", () => {
+		order(g);
+	});
+	time("    insertSelfEdges", () => {
+		insertSelfEdges(g);
+	});
+	time("    adjustCoordinateSystem", () => {
+		adjust(g);
+	});
+	time("    position", () => {
+		position(g);
+	});
+	time("    positionSelfEdges", () => {
+		positionSelfEdges(g);
+	});
+	time("    removeBorderNodes", () => {
+		removeBorderNodes(g);
+	});
+	time("    normalize.undo", () => {
+		undo(g);
+	});
+	time("    fixupEdgeLabelCoords", () => {
+		fixupEdgeLabelCoords(g);
+	});
+	time("    undoCoordinateSystem", () => {
+		undo$1(g);
+	});
+	time("    translateGraph", () => {
+		translateGraph(g);
+	});
+	time("    assignNodeIntersects", () => {
+		assignNodeIntersects(g);
+	});
+	time("    reversePoints", () => {
+		reversePointsForReversedEdges(g);
+	});
+	time("    acyclic.undo", () => {
+		undo$2(g);
+	});
+}
+function updateInputGraph(inputGraph, layoutGraph) {
+	_.forEach(inputGraph.nodes(), (v) => {
+		var inputLabel = inputGraph.node(v);
+		var layoutLabel = layoutGraph.node(v);
+		if (inputLabel) {
+			inputLabel.x = layoutLabel.x;
+			inputLabel.y = layoutLabel.y;
+			if (layoutGraph.children(v).length) {
+				inputLabel.width = layoutLabel.width;
+				inputLabel.height = layoutLabel.height;
+			}
+		}
+	});
+	_.forEach(inputGraph.edges(), (e) => {
+		var inputLabel = inputGraph.edge(e);
+		var layoutLabel = layoutGraph.edge(e);
+		inputLabel.points = layoutLabel.points;
+		if (_.has(layoutLabel, "x")) {
+			inputLabel.x = layoutLabel.x;
+			inputLabel.y = layoutLabel.y;
+		}
+	});
+	inputGraph.graph().width = layoutGraph.graph().width;
+	inputGraph.graph().height = layoutGraph.graph().height;
+}
+var graphNumAttrs = [
+	"nodesep",
+	"edgesep",
+	"ranksep",
+	"marginx",
+	"marginy"
+];
+var graphDefaults = {
+	ranksep: 50,
+	edgesep: 20,
+	nodesep: 50,
+	rankdir: "tb"
+};
+var graphAttrs = [
+	"acyclicer",
+	"ranker",
+	"rankdir",
+	"align"
+];
+var nodeNumAttrs = ["width", "height"];
+var nodeDefaults = {
+	width: 0,
+	height: 0
+};
+var edgeNumAttrs = [
+	"minlen",
+	"weight",
+	"width",
+	"height",
+	"labeloffset"
+];
+var edgeDefaults = {
+	minlen: 1,
+	weight: 1,
+	width: 0,
+	height: 0,
+	labeloffset: 10,
+	labelpos: "r"
+};
+var edgeAttrs = ["labelpos"];
+function buildLayoutGraph(inputGraph) {
+	var g = new Graph({
+		multigraph: true,
+		compound: true
+	});
+	var graph = canonicalize(inputGraph.graph());
+	g.setGraph(_.merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), _.pick(graph, graphAttrs)));
+	_.forEach(inputGraph.nodes(), (v) => {
+		var node = canonicalize(inputGraph.node(v));
+		g.setNode(v, _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+		g.setParent(v, inputGraph.parent(v));
+	});
+	_.forEach(inputGraph.edges(), (e) => {
+		var edge = canonicalize(inputGraph.edge(e));
+		g.setEdge(e, _.merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), _.pick(edge, edgeAttrs)));
+	});
+	return g;
+}
+function makeSpaceForEdgeLabels(g) {
+	var graph = g.graph();
+	graph.ranksep /= 2;
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		edge.minlen *= 2;
+		if (edge.labelpos.toLowerCase() !== "c") {
+			if (graph.rankdir === "TB" || graph.rankdir === "BT") edge.width += edge.labeloffset;
+			else edge.height += edge.labeloffset;
+		}
+	});
+}
+function injectEdgeLabelProxies(g) {
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		if (edge.width && edge.height) {
+			var v = g.node(e.v);
+			addDummyNode(g, "edge-proxy", {
+				rank: (g.node(e.w).rank - v.rank) / 2 + v.rank,
+				e
+			}, "_ep");
+		}
+	});
+}
+function assignRankMinMax(g) {
+	var maxRank = 0;
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v);
+		if (node.borderTop) {
+			node.minRank = g.node(node.borderTop).rank;
+			node.maxRank = g.node(node.borderBottom).rank;
+			maxRank = _.max(maxRank, node.maxRank);
+		}
+	});
+	g.graph().maxRank = maxRank;
+}
+function removeEdgeLabelProxies(g) {
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v);
+		if (node.dummy === "edge-proxy") {
+			g.edge(node.e).labelRank = node.rank;
+			g.removeNode(v);
+		}
+	});
+}
+function translateGraph(g) {
+	var minX = Number.POSITIVE_INFINITY;
+	var maxX = 0;
+	var minY = Number.POSITIVE_INFINITY;
+	var maxY = 0;
+	var graphLabel = g.graph();
+	var marginX = graphLabel.marginx || 0;
+	var marginY = graphLabel.marginy || 0;
+	function getExtremes(attrs) {
+		var x = attrs.x;
+		var y = attrs.y;
+		var w = attrs.width;
+		var h = attrs.height;
+		minX = Math.min(minX, x - w / 2);
+		maxX = Math.max(maxX, x + w / 2);
+		minY = Math.min(minY, y - h / 2);
+		maxY = Math.max(maxY, y + h / 2);
+	}
+	_.forEach(g.nodes(), (v) => {
+		getExtremes(g.node(v));
+	});
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		if (_.has(edge, "x")) getExtremes(edge);
+	});
+	minX -= marginX;
+	minY -= marginY;
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v);
+		node.x -= minX;
+		node.y -= minY;
+	});
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		_.forEach(edge.points, (p) => {
+			p.x -= minX;
+			p.y -= minY;
+		});
+		if (_.has(edge, "x")) edge.x -= minX;
+		if (_.has(edge, "y")) edge.y -= minY;
+	});
+	graphLabel.width = maxX - minX + marginX;
+	graphLabel.height = maxY - minY + marginY;
+}
+function assignNodeIntersects(g) {
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		var nodeV = g.node(e.v);
+		var nodeW = g.node(e.w);
+		var p1, p2;
+		if (!edge.points) {
+			edge.points = [];
+			p1 = nodeW;
+			p2 = nodeV;
+		} else {
+			p1 = edge.points[0];
+			p2 = edge.points[edge.points.length - 1];
+		}
+		edge.points.unshift(intersectRect(nodeV, p1));
+		edge.points.push(intersectRect(nodeW, p2));
+	});
+}
+function fixupEdgeLabelCoords(g) {
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		if (_.has(edge, "x")) {
+			if (edge.labelpos === "l" || edge.labelpos === "r") edge.width -= edge.labeloffset;
+			switch (edge.labelpos) {
+				case "l":
+					edge.x -= edge.width / 2 + edge.labeloffset;
+					break;
+				case "r": edge.x += edge.width / 2 + edge.labeloffset;
+			}
+		}
+	});
+}
+function reversePointsForReversedEdges(g) {
+	_.forEach(g.edges(), (e) => {
+		var edge = g.edge(e);
+		if (edge.reversed) edge.points.reverse();
+	});
+}
+function removeBorderNodes(g) {
+	_.forEach(g.nodes(), (v) => {
+		if (g.children(v).length) {
+			var node = g.node(v);
+			var t = g.node(node.borderTop);
+			var b = g.node(node.borderBottom);
+			var l = g.node(_.last(node.borderLeft));
+			var r = g.node(_.last(node.borderRight));
+			node.width = Math.abs(r.x - l.x);
+			node.height = Math.abs(b.y - t.y);
+			node.x = l.x + node.width / 2;
+			node.y = t.y + node.height / 2;
+		}
+	});
+	_.forEach(g.nodes(), (v) => {
+		if (g.node(v).dummy === "border") g.removeNode(v);
+	});
+}
+function removeSelfEdges(g) {
+	_.forEach(g.edges(), (e) => {
+		if (e.v === e.w) {
+			var node = g.node(e.v);
+			if (!node.selfEdges) node.selfEdges = [];
+			node.selfEdges.push({
+				e,
+				label: g.edge(e)
+			});
+			g.removeEdge(e);
+		}
+	});
+}
+function insertSelfEdges(g) {
+	var layers = buildLayerMatrix(g);
+	_.forEach(layers, (layer) => {
+		var orderShift = 0;
+		_.forEach(layer, (v, i) => {
+			var node = g.node(v);
+			node.order = i + orderShift;
+			_.forEach(node.selfEdges, (selfEdge) => {
+				addDummyNode(g, "selfedge", {
+					width: selfEdge.label.width,
+					height: selfEdge.label.height,
+					rank: node.rank,
+					order: i + ++orderShift,
+					e: selfEdge.e,
+					label: selfEdge.label
+				}, "_se");
+			});
+			delete node.selfEdges;
+		});
+	});
+}
+function positionSelfEdges(g) {
+	_.forEach(g.nodes(), (v) => {
+		var node = g.node(v);
+		if (node.dummy === "selfedge") {
+			var selfNode = g.node(node.e.v);
+			var x = selfNode.x + selfNode.width / 2;
+			var y = selfNode.y;
+			var dx = node.x - x;
+			var dy = selfNode.height / 2;
+			g.setEdge(node.e, node.label);
+			g.removeNode(v);
+			node.label.points = [
+				{
+					x: x + 2 * dx / 3,
+					y: y - dy
+				},
+				{
+					x: x + 5 * dx / 6,
+					y: y - dy
+				},
+				{
+					x: x + dx,
+					y
+				},
+				{
+					x: x + 5 * dx / 6,
+					y: y + dy
+				},
+				{
+					x: x + 2 * dx / 3,
+					y: y + dy
+				}
+			];
+			node.label.x = node.x;
+			node.label.y = node.y;
+		}
+	});
+}
+function selectNumberAttrs(obj, attrs) {
+	return _.mapValues(_.pick(obj, attrs), Number);
+}
+function canonicalize(attrs) {
+	var newAttrs = {};
+	_.forEach(attrs, (v, k) => {
+		newAttrs[k.toLowerCase()] = v;
+	});
+	return newAttrs;
+}
+//#endregion
+//#region src/layout/buildFlatCharts.ts
+/**
+* Build graphs corresponding to the specified transitions.
+* @param transitions - The transitions between states.
+* @param newId - A function that generates unique ids for nodes and edges.
+* @param getStateParams - A function that returns the dimensions of a state node.
+* @param getTransitionParams - A function that returns the dimensions of a transition edge.
+* @param initialStateKey - The key for the initial state.
+* @param finalStateKey - The key for the final state.
+* @param vertical - Whether the graph should be vertical.
+* @returns {TransitionsGraph} - The graph with nodes and edges.
+*/
+function buildFlatCharts({ lodash, transitions = [], newId, getStateParams, getTransitionParams, padding = [5, 5], initialStateKey = "<initial>", finalStateKey = "<final>", vertical = false, direction }) {
+	const prevLodash = getLodash();
+	try {
+		setLodash(lodash);
+		const rankdir = direction || (vertical ? "tb" : "lr");
+		const graph = new Graph({
+			directed: true,
+			multigraph: true
+		}).setGraph({
+			rankdir,
+			multigraph: true
+		});
+		const nodesIndex = {};
+		const getStateNodeId = (key, state = key) => {
+			let id = nodesIndex[key];
+			if (!id) {
+				id = nodesIndex[key] = newId("s");
+				const params = getStateParams(key, state);
+				graph.setNode(id, {
+					id,
+					...params
+				});
+			}
+			return id;
+		};
+		for (const [fromState, event, toState] of transitions) {
+			const fromStateKey = fromState || initialStateKey;
+			const from = getStateNodeId(fromStateKey, fromState);
+			const toStateKey = toState || finalStateKey;
+			const to = getStateNodeId(toStateKey, toState);
+			const params = getTransitionParams(fromStateKey, event, toStateKey);
+			const edgeId = newId("t");
+			graph.setEdge(from, to, {
+				id: edgeId,
+				...params
+			}, edgeId);
+		}
+		layout(graph, { rankdir });
+		const [top, right, bottom, left] = getPadding(padding);
+		const nodes = graph.nodes().map((id) => {
+			const n = graph.node(id);
+			n.x += -n.width / 2;
+			n.y += -n.height / 2;
+			return n;
+		});
+		const edges = graph.edges().map(({ v, w, name }) => {
+			const e = graph.edge(v, w, name);
+			e.x += -e.width / 2;
+			e.y += -e.height / 2;
+			return e;
+		});
+		let x = 0;
+		let y = 0;
+		let width = 0;
+		let height = 0;
+		const addCoords = (node) => {
+			x = Math.min(x, node.x);
+			y = Math.min(y, node.y);
+			width = Math.max(width, node.x + node.width);
+			height = Math.max(height, node.y + node.height);
+		};
+		nodes.forEach(addCoords);
+		edges.forEach(addCoords);
+		edges.forEach((edge) => {
+			for (const point of edge.points) {
+				x = Math.min(x, edge.x);
+				y = Math.min(y, edge.y);
+				width = Math.max(width, point.x);
+				height = Math.max(height, point.y);
+			}
+		});
+		width += left + right;
+		height += bottom + top;
+		const updateCoords = (node) => {
+			node.x = Math.round(node.x + left);
+			node.y = Math.round(node.y + bottom);
+		};
+		const updateBox = (node) => {
+			updateCoords(node);
+			node.y = Math.round(node.y + node.height);
+		};
+		nodes.forEach(updateBox);
+		edges.forEach(updateBox);
+		edges.forEach((edge) => {
+			edge.points.forEach(updateCoords);
+		});
+		return {
+			x,
+			y,
+			width,
+			height,
+			nodes,
+			edges
+		};
+	} finally {
+		setLodash(prevLodash);
+	}
+}
+//#endregion
+//#region src/layout/buildCharts.ts
+/**
+* Build graphs corresponding to the specified transitions.
+* @param config - State configuration with transitions and sub-states.
+* @param newId - A function that generates unique ids for nodes and edges.
+* @param getStateParams - A function that returns the dimensions of a state node.
+* @param getTransitionParams - A function that returns the dimensions of a transition edge.
+* @param initialStateKey - The key for the initial state.
+* @param finalStateKey - The key for the final state.
+* @returns {StateChart} - The graph with nodes and edges.
+*/
+function buildCharts({ lodash, config, newId, getStateParams, getStateLabel = (stateKey) => stateKey.replace(/([a-z])([A-Z])/g, "$1 $2"), getTransitionParams, padding = [5, 5], vertical = false, initialStateKey = "<initial>", finalStateKey = "<final>", direction }) {
+	return buildChart(config);
+	function buildChart(config, id = newId("s"), stack = []) {
+		stack.push(config);
+		try {
+			const buildStateLabel = (state, key = state) => {
+				if (key === initialStateKey || key === finalStateKey) return "";
+				let result;
+				for (let i = stack.length - 1; result === void 0 && i >= 0; i--) {
+					const conf = stack[i];
+					if (!conf.states) continue;
+					for (const subState of conf.states) {
+						if (subState.key !== state) continue;
+						result = subState.label ?? getStateLabel(state);
+						break;
+					}
+				}
+				return result ?? getStateLabel(state) ?? state;
+			};
+			const graph = buildFlatCharts({
+				lodash,
+				transitions: config.transitions || [],
+				newId,
+				getStateParams: (state, key) => {
+					const params = getStateParams(state, key);
+					delete params.state;
+					params.text = buildStateLabel(state, key);
+					return params;
+				},
+				getTransitionParams,
+				padding,
+				initialStateKey,
+				finalStateKey,
+				vertical,
+				direction
+			});
+			const index = graph.nodes.reduce((index, node) => {
+				index[node.key] = node.id;
+				return index;
+			}, {});
+			const text = config.label ?? getStateLabel(config.key) ?? config.key;
+			const children = [];
+			if (config.states) for (const child of config.states) {
+				const childId = index[child.key];
+				children.push(buildChart(child, childId, [...stack]));
+			}
+			return {
+				id,
+				key: config.key,
+				text,
+				...graph,
+				children
+			};
+		} finally {}
+	}
+}
+//#endregion
+//#region src/layout/getLabelDimensions.ts
+function getLabelDimensions(label, { padding = 0, fontSize = 14, getCharWidth = () => fontSize / 1.61, lineGap = fontSize * .2 } = {}) {
+	const lines = [label];
+	let dimensions = {
+		width: 0,
+		height: 0
+	};
+	let lineNumber = 0;
+	for (const line of lines) {
+		if (lineNumber++) dimensions.height += lineGap;
+		dimensions = expandBox(dimensions, getLineDimensions({
+			line,
+			fontSize,
+			getCharWidth
+		}));
+	}
+	const [top, right, bottom, left] = getPadding(padding);
+	return {
+		width: Math.round(dimensions.width + left + right),
+		height: Math.round(dimensions.height + top + bottom)
+	};
+	function expandBox(dim1, dim2) {
+		return {
+			width: Math.round(Math.max(dim1.width, dim2.width)),
+			height: Math.round(dim1.height + dim2.height)
+		};
+	}
+	function getLineDimensions({ line, fontSize = 14, getCharWidth = () => fontSize }) {
+		return {
+			width: line.split("").reduce((w, c) => w += getCharWidth(c), 0),
+			height: fontSize
+		};
+	}
+}
+//#endregion
+//#region src/layout/getGraphParamsProvider.ts
+/**
+* Provides default functions measuring dimensions for state nodes and transition edges in the graph.
+* @param fontSize - The font size for the state and transition labels.
+* @param stateFontSize - The font size for the state labels.
+* @param stateTextPadding - The padding around the state labels.
+* @param transitionsFontSize - The font size for the transition labels.
+* @param transitionsTextPadding - The padding around the transition labels.
+*/
+function getGraphParamsProvider({ fontSize = 14, stateFontSize = fontSize, stateTextPadding = 0, transitionsFontSize = fontSize, transitionsTextPadding = 0, getStateLabel = (state) => state, getTransitionLabel = (_fromState, event, _toState) => event } = {}) {
+	return {
+		getStateParams: (stateKey, state = stateKey) => {
+			const padding = getPadding(stateTextPadding);
+			const fontSize = stateFontSize;
+			const stateLabel = getStateLabel(state);
+			return {
+				...getLabelDimensions(stateLabel, {
+					padding,
+					fontSize
+				}),
+				state,
+				text: stateLabel,
+				key: stateKey,
+				padding,
+				fontSize
+			};
+		},
+		getTransitionParams: (fromStateKey, event, toStateKey) => {
+			const padding = getPadding(transitionsTextPadding);
+			const fontSize = transitionsFontSize;
+			const eventLabel = getTransitionLabel(fromStateKey, event, toStateKey);
+			return {
+				...getLabelDimensions(eventLabel, {
+					padding,
+					fontSize
+				}),
+				from: fromStateKey,
+				event,
+				to: toStateKey,
+				text: eventLabel,
+				padding,
+				fontSize
+			};
+		}
+	};
+}
+//#endregion
+export { buildFlatCharts as i, getLabelDimensions as n, buildCharts as r, getGraphParamsProvider as t };
+
+//# sourceMappingURL=layout-Dp671N6q.js.map