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

package/dist/node_modules/mermaid/dist/chunks/mermaid.core/dagre-6UL2VRFP.js

@@ -0,0 +1,263 @@
+import { __name, log } from "./chunk-AGHRB4JF.js";
+import { getConfig2 } from "./chunk-ABZYJK2D.js";
+import "./chunk-HN2XXSSU.js";
+import { getSubGraphTitleMargins } from "./chunk-CVBHYZKI.js";
+import "./chunk-ATLVNIR6.js";
+import "./chunk-S3R3BYOJ.js";
+import "./chunk-JA3XYJ7Z.js";
+import { clear as clear$1, clear2, insertCluster, insertNode, positionNode, setNodeElem, updateNodeBounds } from "./chunk-JZLCHNYA.js";
+import { clear, insertEdge, insertEdgeLabel, markers_default, positionEdgeLabel } from "./chunk-QXUST7PY.js";
+import { Graph } from "../../../../dagre-d3-es/src/graphlib/graph.js";
+import "../../../../dagre-d3-es/src/graphlib/index.js";
+import { layout } from "../../../../dagre-d3-es/src/dagre/layout.js";
+import "../../../../dagre-d3-es/src/dagre/index.js";
+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 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 {
+					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) {
+					log.error(e);
+				}
+			});
+		}
+		log.debug("Removing node", x), v.removeNode(x);
+	});
+}, "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 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 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 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(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 _ 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(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 (x !== v.w) {
+				let _ = e.parent(x);
+				clusterDb.get(_).externalConnections = !0, y.toCluster = v.w;
+			}
+			log.warn("Fix Replacing with XXX", b, x, v.name), e.setEdge(b, x, y, v.name);
+		}
+	}), 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 y = e.nodes(), b = !1;
+	for (let _ of y) {
+		let v = e.children(_);
+		b ||= v.length > 0;
+	}
+	if (!b) {
+		log.debug("Done, no node has children", e.nodes());
+		return;
+	}
+	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: y,
+			nodesep: 50,
+			ranksep: 50,
+			marginx: 8,
+			marginy: 8
+		}).setDefaultEdgeLabel(function() {
+			return {};
+		});
+		log.warn("Old graph before copy", write(e)), copy(b, e, x, b), e.setNode(b, {
+			clusterNode: !0,
+			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"), 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 (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 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__ */ __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"))(), 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 = 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);
+		}
+	})), 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"), render = /* @__PURE__ */ __name(async (e, y) => {
+	let S = new Graph({
+		multigraph: !0,
+		compound: !0
+	}).setGraph({
+		rankdir: e.direction,
+		nodesep: e.config?.nodeSpacing || e.config?.flowchart?.nodeSpacing || e.nodeSpacing,
+		ranksep: e.config?.rankSpacing || e.config?.flowchart?.rankSpacing || e.rankSpacing,
+		marginx: 8,
+		marginy: 8
+	}).setDefaultEdgeLabel(function() {
+		return {};
+	}), 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 _ = e.start, v = _ + "---" + _ + "---1", y = _ + "---" + _ + "---2", b = S.node(_);
+			S.setNode(v, {
+				domId: v,
+				id: v,
+				parentId: b.parentId,
+				labelStyle: "",
+				label: "",
+				padding: 0,
+				shape: "labelRect",
+				style: "",
+				width: 10,
+				height: 10
+			}), S.setParent(v, b.parentId), S.setNode(y, {
+				domId: y,
+				id: y,
+				parentId: b.parentId,
+				labelStyle: "",
+				padding: 0,
+				shape: "labelRect",
+				label: "",
+				style: "",
+				width: 10,
+				height: 10
+			}), 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");
+export { render };

package/dist/node_modules/mermaid/dist/chunks/mermaid.core/diagram-PSM6KHXK.js

