@loopstack/loopstack-studio 0.25.1 → 0.25.2

package/dist/node_modules/mermaid/dist/chunks/mermaid.core/dagre-KV5264BT.js

@@ -1,132 +1,131 @@
-import { __name as e, log as t } from "./chunk-AGHRB4JF.js";
-import { getConfig2 as n } from "./chunk-ICPOFSXX.js";
+import { __name, log } from "./chunk-AGHRB4JF.js";
+import { getConfig2 } from "./chunk-ICPOFSXX.js";
 import "./chunk-BSJP7CBP.js";
 import "./chunk-5PVQY5BW.js";
-import { getSubGraphTitleMargins as r } from "./chunk-ZZ45TVLE.js";
+import { getSubGraphTitleMargins } from "./chunk-ZZ45TVLE.js";
 import "./chunk-X2U36JSP.js";
 import "./chunk-U2HBQHQK.js";
-import { clear as i, clear2 as a, insertCluster as o, insertNode as s, positionNode as c, setNodeElem as l, updateNodeBounds as u } from "./chunk-5FUZZQ4R.js";
-import { clear as d, insertEdge as f, insertEdgeLabel as p, markers_default as m, positionEdgeLabel as h } from "./chunk-ENJZ2VHE.js";
-import { Graph as g } from "../../../../dagre-d3-es/src/graphlib/graph.js";
+import { clear as clear$1, clear2, insertCluster, insertNode, positionNode, setNodeElem, updateNodeBounds } from "./chunk-5FUZZQ4R.js";
+import { clear, insertEdge, insertEdgeLabel, markers_default, positionEdgeLabel } from "./chunk-ENJZ2VHE.js";
+import { Graph } from "../../../../dagre-d3-es/src/graphlib/graph.js";
 import "../../../../dagre-d3-es/src/graphlib/index.js";
-import { layout as _ } from "../../../../dagre-d3-es/src/dagre/layout.js";
+import { layout } from "../../../../dagre-d3-es/src/dagre/layout.js";
 import "../../../../dagre-d3-es/src/dagre/index.js";
