@wzh-/ai-chat-example 1.0.13 → 1.0.15

package/dist/js/classDiagram-2ON5EDUG.js

@@ -1,11 +1,11 @@
 import "./marked.esm.js";
-import "./isArrayLikeObject.js";
-import "./chunk-S3R3BYOJ.js";
+import "./_baseFor.js";
 import { h as __name } from "./src.js";
 import "./chunk-ABZYJK2D.js";
 import "./path.js";
 import "./math.js";
 import "./array.js";
+import "./chunk-S3R3BYOJ.js";
 import "./line.js";
 import "./dist.js";
 import "./chunk-JA3XYJ7Z.js";

package/dist/js/classDiagram-v2-WZHVMYZB.js

@@ -1,11 +1,11 @@
 import "./marked.esm.js";
-import "./isArrayLikeObject.js";
-import "./chunk-S3R3BYOJ.js";
+import "./_baseFor.js";
 import { h as __name } from "./src.js";
 import "./chunk-ABZYJK2D.js";
 import "./path.js";
 import "./math.js";
 import "./array.js";
+import "./chunk-S3R3BYOJ.js";
 import "./line.js";
 import "./dist.js";
 import "./chunk-JA3XYJ7Z.js";

package/dist/js/clone.js

@@ -1,4 +1,4 @@
-import { y as _baseClone_default } from "./_baseUniq.js";
+import { i as _baseClone_default } from "./graphlib.js";
 var CLONE_SYMBOLS_FLAG = 4;
 function clone(r) {
 	return _baseClone_default(r, CLONE_SYMBOLS_FLAG);

package/dist/js/dagre-6UL2VRFP.js

@@ -1,81 +1,81 @@
 import "./marked.esm.js";
-import "./isArrayLikeObject.js";
-import { r as isUndefined_default } from "./_baseUniq.js";
-import { s as map_default } from "./_basePickBy.js";
+import "./reduce.js";
+import "./_baseFor.js";
 import "./isEmpty.js";
-import { t as layout } from "./dagre.js";
-import "./chunk-S3R3BYOJ.js";
-import { t as clone_default } from "./clone.js";
-import { t as Graph } from "./graphlib.js";
+import { a as map_default } from "./flatten.js";
 import { g as log, h as __name } from "./src.js";
 import { b as getConfig2 } from "./chunk-ABZYJK2D.js";
 import "./path.js";
 import "./math.js";
 import "./array.js";
+import "./chunk-S3R3BYOJ.js";
 import "./line.js";
 import "./dist.js";
 import "./chunk-JA3XYJ7Z.js";
 import "./chunk-HN2XXSSU.js";
 import { t as getSubGraphTitleMargins } from "./chunk-CVBHYZKI.js";
+import { n as isUndefined_default, t as Graph } from "./graphlib.js";
+import { t as clone_default } from "./clone.js";
+import { t as layout } from "./dagre.js";
 import "./chunk-ATLVNIR6.js";
 import { a as insertNode, c as positionNode, i as insertCluster, l as setNodeElem, n as clear2, t as clear$1, u as updateNodeBounds } from "./chunk-JZLCHNYA.js";
 import { a as positionEdgeLabel, i as markers_default, n as insertEdge, r as insertEdgeLabel, t as clear } from "./chunk-QXUST7PY.js";
-function write(C) {
-	var w = {
+function write(r) {
+	var C = {
 		options: {
-			directed: C.isDirected(),
-			multigraph: C.isMultigraph(),
-			compound: C.isCompound()
+			directed: r.isDirected(),
+			multigraph: r.isMultigraph(),
+			compound: r.isCompound()
 		},
-		nodes: writeNodes(C),
-		edges: writeEdges(C)
+		nodes: writeNodes(r),
+		edges: writeEdges(r)
 	};
-	return isUndefined_default(C.graph()) || (w.value = clone_default(C.graph())), w;
+	return isUndefined_default(r.graph()) || (C.value = clone_default(r.graph())), C;
 }
-function writeNodes(w) {
-	return map_default(w.nodes(), function(C) {
-		var T = w.node(C), E = w.parent(C), D = { v: C };
-		return isUndefined_default(T) || (D.value = T), isUndefined_default(E) || (D.parent = E), D;
+function writeNodes(C) {
+	return map_default(C.nodes(), function(r) {
+		var w = C.node(r), T = C.parent(r), E = { v: r };
+		return isUndefined_default(w) || (E.value = w), isUndefined_default(T) || (E.parent = T), E;
 	});
 }
-function writeEdges(w) {
-	return map_default(w.edges(), function(C) {
-		var T = w.edge(C), E = {
-			v: C.v,
-			w: C.w
+function writeEdges(C) {
+	return map_default(C.edges(), function(r) {
+		var w = C.edge(r), T = {
+			v: r.v,
+			w: r.w
 		};
-		return isUndefined_default(C.name) || (E.name = C.name), isUndefined_default(T) || (E.value = T), E;
+		return isUndefined_default(r.name) || (T.name = r.name), isUndefined_default(w) || (T.value = w), T;
 	});
 }
 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((r, C) => {
-	let w = descendants.get(C) || [];
-	return log.trace("In isDescendant", C, " ", r, " = ", w.includes(r)), w.includes(r);
-}, "isDescendant"), edgeInCluster = /* @__PURE__ */ __name((r, C) => {
-	let w = descendants.get(C) || [];
-	return log.info("Descendants of ", C, " is ", w), log.info("Edge is ", r), r.v === C || r.w === C ? !1 : w ? w.includes(r.v) || isDescendant(r.v, C) || isDescendant(r.w, C) || w.includes(r.w) : (log.debug("Tilt, ", C, ",not in descendants"), !1);
-}, "edgeInCluster"), copy = /* @__PURE__ */ __name((r, C, w, T) => {
-	log.warn("Copying children of ", r, "root", T, "data", C.node(r), T);
-	let E = C.children(r) || [];
-	r !== T && E.push(r), log.warn("Copying (nodes) clusterId", r, "nodes", E), E.forEach((E) => {
-		if (C.children(E).length > 0) copy(E, C, w, T);
+}, "clear"), isDescendant = /* @__PURE__ */ __name((r, w) => {
+	let T = descendants.get(w) || [];
+	return log.trace("In isDescendant", w, " ", r, " = ", T.includes(r)), T.includes(r);
+}, "isDescendant"), edgeInCluster = /* @__PURE__ */ __name((r, w) => {
+	let T = descendants.get(w) || [];
+	return log.info("Descendants of ", w, " is ", T), log.info("Edge is ", r), r.v === w || r.w === w ? !1 : T ? T.includes(r.v) || isDescendant(r.v, w) || isDescendant(r.w, w) || T.includes(r.w) : (log.debug("Tilt, ", w, ",not in descendants"), !1);
+}, "edgeInCluster"), copy = /* @__PURE__ */ __name((r, w, T, E) => {
+	log.warn("Copying children of ", r, "root", E, "data", w.node(r), E);
+	let D = w.children(r) || [];
+	r !== E && D.push(r), log.warn("Copying (nodes) clusterId", r, "nodes", D), D.forEach((D) => {
+		if (w.children(D).length > 0) copy(D, w, T, E);
 		else {
-			let O = C.node(E);
-			log.info("cp ", E, " to ", T, " with parent ", r), w.setNode(E, O), T !== C.parent(E) && (log.warn("Setting parent", E, C.parent(E)), w.setParent(E, C.parent(E))), r !== T && E !== r ? (log.debug("Setting parent", E, r), w.setParent(E, r)) : (log.info("In copy ", r, "root", T, "data", C.node(r), T), log.debug("Not Setting parent for node=", E, "cluster!==rootId", r !== T, "node!==clusterId", E !== r));
-			let k = C.edges(E);
-			log.debug("Copying Edges", k), k.forEach((E) => {
-				log.info("Edge", E);
-				let O = C.edge(E.v, E.w, E.name);
-				log.info("Edge data", O, T);
+			let O = w.node(D);
+			log.info("cp ", D, " to ", E, " with parent ", r), T.setNode(D, O), E !== w.parent(D) && (log.warn("Setting parent", D, w.parent(D)), T.setParent(D, w.parent(D))), r !== E && D !== r ? (log.debug("Setting parent", D, r), T.setParent(D, r)) : (log.info("In copy ", r, "root", E, "data", w.node(r), E), log.debug("Not Setting parent for node=", D, "cluster!==rootId", r !== E, "node!==clusterId", D !== r));
+			let k = w.edges(D);
+			log.debug("Copying Edges", k), k.forEach((D) => {
+				log.info("Edge", D);
+				let O = w.edge(D.v, D.w, D.name);
+				log.info("Edge data", O, E);
 				try {
-					edgeInCluster(E, T) ? (log.info("Copying as ", E.v, E.w, O, E.name), w.setEdge(E.v, E.w, O, E.name), log.info("newGraph edges ", w.edges(), w.edge(w.edges()[0]))) : log.info("Skipping copy of edge ", E.v, "-->", E.w, " rootId: ", T, " clusterId:", r);
+					edgeInCluster(D, E) ? (log.info("Copying as ", D.v, D.w, O, D.name), T.setEdge(D.v, D.w, O, D.name), log.info("newGraph edges ", T.edges(), T.edge(T.edges()[0]))) : log.info("Skipping copy of edge ", D.v, "-->", D.w, " rootId: ", E, " clusterId:", r);
 				} catch (r) {
 					log.error(r);
 				}
 			});
 		}
-		log.debug("Removing node", E), C.removeNode(E);
+		log.debug("Removing node", D), w.removeNode(D);
 	});
 }, "copy"), extractDescendants = /* @__PURE__ */ __name((r, C) => {
 	let w = C.children(r), T = [...w];
@@ -90,77 +90,77 @@ var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map
 		w: r.w
 	}));
 	return D.filter((r) => O.some((C) => r.v === C.v && r.w === C.w));
-}, "findCommonEdges"), findNonClusterChild = /* @__PURE__ */ __name((r, C, w) => {
-	let T = C.children(r);
-	if (log.trace("Searching children of id ", r, T), T.length < 1) return r;
-	let E;
-	for (let r of T) {
-		let T = findNonClusterChild(r, C, w), D = findCommonEdges(C, w, T);
-		if (T) if (D.length > 0) E = T;
-		else return T;
+}, "findCommonEdges"), findNonClusterChild = /* @__PURE__ */ __name((r, w, T) => {
+	let E = w.children(r);
+	if (log.trace("Searching children of id ", r, E), E.length < 1) return r;
+	let D;
+	for (let r of E) {
+		let C = findNonClusterChild(r, w, T), E = findCommonEdges(w, T, C);
+		if (C) if (E.length > 0) D = C;
+		else return C;
 	}
-	return E;
-}, "findNonClusterChild"), getAnchorId = /* @__PURE__ */ __name((r) => !clusterDb.has(r) || !clusterDb.get(r).externalConnections ? r : clusterDb.has(r) ? clusterDb.get(r).id : r, "getAnchorId"), adjustClustersAndEdges = /* @__PURE__ */ __name((r, C) => {
-	if (!r || C > 10) {
+	return D;
+}, "findNonClusterChild"), getAnchorId = /* @__PURE__ */ __name((r) => !clusterDb.has(r) || !clusterDb.get(r).externalConnections ? r : clusterDb.has(r) ? clusterDb.get(r).id : r, "getAnchorId"), adjustClustersAndEdges = /* @__PURE__ */ __name((r, w) => {
+	if (!r || w > 10) {
 		log.debug("Opting out, no graph ");
 		return;
 	} else log.debug("Opting in, graph ");
-	r.nodes().forEach(function(C) {
-		r.children(C).length > 0 && (log.warn("Cluster identified", C, " Replacement id in edges: ", findNonClusterChild(C, r, C)), descendants.set(C, extractDescendants(C, r)), clusterDb.set(C, {
-			id: findNonClusterChild(C, r, C),
-			clusterData: r.node(C)
+	r.nodes().forEach(function(w) {
+		r.children(w).length > 0 && (log.warn("Cluster identified", w, " Replacement id in edges: ", findNonClusterChild(w, r, w)), descendants.set(w, extractDescendants(w, r)), clusterDb.set(w, {
+			id: findNonClusterChild(w, r, w),
+			clusterData: r.node(w)
 		}));
-	}), r.nodes().forEach(function(C) {
-		let w = r.children(C), T = r.edges();
-		w.length > 0 ? (log.debug("Cluster identified", C, descendants), T.forEach((r) => {
-			isDescendant(r.v, C) ^ isDescendant(r.w, C) && (log.warn("Edge: ", r, " leaves cluster ", C), log.warn("Descendants of XXX ", C, ": ", descendants.get(C)), clusterDb.get(C).externalConnections = !0);
-		})) : log.debug("Not a cluster ", C, descendants);
+	}), r.nodes().forEach(function(w) {
+		let T = r.children(w), E = r.edges();
+		T.length > 0 ? (log.debug("Cluster identified", w, descendants), E.forEach((r) => {
+			isDescendant(r.v, w) ^ isDescendant(r.w, w) && (log.warn("Edge: ", r, " leaves cluster ", w), log.warn("Descendants of XXX ", w, ": ", descendants.get(w)), clusterDb.get(w).externalConnections = !0);
+		})) : log.debug("Not a cluster ", w, descendants);
 	});
 	for (let C of clusterDb.keys()) {
 		let w = clusterDb.get(C).id, T = r.parent(w);
 		T !== C && clusterDb.has(T) && !clusterDb.get(T).externalConnections && (clusterDb.get(C).id = T);
 	}
-	r.edges().forEach(function(C) {
-		let w = r.edge(C);
-		log.warn("Edge " + C.v + " -> " + C.w + ": " + JSON.stringify(C)), log.warn("Edge " + C.v + " -> " + C.w + ": " + JSON.stringify(r.edge(C)));
-		let T = C.v, E = C.w;
-		if (log.warn("Fix XXX", clusterDb, "ids:", C.v, C.w, "Translating: ", clusterDb.get(C.v), " --- ", clusterDb.get(C.w)), clusterDb.get(C.v) || clusterDb.get(C.w)) {
-			if (log.warn("Fixing and trying - removing XXX", C.v, C.w, C.name), T = getAnchorId(C.v), E = getAnchorId(C.w), r.removeEdge(C.v, C.w, C.name), T !== C.v) {
-				let E = r.parent(T);
-				clusterDb.get(E).externalConnections = !0, w.fromCluster = C.v;
+	r.edges().forEach(function(w) {
+		let T = r.edge(w);
+		log.warn("Edge " + w.v + " -> " + w.w + ": " + JSON.stringify(w)), log.warn("Edge " + w.v + " -> " + w.w + ": " + JSON.stringify(r.edge(w)));
+		let E = w.v, D = w.w;
+		if (log.warn("Fix XXX", clusterDb, "ids:", w.v, w.w, "Translating: ", clusterDb.get(w.v), " --- ", clusterDb.get(w.w)), clusterDb.get(w.v) || clusterDb.get(w.w)) {
+			if (log.warn("Fixing and trying - removing XXX", w.v, w.w, w.name), E = getAnchorId(w.v), D = getAnchorId(w.w), r.removeEdge(w.v, w.w, w.name), E !== w.v) {
+				let C = r.parent(E);
+				clusterDb.get(C).externalConnections = !0, T.fromCluster = w.v;
 			}
-			if (E !== C.w) {
-				let T = r.parent(E);
-				clusterDb.get(T).externalConnections = !0, w.toCluster = C.w;
+			if (D !== w.w) {
+				let C = r.parent(D);
+				clusterDb.get(C).externalConnections = !0, T.toCluster = w.w;
 			}
-			log.warn("Fix Replacing with XXX", T, E, C.name), r.setEdge(T, E, w, C.name);
+			log.warn("Fix Replacing with XXX", E, D, w.name), r.setEdge(E, D, T, w.name);
 		}
 	}), log.warn("Adjusted Graph", write(r)), extractor(r, 0), log.trace(clusterDb);
-}, "adjustClustersAndEdges"), extractor = /* @__PURE__ */ __name((r, C) => {
-	if (log.warn("extractor - ", C, write(r), r.children("D")), C > 10) {
+}, "adjustClustersAndEdges"), extractor = /* @__PURE__ */ __name((r, w) => {
+	if (log.warn("extractor - ", w, write(r), r.children("D")), w > 10) {
 		log.error("Bailing out");
 		return;
 	}
-	let w = r.nodes(), T = !1;
-	for (let C of w) {
+	let T = r.nodes(), E = !1;
+	for (let C of T) {
 		let w = r.children(C);
-		T ||= w.length > 0;
+		E ||= w.length > 0;
 	}
-	if (!T) {
+	if (!E) {
 		log.debug("Done, no node has children", r.nodes());
 		return;
 	}
-	log.debug("Nodes = ", w, C);
-	for (let T of w) if (log.debug("Extracting node", T, clusterDb, clusterDb.has(T) && !clusterDb.get(T).externalConnections, !r.parent(T), r.node(T), r.children("D"), " Depth ", C), !clusterDb.has(T)) log.debug("Not a cluster", T, C);
-	else if (!clusterDb.get(T).externalConnections && r.children(T) && r.children(T).length > 0) {
-		log.warn("Cluster without external connections, without a parent and with children", T, C);
-		let w = r.graph().rankdir === "TB" ? "LR" : "TB";
-		clusterDb.get(T)?.clusterData?.dir && (w = clusterDb.get(T).clusterData.dir, log.warn("Fixing dir", clusterDb.get(T).clusterData.dir, w));
-		let O = new Graph({
+	log.debug("Nodes = ", T, w);
+	for (let E of T) if (log.debug("Extracting node", E, clusterDb, clusterDb.has(E) && !clusterDb.get(E).externalConnections, !r.parent(E), r.node(E), r.children("D"), " Depth ", w), !clusterDb.has(E)) log.debug("Not a cluster", E, w);
+	else if (!clusterDb.get(E).externalConnections && r.children(E) && r.children(E).length > 0) {
+		log.warn("Cluster without external connections, without a parent and with children", E, w);
+		let T = r.graph().rankdir === "TB" ? "LR" : "TB";
+		clusterDb.get(E)?.clusterData?.dir && (T = clusterDb.get(E).clusterData.dir, log.warn("Fixing dir", clusterDb.get(E).clusterData.dir, T));
+		let D = new Graph({
 			multigraph: !0,
 			compound: !0
 		}).setGraph({
-			rankdir: w,
+			rankdir: T,
 			nodesep: 50,
 			ranksep: 50,
 			marginx: 8,
@@ -168,18 +168,18 @@ var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map
 		}).setDefaultEdgeLabel(function() {
 			return {};
 		});
-		log.warn("Old graph before copy", write(r)), copy(T, r, O, T), r.setNode(T, {
+		log.warn("Old graph before copy", write(r)), copy(E, r, D, E), r.setNode(E, {
 			clusterNode: !0,
-			id: T,
-			clusterData: clusterDb.get(T).clusterData,
-			label: clusterDb.get(T).label,
-			graph: O
-		}), log.warn("New graph after copy node: (", T, ")", write(O)), log.debug("Old graph after copy", write(r));
-	} else log.warn("Cluster ** ", T, " **not meeting the criteria !externalConnections:", !clusterDb.get(T).externalConnections, " no parent: ", !r.parent(T), " children ", r.children(T) && r.children(T).length > 0, r.children("D"), C), log.debug(clusterDb);
-	w = r.nodes(), log.warn("New list of nodes", w);
-	for (let T of w) {
-		let w = r.node(T);
-		log.warn(" Now next level", T, w), w?.clusterNode && extractor(w.graph, C + 1);
+			id: E,
+			clusterData: clusterDb.get(E).clusterData,
+			label: clusterDb.get(E).label,
+			graph: D
+		}), log.warn("New graph after copy node: (", E, ")", write(D)), log.debug("Old graph after copy", write(r));
+	} else log.warn("Cluster ** ", E, " **not meeting the criteria !externalConnections:", !clusterDb.get(E).externalConnections, " no parent: ", !r.parent(E), " children ", r.children(E) && r.children(E).length > 0, r.children("D"), w), log.debug(clusterDb);
+	T = r.nodes(), log.warn("New list of nodes", T);
+	for (let E of T) {
+		let T = r.node(E);
+		log.warn(" Now next level", E, T), T?.clusterNode && extractor(T.graph, w + 1);
 	}
 }, "extractor"), sorter = /* @__PURE__ */ __name((r, C) => {
 	if (C.length === 0) return [];
@@ -188,67 +188,67 @@ var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map
 		let T = sorter(r, r.children(C));
 		w = [...w, ...T];
 	}), w;
-}, "sorter"), sortNodesByHierarchy = /* @__PURE__ */ __name((r) => sorter(r, r.children()), "sortNodesByHierarchy"), recursiveRender = /* @__PURE__ */ __name(async (r, C, T, E, k, M) => {
-	log.warn("Graph in recursive render:XAX", write(C), k);
-	let N = C.graph().rankdir;
+}, "sorter"), sortNodesByHierarchy = /* @__PURE__ */ __name((r) => sorter(r, r.children()), "sortNodesByHierarchy"), recursiveRender = /* @__PURE__ */ __name(async (r, T, D, O, k, M) => {
+	log.warn("Graph in recursive render:XAX", write(T), k);
+	let N = T.graph().rankdir;
 	log.trace("Dir in recursive render - dir:", N);
 	let P = r.insert("g").attr("class", "root");
-	C.nodes() ? log.info("Recursive render XXX", C.nodes()) : log.info("No nodes found for", C), C.edges().length > 0 && log.info("Recursive edges", C.edge(C.edges()[0]));
+	T.nodes() ? log.info("Recursive render XXX", T.nodes()) : log.info("No nodes found for", T), T.edges().length > 0 && log.info("Recursive edges", T.edge(T.edges()[0]));
 	let F = P.insert("g").attr("class", "clusters"), I = P.insert("g").attr("class", "edgePaths"), L = P.insert("g").attr("class", "edgeLabels"), R = P.insert("g").attr("class", "nodes");
-	await Promise.all(C.nodes().map(async function(r) {
-		let w = C.node(r);
+	await Promise.all(T.nodes().map(async function(r) {
+		let w = T.node(r);
 		if (k !== void 0) {
 			let w = JSON.parse(JSON.stringify(k.clusterData));
-			log.trace("Setting data for parent cluster XXX\n Node.id = ", r, "\n data=", w.height, "\nParent cluster", k.height), C.setNode(k.id, w), C.parent(r) || (log.trace("Setting parent", r, k.id), C.setParent(r, k.id, w));
+			log.trace("Setting data for parent cluster XXX\n Node.id = ", r, "\n data=", w.height, "\nParent cluster", k.height), T.setNode(k.id, w), T.parent(r) || (log.trace("Setting parent", r, k.id), T.setParent(r, k.id, w));
 		}
-		if (log.info("(Insert) Node XXX" + r + ": " + JSON.stringify(C.node(r))), w?.clusterNode) {
-			log.info("Cluster identified XBX", r, w.width, C.node(r));
-			let { ranksep: O, nodesep: k } = C.graph();
+		if (log.info("(Insert) Node XXX" + r + ": " + JSON.stringify(T.node(r))), w?.clusterNode) {
+			log.info("Cluster identified XBX", r, w.width, T.node(r));
+			let { ranksep: E, nodesep: k } = T.graph();
 			w.graph.setGraph({
 				...w.graph.graph(),
-				ranksep: O + 25,
+				ranksep: E + 25,
 				nodesep: k
 			});
-			let A = await recursiveRender(R, w.graph, T, E, C.node(r), M), j = A.elem;
+			let A = await recursiveRender(R, w.graph, D, O, T.node(r), M), j = A.elem;
 			updateNodeBounds(w, j), w.diff = A.diff || 0, log.info("New compound node after recursive render XAX", r, "width", w.width, "height", w.height), setNodeElem(j, w);
-		} else C.children(r).length > 0 ? (log.trace("Cluster - the non recursive path XBX", r, w.id, w, w.width, "Graph:", C), log.trace(findNonClusterChild(w.id, C)), clusterDb.set(w.id, {
-			id: findNonClusterChild(w.id, C),
+		} else T.children(r).length > 0 ? (log.trace("Cluster - the non recursive path XBX", r, w.id, w, w.width, "Graph:", T), log.trace(findNonClusterChild(w.id, T)), clusterDb.set(w.id, {
+			id: findNonClusterChild(w.id, T),
 			node: w
-		})) : (log.trace("Node - the non recursive path XAX", r, R, C.node(r), N), await insertNode(R, C.node(r), {
+		})) : (log.trace("Node - the non recursive path XAX", r, R, T.node(r), N), await insertNode(R, T.node(r), {
 			config: M,
 			dir: N
 		}));
 	})), await (/* @__PURE__ */ __name(async () => {
-		let r = C.edges().map(async function(r) {
-			let w = C.edge(r.v, r.w, r.name);
-			log.info("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(r)), log.info("Edge " + r.v + " -> " + r.w + ": ", r, " ", JSON.stringify(C.edge(r))), log.info("Fix", clusterDb, "ids:", r.v, r.w, "Translating: ", clusterDb.get(r.v), clusterDb.get(r.w)), await insertEdgeLabel(L, w);
+		let r = T.edges().map(async function(r) {
+			let w = T.edge(r.v, r.w, r.name);
+			log.info("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(r)), log.info("Edge " + r.v + " -> " + r.w + ": ", r, " ", JSON.stringify(T.edge(r))), log.info("Fix", clusterDb, "ids:", r.v, r.w, "Translating: ", clusterDb.get(r.v), clusterDb.get(r.w)), await insertEdgeLabel(L, w);
 		});
 		await Promise.all(r);
-	}, "processEdges"))(), log.info("Graph before layout:", JSON.stringify(write(C))), log.info("############################################# XXX"), log.info("###                Layout                 ### XXX"), log.info("############################################# XXX"), layout(C), log.info("Graph after layout:", JSON.stringify(write(C)));
+	}, "processEdges"))(), log.info("Graph before layout:", JSON.stringify(write(T))), log.info("############################################# XXX"), log.info("###                Layout                 ### XXX"), log.info("############################################# XXX"), layout(T), log.info("Graph after layout:", JSON.stringify(write(T)));
 	let z = 0, { subGraphTitleTotalMargin: B } = getSubGraphTitleMargins(M);
-	return await Promise.all(sortNodesByHierarchy(C).map(async function(r) {
-		let w = C.node(r);
-		if (log.info("Position XBX => " + r + ": (" + w.x, "," + w.y, ") width: ", w.width, " height: ", w.height), w?.clusterNode) w.y += B, log.info("A tainted cluster node XBX1", r, w.id, w.width, w.height, w.x, w.y, C.parent(r)), clusterDb.get(w.id).node = w, positionNode(w);
-		else if (C.children(r).length > 0) {
-			log.info("A pure cluster node XBX1", r, w.id, w.x, w.y, w.width, w.height, C.parent(r)), w.height += B, C.node(w.parentId);
-			let T = w?.padding / 2 || 0, E = w?.labelBBox?.height || 0, O = E - T || 0;
-			log.debug("OffsetY", O, "labelHeight", E, "halfPadding", T), await insertCluster(F, w), clusterDb.get(w.id).node = w;
+	return await Promise.all(sortNodesByHierarchy(T).map(async function(r) {
+		let w = T.node(r);
+		if (log.info("Position XBX => " + r + ": (" + w.x, "," + w.y, ") width: ", w.width, " height: ", w.height), w?.clusterNode) w.y += B, log.info("A tainted cluster node XBX1", r, w.id, w.width, w.height, w.x, w.y, T.parent(r)), clusterDb.get(w.id).node = w, positionNode(w);
+		else if (T.children(r).length > 0) {
+			log.info("A pure cluster node XBX1", r, w.id, w.x, w.y, w.width, w.height, T.parent(r)), w.height += B, T.node(w.parentId);
+			let E = w?.padding / 2 || 0, D = w?.labelBBox?.height || 0, O = D - E || 0;
+			log.debug("OffsetY", O, "labelHeight", D, "halfPadding", E), await insertCluster(F, w), clusterDb.get(w.id).node = w;
 		} else {
-			let r = C.node(w.parentId);
+			let r = T.node(w.parentId);
 			w.y += B / 2, log.info("A regular node XBX1 - using the padding", w.id, "parent", w.parentId, w.width, w.height, w.x, w.y, "offsetY", w.offsetY, "parent", r, r?.offsetY, w), positionNode(w);
 		}
-	})), C.edges().forEach(function(r) {
-		let w = C.edge(r);
-		log.info("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(w), w), w.points.forEach((r) => r.y += B / 2), positionEdgeLabel(w, insertEdge(I, w, clusterDb, T, C.node(r.v), C.node(r.w), E));
-	}), C.nodes().forEach(function(r) {
-		let w = C.node(r);
+	})), T.edges().forEach(function(r) {
+		let w = T.edge(r);
+		log.info("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(w), w), w.points.forEach((r) => r.y += B / 2), positionEdgeLabel(w, insertEdge(I, w, clusterDb, D, T.node(r.v), T.node(r.w), O));
+	}), T.nodes().forEach(function(r) {
+		let w = T.node(r);
 		log.info(r, w.type, w.diff), w.isGroup && (z = w.diff);
 	}), log.warn("Returning from recursive render XAX", P, z), {
 		elem: P,
 		diff: z
 	};
-}, "recursiveRender"), render = /* @__PURE__ */ __name(async (r, C) => {
-	let w = new Graph({
+}, "recursiveRender"), render = /* @__PURE__ */ __name(async (r, w) => {
+	let E = new Graph({
 		multigraph: !0,
 		compound: !0
 	}).setGraph({
@@ -259,15 +259,15 @@ var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map
 		marginy: 8
 	}).setDefaultEdgeLabel(function() {
 		return {};
-	}), T = C.select("g");
-	markers_default(T, r.markers, r.type, r.diagramId), clear2(), clear(), clear$1(), clear4(), r.nodes.forEach((r) => {
-		w.setNode(r.id, { ...r }), r.parentId && w.setParent(r.id, r.parentId);
+	}), D = w.select("g");
+	markers_default(D, r.markers, r.type, r.diagramId), clear2(), clear(), clear$1(), clear4(), r.nodes.forEach((r) => {
+		E.setNode(r.id, { ...r }), r.parentId && E.setParent(r.id, r.parentId);
 	}), log.debug("Edges:", r.edges), r.edges.forEach((r) => {
 		if (r.start === r.end) {
-			let C = r.start, T = C + "---" + C + "---1", E = C + "---" + C + "---2", D = w.node(C);
-			w.setNode(T, {
-				domId: T,
-				id: T,
+			let C = r.start, w = C + "---" + C + "---1", T = C + "---" + C + "---2", D = E.node(C);
+			E.setNode(w, {
+				domId: w,
+				id: w,
 				parentId: D.parentId,
 				labelStyle: "",
 				label: "",
@@ -276,9 +276,9 @@ var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map
 				style: "",
 				width: 10,
 				height: 10
-			}), w.setParent(T, D.parentId), w.setNode(E, {
-				domId: E,
-				id: E,
+			}), E.setParent(w, D.parentId), E.setNode(T, {
+				domId: T,
+				id: T,
 				parentId: D.parentId,
 				labelStyle: "",
 				padding: 0,
@@ -287,12 +287,12 @@ var clusterDb = /* @__PURE__ */ new Map(), descendants = /* @__PURE__ */ new Map
 				style: "",
 				width: 10,
 				height: 10
-			}), w.setParent(E, D.parentId);
+			}), E.setParent(T, D.parentId);
 			let O = structuredClone(r), k = structuredClone(r), A = structuredClone(r);
-			O.label = "", O.arrowTypeEnd = "none", O.id = C + "-cyclic-special-1", k.arrowTypeStart = "none", k.arrowTypeEnd = "none", k.id = C + "-cyclic-special-mid", A.label = "", D.isGroup && (O.fromCluster = C, A.toCluster = C), A.id = C + "-cyclic-special-2", A.arrowTypeStart = "none", w.setEdge(C, T, O, C + "-cyclic-special-0"), w.setEdge(T, E, k, C + "-cyclic-special-1"), w.setEdge(E, C, A, C + "-cyc<lic-special-2");
-		} else w.setEdge(r.start, r.end, { ...r }, r.id);
-	}), log.warn("Graph at first:", JSON.stringify(write(w))), adjustClustersAndEdges(w), log.warn("Graph after XAX:", JSON.stringify(write(w)));
-	let O = getConfig2();
-	await recursiveRender(T, w, r.type, r.diagramId, void 0, O);
+			O.label = "", O.arrowTypeEnd = "none", O.id = C + "-cyclic-special-1", k.arrowTypeStart = "none", k.arrowTypeEnd = "none", k.id = C + "-cyclic-special-mid", A.label = "", D.isGroup && (O.fromCluster = C, A.toCluster = C), A.id = C + "-cyclic-special-2", A.arrowTypeStart = "none", E.setEdge(C, w, O, C + "-cyclic-special-0"), E.setEdge(w, T, k, C + "-cyclic-special-1"), E.setEdge(T, C, A, C + "-cyc<lic-special-2");
+		} else E.setEdge(r.start, r.end, { ...r }, r.id);
+	}), log.warn("Graph at first:", JSON.stringify(write(E))), adjustClustersAndEdges(E), log.warn("Graph after XAX:", JSON.stringify(write(E)));
+	let k = getConfig2();
+	await recursiveRender(D, E, r.type, r.diagramId, void 0, k);
 }, "render");
 export { render };