@blueking/ai-blueking 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/vue3/dagre-DUjlMe_B.js

@@ -0,0 +1,1496 @@
+import { E as _arrayMap_default, _ as _castPath_default, c as filter_default, d as _baseIteratee_default, f as _baseProperty_default, g as _toKey_default, h as _baseGet_default, m as _hasPath_default, n as forEach_default, o as _baseFindIndex_default, p as hasIn_default, r as _castFunction_default, s as _baseFlatten_default, t as reduce_default, u as _baseForOwn_default, v as toString_default, x as keys_default, y as isSymbol_default } from "./reduce-BFKSG9Rs.js";
+import { D as _root_default, O as eq_default, T as _baseGetTag_default, f as _isIndex_default, g as isArray_default, h as isObjectLike_default, i as isArrayLike_default, n as identity_default, t as _baseFor_default, u as _baseUnary_default, w as isObject_default } from "./_baseFor-DAbrc8SN.js";
+import { i as _baseKeys_default, n as _getTag_default } from "./isEmpty-z27q3o-D.js";
+import { a as map_default, i as _baseExtremum_default, n as min_default, o as _baseMap_default, r as _baseLt_default, t as flatten_default } from "./flatten-CfPhNHUL.js";
+import { C as _overRest_default, E as _assignValue_default, P as _baseAssignValue_default, S as constant_default, b as _baseRest_default, v as merge_default, w as keysIn_default, x as _setToString_default, y as _isIterateeCall_default } from "./chunk-S3R3BYOJ-Bs_r55Kk.js";
+import { i as _baseClone_default, n as isUndefined_default, r as values_default, t as Graph } from "./graphlib-KDKEjVHX.js";
+var reWhitespace = /\s/;
+function trimmedEndIndex(u) {
+	for (var z = u.length; z-- && reWhitespace.test(u.charAt(z)););
+	return z;
+}
+var _trimmedEndIndex_default = trimmedEndIndex, reTrimStart = /^\s+/;
+function baseTrim(u) {
+	return u && u.slice(0, _trimmedEndIndex_default(u) + 1).replace(reTrimStart, "");
+}
+var _baseTrim_default = baseTrim, NAN = NaN, reIsBadHex = /^[-+]0x[0-9a-f]+$/i, reIsBinary = /^0b[01]+$/i, reIsOctal = /^0o[0-7]+$/i, freeParseInt = parseInt;
+function toNumber(u) {
+	if (typeof u == "number") return u;
+	if (isSymbol_default(u)) return NAN;
+	if (isObject_default(u)) {
+		var z = typeof u.valueOf == "function" ? u.valueOf() : u;
+		u = isObject_default(z) ? z + "" : z;
+	}
+	if (typeof u != "string") return u === 0 ? u : +u;
+	u = _baseTrim_default(u);
+	var B = reIsBinary.test(u);
+	return B || reIsOctal.test(u) ? freeParseInt(u.slice(2), B ? 2 : 8) : reIsBadHex.test(u) ? NAN : +u;
+}
+var toNumber_default = toNumber, INFINITY = Infinity, MAX_INTEGER = 17976931348623157e292;
+function toFinite(u) {
+	return u ? (u = toNumber_default(u), u === INFINITY || u === -INFINITY ? (u < 0 ? -1 : 1) * MAX_INTEGER : u === u ? u : 0) : u === 0 ? u : 0;
+}
+var toFinite_default = toFinite;
+function toInteger(u) {
+	var z = toFinite_default(u), B = z % 1;
+	return z === z ? B ? z - B : z : 0;
+}
+var toInteger_default = toInteger;
+function flatRest(u) {
+	return _setToString_default(_overRest_default(u, void 0, flatten_default), u + "");
+}
+var _flatRest_default = flatRest, reHasUnicode = RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");
+function hasUnicode(u) {
+	return reHasUnicode.test(u);
+}
+var _hasUnicode_default = hasUnicode, CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
+function cloneDeep(u) {
+	return _baseClone_default(u, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+var cloneDeep_default = cloneDeep, now_default = function() {
+	return _root_default.Date.now();
+}, objectProto = Object.prototype, hasOwnProperty$1 = objectProto.hasOwnProperty, defaults_default = _baseRest_default(function(u, z) {
+	u = Object(u);
+	var B = -1, V = z.length, H = V > 2 ? z[2] : void 0;
+	for (H && _isIterateeCall_default(z[0], z[1], H) && (V = 1); ++B < V;) for (var U = z[B], W = keysIn_default(U), G = -1, K = W.length; ++G < K;) {
+		var q = W[G], J = u[q];
+		(J === void 0 || eq_default(J, objectProto[q]) && !hasOwnProperty$1.call(u, q)) && (u[q] = U[q]);
+	}
+	return u;
+});
+function last(u) {
+	var z = u == null ? 0 : u.length;
+	return z ? u[z - 1] : void 0;
+}
+var last_default = last;
+function createFind(u) {
+	return function(z, B, H) {
+		var U = Object(z);
+		if (!isArrayLike_default(z)) {
+			var W = _baseIteratee_default(B, 3);
+			z = keys_default(z), B = function(u) {
+				return W(U[u], u, U);
+			};
+		}
+		var G = u(z, B, H);
+		return G > -1 ? U[W ? z[G] : G] : void 0;
+	};
+}
+var _createFind_default = createFind, nativeMax$1 = Math.max;
+function findIndex(u, z, B) {
+	var H = u == null ? 0 : u.length;
+	if (!H) return -1;
+	var U = B == null ? 0 : toInteger_default(B);
+	return U < 0 && (U = nativeMax$1(H + U, 0)), _baseFindIndex_default(u, _baseIteratee_default(z, 3), U);
+}
+var find_default = _createFind_default(findIndex);
+function forIn(u, z) {
+	return u == null ? u : _baseFor_default(u, _castFunction_default(z), keysIn_default);
+}
+var forIn_default = forIn;
+function forOwn(u, z) {
+	return u && _baseForOwn_default(u, _castFunction_default(z));
+}
+var forOwn_default = forOwn;
+function baseGt(u, z) {
+	return u > z;
+}
+var _baseGt_default = baseGt, hasOwnProperty = Object.prototype.hasOwnProperty;
+function baseHas(u, z) {
+	return u != null && hasOwnProperty.call(u, z);
+}
+var _baseHas_default = baseHas;
+function has(u, z) {
+	return u != null && _hasPath_default(u, z, _baseHas_default);
+}
+var has_default = has, stringTag = "[object String]";
+function isString(u) {
+	return typeof u == "string" || !isArray_default(u) && isObjectLike_default(u) && _baseGetTag_default(u) == stringTag;
+}
+var isString_default = isString;
+function mapValues(u, z) {
+	var B = {};
+	return z = _baseIteratee_default(z, 3), _baseForOwn_default(u, function(u, V, H) {
+		_baseAssignValue_default(B, V, z(u, V, H));
+	}), B;
+}
+var mapValues_default = mapValues;
+function max(u) {
+	return u && u.length ? _baseExtremum_default(u, identity_default, _baseGt_default) : void 0;
+}
+var max_default = max;
+function minBy(u, z) {
+	return u && u.length ? _baseExtremum_default(u, _baseIteratee_default(z, 2), _baseLt_default) : void 0;
+}
+var minBy_default = minBy;
+function baseSet(u, B, V, H) {
+	if (!isObject_default(u)) return u;
+	B = _castPath_default(B, u);
+	for (var W = -1, G = B.length, K = G - 1, q = u; q != null && ++W < G;) {
+		var J = _toKey_default(B[W]), Y = V;
+		if (J === "__proto__" || J === "constructor" || J === "prototype") return u;
+		if (W != K) {
+			var X = q[J];
+			Y = H ? H(X, J, q) : void 0, Y === void 0 && (Y = isObject_default(X) ? X : _isIndex_default(B[W + 1]) ? [] : {});
+		}
+		_assignValue_default(q, J, Y), q = q[J];
+	}
+	return u;
+}
+var _baseSet_default = baseSet;
+function basePickBy(u, B, V) {
+	for (var H = -1, U = B.length, G = {}; ++H < U;) {
+		var K = B[H], q = _baseGet_default(u, K);
+		V(q, K) && _baseSet_default(G, _castPath_default(K, u), q);
+	}
+	return G;
+}
+var _basePickBy_default = basePickBy;
+function baseSortBy(u, z) {
+	var B = u.length;
+	for (u.sort(z); B--;) u[B] = u[B].value;
+	return u;
+}
+var _baseSortBy_default = baseSortBy;
+function compareAscending(u, z) {
+	if (u !== z) {
+		var B = u !== void 0, V = u === null, H = u === u, U = isSymbol_default(u), W = z !== void 0, G = z === null, K = z === z, q = isSymbol_default(z);
+		if (!G && !q && !U && u > z || U && W && K && !G && !q || V && W && K || !B && K || !H) return 1;
+		if (!V && !U && !q && u < z || q && B && H && !V && !U || G && B && H || !W && H || !K) return -1;
+	}
+	return 0;
+}
+var _compareAscending_default = compareAscending;
+function compareMultiple(u, z, B) {
+	for (var V = -1, H = u.criteria, U = z.criteria, W = H.length, G = B.length; ++V < W;) {
+		var K = _compareAscending_default(H[V], U[V]);
+		if (K) return V >= G ? K : K * (B[V] == "desc" ? -1 : 1);
+	}
+	return u.index - z.index;
+}
+var _compareMultiple_default = compareMultiple;
+function baseOrderBy(z, B, H) {
+	B = B.length ? _arrayMap_default(B, function(u) {
+		return isArray_default(u) ? function(z) {
+			return _baseGet_default(z, u.length === 1 ? u[0] : u);
+		} : u;
+	}) : [identity_default];
+	var U = -1;
+	return B = _arrayMap_default(B, _baseUnary_default(_baseIteratee_default)), _baseSortBy_default(_baseMap_default(z, function(z, V, H) {
+		return {
+			criteria: _arrayMap_default(B, function(u) {
+				return u(z);
+			}),
+			index: ++U,
+			value: z
+		};
+	}), function(u, z) {
+		return _compareMultiple_default(u, z, H);
+	});
+}
+var _baseOrderBy_default = baseOrderBy, _asciiSize_default = _baseProperty_default("length"), rsAstralRange = "\\ud800-\\udfff", rsComboRange = "\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff", rsVarRange = "\\ufe0e\\ufe0f", rsAstral = "[" + rsAstralRange + "]", rsCombo = "[" + rsComboRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ = "\\u200d", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [
+	rsNonAstral,
+	rsRegional,
+	rsSurrPair
+].join("|") + ")" + rsOptVar + reOptMod + ")*", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsSymbol = "(?:" + [
+	rsNonAstral + rsCombo + "?",
+	rsCombo,
+	rsRegional,
+	rsSurrPair,
+	rsAstral
+].join("|") + ")", reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeSize(u) {
+	for (var z = reUnicode.lastIndex = 0; reUnicode.test(u);) ++z;
+	return z;
+}
+var _unicodeSize_default = unicodeSize;
+function stringSize(u) {
+	return _hasUnicode_default(u) ? _unicodeSize_default(u) : _asciiSize_default(u);
+}
+var _stringSize_default = stringSize;
+function basePick(u, z) {
+	return _basePickBy_default(u, z, function(z, B) {
+		return hasIn_default(u, B);
+	});
+}
+var _basePick_default = basePick, pick_default = _flatRest_default(function(u, z) {
+	return u == null ? {} : _basePick_default(u, z);
+}), nativeCeil = Math.ceil, nativeMax = Math.max;
+function baseRange(u, z, B, V) {
+	for (var H = -1, U = nativeMax(nativeCeil((z - u) / (B || 1)), 0), W = Array(U); U--;) W[V ? U : ++H] = u, u += B;
+	return W;
+}
+var _baseRange_default = baseRange;
+function createRange(u) {
+	return function(z, B, V) {
+		return V && typeof V != "number" && _isIterateeCall_default(z, B, V) && (B = V = void 0), z = toFinite_default(z), B === void 0 ? (B = z, z = 0) : B = toFinite_default(B), V = V === void 0 ? z < B ? 1 : -1 : toFinite_default(V), _baseRange_default(z, B, V, u);
+	};
+}
+var range_default = createRange(), mapTag = "[object Map]", setTag = "[object Set]";
+function size(u) {
+	if (u == null) return 0;
+	if (isArrayLike_default(u)) return isString_default(u) ? _stringSize_default(u) : u.length;
+	var z = _getTag_default(u);
+	return z == mapTag || z == setTag ? u.size : _baseKeys_default(u).length;
+}
+var size_default = size, sortBy_default = _baseRest_default(function(u, z) {
+	if (u == null) return [];
+	var B = z.length;
+	return B > 1 && _isIterateeCall_default(u, z[0], z[1]) ? z = [] : B > 2 && _isIterateeCall_default(z[0], z[1], z[2]) && (z = [z[0]]), _baseOrderBy_default(u, _baseFlatten_default(z, 1), []);
+}), idCounter = 0;
+function uniqueId(u) {
+	var z = ++idCounter;
+	return toString_default(u) + z;
+}
+var uniqueId_default = uniqueId;
+function baseZipObject(u, z, B) {
+	for (var V = -1, H = u.length, U = z.length, W = {}; ++V < H;) {
+		var G = V < U ? z[V] : void 0;
+		B(W, u[V], G);
+	}
+	return W;
+}
+var _baseZipObject_default = baseZipObject;
+function zipObject(u, z) {
+	return _baseZipObject_default(u || [], z || [], _assignValue_default);
+}
+var zipObject_default = zipObject, List = class {
+	constructor() {
+		var u = {};
+		u._next = u._prev = u, this._sentinel = u;
+	}
+	dequeue() {
+		var u = this._sentinel, z = u._prev;
+		if (z !== u) return unlink(z), z;
+	}
+	enqueue(u) {
+		var z = this._sentinel;
+		u._prev && u._next && unlink(u), u._next = z._next, z._next._prev = u, z._next = u, u._prev = z;
+	}
+	toString() {
+		for (var u = [], z = this._sentinel, B = z._prev; B !== z;) u.push(JSON.stringify(B, filterOutLinks)), B = B._prev;
+		return "[" + u.join(", ") + "]";
+	}
+};
+function unlink(u) {
+	u._prev._next = u._next, u._next._prev = u._prev, delete u._next, delete u._prev;
+}
+function filterOutLinks(u, z) {
+	if (u !== "_next" && u !== "_prev") return z;
+}
+var DEFAULT_WEIGHT_FN = constant_default(1);
+function greedyFAS(u, z) {
+	if (u.nodeCount() <= 1) return [];
+	var B = buildState(u, z || DEFAULT_WEIGHT_FN);
+	return flatten_default(map_default(doGreedyFAS(B.graph, B.buckets, B.zeroIdx), function(z) {
+		return u.outEdges(z.v, z.w);
+	}));
+}
+function doGreedyFAS(u, z, B) {
+	for (var V = [], H = z[z.length - 1], U = z[0], W; u.nodeCount();) {
+		for (; W = U.dequeue();) removeNode(u, z, B, W);
+		for (; W = H.dequeue();) removeNode(u, z, B, W);
+		if (u.nodeCount()) {
+			for (var G = z.length - 2; G > 0; --G) if (W = z[G].dequeue(), W) {
+				V = V.concat(removeNode(u, z, B, W, !0));
+				break;
+			}
+		}
+	}
+	return V;
+}
+function removeNode(u, z, B, V, H) {
+	var U = H ? [] : void 0;
+	return forEach_default(u.inEdges(V.v), function(V) {
+		var W = u.edge(V), G = u.node(V.v);
+		H && U.push({
+			v: V.v,
+			w: V.w
+		}), G.out -= W, assignBucket(z, B, G);
+	}), forEach_default(u.outEdges(V.v), function(V) {
+		var H = u.edge(V), U = V.w, W = u.node(U);
+		W.in -= H, assignBucket(z, B, W);
+	}), u.removeNode(V.v), U;
+}
+function buildState(u, z) {
+	var B = new Graph(), V = 0, H = 0;
+	forEach_default(u.nodes(), function(u) {
+		B.setNode(u, {
+			v: u,
+			in: 0,
+			out: 0
+		});
+	}), forEach_default(u.edges(), function(u) {
+		var U = B.edge(u.v, u.w) || 0, W = z(u), G = U + W;
+		B.setEdge(u.v, u.w, G), H = Math.max(H, B.node(u.v).out += W), V = Math.max(V, B.node(u.w).in += W);
+	});
+	var U = range_default(H + V + 3).map(function() {
+		return new List();
+	}), W = V + 1;
+	return forEach_default(B.nodes(), function(u) {
+		assignBucket(U, W, B.node(u));
+	}), {
+		graph: B,
+		buckets: U,
+		zeroIdx: W
+	};
+}
+function assignBucket(u, z, B) {
+	B.out ? B.in ? u[B.out - B.in + z].enqueue(B) : u[u.length - 1].enqueue(B) : u[0].enqueue(B);
+}
+function run$2(u) {
+	forEach_default(u.graph().acyclicer === "greedy" ? greedyFAS(u, z(u)) : dfsFAS(u), function(z) {
+		var B = u.edge(z);
+		u.removeEdge(z), B.forwardName = z.name, B.reversed = !0, u.setEdge(z.w, z.v, B, uniqueId_default("rev"));
+	});
+	function z(u) {
+		return function(z) {
+			return u.edge(z).weight;
+		};
+	}
+}
+function dfsFAS(u) {
+	var z = [], B = {}, V = {};
+	function H(U) {
+		Object.prototype.hasOwnProperty.call(V, U) || (V[U] = !0, B[U] = !0, forEach_default(u.outEdges(U), function(u) {
+			Object.prototype.hasOwnProperty.call(B, u.w) ? z.push(u) : H(u.w);
+		}), delete B[U]);
+	}
+	return forEach_default(u.nodes(), H), z;
+}
+function undo$2(u) {
+	forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		if (B.reversed) {
+			u.removeEdge(z);
+			var V = B.forwardName;
+			delete B.reversed, delete B.forwardName, u.setEdge(z.w, z.v, B, V);
+		}
+	});
+}
+function addDummyNode(u, z, B, V) {
+	var H;
+	do
+		H = uniqueId_default(V);
+	while (u.hasNode(H));
+	return B.dummy = z, u.setNode(H, B), H;
+}
+function simplify(u) {
+	var z = new Graph().setGraph(u.graph());
+	return forEach_default(u.nodes(), function(B) {
+		z.setNode(B, u.node(B));
+	}), forEach_default(u.edges(), function(B) {
+		var V = z.edge(B.v, B.w) || {
+			weight: 0,
+			minlen: 1
+		}, H = u.edge(B);
+		z.setEdge(B.v, B.w, {
+			weight: V.weight + H.weight,
+			minlen: Math.max(V.minlen, H.minlen)
+		});
+	}), z;
+}
+function asNonCompoundGraph(u) {
+	var z = new Graph({ multigraph: u.isMultigraph() }).setGraph(u.graph());
+	return forEach_default(u.nodes(), function(B) {
+		u.children(B).length || z.setNode(B, u.node(B));
+	}), forEach_default(u.edges(), function(B) {
+		z.setEdge(B, u.edge(B));
+	}), z;
+}
+function intersectRect(u, z) {
+	var B = u.x, V = u.y, H = z.x - B, U = z.y - V, W = u.width / 2, G = u.height / 2;
+	if (!H && !U) throw Error("Not possible to find intersection inside of the rectangle");
+	var K, q;
+	return Math.abs(U) * W > Math.abs(H) * G ? (U < 0 && (G = -G), K = G * H / U, q = G) : (H < 0 && (W = -W), K = W, q = W * U / H), {
+		x: B + K,
+		y: V + q
+	};
+}
+function buildLayerMatrix(u) {
+	var z = map_default(range_default(maxRank(u) + 1), function() {
+		return [];
+	});
+	return forEach_default(u.nodes(), function(B) {
+		var V = u.node(B), H = V.rank;
+		isUndefined_default(H) || (z[H][V.order] = B);
+	}), z;
+}
+function normalizeRanks(u) {
+	var z = min_default(map_default(u.nodes(), function(z) {
+		return u.node(z).rank;
+	}));
+	forEach_default(u.nodes(), function(B) {
+		var V = u.node(B);
+		has_default(V, "rank") && (V.rank -= z);
+	});
+}
+function removeEmptyRanks(u) {
+	var z = min_default(map_default(u.nodes(), function(z) {
+		return u.node(z).rank;
+	})), B = [];
+	forEach_default(u.nodes(), function(V) {
+		var H = u.node(V).rank - z;
+		B[H] || (B[H] = []), B[H].push(V);
+	});
+	var V = 0, H = u.graph().nodeRankFactor;
+	forEach_default(B, function(z, B) {
+		isUndefined_default(z) && B % H !== 0 ? --V : V && forEach_default(z, function(z) {
+			u.node(z).rank += V;
+		});
+	});
+}
+function addBorderNode$1(u, z, B, V) {
+	var H = {
+		width: 0,
+		height: 0
+	};
+	return arguments.length >= 4 && (H.rank = B, H.order = V), addDummyNode(u, "border", H, z);
+}
+function maxRank(u) {
+	return max_default(map_default(u.nodes(), function(z) {
+		var B = u.node(z).rank;
+		if (!isUndefined_default(B)) return B;
+	}));
+}
+function partition(u, z) {
+	var B = {
+		lhs: [],
+		rhs: []
+	};
+	return forEach_default(u, function(u) {
+		z(u) ? B.lhs.push(u) : B.rhs.push(u);
+	}), B;
+}
+function time(u, z) {
+	var B = now_default();
+	try {
+		return z();
+	} finally {
+		console.log(u + " time: " + (now_default() - B) + "ms");
+	}
+}
+function notime(u, z) {
+	return z();
+}
+function addBorderSegments(u) {
+	function z(B) {
+		var V = u.children(B), H = u.node(B);
+		if (V.length && forEach_default(V, z), Object.prototype.hasOwnProperty.call(H, "minRank")) {
+			H.borderLeft = [], H.borderRight = [];
+			for (var U = H.minRank, W = H.maxRank + 1; U < W; ++U) addBorderNode(u, "borderLeft", "_bl", B, H, U), addBorderNode(u, "borderRight", "_br", B, H, U);
+		}
+	}
+	forEach_default(u.children(), z);
+}
+function addBorderNode(u, z, B, V, H, U) {
+	var W = {
+		width: 0,
+		height: 0,
+		rank: U,
+		borderType: z
+	}, G = H[z][U - 1], K = addDummyNode(u, "border", W, B);
+	H[z][U] = K, u.setParent(K, V), G && u.setEdge(G, K, { weight: 1 });
+}
+function adjust(u) {
+	var z = u.graph().rankdir.toLowerCase();
+	(z === "lr" || z === "rl") && swapWidthHeight(u);
+}
+function undo$1(u) {
+	var z = u.graph().rankdir.toLowerCase();
+	(z === "bt" || z === "rl") && reverseY(u), (z === "lr" || z === "rl") && (swapXY(u), swapWidthHeight(u));
+}
+function swapWidthHeight(u) {
+	forEach_default(u.nodes(), function(z) {
+		swapWidthHeightOne(u.node(z));
+	}), forEach_default(u.edges(), function(z) {
+		swapWidthHeightOne(u.edge(z));
+	});
+}
+function swapWidthHeightOne(u) {
+	var z = u.width;
+	u.width = u.height, u.height = z;
+}
+function reverseY(u) {
+	forEach_default(u.nodes(), function(z) {
+		reverseYOne(u.node(z));
+	}), forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		forEach_default(B.points, reverseYOne), Object.prototype.hasOwnProperty.call(B, "y") && reverseYOne(B);
+	});
+}
+function reverseYOne(u) {
+	u.y = -u.y;
+}
+function swapXY(u) {
+	forEach_default(u.nodes(), function(z) {
+		swapXYOne(u.node(z));
+	}), forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		forEach_default(B.points, swapXYOne), Object.prototype.hasOwnProperty.call(B, "x") && swapXYOne(B);
+	});
+}
+function swapXYOne(u) {
+	var z = u.x;
+	u.x = u.y, u.y = z;
+}
+function run$1(u) {
+	u.graph().dummyChains = [], forEach_default(u.edges(), function(z) {
+		normalizeEdge(u, z);
+	});
+}
+function normalizeEdge(u, z) {
+	var B = z.v, V = u.node(B).rank, H = z.w, U = u.node(H).rank, W = z.name, G = u.edge(z), K = G.labelRank;
+	if (U !== V + 1) {
+		u.removeEdge(z);
+		var q = void 0, J, Y;
+		for (Y = 0, ++V; V < U; ++Y, ++V) G.points = [], q = {
+			width: 0,
+			height: 0,
+			edgeLabel: G,
+			edgeObj: z,
+			rank: V
+		}, J = addDummyNode(u, "edge", q, "_d"), V === K && (q.width = G.width, q.height = G.height, q.dummy = "edge-label", q.labelpos = G.labelpos), u.setEdge(B, J, { weight: G.weight }, W), Y === 0 && u.graph().dummyChains.push(J), B = J;
+		u.setEdge(B, H, { weight: G.weight }, W);
+	}
+}
+function undo(u) {
+	forEach_default(u.graph().dummyChains, function(z) {
+		var B = u.node(z), V = B.edgeLabel, H;
+		for (u.setEdge(B.edgeObj, V); B.dummy;) H = u.successors(z)[0], u.removeNode(z), V.points.push({
+			x: B.x,
+			y: B.y
+		}), B.dummy === "edge-label" && (V.x = B.x, V.y = B.y, V.width = B.width, V.height = B.height), z = H, B = u.node(z);
+	});
+}
+function longestPath(u) {
+	var z = {};
+	function B(V) {
+		var H = u.node(V);
+		if (Object.prototype.hasOwnProperty.call(z, V)) return H.rank;
+		z[V] = !0;
+		var U = min_default(map_default(u.outEdges(V), function(z) {
+			return B(z.w) - u.edge(z).minlen;
+		}));
+		return (U === Infinity || U == null) && (U = 0), H.rank = U;
+	}
+	forEach_default(u.sources(), B);
+}
+function slack(u, z) {
+	return u.node(z.w).rank - u.node(z.v).rank - u.edge(z).minlen;
+}
+function feasibleTree(u) {
+	var z = new Graph({ directed: !1 }), B = u.nodes()[0], V = u.nodeCount();
+	z.setNode(B, {});
+	for (var H, U; tightTree(z, u) < V;) H = findMinSlackEdge(z, u), U = z.hasNode(H.v) ? slack(u, H) : -slack(u, H), shiftRanks(z, u, U);
+	return z;
+}
+function tightTree(u, z) {
+	function B(V) {
+		forEach_default(z.nodeEdges(V), function(H) {
+			var U = H.v, W = V === U ? H.w : U;
+			!u.hasNode(W) && !slack(z, H) && (u.setNode(W, {}), u.setEdge(V, W, {}), B(W));
+		});
+	}
+	return forEach_default(u.nodes(), B), u.nodeCount();
+}
+function findMinSlackEdge(u, z) {
+	return minBy_default(z.edges(), function(B) {
+		if (u.hasNode(B.v) !== u.hasNode(B.w)) return slack(z, B);
+	});
+}
+function shiftRanks(u, z, B) {
+	forEach_default(u.nodes(), function(u) {
+		z.node(u).rank += B;
+	});
+}
+constant_default(1), constant_default(1), topsort.CycleException = CycleException;
+function topsort(u) {
+	var z = {}, B = {}, V = [];
+	function H(U) {
+		if (Object.prototype.hasOwnProperty.call(B, U)) throw new CycleException();
+		Object.prototype.hasOwnProperty.call(z, U) || (B[U] = !0, z[U] = !0, forEach_default(u.predecessors(U), H), delete B[U], V.push(U));
+	}
+	if (forEach_default(u.sinks(), H), size_default(z) !== u.nodeCount()) throw new CycleException();
+	return V;
+}
+function CycleException() {}
+CycleException.prototype = /* @__PURE__ */ Error();
+function dfs$1(u, z, B) {
+	isArray_default(z) || (z = [z]);
+	var V = (u.isDirected() ? u.successors : u.neighbors).bind(u), H = [], U = {};
+	return forEach_default(z, function(z) {
+		if (!u.hasNode(z)) throw Error("Graph does not have node: " + z);
+		doDfs(u, z, B === "post", U, V, H);
+	}), H;
+}
+function doDfs(u, z, B, V, H, U) {
+	Object.prototype.hasOwnProperty.call(V, z) || (V[z] = !0, B || U.push(z), forEach_default(H(z), function(z) {
+		doDfs(u, z, B, V, H, U);
+	}), B && U.push(z));
+}
+function postorder$1(u, z) {
+	return dfs$1(u, z, "post");
+}
+function preorder(u, z) {
+	return dfs$1(u, z, "pre");
+}
+networkSimplex.initLowLimValues = initLowLimValues, networkSimplex.initCutValues = initCutValues, networkSimplex.calcCutValue = calcCutValue, networkSimplex.leaveEdge = leaveEdge, networkSimplex.enterEdge = enterEdge, networkSimplex.exchangeEdges = exchangeEdges;
+function networkSimplex(u) {
+	u = simplify(u), longestPath(u);
+	var z = feasibleTree(u);
+	initLowLimValues(z), initCutValues(z, u);
+	for (var B, V; B = leaveEdge(z);) V = enterEdge(z, u, B), exchangeEdges(z, u, B, V);
+}
+function initCutValues(u, z) {
+	var B = postorder$1(u, u.nodes());
+	B = B.slice(0, B.length - 1), forEach_default(B, function(B) {
+		assignCutValue(u, z, B);
+	});
+}
+function assignCutValue(u, z, B) {
+	var V = u.node(B).parent;
+	u.edge(B, V).cutvalue = calcCutValue(u, z, B);
+}
+function calcCutValue(u, z, B) {
+	var V = u.node(B).parent, H = !0, U = z.edge(B, V), W = 0;
+	return U ||= (H = !1, z.edge(V, B)), W = U.weight, forEach_default(z.nodeEdges(B), function(U) {
+		var G = U.v === B, K = G ? U.w : U.v;
+		if (K !== V) {
+			var q = G === H, J = z.edge(U).weight;
+			if (W += q ? J : -J, isTreeEdge(u, B, K)) {
+				var Y = u.edge(B, K).cutvalue;
+				W += q ? -Y : Y;
+			}
+		}
+	}), W;
+}
+function initLowLimValues(u, z) {
+	arguments.length < 2 && (z = u.nodes()[0]), dfsAssignLowLim(u, {}, 1, z);
+}
+function dfsAssignLowLim(u, z, B, V, H) {
+	var U = B, W = u.node(V);
+	return z[V] = !0, forEach_default(u.neighbors(V), function(H) {
+		Object.prototype.hasOwnProperty.call(z, H) || (B = dfsAssignLowLim(u, z, B, H, V));
+	}), W.low = U, W.lim = B++, H ? W.parent = H : delete W.parent, B;
+}
+function leaveEdge(u) {
+	return find_default(u.edges(), function(z) {
+		return u.edge(z).cutvalue < 0;
+	});
+}
+function enterEdge(u, z, V) {
+	var H = V.v, U = V.w;
+	z.hasEdge(H, U) || (H = V.w, U = V.v);
+	var W = u.node(H), G = u.node(U), K = W, q = !1;
+	return W.lim > G.lim && (K = G, q = !0), minBy_default(filter_default(z.edges(), function(z) {
+		return q === isDescendant(u, u.node(z.v), K) && q !== isDescendant(u, u.node(z.w), K);
+	}), function(u) {
+		return slack(z, u);
+	});
+}
+function exchangeEdges(u, z, B, V) {
+	var H = B.v, U = B.w;
+	u.removeEdge(H, U), u.setEdge(V.v, V.w, {}), initLowLimValues(u), initCutValues(u, z), updateRanks(u, z);
+}
+function updateRanks(u, z) {
+	var B = preorder(u, find_default(u.nodes(), function(u) {
+		return !z.node(u).parent;
+	}));
+	B = B.slice(1), forEach_default(B, function(B) {
+		var V = u.node(B).parent, H = z.edge(B, V), U = !1;
+		H || (H = z.edge(V, B), U = !0), z.node(B).rank = z.node(V).rank + (U ? H.minlen : -H.minlen);
+	});
+}
+function isTreeEdge(u, z, B) {
+	return u.hasEdge(z, B);
+}
+function isDescendant(u, z, B) {
+	return B.low <= z.lim && z.lim <= B.lim;
+}
+function rank(u) {
+	switch (u.graph().ranker) {
+		case "network-simplex":
+			networkSimplexRanker(u);
+			break;
+		case "tight-tree":
+			tightTreeRanker(u);
+			break;
+		case "longest-path":
+			longestPathRanker(u);
+			break;
+		default: networkSimplexRanker(u);
+	}
+}
+var longestPathRanker = longestPath;
+function tightTreeRanker(u) {
+	longestPath(u), feasibleTree(u);
+}
+function networkSimplexRanker(u) {
+	networkSimplex(u);
+}
+function run(u) {
+	var z = addDummyNode(u, "root", {}, "_root"), B = treeDepths(u), V = max_default(values_default(B)) - 1, H = 2 * V + 1;
+	u.graph().nestingRoot = z, forEach_default(u.edges(), function(z) {
+		u.edge(z).minlen *= H;
+	});
+	var U = sumWeights(u) + 1;
+	forEach_default(u.children(), function(W) {
+		dfs(u, z, H, U, V, B, W);
+	}), u.graph().nodeRankFactor = H;
+}
+function dfs(u, z, B, V, H, U, W) {
+	var G = u.children(W);
+	if (!G.length) {
+		W !== z && u.setEdge(z, W, {
+			weight: 0,
+			minlen: B
+		});
+		return;
+	}
+	var q = addBorderNode$1(u, "_bt"), J = addBorderNode$1(u, "_bb"), Y = u.node(W);
+	u.setParent(q, W), Y.borderTop = q, u.setParent(J, W), Y.borderBottom = J, forEach_default(G, function(G) {
+		dfs(u, z, B, V, H, U, G);
+		var K = u.node(G), Y = K.borderTop ? K.borderTop : G, X = K.borderBottom ? K.borderBottom : G, Z = K.borderTop ? V : 2 * V, Q = Y === X ? H - U[W] + 1 : 1;
+		u.setEdge(q, Y, {
+			weight: Z,
+			minlen: Q,
+			nestingEdge: !0
+		}), u.setEdge(X, J, {
+			weight: Z,
+			minlen: Q,
+			nestingEdge: !0
+		});
+	}), u.parent(W) || u.setEdge(z, q, {
+		weight: 0,
+		minlen: H + U[W]
+	});
+}
+function treeDepths(u) {
+	var z = {};
+	function B(V, H) {
+		var U = u.children(V);
+		U && U.length && forEach_default(U, function(u) {
+			B(u, H + 1);
+		}), z[V] = H;
+	}
+	return forEach_default(u.children(), function(u) {
+		B(u, 1);
+	}), z;
+}
+function sumWeights(u) {
+	return reduce_default(u.edges(), function(z, B) {
+		return z + u.edge(B).weight;
+	}, 0);
+}
+function cleanup(u) {
+	var z = u.graph();
+	u.removeNode(z.nestingRoot), delete z.nestingRoot, forEach_default(u.edges(), function(z) {
+		u.edge(z).nestingEdge && u.removeEdge(z);
+	});
+}
+function addSubgraphConstraints(u, z, B) {
+	var V = {}, H;
+	forEach_default(B, function(B) {
+		for (var U = u.parent(B), W, G; U;) {
+			if (W = u.parent(U), W ? (G = V[W], V[W] = U) : (G = H, H = U), G && G !== U) {
+				z.setEdge(G, U);
+				return;
+			}
+			U = W;
+		}
+	});
+}
+function buildLayerGraph(u, z, B) {
+	var V = createRootNode(u), H = new Graph({ compound: !0 }).setGraph({ root: V }).setDefaultNodeLabel(function(z) {
+		return u.node(z);
+	});
+	return forEach_default(u.nodes(), function(U) {
+		var W = u.node(U), G = u.parent(U);
+		(W.rank === z || W.minRank <= z && z <= W.maxRank) && (H.setNode(U), H.setParent(U, G || V), forEach_default(u[B](U), function(z) {
+			var B = z.v === U ? z.w : z.v, V = H.edge(B, U), W = isUndefined_default(V) ? 0 : V.weight;
+			H.setEdge(B, U, { weight: u.edge(z).weight + W });
+		}), Object.prototype.hasOwnProperty.call(W, "minRank") && H.setNode(U, {
+			borderLeft: W.borderLeft[z],
+			borderRight: W.borderRight[z]
+		}));
+	}), H;
+}
+function createRootNode(u) {
+	for (var z; u.hasNode(z = uniqueId_default("_root")););
+	return z;
+}
+function crossCount(u, z) {
+	for (var B = 0, V = 1; V < z.length; ++V) B += twoLayerCrossCount(u, z[V - 1], z[V]);
+	return B;
+}
+function twoLayerCrossCount(u, z, B) {
+	for (var V = zipObject_default(B, map_default(B, function(u, z) {
+		return z;
+	})), H = flatten_default(map_default(z, function(z) {
+		return sortBy_default(map_default(u.outEdges(z), function(z) {
+			return {
+				pos: V[z.w],
+				weight: u.edge(z).weight
+			};
+		}), "pos");
+	})), U = 1; U < B.length;) U <<= 1;
+	var W = 2 * U - 1;
+	--U;
+	var G = map_default(Array(W), function() {
+		return 0;
+	}), q = 0;
+	return forEach_default(H.forEach(function(u) {
+		var z = u.pos + U;
+		G[z] += u.weight;
+		for (var B = 0; z > 0;) z % 2 && (B += G[z + 1]), z = z - 1 >> 1, G[z] += u.weight;
+		q += u.weight * B;
+	})), q;
+}
+function initOrder(u) {
+	var z = {}, V = filter_default(u.nodes(), function(z) {
+		return !u.children(z).length;
+	}), H = map_default(range_default(max_default(map_default(V, function(z) {
+		return u.node(z).rank;
+	})) + 1), function() {
+		return [];
+	});
+	function U(B) {
+		has_default(z, B) || (z[B] = !0, H[u.node(B).rank].push(B), forEach_default(u.successors(B), U));
+	}
+	return forEach_default(sortBy_default(V, function(z) {
+		return u.node(z).rank;
+	}), U), H;
+}
+function barycenter(u, z) {
+	return map_default(z, function(z) {
+		var B = u.inEdges(z);
+		if (B.length) {
+			var V = reduce_default(B, function(z, B) {
+				var V = u.edge(B), H = u.node(B.v);
+				return {
+					sum: z.sum + V.weight * H.order,
+					weight: z.weight + V.weight
+				};
+			}, {
+				sum: 0,
+				weight: 0
+			});
+			return {
+				v: z,
+				barycenter: V.sum / V.weight,
+				weight: V.weight
+			};
+		} else return { v: z };
+	});
+}
+function resolveConflicts(u, z) {
+	var V = {};
+	return forEach_default(u, function(u, z) {
+		var B = V[u.v] = {
+			indegree: 0,
+			in: [],
+			out: [],
+			vs: [u.v],
+			i: z
+		};
+		isUndefined_default(u.barycenter) || (B.barycenter = u.barycenter, B.weight = u.weight);
+	}), forEach_default(z.edges(), function(u) {
+		var z = V[u.v], B = V[u.w];
+		!isUndefined_default(z) && !isUndefined_default(B) && (B.indegree++, z.out.push(V[u.w]));
+	}), doResolveConflicts(filter_default(V, function(u) {
+		return !u.indegree;
+	}));
+}
+function doResolveConflicts(u) {
+	var z = [];
+	function V(u) {
+		return function(z) {
+			z.merged || (isUndefined_default(z.barycenter) || isUndefined_default(u.barycenter) || z.barycenter >= u.barycenter) && mergeEntries(u, z);
+		};
+	}
+	function H(z) {
+		return function(B) {
+			B.in.push(z), --B.indegree === 0 && u.push(B);
+		};
+	}
+	for (; u.length;) {
+		var U = u.pop();
+		z.push(U), forEach_default(U.in.reverse(), V(U)), forEach_default(U.out, H(U));
+	}
+	return map_default(filter_default(z, function(u) {
+		return !u.merged;
+	}), function(u) {
+		return pick_default(u, [
+			"vs",
+			"i",
+			"barycenter",
+			"weight"
+		]);
+	});
+}
+function mergeEntries(u, z) {
+	var B = 0, V = 0;
+	u.weight && (B += u.barycenter * u.weight, V += u.weight), z.weight && (B += z.barycenter * z.weight, V += z.weight), u.vs = z.vs.concat(u.vs), u.barycenter = B / V, u.weight = V, u.i = Math.min(z.i, u.i), z.merged = !0;
+}
+function sort(u, z) {
+	var B = partition(u, function(u) {
+		return Object.prototype.hasOwnProperty.call(u, "barycenter");
+	}), V = B.lhs, H = sortBy_default(B.rhs, function(u) {
+		return -u.i;
+	}), U = [], W = 0, G = 0, q = 0;
+	V.sort(compareWithBias(!!z)), q = consumeUnsortable(U, H, q), forEach_default(V, function(u) {
+		q += u.vs.length, U.push(u.vs), W += u.barycenter * u.weight, G += u.weight, q = consumeUnsortable(U, H, q);
+	});
+	var J = { vs: flatten_default(U) };
+	return G && (J.barycenter = W / G, J.weight = G), J;
+}
+function consumeUnsortable(u, z, B) {
+	for (var V; z.length && (V = last_default(z)).i <= B;) z.pop(), u.push(V.vs), B++;
+	return B;
+}
+function compareWithBias(u) {
+	return function(z, B) {
+		return z.barycenter < B.barycenter ? -1 : z.barycenter > B.barycenter ? 1 : u ? B.i - z.i : z.i - B.i;
+	};
+}
+function sortSubgraph(u, z, V, H) {
+	var U = u.children(z), W = u.node(z), G = W ? W.borderLeft : void 0, q = W ? W.borderRight : void 0, J = {};
+	G && (U = filter_default(U, function(u) {
+		return u !== G && u !== q;
+	}));
+	var Y = barycenter(u, U);
+	forEach_default(Y, function(z) {
+		if (u.children(z.v).length) {
+			var B = sortSubgraph(u, z.v, V, H);
+			J[z.v] = B, Object.prototype.hasOwnProperty.call(B, "barycenter") && mergeBarycenters(z, B);
+		}
+	});
+	var X = resolveConflicts(Y, V);
+	expandSubgraphs(X, J);
+	var Z = sort(X, H);
+	if (G && (Z.vs = flatten_default([
+		G,
+		Z.vs,
+		q
+	]), u.predecessors(G).length)) {
+		var Q = u.node(u.predecessors(G)[0]), $ = u.node(u.predecessors(q)[0]);
+		Object.prototype.hasOwnProperty.call(Z, "barycenter") || (Z.barycenter = 0, Z.weight = 0), Z.barycenter = (Z.barycenter * Z.weight + Q.order + $.order) / (Z.weight + 2), Z.weight += 2;
+	}
+	return Z;
+}
+function expandSubgraphs(u, z) {
+	forEach_default(u, function(u) {
+		u.vs = flatten_default(u.vs.map(function(u) {
+			return z[u] ? z[u].vs : u;
+		}));
+	});
+}
+function mergeBarycenters(u, z) {
+	isUndefined_default(u.barycenter) ? (u.barycenter = z.barycenter, u.weight = z.weight) : (u.barycenter = (u.barycenter * u.weight + z.barycenter * z.weight) / (u.weight + z.weight), u.weight += z.weight);
+}
+function order(u) {
+	var z = maxRank(u), B = buildLayerGraphs(u, range_default(1, z + 1), "inEdges"), V = buildLayerGraphs(u, range_default(z - 1, -1, -1), "outEdges"), H = initOrder(u);
+	assignOrder(u, H);
+	for (var U = Infinity, W, G = 0, K = 0; K < 4; ++G, ++K) {
+		sweepLayerGraphs(G % 2 ? B : V, G % 4 >= 2), H = buildLayerMatrix(u);
+		var q = crossCount(u, H);
+		q < U && (K = 0, W = cloneDeep_default(H), U = q);
+	}
+	assignOrder(u, W);
+}
+function buildLayerGraphs(u, z, B) {
+	return map_default(z, function(z) {
+		return buildLayerGraph(u, z, B);
+	});
+}
+function sweepLayerGraphs(u, z) {
+	var B = new Graph();
+	forEach_default(u, function(u) {
+		var V = u.graph().root, H = sortSubgraph(u, V, B, z);
+		forEach_default(H.vs, function(z, B) {
+			u.node(z).order = B;
+		}), addSubgraphConstraints(u, B, H.vs);
+	});
+}
+function assignOrder(u, z) {
+	forEach_default(z, function(z) {
+		forEach_default(z, function(z, B) {
+			u.node(z).order = B;
+		});
+	});
+}
+function parentDummyChains(u) {
+	var z = postorder(u);
+	forEach_default(u.graph().dummyChains, function(B) {
+		for (var V = u.node(B), H = V.edgeObj, U = findPath(u, z, H.v, H.w), W = U.path, G = U.lca, K = 0, q = W[K], J = !0; B !== H.w;) {
+			if (V = u.node(B), J) {
+				for (; (q = W[K]) !== G && u.node(q).maxRank < V.rank;) K++;
+				q === G && (J = !1);
+			}
+			if (!J) {
+				for (; K < W.length - 1 && u.node(q = W[K + 1]).minRank <= V.rank;) K++;
+				q = W[K];
+			}
+			u.setParent(B, q), B = u.successors(B)[0];
+		}
+	});
+}
+function findPath(u, z, B, V) {
+	var H = [], U = [], W = Math.min(z[B].low, z[V].low), G = Math.max(z[B].lim, z[V].lim), K = B, q;
+	do
+		K = u.parent(K), H.push(K);
+	while (K && (z[K].low > W || G > z[K].lim));
+	for (q = K, K = V; (K = u.parent(K)) !== q;) U.push(K);
+	return {
+		path: H.concat(U.reverse()),
+		lca: q
+	};
+}
+function postorder(u) {
+	var z = {}, B = 0;
+	function V(H) {
+		var U = B;
+		forEach_default(u.children(H), V), z[H] = {
+			low: U,
+			lim: B++
+		};
+	}
+	return forEach_default(u.children(), V), z;
+}
+function findType1Conflicts(u, z) {
+	var B = {};
+	function V(z, V) {
+		var H = 0, U = 0, W = z.length, G = last_default(V);
+		return forEach_default(V, function(z, q) {
+			var J = findOtherInnerSegmentNode(u, z), Y = J ? u.node(J).order : W;
+			(J || z === G) && (forEach_default(V.slice(U, q + 1), function(z) {
+				forEach_default(u.predecessors(z), function(V) {
+					var U = u.node(V), W = U.order;
+					(W < H || Y < W) && !(U.dummy && u.node(z).dummy) && addConflict(B, V, z);
+				});
+			}), U = q + 1, H = Y);
+		}), V;
+	}
+	return reduce_default(z, V), B;
+}
+function findType2Conflicts(u, z) {
+	var B = {};
+	function V(z, V, H, U, W) {
+		var G;
+		forEach_default(range_default(V, H), function(V) {
+			G = z[V], u.node(G).dummy && forEach_default(u.predecessors(G), function(z) {
+				var V = u.node(z);
+				V.dummy && (V.order < U || V.order > W) && addConflict(B, z, G);
+			});
+		});
+	}
+	function H(z, B) {
+		var H = -1, U, W = 0;
+		return forEach_default(B, function(G, K) {
+			if (u.node(G).dummy === "border") {
+				var q = u.predecessors(G);
+				q.length && (U = u.node(q[0]).order, V(B, W, K, H, U), W = K, H = U);
+			}
+			V(B, W, B.length, U, z.length);
+		}), B;
+	}
+	return reduce_default(z, H), B;
+}
+function findOtherInnerSegmentNode(u, z) {
+	if (u.node(z).dummy) return find_default(u.predecessors(z), function(z) {
+		return u.node(z).dummy;
+	});
+}
+function addConflict(u, z, B) {
+	if (z > B) {
+		var V = z;
+		z = B, B = V;
+	}
+	Object.prototype.hasOwnProperty.call(u, z) || Object.defineProperty(u, z, {
+		enumerable: !0,
+		configurable: !0,
+		value: {},
+		writable: !0
+	});
+	var H = u[z];
+	Object.defineProperty(H, B, {
+		enumerable: !0,
+		configurable: !0,
+		value: !0,
+		writable: !0
+	});
+}
+function hasConflict(u, z, B) {
+	if (z > B) {
+		var V = z;
+		z = B, B = V;
+	}
+	return !!u[z] && Object.prototype.hasOwnProperty.call(u[z], B);
+}
+function verticalAlignment(u, z, B, V) {
+	var H = {}, U = {}, W = {};
+	return forEach_default(z, function(u) {
+		forEach_default(u, function(u, z) {
+			H[u] = u, U[u] = u, W[u] = z;
+		});
+	}), forEach_default(z, function(u) {
+		var z = -1;
+		forEach_default(u, function(u) {
+			var G = V(u);
+			if (G.length) {
+				G = sortBy_default(G, function(u) {
+					return W[u];
+				});
+				for (var K = (G.length - 1) / 2, q = Math.floor(K), J = Math.ceil(K); q <= J; ++q) {
+					var Y = G[q];
+					U[u] === u && z < W[Y] && !hasConflict(B, u, Y) && (U[Y] = u, U[u] = H[u] = H[Y], z = W[Y]);
+				}
+			}
+		});
+	}), {
+		root: H,
+		align: U
+	};
+}
+function horizontalCompaction(u, z, B, V, H) {
+	var U = {}, W = buildBlockGraph(u, z, B, H), G = H ? "borderLeft" : "borderRight";
+	function q(u, z) {
+		for (var B = W.nodes(), V = B.pop(), H = {}; V;) H[V] ? u(V) : (H[V] = !0, B.push(V), B = B.concat(z(V))), V = B.pop();
+	}
+	function J(u) {
+		U[u] = W.inEdges(u).reduce(function(u, z) {
+			return Math.max(u, U[z.v] + W.edge(z));
+		}, 0);
+	}
+	function Y(z) {
+		var B = W.outEdges(z).reduce(function(u, z) {
+			return Math.min(u, U[z.w] - W.edge(z));
+		}, Infinity), V = u.node(z);
+		B !== Infinity && V.borderType !== G && (U[z] = Math.max(U[z], B));
+	}
+	return q(J, W.predecessors.bind(W)), q(Y, W.successors.bind(W)), forEach_default(V, function(u) {
+		U[u] = U[B[u]];
+	}), U;
+}
+function buildBlockGraph(u, z, B, V) {
+	var H = new Graph(), U = u.graph(), W = sep(U.nodesep, U.edgesep, V);
+	return forEach_default(z, function(z) {
+		var V;
+		forEach_default(z, function(z) {
+			var U = B[z];
+			if (H.setNode(U), V) {
+				var G = B[V], K = H.edge(G, U);
+				H.setEdge(G, U, Math.max(W(u, z, V), K || 0));
+			}
+			V = z;
+		});
+	}), H;
+}
+function findSmallestWidthAlignment(u, z) {
+	return minBy_default(values_default(z), function(z) {
+		var B = -Infinity, V = Infinity;
+		return forIn_default(z, function(z, H) {
+			var U = width(u, H) / 2;
+			B = Math.max(z + U, B), V = Math.min(z - U, V);
+		}), B - V;
+	});
+}
+function alignCoordinates(u, z) {
+	var B = values_default(z), V = min_default(B), H = max_default(B);
+	forEach_default(["u", "d"], function(B) {
+		forEach_default(["l", "r"], function(U) {
+			var W = B + U, G = u[W], K;
+			if (G !== z) {
+				var q = values_default(G);
+				K = U === "l" ? V - min_default(q) : H - max_default(q), K && (u[W] = mapValues_default(G, function(u) {
+					return u + K;
+				}));
+			}
+		});
+	});
+}
+function balance(u, z) {
+	return mapValues_default(u.ul, function(B, V) {
+		if (z) return u[z.toLowerCase()][V];
+		var H = sortBy_default(map_default(u, V));
+		return (H[1] + H[2]) / 2;
+	});
+}
+function positionX(u) {
+	var z = buildLayerMatrix(u), B = merge_default(findType1Conflicts(u, z), findType2Conflicts(u, z)), V = {}, H;
+	return forEach_default(["u", "d"], function(U) {
+		H = U === "u" ? z : values_default(z).reverse(), forEach_default(["l", "r"], function(z) {
+			z === "r" && (H = map_default(H, function(u) {
+				return values_default(u).reverse();
+			}));
+			var W = (U === "u" ? u.predecessors : u.successors).bind(u), G = verticalAlignment(u, H, B, W), K = horizontalCompaction(u, H, G.root, G.align, z === "r");
+			z === "r" && (K = mapValues_default(K, function(u) {
+				return -u;
+			})), V[U + z] = K;
+		});
+	}), alignCoordinates(V, findSmallestWidthAlignment(u, V)), balance(V, u.graph().align);
+}
+function sep(u, z, B) {
+	return function(V, H, U) {
+		var W = V.node(H), G = V.node(U), K = 0, q;
+		if (K += W.width / 2, Object.prototype.hasOwnProperty.call(W, "labelpos")) switch (W.labelpos.toLowerCase()) {
+			case "l":
+				q = -W.width / 2;
+				break;
+			case "r":
+				q = W.width / 2;
+				break;
+		}
+		if (q && (K += B ? q : -q), q = 0, K += (W.dummy ? z : u) / 2, K += (G.dummy ? z : u) / 2, K += G.width / 2, Object.prototype.hasOwnProperty.call(G, "labelpos")) switch (G.labelpos.toLowerCase()) {
+			case "l":
+				q = G.width / 2;
+				break;
+			case "r":
+				q = -G.width / 2;
+				break;
+		}
+		return q && (K += B ? q : -q), q = 0, K;
+	};
+}
+function width(u, z) {
+	return u.node(z).width;
+}
+function position(u) {
+	u = asNonCompoundGraph(u), positionY(u), forOwn_default(positionX(u), function(z, B) {
+		u.node(B).x = z;
+	});
+}
+function positionY(u) {
+	var z = buildLayerMatrix(u), B = u.graph().ranksep, V = 0;
+	forEach_default(z, function(z) {
+		var H = max_default(map_default(z, function(z) {
+			return u.node(z).height;
+		}));
+		forEach_default(z, function(z) {
+			u.node(z).y = V + H / 2;
+		}), V += H + B;
+	});
+}
+function layout(u, z) {
+	var B = z && z.debugTiming ? time : notime;
+	B("layout", () => {
+		var z = B("  buildLayoutGraph", () => buildLayoutGraph(u));
+		B("  runLayout", () => runLayout(z, B)), B("  updateInputGraph", () => updateInputGraph(u, z));
+	});
+}
+function runLayout(u, z) {
+	z("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(u)), z("    removeSelfEdges", () => removeSelfEdges(u)), z("    acyclic", () => run$2(u)), z("    nestingGraph.run", () => run(u)), z("    rank", () => rank(asNonCompoundGraph(u))), z("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(u)), z("    removeEmptyRanks", () => removeEmptyRanks(u)), z("    nestingGraph.cleanup", () => cleanup(u)), z("    normalizeRanks", () => normalizeRanks(u)), z("    assignRankMinMax", () => assignRankMinMax(u)), z("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(u)), z("    normalize.run", () => run$1(u)), z("    parentDummyChains", () => parentDummyChains(u)), z("    addBorderSegments", () => addBorderSegments(u)), z("    order", () => order(u)), z("    insertSelfEdges", () => insertSelfEdges(u)), z("    adjustCoordinateSystem", () => adjust(u)), z("    position", () => position(u)), z("    positionSelfEdges", () => positionSelfEdges(u)), z("    removeBorderNodes", () => removeBorderNodes(u)), z("    normalize.undo", () => undo(u)), z("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(u)), z("    undoCoordinateSystem", () => undo$1(u)), z("    translateGraph", () => translateGraph(u)), z("    assignNodeIntersects", () => assignNodeIntersects(u)), z("    reversePoints", () => reversePointsForReversedEdges(u)), z("    acyclic.undo", () => undo$2(u));
+}
+function updateInputGraph(u, z) {
+	forEach_default(u.nodes(), function(B) {
+		var V = u.node(B), H = z.node(B);
+		V && (V.x = H.x, V.y = H.y, z.children(B).length && (V.width = H.width, V.height = H.height));
+	}), forEach_default(u.edges(), function(B) {
+		var V = u.edge(B), H = z.edge(B);
+		V.points = H.points, Object.prototype.hasOwnProperty.call(H, "x") && (V.x = H.x, V.y = H.y);
+	}), u.graph().width = z.graph().width, u.graph().height = z.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(u) {
+	var z = new Graph({
+		multigraph: !0,
+		compound: !0
+	}), B = canonicalize(u.graph());
+	return z.setGraph(merge_default({}, graphDefaults, selectNumberAttrs(B, graphNumAttrs), pick_default(B, graphAttrs))), forEach_default(u.nodes(), function(B) {
+		var V = canonicalize(u.node(B));
+		z.setNode(B, defaults_default(selectNumberAttrs(V, nodeNumAttrs), nodeDefaults)), z.setParent(B, u.parent(B));
+	}), forEach_default(u.edges(), function(B) {
+		var V = canonicalize(u.edge(B));
+		z.setEdge(B, merge_default({}, edgeDefaults, selectNumberAttrs(V, edgeNumAttrs), pick_default(V, edgeAttrs)));
+	}), z;
+}
+function makeSpaceForEdgeLabels(u) {
+	var z = u.graph();
+	z.ranksep /= 2, forEach_default(u.edges(), function(B) {
+		var V = u.edge(B);
+		V.minlen *= 2, V.labelpos.toLowerCase() !== "c" && (z.rankdir === "TB" || z.rankdir === "BT" ? V.width += V.labeloffset : V.height += V.labeloffset);
+	});
+}
+function injectEdgeLabelProxies(u) {
+	forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		if (B.width && B.height) {
+			var V = u.node(z.v);
+			addDummyNode(u, "edge-proxy", {
+				rank: (u.node(z.w).rank - V.rank) / 2 + V.rank,
+				e: z
+			}, "_ep");
+		}
+	});
+}
+function assignRankMinMax(u) {
+	var z = 0;
+	forEach_default(u.nodes(), function(B) {
+		var V = u.node(B);
+		V.borderTop && (V.minRank = u.node(V.borderTop).rank, V.maxRank = u.node(V.borderBottom).rank, z = max_default(z, V.maxRank));
+	}), u.graph().maxRank = z;
+}
+function removeEdgeLabelProxies(u) {
+	forEach_default(u.nodes(), function(z) {
+		var B = u.node(z);
+		B.dummy === "edge-proxy" && (u.edge(B.e).labelRank = B.rank, u.removeNode(z));
+	});
+}
+function translateGraph(u) {
+	var z = Infinity, B = 0, V = Infinity, H = 0, U = u.graph(), W = U.marginx || 0, G = U.marginy || 0;
+	function q(u) {
+		var U = u.x, W = u.y, G = u.width, K = u.height;
+		z = Math.min(z, U - G / 2), B = Math.max(B, U + G / 2), V = Math.min(V, W - K / 2), H = Math.max(H, W + K / 2);
+	}
+	forEach_default(u.nodes(), function(z) {
+		q(u.node(z));
+	}), forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		Object.prototype.hasOwnProperty.call(B, "x") && q(B);
+	}), z -= W, V -= G, forEach_default(u.nodes(), function(B) {
+		var H = u.node(B);
+		H.x -= z, H.y -= V;
+	}), forEach_default(u.edges(), function(B) {
+		var H = u.edge(B);
+		forEach_default(H.points, function(u) {
+			u.x -= z, u.y -= V;
+		}), Object.prototype.hasOwnProperty.call(H, "x") && (H.x -= z), Object.prototype.hasOwnProperty.call(H, "y") && (H.y -= V);
+	}), U.width = B - z + W, U.height = H - V + G;
+}
+function assignNodeIntersects(u) {
+	forEach_default(u.edges(), function(z) {
+		var B = u.edge(z), V = u.node(z.v), H = u.node(z.w), U, W;
+		B.points ? (U = B.points[0], W = B.points[B.points.length - 1]) : (B.points = [], U = H, W = V), B.points.unshift(intersectRect(V, U)), B.points.push(intersectRect(H, W));
+	});
+}
+function fixupEdgeLabelCoords(u) {
+	forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		if (Object.prototype.hasOwnProperty.call(B, "x")) switch ((B.labelpos === "l" || B.labelpos === "r") && (B.width -= B.labeloffset), B.labelpos) {
+			case "l":
+				B.x -= B.width / 2 + B.labeloffset;
+				break;
+			case "r":
+				B.x += B.width / 2 + B.labeloffset;
+				break;
+		}
+	});
+}
+function reversePointsForReversedEdges(u) {
+	forEach_default(u.edges(), function(z) {
+		var B = u.edge(z);
+		B.reversed && B.points.reverse();
+	});
+}
+function removeBorderNodes(u) {
+	forEach_default(u.nodes(), function(z) {
+		if (u.children(z).length) {
+			var B = u.node(z), V = u.node(B.borderTop), H = u.node(B.borderBottom), U = u.node(last_default(B.borderLeft)), W = u.node(last_default(B.borderRight));
+			B.width = Math.abs(W.x - U.x), B.height = Math.abs(H.y - V.y), B.x = U.x + B.width / 2, B.y = V.y + B.height / 2;
+		}
+	}), forEach_default(u.nodes(), function(z) {
+		u.node(z).dummy === "border" && u.removeNode(z);
+	});
+}
+function removeSelfEdges(u) {
+	forEach_default(u.edges(), function(z) {
+		if (z.v === z.w) {
+			var B = u.node(z.v);
+			B.selfEdges ||= [], B.selfEdges.push({
+				e: z,
+				label: u.edge(z)
+			}), u.removeEdge(z);
+		}
+	});
+}
+function insertSelfEdges(u) {
+	forEach_default(buildLayerMatrix(u), function(z) {
+		var B = 0;
+		forEach_default(z, function(z, V) {
+			var H = u.node(z);
+			H.order = V + B, forEach_default(H.selfEdges, function(z) {
+				addDummyNode(u, "selfedge", {
+					width: z.label.width,
+					height: z.label.height,
+					rank: H.rank,
+					order: V + ++B,
+					e: z.e,
+					label: z.label
+				}, "_se");
+			}), delete H.selfEdges;
+		});
+	});
+}
+function positionSelfEdges(u) {
+	forEach_default(u.nodes(), function(z) {
+		var B = u.node(z);
+		if (B.dummy === "selfedge") {
+			var V = u.node(B.e.v), H = V.x + V.width / 2, U = V.y, W = B.x - H, G = V.height / 2;
+			u.setEdge(B.e, B.label), u.removeNode(z), B.label.points = [
+				{
+					x: H + 2 * W / 3,
+					y: U - G
+				},
+				{
+					x: H + 5 * W / 6,
+					y: U - G
+				},
+				{
+					x: H + W,
+					y: U
+				},
+				{
+					x: H + 5 * W / 6,
+					y: U + G
+				},
+				{
+					x: H + 2 * W / 3,
+					y: U + G
+				}
+			], B.label.x = B.x, B.label.y = B.y;
+		}
+	});
+}
+function selectNumberAttrs(u, z) {
+	return mapValues_default(pick_default(u, z), Number);
+}
+function canonicalize(u) {
+	var z = {};
+	return forEach_default(u, function(u, B) {
+		z[B.toLowerCase()] = u;
+	}), z;
+}
+export { layout as t };