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

package/dist/node_modules/mermaid/dist/chunks/mermaid.core/chunk-JZLCHNYA.js

@@ -0,0 +1,3516 @@
+import { __name, log } from "./chunk-AGHRB4JF.js";
+import { common_default, defaultConfig_default, evaluate, getConfig, getConfig2, hasKatex, parseGenericTypes, renderKatexSanitized, sanitizeText, sanitizeText3 } from "./chunk-ABZYJK2D.js";
+import select_default from "../../../../d3-selection/src/select.js";
+import "../../../../d3/src/index.js";
+import { getSubGraphTitleMargins } from "./chunk-CVBHYZKI.js";
+import { compileStyles, solidStateFill, styles2String, userNodeOverrides } from "./chunk-ATLVNIR6.js";
+import { calculateTextWidth, decodeEntities, handleUndefinedAttr, parseFontSize } from "./chunk-S3R3BYOJ.js";
+import { createText, getIconSVG } from "./chunk-JA3XYJ7Z.js";
+import { at } from "../../../../roughjs/bundled/rough.esm.js";
+var labelHelper = /* @__PURE__ */ __name(async (l, u, p) => {
+	let h, g = u.useHtmlLabels || evaluate(getConfig2()?.htmlLabels);
+	h = p || "node default";
+	let _ = l.insert("g").attr("class", h).attr("id", u.domId || u.id), y = _.insert("g").attr("class", "label").attr("style", handleUndefinedAttr(u.labelStyle)), x;
+	x = u.label === void 0 ? "" : typeof u.label == "string" ? u.label : u.label[0];
+	let S = await createText(y, sanitizeText(decodeEntities(x), getConfig2()), {
+		useHtmlLabels: g,
+		width: u.width || getConfig2().flowchart?.wrappingWidth,
+		cssClasses: "markdown-node-label",
+		style: u.labelStyle,
+		addSvgBackground: !!u.icon || !!u.img
+	}), C = S.getBBox(), w = (u?.padding ?? 0) / 2;
+	if (g) {
+		let l = S.children[0], u = select_default(S), f = l.getElementsByTagName("img");
+		if (f) {
+			let l = x.replace(/<img[^>]*>/g, "").trim() === "";
+			await Promise.all([...f].map((u) => new Promise((f) => {
+				function p() {
+					if (u.style.display = "flex", u.style.flexDirection = "column", l) {
+						let [e = defaultConfig_default.fontSize] = parseFontSize(getConfig2().fontSize ? getConfig2().fontSize : window.getComputedStyle(document.body).fontSize), l = e * 5 + "px";
+						u.style.minWidth = l, u.style.maxWidth = l;
+					} else u.style.width = "100%";
+					f(u);
+				}
+				__name(p, "setupImage"), setTimeout(() => {
+					u.complete && p();
+				}), u.addEventListener("error", p), u.addEventListener("load", p);
+			})));
+		}
+		C = l.getBoundingClientRect(), u.attr("width", C.width), u.attr("height", C.height);
+	}
+	return g ? y.attr("transform", "translate(" + -C.width / 2 + ", " + -C.height / 2 + ")") : y.attr("transform", "translate(0, " + -C.height / 2 + ")"), u.centerLabel && y.attr("transform", "translate(" + -C.width / 2 + ", " + -C.height / 2 + ")"), y.insert("rect", ":first-child"), {
+		shapeSvg: _,
+		bbox: C,
+		halfPadding: w,
+		label: y
+	};
+}, "labelHelper"), insertLabel = /* @__PURE__ */ __name(async (e, l, u) => {
+	let d = u.useHtmlLabels || evaluate(getConfig2()?.flowchart?.htmlLabels), p = e.insert("g").attr("class", "label").attr("style", u.labelStyle || ""), h = await createText(p, sanitizeText(decodeEntities(l), getConfig2()), {
+		useHtmlLabels: d,
+		width: u.width || getConfig2()?.flowchart?.wrappingWidth,
+		style: u.labelStyle,
+		addSvgBackground: !!u.icon || !!u.img
+	}), g = h.getBBox(), _ = u.padding / 2;
+	if (evaluate(getConfig2()?.flowchart?.htmlLabels)) {
+		let e = h.children[0], l = select_default(h);
+		g = e.getBoundingClientRect(), l.attr("width", g.width), l.attr("height", g.height);
+	}
+	return d ? p.attr("transform", "translate(" + -g.width / 2 + ", " + -g.height / 2 + ")") : p.attr("transform", "translate(0, " + -g.height / 2 + ")"), u.centerLabel && p.attr("transform", "translate(" + -g.width / 2 + ", " + -g.height / 2 + ")"), p.insert("rect", ":first-child"), {
+		shapeSvg: e,
+		bbox: g,
+		halfPadding: _,
+		label: p
+	};
+}, "insertLabel"), updateNodeBounds = /* @__PURE__ */ __name((e, l) => {
+	let u = l.node().getBBox();
+	e.width = u.width, e.height = u.height;
+}, "updateNodeBounds"), getNodeClasses = /* @__PURE__ */ __name((e, l) => (e.look === "handDrawn" ? "rough-node" : "node") + " " + e.cssClasses + " " + (l || ""), "getNodeClasses");
+function createPathFromPoints(e) {
+	let l = e.map((e, l) => `${l === 0 ? "M" : "L"}${e.x},${e.y}`);
+	return l.push("Z"), l.join(" ");
+}
+__name(createPathFromPoints, "createPathFromPoints");
+function generateFullSineWavePoints(e, l, u, d, f, p) {
+	let m = [], h = u - e, g = d - l, _ = h / p, v = 2 * Math.PI / _, y = l + g / 2;
+	for (let l = 0; l <= 50; l++) {
+		let u = e + l / 50 * h, d = y + f * Math.sin(v * (u - e));
+		m.push({
+			x: u,
+			y: d
+		});
+	}
+	return m;
+}
+__name(generateFullSineWavePoints, "generateFullSineWavePoints");
+function generateCirclePoints(e, l, u, d, f, p) {
+	let m = [], h = f * Math.PI / 180, g = (p * Math.PI / 180 - h) / (d - 1);
+	for (let f = 0; f < d; f++) {
+		let d = h + f * g, p = e + u * Math.cos(d), _ = l + u * Math.sin(d);
+		m.push({
+			x: -p,
+			y: -_
+		});
+	}
+	return m;
+}
+__name(generateCirclePoints, "generateCirclePoints");
+var intersect_rect_default = /* @__PURE__ */ __name((e, l) => {
+	var u = e.x, d = e.y, f = l.x - u, p = l.y - d, m = e.width / 2, h = e.height / 2, g, _;
+	return Math.abs(p) * m > Math.abs(f) * h ? (p < 0 && (h = -h), g = p === 0 ? 0 : h * f / p, _ = h) : (f < 0 && (m = -m), g = m, _ = f === 0 ? 0 : m * p / f), {
+		x: u + g,
+		y: d + _
+	};
+}, "intersectRect");
+function applyStyle(e, l) {
+	l && e.attr("style", l);
+}
+__name(applyStyle, "applyStyle");
+async function addHtmlLabel(e) {
+	let l = select_default(document.createElementNS("http://www.w3.org/2000/svg", "foreignObject")), d = l.append("xhtml:div"), f = getConfig2(), p = e.label;
+	e.label && hasKatex(e.label) && (p = await renderKatexSanitized(e.label.replace(common_default.lineBreakRegex, "\n"), f));
+	let g = "<span class=\"" + (e.isNode ? "nodeLabel" : "edgeLabel") + "\" " + (e.labelStyle ? "style=\"" + e.labelStyle + "\"" : "") + ">" + p + "</span>";
+	return d.html(sanitizeText(g, f)), applyStyle(d, e.labelStyle), d.style("display", "inline-block"), d.style("padding-right", "1px"), d.style("white-space", "nowrap"), d.attr("xmlns", "http://www.w3.org/1999/xhtml"), l.node();
+}
+__name(addHtmlLabel, "addHtmlLabel");
+var createLabel_default = /* @__PURE__ */ __name(async (e, u, d, p) => {
+	let h = e || "";
+	if (typeof h == "object" && (h = h[0]), evaluate(getConfig2().flowchart.htmlLabels)) return h = h.replace(/\\n|\n/g, "<br />"), log.info("vertexText" + h), await addHtmlLabel({
+		isNode: p,
+		label: decodeEntities(h).replace(/fa[blrs]?:fa-[\w-]+/g, (e) => `<i class='${e.replace(":", " ")}'></i>`),
+		labelStyle: u && u.replace("fill:", "color:")
+	});
+	{
+		let e = document.createElementNS("http://www.w3.org/2000/svg", "text");
+		e.setAttribute("style", u.replace("color:", "fill:"));
+		let l = [];
+		l = typeof h == "string" ? h.split(/\\n|\n|<br\s*\/?>/gi) : Array.isArray(h) ? h : [];
+		for (let u of l) {
+			let l = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+			l.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve"), l.setAttribute("dy", "1em"), l.setAttribute("x", "0"), d ? l.setAttribute("class", "title-row") : l.setAttribute("class", "row"), l.textContent = u.trim(), e.appendChild(l);
+		}
+		return e;
+	}
+}, "createLabel"), createRoundedRectPathD = /* @__PURE__ */ __name((e, l, u, d, f) => [
+	"M",
+	e + f,
+	l,
+	"H",
+	e + u - f,
+	"A",
+	f,
+	f,
+	0,
+	0,
+	1,
+	e + u,
+	l + f,
+	"V",
+	l + d - f,
+	"A",
+	f,
+	f,
+	0,
+	0,
+	1,
+	e + u - f,
+	l + d,
+	"H",
+	e + f,
+	"A",
+	f,
+	f,
+	0,
+	0,
+	1,
+	e,
+	l + d - f,
+	"V",
+	l + f,
+	"A",
+	f,
+	f,
+	0,
+	0,
+	1,
+	e + f,
+	l,
+	"Z"
+].join(" "), "createRoundedRectPathD"), rect = /* @__PURE__ */ __name(async (e, u) => {
+	log.info("Creating subgraph rect for ", u.id, u);
+	let d = getConfig2(), { themeVariables: p, handDrawnSeed: h } = d, { clusterBkg: g, clusterBorder: _ } = p, { labelStyles: v, nodeStyles: y, borderStyles: S, backgroundStyles: C } = styles2String(u), E = e.insert("g").attr("class", "cluster " + u.cssClasses).attr("id", u.id).attr("data-look", u.look), D = evaluate(d.flowchart.htmlLabels), O = E.insert("g").attr("class", "cluster-label "), k = await createText(O, u.label, {
+		style: u.labelStyle,
+		useHtmlLabels: D,
+		isNode: !0
+	}), j = k.getBBox();
+	if (evaluate(d.flowchart.htmlLabels)) {
+		let e = k.children[0], l = select_default(k);
+		j = e.getBoundingClientRect(), l.attr("width", j.width), l.attr("height", j.height);
+	}
+	let M = u.width <= j.width + u.padding ? j.width + u.padding : u.width;
+	u.width <= j.width + u.padding ? u.diff = (M - u.width) / 2 - u.padding : u.diff = -u.padding;
+	let N = u.height, P = u.x - M / 2, F = u.y - N / 2;
+	log.trace("Data ", u, JSON.stringify(u));
+	let I;
+	if (u.look === "handDrawn") {
+		let e = at.svg(E), d = userNodeOverrides(u, {
+			roughness: .7,
+			fill: g,
+			stroke: _,
+			fillWeight: 3,
+			seed: h
+		}), f = e.path(createRoundedRectPathD(P, F, M, N, 0), d);
+		I = E.insert(() => (log.debug("Rough node insert CXC", f), f), ":first-child"), I.select("path:nth-child(2)").attr("style", S.join(";")), I.select("path").attr("style", C.join(";").replace("fill", "stroke"));
+	} else I = E.insert("rect", ":first-child"), I.attr("style", y).attr("rx", u.rx).attr("ry", u.ry).attr("x", P).attr("y", F).attr("width", M).attr("height", N);
+	let { subGraphTitleTopMargin: L } = getSubGraphTitleMargins(d);
+	if (O.attr("transform", `translate(${u.x - j.width / 2}, ${u.y - u.height / 2 + L})`), v) {
+		let e = O.select("span");
+		e && e.attr("style", v);
+	}
+	let R = I.node().getBBox();
+	return u.offsetX = 0, u.width = R.width, u.height = R.height, u.offsetY = j.height - u.padding / 2, u.intersect = function(e) {
+		return intersect_rect_default(u, e);
+	}, {
+		cluster: E,
+		labelBBox: j
+	};
+}, "rect"), shapes = {
+	rect,
+	squareRect: rect,
+	roundedWithTitle: /* @__PURE__ */ __name(async (e, l) => {
+		let u = getConfig2(), { themeVariables: d, handDrawnSeed: p } = u, { altBackground: h, compositeBackground: g, compositeTitleBackground: _, nodeBorder: v } = d, y = e.insert("g").attr("class", l.cssClasses).attr("id", l.id).attr("data-id", l.id).attr("data-look", l.look), x = y.insert("g", ":first-child"), S = y.insert("g").attr("class", "cluster-label"), C = y.append("rect"), w = S.node().appendChild(await createLabel_default(l.label, l.labelStyle, void 0, !0)), T = w.getBBox();
+		if (evaluate(u.flowchart.htmlLabels)) {
+			let e = w.children[0], l = select_default(w);
+			T = e.getBoundingClientRect(), l.attr("width", T.width), l.attr("height", T.height);
+		}
+		let E = 0 * l.padding, D = E / 2, O = (l.width <= T.width + l.padding ? T.width + l.padding : l.width) + E;
+		l.width <= T.width + l.padding ? l.diff = (O - l.width) / 2 - l.padding : l.diff = -l.padding;
+		let k = l.height + E, A = l.height + E - T.height - 6, j = l.x - O / 2, M = l.y - k / 2;
+		l.width = O;
+		let N = l.y - l.height / 2 - D + T.height + 2, P;
+		if (l.look === "handDrawn") {
+			let e = l.cssClasses.includes("statediagram-cluster-alt"), u = at.svg(y), d = l.rx || l.ry ? u.path(createRoundedRectPathD(j, M, O, k, 10), {
+				roughness: .7,
+				fill: _,
+				fillStyle: "solid",
+				stroke: v,
+				seed: p
+			}) : u.rectangle(j, M, O, k, { seed: p });
+			P = y.insert(() => d, ":first-child");
+			let f = u.rectangle(j, N, O, A, {
+				fill: e ? h : g,
+				fillStyle: e ? "hachure" : "solid",
+				stroke: v,
+				seed: p
+			});
+			P = y.insert(() => d, ":first-child"), C = y.insert(() => f);
+		} else P = x.insert("rect", ":first-child"), P.attr("class", "outer").attr("x", j).attr("y", M).attr("width", O).attr("height", k).attr("data-look", l.look), C.attr("class", "inner").attr("x", j).attr("y", N).attr("width", O).attr("height", A);
+		return S.attr("transform", `translate(${l.x - T.width / 2}, ${M + 1 - (evaluate(u.flowchart.htmlLabels) ? 0 : 3)})`), l.height = P.node().getBBox().height, l.offsetX = 0, l.offsetY = T.height - l.padding / 2, l.labelBBox = T, l.intersect = function(e) {
+			return intersect_rect_default(l, e);
+		}, {
+			cluster: y,
+			labelBBox: T
+		};
+	}, "roundedWithTitle"),
+	noteGroup: /* @__PURE__ */ __name((e, l) => {
+		let u = e.insert("g").attr("class", "note-cluster").attr("id", l.id), d = u.insert("rect", ":first-child"), f = 0 * l.padding, p = f / 2;
+		d.attr("rx", l.rx).attr("ry", l.ry).attr("x", l.x - l.width / 2 - p).attr("y", l.y - l.height / 2 - p).attr("width", l.width + f).attr("height", l.height + f).attr("fill", "none");
+		let m = d.node().getBBox();
+		return l.width = m.width, l.height = m.height, l.intersect = function(e) {
+			return intersect_rect_default(l, e);
+		}, {
+			cluster: u,
+			labelBBox: {
+				width: 0,
+				height: 0
+			}
+		};
+	}, "noteGroup"),
+	divider: /* @__PURE__ */ __name((e, l) => {
+		let { themeVariables: u, handDrawnSeed: d } = getConfig2(), { nodeBorder: f } = u, p = e.insert("g").attr("class", l.cssClasses).attr("id", l.id).attr("data-look", l.look), h = p.insert("g", ":first-child"), g = 0 * l.padding, _ = l.width + g;
+		l.diff = -l.padding;
+		let v = l.height + g, y = l.x - _ / 2, b = l.y - v / 2;
+		l.width = _;
+		let x;
+		if (l.look === "handDrawn") {
+			let e = at.svg(p).rectangle(y, b, _, v, {
+				fill: "lightgrey",
+				roughness: .5,
+				strokeLineDash: [5],
+				stroke: f,
+				seed: d
+			});
+			x = p.insert(() => e, ":first-child");
+		} else x = h.insert("rect", ":first-child"), x.attr("class", "divider").attr("x", y).attr("y", b).attr("width", _).attr("height", v).attr("data-look", l.look);
+		return l.height = x.node().getBBox().height, l.offsetX = 0, l.offsetY = 0, l.intersect = function(e) {
+			return intersect_rect_default(l, e);
+		}, {
+			cluster: p,
+			labelBBox: {}
+		};
+	}, "divider"),
+	kanbanSection: /* @__PURE__ */ __name(async (e, u) => {
+		log.info("Creating subgraph rect for ", u.id, u);
+		let d = getConfig2(), { themeVariables: p, handDrawnSeed: h } = d, { clusterBkg: g, clusterBorder: _ } = p, { labelStyles: v, nodeStyles: y, borderStyles: S, backgroundStyles: C } = styles2String(u), E = e.insert("g").attr("class", "cluster " + u.cssClasses).attr("id", u.id).attr("data-look", u.look), D = evaluate(d.flowchart.htmlLabels), O = E.insert("g").attr("class", "cluster-label "), k = await createText(O, u.label, {
+			style: u.labelStyle,
+			useHtmlLabels: D,
+			isNode: !0,
+			width: u.width
+		}), j = k.getBBox();
+		if (evaluate(d.flowchart.htmlLabels)) {
+			let e = k.children[0], l = select_default(k);
+			j = e.getBoundingClientRect(), l.attr("width", j.width), l.attr("height", j.height);
+		}
+		let M = u.width <= j.width + u.padding ? j.width + u.padding : u.width;
+		u.width <= j.width + u.padding ? u.diff = (M - u.width) / 2 - u.padding : u.diff = -u.padding;
+		let N = u.height, P = u.x - M / 2, F = u.y - N / 2;
+		log.trace("Data ", u, JSON.stringify(u));
+		let I;
+		if (u.look === "handDrawn") {
+			let e = at.svg(E), d = userNodeOverrides(u, {
+				roughness: .7,
+				fill: g,
+				stroke: _,
+				fillWeight: 4,
+				seed: h
+			}), f = e.path(createRoundedRectPathD(P, F, M, N, u.rx), d);
+			I = E.insert(() => (log.debug("Rough node insert CXC", f), f), ":first-child"), I.select("path:nth-child(2)").attr("style", S.join(";")), I.select("path").attr("style", C.join(";").replace("fill", "stroke"));
+		} else I = E.insert("rect", ":first-child"), I.attr("style", y).attr("rx", u.rx).attr("ry", u.ry).attr("x", P).attr("y", F).attr("width", M).attr("height", N);
+		let { subGraphTitleTopMargin: L } = getSubGraphTitleMargins(d);
+		if (O.attr("transform", `translate(${u.x - j.width / 2}, ${u.y - u.height / 2 + L})`), v) {
+			let e = O.select("span");
+			e && e.attr("style", v);
+		}
+		let R = I.node().getBBox();
+		return u.offsetX = 0, u.width = R.width, u.height = R.height, u.offsetY = j.height - u.padding / 2, u.intersect = function(e) {
+			return intersect_rect_default(u, e);
+		}, {
+			cluster: E,
+			labelBBox: j
+		};
+	}, "kanbanSection")
+}, clusterElems = /* @__PURE__ */ new Map(), insertCluster = /* @__PURE__ */ __name(async (e, l) => {
+	let u = await shapes[l.shape || "rect"](e, l);
+	return clusterElems.set(l.id, u), u;
+}, "insertCluster"), clear = /* @__PURE__ */ __name(() => {
+	clusterElems = /* @__PURE__ */ new Map();
+}, "clear");
+function intersectNode(e, l) {
+	return e.intersect(l);
+}
+__name(intersectNode, "intersectNode");
+var intersect_node_default = intersectNode;
+function intersectEllipse(e, l, u, d) {
+	var f = e.x, p = e.y, m = f - d.x, h = p - d.y, g = Math.sqrt(l * l * h * h + u * u * m * m), _ = Math.abs(l * u * m / g);
+	d.x < f && (_ = -_);
+	var v = Math.abs(l * u * h / g);
+	return d.y < p && (v = -v), {
+		x: f + _,
+		y: p + v
+	};
+}
+__name(intersectEllipse, "intersectEllipse");
+var intersect_ellipse_default = intersectEllipse;
+function intersectCircle(e, l, u) {
+	return intersect_ellipse_default(e, l, l, u);
+}
+__name(intersectCircle, "intersectCircle");
+var intersect_circle_default = intersectCircle;
+function intersectLine(e, l, u, d) {
+	{
+		let f = l.y - e.y, p = e.x - l.x, m = l.x * e.y - e.x * l.y, h = f * u.x + p * u.y + m, g = f * d.x + p * d.y + m, _ = 1e-6;
+		if (h !== 0 && g !== 0 && sameSign(h, g)) return;
+		let v = d.y - u.y, y = u.x - d.x, b = d.x * u.y - u.x * d.y, x = v * e.x + y * e.y + b, S = v * l.x + y * l.y + b;
+		if (Math.abs(x) < _ && Math.abs(S) < _ && sameSign(x, S)) return;
+		let C = f * y - v * p;
+		if (C === 0) return;
+		let w = Math.abs(C / 2), T = p * b - y * m, E = T < 0 ? (T - w) / C : (T + w) / C;
+		return T = v * m - f * b, {
+			x: E,
+			y: T < 0 ? (T - w) / C : (T + w) / C
+		};
+	}
+}
+__name(intersectLine, "intersectLine");
+function sameSign(e, l) {
+	return e * l > 0;
+}
+__name(sameSign, "sameSign");
+var intersect_line_default = intersectLine;
+function intersectPolygon(e, l, u) {
+	let d = e.x, f = e.y, p = [], m = Infinity, h = Infinity;
+	typeof l.forEach == "function" ? l.forEach(function(e) {
+		m = Math.min(m, e.x), h = Math.min(h, e.y);
+	}) : (m = Math.min(m, l.x), h = Math.min(h, l.y));
+	let g = d - e.width / 2 - m, _ = f - e.height / 2 - h;
+	for (let d = 0; d < l.length; d++) {
+		let f = l[d], m = l[d < l.length - 1 ? d + 1 : 0], h = intersect_line_default(e, u, {
+			x: g + f.x,
+			y: _ + f.y
+		}, {
+			x: g + m.x,
+			y: _ + m.y
+		});
+		h && p.push(h);
+	}
+	return p.length ? (p.length > 1 && p.sort(function(e, l) {
+		let d = e.x - u.x, f = e.y - u.y, p = Math.sqrt(d * d + f * f), m = l.x - u.x, h = l.y - u.y, g = Math.sqrt(m * m + h * h);
+		return p < g ? -1 : p === g ? 0 : 1;
+	}), p[0]) : e;
+}
+__name(intersectPolygon, "intersectPolygon");
+var intersect_default = {
+	node: intersect_node_default,
+	circle: intersect_circle_default,
+	ellipse: intersect_ellipse_default,
+	polygon: intersectPolygon,
+	rect: intersect_rect_default
+};
+function anchor(e, u) {
+	let { labelStyles: d } = styles2String(u);
+	u.labelStyle = d;
+	let f = getNodeClasses(u), p = f;
+	f || (p = "anchor");
+	let m = e.insert("g").attr("class", p).attr("id", u.domId || u.id), { cssStyles: h } = u, g = at.svg(m), _ = userNodeOverrides(u, {
+		fill: "black",
+		stroke: "none",
+		fillStyle: "solid"
+	});
+	u.look !== "handDrawn" && (_.roughness = 0);
+	let v = g.circle(0, 0, 2, _), y = m.insert(() => v, ":first-child");
+	return y.attr("class", "anchor").attr("style", handleUndefinedAttr(h)), updateNodeBounds(u, y), u.intersect = function(e) {
+		return log.info("Circle intersect", u, 1, e), intersect_default.circle(u, 1, e);
+	}, m;
+}
+__name(anchor, "anchor");
+function generateArcPoints(e, l, u, d, f, p, m) {
+	let h = (e + u) / 2, g = (l + d) / 2, _ = Math.atan2(d - l, u - e), v = (u - e) / 2, y = (d - l) / 2, b = v / f, x = y / p, S = Math.sqrt(b ** 2 + x ** 2);
+	if (S > 1) throw Error("The given radii are too small to create an arc between the points.");
+	let C = Math.sqrt(1 - S ** 2), w = h + C * p * Math.sin(_) * (m ? -1 : 1), T = g - C * f * Math.cos(_) * (m ? -1 : 1), E = Math.atan2((l - T) / p, (e - w) / f), D = Math.atan2((d - T) / p, (u - w) / f) - E;
+	m && D < 0 && (D += 2 * Math.PI), !m && D > 0 && (D -= 2 * Math.PI);
+	let O = [];
+	for (let e = 0; e < 20; e++) {
+		let l = E + e / 19 * D, u = w + f * Math.cos(l), d = T + p * Math.sin(l);
+		O.push({
+			x: u,
+			y: d
+		});
+	}
+	return O;
+}
+__name(generateArcPoints, "generateArcPoints");
+async function bowTieRect(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = p.width + l.padding + 20, h = p.height + l.padding, g = h / 2, _ = g / (2.5 + h / 50), { cssStyles: v } = l, y = [
+		{
+			x: m / 2,
+			y: -h / 2
+		},
+		{
+			x: -m / 2,
+			y: -h / 2
+		},
+		...generateArcPoints(-m / 2, -h / 2, -m / 2, h / 2, _, g, !1),
+		{
+			x: m / 2,
+			y: h / 2
+		},
+		...generateArcPoints(m / 2, h / 2, m / 2, -h / 2, _, g, !0)
+	], b = at.svg(f), x = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let S = createPathFromPoints(y), C = b.path(S, x), E = f.insert(() => C, ":first-child");
+	return E.attr("class", "basic label-container"), v && l.look !== "handDrawn" && E.selectAll("path").attr("style", v), d && l.look !== "handDrawn" && E.selectAll("path").attr("style", d), E.attr("transform", `translate(${_ / 2}, 0)`), updateNodeBounds(l, E), l.intersect = function(e) {
+		return intersect_default.polygon(l, y, e);
+	}, f;
+}
+__name(bowTieRect, "bowTieRect");
+function insertPolygonShape(e, l, u, d) {
+	return e.insert("polygon", ":first-child").attr("points", d.map(function(e) {
+		return e.x + "," + e.y;
+	}).join(" ")).attr("class", "label-container").attr("transform", "translate(" + -l / 2 + "," + u / 2 + ")");
+}
+__name(insertPolygonShape, "insertPolygonShape");
+async function card(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = p.height + l.padding, h = p.width + l.padding + 12, g = h, _ = -m, v = [
+		{
+			x: 12,
+			y: _
+		},
+		{
+			x: g,
+			y: _
+		},
+		{
+			x: g,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: 0,
+			y: _ + 12
+		},
+		{
+			x: 12,
+			y: _
+		}
+	], y, { cssStyles: b } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = createPathFromPoints(v), p = e.path(d, u);
+		y = f.insert(() => p, ":first-child").attr("transform", `translate(${-h / 2}, ${m / 2})`), b && y.attr("style", b);
+	} else y = insertPolygonShape(f, h, m, v);
+	return d && y.attr("style", d), updateNodeBounds(l, y), l.intersect = function(e) {
+		return intersect_default.polygon(l, v, e);
+	}, f;
+}
+__name(card, "card");
+function choice(e, l) {
+	let { nodeStyles: u } = styles2String(l);
+	l.label = "";
+	let d = e.insert("g").attr("class", getNodeClasses(l)).attr("id", l.domId ?? l.id), { cssStyles: f } = l, p = Math.max(28, l.width ?? 0), m = [
+		{
+			x: 0,
+			y: p / 2
+		},
+		{
+			x: p / 2,
+			y: 0
+		},
+		{
+			x: 0,
+			y: -p / 2
+		},
+		{
+			x: -p / 2,
+			y: 0
+		}
+	], h = at.svg(d), g = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (g.roughness = 0, g.fillStyle = "solid");
+	let _ = createPathFromPoints(m), v = h.path(_, g), y = d.insert(() => v, ":first-child");
+	return f && l.look !== "handDrawn" && y.selectAll("path").attr("style", f), u && l.look !== "handDrawn" && y.selectAll("path").attr("style", u), l.width = 28, l.height = 28, l.intersect = function(e) {
+		return intersect_default.polygon(l, m, e);
+	}, d;
+}
+__name(choice, "choice");
+async function circle(e, u, d) {
+	let { labelStyles: f, nodeStyles: p } = styles2String(u);
+	u.labelStyle = f;
+	let { shapeSvg: m, bbox: h, halfPadding: g } = await labelHelper(e, u, getNodeClasses(u)), _ = d?.padding ?? g, v = h.width / 2 + _, y, { cssStyles: b } = u;
+	if (u.look === "handDrawn") {
+		let e = at.svg(m), l = userNodeOverrides(u, {}), d = e.circle(0, 0, v * 2, l);
+		y = m.insert(() => d, ":first-child"), y.attr("class", "basic label-container").attr("style", handleUndefinedAttr(b));
+	} else y = m.insert("circle", ":first-child").attr("class", "basic label-container").attr("style", p).attr("r", v).attr("cx", 0).attr("cy", 0);
+	return updateNodeBounds(u, y), u.calcIntersect = function(e, l) {
+		let u = e.width / 2;
+		return intersect_default.circle(e, u, l);
+	}, u.intersect = function(e) {
+		return log.info("Circle intersect", u, v, e), intersect_default.circle(u, v, e);
+	}, m;
+}
+__name(circle, "circle");
+function createLine(e) {
+	let l = Math.cos(Math.PI / 4), u = Math.sin(Math.PI / 4), d = e * 2, f = {
+		x: d / 2 * l,
+		y: d / 2 * u
+	}, p = {
+		x: -(d / 2) * l,
+		y: d / 2 * u
+	}, m = {
+		x: -(d / 2) * l,
+		y: -(d / 2) * u
+	}, h = {
+		x: d / 2 * l,
+		y: -(d / 2) * u
+	};
+	return `M ${p.x},${p.y} L ${h.x},${h.y}
+                   M ${f.x},${f.y} L ${m.x},${m.y}`;
+}
+__name(createLine, "createLine");
+function crossedCircle(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.labelStyle = d, u.label = "";
+	let p = e.insert("g").attr("class", getNodeClasses(u)).attr("id", u.domId ?? u.id), m = Math.max(30, u?.width ?? 0), { cssStyles: h } = u, g = at.svg(p), _ = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (_.roughness = 0, _.fillStyle = "solid");
+	let v = g.circle(0, 0, m * 2, _), y = createLine(m), b = g.path(y, _), x = p.insert(() => v, ":first-child");
+	return x.insert(() => b), h && u.look !== "handDrawn" && x.selectAll("path").attr("style", h), f && u.look !== "handDrawn" && x.selectAll("path").attr("style", f), updateNodeBounds(u, x), u.intersect = function(e) {
+		return log.info("crossedCircle intersect", u, {
+			radius: m,
+			point: e
+		}), intersect_default.circle(u, m, e);
+	}, p;
+}
+__name(crossedCircle, "crossedCircle");
+function generateCirclePoints2(e, l, u, d = 100, f = 0, p = 180) {
+	let m = [], h = f * Math.PI / 180, g = (p * Math.PI / 180 - h) / (d - 1);
+	for (let f = 0; f < d; f++) {
+		let d = h + f * g, p = e + u * Math.cos(d), _ = l + u * Math.sin(d);
+		m.push({
+			x: -p,
+			y: -_
+		});
+	}
+	return m;
+}
+__name(generateCirclePoints2, "generateCirclePoints");
+async function curlyBraceLeft(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = p.width + (l.padding ?? 0), g = p.height + (l.padding ?? 0), _ = Math.max(5, g * .1), { cssStyles: v } = l, y = [
+		...generateCirclePoints2(h / 2, -g / 2, _, 30, -90, 0),
+		{
+			x: -h / 2 - _,
+			y: _
+		},
+		...generateCirclePoints2(h / 2 + _ * 2, -_, _, 20, -180, -270),
+		...generateCirclePoints2(h / 2 + _ * 2, _, _, 20, -90, -180),
+		{
+			x: -h / 2 - _,
+			y: -g / 2
+		},
+		...generateCirclePoints2(h / 2, g / 2, _, 20, 0, 90)
+	], b = [
+		{
+			x: h / 2,
+			y: -g / 2 - _
+		},
+		{
+			x: -h / 2,
+			y: -g / 2 - _
+		},
+		...generateCirclePoints2(h / 2, -g / 2, _, 20, -90, 0),
+		{
+			x: -h / 2 - _,
+			y: -_
+		},
+		...generateCirclePoints2(h / 2 + h * .1, -_, _, 20, -180, -270),
+		...generateCirclePoints2(h / 2 + h * .1, _, _, 20, -90, -180),
+		{
+			x: -h / 2 - _,
+			y: g / 2
+		},
+		...generateCirclePoints2(h / 2, g / 2, _, 20, 0, 90),
+		{
+			x: -h / 2,
+			y: g / 2 + _
+		},
+		{
+			x: h / 2,
+			y: g / 2 + _
+		}
+	], x = at.svg(f), S = userNodeOverrides(l, { fill: "none" });
+	l.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let C = createPathFromPoints(y).replace("Z", ""), E = x.path(C, S), D = createPathFromPoints(b), O = x.path(D, { ...S }), k = f.insert("g", ":first-child");
+	return k.insert(() => O, ":first-child").attr("stroke-opacity", 0), k.insert(() => E, ":first-child"), k.attr("class", "text"), v && l.look !== "handDrawn" && k.selectAll("path").attr("style", v), d && l.look !== "handDrawn" && k.selectAll("path").attr("style", d), k.attr("transform", `translate(${_}, 0)`), m.attr("transform", `translate(${-h / 2 + _ - (p.x - (p.left ?? 0))},${-g / 2 + (l.padding ?? 0) / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, k), l.intersect = function(e) {
+		return intersect_default.polygon(l, b, e);
+	}, f;
+}
+__name(curlyBraceLeft, "curlyBraceLeft");
+function generateCirclePoints3(e, l, u, d = 100, f = 0, p = 180) {
+	let m = [], h = f * Math.PI / 180, g = (p * Math.PI / 180 - h) / (d - 1);
+	for (let f = 0; f < d; f++) {
+		let d = h + f * g, p = e + u * Math.cos(d), _ = l + u * Math.sin(d);
+		m.push({
+			x: p,
+			y: _
+		});
+	}
+	return m;
+}
+__name(generateCirclePoints3, "generateCirclePoints");
+async function curlyBraceRight(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = p.width + (l.padding ?? 0), g = p.height + (l.padding ?? 0), _ = Math.max(5, g * .1), { cssStyles: v } = l, y = [
+		...generateCirclePoints3(h / 2, -g / 2, _, 20, -90, 0),
+		{
+			x: h / 2 + _,
+			y: -_
+		},
+		...generateCirclePoints3(h / 2 + _ * 2, -_, _, 20, -180, -270),
+		...generateCirclePoints3(h / 2 + _ * 2, _, _, 20, -90, -180),
+		{
+			x: h / 2 + _,
+			y: g / 2
+		},
+		...generateCirclePoints3(h / 2, g / 2, _, 20, 0, 90)
+	], b = [
+		{
+			x: -h / 2,
+			y: -g / 2 - _
+		},
+		{
+			x: h / 2,
+			y: -g / 2 - _
+		},
+		...generateCirclePoints3(h / 2, -g / 2, _, 20, -90, 0),
+		{
+			x: h / 2 + _,
+			y: -_
+		},
+		...generateCirclePoints3(h / 2 + _ * 2, -_, _, 20, -180, -270),
+		...generateCirclePoints3(h / 2 + _ * 2, _, _, 20, -90, -180),
+		{
+			x: h / 2 + _,
+			y: g / 2
+		},
+		...generateCirclePoints3(h / 2, g / 2, _, 20, 0, 90),
+		{
+			x: h / 2,
+			y: g / 2 + _
+		},
+		{
+			x: -h / 2,
+			y: g / 2 + _
+		}
+	], x = at.svg(f), S = userNodeOverrides(l, { fill: "none" });
+	l.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let C = createPathFromPoints(y).replace("Z", ""), E = x.path(C, S), D = createPathFromPoints(b), O = x.path(D, { ...S }), k = f.insert("g", ":first-child");
+	return k.insert(() => O, ":first-child").attr("stroke-opacity", 0), k.insert(() => E, ":first-child"), k.attr("class", "text"), v && l.look !== "handDrawn" && k.selectAll("path").attr("style", v), d && l.look !== "handDrawn" && k.selectAll("path").attr("style", d), k.attr("transform", `translate(${-_}, 0)`), m.attr("transform", `translate(${-h / 2 + (l.padding ?? 0) / 2 - (p.x - (p.left ?? 0))},${-g / 2 + (l.padding ?? 0) / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, k), l.intersect = function(e) {
+		return intersect_default.polygon(l, b, e);
+	}, f;
+}
+__name(curlyBraceRight, "curlyBraceRight");
+function generateCirclePoints4(e, l, u, d = 100, f = 0, p = 180) {
+	let m = [], h = f * Math.PI / 180, g = (p * Math.PI / 180 - h) / (d - 1);
+	for (let f = 0; f < d; f++) {
+		let d = h + f * g, p = e + u * Math.cos(d), _ = l + u * Math.sin(d);
+		m.push({
+			x: -p,
+			y: -_
+		});
+	}
+	return m;
+}
+__name(generateCirclePoints4, "generateCirclePoints");
+async function curlyBraces(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = p.width + (l.padding ?? 0), g = p.height + (l.padding ?? 0), _ = Math.max(5, g * .1), { cssStyles: v } = l, y = [
+		...generateCirclePoints4(h / 2, -g / 2, _, 30, -90, 0),
+		{
+			x: -h / 2 - _,
+			y: _
+		},
+		...generateCirclePoints4(h / 2 + _ * 2, -_, _, 20, -180, -270),
+		...generateCirclePoints4(h / 2 + _ * 2, _, _, 20, -90, -180),
+		{
+			x: -h / 2 - _,
+			y: -g / 2
+		},
+		...generateCirclePoints4(h / 2, g / 2, _, 20, 0, 90)
+	], b = [
+		...generateCirclePoints4(-h / 2 + _ + _ / 2, -g / 2, _, 20, -90, -180),
+		{
+			x: h / 2 - _ / 2,
+			y: _
+		},
+		...generateCirclePoints4(-h / 2 - _ / 2, -_, _, 20, 0, 90),
+		...generateCirclePoints4(-h / 2 - _ / 2, _, _, 20, -90, 0),
+		{
+			x: h / 2 - _ / 2,
+			y: -_
+		},
+		...generateCirclePoints4(-h / 2 + _ + _ / 2, g / 2, _, 30, -180, -270)
+	], x = [
+		{
+			x: h / 2,
+			y: -g / 2 - _
+		},
+		{
+			x: -h / 2,
+			y: -g / 2 - _
+		},
+		...generateCirclePoints4(h / 2, -g / 2, _, 20, -90, 0),
+		{
+			x: -h / 2 - _,
+			y: -_
+		},
+		...generateCirclePoints4(h / 2 + _ * 2, -_, _, 20, -180, -270),
+		...generateCirclePoints4(h / 2 + _ * 2, _, _, 20, -90, -180),
+		{
+			x: -h / 2 - _,
+			y: g / 2
+		},
+		...generateCirclePoints4(h / 2, g / 2, _, 20, 0, 90),
+		{
+			x: -h / 2,
+			y: g / 2 + _
+		},
+		{
+			x: h / 2 - _ - _ / 2,
+			y: g / 2 + _
+		},
+		...generateCirclePoints4(-h / 2 + _ + _ / 2, -g / 2, _, 20, -90, -180),
+		{
+			x: h / 2 - _ / 2,
+			y: _
+		},
+		...generateCirclePoints4(-h / 2 - _ / 2, -_, _, 20, 0, 90),
+		...generateCirclePoints4(-h / 2 - _ / 2, _, _, 20, -90, 0),
+		{
+			x: h / 2 - _ / 2,
+			y: -_
+		},
+		...generateCirclePoints4(-h / 2 + _ + _ / 2, g / 2, _, 30, -180, -270)
+	], S = at.svg(f), C = userNodeOverrides(l, { fill: "none" });
+	l.look !== "handDrawn" && (C.roughness = 0, C.fillStyle = "solid");
+	let E = createPathFromPoints(y).replace("Z", ""), D = S.path(E, C), O = createPathFromPoints(b).replace("Z", ""), k = S.path(O, C), A = createPathFromPoints(x), j = S.path(A, { ...C }), N = f.insert("g", ":first-child");
+	return N.insert(() => j, ":first-child").attr("stroke-opacity", 0), N.insert(() => D, ":first-child"), N.insert(() => k, ":first-child"), N.attr("class", "text"), v && l.look !== "handDrawn" && N.selectAll("path").attr("style", v), d && l.look !== "handDrawn" && N.selectAll("path").attr("style", d), N.attr("transform", `translate(${_ - _ / 4}, 0)`), m.attr("transform", `translate(${-h / 2 + (l.padding ?? 0) / 2 - (p.x - (p.left ?? 0))},${-g / 2 + (l.padding ?? 0) / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, N), l.intersect = function(e) {
+		return intersect_default.polygon(l, x, e);
+	}, f;
+}
+__name(curlyBraces, "curlyBraces");
+async function curvedTrapezoid(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(80, (p.width + (l.padding ?? 0) * 2) * 1.25, l?.width ?? 0), h = Math.max(20, p.height + (l.padding ?? 0) * 2, l?.height ?? 0), g = h / 2, { cssStyles: _ } = l, v = at.svg(f), y = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+	let b = m, x = h, S = b - g, C = x / 4, E = [
+		{
+			x: S,
+			y: 0
+		},
+		{
+			x: C,
+			y: 0
+		},
+		{
+			x: 0,
+			y: x / 2
+		},
+		{
+			x: C,
+			y: x
+		},
+		{
+			x: S,
+			y: x
+		},
+		...generateCirclePoints(-S, -x / 2, g, 50, 270, 90)
+	], D = createPathFromPoints(E), O = v.path(D, y), k = f.insert(() => O, ":first-child");
+	return k.attr("class", "basic label-container"), _ && l.look !== "handDrawn" && k.selectChildren("path").attr("style", _), d && l.look !== "handDrawn" && k.selectChildren("path").attr("style", d), k.attr("transform", `translate(${-m / 2}, ${-h / 2})`), updateNodeBounds(l, k), l.intersect = function(e) {
+		return intersect_default.polygon(l, E, e);
+	}, f;
+}
+__name(curvedTrapezoid, "curvedTrapezoid");
+var createCylinderPathD = /* @__PURE__ */ __name((e, l, u, d, f, p) => [
+	`M${e},${l + p}`,
+	`a${f},${p} 0,0,0 ${u},0`,
+	`a${f},${p} 0,0,0 ${-u},0`,
+	`l0,${d}`,
+	`a${f},${p} 0,0,0 ${u},0`,
+	`l0,${-d}`
+].join(" "), "createCylinderPathD"), createOuterCylinderPathD = /* @__PURE__ */ __name((e, l, u, d, f, p) => [
+	`M${e},${l + p}`,
+	`M${e + u},${l + p}`,
+	`a${f},${p} 0,0,0 ${-u},0`,
+	`l0,${d}`,
+	`a${f},${p} 0,0,0 ${u},0`,
+	`l0,${-d}`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD = /* @__PURE__ */ __name((e, l, u, d, f, p) => [`M${e - u / 2},${-d / 2}`, `a${f},${p} 0,0,0 ${u},0`].join(" "), "createInnerCylinderPathD");
+async function cylinder(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + l.padding, l.width ?? 0), g = h / 2, _ = g / (2.5 + h / 50), v = Math.max(p.height + _ + l.padding, l.height ?? 0), y, { cssStyles: b } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = createOuterCylinderPathD(0, 0, h, v, g, _), d = createInnerCylinderPathD(0, _, h, v, g, _), p = e.path(u, userNodeOverrides(l, {})), m = e.path(d, userNodeOverrides(l, { fill: "none" }));
+		y = f.insert(() => m, ":first-child"), y = f.insert(() => p, ":first-child"), y.attr("class", "basic label-container"), b && y.attr("style", b);
+	} else {
+		let e = createCylinderPathD(0, 0, h, v, g, _);
+		y = f.insert("path", ":first-child").attr("d", e).attr("class", "basic label-container").attr("style", handleUndefinedAttr(b)).attr("style", d);
+	}
+	return y.attr("label-offset-y", _), y.attr("transform", `translate(${-h / 2}, ${-(v / 2 + _)})`), updateNodeBounds(l, y), m.attr("transform", `translate(${-(p.width / 2) - (p.x - (p.left ?? 0))}, ${-(p.height / 2) + (l.padding ?? 0) / 1.5 - (p.y - (p.top ?? 0))})`), l.intersect = function(e) {
+		let u = intersect_default.rect(l, e), d = u.x - (l.x ?? 0);
+		if (g != 0 && (Math.abs(d) < (l.width ?? 0) / 2 || Math.abs(d) == (l.width ?? 0) / 2 && Math.abs(u.y - (l.y ?? 0)) > (l.height ?? 0) / 2 - _)) {
+			let f = _ * _ * (1 - d * d / (g * g));
+			f > 0 && (f = Math.sqrt(f)), f = _ - f, e.y - (l.y ?? 0) > 0 && (f = -f), u.y += f;
+		}
+		return u;
+	}, f;
+}
+__name(cylinder, "cylinder");
+async function dividedRectangle(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = p.width + l.padding, g = p.height + l.padding, _ = g * .2, v = -h / 2, y = -g / 2 - _ / 2, { cssStyles: b } = l, x = at.svg(f), S = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let C = [
+		{
+			x: v,
+			y: y + _
+		},
+		{
+			x: -v,
+			y: y + _
+		},
+		{
+			x: -v,
+			y: -y
+		},
+		{
+			x: v,
+			y: -y
+		},
+		{
+			x: v,
+			y
+		},
+		{
+			x: -v,
+			y
+		},
+		{
+			x: -v,
+			y: y + _
+		}
+	], E = x.polygon(C.map((e) => [e.x, e.y]), S), D = f.insert(() => E, ":first-child");
+	return D.attr("class", "basic label-container"), b && l.look !== "handDrawn" && D.selectAll("path").attr("style", b), d && l.look !== "handDrawn" && D.selectAll("path").attr("style", d), m.attr("transform", `translate(${v + (l.padding ?? 0) / 2 - (p.x - (p.left ?? 0))}, ${y + _ + (l.padding ?? 0) / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, D), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, f;
+}
+__name(dividedRectangle, "dividedRectangle");
+async function doublecircle(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.labelStyle = d;
+	let { shapeSvg: p, bbox: m, halfPadding: h } = await labelHelper(e, u, getNodeClasses(u)), g = m.width / 2 + h + 5, _ = m.width / 2 + h, v, { cssStyles: y } = u;
+	if (u.look === "handDrawn") {
+		let e = at.svg(p), l = userNodeOverrides(u, {
+			roughness: .2,
+			strokeWidth: 2.5
+		}), d = userNodeOverrides(u, {
+			roughness: .2,
+			strokeWidth: 1.5
+		}), f = e.circle(0, 0, g * 2, l), m = e.circle(0, 0, _ * 2, d);
+		v = p.insert("g", ":first-child"), v.attr("class", handleUndefinedAttr(u.cssClasses)).attr("style", handleUndefinedAttr(y)), v.node()?.appendChild(f), v.node()?.appendChild(m);
+	} else {
+		v = p.insert("g", ":first-child");
+		let e = v.insert("circle", ":first-child"), l = v.insert("circle");
+		v.attr("class", "basic label-container").attr("style", f), e.attr("class", "outer-circle").attr("style", f).attr("r", g).attr("cx", 0).attr("cy", 0), l.attr("class", "inner-circle").attr("style", f).attr("r", _).attr("cx", 0).attr("cy", 0);
+	}
+	return updateNodeBounds(u, v), u.intersect = function(e) {
+		return log.info("DoubleCircle intersect", u, g, e), intersect_default.circle(u, g, e);
+	}, p;
+}
+__name(doublecircle, "doublecircle");
+function filledCircle(e, u, { config: { themeVariables: d } }) {
+	let { labelStyles: f, nodeStyles: p } = styles2String(u);
+	u.label = "", u.labelStyle = f;
+	let m = e.insert("g").attr("class", getNodeClasses(u)).attr("id", u.domId ?? u.id), { cssStyles: h } = u, g = at.svg(m), { nodeBorder: _ } = d, v = userNodeOverrides(u, { fillStyle: "solid" });
+	u.look !== "handDrawn" && (v.roughness = 0);
+	let y = g.circle(0, 0, 14, v), b = m.insert(() => y, ":first-child");
+	return b.selectAll("path").attr("style", `fill: ${_} !important;`), h && h.length > 0 && u.look !== "handDrawn" && b.selectAll("path").attr("style", h), p && u.look !== "handDrawn" && b.selectAll("path").attr("style", p), updateNodeBounds(u, b), u.intersect = function(e) {
+		return log.info("filledCircle intersect", u, {
+			radius: 7,
+			point: e
+		}), intersect_default.circle(u, 7, e);
+	}, m;
+}
+__name(filledCircle, "filledCircle");
+async function flippedTriangle(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.labelStyle = d;
+	let { shapeSvg: p, bbox: m, label: h } = await labelHelper(e, u, getNodeClasses(u)), g = m.width + (u.padding ?? 0), _ = g + m.height, v = g + m.height, y = [
+		{
+			x: 0,
+			y: -_
+		},
+		{
+			x: v,
+			y: -_
+		},
+		{
+			x: v / 2,
+			y: 0
+		}
+	], { cssStyles: b } = u, x = at.svg(p), S = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let C = createPathFromPoints(y), E = x.path(C, S), D = p.insert(() => E, ":first-child").attr("transform", `translate(${-_ / 2}, ${_ / 2})`);
+	return b && u.look !== "handDrawn" && D.selectChildren("path").attr("style", b), f && u.look !== "handDrawn" && D.selectChildren("path").attr("style", f), u.width = g, u.height = _, updateNodeBounds(u, D), h.attr("transform", `translate(${-m.width / 2 - (m.x - (m.left ?? 0))}, ${-_ / 2 + (u.padding ?? 0) / 2 + (m.y - (m.top ?? 0))})`), u.intersect = function(e) {
+		return log.info("Triangle intersect", u, y, e), intersect_default.polygon(u, y, e);
+	}, p;
+}
+__name(flippedTriangle, "flippedTriangle");
+function forkJoin(e, l, { dir: u, config: { state: d, themeVariables: f } }) {
+	let { nodeStyles: p } = styles2String(l);
+	l.label = "";
+	let m = e.insert("g").attr("class", getNodeClasses(l)).attr("id", l.domId ?? l.id), { cssStyles: h } = l, g = Math.max(70, l?.width ?? 0), _ = Math.max(10, l?.height ?? 0);
+	u === "LR" && (g = Math.max(10, l?.width ?? 0), _ = Math.max(70, l?.height ?? 0));
+	let v = -1 * g / 2, y = -1 * _ / 2, b = at.svg(m), x = userNodeOverrides(l, {
+		stroke: f.lineColor,
+		fill: f.lineColor
+	});
+	l.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let S = b.rectangle(v, y, g, _, x), C = m.insert(() => S, ":first-child");
+	h && l.look !== "handDrawn" && C.selectAll("path").attr("style", h), p && l.look !== "handDrawn" && C.selectAll("path").attr("style", p), updateNodeBounds(l, C);
+	let E = d?.padding ?? 0;
+	return l.width && l.height && (l.width += E / 2 || 0, l.height += E / 2 || 0), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, m;
+}
+__name(forkJoin, "forkJoin");
+async function halfRoundedRectangle(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.labelStyle = d;
+	let { shapeSvg: p, bbox: m } = await labelHelper(e, u, getNodeClasses(u)), h = Math.max(80, m.width + (u.padding ?? 0) * 2, u?.width ?? 0), g = Math.max(50, m.height + (u.padding ?? 0) * 2, u?.height ?? 0), _ = g / 2, { cssStyles: v } = u, y = at.svg(p), b = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = [
+		{
+			x: -h / 2,
+			y: -g / 2
+		},
+		{
+			x: h / 2 - _,
+			y: -g / 2
+		},
+		...generateCirclePoints(-h / 2 + _, 0, _, 50, 90, 270),
+		{
+			x: h / 2 - _,
+			y: g / 2
+		},
+		{
+			x: -h / 2,
+			y: g / 2
+		}
+	], S = createPathFromPoints(x), C = y.path(S, b), E = p.insert(() => C, ":first-child");
+	return E.attr("class", "basic label-container"), v && u.look !== "handDrawn" && E.selectChildren("path").attr("style", v), f && u.look !== "handDrawn" && E.selectChildren("path").attr("style", f), updateNodeBounds(u, E), u.intersect = function(e) {
+		return log.info("Pill intersect", u, {
+			radius: _,
+			point: e
+		}), intersect_default.polygon(u, x, e);
+	}, p;
+}
+__name(halfRoundedRectangle, "halfRoundedRectangle");
+async function hexagon(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = p.height + (l.padding ?? 0), h = p.width + (l.padding ?? 0) * 2.5, { cssStyles: g } = l, _ = at.svg(f), v = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+	let y = h / 2, b = y / 6;
+	y += b;
+	let x = m / 2, S = x / 2, C = y - S, E = [
+		{
+			x: -C,
+			y: -x
+		},
+		{
+			x: 0,
+			y: -x
+		},
+		{
+			x: C,
+			y: -x
+		},
+		{
+			x: y,
+			y: 0
+		},
+		{
+			x: C,
+			y: x
+		},
+		{
+			x: 0,
+			y: x
+		},
+		{
+			x: -C,
+			y: x
+		},
+		{
+			x: -y,
+			y: 0
+		}
+	], D = createPathFromPoints(E), O = _.path(D, v), k = f.insert(() => O, ":first-child");
+	return k.attr("class", "basic label-container"), g && l.look !== "handDrawn" && k.selectChildren("path").attr("style", g), d && l.look !== "handDrawn" && k.selectChildren("path").attr("style", d), l.width = h, l.height = m, updateNodeBounds(l, k), l.intersect = function(e) {
+		return intersect_default.polygon(l, E, e);
+	}, f;
+}
+__name(hexagon, "hexagon");
+async function hourglass(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.label = "", u.labelStyle = d;
+	let { shapeSvg: p } = await labelHelper(e, u, getNodeClasses(u)), m = Math.max(30, u?.width ?? 0), h = Math.max(30, u?.height ?? 0), { cssStyles: g } = u, _ = at.svg(p), v = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+	let y = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: m,
+			y: 0
+		},
+		{
+			x: 0,
+			y: h
+		},
+		{
+			x: m,
+			y: h
+		}
+	], b = createPathFromPoints(y), x = _.path(b, v), S = p.insert(() => x, ":first-child");
+	return S.attr("class", "basic label-container"), g && u.look !== "handDrawn" && S.selectChildren("path").attr("style", g), f && u.look !== "handDrawn" && S.selectChildren("path").attr("style", f), S.attr("transform", `translate(${-m / 2}, ${-h / 2})`), updateNodeBounds(u, S), u.intersect = function(e) {
+		return log.info("Pill intersect", u, { points: y }), intersect_default.polygon(u, y, e);
+	}, p;
+}
+__name(hourglass, "hourglass");
+async function icon(e, u, { config: { themeVariables: d, flowchart: f } }) {
+	let { labelStyles: p } = styles2String(u);
+	u.labelStyle = p;
+	let m = u.assetHeight ?? 48, h = u.assetWidth ?? 48, g = Math.max(m, h), _ = f?.wrappingWidth;
+	u.width = Math.max(g, _ ?? 0);
+	let { shapeSvg: v, bbox: y, label: b } = await labelHelper(e, u, "icon-shape default"), x = u.pos === "t", C = g, E = g, { nodeBorder: D } = d, { stylesMap: O } = compileStyles(u), k = -E / 2, A = -C / 2, N = u.label ? 8 : 0, F = at.svg(v), I = userNodeOverrides(u, {
+		stroke: "none",
+		fill: "none"
+	});
+	u.look !== "handDrawn" && (I.roughness = 0, I.fillStyle = "solid");
+	let L = F.rectangle(k, A, E, C, I), R = Math.max(E, y.width), z = C + y.height + N, B = F.rectangle(-R / 2, -z / 2, R, z, {
+		...I,
+		fill: "transparent",
+		stroke: "none"
+	}), V = v.insert(() => L, ":first-child"), H = v.insert(() => B);
+	if (u.icon) {
+		let e = v.append("g");
+		e.html(`<g>${await getIconSVG(u.icon, {
+			height: g,
+			width: g,
+			fallbackPrefix: ""
+		})}</g>`);
+		let l = e.node().getBBox(), d = l.width, f = l.height, p = l.x, m = l.y;
+		e.attr("transform", `translate(${-d / 2 - p},${x ? y.height / 2 + N / 2 - f / 2 - m : -y.height / 2 - N / 2 - f / 2 - m})`), e.attr("style", `color: ${O.get("stroke") ?? D};`);
+	}
+	return b.attr("transform", `translate(${-y.width / 2 - (y.x - (y.left ?? 0))},${x ? -z / 2 : z / 2 - y.height})`), V.attr("transform", `translate(0,${x ? y.height / 2 + N / 2 : -y.height / 2 - N / 2})`), updateNodeBounds(u, H), u.intersect = function(e) {
+		if (log.info("iconSquare intersect", u, e), !u.label) return intersect_default.rect(u, e);
+		let d = u.x ?? 0, f = u.y ?? 0, p = u.height ?? 0, m = [];
+		return m = x ? [
+			{
+				x: d - y.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2 + y.height + N
+			},
+			{
+				x: d + E / 2,
+				y: f - p / 2 + y.height + N
+			},
+			{
+				x: d + E / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - E / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - E / 2,
+				y: f - p / 2 + y.height + N
+			},
+			{
+				x: d - y.width / 2,
+				y: f - p / 2 + y.height + N
+			}
+		] : [
+			{
+				x: d - E / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + E / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + E / 2,
+				y: f - p / 2 + C
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2 + C
+			},
+			{
+				x: d + y.width / 2 / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - y.width / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - y.width / 2,
+				y: f - p / 2 + C
+			},
+			{
+				x: d - E / 2,
+				y: f - p / 2 + C
+			}
+		], intersect_default.polygon(u, m, e);
+	}, v;
+}
+__name(icon, "icon");
+async function iconCircle(e, u, { config: { themeVariables: d, flowchart: f } }) {
+	let { labelStyles: p } = styles2String(u);
+	u.labelStyle = p;
+	let m = u.assetHeight ?? 48, h = u.assetWidth ?? 48, g = Math.max(m, h), _ = f?.wrappingWidth;
+	u.width = Math.max(g, _ ?? 0);
+	let { shapeSvg: v, bbox: y, label: b } = await labelHelper(e, u, "icon-shape default"), x = u.label ? 8 : 0, C = u.pos === "t", { nodeBorder: E, mainBkg: D } = d, { stylesMap: O } = compileStyles(u), k = at.svg(v), A = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (A.roughness = 0, A.fillStyle = "solid"), A.stroke = O.get("fill") ?? D;
+	let N = v.append("g");
+	u.icon && N.html(`<g>${await getIconSVG(u.icon, {
+		height: g,
+		width: g,
+		fallbackPrefix: ""
+	})}</g>`);
+	let F = N.node().getBBox(), I = F.width, L = F.height, R = F.x, z = F.y, B = Math.max(I, L) * Math.SQRT2 + 40, V = k.circle(0, 0, B, A), H = Math.max(B, y.width), U = B + y.height + x, W = k.rectangle(-H / 2, -U / 2, H, U, {
+		...A,
+		fill: "transparent",
+		stroke: "none"
+	}), G = v.insert(() => V, ":first-child"), K = v.insert(() => W);
+	return N.attr("transform", `translate(${-I / 2 - R},${C ? y.height / 2 + x / 2 - L / 2 - z : -y.height / 2 - x / 2 - L / 2 - z})`), N.attr("style", `color: ${O.get("stroke") ?? E};`), b.attr("transform", `translate(${-y.width / 2 - (y.x - (y.left ?? 0))},${C ? -U / 2 : U / 2 - y.height})`), G.attr("transform", `translate(0,${C ? y.height / 2 + x / 2 : -y.height / 2 - x / 2})`), updateNodeBounds(u, K), u.intersect = function(e) {
+		return log.info("iconSquare intersect", u, e), intersect_default.rect(u, e);
+	}, v;
+}
+__name(iconCircle, "iconCircle");
+async function iconRounded(e, u, { config: { themeVariables: d, flowchart: f } }) {
+	let { labelStyles: p } = styles2String(u);
+	u.labelStyle = p;
+	let m = u.assetHeight ?? 48, h = u.assetWidth ?? 48, g = Math.max(m, h), _ = f?.wrappingWidth;
+	u.width = Math.max(g, _ ?? 0);
+	let { shapeSvg: v, bbox: y, halfPadding: b, label: x } = await labelHelper(e, u, "icon-shape default"), C = u.pos === "t", E = g + b * 2, D = g + b * 2, { nodeBorder: O, mainBkg: k } = d, { stylesMap: A } = compileStyles(u), N = -D / 2, F = -E / 2, I = u.label ? 8 : 0, L = at.svg(v), R = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (R.roughness = 0, R.fillStyle = "solid"), R.stroke = A.get("fill") ?? k;
+	let z = L.path(createRoundedRectPathD(N, F, D, E, 5), R), B = Math.max(D, y.width), V = E + y.height + I, H = L.rectangle(-B / 2, -V / 2, B, V, {
+		...R,
+		fill: "transparent",
+		stroke: "none"
+	}), W = v.insert(() => z, ":first-child").attr("class", "icon-shape2"), G = v.insert(() => H);
+	if (u.icon) {
+		let e = v.append("g");
+		e.html(`<g>${await getIconSVG(u.icon, {
+			height: g,
+			width: g,
+			fallbackPrefix: ""
+		})}</g>`);
+		let l = e.node().getBBox(), d = l.width, f = l.height, p = l.x, m = l.y;
+		e.attr("transform", `translate(${-d / 2 - p},${C ? y.height / 2 + I / 2 - f / 2 - m : -y.height / 2 - I / 2 - f / 2 - m})`), e.attr("style", `color: ${A.get("stroke") ?? O};`);
+	}
+	return x.attr("transform", `translate(${-y.width / 2 - (y.x - (y.left ?? 0))},${C ? -V / 2 : V / 2 - y.height})`), W.attr("transform", `translate(0,${C ? y.height / 2 + I / 2 : -y.height / 2 - I / 2})`), updateNodeBounds(u, G), u.intersect = function(e) {
+		if (log.info("iconSquare intersect", u, e), !u.label) return intersect_default.rect(u, e);
+		let d = u.x ?? 0, f = u.y ?? 0, p = u.height ?? 0, m = [];
+		return m = C ? [
+			{
+				x: d - y.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2 + y.height + I
+			},
+			{
+				x: d + D / 2,
+				y: f - p / 2 + y.height + I
+			},
+			{
+				x: d + D / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - D / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - D / 2,
+				y: f - p / 2 + y.height + I
+			},
+			{
+				x: d - y.width / 2,
+				y: f - p / 2 + y.height + I
+			}
+		] : [
+			{
+				x: d - D / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + D / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + D / 2,
+				y: f - p / 2 + E
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2 + E
+			},
+			{
+				x: d + y.width / 2 / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - y.width / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - y.width / 2,
+				y: f - p / 2 + E
+			},
+			{
+				x: d - D / 2,
+				y: f - p / 2 + E
+			}
+		], intersect_default.polygon(u, m, e);
+	}, v;
+}
+__name(iconRounded, "iconRounded");
+async function iconSquare(e, u, { config: { themeVariables: d, flowchart: f } }) {
+	let { labelStyles: p } = styles2String(u);
+	u.labelStyle = p;
+	let m = u.assetHeight ?? 48, h = u.assetWidth ?? 48, g = Math.max(m, h), _ = f?.wrappingWidth;
+	u.width = Math.max(g, _ ?? 0);
+	let { shapeSvg: v, bbox: y, halfPadding: b, label: x } = await labelHelper(e, u, "icon-shape default"), C = u.pos === "t", E = g + b * 2, D = g + b * 2, { nodeBorder: O, mainBkg: k } = d, { stylesMap: A } = compileStyles(u), N = -D / 2, F = -E / 2, I = u.label ? 8 : 0, L = at.svg(v), R = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (R.roughness = 0, R.fillStyle = "solid"), R.stroke = A.get("fill") ?? k;
+	let z = L.path(createRoundedRectPathD(N, F, D, E, .1), R), B = Math.max(D, y.width), V = E + y.height + I, H = L.rectangle(-B / 2, -V / 2, B, V, {
+		...R,
+		fill: "transparent",
+		stroke: "none"
+	}), W = v.insert(() => z, ":first-child"), G = v.insert(() => H);
+	if (u.icon) {
+		let e = v.append("g");
+		e.html(`<g>${await getIconSVG(u.icon, {
+			height: g,
+			width: g,
+			fallbackPrefix: ""
+		})}</g>`);
+		let l = e.node().getBBox(), d = l.width, f = l.height, p = l.x, m = l.y;
+		e.attr("transform", `translate(${-d / 2 - p},${C ? y.height / 2 + I / 2 - f / 2 - m : -y.height / 2 - I / 2 - f / 2 - m})`), e.attr("style", `color: ${A.get("stroke") ?? O};`);
+	}
+	return x.attr("transform", `translate(${-y.width / 2 - (y.x - (y.left ?? 0))},${C ? -V / 2 : V / 2 - y.height})`), W.attr("transform", `translate(0,${C ? y.height / 2 + I / 2 : -y.height / 2 - I / 2})`), updateNodeBounds(u, G), u.intersect = function(e) {
+		if (log.info("iconSquare intersect", u, e), !u.label) return intersect_default.rect(u, e);
+		let d = u.x ?? 0, f = u.y ?? 0, p = u.height ?? 0, m = [];
+		return m = C ? [
+			{
+				x: d - y.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2 + y.height + I
+			},
+			{
+				x: d + D / 2,
+				y: f - p / 2 + y.height + I
+			},
+			{
+				x: d + D / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - D / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - D / 2,
+				y: f - p / 2 + y.height + I
+			},
+			{
+				x: d - y.width / 2,
+				y: f - p / 2 + y.height + I
+			}
+		] : [
+			{
+				x: d - D / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + D / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + D / 2,
+				y: f - p / 2 + E
+			},
+			{
+				x: d + y.width / 2,
+				y: f - p / 2 + E
+			},
+			{
+				x: d + y.width / 2 / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - y.width / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - y.width / 2,
+				y: f - p / 2 + E
+			},
+			{
+				x: d - D / 2,
+				y: f - p / 2 + E
+			}
+		], intersect_default.polygon(u, m, e);
+	}, v;
+}
+__name(iconSquare, "iconSquare");
+async function imageSquare(e, u, { config: { flowchart: d } }) {
+	let f = new Image();
+	f.src = u?.img ?? "", await f.decode();
+	let p = Number(f.naturalWidth.toString().replace("px", "")), m = Number(f.naturalHeight.toString().replace("px", ""));
+	u.imageAspectRatio = p / m;
+	let { labelStyles: h } = styles2String(u);
+	u.labelStyle = h;
+	let g = d?.wrappingWidth;
+	u.defaultWidth = d?.wrappingWidth;
+	let _ = Math.max(u.label ? g ?? 0 : 0, u?.assetWidth ?? p), v = u.constraint === "on" && u?.assetHeight ? u.assetHeight * u.imageAspectRatio : _, y = u.constraint === "on" ? v / u.imageAspectRatio : u?.assetHeight ?? m;
+	u.width = Math.max(v, g ?? 0);
+	let { shapeSvg: b, bbox: x, label: S } = await labelHelper(e, u, "image-shape default"), C = u.pos === "t", E = -v / 2, D = -y / 2, O = u.label ? 8 : 0, k = at.svg(b), A = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (A.roughness = 0, A.fillStyle = "solid");
+	let j = k.rectangle(E, D, v, y, A), N = Math.max(v, x.width), F = y + x.height + O, I = k.rectangle(-N / 2, -F / 2, N, F, {
+		...A,
+		fill: "none",
+		stroke: "none"
+	}), L = b.insert(() => j, ":first-child"), R = b.insert(() => I);
+	if (u.img) {
+		let e = b.append("image");
+		e.attr("href", u.img), e.attr("width", v), e.attr("height", y), e.attr("preserveAspectRatio", "none"), e.attr("transform", `translate(${-v / 2},${C ? F / 2 - y : -F / 2})`);
+	}
+	return S.attr("transform", `translate(${-x.width / 2 - (x.x - (x.left ?? 0))},${C ? -y / 2 - x.height / 2 - O / 2 : y / 2 - x.height / 2 + O / 2})`), L.attr("transform", `translate(0,${C ? x.height / 2 + O / 2 : -x.height / 2 - O / 2})`), updateNodeBounds(u, R), u.intersect = function(e) {
+		if (log.info("iconSquare intersect", u, e), !u.label) return intersect_default.rect(u, e);
+		let d = u.x ?? 0, f = u.y ?? 0, p = u.height ?? 0, m = [];
+		return m = C ? [
+			{
+				x: d - x.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + x.width / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + x.width / 2,
+				y: f - p / 2 + x.height + O
+			},
+			{
+				x: d + v / 2,
+				y: f - p / 2 + x.height + O
+			},
+			{
+				x: d + v / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - v / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - v / 2,
+				y: f - p / 2 + x.height + O
+			},
+			{
+				x: d - x.width / 2,
+				y: f - p / 2 + x.height + O
+			}
+		] : [
+			{
+				x: d - v / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + v / 2,
+				y: f - p / 2
+			},
+			{
+				x: d + v / 2,
+				y: f - p / 2 + y
+			},
+			{
+				x: d + x.width / 2,
+				y: f - p / 2 + y
+			},
+			{
+				x: d + x.width / 2 / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - x.width / 2,
+				y: f + p / 2
+			},
+			{
+				x: d - x.width / 2,
+				y: f - p / 2 + y
+			},
+			{
+				x: d - v / 2,
+				y: f - p / 2 + y
+			}
+		], intersect_default.polygon(u, m, e);
+	}, b;
+}
+__name(imageSquare, "imageSquare");
+async function inv_trapezoid(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), h = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), g = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: m,
+			y: 0
+		},
+		{
+			x: m + 3 * h / 6,
+			y: -h
+		},
+		{
+			x: -3 * h / 6,
+			y: -h
+		}
+	], _, { cssStyles: v } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = createPathFromPoints(g), p = e.path(d, u);
+		_ = f.insert(() => p, ":first-child").attr("transform", `translate(${-m / 2}, ${h / 2})`), v && _.attr("style", v);
+	} else _ = insertPolygonShape(f, m, h, g);
+	return d && _.attr("style", d), l.width = m, l.height = h, updateNodeBounds(l, _), l.intersect = function(e) {
+		return intersect_default.polygon(l, g, e);
+	}, f;
+}
+__name(inv_trapezoid, "inv_trapezoid");
+async function drawRect(e, l, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(l);
+	l.labelStyle = d;
+	let { shapeSvg: p, bbox: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(m.width + u.labelPaddingX * 2, l?.width || 0), g = Math.max(m.height + u.labelPaddingY * 2, l?.height || 0), _ = -h / 2, v = -g / 2, y, { rx: b, ry: x } = l, { cssStyles: S } = l;
+	if (u?.rx && u.ry && (b = u.rx, x = u.ry), l.look === "handDrawn") {
+		let e = at.svg(p), u = userNodeOverrides(l, {}), d = b || x ? e.path(createRoundedRectPathD(_, v, h, g, b || 0), u) : e.rectangle(_, v, h, g, u);
+		y = p.insert(() => d, ":first-child"), y.attr("class", "basic label-container").attr("style", handleUndefinedAttr(S));
+	} else y = p.insert("rect", ":first-child"), y.attr("class", "basic label-container").attr("style", f).attr("rx", handleUndefinedAttr(b)).attr("ry", handleUndefinedAttr(x)).attr("x", _).attr("y", v).attr("width", h).attr("height", g);
+	return updateNodeBounds(l, y), l.calcIntersect = function(e, l) {
+		return intersect_default.rect(e, l);
+	}, l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, p;
+}
+__name(drawRect, "drawRect");
+async function labelRect(e, l) {
+	let { shapeSvg: u, bbox: d, label: f } = await labelHelper(e, l, "label"), p = u.insert("rect", ":first-child");
+	return p.attr("width", .1).attr("height", .1), u.attr("class", "label edgeLabel"), f.attr("transform", `translate(${-(d.width / 2) - (d.x - (d.left ?? 0))}, ${-(d.height / 2) - (d.y - (d.top ?? 0))})`), updateNodeBounds(l, p), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, u;
+}
+__name(labelRect, "labelRect");
+async function lean_left(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(p.width + (l.padding ?? 0), l?.width ?? 0), h = Math.max(p.height + (l.padding ?? 0), l?.height ?? 0), g = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: m + 3 * h / 6,
+			y: 0
+		},
+		{
+			x: m,
+			y: -h
+		},
+		{
+			x: -(3 * h) / 6,
+			y: -h
+		}
+	], _, { cssStyles: v } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = createPathFromPoints(g), p = e.path(d, u);
+		_ = f.insert(() => p, ":first-child").attr("transform", `translate(${-m / 2}, ${h / 2})`), v && _.attr("style", v);
+	} else _ = insertPolygonShape(f, m, h, g);
+	return d && _.attr("style", d), l.width = m, l.height = h, updateNodeBounds(l, _), l.intersect = function(e) {
+		return intersect_default.polygon(l, g, e);
+	}, f;
+}
+__name(lean_left, "lean_left");
+async function lean_right(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(p.width + (l.padding ?? 0), l?.width ?? 0), h = Math.max(p.height + (l.padding ?? 0), l?.height ?? 0), g = [
+		{
+			x: -3 * h / 6,
+			y: 0
+		},
+		{
+			x: m,
+			y: 0
+		},
+		{
+			x: m + 3 * h / 6,
+			y: -h
+		},
+		{
+			x: 0,
+			y: -h
+		}
+	], _, { cssStyles: v } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = createPathFromPoints(g), p = e.path(d, u);
+		_ = f.insert(() => p, ":first-child").attr("transform", `translate(${-m / 2}, ${h / 2})`), v && _.attr("style", v);
+	} else _ = insertPolygonShape(f, m, h, g);
+	return d && _.attr("style", d), l.width = m, l.height = h, updateNodeBounds(l, _), l.intersect = function(e) {
+		return intersect_default.polygon(l, g, e);
+	}, f;
+}
+__name(lean_right, "lean_right");
+function lightningBolt(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.label = "", u.labelStyle = d;
+	let p = e.insert("g").attr("class", getNodeClasses(u)).attr("id", u.domId ?? u.id), { cssStyles: m } = u, h = Math.max(35, u?.width ?? 0), g = Math.max(35, u?.height ?? 0), _ = [
+		{
+			x: h,
+			y: 0
+		},
+		{
+			x: 0,
+			y: g + 7 / 2
+		},
+		{
+			x: h - 14,
+			y: g + 7 / 2
+		},
+		{
+			x: 0,
+			y: 2 * g
+		},
+		{
+			x: h,
+			y: g - 7 / 2
+		},
+		{
+			x: 14,
+			y: g - 7 / 2
+		}
+	], v = at.svg(p), y = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+	let b = createPathFromPoints(_), x = v.path(b, y), S = p.insert(() => x, ":first-child");
+	return m && u.look !== "handDrawn" && S.selectAll("path").attr("style", m), f && u.look !== "handDrawn" && S.selectAll("path").attr("style", f), S.attr("transform", `translate(-${h / 2},${-g})`), updateNodeBounds(u, S), u.intersect = function(e) {
+		return log.info("lightningBolt intersect", u, e), intersect_default.polygon(u, _, e);
+	}, p;
+}
+__name(lightningBolt, "lightningBolt");
+var createCylinderPathD2 = /* @__PURE__ */ __name((e, l, u, d, f, p, m) => [
+	`M${e},${l + p}`,
+	`a${f},${p} 0,0,0 ${u},0`,
+	`a${f},${p} 0,0,0 ${-u},0`,
+	`l0,${d}`,
+	`a${f},${p} 0,0,0 ${u},0`,
+	`l0,${-d}`,
+	`M${e},${l + p + m}`,
+	`a${f},${p} 0,0,0 ${u},0`
+].join(" "), "createCylinderPathD"), createOuterCylinderPathD2 = /* @__PURE__ */ __name((e, l, u, d, f, p, m) => [
+	`M${e},${l + p}`,
+	`M${e + u},${l + p}`,
+	`a${f},${p} 0,0,0 ${-u},0`,
+	`l0,${d}`,
+	`a${f},${p} 0,0,0 ${u},0`,
+	`l0,${-d}`,
+	`M${e},${l + p + m}`,
+	`a${f},${p} 0,0,0 ${u},0`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD2 = /* @__PURE__ */ __name((e, l, u, d, f, p) => [`M${e - u / 2},${-d / 2}`, `a${f},${p} 0,0,0 ${u},0`].join(" "), "createInnerCylinderPathD");
+async function linedCylinder(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0), l.width ?? 0), g = h / 2, _ = g / (2.5 + h / 50), v = Math.max(p.height + _ + (l.padding ?? 0), l.height ?? 0), y = v * .1, b, { cssStyles: x } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = createOuterCylinderPathD2(0, 0, h, v, g, _, y), d = createInnerCylinderPathD2(0, _, h, v, g, _), p = userNodeOverrides(l, {}), m = e.path(u, p), S = e.path(d, p);
+		f.insert(() => S, ":first-child").attr("class", "line"), b = f.insert(() => m, ":first-child"), b.attr("class", "basic label-container"), x && b.attr("style", x);
+	} else {
+		let e = createCylinderPathD2(0, 0, h, v, g, _, y);
+		b = f.insert("path", ":first-child").attr("d", e).attr("class", "basic label-container").attr("style", handleUndefinedAttr(x)).attr("style", d);
+	}
+	return b.attr("label-offset-y", _), b.attr("transform", `translate(${-h / 2}, ${-(v / 2 + _)})`), updateNodeBounds(l, b), m.attr("transform", `translate(${-(p.width / 2) - (p.x - (p.left ?? 0))}, ${-(p.height / 2) + _ - (p.y - (p.top ?? 0))})`), l.intersect = function(e) {
+		let u = intersect_default.rect(l, e), d = u.x - (l.x ?? 0);
+		if (g != 0 && (Math.abs(d) < (l.width ?? 0) / 2 || Math.abs(d) == (l.width ?? 0) / 2 && Math.abs(u.y - (l.y ?? 0)) > (l.height ?? 0) / 2 - _)) {
+			let f = _ * _ * (1 - d * d / (g * g));
+			f > 0 && (f = Math.sqrt(f)), f = _ - f, e.y - (l.y ?? 0) > 0 && (f = -f), u.y += f;
+		}
+		return u;
+	}, f;
+}
+__name(linedCylinder, "linedCylinder");
+async function linedWaveEdgedRect(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = g / 4, v = g + _, { cssStyles: y } = l, b = at.svg(f), x = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let S = [
+		{
+			x: -h / 2 - h / 2 * .1,
+			y: -v / 2
+		},
+		{
+			x: -h / 2 - h / 2 * .1,
+			y: v / 2
+		},
+		...generateFullSineWavePoints(-h / 2 - h / 2 * .1, v / 2, h / 2 + h / 2 * .1, v / 2, _, .8),
+		{
+			x: h / 2 + h / 2 * .1,
+			y: -v / 2
+		},
+		{
+			x: -h / 2 - h / 2 * .1,
+			y: -v / 2
+		},
+		{
+			x: -h / 2,
+			y: -v / 2
+		},
+		{
+			x: -h / 2,
+			y: v / 2 * 1.1
+		},
+		{
+			x: -h / 2,
+			y: -v / 2
+		}
+	], C = b.polygon(S.map((e) => [e.x, e.y]), x), E = f.insert(() => C, ":first-child");
+	return E.attr("class", "basic label-container"), y && l.look !== "handDrawn" && E.selectAll("path").attr("style", y), d && l.look !== "handDrawn" && E.selectAll("path").attr("style", d), E.attr("transform", `translate(0,${-_ / 2})`), m.attr("transform", `translate(${-h / 2 + (l.padding ?? 0) + h / 2 * .1 / 2 - (p.x - (p.left ?? 0))},${-g / 2 + (l.padding ?? 0) - _ / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, E), l.intersect = function(e) {
+		return intersect_default.polygon(l, S, e);
+	}, f;
+}
+__name(linedWaveEdgedRect, "linedWaveEdgedRect");
+async function multiRect(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = -h / 2, v = -g / 2, { cssStyles: y } = l, b = at.svg(f), x = userNodeOverrides(l, {}), S = [
+		{
+			x: _ - 5,
+			y: v + 5
+		},
+		{
+			x: _ - 5,
+			y: v + g + 5
+		},
+		{
+			x: _ + h - 5,
+			y: v + g + 5
+		},
+		{
+			x: _ + h - 5,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v + g - 5
+		},
+		{
+			x: _ + h + 5,
+			y: v + g - 5
+		},
+		{
+			x: _ + h + 5,
+			y: v - 5
+		},
+		{
+			x: _ + 5,
+			y: v - 5
+		},
+		{
+			x: _ + 5,
+			y: v
+		},
+		{
+			x: _,
+			y: v
+		},
+		{
+			x: _,
+			y: v + 5
+		}
+	], C = [
+		{
+			x: _,
+			y: v + 5
+		},
+		{
+			x: _ + h - 5,
+			y: v + 5
+		},
+		{
+			x: _ + h - 5,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v
+		},
+		{
+			x: _,
+			y: v
+		}
+	];
+	l.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let E = createPathFromPoints(S), D = b.path(E, x), O = createPathFromPoints(C), k = b.path(O, {
+		...x,
+		fill: "none"
+	}), A = f.insert(() => k, ":first-child");
+	return A.insert(() => D, ":first-child"), A.attr("class", "basic label-container"), y && l.look !== "handDrawn" && A.selectAll("path").attr("style", y), d && l.look !== "handDrawn" && A.selectAll("path").attr("style", d), m.attr("transform", `translate(${-(p.width / 2) - 5 - (p.x - (p.left ?? 0))}, ${-(p.height / 2) + 5 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, A), l.intersect = function(e) {
+		return intersect_default.polygon(l, S, e);
+	}, f;
+}
+__name(multiRect, "multiRect");
+async function multiWaveEdgedRectangle(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = g / 4, v = g + _, y = -h / 2, b = -v / 2, { cssStyles: x } = l, S = generateFullSineWavePoints(y - 5, b + v + 5, y + h - 5, b + v + 5, _, .8), C = S?.[S.length - 1], E = [
+		{
+			x: y - 5,
+			y: b + 5
+		},
+		{
+			x: y - 5,
+			y: b + v + 5
+		},
+		...S,
+		{
+			x: y + h - 5,
+			y: C.y - 5
+		},
+		{
+			x: y + h,
+			y: C.y - 5
+		},
+		{
+			x: y + h,
+			y: C.y - 10
+		},
+		{
+			x: y + h + 5,
+			y: C.y - 10
+		},
+		{
+			x: y + h + 5,
+			y: b - 5
+		},
+		{
+			x: y + 5,
+			y: b - 5
+		},
+		{
+			x: y + 5,
+			y: b
+		},
+		{
+			x: y,
+			y: b
+		},
+		{
+			x: y,
+			y: b + 5
+		}
+	], D = [
+		{
+			x: y,
+			y: b + 5
+		},
+		{
+			x: y + h - 5,
+			y: b + 5
+		},
+		{
+			x: y + h - 5,
+			y: C.y - 5
+		},
+		{
+			x: y + h,
+			y: C.y - 5
+		},
+		{
+			x: y + h,
+			y: b
+		},
+		{
+			x: y,
+			y: b
+		}
+	], O = at.svg(f), k = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (k.roughness = 0, k.fillStyle = "solid");
+	let A = createPathFromPoints(E), j = O.path(A, k), N = createPathFromPoints(D), R = O.path(N, k), z = f.insert(() => j, ":first-child");
+	return z.insert(() => R), z.attr("class", "basic label-container"), x && l.look !== "handDrawn" && z.selectAll("path").attr("style", x), d && l.look !== "handDrawn" && z.selectAll("path").attr("style", d), z.attr("transform", `translate(0,${-_ / 2})`), m.attr("transform", `translate(${-(p.width / 2) - 5 - (p.x - (p.left ?? 0))}, ${-(p.height / 2) + 5 - _ / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, z), l.intersect = function(e) {
+		return intersect_default.polygon(l, E, e);
+	}, f;
+}
+__name(multiWaveEdgedRectangle, "multiWaveEdgedRectangle");
+async function note(e, l, { config: { themeVariables: u } }) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(l);
+	l.labelStyle = d, l.useHtmlLabels || getConfig().flowchart?.htmlLabels !== !1 || (l.centerLabel = !0);
+	let { shapeSvg: m, bbox: h, label: g } = await labelHelper(e, l, getNodeClasses(l)), _ = Math.max(h.width + (l.padding ?? 0) * 2, l?.width ?? 0), v = Math.max(h.height + (l.padding ?? 0) * 2, l?.height ?? 0), y = -_ / 2, b = -v / 2, { cssStyles: x } = l, S = at.svg(m), C = userNodeOverrides(l, {
+		fill: u.noteBkgColor,
+		stroke: u.noteBorderColor
+	});
+	l.look !== "handDrawn" && (C.roughness = 0, C.fillStyle = "solid");
+	let E = S.rectangle(y, b, _, v, C), D = m.insert(() => E, ":first-child");
+	return D.attr("class", "basic label-container"), x && l.look !== "handDrawn" && D.selectAll("path").attr("style", x), f && l.look !== "handDrawn" && D.selectAll("path").attr("style", f), g.attr("transform", `translate(${-h.width / 2 - (h.x - (h.left ?? 0))}, ${-(h.height / 2) - (h.y - (h.top ?? 0))})`), updateNodeBounds(l, D), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, m;
+}
+__name(note, "note");
+var createDecisionBoxPathD = /* @__PURE__ */ __name((e, l, u) => [
+	`M${e + u / 2},${l}`,
+	`L${e + u},${l - u / 2}`,
+	`L${e + u / 2},${l - u}`,
+	`L${e},${l - u / 2}`,
+	"Z"
+].join(" "), "createDecisionBoxPathD");
+async function question(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = p.width + l.padding + (p.height + l.padding), h = .5, g = [
+		{
+			x: m / 2,
+			y: 0
+		},
+		{
+			x: m,
+			y: -m / 2
+		},
+		{
+			x: m / 2,
+			y: -m
+		},
+		{
+			x: 0,
+			y: -m / 2
+		}
+	], _, { cssStyles: v } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = createDecisionBoxPathD(0, 0, m), p = e.path(d, u);
+		_ = f.insert(() => p, ":first-child").attr("transform", `translate(${-m / 2 + h}, ${m / 2})`), v && _.attr("style", v);
+	} else _ = insertPolygonShape(f, m, m, g), _.attr("transform", `translate(${-m / 2 + h}, ${m / 2})`);
+	return d && _.attr("style", d), updateNodeBounds(l, _), l.calcIntersect = function(e, l) {
+		let u = e.width, d = [
+			{
+				x: u / 2,
+				y: 0
+			},
+			{
+				x: u,
+				y: -u / 2
+			},
+			{
+				x: u / 2,
+				y: -u
+			},
+			{
+				x: 0,
+				y: -u / 2
+			}
+		], f = intersect_default.polygon(e, d, l);
+		return {
+			x: f.x - .5,
+			y: f.y - .5
+		};
+	}, l.intersect = function(e) {
+		return this.calcIntersect(l, e);
+	}, f;
+}
+__name(question, "question");
+async function rect_left_inv_arrow(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0), l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0), l?.height ?? 0), _ = -h / 2, v = -g / 2, y = v / 2, b = [
+		{
+			x: _ + y,
+			y: v
+		},
+		{
+			x: _,
+			y: 0
+		},
+		{
+			x: _ + y,
+			y: -v
+		},
+		{
+			x: -_,
+			y: -v
+		},
+		{
+			x: -_,
+			y: v
+		}
+	], { cssStyles: x } = l, S = at.svg(f), C = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (C.roughness = 0, C.fillStyle = "solid");
+	let E = createPathFromPoints(b), D = S.path(E, C), O = f.insert(() => D, ":first-child");
+	return O.attr("class", "basic label-container"), x && l.look !== "handDrawn" && O.selectAll("path").attr("style", x), d && l.look !== "handDrawn" && O.selectAll("path").attr("style", d), O.attr("transform", `translate(${-y / 2},0)`), m.attr("transform", `translate(${-y / 2 - p.width / 2 - (p.x - (p.left ?? 0))}, ${-(p.height / 2) - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, O), l.intersect = function(e) {
+		return intersect_default.polygon(l, b, e);
+	}, f;
+}
+__name(rect_left_inv_arrow, "rect_left_inv_arrow");
+async function rectWithTitle(e, u) {
+	let { labelStyles: d, nodeStyles: p } = styles2String(u);
+	u.labelStyle = d;
+	let h;
+	h = u.cssClasses ? "node " + u.cssClasses : "node default";
+	let g = e.insert("g").attr("class", h).attr("id", u.domId || u.id), _ = g.insert("g"), v = g.insert("g").attr("class", "label").attr("style", p), y = u.description, x = u.label, S = v.node().appendChild(await createLabel_default(x, u.labelStyle, !0, !0)), C = {
+		width: 0,
+		height: 0
+	};
+	if (evaluate(getConfig2()?.flowchart?.htmlLabels)) {
+		let e = S.children[0], l = select_default(S);
+		C = e.getBoundingClientRect(), l.attr("width", C.width), l.attr("height", C.height);
+	}
+	log.info("Text 2", y);
+	let E = y || [], D = S.getBBox(), O = v.node().appendChild(await createLabel_default(E.join ? E.join("<br/>") : E, u.labelStyle, !0, !0)), k = O.children[0], A = select_default(O);
+	C = k.getBoundingClientRect(), A.attr("width", C.width), A.attr("height", C.height);
+	let j = (u.padding || 0) / 2;
+	select_default(O).attr("transform", "translate( " + (C.width > D.width ? 0 : (D.width - C.width) / 2) + ", " + (D.height + j + 5) + ")"), select_default(S).attr("transform", "translate( " + (C.width < D.width ? 0 : -(D.width - C.width) / 2) + ", 0)"), C = v.node().getBBox(), v.attr("transform", "translate(" + -C.width / 2 + ", " + (-C.height / 2 - j + 3) + ")");
+	let M = C.width + (u.padding || 0), N = C.height + (u.padding || 0), F = -C.width / 2 - j, I = -C.height / 2 - j, L, R;
+	if (u.look === "handDrawn") {
+		let e = at.svg(g), d = userNodeOverrides(u, {}), f = e.path(createRoundedRectPathD(F, I, M, N, u.rx || 0), d), p = e.line(-C.width / 2 - j, -C.height / 2 - j + D.height + j, C.width / 2 + j, -C.height / 2 - j + D.height + j, d);
+		R = g.insert(() => (log.debug("Rough node insert CXC", f), p), ":first-child"), L = g.insert(() => (log.debug("Rough node insert CXC", f), f), ":first-child");
+	} else L = _.insert("rect", ":first-child"), R = _.insert("line"), L.attr("class", "outer title-state").attr("style", p).attr("x", -C.width / 2 - j).attr("y", -C.height / 2 - j).attr("width", C.width + (u.padding || 0)).attr("height", C.height + (u.padding || 0)), R.attr("class", "divider").attr("x1", -C.width / 2 - j).attr("x2", C.width / 2 + j).attr("y1", -C.height / 2 - j + D.height + j).attr("y2", -C.height / 2 - j + D.height + j);
+	return updateNodeBounds(u, L), u.intersect = function(e) {
+		return intersect_default.rect(u, e);
+	}, g;
+}
+__name(rectWithTitle, "rectWithTitle");
+function generateArcPoints2(e, l, u, d, f, p, m) {
+	let h = (e + u) / 2, g = (l + d) / 2, _ = Math.atan2(d - l, u - e), v = (u - e) / 2, y = (d - l) / 2, b = v / f, x = y / p, S = Math.sqrt(b ** 2 + x ** 2);
+	if (S > 1) throw Error("The given radii are too small to create an arc between the points.");
+	let C = Math.sqrt(1 - S ** 2), w = h + C * p * Math.sin(_) * (m ? -1 : 1), T = g - C * f * Math.cos(_) * (m ? -1 : 1), E = Math.atan2((l - T) / p, (e - w) / f), D = Math.atan2((d - T) / p, (u - w) / f) - E;
+	m && D < 0 && (D += 2 * Math.PI), !m && D > 0 && (D -= 2 * Math.PI);
+	let O = [];
+	for (let e = 0; e < 20; e++) {
+		let l = E + e / 19 * D, u = w + f * Math.cos(l), d = T + p * Math.sin(l);
+		O.push({
+			x: u,
+			y: d
+		});
+	}
+	return O;
+}
+__name(generateArcPoints2, "generateArcPoints");
+async function roundedRect(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = l?.padding ?? 0, h = l?.padding ?? 0, g = (l?.width ? l?.width : p.width) + m * 2, _ = (l?.height ? l?.height : p.height) + h * 2, v = l.radius || 5, y = l.taper || 5, { cssStyles: b } = l, x = at.svg(f), S = userNodeOverrides(l, {});
+	l.stroke && (S.stroke = l.stroke), l.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let C = [
+		{
+			x: -g / 2 + y,
+			y: -_ / 2
+		},
+		{
+			x: g / 2 - y,
+			y: -_ / 2
+		},
+		...generateArcPoints2(g / 2 - y, -_ / 2, g / 2, -_ / 2 + y, v, v, !0),
+		{
+			x: g / 2,
+			y: -_ / 2 + y
+		},
+		{
+			x: g / 2,
+			y: _ / 2 - y
+		},
+		...generateArcPoints2(g / 2, _ / 2 - y, g / 2 - y, _ / 2, v, v, !0),
+		{
+			x: g / 2 - y,
+			y: _ / 2
+		},
+		{
+			x: -g / 2 + y,
+			y: _ / 2
+		},
+		...generateArcPoints2(-g / 2 + y, _ / 2, -g / 2, _ / 2 - y, v, v, !0),
+		{
+			x: -g / 2,
+			y: _ / 2 - y
+		},
+		{
+			x: -g / 2,
+			y: -_ / 2 + y
+		},
+		...generateArcPoints2(-g / 2, -_ / 2 + y, -g / 2 + y, -_ / 2, v, v, !0)
+	], E = createPathFromPoints(C), D = x.path(E, S), O = f.insert(() => D, ":first-child");
+	return O.attr("class", "basic label-container outer-path"), b && l.look !== "handDrawn" && O.selectChildren("path").attr("style", b), d && l.look !== "handDrawn" && O.selectChildren("path").attr("style", d), updateNodeBounds(l, O), l.intersect = function(e) {
+		return intersect_default.polygon(l, C, e);
+	}, f;
+}
+__name(roundedRect, "roundedRect");
+async function shadedProcess(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = l?.padding ?? 0, g = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), _ = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), v = -p.width / 2 - h, y = -p.height / 2 - h, { cssStyles: b } = l, x = at.svg(f), S = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let C = [
+		{
+			x: v,
+			y
+		},
+		{
+			x: v + g + 8,
+			y
+		},
+		{
+			x: v + g + 8,
+			y: y + _
+		},
+		{
+			x: v - 8,
+			y: y + _
+		},
+		{
+			x: v - 8,
+			y
+		},
+		{
+			x: v,
+			y
+		},
+		{
+			x: v,
+			y: y + _
+		}
+	], E = x.polygon(C.map((e) => [e.x, e.y]), S), D = f.insert(() => E, ":first-child");
+	return D.attr("class", "basic label-container").attr("style", handleUndefinedAttr(b)), d && l.look !== "handDrawn" && D.selectAll("path").attr("style", d), b && l.look !== "handDrawn" && D.selectAll("path").attr("style", d), m.attr("transform", `translate(${-g / 2 + 4 + (l.padding ?? 0) - (p.x - (p.left ?? 0))},${-_ / 2 + (l.padding ?? 0) - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, D), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, f;
+}
+__name(shadedProcess, "shadedProcess");
+async function slopedRect(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = -h / 2, v = -g / 2, { cssStyles: y } = l, b = at.svg(f), x = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let S = [
+		{
+			x: _,
+			y: v
+		},
+		{
+			x: _,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v - g / 2
+		}
+	], C = createPathFromPoints(S), E = b.path(C, x), D = f.insert(() => E, ":first-child");
+	return D.attr("class", "basic label-container"), y && l.look !== "handDrawn" && D.selectChildren("path").attr("style", y), d && l.look !== "handDrawn" && D.selectChildren("path").attr("style", d), D.attr("transform", `translate(0, ${g / 4})`), m.attr("transform", `translate(${-h / 2 + (l.padding ?? 0) - (p.x - (p.left ?? 0))}, ${-g / 4 + (l.padding ?? 0) - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, D), l.intersect = function(e) {
+		return intersect_default.polygon(l, S, e);
+	}, f;
+}
+__name(slopedRect, "slopedRect");
+async function squareRect2(e, l) {
+	return drawRect(e, l, {
+		rx: 0,
+		ry: 0,
+		classes: "",
+		labelPaddingX: l.labelPaddingX ?? (l?.padding || 0) * 2,
+		labelPaddingY: (l?.padding || 0) * 1
+	});
+}
+__name(squareRect2, "squareRect");
+async function stadium(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = p.height + l.padding, h = p.width + m / 4 + l.padding, g = m / 2, { cssStyles: _ } = l, v = at.svg(f), y = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+	let b = [
+		{
+			x: -h / 2 + g,
+			y: -m / 2
+		},
+		{
+			x: h / 2 - g,
+			y: -m / 2
+		},
+		...generateCirclePoints(-h / 2 + g, 0, g, 50, 90, 270),
+		{
+			x: h / 2 - g,
+			y: m / 2
+		},
+		...generateCirclePoints(h / 2 - g, 0, g, 50, 270, 450)
+	], x = createPathFromPoints(b), S = v.path(x, y), C = f.insert(() => S, ":first-child");
+	return C.attr("class", "basic label-container outer-path"), _ && l.look !== "handDrawn" && C.selectChildren("path").attr("style", _), d && l.look !== "handDrawn" && C.selectChildren("path").attr("style", d), updateNodeBounds(l, C), l.intersect = function(e) {
+		return intersect_default.polygon(l, b, e);
+	}, f;
+}
+__name(stadium, "stadium");
+async function state(e, l) {
+	return drawRect(e, l, {
+		rx: 5,
+		ry: 5,
+		classes: "flowchart-node"
+	});
+}
+__name(state, "state");
+function stateEnd(e, l, { config: { themeVariables: u } }) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(l);
+	l.labelStyle = d;
+	let { cssStyles: p } = l, { lineColor: m, stateBorder: h, nodeBorder: g } = u, _ = e.insert("g").attr("class", "node default").attr("id", l.domId || l.id), v = at.svg(_), y = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+	let b = v.circle(0, 0, 14, {
+		...y,
+		stroke: m,
+		strokeWidth: 2
+	}), x = h ?? g, S = v.circle(0, 0, 5, {
+		...y,
+		fill: x,
+		stroke: x,
+		strokeWidth: 2,
+		fillStyle: "solid"
+	}), C = _.insert(() => b, ":first-child");
+	return C.insert(() => S), p && C.selectAll("path").attr("style", p), f && C.selectAll("path").attr("style", f), updateNodeBounds(l, C), l.intersect = function(e) {
+		return intersect_default.circle(l, 7, e);
+	}, _;
+}
+__name(stateEnd, "stateEnd");
+function stateStart(e, l, { config: { themeVariables: u } }) {
+	let { lineColor: d } = u, f = e.insert("g").attr("class", "node default").attr("id", l.domId || l.id), p;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f).circle(0, 0, 14, solidStateFill(d));
+		p = f.insert(() => e), p.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14);
+	} else p = f.insert("circle", ":first-child"), p.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14);
+	return updateNodeBounds(l, p), l.intersect = function(e) {
+		return intersect_default.circle(l, 7, e);
+	}, f;
+}
+__name(stateStart, "stateStart");
+async function subroutine(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = (l?.padding || 0) / 2, h = p.width + l.padding, g = p.height + l.padding, _ = -p.width / 2 - m, v = -p.height / 2 - m, y = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: h,
+			y: 0
+		},
+		{
+			x: h,
+			y: -g
+		},
+		{
+			x: 0,
+			y: -g
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: -8,
+			y: 0
+		},
+		{
+			x: h + 8,
+			y: 0
+		},
+		{
+			x: h + 8,
+			y: -g
+		},
+		{
+			x: -8,
+			y: -g
+		},
+		{
+			x: -8,
+			y: 0
+		}
+	];
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = e.rectangle(_ - 8, v, h + 16, g, u), p = e.line(_, v, _, v + g, u), m = e.line(_ + h, v, _ + h, v + g, u);
+		f.insert(() => p, ":first-child"), f.insert(() => m, ":first-child");
+		let y = f.insert(() => d, ":first-child"), { cssStyles: b } = l;
+		y.attr("class", "basic label-container").attr("style", handleUndefinedAttr(b)), updateNodeBounds(l, y);
+	} else {
+		let e = insertPolygonShape(f, h, g, y);
+		d && e.attr("style", d), updateNodeBounds(l, e);
+	}
+	return l.intersect = function(e) {
+		return intersect_default.polygon(l, y, e);
+	}, f;
+}
+__name(subroutine, "subroutine");
+async function taggedRect(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), h = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), g = -m / 2, _ = -h / 2, v = .2 * h, y = .2 * h, { cssStyles: b } = l, x = at.svg(f), S = userNodeOverrides(l, {}), C = [
+		{
+			x: g - v / 2,
+			y: _
+		},
+		{
+			x: g + m + v / 2,
+			y: _
+		},
+		{
+			x: g + m + v / 2,
+			y: _ + h
+		},
+		{
+			x: g - v / 2,
+			y: _ + h
+		}
+	], E = [
+		{
+			x: g + m - v / 2,
+			y: _ + h
+		},
+		{
+			x: g + m + v / 2,
+			y: _ + h
+		},
+		{
+			x: g + m + v / 2,
+			y: _ + h - y
+		}
+	];
+	l.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+	let D = createPathFromPoints(C), O = x.path(D, S), k = createPathFromPoints(E), A = x.path(k, {
+		...S,
+		fillStyle: "solid"
+	}), j = f.insert(() => A, ":first-child");
+	return j.insert(() => O, ":first-child"), j.attr("class", "basic label-container"), b && l.look !== "handDrawn" && j.selectAll("path").attr("style", b), d && l.look !== "handDrawn" && j.selectAll("path").attr("style", d), updateNodeBounds(l, j), l.intersect = function(e) {
+		return intersect_default.polygon(l, C, e);
+	}, f;
+}
+__name(taggedRect, "taggedRect");
+async function taggedWaveEdgedRectangle(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = g / 4, v = .2 * h, y = .2 * g, b = g + _, { cssStyles: x } = l, S = at.svg(f), C = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (C.roughness = 0, C.fillStyle = "solid");
+	let E = [
+		{
+			x: -h / 2 - h / 2 * .1,
+			y: b / 2
+		},
+		...generateFullSineWavePoints(-h / 2 - h / 2 * .1, b / 2, h / 2 + h / 2 * .1, b / 2, _, .8),
+		{
+			x: h / 2 + h / 2 * .1,
+			y: -b / 2
+		},
+		{
+			x: -h / 2 - h / 2 * .1,
+			y: -b / 2
+		}
+	], D = -h / 2 + h / 2 * .1, O = -b / 2 - y * .4, k = [
+		{
+			x: D + h - v,
+			y: (O + g) * 1.4
+		},
+		{
+			x: D + h,
+			y: O + g - y
+		},
+		{
+			x: D + h,
+			y: (O + g) * .9
+		},
+		...generateFullSineWavePoints(D + h, (O + g) * 1.3, D + h - v, (O + g) * 1.5, -g * .03, .5)
+	], A = createPathFromPoints(E), j = S.path(A, C), N = createPathFromPoints(k), R = S.path(N, {
+		...C,
+		fillStyle: "solid"
+	}), z = f.insert(() => R, ":first-child");
+	return z.insert(() => j, ":first-child"), z.attr("class", "basic label-container"), x && l.look !== "handDrawn" && z.selectAll("path").attr("style", x), d && l.look !== "handDrawn" && z.selectAll("path").attr("style", d), z.attr("transform", `translate(0,${-_ / 2})`), m.attr("transform", `translate(${-h / 2 + (l.padding ?? 0) - (p.x - (p.left ?? 0))},${-g / 2 + (l.padding ?? 0) - _ / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, z), l.intersect = function(e) {
+		return intersect_default.polygon(l, E, e);
+	}, f;
+}
+__name(taggedWaveEdgedRectangle, "taggedWaveEdgedRectangle");
+async function text(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(p.width + l.padding, l?.width || 0), h = Math.max(p.height + l.padding, l?.height || 0), g = -m / 2, _ = -h / 2, v = f.insert("rect", ":first-child");
+	return v.attr("class", "text").attr("style", d).attr("rx", 0).attr("ry", 0).attr("x", g).attr("y", _).attr("width", m).attr("height", h), updateNodeBounds(l, v), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, f;
+}
+__name(text, "text");
+var createCylinderPathD3 = /* @__PURE__ */ __name((e, l, u, d, f, p) => `M${e},${l}
+    a${f},${p} 0,0,1 0,${-d}
+    l${u},0
+    a${f},${p} 0,0,1 0,${d}
+    M${u},${-d}
+    a${f},${p} 0,0,0 0,${d}
+    l${-u},0`, "createCylinderPathD"), createOuterCylinderPathD3 = /* @__PURE__ */ __name((e, l, u, d, f, p) => [
+	`M${e},${l}`,
+	`M${e + u},${l}`,
+	`a${f},${p} 0,0,0 0,${-d}`,
+	`l${-u},0`,
+	`a${f},${p} 0,0,0 0,${d}`,
+	`l${u},0`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD3 = /* @__PURE__ */ __name((e, l, u, d, f, p) => [`M${e + u / 2},${-d / 2}`, `a${f},${p} 0,0,0 0,${d}`].join(" "), "createInnerCylinderPathD");
+async function tiltedCylinder(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m, halfPadding: h } = await labelHelper(e, l, getNodeClasses(l)), g = l.look === "neo" ? h * 2 : h, _ = p.height + g, v = _ / 2, y = v / (2.5 + _ / 50), b = p.width + y + g, { cssStyles: x } = l, S;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = createOuterCylinderPathD3(0, 0, b, _, y, v), d = createInnerCylinderPathD3(0, 0, b, _, y, v), p = e.path(u, userNodeOverrides(l, {})), m = e.path(d, userNodeOverrides(l, { fill: "none" }));
+		S = f.insert(() => m, ":first-child"), S = f.insert(() => p, ":first-child"), S.attr("class", "basic label-container"), x && S.attr("style", x);
+	} else {
+		let e = createCylinderPathD3(0, 0, b, _, y, v);
+		S = f.insert("path", ":first-child").attr("d", e).attr("class", "basic label-container").attr("style", handleUndefinedAttr(x)).attr("style", d), S.attr("class", "basic label-container"), x && S.selectAll("path").attr("style", x), d && S.selectAll("path").attr("style", d);
+	}
+	return S.attr("label-offset-x", y), S.attr("transform", `translate(${-b / 2}, ${_ / 2} )`), m.attr("transform", `translate(${-(p.width / 2) - y - (p.x - (p.left ?? 0))}, ${-(p.height / 2) - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, S), l.intersect = function(e) {
+		let u = intersect_default.rect(l, e), d = u.y - (l.y ?? 0);
+		if (v != 0 && (Math.abs(d) < (l.height ?? 0) / 2 || Math.abs(d) == (l.height ?? 0) / 2 && Math.abs(u.x - (l.x ?? 0)) > (l.width ?? 0) / 2 - y)) {
+			let f = y * y * (1 - d * d / (v * v));
+			f != 0 && (f = Math.sqrt(Math.abs(f))), f = y - f, e.x - (l.x ?? 0) > 0 && (f = -f), u.x += f;
+		}
+		return u;
+	}, f;
+}
+__name(tiltedCylinder, "tiltedCylinder");
+async function trapezoid(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = p.width + l.padding, h = p.height + l.padding, g = [
+		{
+			x: -3 * h / 6,
+			y: 0
+		},
+		{
+			x: m + 3 * h / 6,
+			y: 0
+		},
+		{
+			x: m,
+			y: -h
+		},
+		{
+			x: 0,
+			y: -h
+		}
+	], _, { cssStyles: v } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(f), u = userNodeOverrides(l, {}), d = createPathFromPoints(g), p = e.path(d, u);
+		_ = f.insert(() => p, ":first-child").attr("transform", `translate(${-m / 2}, ${h / 2})`), v && _.attr("style", v);
+	} else _ = insertPolygonShape(f, m, h, g);
+	return d && _.attr("style", d), l.width = m, l.height = h, updateNodeBounds(l, _), l.intersect = function(e) {
+		return intersect_default.polygon(l, g, e);
+	}, f;
+}
+__name(trapezoid, "trapezoid");
+async function trapezoidalPentagon(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(60, p.width + (l.padding ?? 0) * 2, l?.width ?? 0), h = Math.max(20, p.height + (l.padding ?? 0) * 2, l?.height ?? 0), { cssStyles: g } = l, _ = at.svg(f), v = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+	let y = [
+		{
+			x: -m / 2 * .8,
+			y: -h / 2
+		},
+		{
+			x: m / 2 * .8,
+			y: -h / 2
+		},
+		{
+			x: m / 2,
+			y: -h / 2 * .6
+		},
+		{
+			x: m / 2,
+			y: h / 2
+		},
+		{
+			x: -m / 2,
+			y: h / 2
+		},
+		{
+			x: -m / 2,
+			y: -h / 2 * .6
+		}
+	], b = createPathFromPoints(y), x = _.path(b, v), S = f.insert(() => x, ":first-child");
+	return S.attr("class", "basic label-container"), g && l.look !== "handDrawn" && S.selectChildren("path").attr("style", g), d && l.look !== "handDrawn" && S.selectChildren("path").attr("style", d), updateNodeBounds(l, S), l.intersect = function(e) {
+		return intersect_default.polygon(l, y, e);
+	}, f;
+}
+__name(trapezoidalPentagon, "trapezoidalPentagon");
+async function triangle(e, u) {
+	let { labelStyles: d, nodeStyles: p } = styles2String(u);
+	u.labelStyle = d;
+	let { shapeSvg: h, bbox: g, label: _ } = await labelHelper(e, u, getNodeClasses(u)), v = evaluate(getConfig2().flowchart?.htmlLabels), y = g.width + (u.padding ?? 0), b = y + g.height, x = y + g.height, S = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x,
+			y: 0
+		},
+		{
+			x: x / 2,
+			y: -b
+		}
+	], { cssStyles: C } = u, E = at.svg(h), D = userNodeOverrides(u, {});
+	u.look !== "handDrawn" && (D.roughness = 0, D.fillStyle = "solid");
+	let O = createPathFromPoints(S), k = E.path(O, D), A = h.insert(() => k, ":first-child").attr("transform", `translate(${-b / 2}, ${b / 2})`);
+	return C && u.look !== "handDrawn" && A.selectChildren("path").attr("style", C), p && u.look !== "handDrawn" && A.selectChildren("path").attr("style", p), u.width = y, u.height = b, updateNodeBounds(u, A), _.attr("transform", `translate(${-g.width / 2 - (g.x - (g.left ?? 0))}, ${b / 2 - (g.height + (u.padding ?? 0) / (v ? 2 : 1) - (g.y - (g.top ?? 0)))})`), u.intersect = function(e) {
+		return log.info("Triangle intersect", u, S, e), intersect_default.polygon(u, S, e);
+	}, h;
+}
+__name(triangle, "triangle");
+async function waveEdgedRectangle(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = g / 8, v = g + _, { cssStyles: y } = l, b = 70 - h, x = b > 0 ? b / 2 : 0, S = at.svg(f), C = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (C.roughness = 0, C.fillStyle = "solid");
+	let E = [
+		{
+			x: -h / 2 - x,
+			y: v / 2
+		},
+		...generateFullSineWavePoints(-h / 2 - x, v / 2, h / 2 + x, v / 2, _, .8),
+		{
+			x: h / 2 + x,
+			y: -v / 2
+		},
+		{
+			x: -h / 2 - x,
+			y: -v / 2
+		}
+	], D = createPathFromPoints(E), O = S.path(D, C), k = f.insert(() => O, ":first-child");
+	return k.attr("class", "basic label-container"), y && l.look !== "handDrawn" && k.selectAll("path").attr("style", y), d && l.look !== "handDrawn" && k.selectAll("path").attr("style", d), k.attr("transform", `translate(0,${-_ / 2})`), m.attr("transform", `translate(${-h / 2 + (l.padding ?? 0) - (p.x - (p.left ?? 0))},${-g / 2 + (l.padding ?? 0) - _ - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, k), l.intersect = function(e) {
+		return intersect_default.polygon(l, E, e);
+	}, f;
+}
+__name(waveEdgedRectangle, "waveEdgedRectangle");
+async function waveRectangle(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, l, getNodeClasses(l)), m = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), h = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), g = m / h, _ = m, v = h;
+	_ > v * g ? v = _ / g : _ = v * g, _ = Math.max(_, 100), v = Math.max(v, 50);
+	let y = Math.min(v * .2, v / 4), b = v + y * 2, { cssStyles: x } = l, S = at.svg(f), C = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (C.roughness = 0, C.fillStyle = "solid");
+	let E = [
+		{
+			x: -_ / 2,
+			y: b / 2
+		},
+		...generateFullSineWavePoints(-_ / 2, b / 2, _ / 2, b / 2, y, 1),
+		{
+			x: _ / 2,
+			y: -b / 2
+		},
+		...generateFullSineWavePoints(_ / 2, -b / 2, -_ / 2, -b / 2, y, -1)
+	], D = createPathFromPoints(E), O = S.path(D, C), k = f.insert(() => O, ":first-child");
+	return k.attr("class", "basic label-container"), x && l.look !== "handDrawn" && k.selectAll("path").attr("style", x), d && l.look !== "handDrawn" && k.selectAll("path").attr("style", d), updateNodeBounds(l, k), l.intersect = function(e) {
+		return intersect_default.polygon(l, E, e);
+	}, f;
+}
+__name(waveRectangle, "waveRectangle");
+async function windowPane(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, l, getNodeClasses(l)), h = Math.max(p.width + (l.padding ?? 0) * 2, l?.width ?? 0), g = Math.max(p.height + (l.padding ?? 0) * 2, l?.height ?? 0), _ = -h / 2, v = -g / 2, { cssStyles: y } = l, b = at.svg(f), x = userNodeOverrides(l, {}), S = [
+		{
+			x: _ - 5,
+			y: v - 5
+		},
+		{
+			x: _ - 5,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v - 5
+		}
+	], C = `M${_ - 5},${v - 5} L${_ + h},${v - 5} L${_ + h},${v + g} L${_ - 5},${v + g} L${_ - 5},${v - 5}
+                M${_ - 5},${v} L${_ + h},${v}
+                M${_},${v - 5} L${_},${v + g}`;
+	l.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let E = b.path(C, x), D = f.insert(() => E, ":first-child");
+	return D.attr("transform", `translate(${5 / 2}, ${5 / 2})`), D.attr("class", "basic label-container"), y && l.look !== "handDrawn" && D.selectAll("path").attr("style", y), d && l.look !== "handDrawn" && D.selectAll("path").attr("style", d), m.attr("transform", `translate(${-(p.width / 2) + 5 / 2 - (p.x - (p.left ?? 0))}, ${-(p.height / 2) + 5 / 2 - (p.y - (p.top ?? 0))})`), updateNodeBounds(l, D), l.intersect = function(e) {
+		return intersect_default.polygon(l, S, e);
+	}, f;
+}
+__name(windowPane, "windowPane");
+async function erBox(e, l) {
+	let u = l;
+	if (u.alias && (l.label = u.alias), l.look === "handDrawn") {
+		let { themeVariables: u } = getConfig(), { background: d } = u;
+		await erBox(e, {
+			...l,
+			id: l.id + "-background",
+			look: "default",
+			cssStyles: ["stroke: none", `fill: ${d}`]
+		});
+	}
+	let d = getConfig();
+	l.useHtmlLabels = d.htmlLabels;
+	let m = d.er?.diagramPadding ?? 10, h = d.er?.entityPadding ?? 6, { cssStyles: g } = l, { labelStyles: _, nodeStyles: v } = styles2String(l);
+	if (u.attributes.length === 0 && l.label) {
+		let u = {
+			rx: 0,
+			ry: 0,
+			labelPaddingX: m,
+			labelPaddingY: m * 1.5,
+			classes: ""
+		};
+		calculateTextWidth(l.label, d) + u.labelPaddingX * 2 < d.er.minEntityWidth && (l.width = d.er.minEntityWidth);
+		let p = await drawRect(e, l, u);
+		if (!evaluate(d.htmlLabels)) {
+			let e = p.select("text"), l = e.node()?.getBBox();
+			e.attr("transform", `translate(${-l.width / 2}, 0)`);
+		}
+		return p;
+	}
+	d.htmlLabels || (m *= 1.25, h *= 1.25);
+	let y = getNodeClasses(l);
+	y ||= "node default";
+	let x = e.insert("g").attr("class", y).attr("id", l.domId || l.id), S = await addText(x, l.label ?? "", d, 0, 0, ["name"], _);
+	S.height += h;
+	let C = 0, D = [], O = [], k = 0, A = 0, j = 0, M = 0, N = !0, I = !0;
+	for (let e of u.attributes) {
+		let l = await addText(x, e.type, d, 0, C, ["attribute-type"], _);
+		k = Math.max(k, l.width + m);
+		let u = await addText(x, e.name, d, 0, C, ["attribute-name"], _);
+		A = Math.max(A, u.width + m);
+		let f = await addText(x, e.keys.join(), d, 0, C, ["attribute-keys"], _);
+		j = Math.max(j, f.width + m);
+		let p = await addText(x, e.comment, d, 0, C, ["attribute-comment"], _);
+		M = Math.max(M, p.width + m);
+		let g = Math.max(l.height, u.height, f.height, p.height) + h;
+		O.push({
+			yOffset: C,
+			rowHeight: g
+		}), C += g;
+	}
+	let L = 4;
+	j <= m && (N = !1, j = 0, L--), M <= m && (I = !1, M = 0, L--);
+	let R = x.node().getBBox();
+	if (S.width + m * 2 - (k + A + j + M) > 0) {
+		let e = S.width + m * 2 - (k + A + j + M);
+		k += e / L, A += e / L, j > 0 && (j += e / L), M > 0 && (M += e / L);
+	}
+	let z = k + A + j + M, B = at.svg(x), V = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (V.roughness = 0, V.fillStyle = "solid");
+	let H = 0;
+	O.length > 0 && (H = O.reduce((e, l) => e + (l?.rowHeight ?? 0), 0));
+	let U = Math.max(R.width + m * 2, l?.width || 0, z), W = Math.max((H ?? 0) + S.height, l?.height || 0), G = -U / 2, K = -W / 2;
+	x.selectAll("g:not(:first-child)").each((e, l, u) => {
+		let d = select_default(u[l]), f = d.attr("transform"), p = 0, g = 0;
+		if (f) {
+			let e = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(f);
+			e && (p = parseFloat(e[1]), g = parseFloat(e[2]), d.attr("class").includes("attribute-name") ? p += k : d.attr("class").includes("attribute-keys") ? p += k + A : d.attr("class").includes("attribute-comment") && (p += k + A + j));
+		}
+		d.attr("transform", `translate(${G + m / 2 + p}, ${g + K + S.height + h / 2})`);
+	}), x.select(".name").attr("transform", "translate(" + -S.width / 2 + ", " + (K + h / 2) + ")");
+	let q = B.rectangle(G, K, U, W, V), J = x.insert(() => q, ":first-child").attr("style", g.join("")), { themeVariables: Y } = getConfig(), { rowEven: X, rowOdd: Z, nodeBorder: Q } = Y;
+	D.push(0);
+	for (let [e, l] of O.entries()) {
+		let u = (e + 1) % 2 == 0 && l.yOffset !== 0, d = B.rectangle(G, S.height + K + l?.yOffset, U, l?.rowHeight, {
+			...V,
+			fill: u ? X : Z,
+			stroke: Q
+		});
+		x.insert(() => d, "g.label").attr("style", g.join("")).attr("class", `row-rect-${u ? "even" : "odd"}`);
+	}
+	let $ = B.line(G, S.height + K, U + G, S.height + K, V);
+	x.insert(() => $).attr("class", "divider"), $ = B.line(k + G, S.height + K, k + G, W + K, V), x.insert(() => $).attr("class", "divider"), N && ($ = B.line(k + A + G, S.height + K, k + A + G, W + K, V), x.insert(() => $).attr("class", "divider")), I && ($ = B.line(k + A + j + G, S.height + K, k + A + j + G, W + K, V), x.insert(() => $).attr("class", "divider"));
+	for (let e of D) $ = B.line(G, S.height + K + e, U + G, S.height + K + e, V), x.insert(() => $).attr("class", "divider");
+	if (updateNodeBounds(l, J), v && l.look !== "handDrawn") {
+		let e = v.split(";")?.filter((e) => e.includes("stroke"))?.map((e) => `${e}`).join("; ");
+		x.selectAll("path").attr("style", e ?? ""), x.selectAll(".row-rect-even path").attr("style", v);
+	}
+	return l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, x;
+}
+__name(erBox, "erBox");
+async function addText(e, l, u, d = 0, p = 0, m = [], h = "") {
+	let _ = e.insert("g").attr("class", `label ${m.join(" ")}`).attr("transform", `translate(${d}, ${p})`).attr("style", h);
+	l !== parseGenericTypes(l) && (l = parseGenericTypes(l), l = l.replaceAll("<", "&lt;").replaceAll(">", "&gt;"));
+	let v = _.node().appendChild(await createText(_, l, {
+		width: calculateTextWidth(l, u) + 100,
+		style: h,
+		useHtmlLabels: u.htmlLabels
+	}, u));
+	if (l.includes("&lt;") || l.includes("&gt;")) {
+		let e = v.children[0];
+		for (e.textContent = e.textContent.replaceAll("&lt;", "<").replaceAll("&gt;", ">"); e.childNodes[0];) e = e.childNodes[0], e.textContent = e.textContent.replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+	}
+	let y = v.getBBox();
+	if (evaluate(u.htmlLabels)) {
+		let e = v.children[0];
+		e.style.textAlign = "start";
+		let l = select_default(v);
+		y = e.getBoundingClientRect(), l.attr("width", y.width), l.attr("height", y.height);
+	}
+	return y;
+}
+__name(addText, "addText");
+async function textHelper(e, l, u, d, f = u.class.padding ?? 12) {
+	let p = d ? 0 : 3, m = e.insert("g").attr("class", getNodeClasses(l)).attr("id", l.domId || l.id), h = null, g = null, _ = null, v = null, y = 0, b = 0, x = 0;
+	if (h = m.insert("g").attr("class", "annotation-group text"), l.annotations.length > 0) {
+		let e = l.annotations[0];
+		await addText2(h, { text: `\xAB${e}\xBB` }, 0), y = h.node().getBBox().height;
+	}
+	g = m.insert("g").attr("class", "label-group text"), await addText2(g, l, 0, ["font-weight: bolder"]);
+	let S = g.node().getBBox();
+	b = S.height, _ = m.insert("g").attr("class", "members-group text");
+	let C = 0;
+	for (let e of l.members) {
+		let l = await addText2(_, e, C, [e.parseClassifier()]);
+		C += l + p;
+	}
+	x = _.node().getBBox().height, x <= 0 && (x = f / 2), v = m.insert("g").attr("class", "methods-group text");
+	let w = 0;
+	for (let e of l.methods) {
+		let l = await addText2(v, e, w, [e.parseClassifier()]);
+		w += l + p;
+	}
+	let T = m.node().getBBox();
+	if (h !== null) {
+		let e = h.node().getBBox();
+		h.attr("transform", `translate(${-e.width / 2})`);
+	}
+	return g.attr("transform", `translate(${-S.width / 2}, ${y})`), T = m.node().getBBox(), _.attr("transform", `translate(0, ${y + b + f * 2})`), T = m.node().getBBox(), v.attr("transform", `translate(0, ${y + b + (x ? x + f * 4 : f * 2)})`), T = m.node().getBBox(), {
+		shapeSvg: m,
+		bbox: T
+	};
+}
+__name(textHelper, "textHelper");
+async function addText2(l, u, d, m = []) {
+	let g = l.insert("g").attr("class", "label").attr("style", m.join("; ")), _ = getConfig(), v = "useHtmlLabels" in u ? u.useHtmlLabels : evaluate(_.htmlLabels) ?? !0, x = "";
+	x = "text" in u ? u.text : u.label, !v && x.startsWith("\\") && (x = x.substring(1)), hasKatex(x) && (v = !0);
+	let S = await createText(g, sanitizeText3(decodeEntities(x)), {
+		width: calculateTextWidth(x, _) + 50,
+		classes: "markdown-node-label",
+		useHtmlLabels: v
+	}, _), C, w = 1;
+	if (v) {
+		let l = S.children[0], u = select_default(S);
+		w = l.innerHTML.split("<br>").length, l.innerHTML.includes("</math>") && (w += l.innerHTML.split("<mrow>").length - 1);
+		let d = l.getElementsByTagName("img");
+		if (d) {
+			let l = x.replace(/<img[^>]*>/g, "").trim() === "";
+			await Promise.all([...d].map((u) => new Promise((d) => {
+				function f() {
+					if (u.style.display = "flex", u.style.flexDirection = "column", l) {
+						let e = _.fontSize?.toString() ?? window.getComputedStyle(document.body).fontSize, l = parseInt(e, 10) * 5 + "px";
+						u.style.minWidth = l, u.style.maxWidth = l;
+					} else u.style.width = "100%";
+					d(u);
+				}
+				__name(f, "setupImage"), setTimeout(() => {
+					u.complete && f();
+				}), u.addEventListener("error", f), u.addEventListener("load", f);
+			})));
+		}
+		C = l.getBoundingClientRect(), u.attr("width", C.width), u.attr("height", C.height);
+	} else {
+		m.includes("font-weight: bolder") && select_default(S).selectAll("tspan").attr("font-weight", ""), w = S.children.length;
+		let e = S.children[0];
+		(S.textContent === "" || S.textContent.includes("&gt")) && (e.textContent = x[0] + x.substring(1).replaceAll("&gt;", ">").replaceAll("&lt;", "<").trim(), x[1] === " " && (e.textContent = e.textContent[0] + " " + e.textContent.substring(1))), e.textContent === "undefined" && (e.textContent = ""), C = S.getBBox();
+	}
+	return g.attr("transform", "translate(0," + (-C.height / (2 * w) + d) + ")"), C.height;
+}
+__name(addText2, "addText");
+async function classBox(e, l) {
+	let u = getConfig2(), d = u.class.padding ?? 12, p = d, h = l.useHtmlLabels ?? evaluate(u.htmlLabels) ?? !0, g = l;
+	g.annotations = g.annotations ?? [], g.members = g.members ?? [], g.methods = g.methods ?? [];
+	let { shapeSvg: _, bbox: v } = await textHelper(e, l, u, h, p), { labelStyles: y, nodeStyles: x } = styles2String(l);
+	l.labelStyle = y, l.cssStyles = g.styles || "";
+	let S = g.styles?.join(";") || x || "";
+	l.cssStyles ||= S.replaceAll("!important", "").split(";");
+	let C = g.members.length === 0 && g.methods.length === 0 && !u.class?.hideEmptyMembersBox, E = at.svg(_), D = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (D.roughness = 0, D.fillStyle = "solid");
+	let O = v.width, k = v.height;
+	g.members.length === 0 && g.methods.length === 0 ? k += p : g.members.length > 0 && g.methods.length === 0 && (k += p * 2);
+	let A = -O / 2, j = -k / 2, M = E.rectangle(A - d, j - d - (C ? d : g.members.length === 0 && g.methods.length === 0 ? -d / 2 : 0), O + 2 * d, k + 2 * d + (C ? d * 2 : g.members.length === 0 && g.methods.length === 0 ? -d : 0), D), N = _.insert(() => M, ":first-child");
+	N.attr("class", "basic label-container");
+	let F = N.node().getBBox();
+	_.selectAll(".text").each((e, l, u) => {
+		let f = select_default(u[l]), p = f.attr("transform"), m = 0;
+		if (p) {
+			let e = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(p);
+			e && (m = parseFloat(e[2]));
+		}
+		let v = m + j + d - (C ? d : g.members.length === 0 && g.methods.length === 0 ? -d / 2 : 0);
+		h || (v -= 4);
+		let y = A;
+		(f.attr("class").includes("label-group") || f.attr("class").includes("annotation-group")) && (y = -f.node()?.getBBox().width / 2 || 0, _.selectAll("text").each(function(e, l, u) {
+			window.getComputedStyle(u[l]).textAnchor === "middle" && (y = 0);
+		})), f.attr("transform", `translate(${y}, ${v})`);
+	});
+	let I = _.select(".annotation-group").node().getBBox().height - (C ? d / 2 : 0) || 0, L = _.select(".label-group").node().getBBox().height - (C ? d / 2 : 0) || 0, R = _.select(".members-group").node().getBBox().height - (C ? d / 2 : 0) || 0;
+	if (g.members.length > 0 || g.methods.length > 0 || C) {
+		let e = E.line(F.x, I + L + j + d, F.x + F.width, I + L + j + d, D);
+		_.insert(() => e).attr("class", "divider").attr("style", S);
+	}
+	if (C || g.members.length > 0 || g.methods.length > 0) {
+		let e = E.line(F.x, I + L + R + j + p * 2 + d, F.x + F.width, I + L + R + j + d + p * 2, D);
+		_.insert(() => e).attr("class", "divider").attr("style", S);
+	}
+	if (g.look !== "handDrawn" && _.selectAll("path").attr("style", S), N.select(":nth-child(2)").attr("style", S), _.selectAll(".divider").select("path").attr("style", S), l.labelStyle ? _.selectAll("span").attr("style", l.labelStyle) : _.selectAll("span").attr("style", S), !h) {
+		let e = RegExp(/color\s*:\s*([^;]*)/), l = e.exec(S);
+		if (l) {
+			let e = l[0].replace("color", "fill");
+			_.selectAll("tspan").attr("style", e);
+		} else if (y) {
+			let l = e.exec(y);
+			if (l) {
+				let e = l[0].replace("color", "fill");
+				_.selectAll("tspan").attr("style", e);
+			}
+		}
+	}
+	return updateNodeBounds(l, N), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, _;
+}
+__name(classBox, "classBox");
+async function requirementBox(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let f = l, p = l, m = "verifyMethod" in l, h = getNodeClasses(l), g = e.insert("g").attr("class", h).attr("id", l.domId ?? l.id), _;
+	_ = m ? await addText3(g, `&lt;&lt;${f.type}&gt;&gt;`, 0, l.labelStyle) : await addText3(g, "&lt;&lt;Element&gt;&gt;", 0, l.labelStyle);
+	let v = _, y = await addText3(g, f.name, v, l.labelStyle + "; font-weight: bold;");
+	if (v += y + 20, m) {
+		let e = await addText3(g, `${f.requirementId ? `ID: ${f.requirementId}` : ""}`, v, l.labelStyle);
+		v += e;
+		let u = await addText3(g, `${f.text ? `Text: ${f.text}` : ""}`, v, l.labelStyle);
+		v += u;
+		let d = await addText3(g, `${f.risk ? `Risk: ${f.risk}` : ""}`, v, l.labelStyle);
+		v += d, await addText3(g, `${f.verifyMethod ? `Verification: ${f.verifyMethod}` : ""}`, v, l.labelStyle);
+	} else {
+		let e = await addText3(g, `${p.type ? `Type: ${p.type}` : ""}`, v, l.labelStyle);
+		v += e, await addText3(g, `${p.docRef ? `Doc Ref: ${p.docRef}` : ""}`, v, l.labelStyle);
+	}
+	let x = (g.node()?.getBBox().width ?? 200) + 20, S = (g.node()?.getBBox().height ?? 200) + 20, C = -x / 2, E = -S / 2, D = at.svg(g), O = userNodeOverrides(l, {});
+	l.look !== "handDrawn" && (O.roughness = 0, O.fillStyle = "solid");
+	let k = D.rectangle(C, E, x, S, O), A = g.insert(() => k, ":first-child");
+	if (A.attr("class", "basic label-container").attr("style", d), g.selectAll(".label").each((e, l, u) => {
+		let d = select_default(u[l]), f = d.attr("transform"), p = 0, m = 0;
+		if (f) {
+			let e = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(f);
+			e && (p = parseFloat(e[1]), m = parseFloat(e[2]));
+		}
+		let h = m - S / 2, g = C + 20 / 2;
+		(l === 0 || l === 1) && (g = p), d.attr("transform", `translate(${g}, ${h + 20})`);
+	}), v > _ + y + 20) {
+		let e = D.line(C, E + _ + y + 20, C + x, E + _ + y + 20, O);
+		g.insert(() => e).attr("style", d);
+	}
+	return updateNodeBounds(l, A), l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, g;
+}
+__name(requirementBox, "requirementBox");
+async function addText3(e, l, u, d = "") {
+	if (l === "") return 0;
+	let f = e.insert("g").attr("class", "label").attr("style", d), p = getConfig2(), h = p.htmlLabels ?? !0, g = await createText(f, sanitizeText3(decodeEntities(l)), {
+		width: calculateTextWidth(l, p) + 50,
+		classes: "markdown-node-label",
+		useHtmlLabels: h,
+		style: d
+	}, p), _;
+	if (h) {
+		let e = g.children[0], l = select_default(g);
+		_ = e.getBoundingClientRect(), l.attr("width", _.width), l.attr("height", _.height);
+	} else {
+		let e = g.children[0];
+		for (let l of e.children) l.textContent = l.textContent.replaceAll("&gt;", ">").replaceAll("&lt;", "<"), d && l.setAttribute("style", d);
+		_ = g.getBBox(), _.height += 6;
+	}
+	return f.attr("transform", `translate(${-_.width / 2},${-_.height / 2 + u})`), _.height;
+}
+__name(addText3, "addText");
+var colorFromPriority = /* @__PURE__ */ __name((e) => {
+	switch (e) {
+		case "Very High": return "red";
+		case "High": return "orange";
+		case "Medium": return null;
+		case "Low": return "blue";
+		case "Very Low": return "lightblue";
+	}
+}, "colorFromPriority");
+async function kanbanItem(e, l, { config: u }) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(l);
+	l.labelStyle = d || "";
+	let p = l.width;
+	l.width = (l.width ?? 200) - 10;
+	let { shapeSvg: m, bbox: h, label: g } = await labelHelper(e, l, getNodeClasses(l)), _ = l.padding || 10, v = "", y;
+	"ticket" in l && l.ticket && u?.kanban?.ticketBaseUrl && (v = u?.kanban?.ticketBaseUrl.replace("#TICKET#", l.ticket), y = m.insert("svg:a", ":first-child").attr("class", "kanban-ticket-link").attr("xlink:href", v).attr("target", "_blank"));
+	let b = {
+		useHtmlLabels: l.useHtmlLabels,
+		labelStyle: l.labelStyle || "",
+		width: l.width,
+		img: l.img,
+		padding: l.padding || 8,
+		centerLabel: !1
+	}, x, S;
+	y ? {label: x, bbox: S} = await insertLabel(y, "ticket" in l && l.ticket || "", b) : {label: x, bbox: S} = await insertLabel(m, "ticket" in l && l.ticket || "", b);
+	let { label: C, bbox: E } = await insertLabel(m, "assigned" in l && l.assigned || "", b);
+	l.width = p;
+	let D = l?.width || 0, O = Math.max(S.height, E.height) / 2, k = Math.max(h.height + 20, l?.height || 0) + O, A = -D / 2, j = -k / 2;
+	g.attr("transform", "translate(" + (_ - D / 2) + ", " + (-O - h.height / 2) + ")"), x.attr("transform", "translate(" + (_ - D / 2) + ", " + (-O + h.height / 2) + ")"), C.attr("transform", "translate(" + (_ + D / 2 - E.width - 20) + ", " + (-O + h.height / 2) + ")");
+	let I, { rx: L, ry: R } = l, { cssStyles: z } = l;
+	if (l.look === "handDrawn") {
+		let e = at.svg(m), u = userNodeOverrides(l, {}), d = L || R ? e.path(createRoundedRectPathD(A, j, D, k, L || 0), u) : e.rectangle(A, j, D, k, u);
+		I = m.insert(() => d, ":first-child"), I.attr("class", "basic label-container").attr("style", z || null);
+	} else {
+		I = m.insert("rect", ":first-child"), I.attr("class", "basic label-container __APA__").attr("style", f).attr("rx", L ?? 5).attr("ry", R ?? 5).attr("x", A).attr("y", j).attr("width", D).attr("height", k);
+		let e = "priority" in l && l.priority;
+		if (e) {
+			let l = m.append("line"), u = A + 2, d = j + Math.floor((L ?? 0) / 2), f = j + k - Math.floor((L ?? 0) / 2);
+			l.attr("x1", u).attr("y1", d).attr("x2", u).attr("y2", f).attr("stroke-width", "4").attr("stroke", colorFromPriority(e));
+		}
+	}
+	return updateNodeBounds(l, I), l.height = k, l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, m;
+}
+__name(kanbanItem, "kanbanItem");
+async function bang(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.labelStyle = d;
+	let { shapeSvg: p, bbox: m, halfPadding: h, label: g } = await labelHelper(e, u, getNodeClasses(u)), _ = m.width + 10 * h, v = m.height + 8 * h, y = .15 * _, { cssStyles: b } = u, x = m.width + 20, S = m.height + 20, C = Math.max(_, x), E = Math.max(v, S);
+	g.attr("transform", `translate(${-m.width / 2}, ${-m.height / 2})`);
+	let D, k = `M0 0 
+    a${y},${y} 1 0,0 ${C * .25},${-1 * E * .1}
+    a${y},${y} 1 0,0 ${C * .25},0
+    a${y},${y} 1 0,0 ${C * .25},0
+    a${y},${y} 1 0,0 ${C * .25},${E * .1}
+
+    a${y},${y} 1 0,0 ${C * .15},${E * .33}
+    a${y * .8},${y * .8} 1 0,0 0,${E * .34}
+    a${y},${y} 1 0,0 ${-1 * C * .15},${E * .33}
+
+    a${y},${y} 1 0,0 ${-1 * C * .25},${E * .15}
+    a${y},${y} 1 0,0 ${-1 * C * .25},0
+    a${y},${y} 1 0,0 ${-1 * C * .25},0
+    a${y},${y} 1 0,0 ${-1 * C * .25},${-1 * E * .15}
+
+    a${y},${y} 1 0,0 ${-1 * C * .1},${-1 * E * .33}
+    a${y * .8},${y * .8} 1 0,0 0,${-1 * E * .34}
+    a${y},${y} 1 0,0 ${C * .1},${-1 * E * .33}
+  H0 V0 Z`;
+	if (u.look === "handDrawn") {
+		let e = at.svg(p), l = userNodeOverrides(u, {}), d = e.path(k, l);
+		D = p.insert(() => d, ":first-child"), D.attr("class", "basic label-container").attr("style", handleUndefinedAttr(b));
+	} else D = p.insert("path", ":first-child").attr("class", "basic label-container").attr("style", f).attr("d", k);
+	return D.attr("transform", `translate(${-C / 2}, ${-E / 2})`), updateNodeBounds(u, D), u.calcIntersect = function(e, l) {
+		return intersect_default.rect(e, l);
+	}, u.intersect = function(e) {
+		return log.info("Bang intersect", u, e), intersect_default.rect(u, e);
+	}, p;
+}
+__name(bang, "bang");
+async function cloud(e, u) {
+	let { labelStyles: d, nodeStyles: f } = styles2String(u);
+	u.labelStyle = d;
+	let { shapeSvg: p, bbox: m, halfPadding: h, label: g } = await labelHelper(e, u, getNodeClasses(u)), _ = m.width + 2 * h, v = m.height + 2 * h, y = .15 * _, b = .25 * _, x = .35 * _, S = .2 * _, { cssStyles: C } = u, E, D = `M0 0 
+    a${y},${y} 0 0,1 ${_ * .25},${-1 * _ * .1}
+    a${x},${x} 1 0,1 ${_ * .4},${-1 * _ * .1}
+    a${b},${b} 1 0,1 ${_ * .35},${_ * .2}
+
+    a${y},${y} 1 0,1 ${_ * .15},${v * .35}
+    a${S},${S} 1 0,1 ${-1 * _ * .15},${v * .65}
+
+    a${b},${y} 1 0,1 ${-1 * _ * .25},${_ * .15}
+    a${x},${x} 1 0,1 ${-1 * _ * .5},0
+    a${y},${y} 1 0,1 ${-1 * _ * .25},${-1 * _ * .15}
+
+    a${y},${y} 1 0,1 ${-1 * _ * .1},${-1 * v * .35}
+    a${S},${S} 1 0,1 ${_ * .1},${-1 * v * .65}
+  H0 V0 Z`;
+	if (u.look === "handDrawn") {
+		let e = at.svg(p), l = userNodeOverrides(u, {}), d = e.path(D, l);
+		E = p.insert(() => d, ":first-child"), E.attr("class", "basic label-container").attr("style", handleUndefinedAttr(C));
+	} else E = p.insert("path", ":first-child").attr("class", "basic label-container").attr("style", f).attr("d", D);
+	return g.attr("transform", `translate(${-m.width / 2}, ${-m.height / 2})`), E.attr("transform", `translate(${-_ / 2}, ${-v / 2})`), updateNodeBounds(u, E), u.calcIntersect = function(e, l) {
+		return intersect_default.rect(e, l);
+	}, u.intersect = function(e) {
+		return log.info("Cloud intersect", u, e), intersect_default.rect(u, e);
+	}, p;
+}
+__name(cloud, "cloud");
+async function defaultMindmapNode(e, l) {
+	let { labelStyles: u, nodeStyles: d } = styles2String(l);
+	l.labelStyle = u;
+	let { shapeSvg: f, bbox: p, halfPadding: m, label: h } = await labelHelper(e, l, getNodeClasses(l)), g = p.width + 8 * m, _ = p.height + 2 * m, v = `
+    M${-g / 2} ${_ / 2 - 5}
+    v${-_ + 10}
+    q0,-5 5,-5
+    h${g - 10}
+    q5,0 5,5
+    v${_ - 10}
+    q0,5 -5,5
+    h${-g + 10}
+    q-5,0 -5,-5
+    Z
+  `, y = f.append("path").attr("id", "node-" + l.id).attr("class", "node-bkg node-" + l.type).attr("style", d).attr("d", v);
+	return f.append("line").attr("class", "node-line-").attr("x1", -g / 2).attr("y1", _ / 2).attr("x2", g / 2).attr("y2", _ / 2), h.attr("transform", `translate(${-p.width / 2}, ${-p.height / 2})`), f.append(() => h.node()), updateNodeBounds(l, y), l.calcIntersect = function(e, l) {
+		return intersect_default.rect(e, l);
+	}, l.intersect = function(e) {
+		return intersect_default.rect(l, e);
+	}, f;
+}
+__name(defaultMindmapNode, "defaultMindmapNode");
+async function mindmapCircle(e, l) {
+	return circle(e, l, { padding: l.padding ?? 0 });
+}
+__name(mindmapCircle, "mindmapCircle");
+var shapesDefs = [
+	{
+		semanticName: "Process",
+		name: "Rectangle",
+		shortName: "rect",
+		description: "Standard process shape",
+		aliases: [
+			"proc",
+			"process",
+			"rectangle"
+		],
+		internalAliases: ["squareRect"],
+		handler: squareRect2
+	},
+	{
+		semanticName: "Event",
+		name: "Rounded Rectangle",
+		shortName: "rounded",
+		description: "Represents an event",
+		aliases: ["event"],
+		internalAliases: ["roundedRect"],
+		handler: roundedRect
+	},
+	{
+		semanticName: "Terminal Point",
+		name: "Stadium",
+		shortName: "stadium",
+		description: "Terminal point",
+		aliases: ["terminal", "pill"],
+		handler: stadium
+	},
+	{
+		semanticName: "Subprocess",
+		name: "Framed Rectangle",
+		shortName: "fr-rect",
+		description: "Subprocess",
+		aliases: [
+			"subprocess",
+			"subproc",
+			"framed-rectangle",
+			"subroutine"
+		],
+		handler: subroutine
+	},
+	{
+		semanticName: "Database",
+		name: "Cylinder",
+		shortName: "cyl",
+		description: "Database storage",
+		aliases: [
+			"db",
+			"database",
+			"cylinder"
+		],
+		handler: cylinder
+	},
+	{
+		semanticName: "Start",
+		name: "Circle",
+		shortName: "circle",
+		description: "Starting point",
+		aliases: ["circ"],
+		handler: circle
+	},
+	{
+		semanticName: "Bang",
+		name: "Bang",
+		shortName: "bang",
+		description: "Bang",
+		aliases: ["bang"],
+		handler: bang
+	},
+	{
+		semanticName: "Cloud",
+		name: "Cloud",
+		shortName: "cloud",
+		description: "cloud",
+		aliases: ["cloud"],
+		handler: cloud
+	},
+	{
+		semanticName: "Decision",
+		name: "Diamond",
+		shortName: "diam",
+		description: "Decision-making step",
+		aliases: [
+			"decision",
+			"diamond",
+			"question"
+		],
+		handler: question
+	},
+	{
+		semanticName: "Prepare Conditional",
+		name: "Hexagon",
+		shortName: "hex",
+		description: "Preparation or condition step",
+		aliases: ["hexagon", "prepare"],
+		handler: hexagon
+	},
+	{
+		semanticName: "Data Input/Output",
+		name: "Lean Right",
+		shortName: "lean-r",
+		description: "Represents input or output",
+		aliases: ["lean-right", "in-out"],
+		internalAliases: ["lean_right"],
+		handler: lean_right
+	},
+	{
+		semanticName: "Data Input/Output",
+		name: "Lean Left",
+		shortName: "lean-l",
+		description: "Represents output or input",
+		aliases: ["lean-left", "out-in"],
+		internalAliases: ["lean_left"],
+		handler: lean_left
+	},
+	{
+		semanticName: "Priority Action",
+		name: "Trapezoid Base Bottom",
+		shortName: "trap-b",
+		description: "Priority action",
+		aliases: [
+			"priority",
+			"trapezoid-bottom",
+			"trapezoid"
+		],
+		handler: trapezoid
+	},
+	{
+		semanticName: "Manual Operation",
+		name: "Trapezoid Base Top",
+		shortName: "trap-t",
+		description: "Represents a manual task",
+		aliases: [
+			"manual",
+			"trapezoid-top",
+			"inv-trapezoid"
+		],
+		internalAliases: ["inv_trapezoid"],
+		handler: inv_trapezoid
+	},
+	{
+		semanticName: "Stop",
+		name: "Double Circle",
+		shortName: "dbl-circ",
+		description: "Represents a stop point",
+		aliases: ["double-circle"],
+		internalAliases: ["doublecircle"],
+		handler: doublecircle
+	},
+	{
+		semanticName: "Text Block",
+		name: "Text Block",
+		shortName: "text",
+		description: "Text block",
+		handler: text
+	},
+	{
+		semanticName: "Card",
+		name: "Notched Rectangle",
+		shortName: "notch-rect",
+		description: "Represents a card",
+		aliases: ["card", "notched-rectangle"],
+		handler: card
+	},
+	{
+		semanticName: "Lined/Shaded Process",
+		name: "Lined Rectangle",
+		shortName: "lin-rect",
+		description: "Lined process shape",
+		aliases: [
+			"lined-rectangle",
+			"lined-process",
+			"lin-proc",
+			"shaded-process"
+		],
+		handler: shadedProcess
+	},
+	{
+		semanticName: "Start",
+		name: "Small Circle",
+		shortName: "sm-circ",
+		description: "Small starting point",
+		aliases: ["start", "small-circle"],
+		internalAliases: ["stateStart"],
+		handler: stateStart
+	},
+	{
+		semanticName: "Stop",
+		name: "Framed Circle",
+		shortName: "fr-circ",
+		description: "Stop point",
+		aliases: ["stop", "framed-circle"],
+		internalAliases: ["stateEnd"],
+		handler: stateEnd
+	},
+	{
+		semanticName: "Fork/Join",
+		name: "Filled Rectangle",
+		shortName: "fork",
+		description: "Fork or join in process flow",
+		aliases: ["join"],
+		internalAliases: ["forkJoin"],
+		handler: forkJoin
+	},
+	{
+		semanticName: "Collate",
+		name: "Hourglass",
+		shortName: "hourglass",
+		description: "Represents a collate operation",
+		aliases: ["hourglass", "collate"],
+		handler: hourglass
+	},
+	{
+		semanticName: "Comment",
+		name: "Curly Brace",
+		shortName: "brace",
+		description: "Adds a comment",
+		aliases: ["comment", "brace-l"],
+		handler: curlyBraceLeft
+	},
+	{
+		semanticName: "Comment Right",
+		name: "Curly Brace",
+		shortName: "brace-r",
+		description: "Adds a comment",
+		handler: curlyBraceRight
+	},
+	{
+		semanticName: "Comment with braces on both sides",
+		name: "Curly Braces",
+		shortName: "braces",
+		description: "Adds a comment",
+		handler: curlyBraces
+	},
+	{
+		semanticName: "Com Link",
+		name: "Lightning Bolt",
+		shortName: "bolt",
+		description: "Communication link",
+		aliases: ["com-link", "lightning-bolt"],
+		handler: lightningBolt
+	},
+	{
+		semanticName: "Document",
+		name: "Document",
+		shortName: "doc",
+		description: "Represents a document",
+		aliases: ["doc", "document"],
+		handler: waveEdgedRectangle
+	},
+	{
+		semanticName: "Delay",
+		name: "Half-Rounded Rectangle",
+		shortName: "delay",
+		description: "Represents a delay",
+		aliases: ["half-rounded-rectangle"],
+		handler: halfRoundedRectangle
+	},
+	{
+		semanticName: "Direct Access Storage",
+		name: "Horizontal Cylinder",
+		shortName: "h-cyl",
+		description: "Direct access storage",
+		aliases: ["das", "horizontal-cylinder"],
+		handler: tiltedCylinder
+	},
+	{
+		semanticName: "Disk Storage",
+		name: "Lined Cylinder",
+		shortName: "lin-cyl",
+		description: "Disk storage",
+		aliases: ["disk", "lined-cylinder"],
+		handler: linedCylinder
+	},
+	{
+		semanticName: "Display",
+		name: "Curved Trapezoid",
+		shortName: "curv-trap",
+		description: "Represents a display",
+		aliases: ["curved-trapezoid", "display"],
+		handler: curvedTrapezoid
+	},
+	{
+		semanticName: "Divided Process",
+		name: "Divided Rectangle",
+		shortName: "div-rect",
+		description: "Divided process shape",
+		aliases: [
+			"div-proc",
+			"divided-rectangle",
+			"divided-process"
+		],
+		handler: dividedRectangle
+	},
+	{
+		semanticName: "Extract",
+		name: "Triangle",
+		shortName: "tri",
+		description: "Extraction process",
+		aliases: ["extract", "triangle"],
+		handler: triangle
+	},
+	{
+		semanticName: "Internal Storage",
+		name: "Window Pane",
+		shortName: "win-pane",
+		description: "Internal storage",
+		aliases: ["internal-storage", "window-pane"],
+		handler: windowPane
+	},
+	{
+		semanticName: "Junction",
+		name: "Filled Circle",
+		shortName: "f-circ",
+		description: "Junction point",
+		aliases: ["junction", "filled-circle"],
+		handler: filledCircle
+	},
+	{
+		semanticName: "Loop Limit",
+		name: "Trapezoidal Pentagon",
+		shortName: "notch-pent",
+		description: "Loop limit step",
+		aliases: ["loop-limit", "notched-pentagon"],
+		handler: trapezoidalPentagon
+	},
+	{
+		semanticName: "Manual File",
+		name: "Flipped Triangle",
+		shortName: "flip-tri",
+		description: "Manual file operation",
+		aliases: ["manual-file", "flipped-triangle"],
+		handler: flippedTriangle
+	},
+	{
+		semanticName: "Manual Input",
+		name: "Sloped Rectangle",
+		shortName: "sl-rect",
+		description: "Manual input step",
+		aliases: ["manual-input", "sloped-rectangle"],
+		handler: slopedRect
+	},
+	{
+		semanticName: "Multi-Document",
+		name: "Stacked Document",
+		shortName: "docs",
+		description: "Multiple documents",
+		aliases: [
+			"documents",
+			"st-doc",
+			"stacked-document"
+		],
+		handler: multiWaveEdgedRectangle
+	},
+	{
+		semanticName: "Multi-Process",
+		name: "Stacked Rectangle",
+		shortName: "st-rect",
+		description: "Multiple processes",
+		aliases: [
+			"procs",
+			"processes",
+			"stacked-rectangle"
+		],
+		handler: multiRect
+	},
+	{
+		semanticName: "Stored Data",
+		name: "Bow Tie Rectangle",
+		shortName: "bow-rect",
+		description: "Stored data",
+		aliases: ["stored-data", "bow-tie-rectangle"],
+		handler: bowTieRect
+	},
+	{
+		semanticName: "Summary",
+		name: "Crossed Circle",
+		shortName: "cross-circ",
+		description: "Summary",
+		aliases: ["summary", "crossed-circle"],
+		handler: crossedCircle
+	},
+	{
+		semanticName: "Tagged Document",
+		name: "Tagged Document",
+		shortName: "tag-doc",
+		description: "Tagged document",
+		aliases: ["tag-doc", "tagged-document"],
+		handler: taggedWaveEdgedRectangle
+	},
+	{
+		semanticName: "Tagged Process",
+		name: "Tagged Rectangle",
+		shortName: "tag-rect",
+		description: "Tagged process",
+		aliases: [
+			"tagged-rectangle",
+			"tag-proc",
+			"tagged-process"
+		],
+		handler: taggedRect
+	},
+	{
+		semanticName: "Paper Tape",
+		name: "Flag",
+		shortName: "flag",
+		description: "Paper tape",
+		aliases: ["paper-tape"],
+		handler: waveRectangle
+	},
+	{
+		semanticName: "Odd",
+		name: "Odd",
+		shortName: "odd",
+		description: "Odd shape",
+		internalAliases: ["rect_left_inv_arrow"],
+		handler: rect_left_inv_arrow
+	},
+	{
+		semanticName: "Lined Document",
+		name: "Lined Document",
+		shortName: "lin-doc",
+		description: "Lined document",
+		aliases: ["lined-document"],
+		handler: linedWaveEdgedRect
+	}
+], shapes2 = (/* @__PURE__ */ __name(() => {
+	let e = {
+		state,
+		choice,
+		note,
+		rectWithTitle,
+		labelRect,
+		iconSquare,
+		iconCircle,
+		icon,
+		iconRounded,
+		imageSquare,
+		anchor,
+		kanbanItem,
+		mindmapCircle,
+		defaultMindmapNode,
+		classBox,
+		erBox,
+		requirementBox
+	}, l = [...Object.entries(e), ...shapesDefs.flatMap((e) => [
+		e.shortName,
+		..."aliases" in e ? e.aliases : [],
+		..."internalAliases" in e ? e.internalAliases : []
+	].map((l) => [l, e.handler]))];
+	return Object.fromEntries(l);
+}, "generateShapeMap"))();
+function isValidShape(e) {
+	return e in shapes2;
+}
+__name(isValidShape, "isValidShape");
+var nodeElems = /* @__PURE__ */ new Map();
+async function insertNode(e, l, u) {
+	let d, f;
+	l.shape === "rect" && (l.rx && l.ry ? l.shape = "roundedRect" : l.shape = "squareRect");
+	let p = l.shape ? shapes2[l.shape] : void 0;
+	if (!p) throw Error(`No such shape: ${l.shape}. Please check your syntax.`);
+	if (l.link) {
+		let m;
+		u.config.securityLevel === "sandbox" ? m = "_top" : l.linkTarget && (m = l.linkTarget || "_blank"), d = e.insert("svg:a").attr("xlink:href", l.link).attr("target", m ?? null), f = await p(d, l, u);
+	} else f = await p(e, l, u), d = f;
+	return l.tooltip && f.attr("title", l.tooltip), nodeElems.set(l.id, d), l.haveCallback && d.attr("class", d.attr("class") + " clickable"), d;
+}
+__name(insertNode, "insertNode");
+var setNodeElem = /* @__PURE__ */ __name((e, l) => {
+	nodeElems.set(l.id, e);
+}, "setNodeElem"), clear2 = /* @__PURE__ */ __name(() => {
+	nodeElems.clear();
+}, "clear"), positionNode = /* @__PURE__ */ __name((e) => {
+	let u = nodeElems.get(e.id);
+	log.trace("Transforming node", e.diff, e, "translate(" + (e.x - e.width / 2 - 5) + ", " + e.width / 2 + ")");
+	let d = e.diff || 0;
+	return e.clusterNode ? u.attr("transform", "translate(" + (e.x + d - e.width / 2) + ", " + (e.y - e.height / 2 - 8) + ")") : u.attr("transform", "translate(" + e.x + ", " + e.y + ")"), d;
+}, "positionNode");
+export { clear, clear2, createLabel_default, insertCluster, insertNode, isValidShape, labelHelper, positionNode, setNodeElem, updateNodeBounds };