@webskill/sdk 0.21.0 → 0.23.0

package/dist/channel-CZxxLrG7.js

@@ -0,0 +1,9 @@
+import { ot as Color, st as Utils } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+
+//#region ../../node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/channel.js
+const channel = (color, channel) => {
+	return Utils.lang.round(Color.parse(color)[channel]);
+};
+
+//#endregion
+export { channel as t };

package/dist/chunk-2Q5K7J3B-Ck03gkFR.js

@@ -0,0 +1,21 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-2Q5K7J3B.mjs
+var ImperativeState = class {
+	/**
+	* @param init - Function that creates the default state.
+	*/
+	constructor(init) {
+		this.init = init;
+		this.records = this.init();
+	}
+	static {
+		__name(this, "ImperativeState");
+	}
+	reset() {
+		this.records = this.init();
+	}
+};
+
+//#endregion
+export { ImperativeState as t };

package/dist/chunk-3FUC2YCW-tr6jmbQf.js

@@ -0,0 +1,530 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log } from "./src-NkhI3UMl.js";
+import { b as getConfig, x as getConfig2 } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+import { g as utils_default } from "./chunk-ZIGJFQKS-DqEFBuHR.js";
+import { o as labelHelper } from "./chunk-7INBJB4K-C9jq9o66.js";
+import { i as positionNode, n as getSubGraphTitleMargins, r as insertNode, t as clear } from "./chunk-5DYCD2WN-Bt97YGTd.js";
+import { a as insertEdgeLabel, c as markers_default, i as insertEdge, n as edgeLabels, r as hasEdgeLabel, t as clear$1, u as terminalLabels } from "./chunk-Z7XXMR3K-oLg1h8F3.js";
+import { t as Graph } from "./graphlib-tk9gQYuN.js";
+import { r as insertCluster, t as clear$2 } from "./chunk-UA2S7LBM-DxHM29_K.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-3FUC2YCW.mjs
+function createLayoutElementGroups(element, { edgePathsClass = "edges edgePaths" } = {}) {
+	const rootGroups = element.insert("g").attr("class", "root");
+	return {
+		clusters: rootGroups.insert("g").attr("class", "clusters"),
+		edgePaths: rootGroups.insert("g").attr("class", edgePathsClass),
+		edgeLabels: rootGroups.insert("g").attr("class", "edgeLabels"),
+		nodes: rootGroups.insert("g").attr("class", "nodes"),
+		rootGroups
+	};
+}
+__name(createLayoutElementGroups, "createLayoutElementGroups");
+async function measureGroupLabel(nodesGroup, node, measureWidth) {
+	if (node.label) {
+		const { shapeSvg, bbox } = await labelHelper(nodesGroup, measureWidth === void 0 ? node : {
+			...node,
+			width: measureWidth
+		});
+		node.labelBBox = {
+			width: bbox.width,
+			height: bbox.height
+		};
+		shapeSvg.remove();
+	} else node.labelBBox = {
+		width: 0,
+		height: 0
+	};
+}
+__name(measureGroupLabel, "measureGroupLabel");
+async function insertMeasuredNode(nodesGroup, node, renderOptions) {
+	const childNodeEl = await insertNode(nodesGroup, node, renderOptions);
+	const boundingBox = childNodeEl.node()?.getBBox() ?? {
+		width: 0,
+		height: 0
+	};
+	node.width = boundingBox.width;
+	node.height = boundingBox.height;
+	return childNodeEl;
+}
+__name(insertMeasuredNode, "insertMeasuredNode");
+function resolveNodeDir(node, nodeById, diagramDir) {
+	let current = node;
+	const seen = /* @__PURE__ */ new Set();
+	while (current) {
+		if (current.dir) return current.dir;
+		if (!current.parentId || seen.has(current.parentId)) break;
+		seen.add(current.parentId);
+		current = nodeById.get(current.parentId);
+	}
+	return diagramDir;
+}
+__name(resolveNodeDir, "resolveNodeDir");
+async function createGraphWithElements(element, data4Layout, options = {}) {
+	const graph = new Graph({
+		multigraph: true,
+		compound: true
+	});
+	const edgesToProcess = [...data4Layout.edges];
+	const config = getConfig2();
+	const groups = createLayoutElementGroups(element);
+	const { edgeLabels: edgeLabels2, nodes: nodesGroup } = groups;
+	const nodeElements = /* @__PURE__ */ new Map();
+	const nodeById = new Map(data4Layout.nodes.map((node) => [node.id, node]));
+	const diagramDir = data4Layout.direction;
+	const hasDom = element.node() != null;
+	await Promise.all(data4Layout.nodes.map(async (node) => {
+		if (node.isGroup) {
+			if (hasDom) {
+				const unwrap = options.unwrapGroupLabels && node.labelType !== "markdown";
+				await measureGroupLabel(nodesGroup, node, unwrap ? Number.POSITIVE_INFINITY : void 0);
+			}
+			graph.setNode(node.id, { ...node });
+		} else {
+			if (hasDom) {
+				const childNodeEl = await insertMeasuredNode(nodesGroup, node, {
+					config,
+					dir: resolveNodeDir(node, nodeById, diagramDir)
+				});
+				nodeElements.set(node.id, childNodeEl);
+			}
+			graph.setNode(node.id, { ...node });
+		}
+	}));
+	for (const edge of edgesToProcess) {
+		if (hasDom && hasEdgeLabel(edge)) await insertEdgeLabel(edgeLabels2, edge);
+		graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);
+		if (!data4Layout.edges.some((existingEdge) => existingEdge.id === edge.id)) data4Layout.edges.push(edge);
+	}
+	if (globalThis.mermaidCaptureSizes) {
+		const { captureNodeSizes } = await import("./sizeCapture-INFHLROL-D8PWxdOn.js");
+		captureNodeSizes(element, data4Layout);
+	}
+	return {
+		graph,
+		groups,
+		nodeElements
+	};
+}
+__name(createGraphWithElements, "createGraphWithElements");
+var clusterDb = /* @__PURE__ */ new Map();
+var descendants = /* @__PURE__ */ new Map();
+var parents = /* @__PURE__ */ new Map();
+var clear4 = /* @__PURE__ */ __name(() => {
+	descendants.clear();
+	parents.clear();
+	clusterDb.clear();
+}, "clear");
+var isDescendant = /* @__PURE__ */ __name((id, ancestorId) => {
+	const ancestorDescendants = descendants.get(ancestorId) || [];
+	log.trace("In isDescendant", ancestorId, " ", id, " = ", ancestorDescendants.includes(id));
+	return ancestorDescendants.includes(id);
+}, "isDescendant");
+var edgeInCluster = /* @__PURE__ */ __name((edge, clusterId) => {
+	const clusterDescendants = descendants.get(clusterId) || [];
+	log.info("Descendants of ", clusterId, " is ", clusterDescendants);
+	log.info("Edge is ", edge);
+	if (edge.v === clusterId || edge.w === clusterId) return false;
+	if (!clusterDescendants) {
+		log.debug("Tilt, ", clusterId, ",not in descendants");
+		return false;
+	}
+	return clusterDescendants.includes(edge.v) || isDescendant(edge.v, clusterId) || isDescendant(edge.w, clusterId) || clusterDescendants.includes(edge.w);
+}, "edgeInCluster");
+var copy = /* @__PURE__ */ __name((clusterId, graph, newGraph, rootId) => {
+	log.debug("Copying children of ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId);
+	const nodes = graph.children(clusterId) || [];
+	if (clusterId !== rootId) nodes.push(clusterId);
+	log.debug("Copying (nodes) clusterId", clusterId, "nodes", nodes);
+	nodes.forEach((node) => {
+		if (graph.children(node).length > 0) copy(node, graph, newGraph, rootId);
+		else {
+			const data = graph.node(node);
+			log.info("cp ", node, " to ", rootId, " with parent ", clusterId);
+			newGraph.setNode(node, data);
+			if (rootId !== graph.parent(node)) {
+				log.debug("Setting parent", node, graph.parent(node));
+				newGraph.setParent(node, graph.parent(node));
+			}
+			if (clusterId !== rootId && node !== clusterId) {
+				log.debug("Setting parent", node, clusterId);
+				newGraph.setParent(node, clusterId);
+			} else {
+				log.info("In copy ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId);
+				log.debug("Not Setting parent for node=", node, "cluster!==rootId", clusterId !== rootId, "node!==clusterId", node !== clusterId);
+			}
+			const edges = graph.edges(node);
+			log.debug("Copying Edges", edges);
+			edges.forEach((edge) => {
+				log.info("Edge", edge);
+				const data2 = graph.edge(edge.v, edge.w, edge.name);
+				log.info("Edge data", data2, rootId);
+				try {
+					if (edgeInCluster(edge, rootId)) {
+						log.info("Copying as ", edge.v, edge.w, data2, edge.name);
+						newGraph.setEdge(edge.v, edge.w, data2, edge.name);
+						log.info("newGraph edges ", newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+					} else log.info("Skipping copy of edge ", edge.v, "-->", edge.w, " rootId: ", rootId, " clusterId:", clusterId);
+				} catch (e) {
+					log.error(e);
+				}
+			});
+		}
+		log.debug("Removing node", node);
+		graph.removeNode(node);
+	});
+}, "copy");
+var extractDescendants = /* @__PURE__ */ __name((id, graph) => {
+	const children = graph.children(id);
+	let res = [...children];
+	for (const child of children) {
+		parents.set(child, id);
+		res = [...res, ...extractDescendants(child, graph)];
+	}
+	return res;
+}, "extractDescendants");
+var findCommonEdges = /* @__PURE__ */ __name((graph, id1, id2) => {
+	const edges1 = graph.edges().filter((edge) => edge.v === id1 || edge.w === id1);
+	const edges2 = graph.edges().filter((edge) => edge.v === id2 || edge.w === id2);
+	const edges1Prim = edges1.map((edge) => {
+		return {
+			v: edge.v === id1 ? id2 : edge.v,
+			w: edge.w === id1 ? id1 : edge.w
+		};
+	});
+	const edges2Prim = edges2.map((edge) => {
+		return {
+			v: edge.v,
+			w: edge.w
+		};
+	});
+	return edges1Prim.filter((edgeIn1) => {
+		return edges2Prim.some((edge) => edgeIn1.v === edge.v && edgeIn1.w === edge.w);
+	});
+}, "findCommonEdges");
+var findNonClusterChild = /* @__PURE__ */ __name((id, graph, clusterId) => {
+	const children = graph.children(id);
+	log.trace("Searching children of id ", id, children);
+	if (children.length < 1) return id;
+	let reserve;
+	for (const child of children) {
+		const _id = findNonClusterChild(child, graph, clusterId);
+		const commonEdges = findCommonEdges(graph, clusterId, _id);
+		if (_id) if (commonEdges.length > 0) reserve = _id;
+		else return _id;
+	}
+	return reserve;
+}, "findNonClusterChild");
+var getAnchorId = /* @__PURE__ */ __name((id) => {
+	if (!clusterDb.has(id)) return id;
+	if (!clusterDb.get(id).externalConnections) return id;
+	if (clusterDb.has(id)) return clusterDb.get(id).id;
+	return id;
+}, "getAnchorId");
+var adjustClustersAndEdges = /* @__PURE__ */ __name((graph, depth) => {
+	if (!graph || depth > 10) {
+		log.debug("Opting out, no graph ");
+		return;
+	} else log.debug("Opting in, graph ");
+	graph.nodes().forEach(function(id) {
+		if (graph.children(id).length > 0) {
+			log.debug("Cluster identified", id, " Replacement id in edges: ", findNonClusterChild(id, graph, id));
+			descendants.set(id, extractDescendants(id, graph));
+			clusterDb.set(id, {
+				id: findNonClusterChild(id, graph, id),
+				clusterData: graph.node(id)
+			});
+		}
+	});
+	graph.nodes().forEach(function(id) {
+		const children = graph.children(id);
+		const edges = graph.edges();
+		if (children.length > 0) {
+			log.debug("Cluster identified", id, descendants);
+			edges.forEach((edge) => {
+				if (isDescendant(edge.v, id) ^ isDescendant(edge.w, id)) {
+					log.debug("Edge: ", edge, " leaves cluster ", id);
+					log.debug("Descendants of XXX ", id, ": ", descendants.get(id));
+					clusterDb.get(id).externalConnections = true;
+				}
+			});
+		} else log.debug("Not a cluster ", id, descendants);
+	});
+	for (let id of clusterDb.keys()) {
+		const nonClusterChild = clusterDb.get(id).id;
+		const parent = graph.parent(nonClusterChild);
+		if (parent !== id && clusterDb.has(parent) && !clusterDb.get(parent).externalConnections) clusterDb.get(id).id = parent;
+		const hasDirectOutgoingEdge = graph.edges().some((edge) => edge.v === id);
+		if (nonClusterChild && clusterDb.get(id)?.externalConnections && hasDirectOutgoingEdge && isNodeInExtractableCluster(graph, nonClusterChild, id)) {
+			const safeAnchor = findSafeAnchorNode(graph, id, graph.parent(nonClusterChild));
+			if (safeAnchor) clusterDb.get(id).id = safeAnchor;
+		}
+	}
+	graph.edges().forEach(function(e) {
+		const edge = graph.edge(e);
+		log.debug("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
+		log.debug("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(graph.edge(e)));
+		let v = e.v;
+		let w = e.w;
+		log.debug("Fix XXX", clusterDb, "ids:", e.v, e.w, "Translating: ", clusterDb.get(e.v), " --- ", clusterDb.get(e.w));
+		if (clusterDb.get(e.v) || clusterDb.get(e.w)) {
+			log.debug("Fixing and trying - removing XXX", e.v, e.w, e.name);
+			v = getAnchorId(e.v);
+			w = getAnchorId(e.w);
+			graph.removeEdge(e.v, e.w, e.name);
+			if (v !== e.v) {
+				const parent = graph.parent(v);
+				clusterDb.get(parent).externalConnections = true;
+				edge.fromCluster = e.v;
+			}
+			if (w !== e.w) {
+				const parent = graph.parent(w);
+				clusterDb.get(parent).externalConnections = true;
+				edge.toCluster = e.w;
+			}
+			log.debug("Fix Replacing with XXX", v, w, e.name);
+			graph.setEdge(v, w, edge, e.name);
+		}
+	});
+	extractor(graph, 0);
+	log.trace(clusterDb);
+}, "adjustClustersAndEdges");
+var extractor = /* @__PURE__ */ __name((graph, depth) => {
+	if (depth > 10) {
+		log.error("Bailing out");
+		return;
+	}
+	let nodes = graph.nodes();
+	let hasChildren = false;
+	for (const node of nodes) {
+		const children = graph.children(node);
+		hasChildren = hasChildren || children.length > 0;
+	}
+	if (!hasChildren) {
+		log.debug("Done, no node has children", graph.nodes());
+		return;
+	}
+	log.debug("Nodes = ", nodes, depth);
+	for (const node of nodes) {
+		log.debug("Extracting node", node, clusterDb, clusterDb.has(node) && !clusterDb.get(node).externalConnections, !graph.parent(node), graph.node(node), graph.children("D"), " Depth ", depth);
+		if (!clusterDb.has(node)) log.debug("Not a cluster", node, depth);
+		else if (!clusterDb.get(node).externalConnections && graph.children(node) && graph.children(node).length > 0) {
+			log.debug("Cluster without external connections, without a parent and with children", node, depth);
+			let dir = graph.graph().rankdir === "TB" ? "LR" : "TB";
+			if (clusterDb.get(node)?.clusterData?.dir) {
+				dir = clusterDb.get(node).clusterData.dir;
+				log.debug("Fixing dir", clusterDb.get(node).clusterData.dir, dir);
+			}
+			const clusterGraph = new Graph({
+				multigraph: true,
+				compound: true
+			}).setGraph({
+				rankdir: dir,
+				nodesep: 50,
+				ranksep: 50,
+				marginx: 8,
+				marginy: 8
+			}).setDefaultEdgeLabel(function() {
+				return {};
+			});
+			copy(node, graph, clusterGraph, node);
+			graph.setNode(node, {
+				clusterNode: true,
+				id: node,
+				clusterData: clusterDb.get(node).clusterData,
+				label: clusterDb.get(node).label,
+				graph: clusterGraph
+			});
+		} else {
+			log.debug("Cluster ** ", node, " **not meeting the criteria !externalConnections:", !clusterDb.get(node).externalConnections, " no parent: ", !graph.parent(node), " children ", graph.children(node) && graph.children(node).length > 0, graph.children("D"), depth);
+			log.debug(clusterDb);
+		}
+	}
+	nodes = graph.nodes();
+	log.debug("New list of nodes", nodes);
+	for (const node of nodes) {
+		const data = graph.node(node);
+		log.debug(" Now next level", node, data);
+		if (data?.clusterNode) extractor(data.graph, depth + 1);
+	}
+}, "extractor");
+var sorter = /* @__PURE__ */ __name((graph, nodes) => {
+	if (nodes.length === 0) return [];
+	let result = Object.assign([], nodes);
+	nodes.forEach((node) => {
+		const sorted = sorter(graph, graph.children(node));
+		result = [...result, ...sorted];
+	});
+	return result;
+}, "sorter");
+var sortNodesByHierarchy = /* @__PURE__ */ __name((graph) => sorter(graph, graph.children()), "sortNodesByHierarchy");
+var isNodeInExtractableCluster = /* @__PURE__ */ __name((graph, node, rootId) => {
+	let parent = graph.parent(node);
+	while (parent && parent !== rootId) {
+		const cluster = clusterDb.get(parent);
+		if (cluster && !cluster.externalConnections) return true;
+		parent = graph.parent(parent);
+	}
+	return false;
+}, "isNodeInExtractableCluster");
+var findSafeAnchorNode = /* @__PURE__ */ __name((graph, clusterId, excludedCluster) => {
+	const children = graph.children(clusterId) ?? [];
+	for (const child of children) {
+		if (child === excludedCluster || isDescendant(child, excludedCluster)) continue;
+		const candidate = findNonClusterChild(child, graph, clusterId);
+		if (!candidate) continue;
+		if (!isNodeInExtractableCluster(graph, candidate, clusterId)) return candidate;
+	}
+	return null;
+}, "findSafeAnchorNode");
+function createCommonLayoutRenderer({ prepareLayout, measureLayout, runLayoutCore, paintLayout, afterPaint, paintOptions }) {
+	const measureLayoutFn = measureLayout ?? defaultMeasureLayout;
+	return /* @__PURE__ */ __name(async function render(data4Layout, svg, helpers, options) {
+		const element = svg.select("g");
+		(helpers?.insertMarkers ?? markers_default)(element, data4Layout.markers, data4Layout.type, data4Layout.diagramId);
+		clearLayoutRenderState();
+		const renderContext = {
+			element,
+			helpers,
+			options
+		};
+		renderContext.preparedLayout = await prepareLayout?.(data4Layout, renderContext);
+		const measure = await measureLayoutFn(data4Layout, renderContext);
+		const coreResult = await runLayoutCore(data4Layout, renderContext);
+		const paintContext = {
+			...renderContext,
+			measure
+		};
+		if (paintLayout) await paintLayout(data4Layout, paintContext, coreResult);
+		else await paintLayoutData(data4Layout, paintContext, paintOptions);
+		await afterPaint?.(data4Layout, paintContext, coreResult);
+	}, "render");
+}
+__name(createCommonLayoutRenderer, "createCommonLayoutRenderer");
+function clearLayoutRenderState() {
+	clear();
+	clear$1();
+	clear$2();
+	clear4();
+}
+__name(clearLayoutRenderState, "clearLayoutRenderState");
+async function defaultMeasureLayout(data4Layout, { element }, options) {
+	return await createGraphWithElements(element, data4Layout, options);
+}
+__name(defaultMeasureLayout, "defaultMeasureLayout");
+async function paintLayoutData(data4Layout, context, options = {}) {
+	const { measure } = context;
+	const { groups } = measure;
+	for (const node of options.getNodes?.(data4Layout, context) ?? data4Layout.nodes) {
+		if (options.skipNode?.(node, context)) continue;
+		await paintLayoutNode(groups, node, context, options);
+	}
+	const nodeById = buildNodeLookup(data4Layout.nodes);
+	for (const edge of data4Layout.edges) {
+		if (shouldSkipPaintEdge(edge, options)) continue;
+		await paintLayoutEdge(groups, edge, nodeById, data4Layout, options, context);
+	}
+}
+__name(paintLayoutData, "paintLayoutData");
+async function paintLayoutNode(groups, node, context, options) {
+	if (node.clusterNode) positionNode(node);
+	else if (shouldPaintAsCluster(node, context, options)) await insertCluster(groups.clusters, node);
+	else positionNode(node);
+}
+__name(paintLayoutNode, "paintLayoutNode");
+function shouldPaintAsCluster(node, context, options) {
+	return node.isGroup === true && (options.isCluster?.(node, context) ?? true);
+}
+__name(shouldPaintAsCluster, "shouldPaintAsCluster");
+function buildNodeLookup(nodes) {
+	const nodeById = /* @__PURE__ */ new Map();
+	for (const node of nodes) if (node?.id) nodeById.set(node.id, node);
+	return nodeById;
+}
+__name(buildNodeLookup, "buildNodeLookup");
+function shouldSkipPaintEdge(edge, options) {
+	return edge.isLayoutOnly || Boolean(options.skipEdge?.(edge));
+}
+__name(shouldSkipPaintEdge, "shouldSkipPaintEdge");
+async function paintLayoutEdge(groups, edge, nodeById, data4Layout, options, context) {
+	const paths = insertEdge(groups.edgePaths, { ...edge }, options.clusterDb ?? /* @__PURE__ */ new Map(), data4Layout.type, getRenderedNode(edge.start, edge, nodeById, context, options), getRenderedNode(edge.end, edge, nodeById, context, options), data4Layout.diagramId, shouldSkipIntersect(edge, options));
+	if (hasEdgeLabel(edge)) {
+		if (!edgeLabels.has(edge.id)) await insertEdgeLabel(groups.edgeLabels, edge);
+		positionRenderedEdgeLabel(edge, paths);
+	}
+}
+__name(paintLayoutEdge, "paintLayoutEdge");
+function getRenderedNode(id, edge, nodeById, context, options) {
+	return options.getEdgeNode?.(id, edge, context) ?? (id ? nodeById.get(id) ?? {} : {});
+}
+__name(getRenderedNode, "getRenderedNode");
+function shouldSkipIntersect(edge, options) {
+	return typeof options.skipIntersect === "function" ? options.skipIntersect(edge) : options.skipIntersect ?? false;
+}
+__name(shouldSkipIntersect, "shouldSkipIntersect");
+function positionRenderedEdgeLabel(edge, paths) {
+	const path = paths?.updatedPath ?? paths?.originalPath;
+	const { subGraphTitleTotalMargin } = getSubGraphTitleMargins({ flowchart: getConfig().flowchart ?? {} });
+	if (edge.label) {
+		const el = edgeLabels.get(edge.id);
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcLabelPosition(path);
+			log.debug("Moving label " + edge.label + " from (", x, ",", y, ") to (", pos.x, ",", pos.y, ") abc88");
+			if (paths?.updatedPath) {
+				x = pos.x;
+				y = pos.y;
+			}
+		}
+		el.attr("transform", `translate(${x}, ${y + subGraphTitleTotalMargin / 2})`);
+	}
+	if (edge?.startLabelLeft) {
+		const el = terminalLabels.get(edge.id).startLeft;
+		let x = edge?.x;
+		let y = edge?.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeStart ? 10 : 0, "start_left", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+	if (edge.startLabelRight) {
+		const el = terminalLabels.get(edge.id).startRight;
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeStart ? 10 : 0, "start_right", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+	if (edge.endLabelLeft) {
+		const el = terminalLabels.get(edge.id).endLeft;
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeEnd ? 10 : 0, "end_left", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+	if (edge.endLabelRight) {
+		const el = terminalLabels.get(edge.id).endRight;
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeEnd ? 10 : 0, "end_right", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+}
+__name(positionRenderedEdgeLabel, "positionRenderedEdgeLabel");
+
+//#endregion
+export { defaultMeasureLayout as a, sortNodesByHierarchy as c, createLayoutElementGroups as i, clusterDb as n, findNonClusterChild as o, createCommonLayoutRenderer as r, insertMeasuredNode as s, adjustClustersAndEdges as t };

package/dist/chunk-5DYCD2WN-Bt97YGTd.js

@@ -0,0 +1,58 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log } from "./src-NkhI3UMl.js";
+import { u as handleUndefinedAttr } from "./chunk-ZIGJFQKS-DqEFBuHR.js";
+import { s as shapes } from "./chunk-7INBJB4K-C9jq9o66.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-5DYCD2WN.mjs
+var getSubGraphTitleMargins = /* @__PURE__ */ __name(({ flowchart }) => {
+	const subGraphTitleTopMargin = flowchart?.subGraphTitleMargin?.top ?? 0;
+	const subGraphTitleBottomMargin = flowchart?.subGraphTitleMargin?.bottom ?? 0;
+	return {
+		subGraphTitleTopMargin,
+		subGraphTitleBottomMargin,
+		subGraphTitleTotalMargin: subGraphTitleTopMargin + subGraphTitleBottomMargin
+	};
+}, "getSubGraphTitleMargins");
+var nodeElems = /* @__PURE__ */ new Map();
+async function insertNode(elem, node, renderOptions) {
+	let newEl;
+	let el;
+	if (node.shape === "rect") if (node.rx && node.ry) node.shape = "roundedRect";
+	else node.shape = "squareRect";
+	const shapeHandler = node.shape ? shapes[node.shape] : void 0;
+	if (!shapeHandler) throw new Error(`No such shape: ${node.shape}. Please check your syntax.`);
+	if (node.link) {
+		let target;
+		if (renderOptions.config.securityLevel === "sandbox") target = "_top";
+		else if (node.linkTarget) target = node.linkTarget || "_blank";
+		newEl = elem.insert("svg:a").attr("xlink:href", node.link).attr("target", target ?? null);
+		el = await shapeHandler(newEl, node, renderOptions);
+	} else {
+		el = await shapeHandler(elem, node, renderOptions);
+		newEl = el;
+	}
+	newEl.attr("data-look", handleUndefinedAttr(node.look));
+	if (node.tooltip) el.attr("title", node.tooltip);
+	nodeElems.set(node.id, newEl);
+	if (node.haveCallback) newEl.attr("class", newEl.attr("class") + " clickable");
+	return newEl;
+}
+__name(insertNode, "insertNode");
+var setNodeElem = /* @__PURE__ */ __name((elem, node) => {
+	nodeElems.set(node.id, elem);
+}, "setNodeElem");
+var clear = /* @__PURE__ */ __name(() => {
+	nodeElems.clear();
+}, "clear");
+var positionNode = /* @__PURE__ */ __name((node) => {
+	const el = nodeElems.get(node.id);
+	log.trace("Transforming node", node.diff, node, "translate(" + (node.x - node.width / 2 - 5) + ", " + node.width / 2 + ")");
+	const padding = 8;
+	const diff = node.diff || 0;
+	if (node.clusterNode) el.attr("transform", "translate(" + (node.x + diff - node.width / 2) + ", " + (node.y - node.height / 2 - padding) + ")");
+	else el.attr("transform", "translate(" + node.x + ", " + node.y + ")");
+	return diff;
+}, "positionNode");
+
+//#endregion
+export { setNodeElem as a, positionNode as i, getSubGraphTitleMargins as n, insertNode as r, clear as t };

package/dist/chunk-5VM5RSS4-BBxa48HL.js

@@ -0,0 +1,21 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-5VM5RSS4.mjs
+var getIconStyles = /* @__PURE__ */ __name(() => `
+  /* Font Awesome icon styling - consolidated */
+  .label-icon {
+    display: inline-block;
+    height: 1em;
+    overflow: visible;
+    vertical-align: -0.125em;
+  }
+  
+  .node .label-icon path {
+    fill: currentColor;
+    stroke: revert;
+    stroke-width: revert;
+  }
+`, "getIconStyles");
+
+//#endregion
+export { getIconStyles as t };

package/dist/chunk-6AEJRKK7-JXK89I-O.js

@@ -0,0 +1,14 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { p as select_default } from "./src-NkhI3UMl.js";
+import { x as getConfig2 } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-6AEJRKK7.mjs
+var selectSvgElement = /* @__PURE__ */ __name((id) => {
+	const { securityLevel } = getConfig2();
+	let root = select_default("body");
+	if (securityLevel === "sandbox") root = select_default((select_default(`#i${id}`).node()?.contentDocument ?? document).body);
+	return root.select(`#${id}`);
+}, "selectSvgElement");
+
+//#endregion
+export { selectSvgElement as t };