@sme.up/ketchup2 2.7.0 → 2.8.1

package/dist/dagre-GXQ25YYZ-Bg7xf6xn.js

@@ -0,0 +1,425 @@
+import { m as e } from "./src-DQoflmwT.js";
+import { x as t } from "./chunk-DU6HZSFF-waeanndy.js";
+import { n } from "./chunk-Y2CYZVJY-i11wjrBe.js";
+import "./chunk-75Z2AOVW-Drsj7a97.js";
+import "./chunk-P2QGCYS3-BUeNZ170.js";
+import "./chunk-PWAF6VOD-D37VoZ8H.js";
+import "./chunk-GMAD6QVW-D80II4AD.js";
+import { s as r } from "./chunk-4HAMMTFA-CZgIgrp_.js";
+import { a as i, i as a, n as o } from "./chunk-GVQU2GXP-DP3t_9Rl.js";
+import { n as s } from "./chunk-L3NEJ4N5-qPot4t6M.js";
+import { a as c, c as l, i as u } from "./chunk-OSK3NFVY-CQhPF3Mc.js";
+import { t as d } from "./graphlib-XW-Jr8pF.js";
+import { t as f } from "./dagre-D5csT9sx.js";
+import { a as p, i as m, n as h, o as g, r as _, s as v, t as y } from "./chunk-2E4U76K2-ComA5SPA.js";
+//#region node_modules/mermaid/dist/chunks/mermaid.core/dagre-GXQ25YYZ.mjs
+var b = /* @__PURE__ */ n((e, t, n) => Math.max(t, Math.min(n, e)), "clamp"), x = /* @__PURE__ */ n((e = "TB") => {
+	switch (e) {
+		case "BT": return "bottom";
+		case "LR": return "right";
+		case "RL": return "left";
+		default: return "top";
+	}
+}, "getDefaultSelfLoopSide"), S = /* @__PURE__ */ n((e) => e === "flowchart" || e === "flowchart-v2" || e === "stateDiagram" || e === "er" || e === "classDiagram", "shouldMergeSelfLoopSegments"), C = [
+	"x",
+	"y",
+	"width",
+	"height",
+	"labelBBox",
+	"intersect",
+	"calcIntersect",
+	"diff",
+	"clusterNode"
+], w = /* @__PURE__ */ n((e, t, n, r, i) => {
+	let a = [], o = /* @__PURE__ */ new Set();
+	if (n.forEach(({ start: e, end: t }) => {
+		e !== r && o.add(e), t !== r && o.add(t);
+	}), o.forEach((t) => {
+		let n = e.node(t);
+		typeof n?.x == "number" && typeof n?.y == "number" && a.push(n);
+	}), a.length === 0 && n.forEach(({ edge: e }) => {
+		(e.points ?? []).forEach((e) => {
+			typeof e?.x == "number" && typeof e?.y == "number" && a.push(e);
+		});
+	}), a.length === 0) return x(i);
+	let s = a.reduce((e, t) => ({
+		x: e.x + t.x / a.length,
+		y: e.y + t.y / a.length
+	}), {
+		x: 0,
+		y: 0
+	}), c = s.x - t.x, l = s.y - t.y;
+	return Math.abs(c) > Math.abs(l) ? c > 0 ? "right" : "left" : Math.abs(l) > 0 ? l > 0 ? "bottom" : "top" : x(i);
+}, "getSelfLoopSide"), T = /* @__PURE__ */ n((e, t = "top", n = 0, r = 0) => {
+	let i = e.x, a = e.y - n, o = e.width / 2, s = e.height / 2, c = Math.max(36, Math.min(100, e.width * .8)), l = b(Math.max(r, e.width * .35), 36, c), u = b(Math.min(e.width, e.height) * .45, 24, 48);
+	switch (t) {
+		case "bottom": {
+			let e = a + s;
+			return [
+				{
+					x: i - l / 2,
+					y: e
+				},
+				{
+					x: i - l / 2,
+					y: e + u
+				},
+				{
+					x: i + l / 2,
+					y: e + u
+				},
+				{
+					x: i + l / 2,
+					y: e
+				}
+			];
+		}
+		case "right": {
+			let e = i + o;
+			return [
+				{
+					x: e,
+					y: a - l / 2
+				},
+				{
+					x: e + u,
+					y: a - l / 2
+				},
+				{
+					x: e + u,
+					y: a + l / 2
+				},
+				{
+					x: e,
+					y: a + l / 2
+				}
+			];
+		}
+		case "left": {
+			let e = i - o;
+			return [
+				{
+					x: e,
+					y: a - l / 2
+				},
+				{
+					x: e - u,
+					y: a - l / 2
+				},
+				{
+					x: e - u,
+					y: a + l / 2
+				},
+				{
+					x: e,
+					y: a + l / 2
+				}
+			];
+		}
+		default: {
+			let e = a - s;
+			return [
+				{
+					x: i - l / 2,
+					y: e
+				},
+				{
+					x: i - l / 2,
+					y: e - u
+				},
+				{
+					x: i + l / 2,
+					y: e - u
+				},
+				{
+					x: i + l / 2,
+					y: e
+				}
+			];
+		}
+	}
+}, "getSelfLoopPoints"), E = /* @__PURE__ */ n((e, t, n = "top", r = 0, i = {}) => {
+	let a = e.x, o = e.y - r, s = i.width ?? 0, c = i.height ?? 0;
+	switch (n) {
+		case "bottom": return {
+			x: a,
+			y: Math.max(...t.map((e) => e.y)) + c / 2 + 4
+		};
+		case "right": return {
+			x: Math.max(...t.map((e) => e.x)) + s / 2 + 4,
+			y: o
+		};
+		case "left": return {
+			x: Math.min(...t.map((e) => e.x)) - s / 2 - 4,
+			y: o
+		};
+		default: return {
+			x: a,
+			y: Math.min(...t.map((e) => e.y)) - c / 2 - 4
+		};
+	}
+}, "getSelfLoopLabelPosition"), D = /* @__PURE__ */ n((e, t = 0, { mergeSelfLoops: n = !0 } = {}) => {
+	let r = /* @__PURE__ */ new Map(), i = [], a = e.graph()?.rankdir;
+	return e.edges().forEach((t) => {
+		let a = e.edge(t);
+		if (n && a.selfLoop) {
+			let e = a.selfLoop.id;
+			r.has(e) || r.set(e, []), r.get(e).push({
+				edge: a,
+				start: t.v,
+				end: t.w
+			});
+		} else i.push({
+			edge: a,
+			start: t.v,
+			end: t.w
+		});
+	}), r.forEach((n) => {
+		if (n.length !== 3) {
+			n.forEach((e) => i.push(e));
+			return;
+		}
+		n.sort((e, t) => e.edge.selfLoop.order - t.edge.selfLoop.order);
+		let [r, o, s] = n, c = r.edge.originalEdge ?? o.edge.originalEdge ?? s.edge.originalEdge ?? o.edge, l = e.node(c.start);
+		if (!l) {
+			n.forEach((e) => i.push(e));
+			return;
+		}
+		let u = {
+			width: o.edge.width,
+			height: o.edge.height
+		}, d = w(e, l, n, c.start, a), f = T(l, d, t, u.width ?? 0), p = E(l, f, d, t, u), m = {
+			...o.edge,
+			...c,
+			id: c.id,
+			points: f,
+			start: c.start,
+			end: c.end,
+			x: p.x,
+			y: p.y,
+			width: u.width,
+			height: u.height,
+			labelStyle: o.edge.labelStyle,
+			fromCluster: r.edge.fromCluster ?? o.edge.fromCluster ?? s.edge.fromCluster,
+			toCluster: r.edge.toCluster ?? o.edge.toCluster ?? s.edge.toCluster
+		};
+		delete m.selfLoop, delete m.originalEdge, i.push({
+			edge: m,
+			start: m.start,
+			end: m.end
+		});
+	}), i;
+}, "getEdgesToRender"), O = /* @__PURE__ */ n(async ({ element: t, graph: a, diagramType: s, id: l, parentCluster: u, siteConfig: d }) => {
+	let f = a.graph().rankdir;
+	e.trace("Dir in recursive render - dir:", f);
+	let { clusters: _, edgePaths: v, edgeLabels: y, nodes: b, rootGroups: x } = m(t, { edgePathsClass: "edgePaths" });
+	a.nodes() ? e.info("Recursive render XXX", a.nodes()) : e.info("No nodes found for", a), a.edges().length > 0 && e.info("Recursive edges", a.edge(a.edges()[0]));
+	let C = S(s);
+	await Promise.all(a.nodes().map(async function(t) {
+		let n = a.node(t);
+		if (u !== void 0) {
+			let n = JSON.parse(JSON.stringify(u.clusterData));
+			e.trace("Setting data for parent cluster XXX\n Node.id = ", t, "\n data=", n.height, "\nParent cluster", u.height), a.setNode(u.id, n), a.parent(t) || (e.trace("Setting parent", t, u.id), a.setParent(t, u.id, n));
+		}
+		if (e.info("(Insert) Node XXX" + t + ": " + JSON.stringify(a.node(t))), n?.clusterNode) {
+			e.info("Cluster identified XBX", t, n.width, a.node(t));
+			let { ranksep: o, nodesep: c } = a.graph();
+			n.graph.setGraph({
+				...n.graph.graph(),
+				ranksep: o + 25,
+				nodesep: c
+			});
+			let u = await F({
+				element: b,
+				graph: n.graph,
+				diagramType: s,
+				id: l,
+				parentCluster: a.node(t),
+				siteConfig: d
+			}), f = u.elem;
+			r(n, f), n.diff = u.diff || 0, e.info("New compound node after recursive render XAX", t, "width", n.width, "height", n.height), i(f, n);
+		} else a.children(t).length > 0 ? (e.trace("Cluster - the non recursive path XBX", t, n.id, n, n.width, "Graph:", a), e.trace(p(n.id, a)), h.set(n.id, {
+			id: p(n.id, a),
+			node: n
+		})) : (e.trace("Node - the non recursive path XAX", t, b, a.node(t), f), await g(b, a.node(t), {
+			config: d,
+			dir: f
+		}));
+	})), await (/* @__PURE__ */ n(async () => {
+		let t = a.edges().map(async function(t) {
+			let n = a.edge(t.v, t.w, t.name);
+			if (e.info("Edge " + t.v + " -> " + t.w + ": " + JSON.stringify(t)), e.info("Edge " + t.v + " -> " + t.w + ": ", t, " ", JSON.stringify(a.edge(t))), e.info("Fix", h, "ids:", t.v, t.w, "Translating: ", h.get(t.v), h.get(t.w)), C && n.selfLoop) {
+				if (n.selfLoop.order !== 1) return;
+				let e = {
+					...n.originalEdge,
+					...n,
+					id: n.selfLoop.id,
+					startLabelLeft: n.originalEdge?.startLabelLeft ?? n.startLabelLeft,
+					startLabelRight: n.originalEdge?.startLabelRight ?? n.startLabelRight,
+					endLabelLeft: n.originalEdge?.endLabelLeft ?? n.endLabelLeft,
+					endLabelRight: n.originalEdge?.endLabelRight ?? n.endLabelRight
+				};
+				await c(y, e), n.width = e.width, n.height = e.height, n.labelStyle = e.labelStyle;
+				return;
+			}
+			await c(y, n);
+		});
+		await Promise.all(t);
+	}, "processEdges"))();
+	let { subGraphTitleTotalMargin: w } = o(d);
+	return {
+		elem: x,
+		graph: a,
+		groups: {
+			clusters: _,
+			edgePaths: v,
+			edgeLabels: y,
+			nodes: b,
+			rootGroups: x
+		},
+		diagramType: s,
+		id: l,
+		mergeSelfLoops: C,
+		subGraphTitleTotalMargin: w
+	};
+}, "measureDagreGraph"), k = /* @__PURE__ */ n((t) => {
+	e.info("############################################# XXX"), e.info("###                Layout                 ### XXX"), e.info("############################################# XXX"), f(t);
+}, "runDagreGraphLayout"), A = /* @__PURE__ */ n((e, t, n) => {
+	let r = e.node(t);
+	if (!r) return;
+	let i = { ...r };
+	return r?.clusterNode ? i.y = (r.y ?? 0) + n : e.children(t).length > 0 ? i.height = (r.height ?? 0) + n : i.y = (r.y ?? 0) + n / 2, i;
+}, "normalizeDagreNode"), j = /* @__PURE__ */ n((e, t) => {
+	C.forEach((n) => {
+		t[n] !== void 0 && (e[n] = t[n]);
+	});
+}, "applyDagreNodeLayout"), M = /* @__PURE__ */ n((e, t, n, r) => ({
+	...e,
+	start: e.start ?? t,
+	end: e.end ?? n,
+	points: (e.points ?? []).map((e) => ({
+		...e,
+		y: typeof e.y == "number" ? e.y + r : e.y
+	}))
+}), "normalizeDagreEdge"), N = /* @__PURE__ */ n((e, t) => {
+	let { graph: n, mergeSelfLoops: r, subGraphTitleTotalMargin: i = 0 } = t, a = new Map(e.nodes.map((e) => [e.id, e]));
+	v(n).forEach((e) => {
+		let t = A(n, e, i);
+		if (!t) return;
+		j(n.node(e), t);
+		let r = a.get(e);
+		r && j(r, t);
+	});
+	let o = i / 2;
+	return e.edges = D(n, o, { mergeSelfLoops: r }).map(({ edge: e, start: t, end: n }) => M(e, t, n, o)), e;
+}, "applyDagreLayoutResult"), P = /* @__PURE__ */ n(async ({ elem: t, graph: n, groups: { clusters: r, edgePaths: i }, diagramType: o, id: c, mergeSelfLoops: d, subGraphTitleTotalMargin: f }) => {
+	let p = 0;
+	await Promise.all(v(n).map(async function(t) {
+		let i = n.node(t);
+		if (e.info("Position XBX => " + t + ": (" + i.x, "," + i.y, ") width: ", i.width, " height: ", i.height), i?.clusterNode) i.y += f, e.info("A tainted cluster node XBX1", t, i.id, i.width, i.height, i.x, i.y, n.parent(t)), h.get(i.id).node = i, a(i);
+		else if (n.children(t).length > 0) {
+			e.info("A pure cluster node XBX1", t, i.id, i.x, i.y, i.width, i.height, n.parent(t)), i.height += f, n.node(i.parentId);
+			let a = i?.padding / 2 || 0, o = i?.labelBBox?.height || 0, c = o - a || 0;
+			e.debug("OffsetY", c, "labelHeight", o, "halfPadding", a), await s(r, i), h.get(i.id).node = i;
+		} else {
+			let t = n.node(i.parentId);
+			i.y += f / 2, e.info("A regular node XBX1 - using the padding", i.id, "parent", i.parentId, i.width, i.height, i.x, i.y, "offsetY", i.offsetY, "parent", t, t?.offsetY, i), a(i);
+		}
+	}));
+	let m = f / 2;
+	return D(n, m, { mergeSelfLoops: d }).forEach(function({ edge: t, start: r, end: a }) {
+		e.info("Edge " + r + " -> " + a + ": " + JSON.stringify(t), t), t.points.forEach((e) => e.y += m);
+		let s = n.node(r), d = n.node(a), f = u(i, t, h, o, s, d, c);
+		l(t, f);
+	}), n.nodes().forEach(function(t) {
+		let r = n.node(t);
+		e.info(t, r.type, r.diff), r.isGroup && (p = r.diff);
+	}), e.warn("Returning from recursive render XAX", t, p), {
+		elem: t,
+		diff: p
+	};
+}, "paintDagreLayoutCore"), F = /* @__PURE__ */ n(async (e) => {
+	let t = await O(e);
+	return k(t.graph), await P(t);
+}, "renderDagreSubgraph"), I = /* @__PURE__ */ n((t) => {
+	let n = new d({
+		multigraph: !0,
+		compound: !0
+	}).setGraph({
+		rankdir: t.direction,
+		nodesep: t.config?.nodeSpacing || t.nodeSpacing || t.config?.flowchart?.nodeSpacing,
+		ranksep: t.config?.rankSpacing || t.rankSpacing || t.config?.flowchart?.rankSpacing,
+		marginx: 8,
+		marginy: 8
+	}).setDefaultEdgeLabel(function() {
+		return {};
+	});
+	return t.nodes.forEach((e) => {
+		n.setNode(e.id, { ...e }), e.parentId && n.setParent(e.id, e.parentId);
+	}), e.debug("Edges:", t.edges), t.edges.forEach((e) => {
+		if (e.start === e.end) {
+			let t = e.start, r = t + "---" + t + "---1", i = t + "---" + t + "---2", a = n.node(t);
+			n.setNode(r, {
+				domId: r,
+				id: r,
+				parentId: a.parentId,
+				labelStyle: "",
+				label: "",
+				padding: 0,
+				shape: "labelRect",
+				style: "",
+				width: 10,
+				height: 10
+			}), n.setParent(r, a.parentId), n.setNode(i, {
+				domId: i,
+				id: i,
+				parentId: a.parentId,
+				labelStyle: "",
+				padding: 0,
+				shape: "labelRect",
+				label: "",
+				style: "",
+				width: 10,
+				height: 10
+			}), n.setParent(i, a.parentId);
+			let o = structuredClone(e), s = structuredClone(e), c = structuredClone(e), l = structuredClone(e);
+			s.originalEdge = o, s.selfLoop = {
+				id: o.id,
+				order: 0
+			}, c.originalEdge = o, c.selfLoop = {
+				id: o.id,
+				order: 1
+			}, l.originalEdge = o, l.selfLoop = {
+				id: o.id,
+				order: 2
+			}, s.label = "", s.arrowTypeEnd = "none", s.endLabelLeft = "", s.endLabelRight = "", s.startLabelLeft = "", s.id = t + "-cyclic-special-1", c.startLabelRight = "", c.startLabelLeft = "", c.endLabelLeft = "", c.endLabelRight = "", c.arrowTypeStart = "none", c.arrowTypeEnd = "none", c.id = t + "-cyclic-special-mid", l.label = "", l.startLabelRight = "", l.startLabelLeft = "", l.arrowTypeStart = "none", a.isGroup && (s.fromCluster = t, l.toCluster = t), l.id = t + "-cyclic-special-2", l.arrowTypeStart = "none", n.setEdge(t, r, s, t + "-cyclic-special-0"), n.setEdge(r, i, c, t + "-cyclic-special-1"), n.setEdge(i, t, l, t + "-cyclic-special-2");
+		} else n.setEdge(e.start, e.end, { ...e }, e.id);
+	}), y(n), { graph: n };
+}, "prepareLayoutForDagre"), L = /* @__PURE__ */ n(async (e, { element: n, preparedLayout: r }) => {
+	let i = r ?? I(e), a = t(), o = await O({
+		element: n,
+		graph: i.graph,
+		diagramType: e.type,
+		id: e.diagramId,
+		parentCluster: void 0,
+		siteConfig: a
+	});
+	return i.measuredLayout = o, o;
+}, "measureDagreLayout"), R = /* @__PURE__ */ n((e, t) => {
+	let n = t.preparedLayout?.measuredLayout;
+	if (!n) throw Error("runDagreLayoutCore requires measureDagreLayout to run first");
+	return k(n.graph), N(e, n), n;
+}, "runDagreLayoutCore"), z = _({
+	prepareLayout: I,
+	measureLayout: L,
+	runLayoutCore: R,
+	paintOptions: {
+		clusterDb: h,
+		getNodes: /* @__PURE__ */ n((e, { measure: t }) => v(t.graph).map((e) => t.graph.node(e)).filter(Boolean), "getDagrePaintNodes"),
+		getEdgeNode: /* @__PURE__ */ n((e, t, { measure: n }) => e ? n.graph.node(e) : void 0, "getDagreEdgeNode"),
+		skipNode: /* @__PURE__ */ n((e, { measure: t }) => !t.graph.hasNode(e.id), "skipNode"),
+		isCluster: /* @__PURE__ */ n((e, { measure: t }) => t.graph.hasNode(e.id) && (t.graph.children(e.id) ?? []).length > 0, "isCluster")
+	}
+});
+//#endregion
+export { N as applyDagreLayoutResult, D as getEdgesToRender, L as measureDagreLayout, I as prepareLayoutForDagre, z as render, R as runDagreLayoutCore };

package/dist/{defaultLocale-DnzPsei5.js → defaultLocale-N-0uLSyg.js}

@@ -68,7 +68,6 @@ function c(e) {
 		default:
 			if (!+e[n]) break out;
 			r > 0 && (r = 0);
-			break;
 	}
 	return r > 0 ? e.slice(0, r) + e.slice(i + 1) : e;
 }
@@ -165,9 +164,7 @@ function g(e) {
 				case "^":
 					e = k.slice(0, g = k.length >> 1) + n + e + a + k.slice(g);
 					break;
-				default:
-					e = k + n + e + a;
-					break;
+				default: e = k + n + e + a;
 			}
 			return d(e);
 		}