-import { write as v } from "../../../../dagre-d3-es/src/graphlib/json.js";
-//#region ../../node_modules/mermaid/dist/chunks/mermaid.core/dagre-KV5264BT.mjs
-var y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ e(() => {
-	b.clear(), x.clear(), y.clear();
-}, "clear"), C = /* @__PURE__ */ e((e, n) => {
-	let r = b.get(n) || [];
-	return t.trace("In isDescendant", n, " ", e, " = ", r.includes(e)), r.includes(e);
-}, "isDescendant"), w = /* @__PURE__ */ e((e, n) => {
-	let r = b.get(n) || [];
-	return t.info("Descendants of ", n, " is ", r), t.info("Edge is ", e), e.v === n || e.w === n ? !1 : r ? r.includes(e.v) || C(e.v, n) || C(e.w, n) || r.includes(e.w) : (t.debug("Tilt, ", n, ",not in descendants"), !1);
-}, "edgeInCluster"), T = /* @__PURE__ */ e((e, n, r, i) => {
-	t.warn("Copying children of ", e, "root", i, "data", n.node(e), i);
-	let a = n.children(e) || [];
-	e !== i && a.push(e), t.warn("Copying (nodes) clusterId", e, "nodes", a), a.forEach((a) => {
-		if (n.children(a).length > 0) T(a, n, r, i);
+import { write } from "../../../../dagre-d3-es/src/graphlib/json.js";
+var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map(), parents = /* @__PURE__ */ new Map(), clear4 = /* @__PURE__ */ __name(() => {
+	descendants.clear(), parents.clear(), clusterDb.clear();
+}, "clear"), isDescendant = /* @__PURE__ */ __name((e, v) => {
+	let y = descendants.get(v) || [];
+	return log.trace("In isDescendant", v, " ", e, " = ", y.includes(e)), y.includes(e);
+}, "isDescendant"), edgeInCluster = /* @__PURE__ */ __name((e, v) => {
+	let y = descendants.get(v) || [];
+	return log.info("Descendants of ", v, " is ", y), log.info("Edge is ", e), e.v === v || e.w === v ? !1 : y ? y.includes(e.v) || isDescendant(e.v, v) || isDescendant(e.w, v) || y.includes(e.w) : (log.debug("Tilt, ", v, ",not in descendants"), !1);
+}, "edgeInCluster"), copy = /* @__PURE__ */ __name((e, v, y, b) => {
+	log.warn("Copying children of ", e, "root", b, "data", v.node(e), b);
+	let x = v.children(e) || [];
+	e !== b && x.push(e), log.warn("Copying (nodes) clusterId", e, "nodes", x), x.forEach((x) => {
+		if (v.children(x).length > 0) copy(x, v, y, b);
 		else {
-			let o = n.node(a);
-			t.info("cp ", a, " to ", i, " with parent ", e), r.setNode(a, o), i !== n.parent(a) && (t.warn("Setting parent", a, n.parent(a)), r.setParent(a, n.parent(a))), e !== i && a !== e ? (t.debug("Setting parent", a, e), r.setParent(a, e)) : (t.info("In copy ", e, "root", i, "data", n.node(e), i), t.debug("Not Setting parent for node=", a, "cluster!==rootId", e !== i, "node!==clusterId", a !== e));
-			let s = n.edges(a);
-			t.debug("Copying Edges", s), s.forEach((a) => {
-				t.info("Edge", a);
-				let o = n.edge(a.v, a.w, a.name);
-				t.info("Edge data", o, i);
+			let S = v.node(x);
+			log.info("cp ", x, " to ", b, " with parent ", e), y.setNode(x, S), b !== v.parent(x) && (log.warn("Setting parent", x, v.parent(x)), y.setParent(x, v.parent(x))), e !== b && x !== e ? (log.debug("Setting parent", x, e), y.setParent(x, e)) : (log.info("In copy ", e, "root", b, "data", v.node(e), b), log.debug("Not Setting parent for node=", x, "cluster!==rootId", e !== b, "node!==clusterId", x !== e));
+			let C = v.edges(x);
+			log.debug("Copying Edges", C), C.forEach((x) => {
+				log.info("Edge", x);
+				let S = v.edge(x.v, x.w, x.name);
+				log.info("Edge data", S, b);
 				try {
-					w(a, i) ? (t.info("Copying as ", a.v, a.w, o, a.name), r.setEdge(a.v, a.w, o, a.name), t.info("newGraph edges ", r.edges(), r.edge(r.edges()[0]))) : t.info("Skipping copy of edge ", a.v, "-->", a.w, " rootId: ", i, " clusterId:", e);
+					edgeInCluster(x, b) ? (log.info("Copying as ", x.v, x.w, S, x.name), y.setEdge(x.v, x.w, S, x.name), log.info("newGraph edges ", y.edges(), y.edge(y.edges()[0]))) : log.info("Skipping copy of edge ", x.v, "-->", x.w, " rootId: ", b, " clusterId:", e);
 				} catch (e) {
-					t.error(e);
+					log.error(e);
 				}
 			});
 		}
-		t.debug("Removing node", a), n.removeNode(a);
+		log.debug("Removing node", x), v.removeNode(x);
 	});
-}, "copy"), E = /* @__PURE__ */ e((e, t) => {
-	let n = t.children(e), r = [...n];
-	for (let i of n) x.set(i, e), r = [...r, ...E(i, t)];
-	return r;
-}, "extractDescendants"), D = /* @__PURE__ */ e((e, t, n) => {
-	let r = e.edges().filter((e) => e.v === t || e.w === t), i = e.edges().filter((e) => e.v === n || e.w === n), a = r.map((e) => ({
-		v: e.v === t ? n : e.v,
-		w: e.w === t ? t : e.w
-	})), o = i.map((e) => ({
+}, "copy"), extractDescendants = /* @__PURE__ */ __name((e, _) => {
+	let v = _.children(e), y = [...v];
+	for (let b of v) parents.set(b, e), y = [...y, ...extractDescendants(b, _)];
+	return y;
+}, "extractDescendants"), findCommonEdges = /* @__PURE__ */ __name((e, _, v) => {
+	let y = e.edges().filter((e) => e.v === _ || e.w === _), b = e.edges().filter((e) => e.v === v || e.w === v), x = y.map((e) => ({
+		v: e.v === _ ? v : e.v,
+		w: e.w === _ ? _ : e.w
+	})), S = b.map((e) => ({
 		v: e.v,
 		w: e.w
 	}));
-	return a.filter((e) => o.some((t) => e.v === t.v && e.w === t.w));
-}, "findCommonEdges"), O = /* @__PURE__ */ e((e, n, r) => {
-	let i = n.children(e);
-	if (t.trace("Searching children of id ", e, i), i.length < 1) return e;
-	let a;
-	for (let e of i) {
-		let t = O(e, n, r), i = D(n, r, t);
-		if (t) if (i.length > 0) a = t;
-		else return t;
+	return x.filter((e) => S.some((_) => e.v === _.v && e.w === _.w));
+}, "findCommonEdges"), findNonClusterChild = /* @__PURE__ */ __name((e, v, y) => {
+	let b = v.children(e);
+	if (log.trace("Searching children of id ", e, b), b.length < 1) return e;
+	let x;
+	for (let e of b) {
+		let _ = findNonClusterChild(e, v, y), b = findCommonEdges(v, y, _);
+		if (_) if (b.length > 0) x = _;
+		else return _;
 	}
-	return a;
-}, "findNonClusterChild"), k = /* @__PURE__ */ e((e) => !y.has(e) || !y.get(e).externalConnections ? e : y.has(e) ? y.get(e).id : e, "getAnchorId"), A = /* @__PURE__ */ e((e, n) => {
-	if (!e || n > 10) {
-		t.debug("Opting out, no graph ");
+	return x;
+}, "findNonClusterChild"), getAnchorId = /* @__PURE__ */ __name((e) => !clusterDb.has(e) || !clusterDb.get(e).externalConnections ? e : clusterDb.has(e) ? clusterDb.get(e).id : e, "getAnchorId"), adjustClustersAndEdges = /* @__PURE__ */ __name((e, v) => {
+	if (!e || v > 10) {
+		log.debug("Opting out, no graph ");
 		return;
-	} else t.debug("Opting in, graph ");
-	e.nodes().forEach(function(n) {
-		e.children(n).length > 0 && (t.warn("Cluster identified", n, " Replacement id in edges: ", O(n, e, n)), b.set(n, E(n, e)), y.set(n, {
-			id: O(n, e, n),
-			clusterData: e.node(n)
+	} else log.debug("Opting in, graph ");
+	e.nodes().forEach(function(v) {
+		e.children(v).length > 0 && (log.warn("Cluster identified", v, " Replacement id in edges: ", findNonClusterChild(v, e, v)), descendants.set(v, extractDescendants(v, e)), clusterDb.set(v, {
+			id: findNonClusterChild(v, e, v),
+			clusterData: e.node(v)
 		}));
-	}), e.nodes().forEach(function(n) {
-		let r = e.children(n), i = e.edges();
-		r.length > 0 ? (t.debug("Cluster identified", n, b), i.forEach((e) => {
-			C(e.v, n) ^ C(e.w, n) && (t.warn("Edge: ", e, " leaves cluster ", n), t.warn("Descendants of XXX ", n, ": ", b.get(n)), y.get(n).externalConnections = !0);
-		})) : t.debug("Not a cluster ", n, b);
+	}), e.nodes().forEach(function(v) {
+		let y = e.children(v), b = e.edges();
+		y.length > 0 ? (log.debug("Cluster identified", v, descendants), b.forEach((e) => {
+			isDescendant(e.v, v) ^ isDescendant(e.w, v) && (log.warn("Edge: ", e, " leaves cluster ", v), log.warn("Descendants of XXX ", v, ": ", descendants.get(v)), clusterDb.get(v).externalConnections = !0);
+		})) : log.debug("Not a cluster ", v, descendants);
 	});
-	for (let t of y.keys()) {
-		let n = y.get(t).id, r = e.parent(n);
-		r !== t && y.has(r) && !y.get(r).externalConnections && (y.get(t).id = r);
+	for (let _ of clusterDb.keys()) {
+		let v = clusterDb.get(_).id, y = e.parent(v);
+		y !== _ && clusterDb.has(y) && !clusterDb.get(y).externalConnections && (clusterDb.get(_).id = y);
 	}
-	e.edges().forEach(function(n) {
-		let r = e.edge(n);
-		t.warn("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(n)), t.warn("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(e.edge(n)));
-		let i = n.v, a = n.w;
-		if (t.warn("Fix XXX", y, "ids:", n.v, n.w, "Translating: ", y.get(n.v), " --- ", y.get(n.w)), y.get(n.v) || y.get(n.w)) {
-			if (t.warn("Fixing and trying - removing XXX", n.v, n.w, n.name), i = k(n.v), a = k(n.w), e.removeEdge(n.v, n.w, n.name), i !== n.v) {
-				let t = e.parent(i);
-				y.get(t).externalConnections = !0, r.fromCluster = n.v;
+	e.edges().forEach(function(v) {
+		let y = e.edge(v);
+		log.warn("Edge " + v.v + " -> " + v.w + ": " + JSON.stringify(v)), log.warn("Edge " + v.v + " -> " + v.w + ": " + JSON.stringify(e.edge(v)));
+		let b = v.v, x = v.w;
+		if (log.warn("Fix XXX", clusterDb, "ids:", v.v, v.w, "Translating: ", clusterDb.get(v.v), " --- ", clusterDb.get(v.w)), clusterDb.get(v.v) || clusterDb.get(v.w)) {
+			if (log.warn("Fixing and trying - removing XXX", v.v, v.w, v.name), b = getAnchorId(v.v), x = getAnchorId(v.w), e.removeEdge(v.v, v.w, v.name), b !== v.v) {
+				let _ = e.parent(b);
+				clusterDb.get(_).externalConnections = !0, y.fromCluster = v.v;
 			}
-			if (a !== n.w) {
-				let t = e.parent(a);
-				y.get(t).externalConnections = !0, r.toCluster = n.w;
+			if (x !== v.w) {
+				let _ = e.parent(x);
+				clusterDb.get(_).externalConnections = !0, y.toCluster = v.w;
 			}
-			t.warn("Fix Replacing with XXX", i, a, n.name), e.setEdge(i, a, r, n.name);
+			log.warn("Fix Replacing with XXX", b, x, v.name), e.setEdge(b, x, y, v.name);
 		}
-	}), t.warn("Adjusted Graph", v(e)), j(e, 0), t.trace(y);
-}, "adjustClustersAndEdges"), j = /* @__PURE__ */ e((e, n) => {
-	if (t.warn("extractor - ", n, v(e), e.children("D")), n > 10) {
-		t.error("Bailing out");
+	}), log.warn("Adjusted Graph", write(e)), extractor(e, 0), log.trace(clusterDb);
+}, "adjustClustersAndEdges"), extractor = /* @__PURE__ */ __name((e, v) => {
+	if (log.warn("extractor - ", v, write(e), e.children("D")), v > 10) {
+		log.error("Bailing out");
 		return;
 	}
-	let r = e.nodes(), i = !1;
-	for (let t of r) {
-		let n = e.children(t);
-		i ||= n.length > 0;
+	let y = e.nodes(), b = !1;
+	for (let _ of y) {
+		let v = e.children(_);
+		b ||= v.length > 0;
 	}
-	if (!i) {
-		t.debug("Done, no node has children", e.nodes());
+	if (!b) {
+		log.debug("Done, no node has children", e.nodes());
 		return;
 	}
-	t.debug("Nodes = ", r, n);
-	for (let i of r) if (t.debug("Extracting node", i, y, y.has(i) && !y.get(i).externalConnections, !e.parent(i), e.node(i), e.children("D"), " Depth ", n), !y.has(i)) t.debug("Not a cluster", i, n);
-	else if (!y.get(i).externalConnections && e.children(i) && e.children(i).length > 0) {
-		t.warn("Cluster without external connections, without a parent and with children", i, n);
-		let r = e.graph().rankdir === "TB" ? "LR" : "TB";
-		y.get(i)?.clusterData?.dir && (r = y.get(i).clusterData.dir, t.warn("Fixing dir", y.get(i).clusterData.dir, r));
-		let a = new g({
+	log.debug("Nodes = ", y, v);
+	for (let b of y) if (log.debug("Extracting node", b, clusterDb, clusterDb.has(b) && !clusterDb.get(b).externalConnections, !e.parent(b), e.node(b), e.children("D"), " Depth ", v), !clusterDb.has(b)) log.debug("Not a cluster", b, v);
+	else if (!clusterDb.get(b).externalConnections && e.children(b) && e.children(b).length > 0) {
+		log.warn("Cluster without external connections, without a parent and with children", b, v);
+		let y = e.graph().rankdir === "TB" ? "LR" : "TB";
+		clusterDb.get(b)?.clusterData?.dir && (y = clusterDb.get(b).clusterData.dir, log.warn("Fixing dir", clusterDb.get(b).clusterData.dir, y));
+		let x = new Graph({
 			multigraph: !0,
 			compound: !0
 		}).setGraph({
-			rankdir: r,
+			rankdir: y,
 			nodesep: 50,
 			ranksep: 50,
 			marginx: 8,
@@ -134,87 +133,87 @@ var y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE
 		}).setDefaultEdgeLabel(function() {
 			return {};
 		});
-		t.warn("Old graph before copy", v(e)), T(i, e, a, i), e.setNode(i, {
+		log.warn("Old graph before copy", write(e)), copy(b, e, x, b), e.setNode(b, {
 			clusterNode: !0,
-			id: i,
-			clusterData: y.get(i).clusterData,
-			label: y.get(i).label,
-			graph: a
-		}), t.warn("New graph after copy node: (", i, ")", v(a)), t.debug("Old graph after copy", v(e));
-	} else t.warn("Cluster ** ", i, " **not meeting the criteria !externalConnections:", !y.get(i).externalConnections, " no parent: ", !e.parent(i), " children ", e.children(i) && e.children(i).length > 0, e.children("D"), n), t.debug(y);
-	r = e.nodes(), t.warn("New list of nodes", r);
-	for (let i of r) {
-		let r = e.node(i);
-		t.warn(" Now next level", i, r), r?.clusterNode && j(r.graph, n + 1);
+			id: b,
+			clusterData: clusterDb.get(b).clusterData,
+			label: clusterDb.get(b).label,
+			graph: x
+		}), log.warn("New graph after copy node: (", b, ")", write(x)), log.debug("Old graph after copy", write(e));
+	} else log.warn("Cluster ** ", b, " **not meeting the criteria !externalConnections:", !clusterDb.get(b).externalConnections, " no parent: ", !e.parent(b), " children ", e.children(b) && e.children(b).length > 0, e.children("D"), v), log.debug(clusterDb);
+	y = e.nodes(), log.warn("New list of nodes", y);
+	for (let b of y) {
+		let y = e.node(b);
+		log.warn(" Now next level", b, y), y?.clusterNode && extractor(y.graph, v + 1);
 	}
-}, "extractor"), M = /* @__PURE__ */ e((e, t) => {
-	if (t.length === 0) return [];
-	let n = Object.assign([], t);
-	return t.forEach((t) => {
-		let r = M(e, e.children(t));
-		n = [...n, ...r];
-	}), n;
-}, "sorter"), N = /* @__PURE__ */ e((e) => M(e, e.children()), "sortNodesByHierarchy"), P = /* @__PURE__ */ e(async (n, i, a, d, m, g) => {
-	t.warn("Graph in recursive render:XAX", v(i), m);
-	let b = i.graph().rankdir;
-	t.trace("Dir in recursive render - dir:", b);
-	let x = n.insert("g").attr("class", "root");
-	i.nodes() ? t.info("Recursive render XXX", i.nodes()) : t.info("No nodes found for", i), i.edges().length > 0 && t.info("Recursive edges", i.edge(i.edges()[0]));
-	let S = x.insert("g").attr("class", "clusters"), C = x.insert("g").attr("class", "edgePaths"), w = x.insert("g").attr("class", "edgeLabels"), T = x.insert("g").attr("class", "nodes");
-	await Promise.all(i.nodes().map(async function(e) {
-		let n = i.node(e);
-		if (m !== void 0) {
-			let n = JSON.parse(JSON.stringify(m.clusterData));
-			t.trace("Setting data for parent cluster XXX\n Node.id = ", e, "\n data=", n.height, "\nParent cluster", m.height), i.setNode(m.id, n), i.parent(e) || (t.trace("Setting parent", e, m.id), i.setParent(e, m.id, n));
+}, "extractor"), sorter = /* @__PURE__ */ __name((e, _) => {
+	if (_.length === 0) return [];
+	let v = Object.assign([], _);
+	return _.forEach((_) => {
+		let y = sorter(e, e.children(_));
+		v = [...v, ...y];
+	}), v;
+}, "sorter"), sortNodesByHierarchy = /* @__PURE__ */ __name((e) => sorter(e, e.children()), "sortNodesByHierarchy"), recursiveRender = /* @__PURE__ */ __name(async (v, b, x, T, E, D) => {
+	log.warn("Graph in recursive render:XAX", write(b), E);
+	let O = b.graph().rankdir;
+	log.trace("Dir in recursive render - dir:", O);
+	let k = v.insert("g").attr("class", "root");
+	b.nodes() ? log.info("Recursive render XXX", b.nodes()) : log.info("No nodes found for", b), b.edges().length > 0 && log.info("Recursive edges", b.edge(b.edges()[0]));
+	let A = k.insert("g").attr("class", "clusters"), j = k.insert("g").attr("class", "edgePaths"), M = k.insert("g").attr("class", "edgeLabels"), N = k.insert("g").attr("class", "nodes");
+	await Promise.all(b.nodes().map(async function(e) {
+		let v = b.node(e);
+		if (E !== void 0) {
+			let v = JSON.parse(JSON.stringify(E.clusterData));
+			log.trace("Setting data for parent cluster XXX\n Node.id = ", e, "\n data=", v.height, "\nParent cluster", E.height), b.setNode(E.id, v), b.parent(e) || (log.trace("Setting parent", e, E.id), b.setParent(e, E.id, v));
 		}
-		if (t.info("(Insert) Node XXX" + e + ": " + JSON.stringify(i.node(e))), n?.clusterNode) {
-			t.info("Cluster identified XBX", e, n.width, i.node(e));
-			let { ranksep: r, nodesep: o } = i.graph();
-			n.graph.setGraph({
-				...n.graph.graph(),
-				ranksep: r + 25,
-				nodesep: o
+		if (log.info("(Insert) Node XXX" + e + ": " + JSON.stringify(b.node(e))), v?.clusterNode) {
+			log.info("Cluster identified XBX", e, v.width, b.node(e));
+			let { ranksep: y, nodesep: S } = b.graph();
+			v.graph.setGraph({
+				...v.graph.graph(),
+				ranksep: y + 25,
+				nodesep: S
 			});
-			let s = await P(T, n.graph, a, d, i.node(e), g), c = s.elem;
-			u(n, c), n.diff = s.diff || 0, t.info("New compound node after recursive render XAX", e, "width", n.width, "height", n.height), l(c, n);
-		} else i.children(e).length > 0 ? (t.trace("Cluster - the non recursive path XBX", e, n.id, n, n.width, "Graph:", i), t.trace(O(n.id, i)), y.set(n.id, {
-			id: O(n.id, i),
-			node: n
-		})) : (t.trace("Node - the non recursive path XAX", e, T, i.node(e), b), await s(T, i.node(e), {
-			config: g,
-			dir: b
+			let C = await recursiveRender(N, v.graph, x, T, b.node(e), D), w = C.elem;
+			updateNodeBounds(v, w), v.diff = C.diff || 0, log.info("New compound node after recursive render XAX", e, "width", v.width, "height", v.height), setNodeElem(w, v);
+		} else b.children(e).length > 0 ? (log.trace("Cluster - the non recursive path XBX", e, v.id, v, v.width, "Graph:", b), log.trace(findNonClusterChild(v.id, b)), clusterDb.set(v.id, {
+			id: findNonClusterChild(v.id, b),
+			node: v
+		})) : (log.trace("Node - the non recursive path XAX", e, N, b.node(e), O), await insertNode(N, b.node(e), {
+			config: D,
+			dir: O
 		}));
-	})), await (/* @__PURE__ */ e(async () => {
-		let e = i.edges().map(async function(e) {
-			let n = i.edge(e.v, e.w, e.name);
-			t.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e)), t.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(i.edge(e))), t.info("Fix", y, "ids:", e.v, e.w, "Translating: ", y.get(e.v), y.get(e.w)), await p(w, n);
+	})), await (/* @__PURE__ */ __name(async () => {
+		let e = b.edges().map(async function(e) {
+			let v = b.edge(e.v, e.w, e.name);
+			log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e)), log.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(b.edge(e))), log.info("Fix", clusterDb, "ids:", e.v, e.w, "Translating: ", clusterDb.get(e.v), clusterDb.get(e.w)), await insertEdgeLabel(M, v);
 		});
 		await Promise.all(e);
-	}, "processEdges"))(), t.info("Graph before layout:", JSON.stringify(v(i))), t.info("############################################# XXX"), t.info("###                Layout                 ### XXX"), t.info("############################################# XXX"), _(i), t.info("Graph after layout:", JSON.stringify(v(i)));
-	let E = 0, { subGraphTitleTotalMargin: D } = r(g);
-	return await Promise.all(N(i).map(async function(e) {
-		let n = i.node(e);
-		if (t.info("Position XBX => " + e + ": (" + n.x, "," + n.y, ") width: ", n.width, " height: ", n.height), n?.clusterNode) n.y += D, t.info("A tainted cluster node XBX1", e, n.id, n.width, n.height, n.x, n.y, i.parent(e)), y.get(n.id).node = n, c(n);
-		else if (i.children(e).length > 0) {
-			t.info("A pure cluster node XBX1", e, n.id, n.x, n.y, n.width, n.height, i.parent(e)), n.height += D, i.node(n.parentId);
-			let r = n?.padding / 2 || 0, a = n?.labelBBox?.height || 0, s = a - r || 0;
-			t.debug("OffsetY", s, "labelHeight", a, "halfPadding", r), await o(S, n), y.get(n.id).node = n;
+	}, "processEdges"))(), log.info("Graph before layout:", JSON.stringify(write(b))), log.info("############################################# XXX"), log.info("###                Layout                 ### XXX"), log.info("############################################# XXX"), layout(b), log.info("Graph after layout:", JSON.stringify(write(b)));
+	let P = 0, { subGraphTitleTotalMargin: F } = getSubGraphTitleMargins(D);
+	return await Promise.all(sortNodesByHierarchy(b).map(async function(e) {
+		let v = b.node(e);
+		if (log.info("Position XBX => " + e + ": (" + v.x, "," + v.y, ") width: ", v.width, " height: ", v.height), v?.clusterNode) v.y += F, log.info("A tainted cluster node XBX1", e, v.id, v.width, v.height, v.x, v.y, b.parent(e)), clusterDb.get(v.id).node = v, positionNode(v);
+		else if (b.children(e).length > 0) {
+			log.info("A pure cluster node XBX1", e, v.id, v.x, v.y, v.width, v.height, b.parent(e)), v.height += F, b.node(v.parentId);
+			let y = v?.padding / 2 || 0, x = v?.labelBBox?.height || 0, C = x - y || 0;
+			log.debug("OffsetY", C, "labelHeight", x, "halfPadding", y), await insertCluster(A, v), clusterDb.get(v.id).node = v;
 		} else {
-			let e = i.node(n.parentId);
-			n.y += D / 2, t.info("A regular node XBX1 - using the padding", n.id, "parent", n.parentId, n.width, n.height, n.x, n.y, "offsetY", n.offsetY, "parent", e, e?.offsetY, n), c(n);
+			let e = b.node(v.parentId);
+			v.y += F / 2, log.info("A regular node XBX1 - using the padding", v.id, "parent", v.parentId, v.width, v.height, v.x, v.y, "offsetY", v.offsetY, "parent", e, e?.offsetY, v), positionNode(v);
 		}
-	})), i.edges().forEach(function(e) {
-		let n = i.edge(e);
-		t.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(n), n), n.points.forEach((e) => e.y += D / 2), h(n, f(C, n, y, a, i.node(e.v), i.node(e.w), d));
-	}), i.nodes().forEach(function(e) {
-		let n = i.node(e);
-		t.info(e, n.type, n.diff), n.isGroup && (E = n.diff);
-	}), t.warn("Returning from recursive render XAX", x, E), {
-		elem: x,
-		diff: E
+	})), b.edges().forEach(function(e) {
+		let v = b.edge(e);
+		log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(v), v), v.points.forEach((e) => e.y += F / 2), positionEdgeLabel(v, insertEdge(j, v, clusterDb, x, b.node(e.v), b.node(e.w), T));
+	}), b.nodes().forEach(function(e) {
+		let v = b.node(e);
+		log.info(e, v.type, v.diff), v.isGroup && (P = v.diff);
+	}), log.warn("Returning from recursive render XAX", k, P), {
+		elem: k,
+		diff: P
 	};
-}, "recursiveRender"), F = /* @__PURE__ */ e(async (e, r) => {
-	let o = new g({
+}, "recursiveRender"), render = /* @__PURE__ */ __name(async (e, y) => {
+	let S = new Graph({
 		multigraph: !0,
 		compound: !0
 	}).setGraph({
@@ -225,16 +224,16 @@ var y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE
 		marginy: 8
 	}).setDefaultEdgeLabel(function() {
 		return {};
-	}), s = r.select("g");
-	m(s, e.markers, e.type, e.diagramId), a(), d(), i(), S(), e.nodes.forEach((e) => {
-		o.setNode(e.id, { ...e }), e.parentId && o.setParent(e.id, e.parentId);
-	}), t.debug("Edges:", e.edges), e.edges.forEach((e) => {
+	}), C = y.select("g");
+	markers_default(C, e.markers, e.type, e.diagramId), clear2(), clear(), clear$1(), clear4(), e.nodes.forEach((e) => {
+		S.setNode(e.id, { ...e }), e.parentId && S.setParent(e.id, e.parentId);
+	}), log.debug("Edges:", e.edges), e.edges.forEach((e) => {
 		if (e.start === e.end) {
-			let t = e.start, n = t + "---" + t + "---1", r = t + "---" + t + "---2", i = o.node(t);
-			o.setNode(n, {
-				domId: n,
-				id: n,
-				parentId: i.parentId,
+			let _ = e.start, v = _ + "---" + _ + "---1", y = _ + "---" + _ + "---2", b = S.node(_);
+			S.setNode(v, {
+				domId: v,
+				id: v,
+				parentId: b.parentId,
 				labelStyle: "",
 				label: "",
 				padding: 0,
@@ -242,10 +241,10 @@ var y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE
 				style: "",
 				width: 10,
 				height: 10
-			}), o.setParent(n, i.parentId), o.setNode(r, {
-				domId: r,
-				id: r,
-				parentId: i.parentId,
+			}), S.setParent(v, b.parentId), S.setNode(y, {
+				domId: y,
+				id: y,
+				parentId: b.parentId,
 				labelStyle: "",
 				padding: 0,
 				shape: "labelRect",
@@ -253,13 +252,12 @@ var y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE
 				style: "",
 				width: 10,
 				height: 10
-			}), o.setParent(r, i.parentId);
-			let a = structuredClone(e), s = structuredClone(e), c = structuredClone(e);
-			a.label = "", a.arrowTypeEnd = "none", a.id = t + "-cyclic-special-1", s.arrowTypeStart = "none", s.arrowTypeEnd = "none", s.id = t + "-cyclic-special-mid", c.label = "", i.isGroup && (a.fromCluster = t, c.toCluster = t), c.id = t + "-cyclic-special-2", c.arrowTypeStart = "none", o.setEdge(t, n, a, t + "-cyclic-special-0"), o.setEdge(n, r, s, t + "-cyclic-special-1"), o.setEdge(r, t, c, t + "-cyc<lic-special-2");
-		} else o.setEdge(e.start, e.end, { ...e }, e.id);
-	}), t.warn("Graph at first:", JSON.stringify(v(o))), A(o), t.warn("Graph after XAX:", JSON.stringify(v(o)));
-	let c = n();
-	await P(s, o, e.type, e.diagramId, void 0, c);
+			}), S.setParent(y, b.parentId);
+			let x = structuredClone(e), C = structuredClone(e), w = structuredClone(e);
+			x.label = "", x.arrowTypeEnd = "none", x.id = _ + "-cyclic-special-1", C.arrowTypeStart = "none", C.arrowTypeEnd = "none", C.id = _ + "-cyclic-special-mid", w.label = "", b.isGroup && (x.fromCluster = _, w.toCluster = _), w.id = _ + "-cyclic-special-2", w.arrowTypeStart = "none", S.setEdge(_, v, x, _ + "-cyclic-special-0"), S.setEdge(v, y, C, _ + "-cyclic-special-1"), S.setEdge(y, _, w, _ + "-cyc<lic-special-2");
+		} else S.setEdge(e.start, e.end, { ...e }, e.id);
+	}), log.warn("Graph at first:", JSON.stringify(write(S))), adjustClustersAndEdges(S), log.warn("Graph after XAX:", JSON.stringify(write(S)));
+	let w = getConfig2();
+	await recursiveRender(C, S, e.type, e.diagramId, void 0, w);
 }, "render");
-//#endregion
-export { F as render };
+export { render };