@loopstack/loopstack-studio 0.25.0 → 0.25.2

package/dist/node_modules/mermaid/dist/chunks/mermaid.core/chunk-5FUZZQ4R.js

@@ -0,0 +1,3638 @@
+import { __name, log } from "./chunk-AGHRB4JF.js";
+import { evaluate, getConfig, getConfig2, getEffectiveHtmlLabels, hasKatex, parseGenericTypes, sanitizeText, sanitizeText3 } from "./chunk-ICPOFSXX.js";
+import select_default from "../../../../d3-selection/src/select.js";
+import "../../../../d3/src/index.js";
+import { calculateTextWidth, decodeEntities, handleUndefinedAttr } from "./chunk-5PVQY5BW.js";
+import { configureLabelImages, getSubGraphTitleMargins } from "./chunk-ZZ45TVLE.js";
+import { compileStyles, solidStateFill, styles2String, userNodeOverrides } from "./chunk-X2U36JSP.js";
+import { createText, getIconSVG } from "./chunk-U2HBQHQK.js";
+import { at } from "../../../../roughjs/bundled/rough.esm.js";
+var labelHelper = /* @__PURE__ */ __name(async (e, a, s) => {
+	let l, u = a.useHtmlLabels || evaluate(getConfig2()?.htmlLabels);
+	l = s || "node default";
+	let d = e.insert("g").attr("class", l).attr("id", a.domId || a.id), p = d.insert("g").attr("class", "label").attr("style", handleUndefinedAttr(a.labelStyle)), h;
+	h = a.label === void 0 ? "" : typeof a.label == "string" ? a.label : a.label[0];
+	let y = !!a.icon || !!a.img, b = a.labelType === "markdown", x = await createText(p, sanitizeText(decodeEntities(h), getConfig2()), {
+		useHtmlLabels: u,
+		width: a.width || getConfig2().flowchart?.wrappingWidth,
+		classes: b ? "markdown-node-label" : "",
+		style: a.labelStyle,
+		addSvgBackground: y,
+		markdown: b
+	}, getConfig2()), S = x.getBBox(), C = (a?.padding ?? 0) / 2;
+	if (u) {
+		let e = x.children[0], a = select_default(x);
+		await configureLabelImages(e, h), S = e.getBoundingClientRect(), a.attr("width", S.width), a.attr("height", S.height);
+	}
+	return u ? p.attr("transform", "translate(" + -S.width / 2 + ", " + -S.height / 2 + ")") : p.attr("transform", "translate(0, " + -S.height / 2 + ")"), a.centerLabel && p.attr("transform", "translate(" + -S.width / 2 + ", " + -S.height / 2 + ")"), p.insert("rect", ":first-child"), {
+		shapeSvg: d,
+		bbox: S,
+		halfPadding: C,
+		label: p
+	};
+}, "labelHelper"), insertLabel = /* @__PURE__ */ __name(async (e, a, o) => {
+	let s = o.useHtmlLabels ?? getEffectiveHtmlLabels(getConfig2()), u = e.insert("g").attr("class", "label").attr("style", o.labelStyle || ""), d = await createText(u, sanitizeText(decodeEntities(a), getConfig2()), {
+		useHtmlLabels: s,
+		width: o.width || getConfig2()?.flowchart?.wrappingWidth,
+		style: o.labelStyle,
+		addSvgBackground: !!o.icon || !!o.img
+	}), p = d.getBBox(), h = o.padding / 2;
+	if (getEffectiveHtmlLabels(getConfig2())) {
+		let e = d.children[0], a = select_default(d);
+		p = e.getBoundingClientRect(), a.attr("width", p.width), a.attr("height", p.height);
+	}
+	return s ? u.attr("transform", "translate(" + -p.width / 2 + ", " + -p.height / 2 + ")") : u.attr("transform", "translate(0, " + -p.height / 2 + ")"), o.centerLabel && u.attr("transform", "translate(" + -p.width / 2 + ", " + -p.height / 2 + ")"), u.insert("rect", ":first-child"), {
+		shapeSvg: e,
+		bbox: p,
+		halfPadding: h,
+		label: u
+	};
+}, "insertLabel"), updateNodeBounds = /* @__PURE__ */ __name((e, a) => {
+	let o = a.node().getBBox();
+	e.width = o.width, e.height = o.height;
+}, "updateNodeBounds"), getNodeClasses = /* @__PURE__ */ __name((e, a) => (e.look === "handDrawn" ? "rough-node" : "node") + " " + e.cssClasses + " " + (a || ""), "getNodeClasses");
+function createPathFromPoints(e) {
+	let a = e.map((e, a) => `${a === 0 ? "M" : "L"}${e.x},${e.y}`);
+	return a.push("Z"), a.join(" ");
+}
+__name(createPathFromPoints, "createPathFromPoints");
+function generateFullSineWavePoints(e, a, o, s, c, l) {
+	let u = [], d = o - e, f = s - a, p = d / l, m = 2 * Math.PI / p, h = a + f / 2;
+	for (let a = 0; a <= 50; a++) {
+		let o = e + a / 50 * d, s = h + c * Math.sin(m * (o - e));
+		u.push({
+			x: o,
+			y: s
+		});
+	}
+	return u;
+}
+__name(generateFullSineWavePoints, "generateFullSineWavePoints");
+function generateCirclePoints(e, a, o, s, c, l) {
+	let u = [], d = c * Math.PI / 180, f = (l * Math.PI / 180 - d) / (s - 1);
+	for (let c = 0; c < s; c++) {
+		let s = d + c * f, l = e + o * Math.cos(s), p = a + o * Math.sin(s);
+		u.push({
+			x: -l,
+			y: -p
+		});
+	}
+	return u;
+}
+__name(generateCirclePoints, "generateCirclePoints");
+function mergePaths(a) {
+	let o = Array.from(a.childNodes).filter((e) => e.tagName === "path"), s = document.createElementNS("http://www.w3.org/2000/svg", "path"), c = o.map((e) => e.getAttribute("d")).filter((e) => e !== null).join(" ");
+	s.setAttribute("d", c);
+	let l = o.find((e) => e.getAttribute("fill") !== "none"), u = o.find((e) => e.getAttribute("stroke") !== "none"), d = /* @__PURE__ */ __name((e, a) => e?.getAttribute(a) ?? void 0, "getAttr");
+	if (l) {
+		let e = {
+			fill: d(l, "fill"),
+			"fill-opacity": d(l, "fill-opacity") ?? "1"
+		};
+		Object.entries(e).forEach(([e, a]) => {
+			a && s.setAttribute(e, a);
+		});
+	}
+	if (u) {
+		let e = {
+			stroke: d(u, "stroke"),
+			"stroke-width": d(u, "stroke-width") ?? "1",
+			"stroke-opacity": d(u, "stroke-opacity") ?? "1"
+		};
+		Object.entries(e).forEach(([e, a]) => {
+			a && s.setAttribute(e, a);
+		});
+	}
+	let f = document.createElementNS("http://www.w3.org/2000/svg", "g");
+	return f.appendChild(s), f;
+}
+__name(mergePaths, "mergePaths");
+var intersect_rect_default = /* @__PURE__ */ __name((e, a) => {
+	var o = e.x, s = e.y, c = a.x - o, l = a.y - s, u = e.width / 2, d = e.height / 2, f, p;
+	return Math.abs(l) * u > Math.abs(c) * d ? (l < 0 && (d = -d), f = l === 0 ? 0 : d * c / l, p = d) : (c < 0 && (u = -u), f = u, p = c === 0 ? 0 : u * l / c), {
+		x: o + f,
+		y: s + p
+	};
+}, "intersectRect"), createLabel_default = /* @__PURE__ */ __name(async (e, a, o, s = !1, u = !1) => {
+	let d = a || "";
+	typeof d == "object" && (d = d[0]);
+	let f = getConfig2(), p = getEffectiveHtmlLabels(f);
+	return await createText(e, d, {
+		style: o,
+		isTitle: s,
+		useHtmlLabels: p,
+		markdown: !1,
+		isNode: u,
+		width: Infinity
+	}, f);
+}, "createLabel"), createRoundedRectPathD = /* @__PURE__ */ __name((e, a, o, s, c) => [
+	"M",
+	e + c,
+	a,
+	"H",
+	e + o - c,
+	"A",
+	c,
+	c,
+	0,
+	0,
+	1,
+	e + o,
+	a + c,
+	"V",
+	a + s - c,
+	"A",
+	c,
+	c,
+	0,
+	0,
+	1,
+	e + o - c,
+	a + s,
+	"H",
+	e + c,
+	"A",
+	c,
+	c,
+	0,
+	0,
+	1,
+	e,
+	a + s - c,
+	"V",
+	a + c,
+	"A",
+	c,
+	c,
+	0,
+	0,
+	1,
+	e + c,
+	a,
+	"Z"
+].join(" "), "createRoundedRectPathD"), rect = /* @__PURE__ */ __name(async (e, o) => {
+	log.info("Creating subgraph rect for ", o.id, o);
+	let s = getConfig2(), { themeVariables: u, handDrawnSeed: d } = s, { clusterBkg: f, clusterBorder: p } = u, { labelStyles: h, nodeStyles: g, borderStyles: _, backgroundStyles: v } = styles2String(o), b = e.insert("g").attr("class", "cluster " + o.cssClasses).attr("id", o.domId).attr("data-look", o.look), x = getEffectiveHtmlLabels(s), T = b.insert("g").attr("class", "cluster-label "), E;
+	E = o.labelType === "markdown" ? await createText(T, o.label, {
+		style: o.labelStyle,
+		useHtmlLabels: x,
+		isNode: !0,
+		width: o.width
+	}) : await createLabel_default(T, o.label, o.labelStyle || "", !1, !0);
+	let D = E.getBBox();
+	if (getEffectiveHtmlLabels(s)) {
+		let e = E.children[0], a = select_default(E);
+		D = e.getBoundingClientRect(), a.attr("width", D.width), a.attr("height", D.height);
+	}
+	let O = o.width <= D.width + o.padding ? D.width + o.padding : o.width;
+	o.width <= D.width + o.padding ? o.diff = (O - o.width) / 2 - o.padding : o.diff = -o.padding;
+	let k = o.height, A = o.x - O / 2, j = o.y - k / 2;
+	log.trace("Data ", o, JSON.stringify(o));
+	let M;
+	if (o.look === "handDrawn") {
+		let e = at.svg(b), s = userNodeOverrides(o, {
+			roughness: .7,
+			fill: f,
+			stroke: p,
+			fillWeight: 3,
+			seed: d
+		}), c = e.path(createRoundedRectPathD(A, j, O, k, 0), s);
+		M = b.insert(() => (log.debug("Rough node insert CXC", c), c), ":first-child"), M.select("path:nth-child(2)").attr("style", _.join(";")), M.select("path").attr("style", v.join(";").replace("fill", "stroke"));
+	} else M = b.insert("rect", ":first-child"), M.attr("style", g).attr("rx", o.rx).attr("ry", o.ry).attr("x", A).attr("y", j).attr("width", O).attr("height", k);
+	let { subGraphTitleTopMargin: N } = getSubGraphTitleMargins(s);
+	if (T.attr("transform", `translate(${o.x - D.width / 2}, ${o.y - o.height / 2 + N})`), h) {
+		let e = T.select("span");
+		e && e.attr("style", h);
+	}
+	let L = M.node().getBBox();
+	return o.offsetX = 0, o.width = L.width, o.height = L.height, o.offsetY = D.height - o.padding / 2, o.intersect = function(e) {
+		return intersect_rect_default(o, e);
+	}, {
+		cluster: b,
+		labelBBox: D
+	};
+}, "rect"), shapes = {
+	rect,
+	squareRect: rect,
+	roundedWithTitle: /* @__PURE__ */ __name(async (e, a) => {
+		let o = getConfig2(), { themeVariables: s, handDrawnSeed: u } = o, { altBackground: d, compositeBackground: f, compositeTitleBackground: p, nodeBorder: h } = s, g = e.insert("g").attr("class", a.cssClasses).attr("id", a.domId).attr("data-id", a.id).attr("data-look", a.look), _ = g.insert("g", ":first-child"), v = g.insert("g").attr("class", "cluster-label"), y = g.append("rect"), b = await createLabel_default(v, a.label, a.labelStyle, void 0, !0), x = b.getBBox();
+		if (getEffectiveHtmlLabels(o)) {
+			let e = b.children[0], a = select_default(b);
+			x = e.getBoundingClientRect(), a.attr("width", x.width), a.attr("height", x.height);
+		}
+		let S = 0 * a.padding, C = S / 2, w = (a.width <= x.width + a.padding ? x.width + a.padding : a.width) + S;
+		a.width <= x.width + a.padding ? a.diff = (w - a.width) / 2 - a.padding : a.diff = -a.padding;
+		let T = a.height + S, E = a.height + S - x.height - 6, D = a.x - w / 2, O = a.y - T / 2;
+		a.width = w;
+		let k = a.y - a.height / 2 - C + x.height + 2, A;
+		if (a.look === "handDrawn") {
+			let e = a.cssClasses.includes("statediagram-cluster-alt"), o = at.svg(g), s = a.rx || a.ry ? o.path(createRoundedRectPathD(D, O, w, T, 10), {
+				roughness: .7,
+				fill: p,
+				fillStyle: "solid",
+				stroke: h,
+				seed: u
+			}) : o.rectangle(D, O, w, T, { seed: u });
+			A = g.insert(() => s, ":first-child");
+			let c = o.rectangle(D, k, w, E, {
+				fill: e ? d : f,
+				fillStyle: e ? "hachure" : "solid",
+				stroke: h,
+				seed: u
+			});
+			A = g.insert(() => s, ":first-child"), y = g.insert(() => c);
+		} else A = _.insert("rect", ":first-child"), A.attr("class", "outer").attr("x", D).attr("y", O).attr("width", w).attr("height", T).attr("data-look", a.look), y.attr("class", "inner").attr("x", D).attr("y", k).attr("width", w).attr("height", E);
+		return v.attr("transform", `translate(${a.x - x.width / 2}, ${O + 1 - (getEffectiveHtmlLabels(o) ? 0 : 3)})`), a.height = A.node().getBBox().height, a.offsetX = 0, a.offsetY = x.height - a.padding / 2, a.labelBBox = x, a.intersect = function(e) {
+			return intersect_rect_default(a, e);
+		}, {
+			cluster: g,
+			labelBBox: x
+		};
+	}, "roundedWithTitle"),
+	noteGroup: /* @__PURE__ */ __name((e, a) => {
+		let o = e.insert("g").attr("class", "note-cluster").attr("id", a.domId), s = o.insert("rect", ":first-child"), c = 0 * a.padding, l = c / 2;
+		s.attr("rx", a.rx).attr("ry", a.ry).attr("x", a.x - a.width / 2 - l).attr("y", a.y - a.height / 2 - l).attr("width", a.width + c).attr("height", a.height + c).attr("fill", "none");
+		let u = s.node().getBBox();
+		return a.width = u.width, a.height = u.height, a.intersect = function(e) {
+			return intersect_rect_default(a, e);
+		}, {
+			cluster: o,
+			labelBBox: {
+				width: 0,
+				height: 0
+			}
+		};
+	}, "noteGroup"),
+	divider: /* @__PURE__ */ __name((e, a) => {
+		let { themeVariables: o, handDrawnSeed: s } = getConfig2(), { nodeBorder: l } = o, u = e.insert("g").attr("class", a.cssClasses).attr("id", a.domId).attr("data-look", a.look), d = u.insert("g", ":first-child"), f = 0 * a.padding, p = a.width + f;
+		a.diff = -a.padding;
+		let m = a.height + f, h = a.x - p / 2, g = a.y - m / 2;
+		a.width = p;
+		let _;
+		if (a.look === "handDrawn") {
+			let e = at.svg(u).rectangle(h, g, p, m, {
+				fill: "lightgrey",
+				roughness: .5,
+				strokeLineDash: [5],
+				stroke: l,
+				seed: s
+			});
+			_ = u.insert(() => e, ":first-child");
+		} else {
+			_ = d.insert("rect", ":first-child");
+			let e = "outer";
+			e = (a.look, "divider"), _.attr("class", e).attr("x", h).attr("y", g).attr("width", p).attr("height", m).attr("data-look", a.look);
+		}
+		return a.height = _.node().getBBox().height, a.offsetX = 0, a.offsetY = 0, a.intersect = function(e) {
+			return intersect_rect_default(a, e);
+		}, {
+			cluster: u,
+			labelBBox: {}
+		};
+	}, "divider"),
+	kanbanSection: /* @__PURE__ */ __name(async (e, o) => {
+		log.info("Creating subgraph rect for ", o.id, o);
+		let s = getConfig2(), { themeVariables: u, handDrawnSeed: d } = s, { clusterBkg: f, clusterBorder: p } = u, { labelStyles: h, nodeStyles: g, borderStyles: _, backgroundStyles: v } = styles2String(o), b = e.insert("g").attr("class", "cluster " + o.cssClasses).attr("id", o.domId).attr("data-look", o.look), x = getEffectiveHtmlLabels(s), T = b.insert("g").attr("class", "cluster-label "), E = await createText(T, o.label, {
+			style: o.labelStyle,
+			useHtmlLabels: x,
+			isNode: !0,
+			width: o.width
+		}), D = E.getBBox();
+		if (getEffectiveHtmlLabels(s)) {
+			let e = E.children[0], a = select_default(E);
+			D = e.getBoundingClientRect(), a.attr("width", D.width), a.attr("height", D.height);
+		}
+		let O = o.width <= D.width + o.padding ? D.width + o.padding : o.width;
+		o.width <= D.width + o.padding ? o.diff = (O - o.width) / 2 - o.padding : o.diff = -o.padding;
+		let k = o.height, A = o.x - O / 2, j = o.y - k / 2;
+		log.trace("Data ", o, JSON.stringify(o));
+		let M;
+		if (o.look === "handDrawn") {
+			let e = at.svg(b), s = userNodeOverrides(o, {
+				roughness: .7,
+				fill: f,
+				stroke: p,
+				fillWeight: 4,
+				seed: d
+			}), c = e.path(createRoundedRectPathD(A, j, O, k, o.rx), s);
+			M = b.insert(() => (log.debug("Rough node insert CXC", c), c), ":first-child"), M.select("path:nth-child(2)").attr("style", _.join(";")), M.select("path").attr("style", v.join(";").replace("fill", "stroke"));
+		} else M = b.insert("rect", ":first-child"), M.attr("style", g).attr("rx", o.rx).attr("ry", o.ry).attr("x", A).attr("y", j).attr("width", O).attr("height", k);
+		let { subGraphTitleTopMargin: N } = getSubGraphTitleMargins(s);
+		if (T.attr("transform", `translate(${o.x - D.width / 2}, ${o.y - o.height / 2 + N})`), h) {
+			let e = T.select("span");
+			e && e.attr("style", h);
+		}
+		let F = M.node().getBBox();
+		return o.offsetX = 0, o.width = F.width, o.height = F.height, o.offsetY = D.height - o.padding / 2, o.intersect = function(e) {
+			return intersect_rect_default(o, e);
+		}, {
+			cluster: b,
+			labelBBox: D
+		};
+	}, "kanbanSection")
+}, clusterElems = /* @__PURE__ */ new Map(), insertCluster = /* @__PURE__ */ __name(async (e, a) => {
+	let o = await shapes[a.shape || "rect"](e, a);
+	return clusterElems.set(a.id, o), o;
+}, "insertCluster"), clear = /* @__PURE__ */ __name(() => {
+	clusterElems = /* @__PURE__ */ new Map();
+}, "clear");
+function intersectNode(e, a) {
+	return e.intersect(a);
+}
+__name(intersectNode, "intersectNode");
+var intersect_node_default = intersectNode;
+function intersectEllipse(e, a, o, s) {
+	var c = e.x, l = e.y, u = c - s.x, d = l - s.y, f = Math.sqrt(a * a * d * d + o * o * u * u), p = Math.abs(a * o * u / f);
+	s.x < c && (p = -p);
+	var m = Math.abs(a * o * d / f);
+	return s.y < l && (m = -m), {
+		x: c + p,
+		y: l + m
+	};
+}
+__name(intersectEllipse, "intersectEllipse");
+var intersect_ellipse_default = intersectEllipse;
+function intersectCircle(e, a, o) {
+	return intersect_ellipse_default(e, a, a, o);
+}
+__name(intersectCircle, "intersectCircle");
+var intersect_circle_default = intersectCircle;
+function intersectLine(e, a, o, s) {
+	{
+		let c = a.y - e.y, l = e.x - a.x, u = a.x * e.y - e.x * a.y, d = c * o.x + l * o.y + u, f = c * s.x + l * s.y + u, p = 1e-6;
+		if (d !== 0 && f !== 0 && sameSign(d, f)) return;
+		let m = s.y - o.y, h = o.x - s.x, g = s.x * o.y - o.x * s.y, _ = m * e.x + h * e.y + g, v = m * a.x + h * a.y + g;
+		if (Math.abs(_) < p && Math.abs(v) < p && sameSign(_, v)) return;
+		let y = c * h - m * l;
+		if (y === 0) return;
+		let b = Math.abs(y / 2), x = l * g - h * u, S = x < 0 ? (x - b) / y : (x + b) / y;
+		return x = m * u - c * g, {
+			x: S,
+			y: x < 0 ? (x - b) / y : (x + b) / y
+		};
+	}
+}
+__name(intersectLine, "intersectLine");
+function sameSign(e, a) {
+	return e * a > 0;
+}
+__name(sameSign, "sameSign");
+var intersect_line_default = intersectLine;
+function intersectPolygon(e, a, o) {
+	let s = e.x, c = e.y, l = [], u = Infinity, d = Infinity;
+	typeof a.forEach == "function" ? a.forEach(function(e) {
+		u = Math.min(u, e.x), d = Math.min(d, e.y);
+	}) : (u = Math.min(u, a.x), d = Math.min(d, a.y));
+	let f = s - e.width / 2 - u, p = c - e.height / 2 - d;
+	for (let s = 0; s < a.length; s++) {
+		let c = a[s], u = a[s < a.length - 1 ? s + 1 : 0], d = intersect_line_default(e, o, {
+			x: f + c.x,
+			y: p + c.y
+		}, {
+			x: f + u.x,
+			y: p + u.y
+		});
+		d && l.push(d);
+	}
+	return l.length ? (l.length > 1 && l.sort(function(e, a) {
+		let s = e.x - o.x, c = e.y - o.y, l = Math.sqrt(s * s + c * c), u = a.x - o.x, d = a.y - o.y, f = Math.sqrt(u * u + d * d);
+		return l < f ? -1 : l === f ? 0 : 1;
+	}), l[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, o) {
+	let { labelStyles: s } = styles2String(o);
+	o.labelStyle = s;
+	let c = getNodeClasses(o), l = c;
+	c || (l = "anchor");
+	let u = e.insert("g").attr("class", l).attr("id", o.domId || o.id), { cssStyles: d } = o, f = at.svg(u), p = userNodeOverrides(o, {
+		fill: "black",
+		stroke: "none",
+		fillStyle: "solid"
+	});
+	o.look !== "handDrawn" && (p.roughness = 0);
+	let m = f.circle(0, 0, 2, p), h = u.insert(() => m, ":first-child");
+	return h.attr("class", "anchor").attr("style", handleUndefinedAttr(d)), updateNodeBounds(o, h), o.intersect = function(e) {
+		return log.info("Circle intersect", o, 1, e), intersect_default.circle(o, 1, e);
+	}, u;
+}
+__name(anchor, "anchor");
+function generateArcPoints(e, a, o, s, c, l, u) {
+	let d = (e + o) / 2, f = (a + s) / 2, p = Math.atan2(s - a, o - e), m = (o - e) / 2, h = (s - a) / 2, g = m / c, _ = h / l, v = Math.sqrt(g ** 2 + _ ** 2);
+	if (v > 1) throw Error("The given radii are too small to create an arc between the points.");
+	let y = Math.sqrt(1 - v ** 2), b = d + y * l * Math.sin(p) * (u ? -1 : 1), x = f - y * c * Math.cos(p) * (u ? -1 : 1), S = Math.atan2((a - x) / l, (e - b) / c), C = Math.atan2((s - x) / l, (o - b) / c) - S;
+	u && C < 0 && (C += 2 * Math.PI), !u && C > 0 && (C -= 2 * Math.PI);
+	let w = [];
+	for (let e = 0; e < 20; e++) {
+		let a = S + e / 19 * C, o = b + c * Math.cos(a), s = x + l * Math.sin(a);
+		w.push({
+			x: o,
+			y: s
+		});
+	}
+	return w;
+}
+__name(generateArcPoints, "generateArcPoints");
+function calculateArcSagitta(e, a, o) {
+	let [s, c] = [a, o].sort((e, a) => a - e);
+	return c * (1 - Math.sqrt(1 - (e / s / 2) ** 2));
+}
+__name(calculateArcSagitta, "calculateArcSagitta");
+async function bowTieRect(a, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.labelStyle = s;
+	let l = o.padding ?? 0, u = o.look === "neo" ? 16 : l, d = o.look === "neo" ? 12 : l, f = /* @__PURE__ */ __name((e) => e + d, "calcTotalHeight"), p = /* @__PURE__ */ __name((e) => {
+		let a = e / 2;
+		return [a / (2.5 + e / 50), a];
+	}, "calcEllipseRadius"), { shapeSvg: m, bbox: h } = await labelHelper(a, o, getNodeClasses(o)), g = f(o?.height ? o?.height : h.height), [_, v] = p(g), y = calculateArcSagitta(g, _, v), b = (o?.width ? o?.width : h.width) + u * 2 + y - y, x = g, { cssStyles: w } = o, T = [
+		{
+			x: b / 2,
+			y: -x / 2
+		},
+		{
+			x: -b / 2,
+			y: -x / 2
+		},
+		...generateArcPoints(-b / 2, -x / 2, -b / 2, x / 2, _, v, !1),
+		{
+			x: b / 2,
+			y: x / 2
+		},
+		...generateArcPoints(b / 2, x / 2, b / 2, -x / 2, _, v, !0)
+	], D = at.svg(m), j = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (j.roughness = 0, j.fillStyle = "solid");
+	let M = createPathFromPoints(T), N = D.path(M, j), P = m.insert(() => N, ":first-child");
+	return P.attr("class", "basic label-container outer-path"), w && o.look !== "handDrawn" && P.selectAll("path").attr("style", w), c && o.look !== "handDrawn" && P.selectAll("path").attr("style", c), P.attr("transform", `translate(${_ / 2}, 0)`), updateNodeBounds(o, P), o.intersect = function(e) {
+		return intersect_default.polygon(o, T, e);
+	}, m;
+}
+__name(bowTieRect, "bowTieRect");
+function insertPolygonShape(e, a, o, s) {
+	return e.insert("polygon", ":first-child").attr("points", s.map(function(e) {
+		return e.x + "," + e.y;
+	}).join(" ")).attr("class", "label-container").attr("transform", "translate(" + -a / 2 + "," + o / 2 + ")");
+}
+__name(insertPolygonShape, "insertPolygonShape");
+var NOTCH_SIZE = 12;
+async function card(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 28 : c, u = a.look === "neo" ? 24 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.width ?? f.width) + (a.look === "neo" ? l * 2 : l + NOTCH_SIZE), m = (a?.height ?? f.height) + (a.look === "neo" ? u * 2 : u), h = p, g = -m, _ = [
+		{
+			x: 0 + NOTCH_SIZE,
+			y: g
+		},
+		{
+			x: h,
+			y: g
+		},
+		{
+			x: h,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: 0,
+			y: g + NOTCH_SIZE
+		},
+		{
+			x: 0 + NOTCH_SIZE,
+			y: g
+		}
+	], v, { cssStyles: y } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = userNodeOverrides(a, {}), s = createPathFromPoints(_), c = e.path(s, o);
+		v = d.insert(() => c, ":first-child").attr("transform", `translate(${-p / 2}, ${m / 2})`), y && v.attr("style", y);
+	} else v = insertPolygonShape(d, p, m, _);
+	return s && v.attr("style", s), updateNodeBounds(a, v), a.intersect = function(e) {
+		return intersect_default.polygon(a, _, e);
+	}, d;
+}
+__name(card, "card");
+function choice(e, a) {
+	let { nodeStyles: o } = styles2String(a);
+	a.label = "";
+	let s = e.insert("g").attr("class", getNodeClasses(a)).attr("id", a.domId ?? a.id), { cssStyles: c } = a, l = Math.max(28, a.width ?? 0), u = [
+		{
+			x: 0,
+			y: l / 2
+		},
+		{
+			x: l / 2,
+			y: 0
+		},
+		{
+			x: 0,
+			y: -l / 2
+		},
+		{
+			x: -l / 2,
+			y: 0
+		}
+	], d = at.svg(s), f = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (f.roughness = 0, f.fillStyle = "solid");
+	let p = createPathFromPoints(u), m = d.path(p, f), h = s.insert(() => m, ":first-child");
+	return c && a.look !== "handDrawn" && h.selectAll("path").attr("style", c), o && a.look !== "handDrawn" && h.selectAll("path").attr("style", o), a.width = 28, a.height = 28, a.intersect = function(e) {
+		return intersect_default.polygon(a, u, e);
+	}, s;
+}
+__name(choice, "choice");
+async function circle(e, o, s) {
+	let { labelStyles: c, nodeStyles: l } = styles2String(o);
+	o.labelStyle = c;
+	let { shapeSvg: u, bbox: d, halfPadding: f } = await labelHelper(e, o, getNodeClasses(o)), p = s?.padding ?? f, m = o.look === "neo" ? d.width / 2 + 32 : d.width / 2 + p, h, { cssStyles: g } = o;
+	if (o.look === "handDrawn") {
+		let e = at.svg(u), a = userNodeOverrides(o, {}), s = e.circle(0, 0, m * 2, a);
+		h = u.insert(() => s, ":first-child"), h.attr("class", "basic label-container").attr("style", handleUndefinedAttr(g));
+	} else h = u.insert("circle", ":first-child").attr("class", "basic label-container").attr("style", l).attr("r", m).attr("cx", 0).attr("cy", 0);
+	return updateNodeBounds(o, h), o.calcIntersect = function(e, a) {
+		let o = e.width / 2;
+		return intersect_default.circle(e, o, a);
+	}, o.intersect = function(e) {
+		return log.info("Circle intersect", o, m, e), intersect_default.circle(o, m, e);
+	}, u;
+}
+__name(circle, "circle");
+function createLine(e) {
+	let a = Math.cos(Math.PI / 4), o = Math.sin(Math.PI / 4), s = e * 2, c = {
+		x: s / 2 * a,
+		y: s / 2 * o
+	}, l = {
+		x: -(s / 2) * a,
+		y: s / 2 * o
+	}, u = {
+		x: -(s / 2) * a,
+		y: -(s / 2) * o
+	}, d = {
+		x: s / 2 * a,
+		y: -(s / 2) * o
+	};
+	return `M ${l.x},${l.y} L ${d.x},${d.y}
+                   M ${c.x},${c.y} L ${u.x},${u.y}`;
+}
+__name(createLine, "createLine");
+function crossedCircle(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.labelStyle = s, o.label = "";
+	let l = e.insert("g").attr("class", getNodeClasses(o)).attr("id", o.domId ?? o.id), u = Math.max(30, o?.width ?? 0), { cssStyles: d } = o, f = at.svg(l), p = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+	let m = f.circle(0, 0, u * 2, p), h = createLine(u), g = f.path(h, p), _ = l.insert(() => m, ":first-child");
+	return _.insert(() => g), _.attr("class", "outer-path"), d && o.look !== "handDrawn" && _.selectAll("path").attr("style", d), c && o.look !== "handDrawn" && _.selectAll("path").attr("style", c), updateNodeBounds(o, _), o.intersect = function(e) {
+		return log.info("crossedCircle intersect", o, {
+			radius: u,
+			point: e
+		}), intersect_default.circle(o, u, e);
+	}, l;
+}
+__name(crossedCircle, "crossedCircle");
+function generateCirclePoints2(e, a, o, s = 100, c = 0, l = 180) {
+	let u = [], d = c * Math.PI / 180, f = (l * Math.PI / 180 - d) / (s - 1);
+	for (let c = 0; c < s; c++) {
+		let s = d + c * f, l = e + o * Math.cos(s), p = a + o * Math.sin(s);
+		u.push({
+			x: -l,
+			y: -p
+		});
+	}
+	return u;
+}
+__name(generateCirclePoints2, "generateCirclePoints");
+async function curlyBraceLeft(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l, label: u } = await labelHelper(e, a, getNodeClasses(a)), d = a.look === "neo" ? 18 : a.padding ?? 0, f = a.look === "neo" ? 12 : a.padding ?? 0, p = l.width + d, m = l.height + f, h = Math.max(5, m * .1), { cssStyles: g } = a, _ = [
+		...generateCirclePoints2(p / 2, -m / 2, h, 30, -90, 0),
+		{
+			x: -p / 2 - h,
+			y: h
+		},
+		...generateCirclePoints2(p / 2 + h * 2, -h, h, 20, -180, -270),
+		...generateCirclePoints2(p / 2 + h * 2, h, h, 20, -90, -180),
+		{
+			x: -p / 2 - h,
+			y: -m / 2
+		},
+		...generateCirclePoints2(p / 2, m / 2, h, 20, 0, 90)
+	], v = [
+		{
+			x: p / 2,
+			y: -m / 2 - h
+		},
+		{
+			x: -p / 2,
+			y: -m / 2 - h
+		},
+		...generateCirclePoints2(p / 2, -m / 2, h, 20, -90, 0),
+		{
+			x: -p / 2 - h,
+			y: -h
+		},
+		...generateCirclePoints2(p / 2 + p * .1, -h, h, 20, -180, -270),
+		...generateCirclePoints2(p / 2 + p * .1, h, h, 20, -90, -180),
+		{
+			x: -p / 2 - h,
+			y: m / 2
+		},
+		...generateCirclePoints2(p / 2, m / 2, h, 20, 0, 90),
+		{
+			x: -p / 2,
+			y: m / 2 + h
+		},
+		{
+			x: p / 2,
+			y: m / 2 + h
+		}
+	], y = at.svg(c), b = userNodeOverrides(a, { fill: "none" });
+	a.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = createPathFromPoints(_).replace("Z", ""), w = y.path(x, b), T = createPathFromPoints(v), D = y.path(T, { ...b }), j = c.insert("g", ":first-child");
+	return j.insert(() => D, ":first-child").attr("stroke-opacity", 0), j.insert(() => w, ":first-child"), j.attr("class", "text"), g && a.look !== "handDrawn" && j.selectAll("path").attr("style", g), s && a.look !== "handDrawn" && j.selectAll("path").attr("style", s), j.attr("transform", `translate(${h}, 0)`), u.attr("transform", `translate(${-p / 2 + h - (l.x - (l.left ?? 0))},${-m / 2 + (a.padding ?? 0) / 2 - (l.y - (l.top ?? 0))})`), updateNodeBounds(a, j), a.intersect = function(e) {
+		return intersect_default.polygon(a, v, e);
+	}, c;
+}
+__name(curlyBraceLeft, "curlyBraceLeft");
+function generateCirclePoints3(e, a, o, s = 100, c = 0, l = 180) {
+	let u = [], d = c * Math.PI / 180, f = (l * Math.PI / 180 - d) / (s - 1);
+	for (let c = 0; c < s; c++) {
+		let s = d + c * f, l = e + o * Math.cos(s), p = a + o * Math.sin(s);
+		u.push({
+			x: l,
+			y: p
+		});
+	}
+	return u;
+}
+__name(generateCirclePoints3, "generateCirclePoints");
+async function curlyBraceRight(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l, label: u } = await labelHelper(e, a, getNodeClasses(a)), d = a.look === "neo" ? 18 : a.padding ?? 0, f = a.look === "neo" ? 12 : a.padding ?? 0, p = l.width + (a.look === "neo" ? d * 2 : d), m = l.height + (a.look === "neo" ? f * 2 : f), h = Math.max(5, m * .1), { cssStyles: g } = a, _ = [
+		...generateCirclePoints3(p / 2, -m / 2, h, 20, -90, 0),
+		{
+			x: p / 2 + h,
+			y: -h
+		},
+		...generateCirclePoints3(p / 2 + h * 2, -h, h, 20, -180, -270),
+		...generateCirclePoints3(p / 2 + h * 2, h, h, 20, -90, -180),
+		{
+			x: p / 2 + h,
+			y: m / 2
+		},
+		...generateCirclePoints3(p / 2, m / 2, h, 20, 0, 90)
+	], v = [
+		{
+			x: -p / 2,
+			y: -m / 2 - h
+		},
+		{
+			x: p / 2,
+			y: -m / 2 - h
+		},
+		...generateCirclePoints3(p / 2, -m / 2, h, 20, -90, 0),
+		{
+			x: p / 2 + h,
+			y: -h
+		},
+		...generateCirclePoints3(p / 2 + h * 2, -h, h, 20, -180, -270),
+		...generateCirclePoints3(p / 2 + h * 2, h, h, 20, -90, -180),
+		{
+			x: p / 2 + h,
+			y: m / 2
+		},
+		...generateCirclePoints3(p / 2, m / 2, h, 20, 0, 90),
+		{
+			x: p / 2,
+			y: m / 2 + h
+		},
+		{
+			x: -p / 2,
+			y: m / 2 + h
+		}
+	], y = at.svg(c), b = userNodeOverrides(a, { fill: "none" });
+	a.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = createPathFromPoints(_).replace("Z", ""), w = y.path(x, b), T = createPathFromPoints(v), D = y.path(T, { ...b }), j = c.insert("g", ":first-child");
+	return j.insert(() => D, ":first-child").attr("stroke-opacity", 0), j.insert(() => w, ":first-child"), j.attr("class", "text"), g && a.look !== "handDrawn" && j.selectAll("path").attr("style", g), s && a.look !== "handDrawn" && j.selectAll("path").attr("style", s), j.attr("transform", `translate(${-h}, 0)`), u.attr("transform", `translate(${-p / 2 + (a.padding ?? 0) / 2 - (l.x - (l.left ?? 0))},${-m / 2 + (a.padding ?? 0) / 2 - (l.y - (l.top ?? 0))})`), updateNodeBounds(a, j), a.intersect = function(e) {
+		return intersect_default.polygon(a, v, e);
+	}, c;
+}
+__name(curlyBraceRight, "curlyBraceRight");
+function generateCirclePoints4(e, a, o, s = 100, c = 0, l = 180) {
+	let u = [], d = c * Math.PI / 180, f = (l * Math.PI / 180 - d) / (s - 1);
+	for (let c = 0; c < s; c++) {
+		let s = d + c * f, l = e + o * Math.cos(s), p = a + o * Math.sin(s);
+		u.push({
+			x: -l,
+			y: -p
+		});
+	}
+	return u;
+}
+__name(generateCirclePoints4, "generateCirclePoints");
+async function curlyBraces(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l, label: u } = await labelHelper(e, a, getNodeClasses(a)), d = a.look === "neo" ? 18 : a.padding ?? 0, f = a.look === "neo" ? 12 : a.padding ?? 0, p = l.width + (a.look === "neo" ? d * 2 : d), m = l.height + (a.look === "neo" ? f * 2 : f), h = Math.max(5, m * .1), { cssStyles: g } = a, _ = [
+		...generateCirclePoints4(p / 2, -m / 2, h, 30, -90, 0),
+		{
+			x: -p / 2 - h,
+			y: h
+		},
+		...generateCirclePoints4(p / 2 + h * 2, -h, h, 20, -180, -270),
+		...generateCirclePoints4(p / 2 + h * 2, h, h, 20, -90, -180),
+		{
+			x: -p / 2 - h,
+			y: -m / 2
+		},
+		...generateCirclePoints4(p / 2, m / 2, h, 20, 0, 90)
+	], v = [
+		...generateCirclePoints4(-p / 2 + h + h / 2, -m / 2, h, 20, -90, -180),
+		{
+			x: p / 2 - h / 2,
+			y: h
+		},
+		...generateCirclePoints4(-p / 2 - h / 2, -h, h, 20, 0, 90),
+		...generateCirclePoints4(-p / 2 - h / 2, h, h, 20, -90, 0),
+		{
+			x: p / 2 - h / 2,
+			y: -h
+		},
+		...generateCirclePoints4(-p / 2 + h + h / 2, m / 2, h, 30, -180, -270)
+	], y = [
+		{
+			x: p / 2,
+			y: -m / 2 - h
+		},
+		{
+			x: -p / 2,
+			y: -m / 2 - h
+		},
+		...generateCirclePoints4(p / 2, -m / 2, h, 20, -90, 0),
+		{
+			x: -p / 2 - h,
+			y: -h
+		},
+		...generateCirclePoints4(p / 2 + h * 2, -h, h, 20, -180, -270),
+		...generateCirclePoints4(p / 2 + h * 2, h, h, 20, -90, -180),
+		{
+			x: -p / 2 - h,
+			y: m / 2
+		},
+		...generateCirclePoints4(p / 2, m / 2, h, 20, 0, 90),
+		{
+			x: -p / 2,
+			y: m / 2 + h
+		},
+		{
+			x: p / 2 - h - h / 2,
+			y: m / 2 + h
+		},
+		...generateCirclePoints4(-p / 2 + h + h / 2, -m / 2, h, 20, -90, -180),
+		{
+			x: p / 2 - h / 2,
+			y: h
+		},
+		...generateCirclePoints4(-p / 2 - h / 2, -h, h, 20, 0, 90),
+		...generateCirclePoints4(-p / 2 - h / 2, h, h, 20, -90, 0),
+		{
+			x: p / 2 - h / 2,
+			y: -h
+		},
+		...generateCirclePoints4(-p / 2 + h + h / 2, m / 2, h, 30, -180, -270)
+	], b = at.svg(c), x = userNodeOverrides(a, { fill: "none" });
+	a.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let w = createPathFromPoints(_).replace("Z", ""), T = b.path(w, x), D = createPathFromPoints(v).replace("Z", ""), j = b.path(D, x), M = createPathFromPoints(y), N = b.path(M, { ...x }), P = c.insert("g", ":first-child");
+	return P.insert(() => N, ":first-child").attr("stroke-opacity", 0), P.insert(() => T, ":first-child"), P.insert(() => j, ":first-child"), P.attr("class", "text"), g && a.look !== "handDrawn" && P.selectAll("path").attr("style", g), s && a.look !== "handDrawn" && P.selectAll("path").attr("style", s), P.attr("transform", `translate(${h - h / 4}, 0)`), u.attr("transform", `translate(${-p / 2 + (a.padding ?? 0) / 2 - (l.x - (l.left ?? 0))},${-m / 2 + (a.padding ?? 0) / 2 - (l.y - (l.top ?? 0))})`), updateNodeBounds(a, P), a.intersect = function(e) {
+		return intersect_default.polygon(a, y, e);
+	}, c;
+}
+__name(curlyBraces, "curlyBraces");
+async function curvedTrapezoid(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = Math.max(20, (f.width + l * 2) * 1.25, a?.width ?? 0), m = Math.max(5, f.height + u * 2, a?.height ?? 0), h = m / 2, { cssStyles: g } = a, _ = at.svg(d), v = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+	let y = p, b = m, x = y - h, w = b / 4, T = [
+		{
+			x,
+			y: 0
+		},
+		{
+			x: w,
+			y: 0
+		},
+		{
+			x: 0,
+			y: b / 2
+		},
+		{
+			x: w,
+			y: b
+		},
+		{
+			x,
+			y: b
+		},
+		...generateCirclePoints(-x, -b / 2, h, 50, 270, 90)
+	], D = createPathFromPoints(T), j = _.path(D, v), N = d.insert(() => j, ":first-child");
+	return N.attr("class", "basic label-container outer-path"), g && a.look !== "handDrawn" && N.selectChildren("path").attr("style", g), s && a.look !== "handDrawn" && N.selectChildren("path").attr("style", s), N.attr("transform", `translate(${-p / 2}, ${-m / 2})`), updateNodeBounds(a, N), a.intersect = function(e) {
+		return intersect_default.polygon(a, T, e);
+	}, d;
+}
+__name(curvedTrapezoid, "curvedTrapezoid");
+var createCylinderPathD = /* @__PURE__ */ __name((e, a, o, s, c, l) => [
+	`M${e},${a + l}`,
+	`a${c},${l} 0,0,0 ${o},0`,
+	`a${c},${l} 0,0,0 ${-o},0`,
+	`l0,${s}`,
+	`a${c},${l} 0,0,0 ${o},0`,
+	`l0,${-s}`
+].join(" "), "createCylinderPathD"), createOuterCylinderPathD = /* @__PURE__ */ __name((e, a, o, s, c, l) => [
+	`M${e},${a + l}`,
+	`M${e + o},${a + l}`,
+	`a${c},${l} 0,0,0 ${-o},0`,
+	`l0,${s}`,
+	`a${c},${l} 0,0,0 ${o},0`,
+	`l0,${-s}`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD = /* @__PURE__ */ __name((e, a, o, s, c, l) => [`M${e - o / 2},${-s / 2}`, `a${c},${l} 0,0,0 ${o},0`].join(" "), "createInnerCylinderPathD"), MIN_HEIGHT = 8, MIN_WIDTH = 8;
+async function cylinder(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 24 : c, u = a.look === "neo" ? 24 : c;
+	if (a.width || a.height) {
+		let e = a.width ?? 0;
+		a.width = (a.width ?? 0) - u, a.width < MIN_WIDTH && (a.width = MIN_WIDTH);
+		let o = e / 2 / (2.5 + e / 50);
+		a.height = (a.height ?? 0) - l - o * 3, a.height < MIN_HEIGHT && (a.height = MIN_HEIGHT);
+	}
+	let { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, a, getNodeClasses(a)), m = (a.width ? a.width : f.width) + u, h = m / 2, g = h / (2.5 + m / 50), v = (a.height ? a.height : f.height) + l + g, y, { cssStyles: b } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = createOuterCylinderPathD(0, 0, m, v, h, g), s = createInnerCylinderPathD(0, g, m, v, h, g), c = userNodeOverrides(a, {}), l = e.path(o, c), u = e.path(s, userNodeOverrides(a, { fill: "none" }));
+		y = d.insert(() => u, ":first-child"), y = d.insert(() => l, ":first-child"), y.attr("class", "basic label-container"), b && y.attr("style", b);
+	} else {
+		let e = createCylinderPathD(0, 0, m, v, h, g);
+		y = d.insert("path", ":first-child").attr("d", e).attr("class", "basic label-container outer-path").attr("style", handleUndefinedAttr(b)).attr("style", s);
+	}
+	return y.attr("label-offset-y", g), y.attr("transform", `translate(${-m / 2}, ${-(v / 2 + g)})`), updateNodeBounds(a, y), p.attr("transform", `translate(${-(f.width / 2) - (f.x - (f.left ?? 0))}, ${-(f.height / 2) + (a.padding ?? 0) / 1.5 - (f.y - (f.top ?? 0))})`), a.intersect = function(e) {
+		let o = intersect_default.rect(a, e), s = o.x - (a.x ?? 0);
+		if (h != 0 && (Math.abs(s) < (a.width ?? 0) / 2 || Math.abs(s) == (a.width ?? 0) / 2 && Math.abs(o.y - (a.y ?? 0)) > (a.height ?? 0) / 2 - g)) {
+			let c = g * g * (1 - s * s / (h * h));
+			c > 0 && (c = Math.sqrt(c)), c = g - c, e.y - (a.y ?? 0) > 0 && (c = -c), o.y += c;
+		}
+		return o;
+	}, d;
+}
+__name(cylinder, "cylinder");
+async function dividedRectangle(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.look === "neo" ? 16 : a.padding ?? 0, l = a.look === "neo" ? 16 : a.padding ?? 0, { shapeSvg: u, bbox: d, label: f } = await labelHelper(e, a, getNodeClasses(a)), p = d.width + c, m = d.height + l, h = m * .2, g = -p / 2, _ = -m / 2 - h / 2, { cssStyles: v } = a, y = at.svg(u), b = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = [
+		{
+			x: g,
+			y: _ + h
+		},
+		{
+			x: -g,
+			y: _ + h
+		},
+		{
+			x: -g,
+			y: -_
+		},
+		{
+			x: g,
+			y: -_
+		},
+		{
+			x: g,
+			y: _
+		},
+		{
+			x: -g,
+			y: _
+		},
+		{
+			x: -g,
+			y: _ + h
+		}
+	], w = y.polygon(x.map((e) => [e.x, e.y]), b), T = u.insert(() => w, ":first-child");
+	return T.attr("class", "basic label-container outer-path"), v && a.look !== "handDrawn" && T.selectAll("path").attr("style", v), s && a.look !== "handDrawn" && T.selectAll("path").attr("style", s), f.attr("transform", `translate(${g + (a.padding ?? 0) / 2 - (d.x - (d.left ?? 0))}, ${_ + h + (a.padding ?? 0) / 2 - (d.y - (d.top ?? 0))})`), updateNodeBounds(a, T), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, u;
+}
+__name(dividedRectangle, "dividedRectangle");
+async function doublecircle(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o), l = o.look === "neo" ? 12 : 5;
+	o.labelStyle = s;
+	let u = o.padding ?? 0, d = o.look === "neo" ? 16 : u, { shapeSvg: f, bbox: p } = await labelHelper(e, o, getNodeClasses(o)), m = (o?.width ? o?.width / 2 : p.width / 2) + (d ?? 0), h = m - l, g, { cssStyles: v } = o;
+	if (o.look === "handDrawn") {
+		let e = at.svg(f), a = userNodeOverrides(o, {
+			roughness: .2,
+			strokeWidth: 2.5
+		}), s = userNodeOverrides(o, {
+			roughness: .2,
+			strokeWidth: 1.5
+		}), c = e.circle(0, 0, m * 2, a), l = e.circle(0, 0, h * 2, s);
+		g = f.insert("g", ":first-child"), g.attr("class", handleUndefinedAttr(o.cssClasses)).attr("style", handleUndefinedAttr(v)), g.node()?.appendChild(c), g.node()?.appendChild(l);
+	} else {
+		g = f.insert("g", ":first-child");
+		let e = g.insert("circle", ":first-child"), a = g.insert("circle");
+		g.attr("class", "basic label-container").attr("style", c), e.attr("class", "outer-circle").attr("style", c).attr("r", m).attr("cx", 0).attr("cy", 0), a.attr("class", "inner-circle").attr("style", c).attr("r", h).attr("cx", 0).attr("cy", 0);
+	}
+	return updateNodeBounds(o, g), o.intersect = function(e) {
+		return log.info("DoubleCircle intersect", o, m, e), intersect_default.circle(o, m, e);
+	}, f;
+}
+__name(doublecircle, "doublecircle");
+function filledCircle(e, o, { config: { themeVariables: s } }) {
+	let { labelStyles: c, nodeStyles: l } = styles2String(o);
+	o.label = "", o.labelStyle = c;
+	let u = e.insert("g").attr("class", getNodeClasses(o)).attr("id", o.domId ?? o.id), { cssStyles: d } = o, f = at.svg(u), { nodeBorder: p } = s, m = userNodeOverrides(o, { fillStyle: "solid" });
+	o.look !== "handDrawn" && (m.roughness = 0);
+	let h = f.circle(0, 0, 14, m), g = u.insert(() => h, ":first-child");
+	return g.selectAll("path").attr("style", `fill: ${p} !important;`), d && d.length > 0 && o.look !== "handDrawn" && g.selectAll("path").attr("style", d), l && o.look !== "handDrawn" && g.selectAll("path").attr("style", l), updateNodeBounds(o, g), o.intersect = function(e) {
+		return log.info("filledCircle intersect", o, {
+			radius: 7,
+			point: e
+		}), intersect_default.circle(o, 7, e);
+	}, u;
+}
+__name(filledCircle, "filledCircle");
+var MIN_HEIGHT2 = 10, MIN_WIDTH2 = 10;
+async function flippedTriangle(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.labelStyle = s;
+	let l = o.padding ?? 0, u = o.look === "neo" ? l * 2 : l;
+	(o.width || o.height) && (o.height = o?.height ?? 0, o.height < MIN_HEIGHT2 && (o.height = MIN_HEIGHT2), o.width = (o?.width ?? 0) - u - u / 2, o.width < MIN_WIDTH2 && (o.width = MIN_WIDTH2));
+	let { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, o, getNodeClasses(o)), m = (o?.width ? o?.width : f.width) + (u ?? 0), h = o?.height ? o?.height : m + f.height, g = h, _ = [
+		{
+			x: 0,
+			y: -h
+		},
+		{
+			x: g,
+			y: -h
+		},
+		{
+			x: g / 2,
+			y: 0
+		}
+	], { cssStyles: v } = o, y = at.svg(d), b = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = createPathFromPoints(_), w = y.path(x, b), T = d.insert(() => w, ":first-child").attr("transform", `translate(${-h / 2}, ${h / 2})`).attr("class", "outer-path");
+	return v && o.look !== "handDrawn" && T.selectChildren("path").attr("style", v), c && o.look !== "handDrawn" && T.selectChildren("path").attr("style", c), o.width = m, o.height = h, updateNodeBounds(o, T), p.attr("transform", `translate(${-f.width / 2 - (f.x - (f.left ?? 0))}, ${-h / 2 + (o.padding ?? 0) / 2 + (f.y - (f.top ?? 0))})`), o.intersect = function(e) {
+		return log.info("Triangle intersect", o, _, e), intersect_default.polygon(o, _, e);
+	}, d;
+}
+__name(flippedTriangle, "flippedTriangle");
+function forkJoin(e, a, { dir: o, config: { state: s, themeVariables: c } }) {
+	let { nodeStyles: l } = styles2String(a);
+	a.label = "";
+	let u = e.insert("g").attr("class", getNodeClasses(a)).attr("id", a.domId ?? a.id), { cssStyles: d } = a, f = Math.max(70, a?.width ?? 0), p = Math.max(10, a?.height ?? 0);
+	o === "LR" && (f = Math.max(10, a?.width ?? 0), p = Math.max(70, a?.height ?? 0));
+	let m = -1 * f / 2, h = -1 * p / 2, g = at.svg(u), _ = userNodeOverrides(a, {
+		stroke: c.lineColor,
+		fill: c.lineColor
+	});
+	a.look !== "handDrawn" && (_.roughness = 0, _.fillStyle = "solid");
+	let v = g.rectangle(m, h, f, p, _), y = u.insert(() => v, ":first-child");
+	d && a.look !== "handDrawn" && y.selectAll("path").attr("style", d), l && a.look !== "handDrawn" && y.selectAll("path").attr("style", l), updateNodeBounds(a, y);
+	let b = s?.padding ?? 0;
+	return a.width && a.height && (a.width += b / 2 || 0, a.height += b / 2 || 0), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, u;
+}
+__name(forkJoin, "forkJoin");
+async function halfRoundedRectangle(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.labelStyle = s;
+	let l = o.look === "neo" ? 16 : o.padding ?? 0, u = o.look === "neo" ? 12 : o.padding ?? 0;
+	(o.width || o.height) && (o.height = (o?.height ?? 0) - u * 2, o.height < 10 && (o.height = 10), o.width = (o?.width ?? 0) - l * 2, o.width < 15 && (o.width = 15));
+	let { shapeSvg: d, bbox: f } = await labelHelper(e, o, getNodeClasses(o)), p = (o?.width ? o?.width : Math.max(15, f.width)) + l * 2, m = (o?.height ? o?.height : Math.max(10, f.height)) + u * 2, h = m / 2, { cssStyles: g } = o, _ = at.svg(d), v = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+	let y = [
+		{
+			x: -p / 2,
+			y: -m / 2
+		},
+		{
+			x: p / 2 - h,
+			y: -m / 2
+		},
+		...generateCirclePoints(-p / 2 + h, 0, h, 50, 90, 270),
+		{
+			x: p / 2 - h,
+			y: m / 2
+		},
+		{
+			x: -p / 2,
+			y: m / 2
+		}
+	], b = createPathFromPoints(y), x = _.path(b, v), w = d.insert(() => x, ":first-child");
+	return w.attr("class", "basic label-container outer-path"), g && o.look !== "handDrawn" && w.selectChildren("path").attr("style", g), c && o.look !== "handDrawn" && w.selectChildren("path").attr("style", c), updateNodeBounds(o, w), o.intersect = function(e) {
+		return log.info("Pill intersect", o, {
+			radius: h,
+			point: e
+		}), intersect_default.polygon(o, y, e);
+	}, d;
+}
+__name(halfRoundedRectangle, "halfRoundedRectangle");
+var createHexagonPathD = /* @__PURE__ */ __name((e, a, o, s, c) => [
+	`M${e + c},${a}`,
+	`L${e + o - c},${a}`,
+	`L${e + o},${a - s / 2}`,
+	`L${e + o - c},${a - s}`,
+	`L${e + c},${a - s}`,
+	`L${e},${a - s / 2}`,
+	"Z"
+].join(" "), "createHexagonPathD");
+async function hexagon(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a), c = a.look === "neo" ? 3.5 : 4;
+	a.labelStyle = o;
+	let l = a.padding ?? 0, u = a.look === "neo" ? 70 : l, d = a.look === "neo" ? 32 : l;
+	if (a.width || a.height) {
+		let e = (a.height ?? 0) / c;
+		a.width = (a?.width ?? 0) - 2 * e - d, a.height = (a.height ?? 0) - u;
+	}
+	let { shapeSvg: f, bbox: p } = await labelHelper(e, a, getNodeClasses(a)), m = (a?.height ? a?.height : p.height) + u, h = m / c, g = (a?.width ? a?.width : p.width) + 2 * h + d, _ = [
+		{
+			x: h,
+			y: 0
+		},
+		{
+			x: g - h,
+			y: 0
+		},
+		{
+			x: g,
+			y: -m / 2
+		},
+		{
+			x: g - h,
+			y: -m
+		},
+		{
+			x: h,
+			y: -m
+		},
+		{
+			x: 0,
+			y: -m / 2
+		}
+	], v, { cssStyles: y } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(f), o = userNodeOverrides(a, {}), s = createHexagonPathD(0, 0, g, m, h), c = e.path(s, o);
+		v = f.insert(() => c, ":first-child").attr("transform", `translate(${-g / 2}, ${m / 2})`), y && v.attr("style", y);
+	} else v = insertPolygonShape(f, g, m, _);
+	return s && v.attr("style", s), a.width = g, a.height = m, updateNodeBounds(a, v), a.intersect = function(e) {
+		return intersect_default.polygon(a, _, e);
+	}, f;
+}
+__name(hexagon, "hexagon");
+async function hourglass(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.label = "", o.labelStyle = s;
+	let { shapeSvg: l } = await labelHelper(e, o, getNodeClasses(o)), u = Math.max(30, o?.width ?? 0), d = Math.max(30, o?.height ?? 0), { cssStyles: f } = o, p = at.svg(l), m = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (m.roughness = 0, m.fillStyle = "solid");
+	let h = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: u,
+			y: 0
+		},
+		{
+			x: 0,
+			y: d
+		},
+		{
+			x: u,
+			y: d
+		}
+	], g = createPathFromPoints(h), _ = p.path(g, m), v = l.insert(() => _, ":first-child");
+	return v.attr("class", "basic label-container outer-path"), f && o.look !== "handDrawn" && v.selectChildren("path").attr("style", f), c && o.look !== "handDrawn" && v.selectChildren("path").attr("style", c), v.attr("transform", `translate(${-u / 2}, ${-d / 2})`), updateNodeBounds(o, v), o.intersect = function(e) {
+		return log.info("Pill intersect", o, { points: h }), intersect_default.polygon(o, h, e);
+	}, l;
+}
+__name(hourglass, "hourglass");
+async function icon(e, o, { config: { themeVariables: s, flowchart: c } }) {
+	let { labelStyles: l } = styles2String(o);
+	o.labelStyle = l;
+	let u = o.assetHeight ?? 48, d = o.assetWidth ?? 48, f = Math.max(u, d), p = c?.wrappingWidth;
+	o.width = Math.max(f, p ?? 0);
+	let { shapeSvg: m, bbox: h, label: g } = await labelHelper(e, o, "icon-shape default"), _ = o.pos === "t", v = f, y = f, { nodeBorder: x } = s, { stylesMap: w } = compileStyles(o), D = -y / 2, k = -v / 2, A = o.label ? 8 : 0, j = at.svg(m), M = userNodeOverrides(o, {
+		stroke: "none",
+		fill: "none"
+	});
+	o.look !== "handDrawn" && (M.roughness = 0, M.fillStyle = "solid");
+	let N = j.rectangle(D, k, y, v, M), P = Math.max(y, h.width), F = v + h.height + A, I = j.rectangle(-P / 2, -F / 2, P, F, {
+		...M,
+		fill: "transparent",
+		stroke: "none"
+	}), L = m.insert(() => N, ":first-child"), R = m.insert(() => I);
+	if (o.icon) {
+		let e = m.append("g");
+		e.html(`<g>${await getIconSVG(o.icon, {
+			height: f,
+			width: f,
+			fallbackPrefix: ""
+		})}</g>`);
+		let a = e.node().getBBox(), s = a.width, c = a.height, l = a.x, u = a.y;
+		e.attr("transform", `translate(${-s / 2 - l},${_ ? h.height / 2 + A / 2 - c / 2 - u : -h.height / 2 - A / 2 - c / 2 - u})`), e.attr("style", `color: ${w.get("stroke") ?? x};`);
+	}
+	return g.attr("transform", `translate(${-h.width / 2 - (h.x - (h.left ?? 0))},${_ ? -F / 2 : F / 2 - h.height})`), L.attr("transform", `translate(0,${_ ? h.height / 2 + A / 2 : -h.height / 2 - A / 2})`), updateNodeBounds(o, R), o.intersect = function(e) {
+		if (log.info("iconSquare intersect", o, e), !o.label) return intersect_default.rect(o, e);
+		let s = o.x ?? 0, c = o.y ?? 0, l = o.height ?? 0, u = [];
+		return u = _ ? [
+			{
+				x: s - h.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2 + h.height + A
+			},
+			{
+				x: s + y / 2,
+				y: c - l / 2 + h.height + A
+			},
+			{
+				x: s + y / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - y / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - y / 2,
+				y: c - l / 2 + h.height + A
+			},
+			{
+				x: s - h.width / 2,
+				y: c - l / 2 + h.height + A
+			}
+		] : [
+			{
+				x: s - y / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + y / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + y / 2,
+				y: c - l / 2 + v
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2 + v
+			},
+			{
+				x: s + h.width / 2 / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - h.width / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - h.width / 2,
+				y: c - l / 2 + v
+			},
+			{
+				x: s - y / 2,
+				y: c - l / 2 + v
+			}
+		], intersect_default.polygon(o, u, e);
+	}, m;
+}
+__name(icon, "icon");
+async function iconCircle(e, o, { config: { themeVariables: s, flowchart: c } }) {
+	let { labelStyles: l } = styles2String(o);
+	o.labelStyle = l;
+	let u = o.assetHeight ?? 48, d = o.assetWidth ?? 48, f = Math.max(u, d), p = c?.wrappingWidth;
+	o.width = Math.max(f, p ?? 0);
+	let { shapeSvg: m, bbox: h, label: g } = await labelHelper(e, o, "icon-shape default"), _ = o.label ? 8 : 0, v = o.pos === "t", { nodeBorder: y, mainBkg: x } = s, { stylesMap: w } = compileStyles(o), D = at.svg(m), k = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (k.roughness = 0, k.fillStyle = "solid"), k.stroke = w.get("fill") ?? x;
+	let A = m.append("g");
+	o.icon && A.html(`<g>${await getIconSVG(o.icon, {
+		height: f,
+		width: f,
+		fallbackPrefix: ""
+	})}</g>`);
+	let j = A.node().getBBox(), M = j.width, N = j.height, P = j.x, F = j.y, I = Math.max(M, N) * Math.SQRT2 + 40, L = D.circle(0, 0, I, k), R = Math.max(I, h.width), z = I + h.height + _, B = D.rectangle(-R / 2, -z / 2, R, z, {
+		...k,
+		fill: "transparent",
+		stroke: "none"
+	}), V = m.insert(() => L, ":first-child"), H = m.insert(() => B);
+	return A.attr("transform", `translate(${-M / 2 - P},${v ? h.height / 2 + _ / 2 - N / 2 - F : -h.height / 2 - _ / 2 - N / 2 - F})`), A.attr("style", `color: ${w.get("stroke") ?? y};`), g.attr("transform", `translate(${-h.width / 2 - (h.x - (h.left ?? 0))},${v ? -z / 2 : z / 2 - h.height})`), V.attr("transform", `translate(0,${v ? h.height / 2 + _ / 2 : -h.height / 2 - _ / 2})`), updateNodeBounds(o, H), o.intersect = function(e) {
+		return log.info("iconSquare intersect", o, e), intersect_default.rect(o, e);
+	}, m;
+}
+__name(iconCircle, "iconCircle");
+async function iconRounded(e, o, { config: { themeVariables: s, flowchart: c } }) {
+	let { labelStyles: l } = styles2String(o);
+	o.labelStyle = l;
+	let u = o.assetHeight ?? 48, d = o.assetWidth ?? 48, f = Math.max(u, d), p = c?.wrappingWidth;
+	o.width = Math.max(f, p ?? 0);
+	let { shapeSvg: m, bbox: h, halfPadding: g, label: _ } = await labelHelper(e, o, "icon-shape default"), v = o.pos === "t", y = f + g * 2, x = f + g * 2, { nodeBorder: w, mainBkg: D } = s, { stylesMap: k } = compileStyles(o), A = -x / 2, j = -y / 2, M = o.label ? 8 : 0, N = at.svg(m), P = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (P.roughness = 0, P.fillStyle = "solid"), P.stroke = k.get("fill") ?? D;
+	let F = N.path(createRoundedRectPathD(A, j, x, y, 5), P), L = Math.max(x, h.width), R = y + h.height + M, z = N.rectangle(-L / 2, -R / 2, L, R, {
+		...P,
+		fill: "transparent",
+		stroke: "none"
+	}), B = m.insert(() => F, ":first-child").attr("class", "icon-shape2"), V = m.insert(() => z);
+	if (o.icon) {
+		let e = m.append("g");
+		e.html(`<g>${await getIconSVG(o.icon, {
+			height: f,
+			width: f,
+			fallbackPrefix: ""
+		})}</g>`);
+		let a = e.node().getBBox(), s = a.width, c = a.height, l = a.x, u = a.y;
+		e.attr("transform", `translate(${-s / 2 - l},${v ? h.height / 2 + M / 2 - c / 2 - u : -h.height / 2 - M / 2 - c / 2 - u})`), e.attr("style", `color: ${k.get("stroke") ?? w};`);
+	}
+	return _.attr("transform", `translate(${-h.width / 2 - (h.x - (h.left ?? 0))},${v ? -R / 2 : R / 2 - h.height})`), B.attr("transform", `translate(0,${v ? h.height / 2 + M / 2 : -h.height / 2 - M / 2})`), updateNodeBounds(o, V), o.intersect = function(e) {
+		if (log.info("iconSquare intersect", o, e), !o.label) return intersect_default.rect(o, e);
+		let s = o.x ?? 0, c = o.y ?? 0, l = o.height ?? 0, u = [];
+		return u = v ? [
+			{
+				x: s - h.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2 + h.height + M
+			},
+			{
+				x: s + x / 2,
+				y: c - l / 2 + h.height + M
+			},
+			{
+				x: s + x / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - x / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - x / 2,
+				y: c - l / 2 + h.height + M
+			},
+			{
+				x: s - h.width / 2,
+				y: c - l / 2 + h.height + M
+			}
+		] : [
+			{
+				x: s - x / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + x / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + x / 2,
+				y: c - l / 2 + y
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2 + y
+			},
+			{
+				x: s + h.width / 2 / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - h.width / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - h.width / 2,
+				y: c - l / 2 + y
+			},
+			{
+				x: s - x / 2,
+				y: c - l / 2 + y
+			}
+		], intersect_default.polygon(o, u, e);
+	}, m;
+}
+__name(iconRounded, "iconRounded");
+async function iconSquare(e, o, { config: { themeVariables: s, flowchart: c } }) {
+	let { labelStyles: l } = styles2String(o);
+	o.labelStyle = l;
+	let u = o.assetHeight ?? 48, d = o.assetWidth ?? 48, f = Math.max(u, d), p = c?.wrappingWidth;
+	o.width = Math.max(f, p ?? 0);
+	let { shapeSvg: m, bbox: h, halfPadding: g, label: _ } = await labelHelper(e, o, "icon-shape default"), v = o.pos === "t", y = f + g * 2, x = f + g * 2, { nodeBorder: w, mainBkg: D } = s, { stylesMap: k } = compileStyles(o), A = -x / 2, j = -y / 2, M = o.label ? 8 : 0, N = at.svg(m), P = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (P.roughness = 0, P.fillStyle = "solid"), P.stroke = k.get("fill") ?? D;
+	let F = N.path(createRoundedRectPathD(A, j, x, y, .1), P), L = Math.max(x, h.width), R = y + h.height + M, z = N.rectangle(-L / 2, -R / 2, L, R, {
+		...P,
+		fill: "transparent",
+		stroke: "none"
+	}), B = m.insert(() => F, ":first-child"), V = m.insert(() => z);
+	if (o.icon) {
+		let e = m.append("g");
+		e.html(`<g>${await getIconSVG(o.icon, {
+			height: f,
+			width: f,
+			fallbackPrefix: ""
+		})}</g>`);
+		let a = e.node().getBBox(), s = a.width, c = a.height, l = a.x, u = a.y;
+		e.attr("transform", `translate(${-s / 2 - l},${v ? h.height / 2 + M / 2 - c / 2 - u : -h.height / 2 - M / 2 - c / 2 - u})`), e.attr("style", `color: ${k.get("stroke") ?? w};`);
+	}
+	return _.attr("transform", `translate(${-h.width / 2 - (h.x - (h.left ?? 0))},${v ? -R / 2 : R / 2 - h.height})`), B.attr("transform", `translate(0,${v ? h.height / 2 + M / 2 : -h.height / 2 - M / 2})`), updateNodeBounds(o, V), o.intersect = function(e) {
+		if (log.info("iconSquare intersect", o, e), !o.label) return intersect_default.rect(o, e);
+		let s = o.x ?? 0, c = o.y ?? 0, l = o.height ?? 0, u = [];
+		return u = v ? [
+			{
+				x: s - h.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2 + h.height + M
+			},
+			{
+				x: s + x / 2,
+				y: c - l / 2 + h.height + M
+			},
+			{
+				x: s + x / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - x / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - x / 2,
+				y: c - l / 2 + h.height + M
+			},
+			{
+				x: s - h.width / 2,
+				y: c - l / 2 + h.height + M
+			}
+		] : [
+			{
+				x: s - x / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + x / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + x / 2,
+				y: c - l / 2 + y
+			},
+			{
+				x: s + h.width / 2,
+				y: c - l / 2 + y
+			},
+			{
+				x: s + h.width / 2 / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - h.width / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - h.width / 2,
+				y: c - l / 2 + y
+			},
+			{
+				x: s - x / 2,
+				y: c - l / 2 + y
+			}
+		], intersect_default.polygon(o, u, e);
+	}, m;
+}
+__name(iconSquare, "iconSquare");
+async function imageSquare(e, o, { config: { flowchart: s } }) {
+	let c = new Image();
+	c.src = o?.img ?? "", await c.decode();
+	let l = Number(c.naturalWidth.toString().replace("px", "")), u = Number(c.naturalHeight.toString().replace("px", ""));
+	o.imageAspectRatio = l / u;
+	let { labelStyles: d } = styles2String(o);
+	o.labelStyle = d;
+	let f = s?.wrappingWidth;
+	o.defaultWidth = s?.wrappingWidth;
+	let p = Math.max(o.label ? f ?? 0 : 0, o?.assetWidth ?? l), m = o.constraint === "on" && o?.assetHeight ? o.assetHeight * o.imageAspectRatio : p, h = o.constraint === "on" ? m / o.imageAspectRatio : o?.assetHeight ?? u;
+	o.width = Math.max(m, f ?? 0);
+	let { shapeSvg: g, bbox: _, label: v } = await labelHelper(e, o, "image-shape default"), y = o.pos === "t", b = -m / 2, x = -h / 2, w = o.label ? 8 : 0, T = at.svg(g), D = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (D.roughness = 0, D.fillStyle = "solid");
+	let k = T.rectangle(b, x, m, h, D), A = Math.max(m, _.width), j = h + _.height + w, M = T.rectangle(-A / 2, -j / 2, A, j, {
+		...D,
+		fill: "none",
+		stroke: "none"
+	}), N = g.insert(() => k, ":first-child"), P = g.insert(() => M);
+	if (o.img) {
+		let e = g.append("image");
+		e.attr("href", o.img), e.attr("width", m), e.attr("height", h), e.attr("preserveAspectRatio", "none"), e.attr("transform", `translate(${-m / 2},${y ? j / 2 - h : -j / 2})`);
+	}
+	return v.attr("transform", `translate(${-_.width / 2 - (_.x - (_.left ?? 0))},${y ? -h / 2 - _.height / 2 - w / 2 : h / 2 - _.height / 2 + w / 2})`), N.attr("transform", `translate(0,${y ? _.height / 2 + w / 2 : -_.height / 2 - w / 2})`), updateNodeBounds(o, P), o.intersect = function(e) {
+		if (log.info("iconSquare intersect", o, e), !o.label) return intersect_default.rect(o, e);
+		let s = o.x ?? 0, c = o.y ?? 0, l = o.height ?? 0, u = [];
+		return u = y ? [
+			{
+				x: s - _.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + _.width / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + _.width / 2,
+				y: c - l / 2 + _.height + w
+			},
+			{
+				x: s + m / 2,
+				y: c - l / 2 + _.height + w
+			},
+			{
+				x: s + m / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - m / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - m / 2,
+				y: c - l / 2 + _.height + w
+			},
+			{
+				x: s - _.width / 2,
+				y: c - l / 2 + _.height + w
+			}
+		] : [
+			{
+				x: s - m / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + m / 2,
+				y: c - l / 2
+			},
+			{
+				x: s + m / 2,
+				y: c - l / 2 + h
+			},
+			{
+				x: s + _.width / 2,
+				y: c - l / 2 + h
+			},
+			{
+				x: s + _.width / 2 / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - _.width / 2,
+				y: c + l / 2
+			},
+			{
+				x: s - _.width / 2,
+				y: c - l / 2 + h
+			},
+			{
+				x: s - m / 2,
+				y: c - l / 2 + h
+			}
+		], intersect_default.polygon(o, u, e);
+	}, g;
+}
+__name(imageSquare, "imageSquare");
+async function inv_trapezoid(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = c, u = a.look === "neo" ? c * 2 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = Math.max(f.width + (u ?? 0) * 2, a?.width ?? 0), m = Math.max(f.height + (l ?? 0) * 2, a?.height ?? 0), h = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: p,
+			y: 0
+		},
+		{
+			x: p + 3 * m / 6,
+			y: -m
+		},
+		{
+			x: -3 * m / 6,
+			y: -m
+		}
+	], g, { cssStyles: _ } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = userNodeOverrides(a, {}), s = createPathFromPoints(h), c = e.path(s, o);
+		g = d.insert(() => c, ":first-child").attr("transform", `translate(${-p / 2}, ${m / 2})`), _ && g.attr("style", _);
+	} else g = insertPolygonShape(d, p, m, h);
+	return s && g.attr("style", s), a.width = p, a.height = m, updateNodeBounds(a, g), a.intersect = function(e) {
+		return intersect_default.polygon(a, h, e);
+	}, d;
+}
+__name(inv_trapezoid, "inv_trapezoid");
+async function drawRect(e, a, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(a);
+	a.labelStyle = s;
+	let { shapeSvg: l, bbox: u } = await labelHelper(e, a, getNodeClasses(a)), d = Math.max(u.width + o.labelPaddingX * 2, a?.width || 0), f = Math.max(u.height + o.labelPaddingY * 2, a?.height || 0), p = -d / 2, m = -f / 2, h, { rx: g, ry: v } = a, { cssStyles: y } = a;
+	if (o?.rx && o.ry && (g = o.rx, v = o.ry), a.look === "handDrawn") {
+		let e = at.svg(l), o = userNodeOverrides(a, {}), s = g || v ? e.path(createRoundedRectPathD(p, m, d, f, g || 0), o) : e.rectangle(p, m, d, f, o);
+		h = l.insert(() => s, ":first-child"), h.attr("class", "basic label-container").attr("style", handleUndefinedAttr(y));
+	} else h = l.insert("rect", ":first-child"), h.attr("class", "basic label-container").attr("style", c).attr("rx", handleUndefinedAttr(g)).attr("ry", handleUndefinedAttr(v)).attr("x", p).attr("y", m).attr("width", d).attr("height", f);
+	return updateNodeBounds(a, h), a.calcIntersect = function(e, a) {
+		return intersect_default.rect(e, a);
+	}, a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, l;
+}
+__name(drawRect, "drawRect");
+async function labelRect(e, a) {
+	let { shapeSvg: o, bbox: s, label: c } = await labelHelper(e, a, "label"), l = o.insert("rect", ":first-child");
+	return l.attr("width", .1).attr("height", .1), o.attr("class", "label edgeLabel"), c.attr("transform", `translate(${-(s.width / 2) - (s.x - (s.left ?? 0))}, ${-(s.height / 2) - (s.y - (s.top ?? 0))})`), updateNodeBounds(a, l), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, o;
+}
+__name(labelRect, "labelRect");
+async function lean_left(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = c, u = a.look === "neo" ? c * 2 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.height ?? f.height) + l, m = (a?.width ?? f.width) + u, h = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: m + 3 * p / 6,
+			y: 0
+		},
+		{
+			x: m,
+			y: -p
+		},
+		{
+			x: -(3 * p) / 6,
+			y: -p
+		}
+	], g, { cssStyles: _ } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = userNodeOverrides(a, {}), s = createPathFromPoints(h), c = e.path(s, o);
+		g = d.insert(() => c, ":first-child").attr("transform", `translate(${-m / 2}, ${p / 2})`), _ && g.attr("style", _);
+	} else g = insertPolygonShape(d, m, p, h);
+	return s && g.attr("style", s), a.width = m, a.height = p, updateNodeBounds(a, g), a.intersect = function(e) {
+		return intersect_default.polygon(a, h, e);
+	}, d;
+}
+__name(lean_left, "lean_left");
+async function lean_right(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = c, u = a.look === "neo" ? c * 2 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.height ?? f.height) + l, m = (a?.width ?? f.width) + u, h = [
+		{
+			x: -3 * p / 6,
+			y: 0
+		},
+		{
+			x: m,
+			y: 0
+		},
+		{
+			x: m + 3 * p / 6,
+			y: -p
+		},
+		{
+			x: 0,
+			y: -p
+		}
+	], g, { cssStyles: _ } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = userNodeOverrides(a, {}), s = createPathFromPoints(h), c = e.path(s, o);
+		g = d.insert(() => c, ":first-child").attr("transform", `translate(${-m / 2}, ${p / 2})`), _ && g.attr("style", _);
+	} else g = insertPolygonShape(d, m, p, h);
+	return s && g.attr("style", s), a.width = m, a.height = p, updateNodeBounds(a, g), a.intersect = function(e) {
+		return intersect_default.polygon(a, h, e);
+	}, d;
+}
+__name(lean_right, "lean_right");
+function lightningBolt(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.label = "", o.labelStyle = s;
+	let l = e.insert("g").attr("class", getNodeClasses(o)).attr("id", o.domId ?? o.id), { cssStyles: u } = o, d = Math.max(35, o?.width ?? 0), f = Math.max(35, o?.height ?? 0), p = [
+		{
+			x: d,
+			y: 0
+		},
+		{
+			x: 0,
+			y: f + 7 / 2
+		},
+		{
+			x: d - 14,
+			y: f + 7 / 2
+		},
+		{
+			x: 0,
+			y: 2 * f
+		},
+		{
+			x: d,
+			y: f - 7 / 2
+		},
+		{
+			x: 14,
+			y: f - 7 / 2
+		}
+	], m = at.svg(l), h = userNodeOverrides(o, {});
+	o.look !== "handDrawn" && (h.roughness = 0, h.fillStyle = "solid");
+	let g = createPathFromPoints(p), _ = m.path(g, h), v = l.insert(() => _, ":first-child");
+	return v.attr("class", "outer-path"), u && o.look !== "handDrawn" && v.selectAll("path").attr("style", u), c && o.look !== "handDrawn" && v.selectAll("path").attr("style", c), v.attr("transform", `translate(-${d / 2},${-f})`), updateNodeBounds(o, v), o.intersect = function(e) {
+		return log.info("lightningBolt intersect", o, e), intersect_default.polygon(o, p, e);
+	}, l;
+}
+__name(lightningBolt, "lightningBolt");
+var createCylinderPathD2 = /* @__PURE__ */ __name((e, a, o, s, c, l, u) => [
+	`M${e},${a + l}`,
+	`a${c},${l} 0,0,0 ${o},0`,
+	`a${c},${l} 0,0,0 ${-o},0`,
+	`l0,${s}`,
+	`a${c},${l} 0,0,0 ${o},0`,
+	`l0,${-s}`,
+	`M${e},${a + l + u}`,
+	`a${c},${l} 0,0,0 ${o},0`
+].join(" "), "createCylinderPathD"), createOuterCylinderPathD2 = /* @__PURE__ */ __name((e, a, o, s, c, l, u) => [
+	`M${e},${a + l}`,
+	`M${e + o},${a + l}`,
+	`a${c},${l} 0,0,0 ${-o},0`,
+	`l0,${s}`,
+	`a${c},${l} 0,0,0 ${o},0`,
+	`l0,${-s}`,
+	`M${e},${a + l + u}`,
+	`a${c},${l} 0,0,0 ${o},0`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD2 = /* @__PURE__ */ __name((e, a, o, s, c, l) => [`M${e - o / 2},${-s / 2}`, `a${c},${l} 0,0,0 ${o},0`].join(" "), "createInnerCylinderPathD"), MIN_HEIGHT3 = 10, MIN_WIDTH3 = 10;
+async function linedCylinder(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 24 : c;
+	if (a.width || a.height) {
+		let e = a.width ?? 0;
+		a.width = (a.width ?? 0) - l, a.width < MIN_WIDTH3 && (a.width = MIN_WIDTH3);
+		let o = e / 2 / (2.5 + e / 50);
+		a.height = (a.height ?? 0) - u - o * 3, a.height < MIN_HEIGHT3 && (a.height = MIN_HEIGHT3);
+	}
+	let { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, a, getNodeClasses(a)), m = (a?.width ? a?.width : f.width) + l * 2, h = m / 2, g = h / (2.5 + m / 50), v = (a?.height ? a?.height : f.height) + g + u * 2, y = v * .1, b, { cssStyles: x } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = createOuterCylinderPathD2(0, 0, m, v, h, g, y), s = createInnerCylinderPathD2(0, g, m, v, h, g), c = userNodeOverrides(a, {}), l = e.path(o, c), u = e.path(s, c);
+		d.insert(() => u, ":first-child").attr("class", "line"), b = d.insert(() => l, ":first-child"), b.attr("class", "basic label-container"), x && b.attr("style", x);
+	} else {
+		let e = createCylinderPathD2(0, 0, m, v, h, g, y);
+		b = d.insert("path", ":first-child").attr("d", e).attr("class", "basic label-container outer-path").attr("style", handleUndefinedAttr(x)).attr("style", s);
+	}
+	return b.attr("label-offset-y", g), b.attr("transform", `translate(${-m / 2}, ${-(v / 2 + g)})`), updateNodeBounds(a, b), p.attr("transform", `translate(${-(f.width / 2) - (f.x - (f.left ?? 0))}, ${-(f.height / 2) + g - (f.y - (f.top ?? 0))})`), a.intersect = function(e) {
+		let o = intersect_default.rect(a, e), s = o.x - (a.x ?? 0);
+		if (h != 0 && (Math.abs(s) < (a.width ?? 0) / 2 || Math.abs(s) == (a.width ?? 0) / 2 && Math.abs(o.y - (a.y ?? 0)) > (a.height ?? 0) / 2 - g)) {
+			let c = g * g * (1 - s * s / (h * h));
+			c > 0 && (c = Math.sqrt(c)), c = g - c, e.y - (a.y ?? 0) > 0 && (c = -c), o.y += c;
+		}
+		return o;
+	}, d;
+}
+__name(linedCylinder, "linedCylinder");
+async function linedWaveEdgedRect(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c;
+	(a.width || a.height) && (a.width = (a.width ?? 0) * 10 / 11 - l * 2, a.width < 10 && (a.width = 10), a.height = (a?.height ?? 0) - u * 2, a.height < 10 && (a.height = 10));
+	let { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, a, getNodeClasses(a)), m = (a?.width ? a?.width : f.width) + (l ?? 0) * 2, h = (a?.height ? a?.height : f.height) + (u ?? 0) * 2, g = a.look === "neo" ? h / 4 : h / 8, _ = h + g, { cssStyles: v } = a, y = at.svg(d), b = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = [
+		{
+			x: -m / 2 - m / 2 * .1,
+			y: -_ / 2
+		},
+		{
+			x: -m / 2 - m / 2 * .1,
+			y: _ / 2
+		},
+		...generateFullSineWavePoints(-m / 2 - m / 2 * .1, _ / 2, m / 2 + m / 2 * .1, _ / 2, g, .8),
+		{
+			x: m / 2 + m / 2 * .1,
+			y: -_ / 2
+		},
+		{
+			x: -m / 2 - m / 2 * .1,
+			y: -_ / 2
+		},
+		{
+			x: -m / 2,
+			y: -_ / 2
+		},
+		{
+			x: -m / 2,
+			y: _ / 2 * 1.1
+		},
+		{
+			x: -m / 2,
+			y: -_ / 2
+		}
+	], w = y.polygon(x.map((e) => [e.x, e.y]), b), T = d.insert(() => w, ":first-child");
+	return T.attr("class", "basic label-container outer-path"), v && a.look !== "handDrawn" && T.selectAll("path").attr("style", v), s && a.look !== "handDrawn" && T.selectAll("path").attr("style", s), T.attr("transform", `translate(0,${-g / 2})`), p.attr("transform", `translate(${-m / 2 + (a.padding ?? 0) + m / 2 * .1 / 2 - (f.x - (f.left ?? 0))},${-h / 2 + (a.padding ?? 0) - g / 2 - (f.y - (f.top ?? 0))})`), updateNodeBounds(a, T), a.intersect = function(e) {
+		return intersect_default.polygon(a, x, e);
+	}, d;
+}
+__name(linedWaveEdgedRect, "linedWaveEdgedRect");
+async function multiRect(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c, d = a.look === "neo" ? 10 : 5;
+	(a.width || a.height) && (a.width = Math.max((a?.width ?? 0) - l * 2 - 2 * d, 10), a.height = Math.max((a?.height ?? 0) - u * 2 - 2 * d, 10));
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, a, getNodeClasses(a)), h = (a?.width ? a?.width : p.width) + l * 2 + 2 * d, g = (a?.height ? a?.height : p.height) + u * 2 + 2 * d, _ = h - 2 * d, v = g - 2 * d, y = -_ / 2, b = -v / 2, { cssStyles: x } = a, w = at.svg(f), T = userNodeOverrides(a, {}), D = [
+		{
+			x: y - d,
+			y: b + d
+		},
+		{
+			x: y - d,
+			y: b + v + d
+		},
+		{
+			x: y + _ - d,
+			y: b + v + d
+		},
+		{
+			x: y + _ - d,
+			y: b + v
+		},
+		{
+			x: y + _,
+			y: b + v
+		},
+		{
+			x: y + _,
+			y: b + v - d
+		},
+		{
+			x: y + _ + d,
+			y: b + v - d
+		},
+		{
+			x: y + _ + d,
+			y: b - d
+		},
+		{
+			x: y + d,
+			y: b - d
+		},
+		{
+			x: y + d,
+			y: b
+		},
+		{
+			x: y,
+			y: b
+		},
+		{
+			x: y,
+			y: b + d
+		}
+	], j = [
+		{
+			x: y,
+			y: b + d
+		},
+		{
+			x: y + _ - d,
+			y: b + d
+		},
+		{
+			x: y + _ - d,
+			y: b + v
+		},
+		{
+			x: y + _,
+			y: b + v
+		},
+		{
+			x: y + _,
+			y: b
+		},
+		{
+			x: y,
+			y: b
+		}
+	];
+	a.look !== "handDrawn" && (T.roughness = 0, T.fillStyle = "solid");
+	let M = createPathFromPoints(D), P = w.path(M, T), F = createPathFromPoints(j), I = w.path(F, T);
+	a.look !== "handDrawn" && (P = mergePaths(P), I = mergePaths(I));
+	let L = f.insert("g", ":first-child");
+	return L.insert(() => P), L.insert(() => I), L.attr("class", "basic label-container outer-path"), x && a.look !== "handDrawn" && L.selectAll("path").attr("style", x), s && a.look !== "handDrawn" && L.selectAll("path").attr("style", s), m.attr("transform", `translate(${-(p.width / 2) - d - (p.x - (p.left ?? 0))}, ${-(p.height / 2) + d - (p.y - (p.top ?? 0))})`), updateNodeBounds(a, L), a.intersect = function(e) {
+		return intersect_default.polygon(a, D, e);
+	}, f;
+}
+__name(multiRect, "multiRect");
+async function multiWaveEdgedRectangle(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l, label: u } = await labelHelper(e, a, getNodeClasses(a)), d = a.padding ?? 0, f = a.look === "neo" ? 16 : d, p = a.look === "neo" ? 12 : d, m = !0;
+	(a.width || a.height) && (m = !1, a.width = (a?.width ?? 0) - f * 2, a.height = (a?.height ?? 0) - p * 3);
+	let h = Math.max(l.width, a?.width ?? 0) + f * 2, g = Math.max(l.height, a?.height ?? 0) + p * 3, _ = a.look === "neo" ? g / 4 : g / 8, v = g + (m ? _ / 2 : -_ / 2), y = -h / 2, b = -v / 2, { cssStyles: x } = a, w = generateFullSineWavePoints(y - 10, b + v + 10, y + h - 10, b + v + 10, _, .8), T = w?.[w.length - 1], D = [
+		{
+			x: y - 10,
+			y: b + 10
+		},
+		{
+			x: y - 10,
+			y: b + v + 10
+		},
+		...w,
+		{
+			x: y + h - 10,
+			y: T.y - 10
+		},
+		{
+			x: y + h,
+			y: T.y - 10
+		},
+		{
+			x: y + h,
+			y: T.y - 20
+		},
+		{
+			x: y + h + 10,
+			y: T.y - 20
+		},
+		{
+			x: y + h + 10,
+			y: b - 10
+		},
+		{
+			x: y + 10,
+			y: b - 10
+		},
+		{
+			x: y + 10,
+			y: b
+		},
+		{
+			x: y,
+			y: b
+		},
+		{
+			x: y,
+			y: b + 10
+		}
+	], M = [
+		{
+			x: y,
+			y: b + 10
+		},
+		{
+			x: y + h - 10,
+			y: b + 10
+		},
+		{
+			x: y + h - 10,
+			y: T.y - 10
+		},
+		{
+			x: y + h,
+			y: T.y - 10
+		},
+		{
+			x: y + h,
+			y: b
+		},
+		{
+			x: y,
+			y: b
+		}
+	], N = at.svg(c), P = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (P.roughness = 0, P.fillStyle = "solid");
+	let F = createPathFromPoints(D), I = N.path(F, P), L = createPathFromPoints(M), R = N.path(L, P), z = c.insert(() => I, ":first-child");
+	return z.insert(() => R), z.attr("class", "basic label-container outer-path"), x && a.look !== "handDrawn" && z.selectAll("path").attr("style", x), s && a.look !== "handDrawn" && z.selectAll("path").attr("style", s), z.attr("transform", `translate(0,${-_ / 2})`), u.attr("transform", `translate(${-(l.width / 2) - 10 - (l.x - (l.left ?? 0))}, ${-(l.height / 2) + 10 - _ / 2 - (l.y - (l.top ?? 0))})`), updateNodeBounds(a, z), a.intersect = function(e) {
+		return intersect_default.polygon(a, D, e);
+	}, c;
+}
+__name(multiWaveEdgedRectangle, "multiWaveEdgedRectangle");
+async function note(e, a, { config: { themeVariables: o } }) {
+	let { labelStyles: c, nodeStyles: u } = styles2String(a);
+	a.labelStyle = c, a.useHtmlLabels || getEffectiveHtmlLabels(getConfig()) || (a.centerLabel = !0);
+	let { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, a, getNodeClasses(a)), m = Math.max(f.width + (a.padding ?? 0) * 2, a?.width ?? 0), h = Math.max(f.height + (a.padding ?? 0) * 2, a?.height ?? 0), g = -m / 2, _ = -h / 2, { cssStyles: v } = a, y = at.svg(d), b = userNodeOverrides(a, {
+		fill: o.noteBkgColor,
+		stroke: o.noteBorderColor
+	});
+	a.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+	let x = y.rectangle(g, _, m, h, b), w = d.insert(() => x, ":first-child");
+	return w.attr("class", "basic label-container outer-path"), p.attr("class", "label noteLabel"), v && a.look !== "handDrawn" && w.selectAll("path").attr("style", v), u && a.look !== "handDrawn" && w.selectAll("path").attr("style", u), p.attr("transform", `translate(${-f.width / 2 - (f.x - (f.left ?? 0))}, ${-(f.height / 2) - (f.y - (f.top ?? 0))})`), updateNodeBounds(a, w), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, d;
+}
+__name(note, "note");
+var createDecisionBoxPathD = /* @__PURE__ */ __name((e, a, o) => [
+	`M${e + o / 2},${a}`,
+	`L${e + o},${a - o / 2}`,
+	`L${e + o / 2},${a - o}`,
+	`L${e},${a - o / 2}`,
+	"Z"
+].join(" "), "createDecisionBoxPathD");
+async function question(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l } = await labelHelper(e, a, getNodeClasses(a)), u = l.width + (a.padding ?? 0) + (l.height + (a.padding ?? 0)), d = .5, f = [
+		{
+			x: u / 2,
+			y: 0
+		},
+		{
+			x: u,
+			y: -u / 2
+		},
+		{
+			x: u / 2,
+			y: -u
+		},
+		{
+			x: 0,
+			y: -u / 2
+		}
+	], p, { cssStyles: m } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(c), o = userNodeOverrides(a, {}), s = createDecisionBoxPathD(0, 0, u), l = e.path(s, o);
+		p = c.insert(() => l, ":first-child").attr("transform", `translate(${-u / 2 + d}, ${u / 2})`), m && p.attr("style", m);
+	} else p = insertPolygonShape(c, u, u, f), p.attr("transform", `translate(${-u / 2 + d}, ${u / 2})`);
+	return s && p.attr("style", s), updateNodeBounds(a, p), a.calcIntersect = function(e, a) {
+		let o = e.width, s = [
+			{
+				x: o / 2,
+				y: 0
+			},
+			{
+				x: o,
+				y: -o / 2
+			},
+			{
+				x: o / 2,
+				y: -o
+			},
+			{
+				x: 0,
+				y: -o / 2
+			}
+		], c = intersect_default.polygon(e, s, a);
+		return {
+			x: c.x - .5,
+			y: c.y - .5
+		};
+	}, a.intersect = function(e) {
+		return this.calcIntersect(a, e);
+	}, c;
+}
+__name(question, "question");
+async function rect_left_inv_arrow(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 21 : c ?? 0, u = a.look === "neo" ? 12 : c ?? 0, { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, a, getNodeClasses(a)), m = (a?.width ?? f.width) + (a.look === "neo" ? l * 2 : l), h = (a?.height ?? f.height) + (a.look === "neo" ? u * 2 : u), g = -m / 2, _ = -h / 2, v = _ / 2, y = [
+		{
+			x: g + v,
+			y: _
+		},
+		{
+			x: g,
+			y: 0
+		},
+		{
+			x: g + v,
+			y: -_
+		},
+		{
+			x: -g,
+			y: -_
+		},
+		{
+			x: -g,
+			y: _
+		}
+	], { cssStyles: b } = a, x = at.svg(d), w = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (w.roughness = 0, w.fillStyle = "solid");
+	let T = createPathFromPoints(y), D = x.path(T, w), j = d.insert(() => D, ":first-child");
+	return j.attr("class", "basic label-container outer-path"), b && a.look !== "handDrawn" && j.selectAll("path").attr("style", b), s && a.look !== "handDrawn" && j.selectAll("path").attr("style", s), j.attr("transform", `translate(${-v / 2},0)`), p.attr("transform", `translate(${-v / 2 - f.width / 2 - (f.x - (f.left ?? 0))}, ${-(f.height / 2) - (f.y - (f.top ?? 0))})`), updateNodeBounds(a, j), a.intersect = function(e) {
+		return intersect_default.polygon(a, y, e);
+	}, d;
+}
+__name(rect_left_inv_arrow, "rect_left_inv_arrow");
+async function rectWithTitle(e, o) {
+	let { labelStyles: s, nodeStyles: u } = styles2String(o);
+	o.labelStyle = s;
+	let d;
+	d = o.cssClasses ? "node " + o.cssClasses : "node default";
+	let f = e.insert("g").attr("class", d).attr("id", o.domId || o.id), p = f.insert("g"), h = f.insert("g").attr("class", "label").attr("style", u), g = o.description, _ = o.label, v = await createLabel_default(h, _, o.labelStyle, !0, !0), y = {
+		width: 0,
+		height: 0
+	};
+	if (getEffectiveHtmlLabels(getConfig2())) {
+		let e = v.children[0], a = select_default(v);
+		y = e.getBoundingClientRect(), a.attr("width", y.width), a.attr("height", y.height);
+	}
+	log.info("Text 2", g);
+	let b = g || [], x = v.getBBox(), w = await createLabel_default(h, Array.isArray(b) ? b.join("<br/>") : b, o.labelStyle, !0, !0), T = w.children[0], E = select_default(w);
+	y = T.getBoundingClientRect(), E.attr("width", y.width), E.attr("height", y.height);
+	let D = (o.padding || 0) / 2;
+	select_default(w).attr("transform", "translate( " + (y.width > x.width ? 0 : (x.width - y.width) / 2) + ", " + (x.height + D + 5) + ")"), select_default(v).attr("transform", "translate( " + (y.width < x.width ? 0 : -(x.width - y.width) / 2) + ", 0)"), y = h.node().getBBox(), h.attr("transform", "translate(" + -y.width / 2 + ", " + (-y.height / 2 - D + 3) + ")");
+	let k = y.width + (o.padding || 0), A = y.height + (o.padding || 0), j = -y.width / 2 - D, M = -y.height / 2 - D, N, P;
+	if (o.look === "handDrawn") {
+		let e = at.svg(f), s = userNodeOverrides(o, {}), c = e.path(createRoundedRectPathD(j, M, k, A, o.rx || 0), s), l = e.line(-y.width / 2 - D, -y.height / 2 - D + x.height + D, y.width / 2 + D, -y.height / 2 - D + x.height + D, s);
+		P = f.insert(() => (log.debug("Rough node insert CXC", c), l), ":first-child"), N = f.insert(() => (log.debug("Rough node insert CXC", c), c), ":first-child");
+	} else N = p.insert("rect", ":first-child"), P = p.insert("line"), N.attr("class", "outer title-state").attr("style", u).attr("x", -y.width / 2 - D).attr("y", -y.height / 2 - D).attr("width", y.width + (o.padding || 0)).attr("height", y.height + (o.padding || 0)), P.attr("class", "divider").attr("x1", -y.width / 2 - D).attr("x2", y.width / 2 + D).attr("y1", -y.height / 2 - D + x.height + D).attr("y2", -y.height / 2 - D + x.height + D);
+	return updateNodeBounds(o, N), o.intersect = function(e) {
+		return intersect_default.rect(o, e);
+	}, f;
+}
+__name(rectWithTitle, "rectWithTitle");
+async function roundedRect(e, a, { config: { themeVariables: o } }) {
+	let s = o?.radius ?? 5;
+	return drawRect(e, a, {
+		rx: s,
+		ry: s,
+		classes: "",
+		labelPaddingX: (a?.padding ?? 0) * 1,
+		labelPaddingY: (a?.padding ?? 0) * 1
+	});
+}
+__name(roundedRect, "roundedRect");
+var FRAME_WIDTH = 8;
+async function shadedProcess(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.look === "neo" ? 16 : a.padding ?? 0, l = a.look === "neo" ? 12 : a.padding ?? 0, { shapeSvg: u, bbox: d, label: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.width ?? d.width) + c * 2 + (a.look === "neo" ? FRAME_WIDTH : FRAME_WIDTH * 2), m = (a?.height ?? d.height) + l * 2, h = p - FRAME_WIDTH, g = m, v = FRAME_WIDTH - p / 2, y = -m / 2, { cssStyles: b } = a, x = at.svg(u), w = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (w.roughness = 0, w.fillStyle = "solid");
+	let T = [
+		{
+			x: v,
+			y
+		},
+		{
+			x: v + h,
+			y
+		},
+		{
+			x: v + h,
+			y: y + g
+		},
+		{
+			x: v - FRAME_WIDTH,
+			y: y + g
+		},
+		{
+			x: v - FRAME_WIDTH,
+			y
+		},
+		{
+			x: v,
+			y
+		},
+		{
+			x: v,
+			y: y + g
+		}
+	], D = x.polygon(T.map((e) => [e.x, e.y]), w), A = u.insert(() => D, ":first-child");
+	return A.attr("class", "basic label-container outer-path").attr("style", handleUndefinedAttr(b)), s && a.look !== "handDrawn" && A.selectAll("path").attr("style", s), b && a.look !== "handDrawn" && A.selectAll("path").attr("style", s), f.attr("transform", `translate(${FRAME_WIDTH / 2 - d.width / 2 - (d.x - (d.left ?? 0))}, ${-(d.height / 2) - (d.y - (d.top ?? 0))})`), updateNodeBounds(a, A), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, u;
+}
+__name(shadedProcess, "shadedProcess");
+async function slopedRect(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c;
+	(a.width || a.height) && (a.width = Math.max((a?.width ?? 0) - l * 2, 10), a.height = Math.max((a?.height ?? 0) / 1.5 - u * 2, 10));
+	let { shapeSvg: d, bbox: f, label: p } = await labelHelper(e, a, getNodeClasses(a)), m = (a?.width ? a?.width : f.width) + l * 2, h = ((a?.height ? a?.height : f.height) + u * 2) * 1.5, g = m, _ = h / 1.5, v = -g / 2, y = -_ / 2, { cssStyles: b } = a, x = at.svg(d), w = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (w.roughness = 0, w.fillStyle = "solid");
+	let T = [
+		{
+			x: v,
+			y
+		},
+		{
+			x: v,
+			y: y + _
+		},
+		{
+			x: v + g,
+			y: y + _
+		},
+		{
+			x: v + g,
+			y: y - _ / 2
+		}
+	], D = createPathFromPoints(T), j = x.path(D, w), M = d.insert(() => j, ":first-child");
+	return M.attr("class", "basic label-container  outer-path"), b && a.look !== "handDrawn" && M.selectChildren("path").attr("style", b), s && a.look !== "handDrawn" && M.selectChildren("path").attr("style", s), M.attr("transform", `translate(0, ${_ / 4})`), p.attr("transform", `translate(${-g / 2 + (a.padding ?? 0) - (f.x - (f.left ?? 0))}, ${-_ / 4 + (a.padding ?? 0) - (f.y - (f.top ?? 0))})`), updateNodeBounds(a, M), a.intersect = function(e) {
+		return intersect_default.polygon(a, T, e);
+	}, d;
+}
+__name(slopedRect, "slopedRect");
+async function squareRect2(e, a) {
+	let o = a.padding ?? 0, s = a.look === "neo" ? 16 : o * 2, c = a.look === "neo" ? 12 : o;
+	return drawRect(e, a, {
+		rx: 0,
+		ry: 0,
+		classes: "",
+		labelPaddingX: a.labelPaddingX ?? s,
+		labelPaddingY: c
+	});
+}
+__name(squareRect2, "squareRect");
+async function stadium(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 20 : c, u = a.look === "neo" ? 12 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = f.height + (a.look === "neo" ? u * 2 : u), m = f.width + p / 4 + (a.look === "neo" ? l * 2 : l), h = p / 2, { cssStyles: g } = a, _ = at.svg(d), v = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+	let y = [
+		{
+			x: -m / 2 + h,
+			y: -p / 2
+		},
+		{
+			x: m / 2 - h,
+			y: -p / 2
+		},
+		...generateCirclePoints(-m / 2 + h, 0, h, 50, 90, 270),
+		{
+			x: m / 2 - h,
+			y: p / 2
+		},
+		...generateCirclePoints(m / 2 - h, 0, h, 50, 270, 450)
+	], b = createPathFromPoints(y), x = _.path(b, v), w = d.insert(() => x, ":first-child");
+	return w.attr("class", "basic label-container outer-path"), g && a.look !== "handDrawn" && w.selectChildren("path").attr("style", g), s && a.look !== "handDrawn" && w.selectChildren("path").attr("style", s), updateNodeBounds(a, w), a.intersect = function(e) {
+		return intersect_default.polygon(a, y, e);
+	}, d;
+}
+__name(stadium, "stadium");
+async function state(e, a) {
+	return drawRect(e, a, {
+		rx: a.look === "neo" ? 3 : 5,
+		ry: a.look === "neo" ? 3 : 5,
+		classes: "flowchart-node"
+	});
+}
+__name(state, "state");
+function stateEnd(e, a, { config: { themeVariables: o } }) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(a);
+	a.labelStyle = s;
+	let { cssStyles: l } = a, { lineColor: u, stateBorder: d, nodeBorder: f, nodeShadow: p } = o;
+	(a.width || a.height) && ((a.width ?? 0) < 14 && (a.width = 14), (a.height ?? 0) < 14 && (a.height = 14)), a.width ||= 14, a.height ||= 14;
+	let m = e.insert("g").attr("class", "node default").attr("id", a.domId ?? a.id), h = at.svg(m), g = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (g.roughness = 0, g.fillStyle = "solid");
+	let _ = h.circle(0, 0, a.width, {
+		...g,
+		stroke: u,
+		strokeWidth: 2
+	}), v = d ?? f, y = (a.width ?? 0) * 5 / 14, b = h.circle(0, 0, y, {
+		...g,
+		fill: v,
+		stroke: v,
+		strokeWidth: 2,
+		fillStyle: "solid"
+	}), x = m.insert(() => _, ":first-child");
+	if (x.insert(() => b), a.look !== "handDrawn" && x.attr("class", "outer-path"), l && x.selectAll("path").attr("style", l), c && x.selectAll("path").attr("style", c), a.width < 25 && p && a.look !== "handDrawn") {
+		let a = e.node()?.ownerSVGElement?.id ?? "", o = a ? `${a}-drop-shadow-small` : "drop-shadow-small";
+		x.attr("style", `filter:url(#${o})`);
+	}
+	return updateNodeBounds(a, x), a.intersect = function(e) {
+		return intersect_default.circle(a, (a.width ?? 0) / 2, e);
+	}, m;
+}
+__name(stateEnd, "stateEnd");
+function stateStart(e, a, { config: { themeVariables: o } }) {
+	let { lineColor: s, nodeShadow: c } = o;
+	(a.width || a.height) && ((a.width ?? 0) < 14 && (a.width = 14), (a.height ?? 0) < 14 && (a.height = 14)), a.width ||= 14, a.height ||= 14;
+	let l = e.insert("g").attr("class", "node default").attr("id", a.domId || a.id), u;
+	if (a.look === "handDrawn") {
+		let e = at.svg(l).circle(0, 0, a.width, solidStateFill(s));
+		u = l.insert(() => e), u.attr("class", "state-start").attr("r", (a.width ?? 7) / 2).attr("width", a.width ?? 14).attr("height", a.height ?? 14);
+	} else u = l.insert("circle", ":first-child"), u.attr("class", "state-start").attr("r", (a.width ?? 7) / 2).attr("width", a.width ?? 14).attr("height", a.height ?? 14);
+	if (a.width < 25 && c && a.look !== "handDrawn") {
+		let a = e.node()?.ownerSVGElement?.id ?? "", o = a ? `${a}-drop-shadow-small` : "drop-shadow-small";
+		u.attr("style", `filter:url(#${o})`);
+	}
+	return updateNodeBounds(a, u), a.intersect = function(e) {
+		return intersect_default.circle(a, (a.width ?? 7) / 2, e);
+	}, l;
+}
+__name(stateStart, "stateStart");
+var FRAME_WIDTH2 = 8;
+async function subroutine(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a?.padding ?? 8, l = a.look === "neo" ? 28 : c, u = a.look === "neo" ? 12 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.width ?? f.width) + 2 * FRAME_WIDTH2 + l, m = (a?.height ?? f.height) + u, h = p - 2 * FRAME_WIDTH2, g = m, v = -p / 2, y = -m / 2, b = [
+		{
+			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 (a.look === "handDrawn") {
+		let e = at.svg(d), o = userNodeOverrides(a, {}), s = e.rectangle(v, y, h + 16, g, o), c = e.line(v + FRAME_WIDTH2, y, v + FRAME_WIDTH2, y + g, o), l = e.line(v + FRAME_WIDTH2 + h, y, v + FRAME_WIDTH2 + h, y + g, o);
+		d.insert(() => c, ":first-child"), d.insert(() => l, ":first-child");
+		let u = d.insert(() => s, ":first-child"), { cssStyles: f } = a;
+		u.attr("class", "basic label-container").attr("style", handleUndefinedAttr(f)), updateNodeBounds(a, u);
+	} else {
+		let e = insertPolygonShape(d, h, g, b);
+		s && e.attr("style", s), updateNodeBounds(a, e);
+	}
+	return a.intersect = function(e) {
+		return intersect_default.polygon(a, b, e);
+	}, d;
+}
+__name(subroutine, "subroutine");
+var TAG_RATIO = .2;
+async function taggedRect(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c;
+	(a.width || a.height) && (a.height = Math.max((a?.height ?? 0) - u * 2, 10), a.width = Math.max((a?.width ?? 0) - l * 2 - TAG_RATIO * (a.height + u * 2), 10));
+	let { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.height ? a?.height : f.height) + u * 2, m = TAG_RATIO * p, h = TAG_RATIO * p, g = (a?.width ? a?.width : f.width) + l * 2 + m - m, _ = p, v = -g / 2, y = -_ / 2, { cssStyles: b } = a, x = at.svg(d), w = userNodeOverrides(a, {}), T = [
+		{
+			x: v - m / 2,
+			y
+		},
+		{
+			x: v + g + m / 2,
+			y
+		},
+		{
+			x: v + g + m / 2,
+			y: y + _
+		},
+		{
+			x: v - m / 2,
+			y: y + _
+		}
+	], D = [
+		{
+			x: v + g - m / 2,
+			y: y + _
+		},
+		{
+			x: v + g + m / 2,
+			y: y + _
+		},
+		{
+			x: v + g + m / 2,
+			y: y + _ - h
+		}
+	];
+	a.look !== "handDrawn" && (w.roughness = 0, w.fillStyle = "solid");
+	let j = createPathFromPoints(T), M = x.path(j, w), N = createPathFromPoints(D), P = x.path(N, {
+		...w,
+		fillStyle: "solid"
+	}), F = d.insert(() => P, ":first-child");
+	return F.insert(() => M, ":first-child"), F.attr("class", "basic label-container outer-path"), b && a.look !== "handDrawn" && F.selectAll("path").attr("style", b), s && a.look !== "handDrawn" && F.selectAll("path").attr("style", s), updateNodeBounds(a, F), a.intersect = function(e) {
+		return intersect_default.polygon(a, T, e);
+	}, d;
+}
+__name(taggedRect, "taggedRect");
+async function taggedWaveEdgedRectangle(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l, label: u } = await labelHelper(e, a, getNodeClasses(a)), d = Math.max(l.width + (a.padding ?? 0) * 2, a?.width ?? 0), f = Math.max(l.height + (a.padding ?? 0) * 2, a?.height ?? 0), p = f / 8, m = .2 * d, h = .2 * f, g = f + p, { cssStyles: _ } = a, v = at.svg(c), y = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+	let b = [
+		{
+			x: -d / 2 - d / 2 * .1,
+			y: g / 2
+		},
+		...generateFullSineWavePoints(-d / 2 - d / 2 * .1, g / 2, d / 2 + d / 2 * .1, g / 2, p, .8),
+		{
+			x: d / 2 + d / 2 * .1,
+			y: -g / 2
+		},
+		{
+			x: -d / 2 - d / 2 * .1,
+			y: -g / 2
+		}
+	], x = -d / 2 + d / 2 * .1, w = -g / 2 - h * .4, T = [
+		{
+			x: x + d - m,
+			y: (w + f) * 1.3
+		},
+		{
+			x: x + d,
+			y: w + f - h
+		},
+		{
+			x: x + d,
+			y: (w + f) * .9
+		},
+		...generateFullSineWavePoints(x + d, (w + f) * 1.25, x + d - m, (w + f) * 1.3, -f * .02, .5)
+	], D = createPathFromPoints(b), M = v.path(D, y), N = createPathFromPoints(T), P = v.path(N, {
+		...y,
+		fillStyle: "solid"
+	}), F = c.insert(() => P, ":first-child");
+	return F.insert(() => M, ":first-child"), F.attr("class", "basic label-container outer-path"), _ && a.look !== "handDrawn" && F.selectAll("path").attr("style", _), s && a.look !== "handDrawn" && F.selectAll("path").attr("style", s), F.attr("transform", `translate(0,${-p / 2})`), u.attr("transform", `translate(${-d / 2 + (a.padding ?? 0) - (l.x - (l.left ?? 0))},${-f / 2 + (a.padding ?? 0) - p / 2 - (l.y - (l.top ?? 0))})`), updateNodeBounds(a, F), a.intersect = function(e) {
+		return intersect_default.polygon(a, b, e);
+	}, c;
+}
+__name(taggedWaveEdgedRectangle, "taggedWaveEdgedRectangle");
+async function text(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l } = await labelHelper(e, a, getNodeClasses(a)), u = Math.max(l.width + (a.padding ?? 0), a?.width || 0), d = Math.max(l.height + (a.padding ?? 0), a?.height || 0), f = -u / 2, p = -d / 2, m = c.insert("rect", ":first-child");
+	return m.attr("class", "text").attr("style", s).attr("rx", 0).attr("ry", 0).attr("x", f).attr("y", p).attr("width", u).attr("height", d), updateNodeBounds(a, m), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, c;
+}
+__name(text, "text");
+var createCylinderPathD3 = /* @__PURE__ */ __name((e, a, o, s, c, l) => `M${e},${a}
+    a${c},${l} 0,0,1 0,${-s}
+    l${o},0
+    a${c},${l} 0,0,1 0,${s}
+    M${o},${-s}
+    a${c},${l} 0,0,0 0,${s}
+    l${-o},0`, "createCylinderPathD"), createOuterCylinderPathD3 = /* @__PURE__ */ __name((e, a, o, s, c, l) => [
+	`M${e},${a}`,
+	`M${e + o},${a}`,
+	`a${c},${l} 0,0,0 0,${-s}`,
+	`l${-o},0`,
+	`a${c},${l} 0,0,0 0,${s}`,
+	`l${o},0`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD3 = /* @__PURE__ */ __name((e, a, o, s, c, l) => [`M${e + o / 2},${-s / 2}`, `a${c},${l} 0,0,0 0,${s}`].join(" "), "createInnerCylinderPathD"), MIN_HEIGHT4 = 5, MIN_WIDTH4 = 10;
+async function tiltedCylinder(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 12 : c / 2;
+	if (a.width || a.height) {
+		let e = a.height ?? 0;
+		a.height = (a.height ?? 0) - l, a.height < MIN_HEIGHT4 && (a.height = MIN_HEIGHT4);
+		let o = e / 2 / (2.5 + e / 50);
+		a.width = (a.width ?? 0) - l - o * 3, a.width < MIN_WIDTH4 && (a.width = MIN_WIDTH4);
+	}
+	let { shapeSvg: u, bbox: d, label: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a.height ? a.height : d.height) + l, m = p / 2, h = m / (2.5 + p / 50), g = (a.width ? a.width : d.width) + h + l, { cssStyles: v } = a, y;
+	if (a.look === "handDrawn") {
+		let e = at.svg(u), o = createOuterCylinderPathD3(0, 0, g, p, h, m), s = createInnerCylinderPathD3(0, 0, g, p, h, m), c = e.path(o, userNodeOverrides(a, {})), l = e.path(s, userNodeOverrides(a, { fill: "none" }));
+		y = u.insert(() => l, ":first-child"), y = u.insert(() => c, ":first-child"), y.attr("class", "basic label-container"), v && y.attr("style", v);
+	} else {
+		let e = createCylinderPathD3(0, 0, g, p, h, m);
+		y = u.insert("path", ":first-child").attr("d", e).attr("class", "basic label-container").attr("style", handleUndefinedAttr(v)).attr("style", s), y.attr("class", "basic label-container outer-path"), v && y.selectAll("path").attr("style", v), s && y.selectAll("path").attr("style", s);
+	}
+	return y.attr("label-offset-x", h), y.attr("transform", `translate(${-g / 2}, ${p / 2} )`), f.attr("transform", `translate(${-(d.width / 2) - h - (d.x - (d.left ?? 0))}, ${-(d.height / 2) - (d.y - (d.top ?? 0))})`), updateNodeBounds(a, y), a.intersect = function(e) {
+		let o = intersect_default.rect(a, e), s = o.y - (a.y ?? 0);
+		if (m != 0 && (Math.abs(s) < (a.height ?? 0) / 2 || Math.abs(s) == (a.height ?? 0) / 2 && Math.abs(o.x - (a.x ?? 0)) > (a.width ?? 0) / 2 - h)) {
+			let c = h * h * (1 - s * s / (m * m));
+			c != 0 && (c = Math.sqrt(Math.abs(c))), c = h - c, e.x - (a.x ?? 0) > 0 && (c = -c), o.x += c;
+		}
+		return o;
+	}, u;
+}
+__name(tiltedCylinder, "tiltedCylinder");
+async function trapezoid(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = (a.look, c), u = a.look === "neo" ? c * 2 : c, { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.height ?? f.height) + l, m = (a?.width ?? f.width) + u, h = [
+		{
+			x: -3 * p / 6,
+			y: 0
+		},
+		{
+			x: m + 3 * p / 6,
+			y: 0
+		},
+		{
+			x: m,
+			y: -p
+		},
+		{
+			x: 0,
+			y: -p
+		}
+	], g, { cssStyles: _ } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(d), o = userNodeOverrides(a, {}), s = createPathFromPoints(h), c = e.path(s, o);
+		g = d.insert(() => c, ":first-child").attr("transform", `translate(${-m / 2}, ${p / 2})`), _ && g.attr("style", _);
+	} else g = insertPolygonShape(d, m, p, h);
+	return s && g.attr("style", s), a.width = m, a.height = p, updateNodeBounds(a, g), a.intersect = function(e) {
+		return intersect_default.polygon(a, h, e);
+	}, d;
+}
+__name(trapezoid, "trapezoid");
+async function trapezoidalPentagon(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c;
+	(a.width || a.height) && (a.height = (a.height ?? 0) - u * 2, a.height < 5 && (a.height = 5), a.width = (a.width ?? 0) - l * 2, a.width < 15 && (a.width = 15));
+	let { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.width ? a?.width : f.width) + l * 2, m = (a?.height ? a?.height : f.height) + u * 2, { cssStyles: h } = a, g = at.svg(d), _ = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (_.roughness = 0, _.fillStyle = "solid");
+	let v = [
+		{
+			x: -p / 2 * .8,
+			y: -m / 2
+		},
+		{
+			x: p / 2 * .8,
+			y: -m / 2
+		},
+		{
+			x: p / 2,
+			y: -m / 2 * .6
+		},
+		{
+			x: p / 2,
+			y: m / 2
+		},
+		{
+			x: -p / 2,
+			y: m / 2
+		},
+		{
+			x: -p / 2,
+			y: -m / 2 * .6
+		}
+	], y = createPathFromPoints(v), b = g.path(y, _), x = d.insert(() => b, ":first-child");
+	return x.attr("class", "basic label-container outer-path"), h && a.look !== "handDrawn" && x.selectChildren("path").attr("style", h), s && a.look !== "handDrawn" && x.selectChildren("path").attr("style", s), updateNodeBounds(a, x), a.intersect = function(e) {
+		return intersect_default.polygon(a, v, e);
+	}, d;
+}
+__name(trapezoidalPentagon, "trapezoidalPentagon");
+var MIN_HEIGHT5 = 10, MIN_WIDTH5 = 10;
+async function triangle(e, s) {
+	let { labelStyles: l, nodeStyles: u } = styles2String(s);
+	s.labelStyle = l;
+	let d = s.padding ?? 0, f = s.look === "neo" ? d * 2 : d;
+	(s.width || s.height) && (s.width = ((s?.width ?? 0) - f) / 2, s.width < MIN_WIDTH5 && (s.width = MIN_WIDTH5), s.height = s?.height ?? 0, s.height < MIN_HEIGHT5 && (s.height = MIN_HEIGHT5));
+	let { shapeSvg: p, bbox: m, label: h } = await labelHelper(e, s, getNodeClasses(s)), g = evaluate(getConfig2().flowchart?.htmlLabels), _ = (s?.width ? s?.width : m.width) + f, v = s?.height ? s?.height : _ + m.height, y = v, b = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: y,
+			y: 0
+		},
+		{
+			x: y / 2,
+			y: -v
+		}
+	], { cssStyles: x } = s, w = at.svg(p), T = userNodeOverrides(s, {});
+	s.look !== "handDrawn" && (T.roughness = 0, T.fillStyle = "solid");
+	let D = createPathFromPoints(b), j = w.path(D, T), M = p.insert(() => j, ":first-child").attr("transform", `translate(${-v / 2}, ${v / 2})`).attr("class", "outer-path");
+	return x && s.look !== "handDrawn" && M.selectChildren("path").attr("style", x), u && s.look !== "handDrawn" && M.selectChildren("path").attr("style", u), s.width = _, s.height = v, updateNodeBounds(s, M), h.attr("transform", `translate(${-m.width / 2 - (m.x - (m.left ?? 0))}, ${v / 2 - (m.height + (s.padding ?? 0) / (g ? 2 : 1) - (m.y - (m.top ?? 0)))})`), s.intersect = function(e) {
+		return log.info("Triangle intersect", s, b, e), intersect_default.polygon(s, b, e);
+	}, p;
+}
+__name(triangle, "triangle");
+async function waveEdgedRectangle(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 12 : c, d = !0;
+	(a.width || a.height) && (d = !1, a.width = (a?.width ?? 0) - l * 2, a.width < 10 && (a.width = 10), a.height = (a?.height ?? 0) - u * 2, a.height < 10 && (a.height = 10));
+	let { shapeSvg: f, bbox: p, label: m } = await labelHelper(e, a, getNodeClasses(a)), h = (a?.width ? a?.width : p.width) + (l ?? 0) * 2, g = (a?.height ? a?.height : p.height) + (u ?? 0) * 2, _ = a.look === "neo" ? g / 4 : g / 8, v = g + (d ? _ : -_), { cssStyles: y } = a, b = 14 - h, x = b > 0 ? b / 2 : 0, w = at.svg(f), T = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (T.roughness = 0, T.fillStyle = "solid");
+	let D = [
+		{
+			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
+		}
+	], M = createPathFromPoints(D), N = w.path(M, T), P = f.insert(() => N, ":first-child");
+	return P.attr("class", "basic label-container outer-path"), y && a.look !== "handDrawn" && P.selectAll("path").attr("style", y), s && a.look !== "handDrawn" && P.selectAll("path").attr("style", s), P.attr("transform", `translate(0,${-_ / 2})`), m.attr("transform", `translate(${-h / 2 + (a.padding ?? 0) - (p.x - (p.left ?? 0))},${-g / 2 + (a.padding ?? 0) - _ - (p.y - (p.top ?? 0))})`), updateNodeBounds(a, P), a.intersect = function(e) {
+		return intersect_default.polygon(a, D, e);
+	}, f;
+}
+__name(waveEdgedRectangle, "waveEdgedRectangle");
+async function waveRectangle(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.padding ?? 0, l = a.look === "neo" ? 16 : c, u = a.look === "neo" ? 20 : c;
+	if (a.width || a.height) {
+		a.width = a?.width ?? 0, a.width < 20 && (a.width = 20), a.height = a?.height ?? 0, a.height < 10 && (a.height = 10);
+		let e = Math.min(a.height * .2, a.height / 4);
+		a.height = Math.ceil(a.height - u - 20 / 9 * e), a.width -= l * 2;
+	}
+	let { shapeSvg: d, bbox: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.width ? a?.width : f.width) + l * 2, m = (a?.height ? a?.height : f.height) + u, h = m / 8, g = m + h * 2, { cssStyles: _ } = a, v = at.svg(d), y = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+	let b = [
+		{
+			x: -p / 2,
+			y: g / 2
+		},
+		...generateFullSineWavePoints(-p / 2, g / 2, p / 2, g / 2, h, 1),
+		{
+			x: p / 2,
+			y: -g / 2
+		},
+		...generateFullSineWavePoints(p / 2, -g / 2, -p / 2, -g / 2, h, -1)
+	], x = createPathFromPoints(b), w = v.path(x, y), T = d.insert(() => w, ":first-child");
+	return T.attr("class", "basic label-container"), _ && a.look !== "handDrawn" && T.selectAll("path").attr("style", _), s && a.look !== "handDrawn" && T.selectAll("path").attr("style", s), updateNodeBounds(a, T), a.intersect = function(e) {
+		return intersect_default.polygon(a, b, e);
+	}, d;
+}
+__name(waveRectangle, "waveRectangle");
+var rectOffset = 10;
+async function windowPane(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let c = a.look === "neo" ? 16 : a.padding ?? 0, l = a.look === "neo" ? 12 : a.padding ?? 0;
+	(a.width || a.height) && (a.width = Math.max((a?.width ?? 0) - c * 2 - rectOffset, 10), a.height = Math.max((a?.height ?? 0) - l * 2 - rectOffset, 10));
+	let { shapeSvg: u, bbox: d, label: f } = await labelHelper(e, a, getNodeClasses(a)), p = (a?.width ? a?.width : d.width) + c * 2 + rectOffset, m = (a?.height ? a?.height : d.height) + l * 2 + rectOffset, h = p - rectOffset, g = m - rectOffset, _ = -h / 2, v = -g / 2, { cssStyles: y } = a, b = at.svg(u), x = userNodeOverrides(a, {}), w = [
+		{
+			x: _ - rectOffset,
+			y: v - rectOffset
+		},
+		{
+			x: _ - rectOffset,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v + g
+		},
+		{
+			x: _ + h,
+			y: v - rectOffset
+		}
+	], T = `M${_ - rectOffset},${v - rectOffset} L${_ + h},${v - rectOffset} L${_ + h},${v + g} L${_ - rectOffset},${v + g} L${_ - rectOffset},${v - rectOffset}
+                M${_ - rectOffset},${v} L${_ + h},${v}
+                M${_},${v - rectOffset} L${_},${v + g}`;
+	a.look !== "handDrawn" && (x.roughness = 0, x.fillStyle = "solid");
+	let D = b.path(T, x), A = u.insert(() => D, ":first-child");
+	return A.attr("transform", `translate(${rectOffset / 2}, ${rectOffset / 2})`), A.attr("class", "basic label-container outer-path"), y && a.look !== "handDrawn" && A.selectAll("path").attr("style", y), s && a.look !== "handDrawn" && A.selectAll("path").attr("style", s), f.attr("transform", `translate(${-(d.width / 2) + rectOffset / 2 - (d.x - (d.left ?? 0))}, ${-(d.height / 2) + rectOffset / 2 - (d.y - (d.top ?? 0))})`), updateNodeBounds(a, A), a.intersect = function(e) {
+		return intersect_default.polygon(a, w, e);
+	}, u;
+}
+__name(windowPane, "windowPane");
+var COLOR_THEMES = /* @__PURE__ */ new Set(["redux-color", "redux-dark-color"]), REDUX_THEMES = /* @__PURE__ */ new Set([
+	"redux",
+	"redux-dark",
+	"redux-color",
+	"redux-dark-color"
+]);
+async function erBox(e, a) {
+	let c = a;
+	c.alias && (a.label = c.alias);
+	let { theme: l, themeVariables: u } = getConfig(), { rowEven: d, rowOdd: f, nodeBorder: p, borderColorArray: g } = u;
+	if (a.look === "handDrawn") {
+		let { themeVariables: o } = getConfig(), { background: c } = o;
+		await erBox(e, {
+			...a,
+			id: a.id + "-background",
+			domId: (a.domId || a.id) + "-background",
+			look: "default",
+			cssStyles: ["stroke: none", `fill: ${c}`]
+		});
+	}
+	let _ = getConfig();
+	a.useHtmlLabels = _.htmlLabels;
+	let v = _.er?.diagramPadding ?? 10, y = _.er?.entityPadding ?? 6, { cssStyles: b } = a, { labelStyles: x, nodeStyles: w } = styles2String(a);
+	if (c.attributes.length === 0 && a.label) {
+		let s = {
+			rx: 0,
+			ry: 0,
+			labelPaddingX: v,
+			labelPaddingY: v * 1.5,
+			classes: ""
+		};
+		calculateTextWidth(a.label, _) + s.labelPaddingX * 2 < _.er.minEntityWidth && (a.width = _.er.minEntityWidth);
+		let u = await drawRect(e, a, s);
+		if (l != null && COLOR_THEMES.has(l)) {
+			let e = c.colorIndex ?? 0;
+			u.attr("data-color-id", `color-${e % g.length}`);
+		}
+		if (!evaluate(_.htmlLabels)) {
+			let e = u.select("text"), a = e.node()?.getBBox();
+			e.attr("transform", `translate(${-a.width / 2}, 0)`);
+		}
+		return u;
+	}
+	_.htmlLabels || (v *= 1.25, y *= 1.25);
+	let T = getNodeClasses(a);
+	T ||= "node default";
+	let E = e.insert("g").attr("class", T).attr("id", a.domId || a.id), D = await addText(E, a.label ?? "", _, 0, 0, ["name"], x);
+	D.height += y;
+	let A = 0, j = [], M = [], N = 0, P = 0, F = 0, I = 0, L = !0, R = !0;
+	for (let e of c.attributes) {
+		let a = await addText(E, e.type, _, 0, A, ["attribute-type"], x);
+		N = Math.max(N, a.width + v);
+		let o = await addText(E, e.name, _, 0, A, ["attribute-name"], x);
+		P = Math.max(P, o.width + v);
+		let s = await addText(E, e.keys.join(), _, 0, A, ["attribute-keys"], x);
+		F = Math.max(F, s.width + v);
+		let c = await addText(E, e.comment, _, 0, A, ["attribute-comment"], x);
+		I = Math.max(I, c.width + v);
+		let l = Math.max(a.height, o.height, s.height, c.height) + y;
+		M.push({
+			yOffset: A,
+			rowHeight: l
+		}), A += l;
+	}
+	let z = 4;
+	F <= v && (L = !1, F = 0, z--), I <= v && (R = !1, I = 0, z--);
+	let B = E.node().getBBox();
+	if (D.width + v * 2 - (N + P + F + I) > 0) {
+		let e = D.width + v * 2 - (N + P + F + I);
+		N += e / z, P += e / z, F > 0 && (F += e / z), I > 0 && (I += e / z);
+	}
+	let V = N + P + F + I, H = at.svg(E), U = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (U.roughness = 0, U.fillStyle = "solid");
+	let W = 0;
+	M.length > 0 && (W = M.reduce((e, a) => e + (a?.rowHeight ?? 0), 0));
+	let G = Math.max(B.width + v * 2, a?.width || 0, V), K = Math.max((W ?? 0) + D.height, a?.height || 0), q = -G / 2, J = -K / 2;
+	if (E.selectAll("g:not(:first-child)").each((e, a, o) => {
+		let s = select_default(o[a]), c = s.attr("transform"), l = 0, u = 0;
+		if (c) {
+			let e = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(c);
+			e && (l = parseFloat(e[1]), u = parseFloat(e[2]), s.attr("class").includes("attribute-name") ? l += N : s.attr("class").includes("attribute-keys") ? l += N + P : s.attr("class").includes("attribute-comment") && (l += N + P + F));
+		}
+		s.attr("transform", `translate(${q + v / 2 + l}, ${u + J + D.height + y / 2})`);
+	}), E.select(".name").attr("transform", "translate(" + -D.width / 2 + ", " + (J + y / 2) + ")"), l != null && COLOR_THEMES.has(l)) {
+		let e = c.colorIndex ?? 0;
+		E.attr("data-color-id", `color-${e % g.length}`);
+	}
+	let Y = H.rectangle(q, J, G, K, U), X = E.insert(() => Y, ":first-child").attr("class", "outer-path").attr("style", b.join(""));
+	j.push(0);
+	for (let [e, a] of M.entries()) {
+		let o = (e + 1) % 2 == 0 && a.yOffset !== 0, s = H.rectangle(q, D.height + J + a?.yOffset, G, a?.rowHeight, {
+			...U,
+			fill: o ? d : f,
+			stroke: p
+		});
+		E.insert(() => s, "g.label").attr("style", b.join("")).attr("class", `row-rect-${o ? "even" : "odd"}`);
+	}
+	let Z = 1e-4, Q = lineToPolygon(q, D.height + J, G + q, D.height + J, Z), $ = H.polygon(Q.map((e) => [e.x, e.y]), U);
+	if (E.insert(() => $).attr("class", "divider"), Q = lineToPolygon(N + q, D.height + J, N + q, K + J, Z), $ = H.polygon(Q.map((e) => [e.x, e.y]), U), E.insert(() => $).attr("class", "divider"), L) {
+		let e = N + P + q;
+		Q = lineToPolygon(e, D.height + J, e, K + J, Z), $ = H.polygon(Q.map((e) => [e.x, e.y]), U), E.insert(() => $).attr("class", "divider");
+	}
+	if (R) {
+		let e = N + P + F + q;
+		Q = lineToPolygon(e, D.height + J, e, K + J, Z), $ = H.polygon(Q.map((e) => [e.x, e.y]), U), E.insert(() => $).attr("class", "divider");
+	}
+	for (let e of j) {
+		let a = D.height + J + e;
+		Q = lineToPolygon(q, a, G + q, a, Z), $ = H.polygon(Q.map((e) => [e.x, e.y]), U), E.insert(() => $).attr("class", "divider");
+	}
+	if (updateNodeBounds(a, X), w && a.look !== "handDrawn") if (l != null && REDUX_THEMES.has(l)) E.selectAll("path").attr("style", w);
+	else {
+		let e = w.split(";")?.filter((e) => e.includes("stroke"))?.map((e) => `${e}`).join("; ");
+		E.selectAll("path").attr("style", e ?? ""), E.selectAll(".row-rect-even path").attr("style", w);
+	}
+	return a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, E;
+}
+__name(erBox, "erBox");
+async function addText(e, a, s, c = 0, l = 0, u = [], f = "") {
+	let p = e.insert("g").attr("class", `label ${u.join(" ")}`).attr("transform", `translate(${c}, ${l})`).attr("style", f);
+	a !== parseGenericTypes(a) && (a = parseGenericTypes(a), a = a.replaceAll("<", "&lt;").replaceAll(">", "&gt;"));
+	let g = p.node().appendChild(await createText(p, a, {
+		width: calculateTextWidth(a, s) + 100,
+		style: f,
+		useHtmlLabels: s.htmlLabels
+	}, s));
+	if (a.includes("&lt;") || a.includes("&gt;")) {
+		let e = g.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 _ = g.getBBox();
+	if (evaluate(s.htmlLabels)) {
+		let e = g.children[0];
+		e.style.textAlign = "start";
+		let a = select_default(g);
+		_ = e.getBoundingClientRect(), a.attr("width", _.width), a.attr("height", _.height);
+	}
+	return _;
+}
+__name(addText, "addText");
+function lineToPolygon(e, a, o, s, c) {
+	return e === o ? [
+		{
+			x: e - c / 2,
+			y: a
+		},
+		{
+			x: e + c / 2,
+			y: a
+		},
+		{
+			x: o + c / 2,
+			y: s
+		},
+		{
+			x: o - c / 2,
+			y: s
+		}
+	] : [
+		{
+			x: e,
+			y: a - c / 2
+		},
+		{
+			x: e,
+			y: a + c / 2
+		},
+		{
+			x: o,
+			y: s + c / 2
+		},
+		{
+			x: o,
+			y: s - c / 2
+		}
+	];
+}
+__name(lineToPolygon, "lineToPolygon");
+async function textHelper(e, a, o, s, c = o.class.padding ?? 12) {
+	let l = s ? 0 : 3, u = e.insert("g").attr("class", getNodeClasses(a)).attr("id", a.domId || a.id), d = null, f = null, p = null, m = null, h = 0, g = 0, _ = 0;
+	if (d = u.insert("g").attr("class", "annotation-group text"), a.annotations.length > 0) {
+		let e = a.annotations[0];
+		await addText2(d, { text: `\xAB${e}\xBB` }, 0), h = d.node().getBBox().height;
+	}
+	f = u.insert("g").attr("class", "label-group text"), await addText2(f, a, 0, ["font-weight: bolder"]);
+	let v = f.node().getBBox();
+	g = v.height, p = u.insert("g").attr("class", "members-group text");
+	let y = 0;
+	for (let e of a.members) {
+		let a = await addText2(p, e, y, [e.parseClassifier()]);
+		y += a + l;
+	}
+	_ = p.node().getBBox().height, _ <= 0 && (_ = c / 2), m = u.insert("g").attr("class", "methods-group text");
+	let b = 0;
+	for (let e of a.methods) {
+		let a = await addText2(m, e, b, [e.parseClassifier()]);
+		b += a + l;
+	}
+	let x = u.node().getBBox();
+	if (d !== null) {
+		let e = d.node().getBBox();
+		d.attr("transform", `translate(${-e.width / 2})`);
+	}
+	return f.attr("transform", `translate(${-v.width / 2}, ${h})`), x = u.node().getBBox(), p.attr("transform", `translate(0, ${h + g + c * 2})`), x = u.node().getBBox(), m.attr("transform", `translate(0, ${h + g + (_ ? _ + c * 4 : c * 2)})`), x = u.node().getBBox(), {
+		shapeSvg: u,
+		bbox: x
+	};
+}
+__name(textHelper, "textHelper");
+async function addText2(a, c, l, d = []) {
+	let f = a.insert("g").attr("class", "label").attr("style", d.join("; ")), _ = getConfig(), v = "useHtmlLabels" in c ? c.useHtmlLabels : evaluate(_.htmlLabels) ?? !0, y = "";
+	y = "text" in c ? c.text : c.label, !v && y.startsWith("\\") && (y = y.substring(1)), hasKatex(y) && (v = !0);
+	let b = await createText(f, sanitizeText3(decodeEntities(y)), {
+		width: calculateTextWidth(y, _) + 50,
+		classes: "markdown-node-label",
+		useHtmlLabels: v
+	}, _), x, S = 1;
+	if (v) {
+		let a = b.children[0], o = select_default(b);
+		S = a.innerHTML.split("<br>").length, a.innerHTML.includes("</math>") && (S += a.innerHTML.split("<mrow>").length - 1);
+		let s = a.getElementsByTagName("img");
+		if (s) {
+			let a = y.replace(/<img[^>]*>/g, "").trim() === "";
+			await Promise.all([...s].map((o) => new Promise((s) => {
+				function c() {
+					if (o.style.display = "flex", o.style.flexDirection = "column", a) {
+						let e = _.fontSize?.toString() ?? window.getComputedStyle(document.body).fontSize, a = parseInt(e, 10) * 5 + "px";
+						o.style.minWidth = a, o.style.maxWidth = a;
+					} else o.style.width = "100%";
+					s(o);
+				}
+				__name(c, "setupImage"), setTimeout(() => {
+					o.complete && c();
+				}), o.addEventListener("error", c), o.addEventListener("load", c);
+			})));
+		}
+		x = a.getBoundingClientRect(), o.attr("width", x.width), o.attr("height", x.height);
+	} else {
+		d.includes("font-weight: bolder") && select_default(b).selectAll("tspan").attr("font-weight", ""), S = b.children.length;
+		let e = b.children[0];
+		(b.textContent === "" || b.textContent.includes("&gt")) && (e.textContent = y[0] + y.substring(1).replaceAll("&gt;", ">").replaceAll("&lt;", "<").trim(), y[1] === " " && (e.textContent = e.textContent[0] + " " + e.textContent.substring(1))), e.textContent === "undefined" && (e.textContent = ""), x = b.getBBox();
+	}
+	return f.attr("transform", "translate(0," + (-x.height / (2 * S) + l) + ")"), x.height;
+}
+__name(addText2, "addText");
+async function classBox(e, a) {
+	let s = getConfig2(), { themeVariables: l } = s, { useGradient: u } = l, d = s.class.padding ?? 12, f = d, p = a.useHtmlLabels ?? evaluate(s.htmlLabels) ?? !0, h = a;
+	h.annotations = h.annotations ?? [], h.members = h.members ?? [], h.methods = h.methods ?? [];
+	let { shapeSvg: g, bbox: _ } = await textHelper(e, a, s, p, f), { labelStyles: v, nodeStyles: y } = styles2String(a);
+	a.labelStyle = v, a.cssStyles = h.styles || "";
+	let b = h.styles?.join(";") || y || "";
+	a.cssStyles ||= b.replaceAll("!important", "").split(";");
+	let x = h.members.length === 0 && h.methods.length === 0 && !s.class?.hideEmptyMembersBox, w = at.svg(g), T = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (T.roughness = 0, T.fillStyle = "solid");
+	let E = Math.max(a.width ?? 0, _.width), D = Math.max(a.height ?? 0, _.height), k = (a.height ?? 0) > _.height;
+	h.members.length === 0 && h.methods.length === 0 ? D += f : h.members.length > 0 && h.methods.length === 0 && (D += f * 2);
+	let A = -E / 2, j = -D / 2, M = x ? d * 2 : h.members.length === 0 && h.methods.length === 0 ? -d : 0;
+	k && (M = d * 2);
+	let N = w.rectangle(A - d, j - d - (x ? d : h.members.length === 0 && h.methods.length === 0 ? -d / 2 : 0), E + 2 * d, D + 2 * d + M, T), P = g.insert(() => N, ":first-child");
+	P.attr("class", "basic label-container outer-path");
+	let F = P.node().getBBox(), I = g.select(".annotation-group").node().getBBox().height - (x ? d / 2 : 0) || 0, L = g.select(".label-group").node().getBBox().height - (x ? d / 2 : 0) || 0, R = g.select(".members-group").node().getBBox().height - (x ? d / 2 : 0) || 0, z = (I + L + j + d - (j - d - (x ? d : h.members.length === 0 && h.methods.length === 0 ? -d / 2 : 0))) / 2;
+	if (g.selectAll(".text").each((e, a, o) => {
+		let c = select_default(o[a]), l = c.attr("transform"), u = 0;
+		if (l) {
+			let e = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(l);
+			e && (u = parseFloat(e[2]));
+		}
+		let _ = u + j + d - (x ? d : h.members.length === 0 && h.methods.length === 0 ? -d / 2 : 0);
+		if (c.attr("class").includes("methods-group")) {
+			let e = Math.max(R, f / 2);
+			_ = k ? Math.max(z, I + L + e + j + f * 2 + d) + f * 2 : I + L + e + j + f * 4 + d;
+		}
+		h.members.length === 0 && h.methods.length === 0 && s.class?.hideEmptyMembersBox && (_ = h.annotations.length > 0 ? u - f : u), p || (_ -= 4);
+		let v = A;
+		(c.attr("class").includes("label-group") || c.attr("class").includes("annotation-group")) && (v = -c.node()?.getBBox().width / 2 || 0, g.selectAll("text").each(function(e, a, o) {
+			window.getComputedStyle(o[a]).textAnchor === "middle" && (v = 0);
+		})), c.attr("transform", `translate(${v}, ${_})`);
+	}), h.members.length > 0 || h.methods.length > 0 || x) {
+		let e = I + L + j + d, o = w.line(F.x, e, F.x + F.width, e + .001, T);
+		g.insert(() => o).attr("class", `divider${a.look === "neo" && !u ? " neo-line" : ""}`).attr("style", b);
+	}
+	if (x || h.members.length > 0 || h.methods.length > 0) {
+		let e = I + L + R + j + f * 2 + d, o = w.line(F.x, k ? Math.max(z, e) : e, F.x + F.width, (k ? Math.max(z, e) : e) + .001, T);
+		g.insert(() => o).attr("class", `divider${a.look === "neo" && !u ? " neo-line" : ""}`).attr("style", b);
+	}
+	if (h.look !== "handDrawn" && g.selectAll("path").attr("style", b), P.select(":nth-child(2)").attr("style", b), g.selectAll(".divider").select("path").attr("style", b), a.labelStyle ? g.selectAll("span").attr("style", a.labelStyle) : g.selectAll("span").attr("style", b), !p) {
+		let e = RegExp(/color\s*:\s*([^;]*)/), a = e.exec(b);
+		if (a) {
+			let e = a[0].replace("color", "fill");
+			g.selectAll("tspan").attr("style", e);
+		} else if (v) {
+			let a = e.exec(v);
+			if (a) {
+				let e = a[0].replace("color", "fill");
+				g.selectAll("tspan").attr("style", e);
+			}
+		}
+	}
+	return updateNodeBounds(a, P), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, g;
+}
+__name(classBox, "classBox");
+async function requirementBox(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let l = a, u = a, d = "verifyMethod" in a, f = getNodeClasses(a), { themeVariables: p } = getConfig2(), { borderColorArray: h, requirementEdgeLabelBackground: g } = p, _ = e.insert("g").attr("class", f).attr("id", a.domId ?? a.id), v;
+	v = d ? await addText3(_, `&lt;&lt;${l.type}&gt;&gt;`, 0, a.labelStyle) : await addText3(_, "&lt;&lt;Element&gt;&gt;", 0, a.labelStyle);
+	let y = v, b = await addText3(_, l.name, y, a.labelStyle + "; font-weight: bold;");
+	if (y += b + 20, d) {
+		let e = await addText3(_, `${l.requirementId ? `ID: ${l.requirementId}` : ""}`, y, a.labelStyle);
+		y += e;
+		let o = await addText3(_, `${l.text ? `Text: ${l.text}` : ""}`, y, a.labelStyle);
+		y += o;
+		let s = await addText3(_, `${l.risk ? `Risk: ${l.risk}` : ""}`, y, a.labelStyle);
+		y += s, await addText3(_, `${l.verifyMethod ? `Verification: ${l.verifyMethod}` : ""}`, y, a.labelStyle);
+	} else {
+		let e = await addText3(_, `${u.type ? `Type: ${u.type}` : ""}`, y, a.labelStyle);
+		y += e, await addText3(_, `${u.docRef ? `Doc Ref: ${u.docRef}` : ""}`, y, a.labelStyle);
+	}
+	let x = (_.node()?.getBBox().width ?? 200) + 20, w = (_.node()?.getBBox().height ?? 200) + 20, T = -x / 2, E = -w / 2, D = at.svg(_), A = userNodeOverrides(a, {});
+	a.look !== "handDrawn" && (A.roughness = 0, A.fillStyle = "solid");
+	let j = D.rectangle(T, E, x, w, A), M = _.insert(() => j, ":first-child");
+	if (M.attr("class", "basic label-container outer-path").attr("style", s), h?.length) {
+		let e = a.colorIndex ?? 0;
+		_.attr("data-color-id", `color-${e % h.length}`);
+	}
+	if (_.selectAll(".label").each((e, a, o) => {
+		let s = select_default(o[a]), c = s.attr("transform"), l = 0, u = 0;
+		if (c) {
+			let e = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(c);
+			e && (l = parseFloat(e[1]), u = parseFloat(e[2]));
+		}
+		let d = u - w / 2, f = T + 20 / 2;
+		(a === 0 || a === 1) && (f = l), s.attr("transform", `translate(${f}, ${d + 20})`);
+	}), y > v + b + 20) {
+		let e = E + v + b + 20, o;
+		if (a.look === "neo") {
+			let a = .001, s = [
+				[T, e],
+				[T + x, e],
+				[T + x, e + a],
+				[T, e + a]
+			];
+			o = D.polygon(s, A);
+		} else o = D.line(T, e, T + x, e, A);
+		_.insert(() => o).attr("class", "divider");
+	}
+	return updateNodeBounds(a, M), a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, s && a.look !== "handDrawn" && (g || h?.length) && _.selectAll("path").attr("style", s), _;
+}
+__name(requirementBox, "requirementBox");
+async function addText3(e, a, o, s = "") {
+	if (a === "") return 0;
+	let l = e.insert("g").attr("class", "label").attr("style", s), u = getConfig2(), d = u.htmlLabels ?? !0, f = await createText(l, sanitizeText3(decodeEntities(a)), {
+		width: calculateTextWidth(a, u) + 50,
+		classes: "markdown-node-label",
+		useHtmlLabels: d,
+		style: s
+	}, u), _;
+	if (d) {
+		let e = f.children[0], a = select_default(f);
+		_ = e.getBoundingClientRect(), a.attr("width", _.width), a.attr("height", _.height);
+	} else {
+		let e = f.children[0];
+		for (let a of e.children) s && a.setAttribute("style", s);
+		_ = f.getBBox(), _.height += 6;
+	}
+	return l.attr("transform", `translate(${-_.width / 2},${-_.height / 2 + o})`), _.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, a, { config: o }) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(a);
+	a.labelStyle = s || "";
+	let l = a.width;
+	a.width = (a.width ?? 200) - 10;
+	let { shapeSvg: u, bbox: d, label: f } = await labelHelper(e, a, getNodeClasses(a)), p = a.padding || 10, m = "", h;
+	"ticket" in a && a.ticket && o?.kanban?.ticketBaseUrl && (m = o?.kanban?.ticketBaseUrl.replace("#TICKET#", a.ticket), h = u.insert("svg:a", ":first-child").attr("class", "kanban-ticket-link").attr("xlink:href", m).attr("target", "_blank"));
+	let g = {
+		useHtmlLabels: a.useHtmlLabels,
+		labelStyle: a.labelStyle || "",
+		width: a.width,
+		img: a.img,
+		padding: a.padding || 8,
+		centerLabel: !1
+	}, _, v;
+	h ? {label: _, bbox: v} = await insertLabel(h, "ticket" in a && a.ticket || "", g) : {label: _, bbox: v} = await insertLabel(u, "ticket" in a && a.ticket || "", g);
+	let { label: y, bbox: b } = await insertLabel(u, "assigned" in a && a.assigned || "", g);
+	a.width = l;
+	let x = a?.width || 0, w = Math.max(v.height, b.height) / 2, T = Math.max(d.height + 20, a?.height || 0) + w, A = -x / 2, j = -T / 2;
+	f.attr("transform", "translate(" + (p - x / 2) + ", " + (-w - d.height / 2) + ")"), _.attr("transform", "translate(" + (p - x / 2) + ", " + (-w + d.height / 2) + ")"), y.attr("transform", "translate(" + (p + x / 2 - b.width - 20) + ", " + (-w + d.height / 2) + ")");
+	let M, { rx: N, ry: P } = a, { cssStyles: F } = a;
+	if (a.look === "handDrawn") {
+		let e = at.svg(u), o = userNodeOverrides(a, {}), s = N || P ? e.path(createRoundedRectPathD(A, j, x, T, N || 0), o) : e.rectangle(A, j, x, T, o);
+		M = u.insert(() => s, ":first-child"), M.attr("class", "basic label-container").attr("style", F || null);
+	} else {
+		M = u.insert("rect", ":first-child"), M.attr("class", "basic label-container __APA__").attr("style", c).attr("rx", N ?? 5).attr("ry", P ?? 5).attr("x", A).attr("y", j).attr("width", x).attr("height", T);
+		let e = "priority" in a && a.priority;
+		if (e) {
+			let a = u.append("line"), o = A + 2, s = j + Math.floor((N ?? 0) / 2), c = j + T - Math.floor((N ?? 0) / 2);
+			a.attr("x1", o).attr("y1", s).attr("x2", o).attr("y2", c).attr("stroke-width", "4").attr("stroke", colorFromPriority(e));
+		}
+	}
+	return updateNodeBounds(a, M), a.height = T, a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, u;
+}
+__name(kanbanItem, "kanbanItem");
+async function bang(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.labelStyle = s;
+	let { shapeSvg: l, bbox: u, halfPadding: d, label: f } = await labelHelper(e, o, getNodeClasses(o)), p = u.width + 10 * d, m = u.height + 8 * d, h = .15 * p, { cssStyles: g } = o, v = u.width + 20, y = u.height + 20, b = Math.max(p, v), x = Math.max(m, y);
+	f.attr("transform", `translate(${-u.width / 2}, ${-u.height / 2})`);
+	let w, T = `M0 0 
+    a${h},${h} 1 0,0 ${b * .25},${-1 * x * .1}
+    a${h},${h} 1 0,0 ${b * .25},0
+    a${h},${h} 1 0,0 ${b * .25},0
+    a${h},${h} 1 0,0 ${b * .25},${x * .1}
+
+    a${h},${h} 1 0,0 ${b * .15},${x * .33}
+    a${h * .8},${h * .8} 1 0,0 0,${x * .34}
+    a${h},${h} 1 0,0 ${-1 * b * .15},${x * .33}
+
+    a${h},${h} 1 0,0 ${-1 * b * .25},${x * .15}
+    a${h},${h} 1 0,0 ${-1 * b * .25},0
+    a${h},${h} 1 0,0 ${-1 * b * .25},0
+    a${h},${h} 1 0,0 ${-1 * b * .25},${-1 * x * .15}
+
+    a${h},${h} 1 0,0 ${-1 * b * .1},${-1 * x * .33}
+    a${h * .8},${h * .8} 1 0,0 0,${-1 * x * .34}
+    a${h},${h} 1 0,0 ${b * .1},${-1 * x * .33}
+  H0 V0 Z`;
+	if (o.look === "handDrawn") {
+		let e = at.svg(l), a = userNodeOverrides(o, {}), s = e.path(T, a);
+		w = l.insert(() => s, ":first-child"), w.attr("class", "basic label-container").attr("style", handleUndefinedAttr(g));
+	} else w = l.insert("path", ":first-child").attr("class", "basic label-container").attr("style", c).attr("d", T);
+	return w.attr("transform", `translate(${-b / 2}, ${-x / 2})`), updateNodeBounds(o, w), o.calcIntersect = function(e, a) {
+		return intersect_default.rect(e, a);
+	}, o.intersect = function(e) {
+		return log.info("Bang intersect", o, e), intersect_default.rect(o, e);
+	}, l;
+}
+__name(bang, "bang");
+async function cloud(e, o) {
+	let { labelStyles: s, nodeStyles: c } = styles2String(o);
+	o.labelStyle = s;
+	let { shapeSvg: l, bbox: u, halfPadding: d, label: f } = await labelHelper(e, o, getNodeClasses(o)), p = u.width + 2 * d, m = u.height + 2 * d, h = .15 * p, g = .25 * p, v = .35 * p, y = .2 * p, { cssStyles: b } = o, x, w = `M0 0 
+    a${h},${h} 0 0,1 ${p * .25},${-1 * p * .1}
+    a${v},${v} 1 0,1 ${p * .4},${-1 * p * .1}
+    a${g},${g} 1 0,1 ${p * .35},${p * .2}
+
+    a${h},${h} 1 0,1 ${p * .15},${m * .35}
+    a${y},${y} 1 0,1 ${-1 * p * .15},${m * .65}
+
+    a${g},${h} 1 0,1 ${-1 * p * .25},${p * .15}
+    a${v},${v} 1 0,1 ${-1 * p * .5},0
+    a${h},${h} 1 0,1 ${-1 * p * .25},${-1 * p * .15}
+
+    a${h},${h} 1 0,1 ${-1 * p * .1},${-1 * m * .35}
+    a${y},${y} 1 0,1 ${p * .1},${-1 * m * .65}
+  H0 V0 Z`;
+	if (o.look === "handDrawn") {
+		let e = at.svg(l), a = userNodeOverrides(o, {}), s = e.path(w, a);
+		x = l.insert(() => s, ":first-child"), x.attr("class", "basic label-container").attr("style", handleUndefinedAttr(b));
+	} else x = l.insert("path", ":first-child").attr("class", "basic label-container").attr("style", c).attr("d", w);
+	return f.attr("transform", `translate(${-u.width / 2}, ${-u.height / 2})`), x.attr("transform", `translate(${-p / 2}, ${-m / 2})`), updateNodeBounds(o, x), o.calcIntersect = function(e, a) {
+		return intersect_default.rect(e, a);
+	}, o.intersect = function(e) {
+		return log.info("Cloud intersect", o, e), intersect_default.rect(o, e);
+	}, l;
+}
+__name(cloud, "cloud");
+async function defaultMindmapNode(e, a) {
+	let { labelStyles: o, nodeStyles: s } = styles2String(a);
+	a.labelStyle = o;
+	let { shapeSvg: c, bbox: l, halfPadding: u, label: d } = await labelHelper(e, a, getNodeClasses(a)), f = l.width + 8 * u, p = l.height + 2 * u, m = a.look === "neo" ? `
+    M${-f / 2} ${p / 2 - 5}
+    v${-p + 10}
+    q0,-5 5,-5
+    h${f - 10}
+    q5,0 5,5
+    v${p - 5}
+    H${-f / 2}
+    Z
+  ` : `
+    M${-f / 2} ${p / 2 - 5}
+    v${-p + 10}
+    q0,-5 5,-5
+    h${f - 10}
+    q5,0 5,5
+    v${p - 10}
+    q0,5 -5,5
+    h${-(f - 10)}
+    q-5,0 -5,-5
+    Z
+  `;
+	if (!a.domId) throw Error(`defaultMindmapNode: node "${a.id}" is missing a domId \u2014 was render.ts domId prefixing skipped?`);
+	let h = c.append("path").attr("id", a.domId).attr("class", "node-bkg node-" + a.type).attr("style", s).attr("d", m);
+	return c.append("line").attr("class", "node-line-").attr("x1", -f / 2).attr("y1", p / 2).attr("x2", f / 2).attr("y2", p / 2), d.attr("transform", `translate(${-l.width / 2}, ${-l.height / 2})`), c.append(() => d.node()), updateNodeBounds(a, h), a.calcIntersect = function(e, a) {
+		return intersect_default.rect(e, a);
+	}, a.intersect = function(e) {
+		return intersect_default.rect(a, e);
+	}, c;
+}
+__name(defaultMindmapNode, "defaultMindmapNode");
+async function mindmapCircle(e, a) {
+	return circle(e, a, { padding: a.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
+	}, a = [...Object.entries(e), ...shapesDefs.flatMap((e) => [
+		e.shortName,
+		..."aliases" in e ? e.aliases : [],
+		..."internalAliases" in e ? e.internalAliases : []
+	].map((a) => [a, e.handler]))];
+	return Object.fromEntries(a);
+}, "generateShapeMap"))();
+function isValidShape(e) {
+	return e in shapes2;
+}
+__name(isValidShape, "isValidShape");
+var nodeElems = /* @__PURE__ */ new Map();
+async function insertNode(e, a, o) {
+	let s, c;
+	a.shape === "rect" && (a.rx && a.ry ? a.shape = "roundedRect" : a.shape = "squareRect");
+	let l = a.shape ? shapes2[a.shape] : void 0;
+	if (!l) throw Error(`No such shape: ${a.shape}. Please check your syntax.`);
+	if (a.link) {
+		let u;
+		o.config.securityLevel === "sandbox" ? u = "_top" : a.linkTarget && (u = a.linkTarget || "_blank"), s = e.insert("svg:a").attr("xlink:href", a.link).attr("target", u ?? null), c = await l(s, a, o);
+	} else c = await l(e, a, o), s = c;
+	return s.attr("data-look", handleUndefinedAttr(a.look)), a.tooltip && c.attr("title", a.tooltip), nodeElems.set(a.id, s), a.haveCallback && s.attr("class", s.attr("class") + " clickable"), s;
+}
+__name(insertNode, "insertNode");
+var setNodeElem = /* @__PURE__ */ __name((e, a) => {
+	nodeElems.set(a.id, e);
+}, "setNodeElem"), clear2 = /* @__PURE__ */ __name(() => {
+	nodeElems.clear();
+}, "clear"), positionNode = /* @__PURE__ */ __name((e) => {
+	let o = nodeElems.get(e.id);
+	log.trace("Transforming node", e.diff, e, "translate(" + (e.x - e.width / 2 - 5) + ", " + e.width / 2 + ")");
+	let s = e.diff || 0;
+	return e.clusterNode ? o.attr("transform", "translate(" + (e.x + s - e.width / 2) + ", " + (e.y - e.height / 2 - 8) + ")") : o.attr("transform", "translate(" + e.x + ", " + e.y + ")"), s;
+}, "positionNode");
+export { clear, clear2, createLabel_default, insertCluster, insertNode, isValidShape, labelHelper, positionNode, setNodeElem, updateNodeBounds };