@@ -0,0 +1,283 @@
+import { __name, log } from "./chunk-AGHRB4JF.js";
+import { clear, configureSvgSize, defaultConfig_default, getAccDescription, getAccTitle, getConfig, getDiagramTitle, setAccDescription, setAccTitle, setDiagramTitle } from "./chunk-ABZYJK2D.js";
+import select_default from "../../../../d3-selection/src/select.js";
+import { format } from "../../../../d3-format/src/defaultLocale.js";
+import hierarchy from "../../../../d3-hierarchy/src/hierarchy/index.js";
+import treemap_default from "../../../../d3-hierarchy/src/treemap/index.js";
+import ordinal from "../../../../d3-scale/src/ordinal.js";
+import "../../../../d3/src/index.js";
+import { selectSvgElement } from "./chunk-EXTU4WIE.js";
+import { isLabelStyle, styles2String } from "./chunk-ATLVNIR6.js";
+import { cleanAndMerge } from "./chunk-S3R3BYOJ.js";
+import { populateCommonDb } from "./chunk-4BX2VUAB.js";
+import { parse } from "../../../../@mermaid-js/parser/dist/mermaid-parser.core.js";
+import { setupViewPortForSVG } from "./chunk-QN33PNHL.js";
+var TreeMapDB = class {
+	constructor() {
+		this.nodes = [], this.levels = /* @__PURE__ */ new Map(), this.outerNodes = [], this.classes = /* @__PURE__ */ new Map(), this.setAccTitle = setAccTitle, this.getAccTitle = getAccTitle, this.setDiagramTitle = setDiagramTitle, this.getDiagramTitle = getDiagramTitle, this.getAccDescription = getAccDescription, this.setAccDescription = setAccDescription;
+	}
+	static #e = __name(this, "TreeMapDB");
+	getNodes() {
+		return this.nodes;
+	}
+	getConfig() {
+		let e = defaultConfig_default, f = getConfig();
+		return cleanAndMerge({
+			...e.treemap,
+			...f.treemap ?? {}
+		});
+	}
+	addNode(e, f) {
+		this.nodes.push(e), this.levels.set(e, f), f === 0 && (this.outerNodes.push(e), this.root ??= e);
+	}
+	getRoot() {
+		return {
+			name: "",
+			children: this.outerNodes
+		};
+	}
+	addClass(e, f) {
+		let p = this.classes.get(e) ?? {
+			id: e,
+			styles: [],
+			textStyles: []
+		}, m = f.replace(/\\,/g, "§§§").replace(/,/g, ";").replace(/§§§/g, ",").split(";");
+		m && m.forEach((e) => {
+			isLabelStyle(e) && (p?.textStyles ? p.textStyles.push(e) : p.textStyles = [e]), p?.styles ? p.styles.push(e) : p.styles = [e];
+		}), this.classes.set(e, p);
+	}
+	getClasses() {
+		return this.classes;
+	}
+	getStylesForClass(e) {
+		return this.classes.get(e)?.styles ?? [];
+	}
+	clear() {
+		clear(), this.nodes = [], this.levels = /* @__PURE__ */ new Map(), this.outerNodes = [], this.classes = /* @__PURE__ */ new Map(), this.root = void 0;
+	}
+};
+function buildHierarchy(e) {
+	if (!e.length) return [];
+	let f = [], p = [];
+	return e.forEach((e) => {
+		let m = {
+			name: e.name,
+			children: e.type === "Leaf" ? void 0 : []
+		};
+		for (m.classSelector = e?.classSelector, e?.cssCompiledStyles && (m.cssCompiledStyles = [e.cssCompiledStyles]), e.type === "Leaf" && e.value !== void 0 && (m.value = e.value); p.length > 0 && p[p.length - 1].level >= e.level;) p.pop();
+		if (p.length === 0) f.push(m);
+		else {
+			let e = p[p.length - 1].node;
+			e.children ? e.children.push(m) : e.children = [m];
+		}
+		e.type !== "Leaf" && p.push({
+			node: m,
+			level: e.level
+		});
+	}), f;
+}
+__name(buildHierarchy, "buildHierarchy");
+var populate = /* @__PURE__ */ __name((f, p) => {
+	populateCommonDb(f, p);
+	let m = [];
+	for (let e of f.TreemapRows ?? []) e.$type === "ClassDefStatement" && p.addClass(e.className ?? "", e.styleText ?? "");
+	for (let e of f.TreemapRows ?? []) {
+		let f = e.item;
+		if (!f) continue;
+		let h = e.indent ? parseInt(e.indent) : 0, g = getItemName(f), _ = f.classSelector ? p.getStylesForClass(f.classSelector) : [], v = _.length > 0 ? _.join(";") : void 0, y = {
+			level: h,
+			name: g,
+			type: f.$type,
+			value: f.value,
+			classSelector: f.classSelector,
+			cssCompiledStyles: v
+		};
+		m.push(y);
+	}
+	let h = buildHierarchy(m), g = /* @__PURE__ */ __name((e, f) => {
+		for (let m of e) p.addNode(m, f), m.children && m.children.length > 0 && g(m.children, f + 1);
+	}, "addNodesRecursively");
+	g(h, 0);
+}, "populate"), getItemName = /* @__PURE__ */ __name((e) => e.name ? String(e.name) : "", "getItemName"), parser = {
+	parser: { yy: void 0 },
+	parse: /* @__PURE__ */ __name(async (e) => {
+		try {
+			let p = await parse("treemap", e);
+			log.debug("Treemap AST:", p);
+			let m = parser.parser?.yy;
+			if (!(m instanceof TreeMapDB)) throw Error("parser.parser?.yy was not a TreemapDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues.");
+			populate(p, m);
+		} catch (e) {
+			throw log.error("Error parsing treemap:", e), e;
+		}
+	}, "parse")
+}, DEFAULT_INNER_PADDING = 10, SECTION_INNER_PADDING = 10, SECTION_HEADER_HEIGHT = 25, renderer = {
+	draw: /* @__PURE__ */ __name((p, h, g, _) => {
+		let y = _.db, b = y.getConfig(), x = b.padding ?? DEFAULT_INNER_PADDING, S = y.getDiagramTitle(), C = y.getRoot(), { themeVariables: w } = getConfig();
+		if (!C) return;
+		let T = S ? 30 : 0, E = selectSvgElement(h), D = b.nodeWidth ? b.nodeWidth * SECTION_INNER_PADDING : 960, O = b.nodeHeight ? b.nodeHeight * SECTION_INNER_PADDING : 500, k = D, A = O + T;
+		E.attr("viewBox", `0 0 ${k} ${A}`), configureSvgSize(E, A, k, b.useMaxWidth);
+		let j;
+		try {
+			let f = b.valueFormat || ",";
+			if (f === "$0,0") j = /* @__PURE__ */ __name((e) => "$" + format(",")(e), "valueFormat");
+			else if (f.startsWith("$") && f.includes(",")) {
+				let p = /\.\d+/.exec(f), m = p ? p[0] : "";
+				j = /* @__PURE__ */ __name((e) => "$" + format("," + m)(e), "valueFormat");
+			} else if (f.startsWith("$")) {
+				let p = f.substring(1);
+				j = /* @__PURE__ */ __name((e) => "$" + format(p || "")(e), "valueFormat");
+			} else j = format(f);
+		} catch (e) {
+			log.error("Error creating format function:", e), j = format(",");
+		}
+		let M = ordinal().range([
+			"transparent",
+			w.cScale0,
+			w.cScale1,
+			w.cScale2,
+			w.cScale3,
+			w.cScale4,
+			w.cScale5,
+			w.cScale6,
+			w.cScale7,
+			w.cScale8,
+			w.cScale9,
+			w.cScale10,
+			w.cScale11
+		]), N = ordinal().range([
+			"transparent",
+			w.cScalePeer0,
+			w.cScalePeer1,
+			w.cScalePeer2,
+			w.cScalePeer3,
+			w.cScalePeer4,
+			w.cScalePeer5,
+			w.cScalePeer6,
+			w.cScalePeer7,
+			w.cScalePeer8,
+			w.cScalePeer9,
+			w.cScalePeer10,
+			w.cScalePeer11
+		]), P = ordinal().range([
+			w.cScaleLabel0,
+			w.cScaleLabel1,
+			w.cScaleLabel2,
+			w.cScaleLabel3,
+			w.cScaleLabel4,
+			w.cScaleLabel5,
+			w.cScaleLabel6,
+			w.cScaleLabel7,
+			w.cScaleLabel8,
+			w.cScaleLabel9,
+			w.cScaleLabel10,
+			w.cScaleLabel11
+		]);
+		S && E.append("text").attr("x", k / 2).attr("y", T / 2).attr("class", "treemapTitle").attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(S);
+		let F = E.append("g").attr("transform", `translate(0, ${T})`).attr("class", "treemapContainer"), I = hierarchy(C).sum((e) => e.value ?? 0).sort((e, f) => (f.value ?? 0) - (e.value ?? 0)), L = treemap_default().size([D, O]).paddingTop((e) => e.children && e.children.length > 0 ? SECTION_HEADER_HEIGHT + SECTION_INNER_PADDING : 0).paddingInner(x).paddingLeft((e) => e.children && e.children.length > 0 ? SECTION_INNER_PADDING : 0).paddingRight((e) => e.children && e.children.length > 0 ? SECTION_INNER_PADDING : 0).paddingBottom((e) => e.children && e.children.length > 0 ? SECTION_INNER_PADDING : 0).round(!0)(I), R = L.descendants().filter((e) => e.children && e.children.length > 0), z = F.selectAll(".treemapSection").data(R).enter().append("g").attr("class", "treemapSection").attr("transform", (e) => `translate(${e.x0},${e.y0})`);
+		z.append("rect").attr("width", (e) => e.x1 - e.x0).attr("height", SECTION_HEADER_HEIGHT).attr("class", "treemapSectionHeader").attr("fill", "none").attr("fill-opacity", .6).attr("stroke-width", .6).attr("style", (e) => e.depth === 0 ? "display: none;" : ""), z.append("clipPath").attr("id", (e, f) => `clip-section-${h}-${f}`).append("rect").attr("width", (e) => Math.max(0, e.x1 - e.x0 - 12)).attr("height", SECTION_HEADER_HEIGHT), z.append("rect").attr("width", (e) => e.x1 - e.x0).attr("height", (e) => e.y1 - e.y0).attr("class", (e, f) => `treemapSection section${f}`).attr("fill", (e) => M(e.data.name)).attr("fill-opacity", .6).attr("stroke", (e) => N(e.data.name)).attr("stroke-width", 2).attr("stroke-opacity", .4).attr("style", (e) => {
+			if (e.depth === 0) return "display: none;";
+			let f = styles2String({ cssCompiledStyles: e.data.cssCompiledStyles });
+			return f.nodeStyles + ";" + f.borderStyles.join(";");
+		}), z.append("text").attr("class", "treemapSectionLabel").attr("x", 6).attr("y", SECTION_HEADER_HEIGHT / 2).attr("dominant-baseline", "middle").text((e) => e.depth === 0 ? "" : e.data.name).attr("font-weight", "bold").attr("style", (e) => e.depth === 0 ? "display: none;" : "dominant-baseline: middle; font-size: 12px; fill:" + P(e.data.name) + "; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;" + styles2String({ cssCompiledStyles: e.data.cssCompiledStyles }).labelStyles.replace("color:", "fill:")).each(function(e) {
+			if (e.depth === 0) return;
+			let f = select_default(this), p = e.data.name;
+			f.text(p);
+			let m = e.x1 - e.x0, h;
+			h = b.showValues !== !1 && e.value ? m - 10 - 30 - 10 - 6 : m - 6 - 6;
+			let g = Math.max(15, h), _ = f.node();
+			if (_.getComputedTextLength() > g) {
+				let e = p;
+				for (; e.length > 0;) {
+					if (e = p.substring(0, e.length - 1), e.length === 0) {
+						f.text("..."), _.getComputedTextLength() > g && f.text("");
+						break;
+					}
+					if (f.text(e + "..."), _.getComputedTextLength() <= g) break;
+				}
+			}
+		}), b.showValues !== !1 && z.append("text").attr("class", "treemapSectionValue").attr("x", (e) => e.x1 - e.x0 - 10).attr("y", SECTION_HEADER_HEIGHT / 2).attr("text-anchor", "end").attr("dominant-baseline", "middle").text((e) => e.value ? j(e.value) : "").attr("font-style", "italic").attr("style", (e) => e.depth === 0 ? "display: none;" : "text-anchor: end; dominant-baseline: middle; font-size: 10px; fill:" + P(e.data.name) + "; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;" + styles2String({ cssCompiledStyles: e.data.cssCompiledStyles }).labelStyles.replace("color:", "fill:"));
+		let B = L.leaves(), V = F.selectAll(".treemapLeafGroup").data(B).enter().append("g").attr("class", (e, f) => `treemapNode treemapLeafGroup leaf${f}${e.data.classSelector ? ` ${e.data.classSelector}` : ""}x`).attr("transform", (e) => `translate(${e.x0},${e.y0})`);
+		V.append("rect").attr("width", (e) => e.x1 - e.x0).attr("height", (e) => e.y1 - e.y0).attr("class", "treemapLeaf").attr("fill", (e) => e.parent ? M(e.parent.data.name) : M(e.data.name)).attr("style", (e) => styles2String({ cssCompiledStyles: e.data.cssCompiledStyles }).nodeStyles).attr("fill-opacity", .3).attr("stroke", (e) => e.parent ? M(e.parent.data.name) : M(e.data.name)).attr("stroke-width", 3), V.append("clipPath").attr("id", (e, f) => `clip-${h}-${f}`).append("rect").attr("width", (e) => Math.max(0, e.x1 - e.x0 - 4)).attr("height", (e) => Math.max(0, e.y1 - e.y0 - 4)), V.append("text").attr("class", "treemapLabel").attr("x", (e) => (e.x1 - e.x0) / 2).attr("y", (e) => (e.y1 - e.y0) / 2).attr("style", (e) => "text-anchor: middle; dominant-baseline: middle; font-size: 38px;fill:" + P(e.data.name) + ";" + styles2String({ cssCompiledStyles: e.data.cssCompiledStyles }).labelStyles.replace("color:", "fill:")).attr("clip-path", (e, f) => `url(#clip-${h}-${f})`).text((e) => e.data.name).each(function(e) {
+			let f = select_default(this), p = e.x1 - e.x0, m = e.y1 - e.y0, h = f.node(), g = p - 8, _ = m - 8;
+			if (g < 10 || _ < 10) {
+				f.style("display", "none");
+				return;
+			}
+			let v = parseInt(f.style("font-size"), 10), y = .6;
+			for (; h.getComputedTextLength() > g && v > 8;) v--, f.style("font-size", `${v}px`);
+			let b = Math.max(6, Math.min(28, Math.round(v * y))), x = v + 2 + b;
+			for (; x > _ && v > 8 && (v--, b = Math.max(6, Math.min(28, Math.round(v * y))), !(b < 6 && v === 8));) f.style("font-size", `${v}px`), x = v + 2 + b;
+			f.style("font-size", `${v}px`), (h.getComputedTextLength() > g || v < 8 || _ < v) && f.style("display", "none");
+		}), b.showValues !== !1 && V.append("text").attr("class", "treemapValue").attr("x", (e) => (e.x1 - e.x0) / 2).attr("y", function(e) {
+			return (e.y1 - e.y0) / 2;
+		}).attr("style", (e) => "text-anchor: middle; dominant-baseline: hanging; font-size: 28px;fill:" + P(e.data.name) + ";" + styles2String({ cssCompiledStyles: e.data.cssCompiledStyles }).labelStyles.replace("color:", "fill:")).attr("clip-path", (e, f) => `url(#clip-${h}-${f})`).text((e) => e.value ? j(e.value) : "").each(function(e) {
+			let f = select_default(this), p = this.parentNode;
+			if (!p) {
+				f.style("display", "none");
+				return;
+			}
+			let m = select_default(p).select(".treemapLabel");
+			if (m.empty() || m.style("display") === "none") {
+				f.style("display", "none");
+				return;
+			}
+			let h = parseFloat(m.style("font-size")), g = Math.max(6, Math.min(28, Math.round(h * .6)));
+			f.style("font-size", `${g}px`);
+			let _ = (e.y1 - e.y0) / 2 + h / 2 + 2;
+			f.attr("y", _);
+			let v = e.x1 - e.x0, y = e.y1 - e.y0 - 4, b = v - 8;
+			f.node().getComputedTextLength() > b || _ + g > y || g < 6 ? f.style("display", "none") : f.style("display", null);
+		}), setupViewPortForSVG(E, b.diagramPadding ?? 8, "flowchart", b?.useMaxWidth || !1);
+	}, "draw"),
+	getClasses: /* @__PURE__ */ __name(function(e, f) {
+		return f.db.getClasses();
+	}, "getClasses")
+}, defaultTreemapStyleOptions = {
+	sectionStrokeColor: "black",
+	sectionStrokeWidth: "1",
+	sectionFillColor: "#efefef",
+	leafStrokeColor: "black",
+	leafStrokeWidth: "1",
+	leafFillColor: "#efefef",
+	labelColor: "black",
+	labelFontSize: "12px",
+	valueFontSize: "10px",
+	valueColor: "black",
+	titleColor: "black",
+	titleFontSize: "14px"
+}, diagram = {
+	parser,
+	get db() {
+		return new TreeMapDB();
+	},
+	renderer,
+	styles: /* @__PURE__ */ __name(({ treemap: e } = {}) => {
+		let f = cleanAndMerge(defaultTreemapStyleOptions, e);
+		return `
+  .treemapNode.section {
+    stroke: ${f.sectionStrokeColor};
+    stroke-width: ${f.sectionStrokeWidth};
+    fill: ${f.sectionFillColor};
+  }
+  .treemapNode.leaf {
+    stroke: ${f.leafStrokeColor};
+    stroke-width: ${f.leafStrokeWidth};
+    fill: ${f.leafFillColor};
+  }
+  .treemapLabel {
+    fill: ${f.labelColor};
+    font-size: ${f.labelFontSize};
+  }
+  .treemapValue {
+    fill: ${f.valueColor};
+    font-size: ${f.valueFontSize};
+  }
+  .treemapTitle {
+    fill: ${f.titleColor};
+    font-size: ${f.titleFontSize};
+  }
+  `;
+	}, "getStyles")
+};
+export { diagram };