@blueking/ai-blueking 2.0.0-dev.2 → 2.0.0-dev.3

package/dist/vue2/chunk-JZLCHNYA-Df0-MseJ.js

@@ -0,0 +1,4861 @@
+import { g as log, h as __name, p as select_default } from "./src-VlKYSsxJ.js";
+import { A as parseGenericTypes, I as sanitizeText, L as sanitizeText3, N as renderKatexSanitized, O as hasKatex, b as getConfig2, d as defaultConfig_default, h as evaluate, s as common_default, y as getConfig } from "./chunk-ABZYJK2D-gsx40GnJ.js";
+import { a as decodeEntities, p as parseFontSize, r as calculateTextWidth, u as handleUndefinedAttr } from "./chunk-S3R3BYOJ-Bs_r55Kk.js";
+import { n as createText, r as getIconSVG } from "./chunk-JA3XYJ7Z-CRet4f6a.js";
+import { t as getSubGraphTitleMargins } from "./chunk-CVBHYZKI-Cs8lCw3u.js";
+import { a as userNodeOverrides, i as styles2String, r as solidStateFill, t as compileStyles } from "./chunk-ATLVNIR6-CTTwtx-5.js";
+function t(te, lr, ur) {
+	if (te && te.length) {
+		let [dr, fr] = lr, pr = Math.PI / 180 * ur, mr = Math.cos(pr), hr = Math.sin(pr);
+		for (let lr of te) {
+			let [te, ur] = lr;
+			lr[0] = (te - dr) * mr - (ur - fr) * hr + dr, lr[1] = (te - dr) * hr + (ur - fr) * mr + fr;
+		}
+	}
+}
+function e(te, lr) {
+	return te[0] === lr[0] && te[1] === lr[1];
+}
+function s(te, lr, ur, dr = 1) {
+	let fr = ur, pr = Math.max(lr, .1), mr = te[0] && te[0][0] && typeof te[0][0] == "number" ? [te] : te, hr = [0, 0];
+	if (fr) for (let te of mr) t(te, hr, fr);
+	let gr = function(te, lr, ur) {
+		let dr = [];
+		for (let lr of te) {
+			let te = [...lr];
+			e(te[0], te[te.length - 1]) || te.push([te[0][0], te[0][1]]), te.length > 2 && dr.push(te);
+		}
+		let fr = [];
+		lr = Math.max(lr, .1);
+		let pr = [];
+		for (let te of dr) for (let lr = 0; lr < te.length - 1; lr++) {
+			let ur = te[lr], dr = te[lr + 1];
+			if (ur[1] !== dr[1]) {
+				let te = Math.min(ur[1], dr[1]);
+				pr.push({
+					ymin: te,
+					ymax: Math.max(ur[1], dr[1]),
+					x: te === ur[1] ? ur[0] : dr[0],
+					islope: (dr[0] - ur[0]) / (dr[1] - ur[1])
+				});
+			}
+		}
+		if (pr.sort(((te, lr) => te.ymin < lr.ymin ? -1 : te.ymin > lr.ymin ? 1 : te.x < lr.x ? -1 : te.x > lr.x ? 1 : te.ymax === lr.ymax ? 0 : (te.ymax - lr.ymax) / Math.abs(te.ymax - lr.ymax))), !pr.length) return fr;
+		let mr = [], hr = pr[0].ymin, gr = 0;
+		for (; mr.length || pr.length;) {
+			if (pr.length) {
+				let te = -1;
+				for (let lr = 0; lr < pr.length && !(pr[lr].ymin > hr); lr++) te = lr;
+				pr.splice(0, te + 1).forEach(((te) => {
+					mr.push({
+						s: hr,
+						edge: te
+					});
+				}));
+			}
+			if (mr = mr.filter(((te) => !(te.edge.ymax <= hr))), mr.sort(((te, lr) => te.edge.x === lr.edge.x ? 0 : (te.edge.x - lr.edge.x) / Math.abs(te.edge.x - lr.edge.x))), (ur !== 1 || gr % lr == 0) && mr.length > 1) for (let te = 0; te < mr.length; te += 2) {
+				let lr = te + 1;
+				if (lr >= mr.length) break;
+				let ur = mr[te].edge, dr = mr[lr].edge;
+				fr.push([[Math.round(ur.x), hr], [Math.round(dr.x), hr]]);
+			}
+			hr += ur, mr.forEach(((te) => {
+				te.edge.x = te.edge.x + ur * te.edge.islope;
+			})), gr++;
+		}
+		return fr;
+	}(mr, pr, dr);
+	if (fr) {
+		for (let te of mr) t(te, hr, -fr);
+		(function(te, lr, ur) {
+			let dr = [];
+			te.forEach(((te) => dr.push(...te))), t(dr, lr, ur);
+		})(gr, hr, -fr);
+	}
+	return gr;
+}
+function n(te, lr) {
+	let ur = lr.hachureAngle + 90, dr = lr.hachureGap;
+	dr < 0 && (dr = 4 * lr.strokeWidth), dr = Math.round(Math.max(dr, .1));
+	let fr = 1;
+	return lr.roughness >= 1 && (lr.randomizer?.next() || Math.random()) > .7 && (fr = dr), s(te, dr, ur, fr || 1);
+}
+var o = class {
+	constructor(te) {
+		this.helper = te;
+	}
+	fillPolygons(te, lr) {
+		return this._fillPolygons(te, lr);
+	}
+	_fillPolygons(te, lr) {
+		let ur = n(te, lr);
+		return {
+			type: "fillSketch",
+			ops: this.renderLines(ur, lr)
+		};
+	}
+	renderLines(te, lr) {
+		let ur = [];
+		for (let dr of te) ur.push(...this.helper.doubleLineOps(dr[0][0], dr[0][1], dr[1][0], dr[1][1], lr));
+		return ur;
+	}
+};
+function a(te) {
+	let lr = te[0], ur = te[1];
+	return Math.sqrt((lr[0] - ur[0]) ** 2 + (lr[1] - ur[1]) ** 2);
+}
+var h = class extends o {
+	fillPolygons(te, lr) {
+		let ur = lr.hachureGap;
+		ur < 0 && (ur = 4 * lr.strokeWidth), ur = Math.max(ur, .1);
+		let dr = n(te, Object.assign({}, lr, { hachureGap: ur })), fr = Math.PI / 180 * lr.hachureAngle, pr = [], mr = .5 * ur * Math.cos(fr), hr = .5 * ur * Math.sin(fr);
+		for (let [te, lr] of dr) a([te, lr]) && pr.push([[te[0] - mr, te[1] + hr], [...lr]], [[te[0] + mr, te[1] - hr], [...lr]]);
+		return {
+			type: "fillSketch",
+			ops: this.renderLines(pr, lr)
+		};
+	}
+}, r = class extends o {
+	fillPolygons(te, lr) {
+		let ur = this._fillPolygons(te, lr), dr = Object.assign({}, lr, { hachureAngle: lr.hachureAngle + 90 }), fr = this._fillPolygons(te, dr);
+		return ur.ops = ur.ops.concat(fr.ops), ur;
+	}
+}, i = class {
+	constructor(te) {
+		this.helper = te;
+	}
+	fillPolygons(te, lr) {
+		let ur = n(te, lr = Object.assign({}, lr, { hachureAngle: 0 }));
+		return this.dotsOnLines(ur, lr);
+	}
+	dotsOnLines(te, lr) {
+		let ur = [], dr = lr.hachureGap;
+		dr < 0 && (dr = 4 * lr.strokeWidth), dr = Math.max(dr, .1);
+		let fr = lr.fillWeight;
+		fr < 0 && (fr = lr.strokeWidth / 2);
+		let pr = dr / 4;
+		for (let mr of te) {
+			let te = a(mr), hr = te / dr, gr = Math.ceil(hr) - 1, _r = te - gr * dr, vr = (mr[0][0] + mr[1][0]) / 2 - dr / 4, yr = Math.min(mr[0][1], mr[1][1]);
+			for (let te = 0; te < gr; te++) {
+				let mr = yr + _r + te * dr, hr = vr - pr + 2 * Math.random() * pr, gr = mr - pr + 2 * Math.random() * pr, br = this.helper.ellipse(hr, gr, fr, fr, lr);
+				ur.push(...br.ops);
+			}
+		}
+		return {
+			type: "fillSketch",
+			ops: ur
+		};
+	}
+}, c = class {
+	constructor(te) {
+		this.helper = te;
+	}
+	fillPolygons(te, lr) {
+		let ur = n(te, lr);
+		return {
+			type: "fillSketch",
+			ops: this.dashedLine(ur, lr)
+		};
+	}
+	dashedLine(te, lr) {
+		let ur = lr.dashOffset < 0 ? lr.hachureGap < 0 ? 4 * lr.strokeWidth : lr.hachureGap : lr.dashOffset, dr = lr.dashGap < 0 ? lr.hachureGap < 0 ? 4 * lr.strokeWidth : lr.hachureGap : lr.dashGap, fr = [];
+		return te.forEach(((te) => {
+			let pr = a(te), mr = Math.floor(pr / (ur + dr)), hr = (pr + dr - mr * (ur + dr)) / 2, gr = te[0], _r = te[1];
+			gr[0] > _r[0] && (gr = te[1], _r = te[0]);
+			let vr = Math.atan((_r[1] - gr[1]) / (_r[0] - gr[0]));
+			for (let te = 0; te < mr; te++) {
+				let pr = te * (ur + dr), mr = pr + ur, _r = [gr[0] + pr * Math.cos(vr) + hr * Math.cos(vr), gr[1] + pr * Math.sin(vr) + hr * Math.sin(vr)], yr = [gr[0] + mr * Math.cos(vr) + hr * Math.cos(vr), gr[1] + mr * Math.sin(vr) + hr * Math.sin(vr)];
+				fr.push(...this.helper.doubleLineOps(_r[0], _r[1], yr[0], yr[1], lr));
+			}
+		})), fr;
+	}
+}, l = class {
+	constructor(te) {
+		this.helper = te;
+	}
+	fillPolygons(te, lr) {
+		let ur = lr.hachureGap < 0 ? 4 * lr.strokeWidth : lr.hachureGap, dr = lr.zigzagOffset < 0 ? ur : lr.zigzagOffset, fr = n(te, lr = Object.assign({}, lr, { hachureGap: ur + dr }));
+		return {
+			type: "fillSketch",
+			ops: this.zigzagLines(fr, dr, lr)
+		};
+	}
+	zigzagLines(te, lr, ur) {
+		let dr = [];
+		return te.forEach(((te) => {
+			let fr = a(te), pr = Math.round(fr / (2 * lr)), mr = te[0], hr = te[1];
+			mr[0] > hr[0] && (mr = te[1], hr = te[0]);
+			let gr = Math.atan((hr[1] - mr[1]) / (hr[0] - mr[0]));
+			for (let te = 0; te < pr; te++) {
+				let fr = 2 * te * lr, pr = 2 * (te + 1) * lr, hr = Math.sqrt(2 * lr ** 2), _r = [mr[0] + fr * Math.cos(gr), mr[1] + fr * Math.sin(gr)], vr = [mr[0] + pr * Math.cos(gr), mr[1] + pr * Math.sin(gr)], yr = [_r[0] + hr * Math.cos(gr + Math.PI / 4), _r[1] + hr * Math.sin(gr + Math.PI / 4)];
+				dr.push(...this.helper.doubleLineOps(_r[0], _r[1], yr[0], yr[1], ur), ...this.helper.doubleLineOps(yr[0], yr[1], vr[0], vr[1], ur));
+			}
+		})), dr;
+	}
+}, u = {}, p = class {
+	constructor(te) {
+		this.seed = te;
+	}
+	next() {
+		return this.seed ? (2 ** 31 - 1 & (this.seed = Math.imul(48271, this.seed))) / 2 ** 31 : Math.random();
+	}
+}, f = 0, d = 1, g = 2, M = {
+	A: 7,
+	a: 7,
+	C: 6,
+	c: 6,
+	H: 1,
+	h: 1,
+	L: 2,
+	l: 2,
+	M: 2,
+	m: 2,
+	Q: 4,
+	q: 4,
+	S: 4,
+	s: 4,
+	T: 2,
+	t: 2,
+	V: 1,
+	v: 1,
+	Z: 0,
+	z: 0
+};
+function k(te, lr) {
+	return te.type === lr;
+}
+function b(te) {
+	let lr = [], ur = function(te) {
+		let lr = [];
+		for (; te !== "";) if (te.match(/^([ \t\r\n,]+)/)) te = te.substr(RegExp.$1.length);
+		else if (te.match(/^([aAcChHlLmMqQsStTvVzZ])/)) lr[lr.length] = {
+			type: f,
+			text: RegExp.$1
+		}, te = te.substr(RegExp.$1.length);
+		else {
+			if (!te.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) return [];
+			lr[lr.length] = {
+				type: d,
+				text: `${parseFloat(RegExp.$1)}`
+			}, te = te.substr(RegExp.$1.length);
+		}
+		return lr[lr.length] = {
+			type: g,
+			text: ""
+		}, lr;
+	}(te), dr = "BOD", fr = 0, pr = ur[fr];
+	for (; !k(pr, g);) {
+		let mr = 0, hr = [];
+		if (dr === "BOD") {
+			if (pr.text !== "M" && pr.text !== "m") return b("M0,0" + te);
+			fr++, mr = M[pr.text], dr = pr.text;
+		} else k(pr, d) ? mr = M[dr] : (fr++, mr = M[pr.text], dr = pr.text);
+		if (!(fr + mr < ur.length)) throw Error("Path data ended short");
+		for (let te = fr; te < fr + mr; te++) {
+			let lr = ur[te];
+			if (!k(lr, d)) throw Error("Param not a number: " + dr + "," + lr.text);
+			hr[hr.length] = +lr.text;
+		}
+		if (typeof M[dr] != "number") throw Error("Bad segment: " + dr);
+		{
+			let te = {
+				key: dr,
+				data: hr
+			};
+			lr.push(te), fr += mr, pr = ur[fr], dr === "M" && (dr = "L"), dr === "m" && (dr = "l");
+		}
+	}
+	return lr;
+}
+function y(te) {
+	let lr = 0, ur = 0, dr = 0, fr = 0, pr = [];
+	for (let { key: mr, data: hr } of te) switch (mr) {
+		case "M":
+			pr.push({
+				key: "M",
+				data: [...hr]
+			}), [lr, ur] = hr, [dr, fr] = hr;
+			break;
+		case "m":
+			lr += hr[0], ur += hr[1], pr.push({
+				key: "M",
+				data: [lr, ur]
+			}), dr = lr, fr = ur;
+			break;
+		case "L":
+			pr.push({
+				key: "L",
+				data: [...hr]
+			}), [lr, ur] = hr;
+			break;
+		case "l":
+			lr += hr[0], ur += hr[1], pr.push({
+				key: "L",
+				data: [lr, ur]
+			});
+			break;
+		case "C":
+			pr.push({
+				key: "C",
+				data: [...hr]
+			}), lr = hr[4], ur = hr[5];
+			break;
+		case "c": {
+			let te = hr.map(((te, dr) => dr % 2 ? te + ur : te + lr));
+			pr.push({
+				key: "C",
+				data: te
+			}), lr = te[4], ur = te[5];
+			break;
+		}
+		case "Q":
+			pr.push({
+				key: "Q",
+				data: [...hr]
+			}), lr = hr[2], ur = hr[3];
+			break;
+		case "q": {
+			let te = hr.map(((te, dr) => dr % 2 ? te + ur : te + lr));
+			pr.push({
+				key: "Q",
+				data: te
+			}), lr = te[2], ur = te[3];
+			break;
+		}
+		case "A":
+			pr.push({
+				key: "A",
+				data: [...hr]
+			}), lr = hr[5], ur = hr[6];
+			break;
+		case "a":
+			lr += hr[5], ur += hr[6], pr.push({
+				key: "A",
+				data: [
+					hr[0],
+					hr[1],
+					hr[2],
+					hr[3],
+					hr[4],
+					lr,
+					ur
+				]
+			});
+			break;
+		case "H":
+			pr.push({
+				key: "H",
+				data: [...hr]
+			}), lr = hr[0];
+			break;
+		case "h":
+			lr += hr[0], pr.push({
+				key: "H",
+				data: [lr]
+			});
+			break;
+		case "V":
+			pr.push({
+				key: "V",
+				data: [...hr]
+			}), ur = hr[0];
+			break;
+		case "v":
+			ur += hr[0], pr.push({
+				key: "V",
+				data: [ur]
+			});
+			break;
+		case "S":
+			pr.push({
+				key: "S",
+				data: [...hr]
+			}), lr = hr[2], ur = hr[3];
+			break;
+		case "s": {
+			let te = hr.map(((te, dr) => dr % 2 ? te + ur : te + lr));
+			pr.push({
+				key: "S",
+				data: te
+			}), lr = te[2], ur = te[3];
+			break;
+		}
+		case "T":
+			pr.push({
+				key: "T",
+				data: [...hr]
+			}), lr = hr[0], ur = hr[1];
+			break;
+		case "t":
+			lr += hr[0], ur += hr[1], pr.push({
+				key: "T",
+				data: [lr, ur]
+			});
+			break;
+		case "Z":
+		case "z": pr.push({
+			key: "Z",
+			data: []
+		}), lr = dr, ur = fr;
+	}
+	return pr;
+}
+function m(te) {
+	let lr = [], ur = "", dr = 0, fr = 0, pr = 0, mr = 0, hr = 0, gr = 0;
+	for (let { key: _r, data: vr } of te) {
+		switch (_r) {
+			case "M":
+				lr.push({
+					key: "M",
+					data: [...vr]
+				}), [dr, fr] = vr, [pr, mr] = vr;
+				break;
+			case "C":
+				lr.push({
+					key: "C",
+					data: [...vr]
+				}), dr = vr[4], fr = vr[5], hr = vr[2], gr = vr[3];
+				break;
+			case "L":
+				lr.push({
+					key: "L",
+					data: [...vr]
+				}), [dr, fr] = vr;
+				break;
+			case "H":
+				dr = vr[0], lr.push({
+					key: "L",
+					data: [dr, fr]
+				});
+				break;
+			case "V":
+				fr = vr[0], lr.push({
+					key: "L",
+					data: [dr, fr]
+				});
+				break;
+			case "S": {
+				let te = 0, pr = 0;
+				ur === "C" || ur === "S" ? (te = dr + (dr - hr), pr = fr + (fr - gr)) : (te = dr, pr = fr), lr.push({
+					key: "C",
+					data: [
+						te,
+						pr,
+						...vr
+					]
+				}), hr = vr[0], gr = vr[1], dr = vr[2], fr = vr[3];
+				break;
+			}
+			case "T": {
+				let [te, pr] = vr, mr = 0, _r = 0;
+				ur === "Q" || ur === "T" ? (mr = dr + (dr - hr), _r = fr + (fr - gr)) : (mr = dr, _r = fr);
+				let yr = dr + 2 * (mr - dr) / 3, br = fr + 2 * (_r - fr) / 3, xr = te + 2 * (mr - te) / 3, Sr = pr + 2 * (_r - pr) / 3;
+				lr.push({
+					key: "C",
+					data: [
+						yr,
+						br,
+						xr,
+						Sr,
+						te,
+						pr
+					]
+				}), hr = mr, gr = _r, dr = te, fr = pr;
+				break;
+			}
+			case "Q": {
+				let [te, ur, pr, mr] = vr, _r = dr + 2 * (te - dr) / 3, yr = fr + 2 * (ur - fr) / 3, br = pr + 2 * (te - pr) / 3, xr = mr + 2 * (ur - mr) / 3;
+				lr.push({
+					key: "C",
+					data: [
+						_r,
+						yr,
+						br,
+						xr,
+						pr,
+						mr
+					]
+				}), hr = te, gr = ur, dr = pr, fr = mr;
+				break;
+			}
+			case "A": {
+				let te = Math.abs(vr[0]), ur = Math.abs(vr[1]), pr = vr[2], mr = vr[3], hr = vr[4], gr = vr[5], _r = vr[6];
+				te === 0 || ur === 0 ? (lr.push({
+					key: "C",
+					data: [
+						dr,
+						fr,
+						gr,
+						_r,
+						gr,
+						_r
+					]
+				}), dr = gr, fr = _r) : (dr !== gr || fr !== _r) && (x(dr, fr, gr, _r, te, ur, pr, mr, hr).forEach((function(te) {
+					lr.push({
+						key: "C",
+						data: te
+					});
+				})), dr = gr, fr = _r);
+				break;
+			}
+			case "Z": lr.push({
+				key: "Z",
+				data: []
+			}), dr = pr, fr = mr;
+		}
+		ur = _r;
+	}
+	return lr;
+}
+function w(te, lr, ur) {
+	return [te * Math.cos(ur) - lr * Math.sin(ur), te * Math.sin(ur) + lr * Math.cos(ur)];
+}
+function x(te, lr, ur, dr, fr, pr, mr, hr, gr, _r) {
+	let vr = (yr = mr, Math.PI * yr / 180);
+	var yr;
+	let br = [], xr = 0, Sr = 0, Cr = 0, wr = 0;
+	if (_r) [xr, Sr, Cr, wr] = _r;
+	else {
+		[te, lr] = w(te, lr, -vr), [ur, dr] = w(ur, dr, -vr);
+		let mr = (te - ur) / 2, _r = (lr - dr) / 2, yr = mr * mr / (fr * fr) + _r * _r / (pr * pr);
+		yr > 1 && (yr = Math.sqrt(yr), fr *= yr, pr *= yr);
+		let br = fr * fr, Tr = pr * pr, Er = br * Tr - br * _r * _r - Tr * mr * mr, Dr = br * _r * _r + Tr * mr * mr, Or = (hr === gr ? -1 : 1) * Math.sqrt(Math.abs(Er / Dr));
+		Cr = Or * fr * _r / pr + (te + ur) / 2, wr = Or * -pr * mr / fr + (lr + dr) / 2, xr = Math.asin(parseFloat(((lr - wr) / pr).toFixed(9))), Sr = Math.asin(parseFloat(((dr - wr) / pr).toFixed(9))), te < Cr && (xr = Math.PI - xr), ur < Cr && (Sr = Math.PI - Sr), xr < 0 && (xr = 2 * Math.PI + xr), Sr < 0 && (Sr = 2 * Math.PI + Sr), gr && xr > Sr && (xr -= 2 * Math.PI), !gr && Sr > xr && (Sr -= 2 * Math.PI);
+	}
+	let Tr = Sr - xr;
+	if (Math.abs(Tr) > 120 * Math.PI / 180) {
+		let te = Sr, lr = ur, hr = dr;
+		Sr = gr && Sr > xr ? xr + 120 * Math.PI / 180 * 1 : xr + 120 * Math.PI / 180 * -1, br = x(ur = Cr + fr * Math.cos(Sr), dr = wr + pr * Math.sin(Sr), lr, hr, fr, pr, mr, 0, gr, [
+			Sr,
+			te,
+			Cr,
+			wr
+		]);
+	}
+	Tr = Sr - xr;
+	let Er = Math.cos(xr), Dr = Math.sin(xr), Or = Math.cos(Sr), kr = Math.sin(Sr), Ar = Math.tan(Tr / 4), jr = 4 / 3 * fr * Ar, Mr = 4 / 3 * pr * Ar, Nr = [te, lr], Pr = [te + jr * Dr, lr - Mr * Er], Fr = [ur + jr * kr, dr - Mr * Or], Ir = [ur, dr];
+	if (Pr[0] = 2 * Nr[0] - Pr[0], Pr[1] = 2 * Nr[1] - Pr[1], _r) return [
+		Pr,
+		Fr,
+		Ir
+	].concat(br);
+	{
+		br = [
+			Pr,
+			Fr,
+			Ir
+		].concat(br);
+		let te = [];
+		for (let lr = 0; lr < br.length; lr += 3) {
+			let ur = w(br[lr][0], br[lr][1], vr), dr = w(br[lr + 1][0], br[lr + 1][1], vr), fr = w(br[lr + 2][0], br[lr + 2][1], vr);
+			te.push([
+				ur[0],
+				ur[1],
+				dr[0],
+				dr[1],
+				fr[0],
+				fr[1]
+			]);
+		}
+		return te;
+	}
+}
+var P = {
+	randOffset: function(te, lr) {
+		return G(te, lr);
+	},
+	randOffsetWithRange: function(te, lr, ur) {
+		return E(te, lr, ur);
+	},
+	ellipse: function(te, lr, ur, dr, fr) {
+		return D(te, lr, fr, T(ur, dr, fr)).opset;
+	},
+	doubleLineOps: function(te, lr, ur, dr, fr) {
+		return $(te, lr, ur, dr, fr, !0);
+	}
+};
+function v(te, lr, ur, dr, fr) {
+	return {
+		type: "path",
+		ops: $(te, lr, ur, dr, fr)
+	};
+}
+function S(te, lr, ur) {
+	let dr = (te || []).length;
+	if (dr > 2) {
+		let fr = [];
+		for (let lr = 0; lr < dr - 1; lr++) fr.push(...$(te[lr][0], te[lr][1], te[lr + 1][0], te[lr + 1][1], ur));
+		return lr && fr.push(...$(te[dr - 1][0], te[dr - 1][1], te[0][0], te[0][1], ur)), {
+			type: "path",
+			ops: fr
+		};
+	}
+	return dr === 2 ? v(te[0][0], te[0][1], te[1][0], te[1][1], ur) : {
+		type: "path",
+		ops: []
+	};
+}
+function O(te, lr, ur, dr, fr) {
+	return function(te, lr) {
+		return S(te, !0, lr);
+	}([
+		[te, lr],
+		[te + ur, lr],
+		[te + ur, lr + dr],
+		[te, lr + dr]
+	], fr);
+}
+function L(te, lr) {
+	if (te.length) {
+		let ur = typeof te[0][0] == "number" ? [te] : te, dr = j(ur[0], 1 * (1 + .2 * lr.roughness), lr), fr = lr.disableMultiStroke ? [] : j(ur[0], 1.5 * (1 + .22 * lr.roughness), z(lr));
+		for (let te = 1; te < ur.length; te++) {
+			let pr = ur[te];
+			if (pr.length) {
+				let te = j(pr, 1 * (1 + .2 * lr.roughness), lr), ur = lr.disableMultiStroke ? [] : j(pr, 1.5 * (1 + .22 * lr.roughness), z(lr));
+				for (let lr of te) lr.op !== "move" && dr.push(lr);
+				for (let te of ur) te.op !== "move" && fr.push(te);
+			}
+		}
+		return {
+			type: "path",
+			ops: dr.concat(fr)
+		};
+	}
+	return {
+		type: "path",
+		ops: []
+	};
+}
+function T(te, lr, ur) {
+	let dr = Math.sqrt(2 * Math.PI * Math.sqrt(((te / 2) ** 2 + (lr / 2) ** 2) / 2)), fr = Math.ceil(Math.max(ur.curveStepCount, ur.curveStepCount / Math.sqrt(200) * dr)), pr = 2 * Math.PI / fr, mr = Math.abs(te / 2), hr = Math.abs(lr / 2), gr = 1 - ur.curveFitting;
+	return mr += G(mr * gr, ur), hr += G(hr * gr, ur), {
+		increment: pr,
+		rx: mr,
+		ry: hr
+	};
+}
+function D(te, lr, ur, dr) {
+	let [fr, pr] = F(dr.increment, te, lr, dr.rx, dr.ry, 1, dr.increment * E(.1, E(.4, 1, ur), ur), ur), mr = q(fr, null, ur);
+	if (!ur.disableMultiStroke && ur.roughness !== 0) {
+		let [fr] = F(dr.increment, te, lr, dr.rx, dr.ry, 1.5, 0, ur), pr = q(fr, null, ur);
+		mr = mr.concat(pr);
+	}
+	return {
+		estimatedPoints: pr,
+		opset: {
+			type: "path",
+			ops: mr
+		}
+	};
+}
+function A(te, lr, ur, dr, fr, pr, mr, hr, gr) {
+	let _r = te, vr = lr, yr = Math.abs(ur / 2), br = Math.abs(dr / 2);
+	yr += G(.01 * yr, gr), br += G(.01 * br, gr);
+	let xr = fr, Sr = pr;
+	for (; xr < 0;) xr += 2 * Math.PI, Sr += 2 * Math.PI;
+	Sr - xr > 2 * Math.PI && (xr = 0, Sr = 2 * Math.PI);
+	let Cr = 2 * Math.PI / gr.curveStepCount, wr = Math.min(Cr / 2, (Sr - xr) / 2), Tr = V(wr, _r, vr, yr, br, xr, Sr, 1, gr);
+	if (!gr.disableMultiStroke) {
+		let te = V(wr, _r, vr, yr, br, xr, Sr, 1.5, gr);
+		Tr.push(...te);
+	}
+	return mr && (hr ? Tr.push(...$(_r, vr, _r + yr * Math.cos(xr), vr + br * Math.sin(xr), gr), ...$(_r, vr, _r + yr * Math.cos(Sr), vr + br * Math.sin(Sr), gr)) : Tr.push({
+		op: "lineTo",
+		data: [_r, vr]
+	}, {
+		op: "lineTo",
+		data: [_r + yr * Math.cos(xr), vr + br * Math.sin(xr)]
+	})), {
+		type: "path",
+		ops: Tr
+	};
+}
+function _(te, lr) {
+	let ur = m(y(b(te))), dr = [], fr = [0, 0], pr = [0, 0];
+	for (let { key: te, data: mr } of ur) switch (te) {
+		case "M":
+			pr = [mr[0], mr[1]], fr = [mr[0], mr[1]];
+			break;
+		case "L":
+			dr.push(...$(pr[0], pr[1], mr[0], mr[1], lr)), pr = [mr[0], mr[1]];
+			break;
+		case "C": {
+			let [te, ur, fr, hr, gr, _r] = mr;
+			dr.push(...Z(te, ur, fr, hr, gr, _r, pr, lr)), pr = [gr, _r];
+			break;
+		}
+		case "Z": dr.push(...$(pr[0], pr[1], fr[0], fr[1], lr)), pr = [fr[0], fr[1]];
+	}
+	return {
+		type: "path",
+		ops: dr
+	};
+}
+function I(te, lr) {
+	let ur = [];
+	for (let dr of te) if (dr.length) {
+		let te = lr.maxRandomnessOffset || 0, fr = dr.length;
+		if (fr > 2) {
+			ur.push({
+				op: "move",
+				data: [dr[0][0] + G(te, lr), dr[0][1] + G(te, lr)]
+			});
+			for (let pr = 1; pr < fr; pr++) ur.push({
+				op: "lineTo",
+				data: [dr[pr][0] + G(te, lr), dr[pr][1] + G(te, lr)]
+			});
+		}
+	}
+	return {
+		type: "fillPath",
+		ops: ur
+	};
+}
+function C(te, lr) {
+	return function(te, lr) {
+		let ur = te.fillStyle || "hachure";
+		if (!u[ur]) switch (ur) {
+			case "zigzag":
+				u[ur] || (u[ur] = new h(lr));
+				break;
+			case "cross-hatch":
+				u[ur] || (u[ur] = new r(lr));
+				break;
+			case "dots":
+				u[ur] || (u[ur] = new i(lr));
+				break;
+			case "dashed":
+				u[ur] || (u[ur] = new c(lr));
+				break;
+			case "zigzag-line":
+				u[ur] || (u[ur] = new l(lr));
+				break;
+			default: ur = "hachure", u[ur] || (u[ur] = new o(lr));
+		}
+		return u[ur];
+	}(lr, P).fillPolygons(te, lr);
+}
+function z(te) {
+	let lr = Object.assign({}, te);
+	return lr.randomizer = void 0, te.seed && (lr.seed = te.seed + 1), lr;
+}
+function W(te) {
+	return te.randomizer ||= new p(te.seed || 0), te.randomizer.next();
+}
+function E(te, lr, ur, dr = 1) {
+	return ur.roughness * dr * (W(ur) * (lr - te) + te);
+}
+function G(te, lr, ur = 1) {
+	return E(-te, te, lr, ur);
+}
+function $(te, lr, ur, dr, fr, pr = !1) {
+	let mr = pr ? fr.disableMultiStrokeFill : fr.disableMultiStroke, hr = R(te, lr, ur, dr, fr, !0, !1);
+	if (mr) return hr;
+	let gr = R(te, lr, ur, dr, fr, !0, !0);
+	return hr.concat(gr);
+}
+function R(te, lr, ur, dr, fr, pr, mr) {
+	let hr = (te - ur) ** 2 + (lr - dr) ** 2, gr = Math.sqrt(hr), _r = 1;
+	_r = gr < 200 ? 1 : gr > 500 ? .4 : -.0016668 * gr + 1.233334;
+	let vr = fr.maxRandomnessOffset || 0;
+	vr * vr * 100 > hr && (vr = gr / 10);
+	let yr = vr / 2, br = .2 + .2 * W(fr), xr = fr.bowing * fr.maxRandomnessOffset * (dr - lr) / 200, Sr = fr.bowing * fr.maxRandomnessOffset * (te - ur) / 200;
+	xr = G(xr, fr, _r), Sr = G(Sr, fr, _r);
+	let Cr = [], wr = () => G(yr, fr, _r), Tr = () => G(vr, fr, _r), Er = fr.preserveVertices;
+	return pr && (mr ? Cr.push({
+		op: "move",
+		data: [te + (Er ? 0 : wr()), lr + (Er ? 0 : wr())]
+	}) : Cr.push({
+		op: "move",
+		data: [te + (Er ? 0 : G(vr, fr, _r)), lr + (Er ? 0 : G(vr, fr, _r))]
+	})), mr ? Cr.push({
+		op: "bcurveTo",
+		data: [
+			xr + te + (ur - te) * br + wr(),
+			Sr + lr + (dr - lr) * br + wr(),
+			xr + te + 2 * (ur - te) * br + wr(),
+			Sr + lr + 2 * (dr - lr) * br + wr(),
+			ur + (Er ? 0 : wr()),
+			dr + (Er ? 0 : wr())
+		]
+	}) : Cr.push({
+		op: "bcurveTo",
+		data: [
+			xr + te + (ur - te) * br + Tr(),
+			Sr + lr + (dr - lr) * br + Tr(),
+			xr + te + 2 * (ur - te) * br + Tr(),
+			Sr + lr + 2 * (dr - lr) * br + Tr(),
+			ur + (Er ? 0 : Tr()),
+			dr + (Er ? 0 : Tr())
+		]
+	}), Cr;
+}
+function j(te, lr, ur) {
+	if (!te.length) return [];
+	let dr = [];
+	dr.push([te[0][0] + G(lr, ur), te[0][1] + G(lr, ur)]), dr.push([te[0][0] + G(lr, ur), te[0][1] + G(lr, ur)]);
+	for (let fr = 1; fr < te.length; fr++) dr.push([te[fr][0] + G(lr, ur), te[fr][1] + G(lr, ur)]), fr === te.length - 1 && dr.push([te[fr][0] + G(lr, ur), te[fr][1] + G(lr, ur)]);
+	return q(dr, null, ur);
+}
+function q(te, lr, ur) {
+	let dr = te.length, fr = [];
+	if (dr > 3) {
+		let pr = [], mr = 1 - ur.curveTightness;
+		fr.push({
+			op: "move",
+			data: [te[1][0], te[1][1]]
+		});
+		for (let lr = 1; lr + 2 < dr; lr++) {
+			let ur = te[lr];
+			pr[0] = [ur[0], ur[1]], pr[1] = [ur[0] + (mr * te[lr + 1][0] - mr * te[lr - 1][0]) / 6, ur[1] + (mr * te[lr + 1][1] - mr * te[lr - 1][1]) / 6], pr[2] = [te[lr + 1][0] + (mr * te[lr][0] - mr * te[lr + 2][0]) / 6, te[lr + 1][1] + (mr * te[lr][1] - mr * te[lr + 2][1]) / 6], pr[3] = [te[lr + 1][0], te[lr + 1][1]], fr.push({
+				op: "bcurveTo",
+				data: [
+					pr[1][0],
+					pr[1][1],
+					pr[2][0],
+					pr[2][1],
+					pr[3][0],
+					pr[3][1]
+				]
+			});
+		}
+		if (lr && lr.length === 2) {
+			let te = ur.maxRandomnessOffset;
+			fr.push({
+				op: "lineTo",
+				data: [lr[0] + G(te, ur), lr[1] + G(te, ur)]
+			});
+		}
+	} else dr === 3 ? (fr.push({
+		op: "move",
+		data: [te[1][0], te[1][1]]
+	}), fr.push({
+		op: "bcurveTo",
+		data: [
+			te[1][0],
+			te[1][1],
+			te[2][0],
+			te[2][1],
+			te[2][0],
+			te[2][1]
+		]
+	})) : dr === 2 && fr.push(...R(te[0][0], te[0][1], te[1][0], te[1][1], ur, !0, !0));
+	return fr;
+}
+function F(te, lr, ur, dr, fr, pr, mr, hr) {
+	let gr = [], _r = [];
+	if (hr.roughness === 0) {
+		te /= 4, _r.push([lr + dr * Math.cos(-te), ur + fr * Math.sin(-te)]);
+		for (let pr = 0; pr <= 2 * Math.PI; pr += te) {
+			let te = [lr + dr * Math.cos(pr), ur + fr * Math.sin(pr)];
+			gr.push(te), _r.push(te);
+		}
+		_r.push([lr + dr * Math.cos(0), ur + fr * Math.sin(0)]), _r.push([lr + dr * Math.cos(te), ur + fr * Math.sin(te)]);
+	} else {
+		let vr = G(.5, hr) - Math.PI / 2;
+		_r.push([G(pr, hr) + lr + .9 * dr * Math.cos(vr - te), G(pr, hr) + ur + .9 * fr * Math.sin(vr - te)]);
+		let yr = 2 * Math.PI + vr - .01;
+		for (let mr = vr; mr < yr; mr += te) {
+			let te = [G(pr, hr) + lr + dr * Math.cos(mr), G(pr, hr) + ur + fr * Math.sin(mr)];
+			gr.push(te), _r.push(te);
+		}
+		_r.push([G(pr, hr) + lr + dr * Math.cos(vr + 2 * Math.PI + .5 * mr), G(pr, hr) + ur + fr * Math.sin(vr + 2 * Math.PI + .5 * mr)]), _r.push([G(pr, hr) + lr + .98 * dr * Math.cos(vr + mr), G(pr, hr) + ur + .98 * fr * Math.sin(vr + mr)]), _r.push([G(pr, hr) + lr + .9 * dr * Math.cos(vr + .5 * mr), G(pr, hr) + ur + .9 * fr * Math.sin(vr + .5 * mr)]);
+	}
+	return [_r, gr];
+}
+function V(te, lr, ur, dr, fr, pr, mr, hr, gr) {
+	let _r = pr + G(.1, gr), vr = [];
+	vr.push([G(hr, gr) + lr + .9 * dr * Math.cos(_r - te), G(hr, gr) + ur + .9 * fr * Math.sin(_r - te)]);
+	for (let pr = _r; pr <= mr; pr += te) vr.push([G(hr, gr) + lr + dr * Math.cos(pr), G(hr, gr) + ur + fr * Math.sin(pr)]);
+	return vr.push([lr + dr * Math.cos(mr), ur + fr * Math.sin(mr)]), vr.push([lr + dr * Math.cos(mr), ur + fr * Math.sin(mr)]), q(vr, null, gr);
+}
+function Z(te, lr, ur, dr, fr, pr, mr, hr) {
+	let gr = [], _r = [hr.maxRandomnessOffset || 1, (hr.maxRandomnessOffset || 1) + .3], vr = [0, 0], yr = hr.disableMultiStroke ? 1 : 2, br = hr.preserveVertices;
+	for (let xr = 0; xr < yr; xr++) xr === 0 ? gr.push({
+		op: "move",
+		data: [mr[0], mr[1]]
+	}) : gr.push({
+		op: "move",
+		data: [mr[0] + (br ? 0 : G(_r[0], hr)), mr[1] + (br ? 0 : G(_r[0], hr))]
+	}), vr = br ? [fr, pr] : [fr + G(_r[xr], hr), pr + G(_r[xr], hr)], gr.push({
+		op: "bcurveTo",
+		data: [
+			te + G(_r[xr], hr),
+			lr + G(_r[xr], hr),
+			ur + G(_r[xr], hr),
+			dr + G(_r[xr], hr),
+			vr[0],
+			vr[1]
+		]
+	});
+	return gr;
+}
+function Q(te) {
+	return [...te];
+}
+function H(te, lr = 0) {
+	let ur = te.length;
+	if (ur < 3) throw Error("A curve must have at least three points.");
+	let dr = [];
+	if (ur === 3) dr.push(Q(te[0]), Q(te[1]), Q(te[2]), Q(te[2]));
+	else {
+		let ur = [];
+		ur.push(te[0], te[0]);
+		for (let lr = 1; lr < te.length; lr++) ur.push(te[lr]), lr === te.length - 1 && ur.push(te[lr]);
+		let fr = [], pr = 1 - lr;
+		dr.push(Q(ur[0]));
+		for (let te = 1; te + 2 < ur.length; te++) {
+			let lr = ur[te];
+			fr[0] = [lr[0], lr[1]], fr[1] = [lr[0] + (pr * ur[te + 1][0] - pr * ur[te - 1][0]) / 6, lr[1] + (pr * ur[te + 1][1] - pr * ur[te - 1][1]) / 6], fr[2] = [ur[te + 1][0] + (pr * ur[te][0] - pr * ur[te + 2][0]) / 6, ur[te + 1][1] + (pr * ur[te][1] - pr * ur[te + 2][1]) / 6], fr[3] = [ur[te + 1][0], ur[te + 1][1]], dr.push(fr[1], fr[2], fr[3]);
+		}
+	}
+	return dr;
+}
+function N(te, lr) {
+	return (te[0] - lr[0]) ** 2 + (te[1] - lr[1]) ** 2;
+}
+function B(te, lr, ur) {
+	let dr = N(lr, ur);
+	if (dr === 0) return N(te, lr);
+	let fr = ((te[0] - lr[0]) * (ur[0] - lr[0]) + (te[1] - lr[1]) * (ur[1] - lr[1])) / dr;
+	return fr = Math.max(0, Math.min(1, fr)), N(te, J(lr, ur, fr));
+}
+function J(te, lr, ur) {
+	return [te[0] + (lr[0] - te[0]) * ur, te[1] + (lr[1] - te[1]) * ur];
+}
+function K(te, lr, ur, dr) {
+	let fr = dr || [];
+	if (function(te, lr) {
+		let ur = te[lr + 0], dr = te[lr + 1], fr = te[lr + 2], pr = te[lr + 3], mr = 3 * dr[0] - 2 * ur[0] - pr[0];
+		mr *= mr;
+		let hr = 3 * dr[1] - 2 * ur[1] - pr[1];
+		hr *= hr;
+		let gr = 3 * fr[0] - 2 * pr[0] - ur[0];
+		gr *= gr;
+		let _r = 3 * fr[1] - 2 * pr[1] - ur[1];
+		return _r *= _r, mr < gr && (mr = gr), hr < _r && (hr = _r), mr + hr;
+	}(te, lr) < ur) {
+		let ur = te[lr + 0];
+		fr.length ? (pr = fr[fr.length - 1], mr = ur, Math.sqrt(N(pr, mr))) > 1 && fr.push(ur) : fr.push(ur), fr.push(te[lr + 3]);
+	} else {
+		let dr = .5, pr = te[lr + 0], mr = te[lr + 1], hr = te[lr + 2], gr = te[lr + 3], _r = J(pr, mr, dr), vr = J(mr, hr, dr), yr = J(hr, gr, dr), br = J(_r, vr, dr), xr = J(vr, yr, dr), Sr = J(br, xr, dr);
+		K([
+			pr,
+			_r,
+			br,
+			Sr
+		], 0, ur, fr), K([
+			Sr,
+			xr,
+			yr,
+			gr
+		], 0, ur, fr);
+	}
+	var pr, mr;
+	return fr;
+}
+function U(te, lr) {
+	return X(te, 0, te.length, lr);
+}
+function X(te, lr, ur, dr, fr) {
+	let pr = fr || [], mr = te[lr], hr = te[ur - 1], gr = 0, _r = 1;
+	for (let dr = lr + 1; dr < ur - 1; ++dr) {
+		let lr = B(te[dr], mr, hr);
+		lr > gr && (gr = lr, _r = dr);
+	}
+	return Math.sqrt(gr) > dr ? (X(te, lr, _r + 1, dr, pr), X(te, _r, ur, dr, pr)) : (pr.length || pr.push(mr), pr.push(hr)), pr;
+}
+function Y(te, lr = .15, ur) {
+	let dr = [], fr = (te.length - 1) / 3;
+	for (let ur = 0; ur < fr; ur++) K(te, 3 * ur, lr, dr);
+	return ur && ur > 0 ? X(dr, 0, dr.length, ur) : dr;
+}
+var tt = "none", et = class {
+	constructor(te) {
+		this.defaultOptions = {
+			maxRandomnessOffset: 2,
+			roughness: 1,
+			bowing: 1,
+			stroke: "#000",
+			strokeWidth: 1,
+			curveTightness: 0,
+			curveFitting: .95,
+			curveStepCount: 9,
+			fillStyle: "hachure",
+			fillWeight: -1,
+			hachureAngle: -41,
+			hachureGap: -1,
+			dashOffset: -1,
+			dashGap: -1,
+			zigzagOffset: -1,
+			seed: 0,
+			disableMultiStroke: !1,
+			disableMultiStrokeFill: !1,
+			preserveVertices: !1,
+			fillShapeRoughnessGain: .8
+		}, this.config = te || {}, this.config.options && (this.defaultOptions = this._o(this.config.options));
+	}
+	static newSeed() {
+		return Math.floor(Math.random() * 2 ** 31);
+	}
+	_o(te) {
+		return te ? Object.assign({}, this.defaultOptions, te) : this.defaultOptions;
+	}
+	_d(te, lr, ur) {
+		return {
+			shape: te,
+			sets: lr || [],
+			options: ur || this.defaultOptions
+		};
+	}
+	line(te, lr, ur, dr, fr) {
+		let pr = this._o(fr);
+		return this._d("line", [v(te, lr, ur, dr, pr)], pr);
+	}
+	rectangle(te, lr, ur, dr, fr) {
+		let pr = this._o(fr), mr = [], hr = O(te, lr, ur, dr, pr);
+		if (pr.fill) {
+			let fr = [
+				[te, lr],
+				[te + ur, lr],
+				[te + ur, lr + dr],
+				[te, lr + dr]
+			];
+			pr.fillStyle === "solid" ? mr.push(I([fr], pr)) : mr.push(C([fr], pr));
+		}
+		return pr.stroke !== tt && mr.push(hr), this._d("rectangle", mr, pr);
+	}
+	ellipse(te, lr, ur, dr, fr) {
+		let pr = this._o(fr), mr = [], hr = T(ur, dr, pr), gr = D(te, lr, pr, hr);
+		if (pr.fill) if (pr.fillStyle === "solid") {
+			let ur = D(te, lr, pr, hr).opset;
+			ur.type = "fillPath", mr.push(ur);
+		} else mr.push(C([gr.estimatedPoints], pr));
+		return pr.stroke !== tt && mr.push(gr.opset), this._d("ellipse", mr, pr);
+	}
+	circle(te, lr, ur, dr) {
+		let fr = this.ellipse(te, lr, ur, ur, dr);
+		return fr.shape = "circle", fr;
+	}
+	linearPath(te, lr) {
+		let ur = this._o(lr);
+		return this._d("linearPath", [S(te, !1, ur)], ur);
+	}
+	arc(te, lr, ur, dr, fr, pr, mr = !1, hr) {
+		let gr = this._o(hr), _r = [], vr = A(te, lr, ur, dr, fr, pr, mr, !0, gr);
+		if (mr && gr.fill) if (gr.fillStyle === "solid") {
+			let mr = Object.assign({}, gr);
+			mr.disableMultiStroke = !0;
+			let hr = A(te, lr, ur, dr, fr, pr, !0, !1, mr);
+			hr.type = "fillPath", _r.push(hr);
+		} else _r.push(function(te, lr, ur, dr, fr, pr, mr) {
+			let hr = te, gr = lr, _r = Math.abs(ur / 2), vr = Math.abs(dr / 2);
+			_r += G(.01 * _r, mr), vr += G(.01 * vr, mr);
+			let yr = fr, br = pr;
+			for (; yr < 0;) yr += 2 * Math.PI, br += 2 * Math.PI;
+			br - yr > 2 * Math.PI && (yr = 0, br = 2 * Math.PI);
+			let xr = (br - yr) / mr.curveStepCount, Sr = [];
+			for (let te = yr; te <= br; te += xr) Sr.push([hr + _r * Math.cos(te), gr + vr * Math.sin(te)]);
+			return Sr.push([hr + _r * Math.cos(br), gr + vr * Math.sin(br)]), Sr.push([hr, gr]), C([Sr], mr);
+		}(te, lr, ur, dr, fr, pr, gr));
+		return gr.stroke !== tt && _r.push(vr), this._d("arc", _r, gr);
+	}
+	curve(te, lr) {
+		let ur = this._o(lr), dr = [], fr = L(te, ur);
+		if (ur.fill && ur.fill !== tt) if (ur.fillStyle === "solid") {
+			let lr = L(te, Object.assign(Object.assign({}, ur), {
+				disableMultiStroke: !0,
+				roughness: ur.roughness ? ur.roughness + ur.fillShapeRoughnessGain : 0
+			}));
+			dr.push({
+				type: "fillPath",
+				ops: this._mergedShape(lr.ops)
+			});
+		} else {
+			let lr = [], fr = te;
+			if (fr.length) {
+				let te = typeof fr[0][0] == "number" ? [fr] : fr;
+				for (let dr of te) dr.length < 3 ? lr.push(...dr) : dr.length === 3 ? lr.push(...Y(H([
+					dr[0],
+					dr[0],
+					dr[1],
+					dr[2]
+				]), 10, (1 + ur.roughness) / 2)) : lr.push(...Y(H(dr), 10, (1 + ur.roughness) / 2));
+			}
+			lr.length && dr.push(C([lr], ur));
+		}
+		return ur.stroke !== tt && dr.push(fr), this._d("curve", dr, ur);
+	}
+	polygon(te, lr) {
+		let ur = this._o(lr), dr = [], fr = S(te, !0, ur);
+		return ur.fill && (ur.fillStyle === "solid" ? dr.push(I([te], ur)) : dr.push(C([te], ur))), ur.stroke !== tt && dr.push(fr), this._d("polygon", dr, ur);
+	}
+	path(te, lr) {
+		let ur = this._o(lr), dr = [];
+		if (!te) return this._d("path", dr, ur);
+		te = (te || "").replace(/\n/g, " ").replace(/(-\s)/g, "-").replace("/(ss)/g", " ");
+		let fr = ur.fill && ur.fill !== "transparent" && ur.fill !== tt, pr = ur.stroke !== tt, mr = !!(ur.simplification && ur.simplification < 1), hr = function(te, lr, ur) {
+			let dr = m(y(b(te))), fr = [], pr = [], mr = [0, 0], hr = [], gr = () => {
+				hr.length >= 4 && pr.push(...Y(hr, lr)), hr = [];
+			}, _r = () => {
+				gr(), pr.length && (fr.push(pr), pr = []);
+			};
+			for (let { key: te, data: lr } of dr) switch (te) {
+				case "M":
+					_r(), mr = [lr[0], lr[1]], pr.push(mr);
+					break;
+				case "L":
+					gr(), pr.push([lr[0], lr[1]]);
+					break;
+				case "C":
+					if (!hr.length) {
+						let te = pr.length ? pr[pr.length - 1] : mr;
+						hr.push([te[0], te[1]]);
+					}
+					hr.push([lr[0], lr[1]]), hr.push([lr[2], lr[3]]), hr.push([lr[4], lr[5]]);
+					break;
+				case "Z": gr(), pr.push([mr[0], mr[1]]);
+			}
+			if (_r(), !ur) return fr;
+			let vr = [];
+			for (let te of fr) {
+				let lr = U(te, ur);
+				lr.length && vr.push(lr);
+			}
+			return vr;
+		}(te, 1, mr ? 4 - 4 * (ur.simplification || 1) : (1 + ur.roughness) / 2), gr = _(te, ur);
+		if (fr) if (ur.fillStyle === "solid") if (hr.length === 1) {
+			let lr = _(te, Object.assign(Object.assign({}, ur), {
+				disableMultiStroke: !0,
+				roughness: ur.roughness ? ur.roughness + ur.fillShapeRoughnessGain : 0
+			}));
+			dr.push({
+				type: "fillPath",
+				ops: this._mergedShape(lr.ops)
+			});
+		} else dr.push(I(hr, ur));
+		else dr.push(C(hr, ur));
+		return pr && (mr ? hr.forEach(((te) => {
+			dr.push(S(te, !1, ur));
+		})) : dr.push(gr)), this._d("path", dr, ur);
+	}
+	opsToPath(te, lr) {
+		let ur = "";
+		for (let dr of te.ops) {
+			let te = typeof lr == "number" && lr >= 0 ? dr.data.map(((te) => +te.toFixed(lr))) : dr.data;
+			switch (dr.op) {
+				case "move":
+					ur += `M${te[0]} ${te[1]} `;
+					break;
+				case "bcurveTo":
+					ur += `C${te[0]} ${te[1]}, ${te[2]} ${te[3]}, ${te[4]} ${te[5]} `;
+					break;
+				case "lineTo": ur += `L${te[0]} ${te[1]} `;
+			}
+		}
+		return ur.trim();
+	}
+	toPaths(te) {
+		let lr = te.sets || [], ur = te.options || this.defaultOptions, dr = [];
+		for (let te of lr) {
+			let lr = null;
+			switch (te.type) {
+				case "path":
+					lr = {
+						d: this.opsToPath(te),
+						stroke: ur.stroke,
+						strokeWidth: ur.strokeWidth,
+						fill: tt
+					};
+					break;
+				case "fillPath":
+					lr = {
+						d: this.opsToPath(te),
+						stroke: tt,
+						strokeWidth: 0,
+						fill: ur.fill || tt
+					};
+					break;
+				case "fillSketch": lr = this.fillSketch(te, ur);
+			}
+			lr && dr.push(lr);
+		}
+		return dr;
+	}
+	fillSketch(te, lr) {
+		let ur = lr.fillWeight;
+		return ur < 0 && (ur = lr.strokeWidth / 2), {
+			d: this.opsToPath(te),
+			stroke: lr.fill || tt,
+			strokeWidth: ur,
+			fill: tt
+		};
+	}
+	_mergedShape(te) {
+		return te.filter(((te, lr) => lr === 0 || te.op !== "move"));
+	}
+}, st = class {
+	constructor(te, lr) {
+		this.canvas = te, this.ctx = this.canvas.getContext("2d"), this.gen = new et(lr);
+	}
+	draw(te) {
+		let lr = te.sets || [], ur = te.options || this.getDefaultOptions(), dr = this.ctx, fr = te.options.fixedDecimalPlaceDigits;
+		for (let pr of lr) switch (pr.type) {
+			case "path":
+				dr.save(), dr.strokeStyle = ur.stroke === "none" ? "transparent" : ur.stroke, dr.lineWidth = ur.strokeWidth, ur.strokeLineDash && dr.setLineDash(ur.strokeLineDash), ur.strokeLineDashOffset && (dr.lineDashOffset = ur.strokeLineDashOffset), this._drawToContext(dr, pr, fr), dr.restore();
+				break;
+			case "fillPath": {
+				dr.save(), dr.fillStyle = ur.fill || "";
+				let lr = te.shape === "curve" || te.shape === "polygon" || te.shape === "path" ? "evenodd" : "nonzero";
+				this._drawToContext(dr, pr, fr, lr), dr.restore();
+				break;
+			}
+			case "fillSketch": this.fillSketch(dr, pr, ur);
+		}
+	}
+	fillSketch(te, lr, ur) {
+		let dr = ur.fillWeight;
+		dr < 0 && (dr = ur.strokeWidth / 2), te.save(), ur.fillLineDash && te.setLineDash(ur.fillLineDash), ur.fillLineDashOffset && (te.lineDashOffset = ur.fillLineDashOffset), te.strokeStyle = ur.fill || "", te.lineWidth = dr, this._drawToContext(te, lr, ur.fixedDecimalPlaceDigits), te.restore();
+	}
+	_drawToContext(te, lr, ur, dr = "nonzero") {
+		te.beginPath();
+		for (let dr of lr.ops) {
+			let lr = typeof ur == "number" && ur >= 0 ? dr.data.map(((te) => +te.toFixed(ur))) : dr.data;
+			switch (dr.op) {
+				case "move":
+					te.moveTo(lr[0], lr[1]);
+					break;
+				case "bcurveTo":
+					te.bezierCurveTo(lr[0], lr[1], lr[2], lr[3], lr[4], lr[5]);
+					break;
+				case "lineTo": te.lineTo(lr[0], lr[1]);
+			}
+		}
+		lr.type === "fillPath" ? te.fill(dr) : te.stroke();
+	}
+	get generator() {
+		return this.gen;
+	}
+	getDefaultOptions() {
+		return this.gen.defaultOptions;
+	}
+	line(te, lr, ur, dr, fr) {
+		let pr = this.gen.line(te, lr, ur, dr, fr);
+		return this.draw(pr), pr;
+	}
+	rectangle(te, lr, ur, dr, fr) {
+		let pr = this.gen.rectangle(te, lr, ur, dr, fr);
+		return this.draw(pr), pr;
+	}
+	ellipse(te, lr, ur, dr, fr) {
+		let pr = this.gen.ellipse(te, lr, ur, dr, fr);
+		return this.draw(pr), pr;
+	}
+	circle(te, lr, ur, dr) {
+		let fr = this.gen.circle(te, lr, ur, dr);
+		return this.draw(fr), fr;
+	}
+	linearPath(te, lr) {
+		let ur = this.gen.linearPath(te, lr);
+		return this.draw(ur), ur;
+	}
+	polygon(te, lr) {
+		let ur = this.gen.polygon(te, lr);
+		return this.draw(ur), ur;
+	}
+	arc(te, lr, ur, dr, fr, pr, mr = !1, hr) {
+		let gr = this.gen.arc(te, lr, ur, dr, fr, pr, mr, hr);
+		return this.draw(gr), gr;
+	}
+	curve(te, lr) {
+		let ur = this.gen.curve(te, lr);
+		return this.draw(ur), ur;
+	}
+	path(te, lr) {
+		let ur = this.gen.path(te, lr);
+		return this.draw(ur), ur;
+	}
+}, nt = "http://www.w3.org/2000/svg", ot = class {
+	constructor(te, lr) {
+		this.svg = te, this.gen = new et(lr);
+	}
+	draw(te) {
+		let lr = te.sets || [], ur = te.options || this.getDefaultOptions(), dr = this.svg.ownerDocument || window.document, fr = dr.createElementNS(nt, "g"), pr = te.options.fixedDecimalPlaceDigits;
+		for (let mr of lr) {
+			let lr = null;
+			switch (mr.type) {
+				case "path":
+					lr = dr.createElementNS(nt, "path"), lr.setAttribute("d", this.opsToPath(mr, pr)), lr.setAttribute("stroke", ur.stroke), lr.setAttribute("stroke-width", ur.strokeWidth + ""), lr.setAttribute("fill", "none"), ur.strokeLineDash && lr.setAttribute("stroke-dasharray", ur.strokeLineDash.join(" ").trim()), ur.strokeLineDashOffset && lr.setAttribute("stroke-dashoffset", `${ur.strokeLineDashOffset}`);
+					break;
+				case "fillPath":
+					lr = dr.createElementNS(nt, "path"), lr.setAttribute("d", this.opsToPath(mr, pr)), lr.setAttribute("stroke", "none"), lr.setAttribute("stroke-width", "0"), lr.setAttribute("fill", ur.fill || ""), te.shape !== "curve" && te.shape !== "polygon" || lr.setAttribute("fill-rule", "evenodd");
+					break;
+				case "fillSketch": lr = this.fillSketch(dr, mr, ur);
+			}
+			lr && fr.appendChild(lr);
+		}
+		return fr;
+	}
+	fillSketch(te, lr, ur) {
+		let dr = ur.fillWeight;
+		dr < 0 && (dr = ur.strokeWidth / 2);
+		let fr = te.createElementNS(nt, "path");
+		return fr.setAttribute("d", this.opsToPath(lr, ur.fixedDecimalPlaceDigits)), fr.setAttribute("stroke", ur.fill || ""), fr.setAttribute("stroke-width", dr + ""), fr.setAttribute("fill", "none"), ur.fillLineDash && fr.setAttribute("stroke-dasharray", ur.fillLineDash.join(" ").trim()), ur.fillLineDashOffset && fr.setAttribute("stroke-dashoffset", `${ur.fillLineDashOffset}`), fr;
+	}
+	get generator() {
+		return this.gen;
+	}
+	getDefaultOptions() {
+		return this.gen.defaultOptions;
+	}
+	opsToPath(te, lr) {
+		return this.gen.opsToPath(te, lr);
+	}
+	line(te, lr, ur, dr, fr) {
+		let pr = this.gen.line(te, lr, ur, dr, fr);
+		return this.draw(pr);
+	}
+	rectangle(te, lr, ur, dr, fr) {
+		let pr = this.gen.rectangle(te, lr, ur, dr, fr);
+		return this.draw(pr);
+	}
+	ellipse(te, lr, ur, dr, fr) {
+		let pr = this.gen.ellipse(te, lr, ur, dr, fr);
+		return this.draw(pr);
+	}
+	circle(te, lr, ur, dr) {
+		let fr = this.gen.circle(te, lr, ur, dr);
+		return this.draw(fr);
+	}
+	linearPath(te, lr) {
+		let ur = this.gen.linearPath(te, lr);
+		return this.draw(ur);
+	}
+	polygon(te, lr) {
+		let ur = this.gen.polygon(te, lr);
+		return this.draw(ur);
+	}
+	arc(te, lr, ur, dr, fr, pr, mr = !1, hr) {
+		let gr = this.gen.arc(te, lr, ur, dr, fr, pr, mr, hr);
+		return this.draw(gr);
+	}
+	curve(te, lr) {
+		let ur = this.gen.curve(te, lr);
+		return this.draw(ur);
+	}
+	path(te, lr) {
+		let ur = this.gen.path(te, lr);
+		return this.draw(ur);
+	}
+}, at = {
+	canvas: (te, lr) => new st(te, lr),
+	svg: (te, lr) => new ot(te, lr),
+	generator: (te) => new et(te),
+	newSeed: () => et.newSeed()
+}, labelHelper = /* @__PURE__ */ __name(async (te, dr, pr) => {
+	let mr, hr = dr.useHtmlLabels || evaluate(getConfig2()?.htmlLabels);
+	mr = pr || "node default";
+	let yr = te.insert("g").attr("class", mr).attr("id", dr.domId || dr.id), br = yr.insert("g").attr("class", "label").attr("style", handleUndefinedAttr(dr.labelStyle)), Cr;
+	Cr = dr.label === void 0 ? "" : typeof dr.label == "string" ? dr.label : dr.label[0];
+	let Er = await createText(br, sanitizeText(decodeEntities(Cr), getConfig2()), {
+		useHtmlLabels: hr,
+		width: dr.width || getConfig2().flowchart?.wrappingWidth,
+		cssClasses: "markdown-node-label",
+		style: dr.labelStyle,
+		addSvgBackground: !!dr.icon || !!dr.img
+	}), Dr = Er.getBBox(), Or = (dr?.padding ?? 0) / 2;
+	if (hr) {
+		let te = Er.children[0], dr = select_default(Er), fr = te.getElementsByTagName("img");
+		if (fr) {
+			let te = Cr.replace(/<img[^>]*>/g, "").trim() === "";
+			await Promise.all([...fr].map((ur) => new Promise((dr) => {
+				function fr() {
+					if (ur.style.display = "flex", ur.style.flexDirection = "column", te) {
+						let [te = defaultConfig_default.fontSize] = parseFontSize(getConfig2().fontSize ? getConfig2().fontSize : window.getComputedStyle(document.body).fontSize), lr = te * 5 + "px";
+						ur.style.minWidth = lr, ur.style.maxWidth = lr;
+					} else ur.style.width = "100%";
+					dr(ur);
+				}
+				__name(fr, "setupImage"), setTimeout(() => {
+					ur.complete && fr();
+				}), ur.addEventListener("error", fr), ur.addEventListener("load", fr);
+			})));
+		}
+		Dr = te.getBoundingClientRect(), dr.attr("width", Dr.width), dr.attr("height", Dr.height);
+	}
+	return hr ? br.attr("transform", "translate(" + -Dr.width / 2 + ", " + -Dr.height / 2 + ")") : br.attr("transform", "translate(0, " + -Dr.height / 2 + ")"), dr.centerLabel && br.attr("transform", "translate(" + -Dr.width / 2 + ", " + -Dr.height / 2 + ")"), br.insert("rect", ":first-child"), {
+		shapeSvg: yr,
+		bbox: Dr,
+		halfPadding: Or,
+		label: br
+	};
+}, "labelHelper"), insertLabel = /* @__PURE__ */ __name(async (te, lr, dr) => {
+	let pr = dr.useHtmlLabels || evaluate(getConfig2()?.flowchart?.htmlLabels), mr = te.insert("g").attr("class", "label").attr("style", dr.labelStyle || ""), hr = await createText(mr, sanitizeText(decodeEntities(lr), getConfig2()), {
+		useHtmlLabels: pr,
+		width: dr.width || getConfig2()?.flowchart?.wrappingWidth,
+		style: dr.labelStyle,
+		addSvgBackground: !!dr.icon || !!dr.img
+	}), _r = hr.getBBox(), yr = dr.padding / 2;
+	if (evaluate(getConfig2()?.flowchart?.htmlLabels)) {
+		let te = hr.children[0], lr = select_default(hr);
+		_r = te.getBoundingClientRect(), lr.attr("width", _r.width), lr.attr("height", _r.height);
+	}
+	return pr ? mr.attr("transform", "translate(" + -_r.width / 2 + ", " + -_r.height / 2 + ")") : mr.attr("transform", "translate(0, " + -_r.height / 2 + ")"), dr.centerLabel && mr.attr("transform", "translate(" + -_r.width / 2 + ", " + -_r.height / 2 + ")"), mr.insert("rect", ":first-child"), {
+		shapeSvg: te,
+		bbox: _r,
+		halfPadding: yr,
+		label: mr
+	};
+}, "insertLabel"), updateNodeBounds = /* @__PURE__ */ __name((te, lr) => {
+	let ur = lr.node().getBBox();
+	te.width = ur.width, te.height = ur.height;
+}, "updateNodeBounds"), getNodeClasses = /* @__PURE__ */ __name((te, lr) => (te.look === "handDrawn" ? "rough-node" : "node") + " " + te.cssClasses + " " + (lr || ""), "getNodeClasses");
+function createPathFromPoints(te) {
+	let lr = te.map((te, lr) => `${lr === 0 ? "M" : "L"}${te.x},${te.y}`);
+	return lr.push("Z"), lr.join(" ");
+}
+__name(createPathFromPoints, "createPathFromPoints");
+function generateFullSineWavePoints(te, lr, ur, dr, fr, pr) {
+	let mr = [], hr = ur - te, gr = dr - lr, _r = hr / pr, vr = 2 * Math.PI / _r, yr = lr + gr / 2;
+	for (let lr = 0; lr <= 50; lr++) {
+		let ur = te + lr / 50 * hr, dr = yr + fr * Math.sin(vr * (ur - te));
+		mr.push({
+			x: ur,
+			y: dr
+		});
+	}
+	return mr;
+}
+__name(generateFullSineWavePoints, "generateFullSineWavePoints");
+function generateCirclePoints(te, lr, ur, dr, fr, pr) {
+	let mr = [], hr = fr * Math.PI / 180, gr = (pr * Math.PI / 180 - hr) / (dr - 1);
+	for (let fr = 0; fr < dr; fr++) {
+		let dr = hr + fr * gr, pr = te + ur * Math.cos(dr), _r = lr + ur * Math.sin(dr);
+		mr.push({
+			x: -pr,
+			y: -_r
+		});
+	}
+	return mr;
+}
+__name(generateCirclePoints, "generateCirclePoints");
+var intersect_rect_default = /* @__PURE__ */ __name((te, lr) => {
+	var ur = te.x, dr = te.y, fr = lr.x - ur, pr = lr.y - dr, mr = te.width / 2, hr = te.height / 2, gr, _r;
+	return Math.abs(pr) * mr > Math.abs(fr) * hr ? (pr < 0 && (hr = -hr), gr = pr === 0 ? 0 : hr * fr / pr, _r = hr) : (fr < 0 && (mr = -mr), gr = mr, _r = fr === 0 ? 0 : mr * pr / fr), {
+		x: ur + gr,
+		y: dr + _r
+	};
+}, "intersectRect");
+function applyStyle(te, lr) {
+	lr && te.attr("style", lr);
+}
+__name(applyStyle, "applyStyle");
+async function addHtmlLabel(te) {
+	let lr = select_default(document.createElementNS("http://www.w3.org/2000/svg", "foreignObject")), dr = lr.append("xhtml:div"), pr = getConfig2(), _r = te.label;
+	te.label && hasKatex(te.label) && (_r = await renderKatexSanitized(te.label.replace(common_default.lineBreakRegex, "\n"), pr));
+	let vr = "<span class=\"" + (te.isNode ? "nodeLabel" : "edgeLabel") + "\" " + (te.labelStyle ? "style=\"" + te.labelStyle + "\"" : "") + ">" + _r + "</span>";
+	return dr.html(sanitizeText(vr, pr)), applyStyle(dr, te.labelStyle), dr.style("display", "inline-block"), dr.style("padding-right", "1px"), dr.style("white-space", "nowrap"), dr.attr("xmlns", "http://www.w3.org/1999/xhtml"), lr.node();
+}
+__name(addHtmlLabel, "addHtmlLabel");
+var createLabel_default = /* @__PURE__ */ __name(async (lr, ur, dr, fr) => {
+	let pr = lr || "";
+	if (typeof pr == "object" && (pr = pr[0]), evaluate(getConfig2().flowchart.htmlLabels)) return pr = pr.replace(/\\n|\n/g, "<br />"), log.info("vertexText" + pr), await addHtmlLabel({
+		isNode: fr,
+		label: decodeEntities(pr).replace(/fa[blrs]?:fa-[\w-]+/g, (te) => `<i class='${te.replace(":", " ")}'></i>`),
+		labelStyle: ur && ur.replace("fill:", "color:")
+	});
+	{
+		let te = document.createElementNS("http://www.w3.org/2000/svg", "text");
+		te.setAttribute("style", ur.replace("color:", "fill:"));
+		let lr = [];
+		lr = typeof pr == "string" ? pr.split(/\\n|\n|<br\s*\/?>/gi) : Array.isArray(pr) ? pr : [];
+		for (let ur of lr) {
+			let lr = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+			lr.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve"), lr.setAttribute("dy", "1em"), lr.setAttribute("x", "0"), dr ? lr.setAttribute("class", "title-row") : lr.setAttribute("class", "row"), lr.textContent = ur.trim(), te.appendChild(lr);
+		}
+		return te;
+	}
+}, "createLabel"), createRoundedRectPathD = /* @__PURE__ */ __name((te, lr, ur, dr, fr) => [
+	"M",
+	te + fr,
+	lr,
+	"H",
+	te + ur - fr,
+	"A",
+	fr,
+	fr,
+	0,
+	0,
+	1,
+	te + ur,
+	lr + fr,
+	"V",
+	lr + dr - fr,
+	"A",
+	fr,
+	fr,
+	0,
+	0,
+	1,
+	te + ur - fr,
+	lr + dr,
+	"H",
+	te + fr,
+	"A",
+	fr,
+	fr,
+	0,
+	0,
+	1,
+	te,
+	lr + dr - fr,
+	"V",
+	lr + fr,
+	"A",
+	fr,
+	fr,
+	0,
+	0,
+	1,
+	te + fr,
+	lr,
+	"Z"
+].join(" "), "createRoundedRectPathD"), rect = /* @__PURE__ */ __name(async (lr, dr) => {
+	log.info("Creating subgraph rect for ", dr.id, dr);
+	let fr = getConfig2(), { themeVariables: pr, handDrawnSeed: mr } = fr, { clusterBkg: hr, clusterBorder: _r } = pr, { labelStyles: yr, nodeStyles: br, borderStyles: xr, backgroundStyles: Sr } = styles2String(dr), Cr = lr.insert("g").attr("class", "cluster " + dr.cssClasses).attr("id", dr.id).attr("data-look", dr.look), wr = evaluate(fr.flowchart.htmlLabels), Er = Cr.insert("g").attr("class", "cluster-label "), Ar = await createText(Er, dr.label, {
+		style: dr.labelStyle,
+		useHtmlLabels: wr,
+		isNode: !0
+	}), jr = Ar.getBBox();
+	if (evaluate(fr.flowchart.htmlLabels)) {
+		let te = Ar.children[0], lr = select_default(Ar);
+		jr = te.getBoundingClientRect(), lr.attr("width", jr.width), lr.attr("height", jr.height);
+	}
+	let Mr = dr.width <= jr.width + dr.padding ? jr.width + dr.padding : dr.width;
+	dr.width <= jr.width + dr.padding ? dr.diff = (Mr - dr.width) / 2 - dr.padding : dr.diff = -dr.padding;
+	let Nr = dr.height, Pr = dr.x - Mr / 2, Fr = dr.y - Nr / 2;
+	log.trace("Data ", dr, JSON.stringify(dr));
+	let Ir;
+	if (dr.look === "handDrawn") {
+		let lr = at.svg(Cr), ur = userNodeOverrides(dr, {
+			roughness: .7,
+			fill: hr,
+			stroke: _r,
+			fillWeight: 3,
+			seed: mr
+		}), fr = lr.path(createRoundedRectPathD(Pr, Fr, Mr, Nr, 0), ur);
+		Ir = Cr.insert(() => (log.debug("Rough node insert CXC", fr), fr), ":first-child"), Ir.select("path:nth-child(2)").attr("style", xr.join(";")), Ir.select("path").attr("style", Sr.join(";").replace("fill", "stroke"));
+	} else Ir = Cr.insert("rect", ":first-child"), Ir.attr("style", br).attr("rx", dr.rx).attr("ry", dr.ry).attr("x", Pr).attr("y", Fr).attr("width", Mr).attr("height", Nr);
+	let { subGraphTitleTopMargin: Lr } = getSubGraphTitleMargins(fr);
+	if (Er.attr("transform", `translate(${dr.x - jr.width / 2}, ${dr.y - dr.height / 2 + Lr})`), yr) {
+		let te = Er.select("span");
+		te && te.attr("style", yr);
+	}
+	let Rr = Ir.node().getBBox();
+	return dr.offsetX = 0, dr.width = Rr.width, dr.height = Rr.height, dr.offsetY = jr.height - dr.padding / 2, dr.intersect = function(te) {
+		return intersect_rect_default(dr, te);
+	}, {
+		cluster: Cr,
+		labelBBox: jr
+	};
+}, "rect"), shapes = {
+	rect,
+	squareRect: rect,
+	roundedWithTitle: /* @__PURE__ */ __name(async (te, lr) => {
+		let dr = getConfig2(), { themeVariables: fr, handDrawnSeed: pr } = dr, { altBackground: mr, compositeBackground: hr, compositeTitleBackground: _r, nodeBorder: yr } = fr, br = te.insert("g").attr("class", lr.cssClasses).attr("id", lr.id).attr("data-id", lr.id).attr("data-look", lr.look), xr = br.insert("g", ":first-child"), Sr = br.insert("g").attr("class", "cluster-label"), Cr = br.append("rect"), wr = Sr.node().appendChild(await createLabel_default(lr.label, lr.labelStyle, void 0, !0)), Tr = wr.getBBox();
+		if (evaluate(dr.flowchart.htmlLabels)) {
+			let te = wr.children[0], lr = select_default(wr);
+			Tr = te.getBoundingClientRect(), lr.attr("width", Tr.width), lr.attr("height", Tr.height);
+		}
+		let Er = 0 * lr.padding, Dr = Er / 2, Or = (lr.width <= Tr.width + lr.padding ? Tr.width + lr.padding : lr.width) + Er;
+		lr.width <= Tr.width + lr.padding ? lr.diff = (Or - lr.width) / 2 - lr.padding : lr.diff = -lr.padding;
+		let kr = lr.height + Er, Ar = lr.height + Er - Tr.height - 6, jr = lr.x - Or / 2, Mr = lr.y - kr / 2;
+		lr.width = Or;
+		let Nr = lr.y - lr.height / 2 - Dr + Tr.height + 2, Pr;
+		if (lr.look === "handDrawn") {
+			let te = lr.cssClasses.includes("statediagram-cluster-alt"), ur = at.svg(br), dr = lr.rx || lr.ry ? ur.path(createRoundedRectPathD(jr, Mr, Or, kr, 10), {
+				roughness: .7,
+				fill: _r,
+				fillStyle: "solid",
+				stroke: yr,
+				seed: pr
+			}) : ur.rectangle(jr, Mr, Or, kr, { seed: pr });
+			Pr = br.insert(() => dr, ":first-child");
+			let fr = ur.rectangle(jr, Nr, Or, Ar, {
+				fill: te ? mr : hr,
+				fillStyle: te ? "hachure" : "solid",
+				stroke: yr,
+				seed: pr
+			});
+			Pr = br.insert(() => dr, ":first-child"), Cr = br.insert(() => fr);
+		} else Pr = xr.insert("rect", ":first-child"), Pr.attr("class", "outer").attr("x", jr).attr("y", Mr).attr("width", Or).attr("height", kr).attr("data-look", lr.look), Cr.attr("class", "inner").attr("x", jr).attr("y", Nr).attr("width", Or).attr("height", Ar);
+		return Sr.attr("transform", `translate(${lr.x - Tr.width / 2}, ${Mr + 1 - (evaluate(dr.flowchart.htmlLabels) ? 0 : 3)})`), lr.height = Pr.node().getBBox().height, lr.offsetX = 0, lr.offsetY = Tr.height - lr.padding / 2, lr.labelBBox = Tr, lr.intersect = function(te) {
+			return intersect_rect_default(lr, te);
+		}, {
+			cluster: br,
+			labelBBox: Tr
+		};
+	}, "roundedWithTitle"),
+	noteGroup: /* @__PURE__ */ __name((te, lr) => {
+		let ur = te.insert("g").attr("class", "note-cluster").attr("id", lr.id), dr = ur.insert("rect", ":first-child"), fr = 0 * lr.padding, pr = fr / 2;
+		dr.attr("rx", lr.rx).attr("ry", lr.ry).attr("x", lr.x - lr.width / 2 - pr).attr("y", lr.y - lr.height / 2 - pr).attr("width", lr.width + fr).attr("height", lr.height + fr).attr("fill", "none");
+		let mr = dr.node().getBBox();
+		return lr.width = mr.width, lr.height = mr.height, lr.intersect = function(te) {
+			return intersect_rect_default(lr, te);
+		}, {
+			cluster: ur,
+			labelBBox: {
+				width: 0,
+				height: 0
+			}
+		};
+	}, "noteGroup"),
+	divider: /* @__PURE__ */ __name((te, lr) => {
+		let { themeVariables: ur, handDrawnSeed: dr } = getConfig2(), { nodeBorder: fr } = ur, pr = te.insert("g").attr("class", lr.cssClasses).attr("id", lr.id).attr("data-look", lr.look), mr = pr.insert("g", ":first-child"), hr = 0 * lr.padding, _r = lr.width + hr;
+		lr.diff = -lr.padding;
+		let vr = lr.height + hr, yr = lr.x - _r / 2, br = lr.y - vr / 2;
+		lr.width = _r;
+		let xr;
+		if (lr.look === "handDrawn") {
+			let te = at.svg(pr).rectangle(yr, br, _r, vr, {
+				fill: "lightgrey",
+				roughness: .5,
+				strokeLineDash: [5],
+				stroke: fr,
+				seed: dr
+			});
+			xr = pr.insert(() => te, ":first-child");
+		} else xr = mr.insert("rect", ":first-child"), xr.attr("class", "divider").attr("x", yr).attr("y", br).attr("width", _r).attr("height", vr).attr("data-look", lr.look);
+		return lr.height = xr.node().getBBox().height, lr.offsetX = 0, lr.offsetY = 0, lr.intersect = function(te) {
+			return intersect_rect_default(lr, te);
+		}, {
+			cluster: pr,
+			labelBBox: {}
+		};
+	}, "divider"),
+	kanbanSection: /* @__PURE__ */ __name(async (lr, dr) => {
+		log.info("Creating subgraph rect for ", dr.id, dr);
+		let fr = getConfig2(), { themeVariables: pr, handDrawnSeed: mr } = fr, { clusterBkg: hr, clusterBorder: _r } = pr, { labelStyles: yr, nodeStyles: br, borderStyles: xr, backgroundStyles: Sr } = styles2String(dr), Cr = lr.insert("g").attr("class", "cluster " + dr.cssClasses).attr("id", dr.id).attr("data-look", dr.look), wr = evaluate(fr.flowchart.htmlLabels), Er = Cr.insert("g").attr("class", "cluster-label "), Ar = await createText(Er, dr.label, {
+			style: dr.labelStyle,
+			useHtmlLabels: wr,
+			isNode: !0,
+			width: dr.width
+		}), jr = Ar.getBBox();
+		if (evaluate(fr.flowchart.htmlLabels)) {
+			let te = Ar.children[0], lr = select_default(Ar);
+			jr = te.getBoundingClientRect(), lr.attr("width", jr.width), lr.attr("height", jr.height);
+		}
+		let Mr = dr.width <= jr.width + dr.padding ? jr.width + dr.padding : dr.width;
+		dr.width <= jr.width + dr.padding ? dr.diff = (Mr - dr.width) / 2 - dr.padding : dr.diff = -dr.padding;
+		let Nr = dr.height, Pr = dr.x - Mr / 2, Fr = dr.y - Nr / 2;
+		log.trace("Data ", dr, JSON.stringify(dr));
+		let Ir;
+		if (dr.look === "handDrawn") {
+			let lr = at.svg(Cr), ur = userNodeOverrides(dr, {
+				roughness: .7,
+				fill: hr,
+				stroke: _r,
+				fillWeight: 4,
+				seed: mr
+			}), fr = lr.path(createRoundedRectPathD(Pr, Fr, Mr, Nr, dr.rx), ur);
+			Ir = Cr.insert(() => (log.debug("Rough node insert CXC", fr), fr), ":first-child"), Ir.select("path:nth-child(2)").attr("style", xr.join(";")), Ir.select("path").attr("style", Sr.join(";").replace("fill", "stroke"));
+		} else Ir = Cr.insert("rect", ":first-child"), Ir.attr("style", br).attr("rx", dr.rx).attr("ry", dr.ry).attr("x", Pr).attr("y", Fr).attr("width", Mr).attr("height", Nr);
+		let { subGraphTitleTopMargin: Lr } = getSubGraphTitleMargins(fr);
+		if (Er.attr("transform", `translate(${dr.x - jr.width / 2}, ${dr.y - dr.height / 2 + Lr})`), yr) {
+			let te = Er.select("span");
+			te && te.attr("style", yr);
+		}
+		let Rr = Ir.node().getBBox();
+		return dr.offsetX = 0, dr.width = Rr.width, dr.height = Rr.height, dr.offsetY = jr.height - dr.padding / 2, dr.intersect = function(te) {
+			return intersect_rect_default(dr, te);
+		}, {
+			cluster: Cr,
+			labelBBox: jr
+		};
+	}, "kanbanSection")
+}, clusterElems = /* @__PURE__ */ new Map(), insertCluster = /* @__PURE__ */ __name(async (te, lr) => {
+	let ur = await shapes[lr.shape || "rect"](te, lr);
+	return clusterElems.set(lr.id, ur), ur;
+}, "insertCluster"), clear = /* @__PURE__ */ __name(() => {
+	clusterElems = /* @__PURE__ */ new Map();
+}, "clear");
+function intersectNode(te, lr) {
+	return te.intersect(lr);
+}
+__name(intersectNode, "intersectNode");
+var intersect_node_default = intersectNode;
+function intersectEllipse(te, lr, ur, dr) {
+	var fr = te.x, pr = te.y, mr = fr - dr.x, hr = pr - dr.y, gr = Math.sqrt(lr * lr * hr * hr + ur * ur * mr * mr), _r = Math.abs(lr * ur * mr / gr);
+	dr.x < fr && (_r = -_r);
+	var vr = Math.abs(lr * ur * hr / gr);
+	return dr.y < pr && (vr = -vr), {
+		x: fr + _r,
+		y: pr + vr
+	};
+}
+__name(intersectEllipse, "intersectEllipse");
+var intersect_ellipse_default = intersectEllipse;
+function intersectCircle(te, lr, ur) {
+	return intersect_ellipse_default(te, lr, lr, ur);
+}
+__name(intersectCircle, "intersectCircle");
+var intersect_circle_default = intersectCircle;
+function intersectLine(te, lr, ur, dr) {
+	{
+		let fr = lr.y - te.y, pr = te.x - lr.x, mr = lr.x * te.y - te.x * lr.y, hr = fr * ur.x + pr * ur.y + mr, gr = fr * dr.x + pr * dr.y + mr, _r = 1e-6;
+		if (hr !== 0 && gr !== 0 && sameSign(hr, gr)) return;
+		let vr = dr.y - ur.y, yr = ur.x - dr.x, br = dr.x * ur.y - ur.x * dr.y, xr = vr * te.x + yr * te.y + br, Sr = vr * lr.x + yr * lr.y + br;
+		if (Math.abs(xr) < _r && Math.abs(Sr) < _r && sameSign(xr, Sr)) return;
+		let Cr = fr * yr - vr * pr;
+		if (Cr === 0) return;
+		let wr = Math.abs(Cr / 2), Tr = pr * br - yr * mr, Er = Tr < 0 ? (Tr - wr) / Cr : (Tr + wr) / Cr;
+		return Tr = vr * mr - fr * br, {
+			x: Er,
+			y: Tr < 0 ? (Tr - wr) / Cr : (Tr + wr) / Cr
+		};
+	}
+}
+__name(intersectLine, "intersectLine");
+function sameSign(te, lr) {
+	return te * lr > 0;
+}
+__name(sameSign, "sameSign");
+var intersect_line_default = intersectLine;
+function intersectPolygon(te, lr, ur) {
+	let dr = te.x, fr = te.y, pr = [], mr = Infinity, hr = Infinity;
+	typeof lr.forEach == "function" ? lr.forEach(function(te) {
+		mr = Math.min(mr, te.x), hr = Math.min(hr, te.y);
+	}) : (mr = Math.min(mr, lr.x), hr = Math.min(hr, lr.y));
+	let gr = dr - te.width / 2 - mr, _r = fr - te.height / 2 - hr;
+	for (let dr = 0; dr < lr.length; dr++) {
+		let fr = lr[dr], mr = lr[dr < lr.length - 1 ? dr + 1 : 0], hr = intersect_line_default(te, ur, {
+			x: gr + fr.x,
+			y: _r + fr.y
+		}, {
+			x: gr + mr.x,
+			y: _r + mr.y
+		});
+		hr && pr.push(hr);
+	}
+	return pr.length ? (pr.length > 1 && pr.sort(function(te, lr) {
+		let dr = te.x - ur.x, fr = te.y - ur.y, pr = Math.sqrt(dr * dr + fr * fr), mr = lr.x - ur.x, hr = lr.y - ur.y, gr = Math.sqrt(mr * mr + hr * hr);
+		return pr < gr ? -1 : pr === gr ? 0 : 1;
+	}), pr[0]) : te;
+}
+__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(lr, ur) {
+	let { labelStyles: dr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let fr = getNodeClasses(ur), pr = fr;
+	fr || (pr = "anchor");
+	let mr = lr.insert("g").attr("class", pr).attr("id", ur.domId || ur.id), { cssStyles: hr } = ur, gr = at.svg(mr), _r = userNodeOverrides(ur, {
+		fill: "black",
+		stroke: "none",
+		fillStyle: "solid"
+	});
+	ur.look !== "handDrawn" && (_r.roughness = 0);
+	let vr = gr.circle(0, 0, 2, _r), yr = mr.insert(() => vr, ":first-child");
+	return yr.attr("class", "anchor").attr("style", handleUndefinedAttr(hr)), updateNodeBounds(ur, yr), ur.intersect = function(lr) {
+		return log.info("Circle intersect", ur, 1, lr), intersect_default.circle(ur, 1, lr);
+	}, mr;
+}
+__name(anchor, "anchor");
+function generateArcPoints(te, lr, ur, dr, fr, pr, mr) {
+	let hr = (te + ur) / 2, gr = (lr + dr) / 2, _r = Math.atan2(dr - lr, ur - te), vr = (ur - te) / 2, yr = (dr - lr) / 2, br = vr / fr, xr = yr / pr, Sr = Math.sqrt(br ** 2 + xr ** 2);
+	if (Sr > 1) throw Error("The given radii are too small to create an arc between the points.");
+	let Cr = Math.sqrt(1 - Sr ** 2), wr = hr + Cr * pr * Math.sin(_r) * (mr ? -1 : 1), Tr = gr - Cr * fr * Math.cos(_r) * (mr ? -1 : 1), Er = Math.atan2((lr - Tr) / pr, (te - wr) / fr), Dr = Math.atan2((dr - Tr) / pr, (ur - wr) / fr) - Er;
+	mr && Dr < 0 && (Dr += 2 * Math.PI), !mr && Dr > 0 && (Dr -= 2 * Math.PI);
+	let Or = [];
+	for (let te = 0; te < 20; te++) {
+		let lr = Er + te / 19 * Dr, ur = wr + fr * Math.cos(lr), dr = Tr + pr * Math.sin(lr);
+		Or.push({
+			x: ur,
+			y: dr
+		});
+	}
+	return Or;
+}
+__name(generateArcPoints, "generateArcPoints");
+async function bowTieRect(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = pr.width + lr.padding + 20, hr = pr.height + lr.padding, gr = hr / 2, _r = gr / (2.5 + hr / 50), { cssStyles: vr } = lr, yr = [
+		{
+			x: mr / 2,
+			y: -hr / 2
+		},
+		{
+			x: -mr / 2,
+			y: -hr / 2
+		},
+		...generateArcPoints(-mr / 2, -hr / 2, -mr / 2, hr / 2, _r, gr, !1),
+		{
+			x: mr / 2,
+			y: hr / 2
+		},
+		...generateArcPoints(mr / 2, hr / 2, mr / 2, -hr / 2, _r, gr, !0)
+	], br = at.svg(fr), xr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (xr.roughness = 0, xr.fillStyle = "solid");
+	let Sr = createPathFromPoints(yr), Cr = br.path(Sr, xr), wr = fr.insert(() => Cr, ":first-child");
+	return wr.attr("class", "basic label-container"), vr && lr.look !== "handDrawn" && wr.selectAll("path").attr("style", vr), dr && lr.look !== "handDrawn" && wr.selectAll("path").attr("style", dr), wr.attr("transform", `translate(${_r / 2}, 0)`), updateNodeBounds(lr, wr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, yr, te);
+	}, fr;
+}
+__name(bowTieRect, "bowTieRect");
+function insertPolygonShape(te, lr, ur, dr) {
+	return te.insert("polygon", ":first-child").attr("points", dr.map(function(te) {
+		return te.x + "," + te.y;
+	}).join(" ")).attr("class", "label-container").attr("transform", "translate(" + -lr / 2 + "," + ur / 2 + ")");
+}
+__name(insertPolygonShape, "insertPolygonShape");
+async function card(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = pr.height + lr.padding, hr = pr.width + lr.padding + 12, gr = hr, _r = -mr, vr = [
+		{
+			x: 12,
+			y: _r
+		},
+		{
+			x: gr,
+			y: _r
+		},
+		{
+			x: gr,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: 0,
+			y: _r + 12
+		},
+		{
+			x: 12,
+			y: _r
+		}
+	], yr, { cssStyles: br } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = createPathFromPoints(vr), pr = te.path(dr, ur);
+		yr = fr.insert(() => pr, ":first-child").attr("transform", `translate(${-hr / 2}, ${mr / 2})`), br && yr.attr("style", br);
+	} else yr = insertPolygonShape(fr, hr, mr, vr);
+	return dr && yr.attr("style", dr), updateNodeBounds(lr, yr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, vr, te);
+	}, fr;
+}
+__name(card, "card");
+function choice(te, lr) {
+	let { nodeStyles: ur } = styles2String(lr);
+	lr.label = "";
+	let dr = te.insert("g").attr("class", getNodeClasses(lr)).attr("id", lr.domId ?? lr.id), { cssStyles: fr } = lr, pr = Math.max(28, lr.width ?? 0), mr = [
+		{
+			x: 0,
+			y: pr / 2
+		},
+		{
+			x: pr / 2,
+			y: 0
+		},
+		{
+			x: 0,
+			y: -pr / 2
+		},
+		{
+			x: -pr / 2,
+			y: 0
+		}
+	], hr = at.svg(dr), gr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (gr.roughness = 0, gr.fillStyle = "solid");
+	let _r = createPathFromPoints(mr), vr = hr.path(_r, gr), yr = dr.insert(() => vr, ":first-child");
+	return fr && lr.look !== "handDrawn" && yr.selectAll("path").attr("style", fr), ur && lr.look !== "handDrawn" && yr.selectAll("path").attr("style", ur), lr.width = 28, lr.height = 28, lr.intersect = function(te) {
+		return intersect_default.polygon(lr, mr, te);
+	}, dr;
+}
+__name(choice, "choice");
+async function circle(lr, ur, dr) {
+	let { labelStyles: fr, nodeStyles: pr } = styles2String(ur);
+	ur.labelStyle = fr;
+	let { shapeSvg: mr, bbox: hr, halfPadding: gr } = await labelHelper(lr, ur, getNodeClasses(ur)), _r = dr?.padding ?? gr, vr = hr.width / 2 + _r, yr, { cssStyles: br } = ur;
+	if (ur.look === "handDrawn") {
+		let te = at.svg(mr), lr = userNodeOverrides(ur, {}), dr = te.circle(0, 0, vr * 2, lr);
+		yr = mr.insert(() => dr, ":first-child"), yr.attr("class", "basic label-container").attr("style", handleUndefinedAttr(br));
+	} else yr = mr.insert("circle", ":first-child").attr("class", "basic label-container").attr("style", pr).attr("r", vr).attr("cx", 0).attr("cy", 0);
+	return updateNodeBounds(ur, yr), ur.calcIntersect = function(te, lr) {
+		let ur = te.width / 2;
+		return intersect_default.circle(te, ur, lr);
+	}, ur.intersect = function(lr) {
+		return log.info("Circle intersect", ur, vr, lr), intersect_default.circle(ur, vr, lr);
+	}, mr;
+}
+__name(circle, "circle");
+function createLine(te) {
+	let lr = Math.cos(Math.PI / 4), ur = Math.sin(Math.PI / 4), dr = te * 2, fr = {
+		x: dr / 2 * lr,
+		y: dr / 2 * ur
+	}, pr = {
+		x: -(dr / 2) * lr,
+		y: dr / 2 * ur
+	}, mr = {
+		x: -(dr / 2) * lr,
+		y: -(dr / 2) * ur
+	}, hr = {
+		x: dr / 2 * lr,
+		y: -(dr / 2) * ur
+	};
+	return `M ${pr.x},${pr.y} L ${hr.x},${hr.y}
+                   M ${fr.x},${fr.y} L ${mr.x},${mr.y}`;
+}
+__name(createLine, "createLine");
+function crossedCircle(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr, ur.label = "";
+	let pr = lr.insert("g").attr("class", getNodeClasses(ur)).attr("id", ur.domId ?? ur.id), mr = Math.max(30, ur?.width ?? 0), { cssStyles: hr } = ur, gr = at.svg(pr), _r = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (_r.roughness = 0, _r.fillStyle = "solid");
+	let vr = gr.circle(0, 0, mr * 2, _r), yr = createLine(mr), br = gr.path(yr, _r), xr = pr.insert(() => vr, ":first-child");
+	return xr.insert(() => br), hr && ur.look !== "handDrawn" && xr.selectAll("path").attr("style", hr), fr && ur.look !== "handDrawn" && xr.selectAll("path").attr("style", fr), updateNodeBounds(ur, xr), ur.intersect = function(lr) {
+		return log.info("crossedCircle intersect", ur, {
+			radius: mr,
+			point: lr
+		}), intersect_default.circle(ur, mr, lr);
+	}, pr;
+}
+__name(crossedCircle, "crossedCircle");
+function generateCirclePoints2(te, lr, ur, dr = 100, fr = 0, pr = 180) {
+	let mr = [], hr = fr * Math.PI / 180, gr = (pr * Math.PI / 180 - hr) / (dr - 1);
+	for (let fr = 0; fr < dr; fr++) {
+		let dr = hr + fr * gr, pr = te + ur * Math.cos(dr), _r = lr + ur * Math.sin(dr);
+		mr.push({
+			x: -pr,
+			y: -_r
+		});
+	}
+	return mr;
+}
+__name(generateCirclePoints2, "generateCirclePoints");
+async function curlyBraceLeft(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = pr.width + (lr.padding ?? 0), gr = pr.height + (lr.padding ?? 0), _r = Math.max(5, gr * .1), { cssStyles: vr } = lr, yr = [
+		...generateCirclePoints2(hr / 2, -gr / 2, _r, 30, -90, 0),
+		{
+			x: -hr / 2 - _r,
+			y: _r
+		},
+		...generateCirclePoints2(hr / 2 + _r * 2, -_r, _r, 20, -180, -270),
+		...generateCirclePoints2(hr / 2 + _r * 2, _r, _r, 20, -90, -180),
+		{
+			x: -hr / 2 - _r,
+			y: -gr / 2
+		},
+		...generateCirclePoints2(hr / 2, gr / 2, _r, 20, 0, 90)
+	], br = [
+		{
+			x: hr / 2,
+			y: -gr / 2 - _r
+		},
+		{
+			x: -hr / 2,
+			y: -gr / 2 - _r
+		},
+		...generateCirclePoints2(hr / 2, -gr / 2, _r, 20, -90, 0),
+		{
+			x: -hr / 2 - _r,
+			y: -_r
+		},
+		...generateCirclePoints2(hr / 2 + hr * .1, -_r, _r, 20, -180, -270),
+		...generateCirclePoints2(hr / 2 + hr * .1, _r, _r, 20, -90, -180),
+		{
+			x: -hr / 2 - _r,
+			y: gr / 2
+		},
+		...generateCirclePoints2(hr / 2, gr / 2, _r, 20, 0, 90),
+		{
+			x: -hr / 2,
+			y: gr / 2 + _r
+		},
+		{
+			x: hr / 2,
+			y: gr / 2 + _r
+		}
+	], xr = at.svg(fr), Sr = userNodeOverrides(lr, { fill: "none" });
+	lr.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Cr = createPathFromPoints(yr).replace("Z", ""), wr = xr.path(Cr, Sr), Tr = createPathFromPoints(br), Er = xr.path(Tr, { ...Sr }), Dr = fr.insert("g", ":first-child");
+	return Dr.insert(() => Er, ":first-child").attr("stroke-opacity", 0), Dr.insert(() => wr, ":first-child"), Dr.attr("class", "text"), vr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", vr), dr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", dr), Dr.attr("transform", `translate(${_r}, 0)`), mr.attr("transform", `translate(${-hr / 2 + _r - (pr.x - (pr.left ?? 0))},${-gr / 2 + (lr.padding ?? 0) / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Dr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, br, te);
+	}, fr;
+}
+__name(curlyBraceLeft, "curlyBraceLeft");
+function generateCirclePoints3(te, lr, ur, dr = 100, fr = 0, pr = 180) {
+	let mr = [], hr = fr * Math.PI / 180, gr = (pr * Math.PI / 180 - hr) / (dr - 1);
+	for (let fr = 0; fr < dr; fr++) {
+		let dr = hr + fr * gr, pr = te + ur * Math.cos(dr), _r = lr + ur * Math.sin(dr);
+		mr.push({
+			x: pr,
+			y: _r
+		});
+	}
+	return mr;
+}
+__name(generateCirclePoints3, "generateCirclePoints");
+async function curlyBraceRight(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = pr.width + (lr.padding ?? 0), gr = pr.height + (lr.padding ?? 0), _r = Math.max(5, gr * .1), { cssStyles: vr } = lr, yr = [
+		...generateCirclePoints3(hr / 2, -gr / 2, _r, 20, -90, 0),
+		{
+			x: hr / 2 + _r,
+			y: -_r
+		},
+		...generateCirclePoints3(hr / 2 + _r * 2, -_r, _r, 20, -180, -270),
+		...generateCirclePoints3(hr / 2 + _r * 2, _r, _r, 20, -90, -180),
+		{
+			x: hr / 2 + _r,
+			y: gr / 2
+		},
+		...generateCirclePoints3(hr / 2, gr / 2, _r, 20, 0, 90)
+	], br = [
+		{
+			x: -hr / 2,
+			y: -gr / 2 - _r
+		},
+		{
+			x: hr / 2,
+			y: -gr / 2 - _r
+		},
+		...generateCirclePoints3(hr / 2, -gr / 2, _r, 20, -90, 0),
+		{
+			x: hr / 2 + _r,
+			y: -_r
+		},
+		...generateCirclePoints3(hr / 2 + _r * 2, -_r, _r, 20, -180, -270),
+		...generateCirclePoints3(hr / 2 + _r * 2, _r, _r, 20, -90, -180),
+		{
+			x: hr / 2 + _r,
+			y: gr / 2
+		},
+		...generateCirclePoints3(hr / 2, gr / 2, _r, 20, 0, 90),
+		{
+			x: hr / 2,
+			y: gr / 2 + _r
+		},
+		{
+			x: -hr / 2,
+			y: gr / 2 + _r
+		}
+	], xr = at.svg(fr), Sr = userNodeOverrides(lr, { fill: "none" });
+	lr.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Cr = createPathFromPoints(yr).replace("Z", ""), wr = xr.path(Cr, Sr), Tr = createPathFromPoints(br), Er = xr.path(Tr, { ...Sr }), Dr = fr.insert("g", ":first-child");
+	return Dr.insert(() => Er, ":first-child").attr("stroke-opacity", 0), Dr.insert(() => wr, ":first-child"), Dr.attr("class", "text"), vr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", vr), dr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", dr), Dr.attr("transform", `translate(${-_r}, 0)`), mr.attr("transform", `translate(${-hr / 2 + (lr.padding ?? 0) / 2 - (pr.x - (pr.left ?? 0))},${-gr / 2 + (lr.padding ?? 0) / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Dr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, br, te);
+	}, fr;
+}
+__name(curlyBraceRight, "curlyBraceRight");
+function generateCirclePoints4(te, lr, ur, dr = 100, fr = 0, pr = 180) {
+	let mr = [], hr = fr * Math.PI / 180, gr = (pr * Math.PI / 180 - hr) / (dr - 1);
+	for (let fr = 0; fr < dr; fr++) {
+		let dr = hr + fr * gr, pr = te + ur * Math.cos(dr), _r = lr + ur * Math.sin(dr);
+		mr.push({
+			x: -pr,
+			y: -_r
+		});
+	}
+	return mr;
+}
+__name(generateCirclePoints4, "generateCirclePoints");
+async function curlyBraces(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = pr.width + (lr.padding ?? 0), gr = pr.height + (lr.padding ?? 0), _r = Math.max(5, gr * .1), { cssStyles: vr } = lr, yr = [
+		...generateCirclePoints4(hr / 2, -gr / 2, _r, 30, -90, 0),
+		{
+			x: -hr / 2 - _r,
+			y: _r
+		},
+		...generateCirclePoints4(hr / 2 + _r * 2, -_r, _r, 20, -180, -270),
+		...generateCirclePoints4(hr / 2 + _r * 2, _r, _r, 20, -90, -180),
+		{
+			x: -hr / 2 - _r,
+			y: -gr / 2
+		},
+		...generateCirclePoints4(hr / 2, gr / 2, _r, 20, 0, 90)
+	], br = [
+		...generateCirclePoints4(-hr / 2 + _r + _r / 2, -gr / 2, _r, 20, -90, -180),
+		{
+			x: hr / 2 - _r / 2,
+			y: _r
+		},
+		...generateCirclePoints4(-hr / 2 - _r / 2, -_r, _r, 20, 0, 90),
+		...generateCirclePoints4(-hr / 2 - _r / 2, _r, _r, 20, -90, 0),
+		{
+			x: hr / 2 - _r / 2,
+			y: -_r
+		},
+		...generateCirclePoints4(-hr / 2 + _r + _r / 2, gr / 2, _r, 30, -180, -270)
+	], xr = [
+		{
+			x: hr / 2,
+			y: -gr / 2 - _r
+		},
+		{
+			x: -hr / 2,
+			y: -gr / 2 - _r
+		},
+		...generateCirclePoints4(hr / 2, -gr / 2, _r, 20, -90, 0),
+		{
+			x: -hr / 2 - _r,
+			y: -_r
+		},
+		...generateCirclePoints4(hr / 2 + _r * 2, -_r, _r, 20, -180, -270),
+		...generateCirclePoints4(hr / 2 + _r * 2, _r, _r, 20, -90, -180),
+		{
+			x: -hr / 2 - _r,
+			y: gr / 2
+		},
+		...generateCirclePoints4(hr / 2, gr / 2, _r, 20, 0, 90),
+		{
+			x: -hr / 2,
+			y: gr / 2 + _r
+		},
+		{
+			x: hr / 2 - _r - _r / 2,
+			y: gr / 2 + _r
+		},
+		...generateCirclePoints4(-hr / 2 + _r + _r / 2, -gr / 2, _r, 20, -90, -180),
+		{
+			x: hr / 2 - _r / 2,
+			y: _r
+		},
+		...generateCirclePoints4(-hr / 2 - _r / 2, -_r, _r, 20, 0, 90),
+		...generateCirclePoints4(-hr / 2 - _r / 2, _r, _r, 20, -90, 0),
+		{
+			x: hr / 2 - _r / 2,
+			y: -_r
+		},
+		...generateCirclePoints4(-hr / 2 + _r + _r / 2, gr / 2, _r, 30, -180, -270)
+	], Sr = at.svg(fr), Cr = userNodeOverrides(lr, { fill: "none" });
+	lr.look !== "handDrawn" && (Cr.roughness = 0, Cr.fillStyle = "solid");
+	let wr = createPathFromPoints(yr).replace("Z", ""), Tr = Sr.path(wr, Cr), Er = createPathFromPoints(br).replace("Z", ""), Dr = Sr.path(Er, Cr), Ar = createPathFromPoints(xr), jr = Sr.path(Ar, { ...Cr }), Mr = fr.insert("g", ":first-child");
+	return Mr.insert(() => jr, ":first-child").attr("stroke-opacity", 0), Mr.insert(() => Tr, ":first-child"), Mr.insert(() => Dr, ":first-child"), Mr.attr("class", "text"), vr && lr.look !== "handDrawn" && Mr.selectAll("path").attr("style", vr), dr && lr.look !== "handDrawn" && Mr.selectAll("path").attr("style", dr), Mr.attr("transform", `translate(${_r - _r / 4}, 0)`), mr.attr("transform", `translate(${-hr / 2 + (lr.padding ?? 0) / 2 - (pr.x - (pr.left ?? 0))},${-gr / 2 + (lr.padding ?? 0) / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Mr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, xr, te);
+	}, fr;
+}
+__name(curlyBraces, "curlyBraces");
+async function curvedTrapezoid(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(80, (pr.width + (lr.padding ?? 0) * 2) * 1.25, lr?.width ?? 0), hr = Math.max(20, pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), gr = hr / 2, { cssStyles: _r } = lr, vr = at.svg(fr), yr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (yr.roughness = 0, yr.fillStyle = "solid");
+	let br = mr, xr = hr, Sr = br - gr, Cr = xr / 4, wr = [
+		{
+			x: Sr,
+			y: 0
+		},
+		{
+			x: Cr,
+			y: 0
+		},
+		{
+			x: 0,
+			y: xr / 2
+		},
+		{
+			x: Cr,
+			y: xr
+		},
+		{
+			x: Sr,
+			y: xr
+		},
+		...generateCirclePoints(-Sr, -xr / 2, gr, 50, 270, 90)
+	], Tr = createPathFromPoints(wr), Er = vr.path(Tr, yr), Dr = fr.insert(() => Er, ":first-child");
+	return Dr.attr("class", "basic label-container"), _r && lr.look !== "handDrawn" && Dr.selectChildren("path").attr("style", _r), dr && lr.look !== "handDrawn" && Dr.selectChildren("path").attr("style", dr), Dr.attr("transform", `translate(${-mr / 2}, ${-hr / 2})`), updateNodeBounds(lr, Dr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, wr, te);
+	}, fr;
+}
+__name(curvedTrapezoid, "curvedTrapezoid");
+var createCylinderPathD = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => [
+	`M${te},${lr + pr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`,
+	`a${fr},${pr} 0,0,0 ${-ur},0`,
+	`l0,${dr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`,
+	`l0,${-dr}`
+].join(" "), "createCylinderPathD"), createOuterCylinderPathD = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => [
+	`M${te},${lr + pr}`,
+	`M${te + ur},${lr + pr}`,
+	`a${fr},${pr} 0,0,0 ${-ur},0`,
+	`l0,${dr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`,
+	`l0,${-dr}`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => [`M${te - ur / 2},${-dr / 2}`, `a${fr},${pr} 0,0,0 ${ur},0`].join(" "), "createInnerCylinderPathD");
+async function cylinder(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + lr.padding, lr.width ?? 0), gr = hr / 2, _r = gr / (2.5 + hr / 50), vr = Math.max(pr.height + _r + lr.padding, lr.height ?? 0), yr, { cssStyles: br } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = createOuterCylinderPathD(0, 0, hr, vr, gr, _r), dr = createInnerCylinderPathD(0, _r, hr, vr, gr, _r), pr = te.path(ur, userNodeOverrides(lr, {})), mr = te.path(dr, userNodeOverrides(lr, { fill: "none" }));
+		yr = fr.insert(() => mr, ":first-child"), yr = fr.insert(() => pr, ":first-child"), yr.attr("class", "basic label-container"), br && yr.attr("style", br);
+	} else {
+		let te = createCylinderPathD(0, 0, hr, vr, gr, _r);
+		yr = fr.insert("path", ":first-child").attr("d", te).attr("class", "basic label-container").attr("style", handleUndefinedAttr(br)).attr("style", dr);
+	}
+	return yr.attr("label-offset-y", _r), yr.attr("transform", `translate(${-hr / 2}, ${-(vr / 2 + _r)})`), updateNodeBounds(lr, yr), mr.attr("transform", `translate(${-(pr.width / 2) - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) + (lr.padding ?? 0) / 1.5 - (pr.y - (pr.top ?? 0))})`), lr.intersect = function(te) {
+		let ur = intersect_default.rect(lr, te), dr = ur.x - (lr.x ?? 0);
+		if (gr != 0 && (Math.abs(dr) < (lr.width ?? 0) / 2 || Math.abs(dr) == (lr.width ?? 0) / 2 && Math.abs(ur.y - (lr.y ?? 0)) > (lr.height ?? 0) / 2 - _r)) {
+			let fr = _r * _r * (1 - dr * dr / (gr * gr));
+			fr > 0 && (fr = Math.sqrt(fr)), fr = _r - fr, te.y - (lr.y ?? 0) > 0 && (fr = -fr), ur.y += fr;
+		}
+		return ur;
+	}, fr;
+}
+__name(cylinder, "cylinder");
+async function dividedRectangle(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = pr.width + lr.padding, gr = pr.height + lr.padding, _r = gr * .2, vr = -hr / 2, yr = -gr / 2 - _r / 2, { cssStyles: br } = lr, xr = at.svg(fr), Sr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Cr = [
+		{
+			x: vr,
+			y: yr + _r
+		},
+		{
+			x: -vr,
+			y: yr + _r
+		},
+		{
+			x: -vr,
+			y: -yr
+		},
+		{
+			x: vr,
+			y: -yr
+		},
+		{
+			x: vr,
+			y: yr
+		},
+		{
+			x: -vr,
+			y: yr
+		},
+		{
+			x: -vr,
+			y: yr + _r
+		}
+	], wr = xr.polygon(Cr.map((te) => [te.x, te.y]), Sr), Tr = fr.insert(() => wr, ":first-child");
+	return Tr.attr("class", "basic label-container"), br && lr.look !== "handDrawn" && Tr.selectAll("path").attr("style", br), dr && lr.look !== "handDrawn" && Tr.selectAll("path").attr("style", dr), mr.attr("transform", `translate(${vr + (lr.padding ?? 0) / 2 - (pr.x - (pr.left ?? 0))}, ${yr + _r + (lr.padding ?? 0) / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Tr), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, fr;
+}
+__name(dividedRectangle, "dividedRectangle");
+async function doublecircle(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr, halfPadding: hr } = await labelHelper(lr, ur, getNodeClasses(ur)), gr = mr.width / 2 + hr + 5, _r = mr.width / 2 + hr, vr, { cssStyles: yr } = ur;
+	if (ur.look === "handDrawn") {
+		let te = at.svg(pr), lr = userNodeOverrides(ur, {
+			roughness: .2,
+			strokeWidth: 2.5
+		}), dr = userNodeOverrides(ur, {
+			roughness: .2,
+			strokeWidth: 1.5
+		}), fr = te.circle(0, 0, gr * 2, lr), mr = te.circle(0, 0, _r * 2, dr);
+		vr = pr.insert("g", ":first-child"), vr.attr("class", handleUndefinedAttr(ur.cssClasses)).attr("style", handleUndefinedAttr(yr)), vr.node()?.appendChild(fr), vr.node()?.appendChild(mr);
+	} else {
+		vr = pr.insert("g", ":first-child");
+		let te = vr.insert("circle", ":first-child"), lr = vr.insert("circle");
+		vr.attr("class", "basic label-container").attr("style", fr), te.attr("class", "outer-circle").attr("style", fr).attr("r", gr).attr("cx", 0).attr("cy", 0), lr.attr("class", "inner-circle").attr("style", fr).attr("r", _r).attr("cx", 0).attr("cy", 0);
+	}
+	return updateNodeBounds(ur, vr), ur.intersect = function(lr) {
+		return log.info("DoubleCircle intersect", ur, gr, lr), intersect_default.circle(ur, gr, lr);
+	}, pr;
+}
+__name(doublecircle, "doublecircle");
+function filledCircle(lr, ur, { config: { themeVariables: dr } }) {
+	let { labelStyles: fr, nodeStyles: pr } = styles2String(ur);
+	ur.label = "", ur.labelStyle = fr;
+	let mr = lr.insert("g").attr("class", getNodeClasses(ur)).attr("id", ur.domId ?? ur.id), { cssStyles: hr } = ur, gr = at.svg(mr), { nodeBorder: _r } = dr, vr = userNodeOverrides(ur, { fillStyle: "solid" });
+	ur.look !== "handDrawn" && (vr.roughness = 0);
+	let yr = gr.circle(0, 0, 14, vr), br = mr.insert(() => yr, ":first-child");
+	return br.selectAll("path").attr("style", `fill: ${_r} !important;`), hr && hr.length > 0 && ur.look !== "handDrawn" && br.selectAll("path").attr("style", hr), pr && ur.look !== "handDrawn" && br.selectAll("path").attr("style", pr), updateNodeBounds(ur, br), ur.intersect = function(lr) {
+		return log.info("filledCircle intersect", ur, {
+			radius: 7,
+			point: lr
+		}), intersect_default.circle(ur, 7, lr);
+	}, mr;
+}
+__name(filledCircle, "filledCircle");
+async function flippedTriangle(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr, label: hr } = await labelHelper(lr, ur, getNodeClasses(ur)), gr = mr.width + (ur.padding ?? 0), _r = gr + mr.height, vr = gr + mr.height, yr = [
+		{
+			x: 0,
+			y: -_r
+		},
+		{
+			x: vr,
+			y: -_r
+		},
+		{
+			x: vr / 2,
+			y: 0
+		}
+	], { cssStyles: br } = ur, xr = at.svg(pr), Sr = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Cr = createPathFromPoints(yr), wr = xr.path(Cr, Sr), Tr = pr.insert(() => wr, ":first-child").attr("transform", `translate(${-_r / 2}, ${_r / 2})`);
+	return br && ur.look !== "handDrawn" && Tr.selectChildren("path").attr("style", br), fr && ur.look !== "handDrawn" && Tr.selectChildren("path").attr("style", fr), ur.width = gr, ur.height = _r, updateNodeBounds(ur, Tr), hr.attr("transform", `translate(${-mr.width / 2 - (mr.x - (mr.left ?? 0))}, ${-_r / 2 + (ur.padding ?? 0) / 2 + (mr.y - (mr.top ?? 0))})`), ur.intersect = function(lr) {
+		return log.info("Triangle intersect", ur, yr, lr), intersect_default.polygon(ur, yr, lr);
+	}, pr;
+}
+__name(flippedTriangle, "flippedTriangle");
+function forkJoin(te, lr, { dir: ur, config: { state: dr, themeVariables: fr } }) {
+	let { nodeStyles: pr } = styles2String(lr);
+	lr.label = "";
+	let mr = te.insert("g").attr("class", getNodeClasses(lr)).attr("id", lr.domId ?? lr.id), { cssStyles: hr } = lr, gr = Math.max(70, lr?.width ?? 0), _r = Math.max(10, lr?.height ?? 0);
+	ur === "LR" && (gr = Math.max(10, lr?.width ?? 0), _r = Math.max(70, lr?.height ?? 0));
+	let vr = -1 * gr / 2, yr = -1 * _r / 2, br = at.svg(mr), xr = userNodeOverrides(lr, {
+		stroke: fr.lineColor,
+		fill: fr.lineColor
+	});
+	lr.look !== "handDrawn" && (xr.roughness = 0, xr.fillStyle = "solid");
+	let Sr = br.rectangle(vr, yr, gr, _r, xr), Cr = mr.insert(() => Sr, ":first-child");
+	hr && lr.look !== "handDrawn" && Cr.selectAll("path").attr("style", hr), pr && lr.look !== "handDrawn" && Cr.selectAll("path").attr("style", pr), updateNodeBounds(lr, Cr);
+	let wr = dr?.padding ?? 0;
+	return lr.width && lr.height && (lr.width += wr / 2 || 0, lr.height += wr / 2 || 0), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, mr;
+}
+__name(forkJoin, "forkJoin");
+async function halfRoundedRectangle(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr } = await labelHelper(lr, ur, getNodeClasses(ur)), hr = Math.max(80, mr.width + (ur.padding ?? 0) * 2, ur?.width ?? 0), gr = Math.max(50, mr.height + (ur.padding ?? 0) * 2, ur?.height ?? 0), _r = gr / 2, { cssStyles: vr } = ur, yr = at.svg(pr), br = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (br.roughness = 0, br.fillStyle = "solid");
+	let xr = [
+		{
+			x: -hr / 2,
+			y: -gr / 2
+		},
+		{
+			x: hr / 2 - _r,
+			y: -gr / 2
+		},
+		...generateCirclePoints(-hr / 2 + _r, 0, _r, 50, 90, 270),
+		{
+			x: hr / 2 - _r,
+			y: gr / 2
+		},
+		{
+			x: -hr / 2,
+			y: gr / 2
+		}
+	], Sr = createPathFromPoints(xr), Cr = yr.path(Sr, br), wr = pr.insert(() => Cr, ":first-child");
+	return wr.attr("class", "basic label-container"), vr && ur.look !== "handDrawn" && wr.selectChildren("path").attr("style", vr), fr && ur.look !== "handDrawn" && wr.selectChildren("path").attr("style", fr), updateNodeBounds(ur, wr), ur.intersect = function(lr) {
+		return log.info("Pill intersect", ur, {
+			radius: _r,
+			point: lr
+		}), intersect_default.polygon(ur, xr, lr);
+	}, pr;
+}
+__name(halfRoundedRectangle, "halfRoundedRectangle");
+async function hexagon(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = pr.height + (lr.padding ?? 0), hr = pr.width + (lr.padding ?? 0) * 2.5, { cssStyles: gr } = lr, _r = at.svg(fr), vr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (vr.roughness = 0, vr.fillStyle = "solid");
+	let yr = hr / 2, br = yr / 6;
+	yr += br;
+	let xr = mr / 2, Sr = xr / 2, Cr = yr - Sr, wr = [
+		{
+			x: -Cr,
+			y: -xr
+		},
+		{
+			x: 0,
+			y: -xr
+		},
+		{
+			x: Cr,
+			y: -xr
+		},
+		{
+			x: yr,
+			y: 0
+		},
+		{
+			x: Cr,
+			y: xr
+		},
+		{
+			x: 0,
+			y: xr
+		},
+		{
+			x: -Cr,
+			y: xr
+		},
+		{
+			x: -yr,
+			y: 0
+		}
+	], Tr = createPathFromPoints(wr), Er = _r.path(Tr, vr), Dr = fr.insert(() => Er, ":first-child");
+	return Dr.attr("class", "basic label-container"), gr && lr.look !== "handDrawn" && Dr.selectChildren("path").attr("style", gr), dr && lr.look !== "handDrawn" && Dr.selectChildren("path").attr("style", dr), lr.width = hr, lr.height = mr, updateNodeBounds(lr, Dr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, wr, te);
+	}, fr;
+}
+__name(hexagon, "hexagon");
+async function hourglass(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.label = "", ur.labelStyle = dr;
+	let { shapeSvg: pr } = await labelHelper(lr, ur, getNodeClasses(ur)), mr = Math.max(30, ur?.width ?? 0), hr = Math.max(30, ur?.height ?? 0), { cssStyles: gr } = ur, _r = at.svg(pr), vr = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (vr.roughness = 0, vr.fillStyle = "solid");
+	let yr = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: mr,
+			y: 0
+		},
+		{
+			x: 0,
+			y: hr
+		},
+		{
+			x: mr,
+			y: hr
+		}
+	], br = createPathFromPoints(yr), xr = _r.path(br, vr), Sr = pr.insert(() => xr, ":first-child");
+	return Sr.attr("class", "basic label-container"), gr && ur.look !== "handDrawn" && Sr.selectChildren("path").attr("style", gr), fr && ur.look !== "handDrawn" && Sr.selectChildren("path").attr("style", fr), Sr.attr("transform", `translate(${-mr / 2}, ${-hr / 2})`), updateNodeBounds(ur, Sr), ur.intersect = function(lr) {
+		return log.info("Pill intersect", ur, { points: yr }), intersect_default.polygon(ur, yr, lr);
+	}, pr;
+}
+__name(hourglass, "hourglass");
+async function icon(lr, ur, { config: { themeVariables: dr, flowchart: fr } }) {
+	let { labelStyles: pr } = styles2String(ur);
+	ur.labelStyle = pr;
+	let mr = ur.assetHeight ?? 48, hr = ur.assetWidth ?? 48, gr = Math.max(mr, hr), _r = fr?.wrappingWidth;
+	ur.width = Math.max(gr, _r ?? 0);
+	let { shapeSvg: vr, bbox: yr, label: br } = await labelHelper(lr, ur, "icon-shape default"), xr = ur.pos === "t", Sr = gr, Cr = gr, { nodeBorder: wr } = dr, { stylesMap: Tr } = compileStyles(ur), Dr = -Cr / 2, Ar = -Sr / 2, Mr = ur.label ? 8 : 0, Nr = at.svg(vr), Pr = userNodeOverrides(ur, {
+		stroke: "none",
+		fill: "none"
+	});
+	ur.look !== "handDrawn" && (Pr.roughness = 0, Pr.fillStyle = "solid");
+	let Fr = Nr.rectangle(Dr, Ar, Cr, Sr, Pr), Ir = Math.max(Cr, yr.width), Lr = Sr + yr.height + Mr, Rr = Nr.rectangle(-Ir / 2, -Lr / 2, Ir, Lr, {
+		...Pr,
+		fill: "transparent",
+		stroke: "none"
+	}), zr = vr.insert(() => Fr, ":first-child"), Br = vr.insert(() => Rr);
+	if (ur.icon) {
+		let te = vr.append("g");
+		te.html(`<g>${await getIconSVG(ur.icon, {
+			height: gr,
+			width: gr,
+			fallbackPrefix: ""
+		})}</g>`);
+		let lr = te.node().getBBox(), dr = lr.width, fr = lr.height, pr = lr.x, mr = lr.y;
+		te.attr("transform", `translate(${-dr / 2 - pr},${xr ? yr.height / 2 + Mr / 2 - fr / 2 - mr : -yr.height / 2 - Mr / 2 - fr / 2 - mr})`), te.attr("style", `color: ${Tr.get("stroke") ?? wr};`);
+	}
+	return br.attr("transform", `translate(${-yr.width / 2 - (yr.x - (yr.left ?? 0))},${xr ? -Lr / 2 : Lr / 2 - yr.height})`), zr.attr("transform", `translate(0,${xr ? yr.height / 2 + Mr / 2 : -yr.height / 2 - Mr / 2})`), updateNodeBounds(ur, Br), ur.intersect = function(lr) {
+		if (log.info("iconSquare intersect", ur, lr), !ur.label) return intersect_default.rect(ur, lr);
+		let dr = ur.x ?? 0, fr = ur.y ?? 0, pr = ur.height ?? 0, mr = [];
+		return mr = xr ? [
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2 + yr.height + Mr
+			},
+			{
+				x: dr + Cr / 2,
+				y: fr - pr / 2 + yr.height + Mr
+			},
+			{
+				x: dr + Cr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - Cr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - Cr / 2,
+				y: fr - pr / 2 + yr.height + Mr
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2 + yr.height + Mr
+			}
+		] : [
+			{
+				x: dr - Cr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + Cr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + Cr / 2,
+				y: fr - pr / 2 + Sr
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2 + Sr
+			},
+			{
+				x: dr + yr.width / 2 / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2 + Sr
+			},
+			{
+				x: dr - Cr / 2,
+				y: fr - pr / 2 + Sr
+			}
+		], intersect_default.polygon(ur, mr, lr);
+	}, vr;
+}
+__name(icon, "icon");
+async function iconCircle(lr, ur, { config: { themeVariables: dr, flowchart: fr } }) {
+	let { labelStyles: pr } = styles2String(ur);
+	ur.labelStyle = pr;
+	let mr = ur.assetHeight ?? 48, hr = ur.assetWidth ?? 48, gr = Math.max(mr, hr), _r = fr?.wrappingWidth;
+	ur.width = Math.max(gr, _r ?? 0);
+	let { shapeSvg: vr, bbox: yr, label: br } = await labelHelper(lr, ur, "icon-shape default"), xr = ur.label ? 8 : 0, Sr = ur.pos === "t", { nodeBorder: Cr, mainBkg: wr } = dr, { stylesMap: Tr } = compileStyles(ur), Dr = at.svg(vr), Ar = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (Ar.roughness = 0, Ar.fillStyle = "solid"), Ar.stroke = Tr.get("fill") ?? wr;
+	let Mr = vr.append("g");
+	ur.icon && Mr.html(`<g>${await getIconSVG(ur.icon, {
+		height: gr,
+		width: gr,
+		fallbackPrefix: ""
+	})}</g>`);
+	let Nr = Mr.node().getBBox(), Pr = Nr.width, Fr = Nr.height, Ir = Nr.x, Lr = Nr.y, Rr = Math.max(Pr, Fr) * Math.SQRT2 + 40, zr = Dr.circle(0, 0, Rr, Ar), Br = Math.max(Rr, yr.width), Vr = Rr + yr.height + xr, Hr = Dr.rectangle(-Br / 2, -Vr / 2, Br, Vr, {
+		...Ar,
+		fill: "transparent",
+		stroke: "none"
+	}), Ur = vr.insert(() => zr, ":first-child"), Wr = vr.insert(() => Hr);
+	return Mr.attr("transform", `translate(${-Pr / 2 - Ir},${Sr ? yr.height / 2 + xr / 2 - Fr / 2 - Lr : -yr.height / 2 - xr / 2 - Fr / 2 - Lr})`), Mr.attr("style", `color: ${Tr.get("stroke") ?? Cr};`), br.attr("transform", `translate(${-yr.width / 2 - (yr.x - (yr.left ?? 0))},${Sr ? -Vr / 2 : Vr / 2 - yr.height})`), Ur.attr("transform", `translate(0,${Sr ? yr.height / 2 + xr / 2 : -yr.height / 2 - xr / 2})`), updateNodeBounds(ur, Wr), ur.intersect = function(lr) {
+		return log.info("iconSquare intersect", ur, lr), intersect_default.rect(ur, lr);
+	}, vr;
+}
+__name(iconCircle, "iconCircle");
+async function iconRounded(lr, ur, { config: { themeVariables: dr, flowchart: fr } }) {
+	let { labelStyles: pr } = styles2String(ur);
+	ur.labelStyle = pr;
+	let mr = ur.assetHeight ?? 48, hr = ur.assetWidth ?? 48, gr = Math.max(mr, hr), _r = fr?.wrappingWidth;
+	ur.width = Math.max(gr, _r ?? 0);
+	let { shapeSvg: vr, bbox: yr, halfPadding: br, label: xr } = await labelHelper(lr, ur, "icon-shape default"), Sr = ur.pos === "t", Cr = gr + br * 2, wr = gr + br * 2, { nodeBorder: Tr, mainBkg: Dr } = dr, { stylesMap: Ar } = compileStyles(ur), Mr = -wr / 2, Nr = -Cr / 2, Pr = ur.label ? 8 : 0, Fr = at.svg(vr), Ir = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (Ir.roughness = 0, Ir.fillStyle = "solid"), Ir.stroke = Ar.get("fill") ?? Dr;
+	let Lr = Fr.path(createRoundedRectPathD(Mr, Nr, wr, Cr, 5), Ir), Rr = Math.max(wr, yr.width), zr = Cr + yr.height + Pr, Br = Fr.rectangle(-Rr / 2, -zr / 2, Rr, zr, {
+		...Ir,
+		fill: "transparent",
+		stroke: "none"
+	}), Vr = vr.insert(() => Lr, ":first-child").attr("class", "icon-shape2"), Hr = vr.insert(() => Br);
+	if (ur.icon) {
+		let te = vr.append("g");
+		te.html(`<g>${await getIconSVG(ur.icon, {
+			height: gr,
+			width: gr,
+			fallbackPrefix: ""
+		})}</g>`);
+		let lr = te.node().getBBox(), dr = lr.width, fr = lr.height, pr = lr.x, mr = lr.y;
+		te.attr("transform", `translate(${-dr / 2 - pr},${Sr ? yr.height / 2 + Pr / 2 - fr / 2 - mr : -yr.height / 2 - Pr / 2 - fr / 2 - mr})`), te.attr("style", `color: ${Ar.get("stroke") ?? Tr};`);
+	}
+	return xr.attr("transform", `translate(${-yr.width / 2 - (yr.x - (yr.left ?? 0))},${Sr ? -zr / 2 : zr / 2 - yr.height})`), Vr.attr("transform", `translate(0,${Sr ? yr.height / 2 + Pr / 2 : -yr.height / 2 - Pr / 2})`), updateNodeBounds(ur, Hr), ur.intersect = function(lr) {
+		if (log.info("iconSquare intersect", ur, lr), !ur.label) return intersect_default.rect(ur, lr);
+		let dr = ur.x ?? 0, fr = ur.y ?? 0, pr = ur.height ?? 0, mr = [];
+		return mr = Sr ? [
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			},
+			{
+				x: dr + wr / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			},
+			{
+				x: dr + wr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - wr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - wr / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			}
+		] : [
+			{
+				x: dr - wr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + wr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + wr / 2,
+				y: fr - pr / 2 + Cr
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2 + Cr
+			},
+			{
+				x: dr + yr.width / 2 / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2 + Cr
+			},
+			{
+				x: dr - wr / 2,
+				y: fr - pr / 2 + Cr
+			}
+		], intersect_default.polygon(ur, mr, lr);
+	}, vr;
+}
+__name(iconRounded, "iconRounded");
+async function iconSquare(lr, ur, { config: { themeVariables: dr, flowchart: fr } }) {
+	let { labelStyles: pr } = styles2String(ur);
+	ur.labelStyle = pr;
+	let mr = ur.assetHeight ?? 48, hr = ur.assetWidth ?? 48, gr = Math.max(mr, hr), _r = fr?.wrappingWidth;
+	ur.width = Math.max(gr, _r ?? 0);
+	let { shapeSvg: vr, bbox: yr, halfPadding: br, label: xr } = await labelHelper(lr, ur, "icon-shape default"), Sr = ur.pos === "t", Cr = gr + br * 2, wr = gr + br * 2, { nodeBorder: Tr, mainBkg: Dr } = dr, { stylesMap: Ar } = compileStyles(ur), Mr = -wr / 2, Nr = -Cr / 2, Pr = ur.label ? 8 : 0, Fr = at.svg(vr), Ir = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (Ir.roughness = 0, Ir.fillStyle = "solid"), Ir.stroke = Ar.get("fill") ?? Dr;
+	let Lr = Fr.path(createRoundedRectPathD(Mr, Nr, wr, Cr, .1), Ir), Rr = Math.max(wr, yr.width), zr = Cr + yr.height + Pr, Br = Fr.rectangle(-Rr / 2, -zr / 2, Rr, zr, {
+		...Ir,
+		fill: "transparent",
+		stroke: "none"
+	}), Vr = vr.insert(() => Lr, ":first-child"), Hr = vr.insert(() => Br);
+	if (ur.icon) {
+		let te = vr.append("g");
+		te.html(`<g>${await getIconSVG(ur.icon, {
+			height: gr,
+			width: gr,
+			fallbackPrefix: ""
+		})}</g>`);
+		let lr = te.node().getBBox(), dr = lr.width, fr = lr.height, pr = lr.x, mr = lr.y;
+		te.attr("transform", `translate(${-dr / 2 - pr},${Sr ? yr.height / 2 + Pr / 2 - fr / 2 - mr : -yr.height / 2 - Pr / 2 - fr / 2 - mr})`), te.attr("style", `color: ${Ar.get("stroke") ?? Tr};`);
+	}
+	return xr.attr("transform", `translate(${-yr.width / 2 - (yr.x - (yr.left ?? 0))},${Sr ? -zr / 2 : zr / 2 - yr.height})`), Vr.attr("transform", `translate(0,${Sr ? yr.height / 2 + Pr / 2 : -yr.height / 2 - Pr / 2})`), updateNodeBounds(ur, Hr), ur.intersect = function(lr) {
+		if (log.info("iconSquare intersect", ur, lr), !ur.label) return intersect_default.rect(ur, lr);
+		let dr = ur.x ?? 0, fr = ur.y ?? 0, pr = ur.height ?? 0, mr = [];
+		return mr = Sr ? [
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			},
+			{
+				x: dr + wr / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			},
+			{
+				x: dr + wr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - wr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - wr / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2 + yr.height + Pr
+			}
+		] : [
+			{
+				x: dr - wr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + wr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + wr / 2,
+				y: fr - pr / 2 + Cr
+			},
+			{
+				x: dr + yr.width / 2,
+				y: fr - pr / 2 + Cr
+			},
+			{
+				x: dr + yr.width / 2 / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - yr.width / 2,
+				y: fr - pr / 2 + Cr
+			},
+			{
+				x: dr - wr / 2,
+				y: fr - pr / 2 + Cr
+			}
+		], intersect_default.polygon(ur, mr, lr);
+	}, vr;
+}
+__name(iconSquare, "iconSquare");
+async function imageSquare(lr, ur, { config: { flowchart: dr } }) {
+	let fr = new Image();
+	fr.src = ur?.img ?? "", await fr.decode();
+	let pr = Number(fr.naturalWidth.toString().replace("px", "")), mr = Number(fr.naturalHeight.toString().replace("px", ""));
+	ur.imageAspectRatio = pr / mr;
+	let { labelStyles: hr } = styles2String(ur);
+	ur.labelStyle = hr;
+	let gr = dr?.wrappingWidth;
+	ur.defaultWidth = dr?.wrappingWidth;
+	let _r = Math.max(ur.label ? gr ?? 0 : 0, ur?.assetWidth ?? pr), vr = ur.constraint === "on" && ur?.assetHeight ? ur.assetHeight * ur.imageAspectRatio : _r, yr = ur.constraint === "on" ? vr / ur.imageAspectRatio : ur?.assetHeight ?? mr;
+	ur.width = Math.max(vr, gr ?? 0);
+	let { shapeSvg: br, bbox: xr, label: Sr } = await labelHelper(lr, ur, "image-shape default"), Cr = ur.pos === "t", wr = -vr / 2, Tr = -yr / 2, Er = ur.label ? 8 : 0, Dr = at.svg(br), Ar = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (Ar.roughness = 0, Ar.fillStyle = "solid");
+	let jr = Dr.rectangle(wr, Tr, vr, yr, Ar), Mr = Math.max(vr, xr.width), Nr = yr + xr.height + Er, Pr = Dr.rectangle(-Mr / 2, -Nr / 2, Mr, Nr, {
+		...Ar,
+		fill: "none",
+		stroke: "none"
+	}), Fr = br.insert(() => jr, ":first-child"), Ir = br.insert(() => Pr);
+	if (ur.img) {
+		let te = br.append("image");
+		te.attr("href", ur.img), te.attr("width", vr), te.attr("height", yr), te.attr("preserveAspectRatio", "none"), te.attr("transform", `translate(${-vr / 2},${Cr ? Nr / 2 - yr : -Nr / 2})`);
+	}
+	return Sr.attr("transform", `translate(${-xr.width / 2 - (xr.x - (xr.left ?? 0))},${Cr ? -yr / 2 - xr.height / 2 - Er / 2 : yr / 2 - xr.height / 2 + Er / 2})`), Fr.attr("transform", `translate(0,${Cr ? xr.height / 2 + Er / 2 : -xr.height / 2 - Er / 2})`), updateNodeBounds(ur, Ir), ur.intersect = function(lr) {
+		if (log.info("iconSquare intersect", ur, lr), !ur.label) return intersect_default.rect(ur, lr);
+		let dr = ur.x ?? 0, fr = ur.y ?? 0, pr = ur.height ?? 0, mr = [];
+		return mr = Cr ? [
+			{
+				x: dr - xr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + xr.width / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + xr.width / 2,
+				y: fr - pr / 2 + xr.height + Er
+			},
+			{
+				x: dr + vr / 2,
+				y: fr - pr / 2 + xr.height + Er
+			},
+			{
+				x: dr + vr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - vr / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - vr / 2,
+				y: fr - pr / 2 + xr.height + Er
+			},
+			{
+				x: dr - xr.width / 2,
+				y: fr - pr / 2 + xr.height + Er
+			}
+		] : [
+			{
+				x: dr - vr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + vr / 2,
+				y: fr - pr / 2
+			},
+			{
+				x: dr + vr / 2,
+				y: fr - pr / 2 + yr
+			},
+			{
+				x: dr + xr.width / 2,
+				y: fr - pr / 2 + yr
+			},
+			{
+				x: dr + xr.width / 2 / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - xr.width / 2,
+				y: fr + pr / 2
+			},
+			{
+				x: dr - xr.width / 2,
+				y: fr - pr / 2 + yr
+			},
+			{
+				x: dr - vr / 2,
+				y: fr - pr / 2 + yr
+			}
+		], intersect_default.polygon(ur, mr, lr);
+	}, br;
+}
+__name(imageSquare, "imageSquare");
+async function inv_trapezoid(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), hr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), gr = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: mr,
+			y: 0
+		},
+		{
+			x: mr + 3 * hr / 6,
+			y: -hr
+		},
+		{
+			x: -3 * hr / 6,
+			y: -hr
+		}
+	], _r, { cssStyles: vr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = createPathFromPoints(gr), pr = te.path(dr, ur);
+		_r = fr.insert(() => pr, ":first-child").attr("transform", `translate(${-mr / 2}, ${hr / 2})`), vr && _r.attr("style", vr);
+	} else _r = insertPolygonShape(fr, mr, hr, gr);
+	return dr && _r.attr("style", dr), lr.width = mr, lr.height = hr, updateNodeBounds(lr, _r), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, gr, te);
+	}, fr;
+}
+__name(inv_trapezoid, "inv_trapezoid");
+async function drawRect(te, lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(lr);
+	lr.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(mr.width + ur.labelPaddingX * 2, lr?.width || 0), gr = Math.max(mr.height + ur.labelPaddingY * 2, lr?.height || 0), _r = -hr / 2, vr = -gr / 2, yr, { rx: br, ry: xr } = lr, { cssStyles: Sr } = lr;
+	if (ur?.rx && ur.ry && (br = ur.rx, xr = ur.ry), lr.look === "handDrawn") {
+		let te = at.svg(pr), ur = userNodeOverrides(lr, {}), dr = br || xr ? te.path(createRoundedRectPathD(_r, vr, hr, gr, br || 0), ur) : te.rectangle(_r, vr, hr, gr, ur);
+		yr = pr.insert(() => dr, ":first-child"), yr.attr("class", "basic label-container").attr("style", handleUndefinedAttr(Sr));
+	} else yr = pr.insert("rect", ":first-child"), yr.attr("class", "basic label-container").attr("style", fr).attr("rx", handleUndefinedAttr(br)).attr("ry", handleUndefinedAttr(xr)).attr("x", _r).attr("y", vr).attr("width", hr).attr("height", gr);
+	return updateNodeBounds(lr, yr), lr.calcIntersect = function(te, lr) {
+		return intersect_default.rect(te, lr);
+	}, lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, pr;
+}
+__name(drawRect, "drawRect");
+async function labelRect(te, lr) {
+	let { shapeSvg: ur, bbox: dr, label: fr } = await labelHelper(te, lr, "label"), pr = ur.insert("rect", ":first-child");
+	return pr.attr("width", .1).attr("height", .1), ur.attr("class", "label edgeLabel"), fr.attr("transform", `translate(${-(dr.width / 2) - (dr.x - (dr.left ?? 0))}, ${-(dr.height / 2) - (dr.y - (dr.top ?? 0))})`), updateNodeBounds(lr, pr), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, ur;
+}
+__name(labelRect, "labelRect");
+async function lean_left(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(pr.width + (lr.padding ?? 0), lr?.width ?? 0), hr = Math.max(pr.height + (lr.padding ?? 0), lr?.height ?? 0), gr = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: mr + 3 * hr / 6,
+			y: 0
+		},
+		{
+			x: mr,
+			y: -hr
+		},
+		{
+			x: -(3 * hr) / 6,
+			y: -hr
+		}
+	], _r, { cssStyles: vr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = createPathFromPoints(gr), pr = te.path(dr, ur);
+		_r = fr.insert(() => pr, ":first-child").attr("transform", `translate(${-mr / 2}, ${hr / 2})`), vr && _r.attr("style", vr);
+	} else _r = insertPolygonShape(fr, mr, hr, gr);
+	return dr && _r.attr("style", dr), lr.width = mr, lr.height = hr, updateNodeBounds(lr, _r), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, gr, te);
+	}, fr;
+}
+__name(lean_left, "lean_left");
+async function lean_right(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(pr.width + (lr.padding ?? 0), lr?.width ?? 0), hr = Math.max(pr.height + (lr.padding ?? 0), lr?.height ?? 0), gr = [
+		{
+			x: -3 * hr / 6,
+			y: 0
+		},
+		{
+			x: mr,
+			y: 0
+		},
+		{
+			x: mr + 3 * hr / 6,
+			y: -hr
+		},
+		{
+			x: 0,
+			y: -hr
+		}
+	], _r, { cssStyles: vr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = createPathFromPoints(gr), pr = te.path(dr, ur);
+		_r = fr.insert(() => pr, ":first-child").attr("transform", `translate(${-mr / 2}, ${hr / 2})`), vr && _r.attr("style", vr);
+	} else _r = insertPolygonShape(fr, mr, hr, gr);
+	return dr && _r.attr("style", dr), lr.width = mr, lr.height = hr, updateNodeBounds(lr, _r), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, gr, te);
+	}, fr;
+}
+__name(lean_right, "lean_right");
+function lightningBolt(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.label = "", ur.labelStyle = dr;
+	let pr = lr.insert("g").attr("class", getNodeClasses(ur)).attr("id", ur.domId ?? ur.id), { cssStyles: mr } = ur, hr = Math.max(35, ur?.width ?? 0), gr = Math.max(35, ur?.height ?? 0), _r = [
+		{
+			x: hr,
+			y: 0
+		},
+		{
+			x: 0,
+			y: gr + 7 / 2
+		},
+		{
+			x: hr - 14,
+			y: gr + 7 / 2
+		},
+		{
+			x: 0,
+			y: 2 * gr
+		},
+		{
+			x: hr,
+			y: gr - 7 / 2
+		},
+		{
+			x: 14,
+			y: gr - 7 / 2
+		}
+	], vr = at.svg(pr), yr = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (yr.roughness = 0, yr.fillStyle = "solid");
+	let br = createPathFromPoints(_r), xr = vr.path(br, yr), Sr = pr.insert(() => xr, ":first-child");
+	return mr && ur.look !== "handDrawn" && Sr.selectAll("path").attr("style", mr), fr && ur.look !== "handDrawn" && Sr.selectAll("path").attr("style", fr), Sr.attr("transform", `translate(-${hr / 2},${-gr})`), updateNodeBounds(ur, Sr), ur.intersect = function(lr) {
+		return log.info("lightningBolt intersect", ur, lr), intersect_default.polygon(ur, _r, lr);
+	}, pr;
+}
+__name(lightningBolt, "lightningBolt");
+var createCylinderPathD2 = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr, mr) => [
+	`M${te},${lr + pr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`,
+	`a${fr},${pr} 0,0,0 ${-ur},0`,
+	`l0,${dr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`,
+	`l0,${-dr}`,
+	`M${te},${lr + pr + mr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`
+].join(" "), "createCylinderPathD"), createOuterCylinderPathD2 = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr, mr) => [
+	`M${te},${lr + pr}`,
+	`M${te + ur},${lr + pr}`,
+	`a${fr},${pr} 0,0,0 ${-ur},0`,
+	`l0,${dr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`,
+	`l0,${-dr}`,
+	`M${te},${lr + pr + mr}`,
+	`a${fr},${pr} 0,0,0 ${ur},0`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD2 = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => [`M${te - ur / 2},${-dr / 2}`, `a${fr},${pr} 0,0,0 ${ur},0`].join(" "), "createInnerCylinderPathD");
+async function linedCylinder(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0), lr.width ?? 0), gr = hr / 2, _r = gr / (2.5 + hr / 50), vr = Math.max(pr.height + _r + (lr.padding ?? 0), lr.height ?? 0), yr = vr * .1, br, { cssStyles: xr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = createOuterCylinderPathD2(0, 0, hr, vr, gr, _r, yr), dr = createInnerCylinderPathD2(0, _r, hr, vr, gr, _r), pr = userNodeOverrides(lr, {}), mr = te.path(ur, pr), Sr = te.path(dr, pr);
+		fr.insert(() => Sr, ":first-child").attr("class", "line"), br = fr.insert(() => mr, ":first-child"), br.attr("class", "basic label-container"), xr && br.attr("style", xr);
+	} else {
+		let te = createCylinderPathD2(0, 0, hr, vr, gr, _r, yr);
+		br = fr.insert("path", ":first-child").attr("d", te).attr("class", "basic label-container").attr("style", handleUndefinedAttr(xr)).attr("style", dr);
+	}
+	return br.attr("label-offset-y", _r), br.attr("transform", `translate(${-hr / 2}, ${-(vr / 2 + _r)})`), updateNodeBounds(lr, br), mr.attr("transform", `translate(${-(pr.width / 2) - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) + _r - (pr.y - (pr.top ?? 0))})`), lr.intersect = function(te) {
+		let ur = intersect_default.rect(lr, te), dr = ur.x - (lr.x ?? 0);
+		if (gr != 0 && (Math.abs(dr) < (lr.width ?? 0) / 2 || Math.abs(dr) == (lr.width ?? 0) / 2 && Math.abs(ur.y - (lr.y ?? 0)) > (lr.height ?? 0) / 2 - _r)) {
+			let fr = _r * _r * (1 - dr * dr / (gr * gr));
+			fr > 0 && (fr = Math.sqrt(fr)), fr = _r - fr, te.y - (lr.y ?? 0) > 0 && (fr = -fr), ur.y += fr;
+		}
+		return ur;
+	}, fr;
+}
+__name(linedCylinder, "linedCylinder");
+async function linedWaveEdgedRect(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = gr / 4, vr = gr + _r, { cssStyles: yr } = lr, br = at.svg(fr), xr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (xr.roughness = 0, xr.fillStyle = "solid");
+	let Sr = [
+		{
+			x: -hr / 2 - hr / 2 * .1,
+			y: -vr / 2
+		},
+		{
+			x: -hr / 2 - hr / 2 * .1,
+			y: vr / 2
+		},
+		...generateFullSineWavePoints(-hr / 2 - hr / 2 * .1, vr / 2, hr / 2 + hr / 2 * .1, vr / 2, _r, .8),
+		{
+			x: hr / 2 + hr / 2 * .1,
+			y: -vr / 2
+		},
+		{
+			x: -hr / 2 - hr / 2 * .1,
+			y: -vr / 2
+		},
+		{
+			x: -hr / 2,
+			y: -vr / 2
+		},
+		{
+			x: -hr / 2,
+			y: vr / 2 * 1.1
+		},
+		{
+			x: -hr / 2,
+			y: -vr / 2
+		}
+	], Cr = br.polygon(Sr.map((te) => [te.x, te.y]), xr), wr = fr.insert(() => Cr, ":first-child");
+	return wr.attr("class", "basic label-container"), yr && lr.look !== "handDrawn" && wr.selectAll("path").attr("style", yr), dr && lr.look !== "handDrawn" && wr.selectAll("path").attr("style", dr), wr.attr("transform", `translate(0,${-_r / 2})`), mr.attr("transform", `translate(${-hr / 2 + (lr.padding ?? 0) + hr / 2 * .1 / 2 - (pr.x - (pr.left ?? 0))},${-gr / 2 + (lr.padding ?? 0) - _r / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, wr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, Sr, te);
+	}, fr;
+}
+__name(linedWaveEdgedRect, "linedWaveEdgedRect");
+async function multiRect(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = -hr / 2, vr = -gr / 2, { cssStyles: yr } = lr, br = at.svg(fr), xr = userNodeOverrides(lr, {}), Sr = [
+		{
+			x: _r - 5,
+			y: vr + 5
+		},
+		{
+			x: _r - 5,
+			y: vr + gr + 5
+		},
+		{
+			x: _r + hr - 5,
+			y: vr + gr + 5
+		},
+		{
+			x: _r + hr - 5,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr + gr - 5
+		},
+		{
+			x: _r + hr + 5,
+			y: vr + gr - 5
+		},
+		{
+			x: _r + hr + 5,
+			y: vr - 5
+		},
+		{
+			x: _r + 5,
+			y: vr - 5
+		},
+		{
+			x: _r + 5,
+			y: vr
+		},
+		{
+			x: _r,
+			y: vr
+		},
+		{
+			x: _r,
+			y: vr + 5
+		}
+	], Cr = [
+		{
+			x: _r,
+			y: vr + 5
+		},
+		{
+			x: _r + hr - 5,
+			y: vr + 5
+		},
+		{
+			x: _r + hr - 5,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr
+		},
+		{
+			x: _r,
+			y: vr
+		}
+	];
+	lr.look !== "handDrawn" && (xr.roughness = 0, xr.fillStyle = "solid");
+	let wr = createPathFromPoints(Sr), Tr = br.path(wr, xr), Er = createPathFromPoints(Cr), Dr = br.path(Er, {
+		...xr,
+		fill: "none"
+	}), Ar = fr.insert(() => Dr, ":first-child");
+	return Ar.insert(() => Tr, ":first-child"), Ar.attr("class", "basic label-container"), yr && lr.look !== "handDrawn" && Ar.selectAll("path").attr("style", yr), dr && lr.look !== "handDrawn" && Ar.selectAll("path").attr("style", dr), mr.attr("transform", `translate(${-(pr.width / 2) - 5 - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) + 5 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Ar), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, Sr, te);
+	}, fr;
+}
+__name(multiRect, "multiRect");
+async function multiWaveEdgedRectangle(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = gr / 4, vr = gr + _r, yr = -hr / 2, br = -vr / 2, { cssStyles: xr } = lr, Sr = generateFullSineWavePoints(yr - 5, br + vr + 5, yr + hr - 5, br + vr + 5, _r, .8), Cr = Sr?.[Sr.length - 1], wr = [
+		{
+			x: yr - 5,
+			y: br + 5
+		},
+		{
+			x: yr - 5,
+			y: br + vr + 5
+		},
+		...Sr,
+		{
+			x: yr + hr - 5,
+			y: Cr.y - 5
+		},
+		{
+			x: yr + hr,
+			y: Cr.y - 5
+		},
+		{
+			x: yr + hr,
+			y: Cr.y - 10
+		},
+		{
+			x: yr + hr + 5,
+			y: Cr.y - 10
+		},
+		{
+			x: yr + hr + 5,
+			y: br - 5
+		},
+		{
+			x: yr + 5,
+			y: br - 5
+		},
+		{
+			x: yr + 5,
+			y: br
+		},
+		{
+			x: yr,
+			y: br
+		},
+		{
+			x: yr,
+			y: br + 5
+		}
+	], Tr = [
+		{
+			x: yr,
+			y: br + 5
+		},
+		{
+			x: yr + hr - 5,
+			y: br + 5
+		},
+		{
+			x: yr + hr - 5,
+			y: Cr.y - 5
+		},
+		{
+			x: yr + hr,
+			y: Cr.y - 5
+		},
+		{
+			x: yr + hr,
+			y: br
+		},
+		{
+			x: yr,
+			y: br
+		}
+	], Er = at.svg(fr), Dr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Dr.roughness = 0, Dr.fillStyle = "solid");
+	let Ar = createPathFromPoints(wr), jr = Er.path(Ar, Dr), Mr = createPathFromPoints(Tr), Nr = Er.path(Mr, Dr), Pr = fr.insert(() => jr, ":first-child");
+	return Pr.insert(() => Nr), Pr.attr("class", "basic label-container"), xr && lr.look !== "handDrawn" && Pr.selectAll("path").attr("style", xr), dr && lr.look !== "handDrawn" && Pr.selectAll("path").attr("style", dr), Pr.attr("transform", `translate(0,${-_r / 2})`), mr.attr("transform", `translate(${-(pr.width / 2) - 5 - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) + 5 - _r / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Pr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, wr, te);
+	}, fr;
+}
+__name(multiWaveEdgedRectangle, "multiWaveEdgedRectangle");
+async function note(te, lr, { config: { themeVariables: ur } }) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(lr);
+	lr.labelStyle = dr, lr.useHtmlLabels || getConfig().flowchart?.htmlLabels !== !1 || (lr.centerLabel = !0);
+	let { shapeSvg: pr, bbox: mr, label: hr } = await labelHelper(te, lr, getNodeClasses(lr)), gr = Math.max(mr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), _r = Math.max(mr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), vr = -gr / 2, yr = -_r / 2, { cssStyles: xr } = lr, Sr = at.svg(pr), Cr = userNodeOverrides(lr, {
+		fill: ur.noteBkgColor,
+		stroke: ur.noteBorderColor
+	});
+	lr.look !== "handDrawn" && (Cr.roughness = 0, Cr.fillStyle = "solid");
+	let wr = Sr.rectangle(vr, yr, gr, _r, Cr), Tr = pr.insert(() => wr, ":first-child");
+	return Tr.attr("class", "basic label-container"), xr && lr.look !== "handDrawn" && Tr.selectAll("path").attr("style", xr), fr && lr.look !== "handDrawn" && Tr.selectAll("path").attr("style", fr), hr.attr("transform", `translate(${-mr.width / 2 - (mr.x - (mr.left ?? 0))}, ${-(mr.height / 2) - (mr.y - (mr.top ?? 0))})`), updateNodeBounds(lr, Tr), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, pr;
+}
+__name(note, "note");
+var createDecisionBoxPathD = /* @__PURE__ */ __name((te, lr, ur) => [
+	`M${te + ur / 2},${lr}`,
+	`L${te + ur},${lr - ur / 2}`,
+	`L${te + ur / 2},${lr - ur}`,
+	`L${te},${lr - ur / 2}`,
+	"Z"
+].join(" "), "createDecisionBoxPathD");
+async function question(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = pr.width + lr.padding + (pr.height + lr.padding), hr = .5, gr = [
+		{
+			x: mr / 2,
+			y: 0
+		},
+		{
+			x: mr,
+			y: -mr / 2
+		},
+		{
+			x: mr / 2,
+			y: -mr
+		},
+		{
+			x: 0,
+			y: -mr / 2
+		}
+	], _r, { cssStyles: vr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = createDecisionBoxPathD(0, 0, mr), pr = te.path(dr, ur);
+		_r = fr.insert(() => pr, ":first-child").attr("transform", `translate(${-mr / 2 + hr}, ${mr / 2})`), vr && _r.attr("style", vr);
+	} else _r = insertPolygonShape(fr, mr, mr, gr), _r.attr("transform", `translate(${-mr / 2 + hr}, ${mr / 2})`);
+	return dr && _r.attr("style", dr), updateNodeBounds(lr, _r), lr.calcIntersect = function(te, lr) {
+		let ur = te.width, dr = [
+			{
+				x: ur / 2,
+				y: 0
+			},
+			{
+				x: ur,
+				y: -ur / 2
+			},
+			{
+				x: ur / 2,
+				y: -ur
+			},
+			{
+				x: 0,
+				y: -ur / 2
+			}
+		], fr = intersect_default.polygon(te, dr, lr);
+		return {
+			x: fr.x - .5,
+			y: fr.y - .5
+		};
+	}, lr.intersect = function(te) {
+		return this.calcIntersect(lr, te);
+	}, fr;
+}
+__name(question, "question");
+async function rect_left_inv_arrow(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0), lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0), lr?.height ?? 0), _r = -hr / 2, vr = -gr / 2, yr = vr / 2, br = [
+		{
+			x: _r + yr,
+			y: vr
+		},
+		{
+			x: _r,
+			y: 0
+		},
+		{
+			x: _r + yr,
+			y: -vr
+		},
+		{
+			x: -_r,
+			y: -vr
+		},
+		{
+			x: -_r,
+			y: vr
+		}
+	], { cssStyles: xr } = lr, Sr = at.svg(fr), Cr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Cr.roughness = 0, Cr.fillStyle = "solid");
+	let wr = createPathFromPoints(br), Tr = Sr.path(wr, Cr), Er = fr.insert(() => Tr, ":first-child");
+	return Er.attr("class", "basic label-container"), xr && lr.look !== "handDrawn" && Er.selectAll("path").attr("style", xr), dr && lr.look !== "handDrawn" && Er.selectAll("path").attr("style", dr), Er.attr("transform", `translate(${-yr / 2},0)`), mr.attr("transform", `translate(${-yr / 2 - pr.width / 2 - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Er), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, br, te);
+	}, fr;
+}
+__name(rect_left_inv_arrow, "rect_left_inv_arrow");
+async function rectWithTitle(lr, dr) {
+	let { labelStyles: fr, nodeStyles: pr } = styles2String(dr);
+	dr.labelStyle = fr;
+	let mr;
+	mr = dr.cssClasses ? "node " + dr.cssClasses : "node default";
+	let hr = lr.insert("g").attr("class", mr).attr("id", dr.domId || dr.id), _r = hr.insert("g"), yr = hr.insert("g").attr("class", "label").attr("style", pr), br = dr.description, xr = dr.label, Sr = yr.node().appendChild(await createLabel_default(xr, dr.labelStyle, !0, !0)), Cr = {
+		width: 0,
+		height: 0
+	};
+	if (evaluate(getConfig2()?.flowchart?.htmlLabels)) {
+		let te = Sr.children[0], lr = select_default(Sr);
+		Cr = te.getBoundingClientRect(), lr.attr("width", Cr.width), lr.attr("height", Cr.height);
+	}
+	log.info("Text 2", br);
+	let wr = br || [], Tr = Sr.getBBox(), Er = yr.node().appendChild(await createLabel_default(wr.join ? wr.join("<br/>") : wr, dr.labelStyle, !0, !0)), Dr = Er.children[0], Ar = select_default(Er);
+	Cr = Dr.getBoundingClientRect(), Ar.attr("width", Cr.width), Ar.attr("height", Cr.height);
+	let jr = (dr.padding || 0) / 2;
+	select_default(Er).attr("transform", "translate( " + (Cr.width > Tr.width ? 0 : (Tr.width - Cr.width) / 2) + ", " + (Tr.height + jr + 5) + ")"), select_default(Sr).attr("transform", "translate( " + (Cr.width < Tr.width ? 0 : -(Tr.width - Cr.width) / 2) + ", 0)"), Cr = yr.node().getBBox(), yr.attr("transform", "translate(" + -Cr.width / 2 + ", " + (-Cr.height / 2 - jr + 3) + ")");
+	let Mr = Cr.width + (dr.padding || 0), Nr = Cr.height + (dr.padding || 0), Pr = -Cr.width / 2 - jr, Fr = -Cr.height / 2 - jr, Ir, Lr;
+	if (dr.look === "handDrawn") {
+		let lr = at.svg(hr), ur = userNodeOverrides(dr, {}), fr = lr.path(createRoundedRectPathD(Pr, Fr, Mr, Nr, dr.rx || 0), ur), pr = lr.line(-Cr.width / 2 - jr, -Cr.height / 2 - jr + Tr.height + jr, Cr.width / 2 + jr, -Cr.height / 2 - jr + Tr.height + jr, ur);
+		Lr = hr.insert(() => (log.debug("Rough node insert CXC", fr), pr), ":first-child"), Ir = hr.insert(() => (log.debug("Rough node insert CXC", fr), fr), ":first-child");
+	} else Ir = _r.insert("rect", ":first-child"), Lr = _r.insert("line"), Ir.attr("class", "outer title-state").attr("style", pr).attr("x", -Cr.width / 2 - jr).attr("y", -Cr.height / 2 - jr).attr("width", Cr.width + (dr.padding || 0)).attr("height", Cr.height + (dr.padding || 0)), Lr.attr("class", "divider").attr("x1", -Cr.width / 2 - jr).attr("x2", Cr.width / 2 + jr).attr("y1", -Cr.height / 2 - jr + Tr.height + jr).attr("y2", -Cr.height / 2 - jr + Tr.height + jr);
+	return updateNodeBounds(dr, Ir), dr.intersect = function(te) {
+		return intersect_default.rect(dr, te);
+	}, hr;
+}
+__name(rectWithTitle, "rectWithTitle");
+function generateArcPoints2(te, lr, ur, dr, fr, pr, mr) {
+	let hr = (te + ur) / 2, gr = (lr + dr) / 2, _r = Math.atan2(dr - lr, ur - te), vr = (ur - te) / 2, yr = (dr - lr) / 2, br = vr / fr, xr = yr / pr, Sr = Math.sqrt(br ** 2 + xr ** 2);
+	if (Sr > 1) throw Error("The given radii are too small to create an arc between the points.");
+	let Cr = Math.sqrt(1 - Sr ** 2), wr = hr + Cr * pr * Math.sin(_r) * (mr ? -1 : 1), Tr = gr - Cr * fr * Math.cos(_r) * (mr ? -1 : 1), Er = Math.atan2((lr - Tr) / pr, (te - wr) / fr), Dr = Math.atan2((dr - Tr) / pr, (ur - wr) / fr) - Er;
+	mr && Dr < 0 && (Dr += 2 * Math.PI), !mr && Dr > 0 && (Dr -= 2 * Math.PI);
+	let Or = [];
+	for (let te = 0; te < 20; te++) {
+		let lr = Er + te / 19 * Dr, ur = wr + fr * Math.cos(lr), dr = Tr + pr * Math.sin(lr);
+		Or.push({
+			x: ur,
+			y: dr
+		});
+	}
+	return Or;
+}
+__name(generateArcPoints2, "generateArcPoints");
+async function roundedRect(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = lr?.padding ?? 0, hr = lr?.padding ?? 0, gr = (lr?.width ? lr?.width : pr.width) + mr * 2, _r = (lr?.height ? lr?.height : pr.height) + hr * 2, vr = lr.radius || 5, yr = lr.taper || 5, { cssStyles: br } = lr, xr = at.svg(fr), Sr = userNodeOverrides(lr, {});
+	lr.stroke && (Sr.stroke = lr.stroke), lr.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Cr = [
+		{
+			x: -gr / 2 + yr,
+			y: -_r / 2
+		},
+		{
+			x: gr / 2 - yr,
+			y: -_r / 2
+		},
+		...generateArcPoints2(gr / 2 - yr, -_r / 2, gr / 2, -_r / 2 + yr, vr, vr, !0),
+		{
+			x: gr / 2,
+			y: -_r / 2 + yr
+		},
+		{
+			x: gr / 2,
+			y: _r / 2 - yr
+		},
+		...generateArcPoints2(gr / 2, _r / 2 - yr, gr / 2 - yr, _r / 2, vr, vr, !0),
+		{
+			x: gr / 2 - yr,
+			y: _r / 2
+		},
+		{
+			x: -gr / 2 + yr,
+			y: _r / 2
+		},
+		...generateArcPoints2(-gr / 2 + yr, _r / 2, -gr / 2, _r / 2 - yr, vr, vr, !0),
+		{
+			x: -gr / 2,
+			y: _r / 2 - yr
+		},
+		{
+			x: -gr / 2,
+			y: -_r / 2 + yr
+		},
+		...generateArcPoints2(-gr / 2, -_r / 2 + yr, -gr / 2 + yr, -_r / 2, vr, vr, !0)
+	], wr = createPathFromPoints(Cr), Tr = xr.path(wr, Sr), Er = fr.insert(() => Tr, ":first-child");
+	return Er.attr("class", "basic label-container outer-path"), br && lr.look !== "handDrawn" && Er.selectChildren("path").attr("style", br), dr && lr.look !== "handDrawn" && Er.selectChildren("path").attr("style", dr), updateNodeBounds(lr, Er), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, Cr, te);
+	}, fr;
+}
+__name(roundedRect, "roundedRect");
+async function shadedProcess(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = lr?.padding ?? 0, gr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), _r = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), vr = -pr.width / 2 - hr, yr = -pr.height / 2 - hr, { cssStyles: br } = lr, xr = at.svg(fr), Sr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Cr = [
+		{
+			x: vr,
+			y: yr
+		},
+		{
+			x: vr + gr + 8,
+			y: yr
+		},
+		{
+			x: vr + gr + 8,
+			y: yr + _r
+		},
+		{
+			x: vr - 8,
+			y: yr + _r
+		},
+		{
+			x: vr - 8,
+			y: yr
+		},
+		{
+			x: vr,
+			y: yr
+		},
+		{
+			x: vr,
+			y: yr + _r
+		}
+	], Tr = xr.polygon(Cr.map((te) => [te.x, te.y]), Sr), Er = fr.insert(() => Tr, ":first-child");
+	return Er.attr("class", "basic label-container").attr("style", handleUndefinedAttr(br)), dr && lr.look !== "handDrawn" && Er.selectAll("path").attr("style", dr), br && lr.look !== "handDrawn" && Er.selectAll("path").attr("style", dr), mr.attr("transform", `translate(${-gr / 2 + 4 + (lr.padding ?? 0) - (pr.x - (pr.left ?? 0))},${-_r / 2 + (lr.padding ?? 0) - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Er), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, fr;
+}
+__name(shadedProcess, "shadedProcess");
+async function slopedRect(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = -hr / 2, vr = -gr / 2, { cssStyles: yr } = lr, br = at.svg(fr), xr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (xr.roughness = 0, xr.fillStyle = "solid");
+	let Sr = [
+		{
+			x: _r,
+			y: vr
+		},
+		{
+			x: _r,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr - gr / 2
+		}
+	], Cr = createPathFromPoints(Sr), wr = br.path(Cr, xr), Tr = fr.insert(() => wr, ":first-child");
+	return Tr.attr("class", "basic label-container"), yr && lr.look !== "handDrawn" && Tr.selectChildren("path").attr("style", yr), dr && lr.look !== "handDrawn" && Tr.selectChildren("path").attr("style", dr), Tr.attr("transform", `translate(0, ${gr / 4})`), mr.attr("transform", `translate(${-hr / 2 + (lr.padding ?? 0) - (pr.x - (pr.left ?? 0))}, ${-gr / 4 + (lr.padding ?? 0) - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Tr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, Sr, te);
+	}, fr;
+}
+__name(slopedRect, "slopedRect");
+async function squareRect2(te, lr) {
+	return drawRect(te, lr, {
+		rx: 0,
+		ry: 0,
+		classes: "",
+		labelPaddingX: lr.labelPaddingX ?? (lr?.padding || 0) * 2,
+		labelPaddingY: (lr?.padding || 0) * 1
+	});
+}
+__name(squareRect2, "squareRect");
+async function stadium(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = pr.height + lr.padding, hr = pr.width + mr / 4 + lr.padding, gr = mr / 2, { cssStyles: _r } = lr, vr = at.svg(fr), yr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (yr.roughness = 0, yr.fillStyle = "solid");
+	let br = [
+		{
+			x: -hr / 2 + gr,
+			y: -mr / 2
+		},
+		{
+			x: hr / 2 - gr,
+			y: -mr / 2
+		},
+		...generateCirclePoints(-hr / 2 + gr, 0, gr, 50, 90, 270),
+		{
+			x: hr / 2 - gr,
+			y: mr / 2
+		},
+		...generateCirclePoints(hr / 2 - gr, 0, gr, 50, 270, 450)
+	], xr = createPathFromPoints(br), Sr = vr.path(xr, yr), Cr = fr.insert(() => Sr, ":first-child");
+	return Cr.attr("class", "basic label-container outer-path"), _r && lr.look !== "handDrawn" && Cr.selectChildren("path").attr("style", _r), dr && lr.look !== "handDrawn" && Cr.selectChildren("path").attr("style", dr), updateNodeBounds(lr, Cr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, br, te);
+	}, fr;
+}
+__name(stadium, "stadium");
+async function state(te, lr) {
+	return drawRect(te, lr, {
+		rx: 5,
+		ry: 5,
+		classes: "flowchart-node"
+	});
+}
+__name(state, "state");
+function stateEnd(te, lr, { config: { themeVariables: ur } }) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(lr);
+	lr.labelStyle = dr;
+	let { cssStyles: pr } = lr, { lineColor: mr, stateBorder: hr, nodeBorder: gr } = ur, _r = te.insert("g").attr("class", "node default").attr("id", lr.domId || lr.id), vr = at.svg(_r), yr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (yr.roughness = 0, yr.fillStyle = "solid");
+	let br = vr.circle(0, 0, 14, {
+		...yr,
+		stroke: mr,
+		strokeWidth: 2
+	}), xr = hr ?? gr, Sr = vr.circle(0, 0, 5, {
+		...yr,
+		fill: xr,
+		stroke: xr,
+		strokeWidth: 2,
+		fillStyle: "solid"
+	}), Cr = _r.insert(() => br, ":first-child");
+	return Cr.insert(() => Sr), pr && Cr.selectAll("path").attr("style", pr), fr && Cr.selectAll("path").attr("style", fr), updateNodeBounds(lr, Cr), lr.intersect = function(te) {
+		return intersect_default.circle(lr, 7, te);
+	}, _r;
+}
+__name(stateEnd, "stateEnd");
+function stateStart(te, lr, { config: { themeVariables: ur } }) {
+	let { lineColor: dr } = ur, fr = te.insert("g").attr("class", "node default").attr("id", lr.domId || lr.id), pr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr).circle(0, 0, 14, solidStateFill(dr));
+		pr = fr.insert(() => te), pr.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14);
+	} else pr = fr.insert("circle", ":first-child"), pr.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14);
+	return updateNodeBounds(lr, pr), lr.intersect = function(te) {
+		return intersect_default.circle(lr, 7, te);
+	}, fr;
+}
+__name(stateStart, "stateStart");
+async function subroutine(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = (lr?.padding || 0) / 2, hr = pr.width + lr.padding, gr = pr.height + lr.padding, _r = -pr.width / 2 - mr, vr = -pr.height / 2 - mr, yr = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: hr,
+			y: 0
+		},
+		{
+			x: hr,
+			y: -gr
+		},
+		{
+			x: 0,
+			y: -gr
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: -8,
+			y: 0
+		},
+		{
+			x: hr + 8,
+			y: 0
+		},
+		{
+			x: hr + 8,
+			y: -gr
+		},
+		{
+			x: -8,
+			y: -gr
+		},
+		{
+			x: -8,
+			y: 0
+		}
+	];
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = te.rectangle(_r - 8, vr, hr + 16, gr, ur), pr = te.line(_r, vr, _r, vr + gr, ur), mr = te.line(_r + hr, vr, _r + hr, vr + gr, ur);
+		fr.insert(() => pr, ":first-child"), fr.insert(() => mr, ":first-child");
+		let yr = fr.insert(() => dr, ":first-child"), { cssStyles: br } = lr;
+		yr.attr("class", "basic label-container").attr("style", handleUndefinedAttr(br)), updateNodeBounds(lr, yr);
+	} else {
+		let te = insertPolygonShape(fr, hr, gr, yr);
+		dr && te.attr("style", dr), updateNodeBounds(lr, te);
+	}
+	return lr.intersect = function(te) {
+		return intersect_default.polygon(lr, yr, te);
+	}, fr;
+}
+__name(subroutine, "subroutine");
+async function taggedRect(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), hr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), gr = -mr / 2, _r = -hr / 2, vr = .2 * hr, yr = .2 * hr, { cssStyles: br } = lr, xr = at.svg(fr), Sr = userNodeOverrides(lr, {}), Cr = [
+		{
+			x: gr - vr / 2,
+			y: _r
+		},
+		{
+			x: gr + mr + vr / 2,
+			y: _r
+		},
+		{
+			x: gr + mr + vr / 2,
+			y: _r + hr
+		},
+		{
+			x: gr - vr / 2,
+			y: _r + hr
+		}
+	], wr = [
+		{
+			x: gr + mr - vr / 2,
+			y: _r + hr
+		},
+		{
+			x: gr + mr + vr / 2,
+			y: _r + hr
+		},
+		{
+			x: gr + mr + vr / 2,
+			y: _r + hr - yr
+		}
+	];
+	lr.look !== "handDrawn" && (Sr.roughness = 0, Sr.fillStyle = "solid");
+	let Tr = createPathFromPoints(Cr), Er = xr.path(Tr, Sr), Dr = createPathFromPoints(wr), Ar = xr.path(Dr, {
+		...Sr,
+		fillStyle: "solid"
+	}), jr = fr.insert(() => Ar, ":first-child");
+	return jr.insert(() => Er, ":first-child"), jr.attr("class", "basic label-container"), br && lr.look !== "handDrawn" && jr.selectAll("path").attr("style", br), dr && lr.look !== "handDrawn" && jr.selectAll("path").attr("style", dr), updateNodeBounds(lr, jr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, Cr, te);
+	}, fr;
+}
+__name(taggedRect, "taggedRect");
+async function taggedWaveEdgedRectangle(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = gr / 4, vr = .2 * hr, yr = .2 * gr, br = gr + _r, { cssStyles: xr } = lr, Sr = at.svg(fr), Cr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Cr.roughness = 0, Cr.fillStyle = "solid");
+	let wr = [
+		{
+			x: -hr / 2 - hr / 2 * .1,
+			y: br / 2
+		},
+		...generateFullSineWavePoints(-hr / 2 - hr / 2 * .1, br / 2, hr / 2 + hr / 2 * .1, br / 2, _r, .8),
+		{
+			x: hr / 2 + hr / 2 * .1,
+			y: -br / 2
+		},
+		{
+			x: -hr / 2 - hr / 2 * .1,
+			y: -br / 2
+		}
+	], Tr = -hr / 2 + hr / 2 * .1, Er = -br / 2 - yr * .4, Dr = [
+		{
+			x: Tr + hr - vr,
+			y: (Er + gr) * 1.4
+		},
+		{
+			x: Tr + hr,
+			y: Er + gr - yr
+		},
+		{
+			x: Tr + hr,
+			y: (Er + gr) * .9
+		},
+		...generateFullSineWavePoints(Tr + hr, (Er + gr) * 1.3, Tr + hr - vr, (Er + gr) * 1.5, -gr * .03, .5)
+	], Ar = createPathFromPoints(wr), jr = Sr.path(Ar, Cr), Mr = createPathFromPoints(Dr), Nr = Sr.path(Mr, {
+		...Cr,
+		fillStyle: "solid"
+	}), Pr = fr.insert(() => Nr, ":first-child");
+	return Pr.insert(() => jr, ":first-child"), Pr.attr("class", "basic label-container"), xr && lr.look !== "handDrawn" && Pr.selectAll("path").attr("style", xr), dr && lr.look !== "handDrawn" && Pr.selectAll("path").attr("style", dr), Pr.attr("transform", `translate(0,${-_r / 2})`), mr.attr("transform", `translate(${-hr / 2 + (lr.padding ?? 0) - (pr.x - (pr.left ?? 0))},${-gr / 2 + (lr.padding ?? 0) - _r / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Pr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, wr, te);
+	}, fr;
+}
+__name(taggedWaveEdgedRectangle, "taggedWaveEdgedRectangle");
+async function text(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(pr.width + lr.padding, lr?.width || 0), hr = Math.max(pr.height + lr.padding, lr?.height || 0), gr = -mr / 2, _r = -hr / 2, vr = fr.insert("rect", ":first-child");
+	return vr.attr("class", "text").attr("style", dr).attr("rx", 0).attr("ry", 0).attr("x", gr).attr("y", _r).attr("width", mr).attr("height", hr), updateNodeBounds(lr, vr), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, fr;
+}
+__name(text, "text");
+var createCylinderPathD3 = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => `M${te},${lr}
+    a${fr},${pr} 0,0,1 0,${-dr}
+    l${ur},0
+    a${fr},${pr} 0,0,1 0,${dr}
+    M${ur},${-dr}
+    a${fr},${pr} 0,0,0 0,${dr}
+    l${-ur},0`, "createCylinderPathD"), createOuterCylinderPathD3 = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => [
+	`M${te},${lr}`,
+	`M${te + ur},${lr}`,
+	`a${fr},${pr} 0,0,0 0,${-dr}`,
+	`l${-ur},0`,
+	`a${fr},${pr} 0,0,0 0,${dr}`,
+	`l${ur},0`
+].join(" "), "createOuterCylinderPathD"), createInnerCylinderPathD3 = /* @__PURE__ */ __name((te, lr, ur, dr, fr, pr) => [`M${te + ur / 2},${-dr / 2}`, `a${fr},${pr} 0,0,0 0,${dr}`].join(" "), "createInnerCylinderPathD");
+async function tiltedCylinder(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr, halfPadding: hr } = await labelHelper(te, lr, getNodeClasses(lr)), gr = lr.look === "neo" ? hr * 2 : hr, _r = pr.height + gr, vr = _r / 2, yr = vr / (2.5 + _r / 50), br = pr.width + yr + gr, { cssStyles: xr } = lr, Sr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = createOuterCylinderPathD3(0, 0, br, _r, yr, vr), dr = createInnerCylinderPathD3(0, 0, br, _r, yr, vr), pr = te.path(ur, userNodeOverrides(lr, {})), mr = te.path(dr, userNodeOverrides(lr, { fill: "none" }));
+		Sr = fr.insert(() => mr, ":first-child"), Sr = fr.insert(() => pr, ":first-child"), Sr.attr("class", "basic label-container"), xr && Sr.attr("style", xr);
+	} else {
+		let te = createCylinderPathD3(0, 0, br, _r, yr, vr);
+		Sr = fr.insert("path", ":first-child").attr("d", te).attr("class", "basic label-container").attr("style", handleUndefinedAttr(xr)).attr("style", dr), Sr.attr("class", "basic label-container"), xr && Sr.selectAll("path").attr("style", xr), dr && Sr.selectAll("path").attr("style", dr);
+	}
+	return Sr.attr("label-offset-x", yr), Sr.attr("transform", `translate(${-br / 2}, ${_r / 2} )`), mr.attr("transform", `translate(${-(pr.width / 2) - yr - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Sr), lr.intersect = function(te) {
+		let ur = intersect_default.rect(lr, te), dr = ur.y - (lr.y ?? 0);
+		if (vr != 0 && (Math.abs(dr) < (lr.height ?? 0) / 2 || Math.abs(dr) == (lr.height ?? 0) / 2 && Math.abs(ur.x - (lr.x ?? 0)) > (lr.width ?? 0) / 2 - yr)) {
+			let fr = yr * yr * (1 - dr * dr / (vr * vr));
+			fr != 0 && (fr = Math.sqrt(Math.abs(fr))), fr = yr - fr, te.x - (lr.x ?? 0) > 0 && (fr = -fr), ur.x += fr;
+		}
+		return ur;
+	}, fr;
+}
+__name(tiltedCylinder, "tiltedCylinder");
+async function trapezoid(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = pr.width + lr.padding, hr = pr.height + lr.padding, gr = [
+		{
+			x: -3 * hr / 6,
+			y: 0
+		},
+		{
+			x: mr + 3 * hr / 6,
+			y: 0
+		},
+		{
+			x: mr,
+			y: -hr
+		},
+		{
+			x: 0,
+			y: -hr
+		}
+	], _r, { cssStyles: vr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(fr), ur = userNodeOverrides(lr, {}), dr = createPathFromPoints(gr), pr = te.path(dr, ur);
+		_r = fr.insert(() => pr, ":first-child").attr("transform", `translate(${-mr / 2}, ${hr / 2})`), vr && _r.attr("style", vr);
+	} else _r = insertPolygonShape(fr, mr, hr, gr);
+	return dr && _r.attr("style", dr), lr.width = mr, lr.height = hr, updateNodeBounds(lr, _r), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, gr, te);
+	}, fr;
+}
+__name(trapezoid, "trapezoid");
+async function trapezoidalPentagon(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(60, pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), hr = Math.max(20, pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), { cssStyles: gr } = lr, _r = at.svg(fr), vr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (vr.roughness = 0, vr.fillStyle = "solid");
+	let yr = [
+		{
+			x: -mr / 2 * .8,
+			y: -hr / 2
+		},
+		{
+			x: mr / 2 * .8,
+			y: -hr / 2
+		},
+		{
+			x: mr / 2,
+			y: -hr / 2 * .6
+		},
+		{
+			x: mr / 2,
+			y: hr / 2
+		},
+		{
+			x: -mr / 2,
+			y: hr / 2
+		},
+		{
+			x: -mr / 2,
+			y: -hr / 2 * .6
+		}
+	], br = createPathFromPoints(yr), xr = _r.path(br, vr), Sr = fr.insert(() => xr, ":first-child");
+	return Sr.attr("class", "basic label-container"), gr && lr.look !== "handDrawn" && Sr.selectChildren("path").attr("style", gr), dr && lr.look !== "handDrawn" && Sr.selectChildren("path").attr("style", dr), updateNodeBounds(lr, Sr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, yr, te);
+	}, fr;
+}
+__name(trapezoidalPentagon, "trapezoidalPentagon");
+async function triangle(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr, label: hr } = await labelHelper(lr, ur, getNodeClasses(ur)), _r = evaluate(getConfig2().flowchart?.htmlLabels), yr = mr.width + (ur.padding ?? 0), br = yr + mr.height, xr = yr + mr.height, Sr = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: xr,
+			y: 0
+		},
+		{
+			x: xr / 2,
+			y: -br
+		}
+	], { cssStyles: Cr } = ur, wr = at.svg(pr), Tr = userNodeOverrides(ur, {});
+	ur.look !== "handDrawn" && (Tr.roughness = 0, Tr.fillStyle = "solid");
+	let Er = createPathFromPoints(Sr), Dr = wr.path(Er, Tr), Ar = pr.insert(() => Dr, ":first-child").attr("transform", `translate(${-br / 2}, ${br / 2})`);
+	return Cr && ur.look !== "handDrawn" && Ar.selectChildren("path").attr("style", Cr), fr && ur.look !== "handDrawn" && Ar.selectChildren("path").attr("style", fr), ur.width = yr, ur.height = br, updateNodeBounds(ur, Ar), hr.attr("transform", `translate(${-mr.width / 2 - (mr.x - (mr.left ?? 0))}, ${br / 2 - (mr.height + (ur.padding ?? 0) / (_r ? 2 : 1) - (mr.y - (mr.top ?? 0)))})`), ur.intersect = function(lr) {
+		return log.info("Triangle intersect", ur, Sr, lr), intersect_default.polygon(ur, Sr, lr);
+	}, pr;
+}
+__name(triangle, "triangle");
+async function waveEdgedRectangle(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = gr / 8, vr = gr + _r, { cssStyles: yr } = lr, br = 70 - hr, xr = br > 0 ? br / 2 : 0, Sr = at.svg(fr), Cr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Cr.roughness = 0, Cr.fillStyle = "solid");
+	let wr = [
+		{
+			x: -hr / 2 - xr,
+			y: vr / 2
+		},
+		...generateFullSineWavePoints(-hr / 2 - xr, vr / 2, hr / 2 + xr, vr / 2, _r, .8),
+		{
+			x: hr / 2 + xr,
+			y: -vr / 2
+		},
+		{
+			x: -hr / 2 - xr,
+			y: -vr / 2
+		}
+	], Tr = createPathFromPoints(wr), Er = Sr.path(Tr, Cr), Dr = fr.insert(() => Er, ":first-child");
+	return Dr.attr("class", "basic label-container"), yr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", yr), dr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", dr), Dr.attr("transform", `translate(0,${-_r / 2})`), mr.attr("transform", `translate(${-hr / 2 + (lr.padding ?? 0) - (pr.x - (pr.left ?? 0))},${-gr / 2 + (lr.padding ?? 0) - _r - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Dr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, wr, te);
+	}, fr;
+}
+__name(waveEdgedRectangle, "waveEdgedRectangle");
+async function waveRectangle(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr } = await labelHelper(te, lr, getNodeClasses(lr)), mr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), hr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), gr = mr / hr, _r = mr, vr = hr;
+	_r > vr * gr ? vr = _r / gr : _r = vr * gr, _r = Math.max(_r, 100), vr = Math.max(vr, 50);
+	let yr = Math.min(vr * .2, vr / 4), br = vr + yr * 2, { cssStyles: xr } = lr, Sr = at.svg(fr), Cr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Cr.roughness = 0, Cr.fillStyle = "solid");
+	let wr = [
+		{
+			x: -_r / 2,
+			y: br / 2
+		},
+		...generateFullSineWavePoints(-_r / 2, br / 2, _r / 2, br / 2, yr, 1),
+		{
+			x: _r / 2,
+			y: -br / 2
+		},
+		...generateFullSineWavePoints(_r / 2, -br / 2, -_r / 2, -br / 2, yr, -1)
+	], Tr = createPathFromPoints(wr), Er = Sr.path(Tr, Cr), Dr = fr.insert(() => Er, ":first-child");
+	return Dr.attr("class", "basic label-container"), xr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", xr), dr && lr.look !== "handDrawn" && Dr.selectAll("path").attr("style", dr), updateNodeBounds(lr, Dr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, wr, te);
+	}, fr;
+}
+__name(waveRectangle, "waveRectangle");
+async function windowPane(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, label: mr } = await labelHelper(te, lr, getNodeClasses(lr)), hr = Math.max(pr.width + (lr.padding ?? 0) * 2, lr?.width ?? 0), gr = Math.max(pr.height + (lr.padding ?? 0) * 2, lr?.height ?? 0), _r = -hr / 2, vr = -gr / 2, { cssStyles: yr } = lr, br = at.svg(fr), xr = userNodeOverrides(lr, {}), Sr = [
+		{
+			x: _r - 5,
+			y: vr - 5
+		},
+		{
+			x: _r - 5,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr + gr
+		},
+		{
+			x: _r + hr,
+			y: vr - 5
+		}
+	], Cr = `M${_r - 5},${vr - 5} L${_r + hr},${vr - 5} L${_r + hr},${vr + gr} L${_r - 5},${vr + gr} L${_r - 5},${vr - 5}
+                M${_r - 5},${vr} L${_r + hr},${vr}
+                M${_r},${vr - 5} L${_r},${vr + gr}`;
+	lr.look !== "handDrawn" && (xr.roughness = 0, xr.fillStyle = "solid");
+	let wr = br.path(Cr, xr), Tr = fr.insert(() => wr, ":first-child");
+	return Tr.attr("transform", `translate(${5 / 2}, ${5 / 2})`), Tr.attr("class", "basic label-container"), yr && lr.look !== "handDrawn" && Tr.selectAll("path").attr("style", yr), dr && lr.look !== "handDrawn" && Tr.selectAll("path").attr("style", dr), mr.attr("transform", `translate(${-(pr.width / 2) + 5 / 2 - (pr.x - (pr.left ?? 0))}, ${-(pr.height / 2) + 5 / 2 - (pr.y - (pr.top ?? 0))})`), updateNodeBounds(lr, Tr), lr.intersect = function(te) {
+		return intersect_default.polygon(lr, Sr, te);
+	}, fr;
+}
+__name(windowPane, "windowPane");
+async function erBox(te, lr) {
+	let dr = lr;
+	if (dr.alias && (lr.label = dr.alias), lr.look === "handDrawn") {
+		let { themeVariables: ur } = getConfig(), { background: dr } = ur;
+		await erBox(te, {
+			...lr,
+			id: lr.id + "-background",
+			look: "default",
+			cssStyles: ["stroke: none", `fill: ${dr}`]
+		});
+	}
+	let fr = getConfig();
+	lr.useHtmlLabels = fr.htmlLabels;
+	let pr = fr.er?.diagramPadding ?? 10, mr = fr.er?.entityPadding ?? 6, { cssStyles: hr } = lr, { labelStyles: gr, nodeStyles: _r } = styles2String(lr);
+	if (dr.attributes.length === 0 && lr.label) {
+		let ur = {
+			rx: 0,
+			ry: 0,
+			labelPaddingX: pr,
+			labelPaddingY: pr * 1.5,
+			classes: ""
+		};
+		calculateTextWidth(lr.label, fr) + ur.labelPaddingX * 2 < fr.er.minEntityWidth && (lr.width = fr.er.minEntityWidth);
+		let dr = await drawRect(te, lr, ur);
+		if (!evaluate(fr.htmlLabels)) {
+			let te = dr.select("text"), lr = te.node()?.getBBox();
+			te.attr("transform", `translate(${-lr.width / 2}, 0)`);
+		}
+		return dr;
+	}
+	fr.htmlLabels || (pr *= 1.25, mr *= 1.25);
+	let yr = getNodeClasses(lr);
+	yr ||= "node default";
+	let xr = te.insert("g").attr("class", yr).attr("id", lr.domId || lr.id), Sr = await addText(xr, lr.label ?? "", fr, 0, 0, ["name"], gr);
+	Sr.height += mr;
+	let wr = 0, Tr = [], Er = [], Dr = 0, Ar = 0, jr = 0, Mr = 0, Nr = !0, Pr = !0;
+	for (let te of dr.attributes) {
+		let lr = await addText(xr, te.type, fr, 0, wr, ["attribute-type"], gr);
+		Dr = Math.max(Dr, lr.width + pr);
+		let ur = await addText(xr, te.name, fr, 0, wr, ["attribute-name"], gr);
+		Ar = Math.max(Ar, ur.width + pr);
+		let dr = await addText(xr, te.keys.join(), fr, 0, wr, ["attribute-keys"], gr);
+		jr = Math.max(jr, dr.width + pr);
+		let hr = await addText(xr, te.comment, fr, 0, wr, ["attribute-comment"], gr);
+		Mr = Math.max(Mr, hr.width + pr);
+		let _r = Math.max(lr.height, ur.height, dr.height, hr.height) + mr;
+		Er.push({
+			yOffset: wr,
+			rowHeight: _r
+		}), wr += _r;
+	}
+	let Fr = 4;
+	jr <= pr && (Nr = !1, jr = 0, Fr--), Mr <= pr && (Pr = !1, Mr = 0, Fr--);
+	let Ir = xr.node().getBBox();
+	if (Sr.width + pr * 2 - (Dr + Ar + jr + Mr) > 0) {
+		let te = Sr.width + pr * 2 - (Dr + Ar + jr + Mr);
+		Dr += te / Fr, Ar += te / Fr, jr > 0 && (jr += te / Fr), Mr > 0 && (Mr += te / Fr);
+	}
+	let Lr = Dr + Ar + jr + Mr, Rr = at.svg(xr), zr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (zr.roughness = 0, zr.fillStyle = "solid");
+	let Br = 0;
+	Er.length > 0 && (Br = Er.reduce((te, lr) => te + (lr?.rowHeight ?? 0), 0));
+	let Vr = Math.max(Ir.width + pr * 2, lr?.width || 0, Lr), Hr = Math.max((Br ?? 0) + Sr.height, lr?.height || 0), Ur = -Vr / 2, Wr = -Hr / 2;
+	xr.selectAll("g:not(:first-child)").each((te, lr, dr) => {
+		let fr = select_default(dr[lr]), hr = fr.attr("transform"), gr = 0, _r = 0;
+		if (hr) {
+			let te = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(hr);
+			te && (gr = parseFloat(te[1]), _r = parseFloat(te[2]), fr.attr("class").includes("attribute-name") ? gr += Dr : fr.attr("class").includes("attribute-keys") ? gr += Dr + Ar : fr.attr("class").includes("attribute-comment") && (gr += Dr + Ar + jr));
+		}
+		fr.attr("transform", `translate(${Ur + pr / 2 + gr}, ${_r + Wr + Sr.height + mr / 2})`);
+	}), xr.select(".name").attr("transform", "translate(" + -Sr.width / 2 + ", " + (Wr + mr / 2) + ")");
+	let Gr = Rr.rectangle(Ur, Wr, Vr, Hr, zr), Kr = xr.insert(() => Gr, ":first-child").attr("style", hr.join("")), { themeVariables: qr } = getConfig(), { rowEven: Jr, rowOdd: Yr, nodeBorder: Xr } = qr;
+	Tr.push(0);
+	for (let [te, lr] of Er.entries()) {
+		let ur = (te + 1) % 2 == 0 && lr.yOffset !== 0, dr = Rr.rectangle(Ur, Sr.height + Wr + lr?.yOffset, Vr, lr?.rowHeight, {
+			...zr,
+			fill: ur ? Jr : Yr,
+			stroke: Xr
+		});
+		xr.insert(() => dr, "g.label").attr("style", hr.join("")).attr("class", `row-rect-${ur ? "even" : "odd"}`);
+	}
+	let Zr = Rr.line(Ur, Sr.height + Wr, Vr + Ur, Sr.height + Wr, zr);
+	xr.insert(() => Zr).attr("class", "divider"), Zr = Rr.line(Dr + Ur, Sr.height + Wr, Dr + Ur, Hr + Wr, zr), xr.insert(() => Zr).attr("class", "divider"), Nr && (Zr = Rr.line(Dr + Ar + Ur, Sr.height + Wr, Dr + Ar + Ur, Hr + Wr, zr), xr.insert(() => Zr).attr("class", "divider")), Pr && (Zr = Rr.line(Dr + Ar + jr + Ur, Sr.height + Wr, Dr + Ar + jr + Ur, Hr + Wr, zr), xr.insert(() => Zr).attr("class", "divider"));
+	for (let te of Tr) Zr = Rr.line(Ur, Sr.height + Wr + te, Vr + Ur, Sr.height + Wr + te, zr), xr.insert(() => Zr).attr("class", "divider");
+	if (updateNodeBounds(lr, Kr), _r && lr.look !== "handDrawn") {
+		let te = _r.split(";")?.filter((te) => te.includes("stroke"))?.map((te) => `${te}`).join("; ");
+		xr.selectAll("path").attr("style", te ?? ""), xr.selectAll(".row-rect-even path").attr("style", _r);
+	}
+	return lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, xr;
+}
+__name(erBox, "erBox");
+async function addText(te, lr, fr, pr = 0, mr = 0, hr = [], gr = "") {
+	let _r = te.insert("g").attr("class", `label ${hr.join(" ")}`).attr("transform", `translate(${pr}, ${mr})`).attr("style", gr);
+	lr !== parseGenericTypes(lr) && (lr = parseGenericTypes(lr), lr = lr.replaceAll("<", "&lt;").replaceAll(">", "&gt;"));
+	let yr = _r.node().appendChild(await createText(_r, lr, {
+		width: calculateTextWidth(lr, fr) + 100,
+		style: gr,
+		useHtmlLabels: fr.htmlLabels
+	}, fr));
+	if (lr.includes("&lt;") || lr.includes("&gt;")) {
+		let te = yr.children[0];
+		for (te.textContent = te.textContent.replaceAll("&lt;", "<").replaceAll("&gt;", ">"); te.childNodes[0];) te = te.childNodes[0], te.textContent = te.textContent.replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+	}
+	let br = yr.getBBox();
+	if (evaluate(fr.htmlLabels)) {
+		let te = yr.children[0];
+		te.style.textAlign = "start";
+		let lr = select_default(yr);
+		br = te.getBoundingClientRect(), lr.attr("width", br.width), lr.attr("height", br.height);
+	}
+	return br;
+}
+__name(addText, "addText");
+async function textHelper(te, lr, ur, dr, fr = ur.class.padding ?? 12) {
+	let pr = dr ? 0 : 3, mr = te.insert("g").attr("class", getNodeClasses(lr)).attr("id", lr.domId || lr.id), hr = null, gr = null, _r = null, vr = null, yr = 0, br = 0, xr = 0;
+	if (hr = mr.insert("g").attr("class", "annotation-group text"), lr.annotations.length > 0) {
+		let te = lr.annotations[0];
+		await addText2(hr, { text: `\xAB${te}\xBB` }, 0), yr = hr.node().getBBox().height;
+	}
+	gr = mr.insert("g").attr("class", "label-group text"), await addText2(gr, lr, 0, ["font-weight: bolder"]);
+	let Sr = gr.node().getBBox();
+	br = Sr.height, _r = mr.insert("g").attr("class", "members-group text");
+	let Cr = 0;
+	for (let te of lr.members) {
+		let lr = await addText2(_r, te, Cr, [te.parseClassifier()]);
+		Cr += lr + pr;
+	}
+	xr = _r.node().getBBox().height, xr <= 0 && (xr = fr / 2), vr = mr.insert("g").attr("class", "methods-group text");
+	let wr = 0;
+	for (let te of lr.methods) {
+		let lr = await addText2(vr, te, wr, [te.parseClassifier()]);
+		wr += lr + pr;
+	}
+	let Tr = mr.node().getBBox();
+	if (hr !== null) {
+		let te = hr.node().getBBox();
+		hr.attr("transform", `translate(${-te.width / 2})`);
+	}
+	return gr.attr("transform", `translate(${-Sr.width / 2}, ${yr})`), Tr = mr.node().getBBox(), _r.attr("transform", `translate(0, ${yr + br + fr * 2})`), Tr = mr.node().getBBox(), vr.attr("transform", `translate(0, ${yr + br + (xr ? xr + fr * 4 : fr * 2)})`), Tr = mr.node().getBBox(), {
+		shapeSvg: mr,
+		bbox: Tr
+	};
+}
+__name(textHelper, "textHelper");
+async function addText2(te, dr, fr, mr = []) {
+	let gr = te.insert("g").attr("class", "label").attr("style", mr.join("; ")), _r = getConfig(), yr = "useHtmlLabels" in dr ? dr.useHtmlLabels : evaluate(_r.htmlLabels) ?? !0, Sr = "";
+	Sr = "text" in dr ? dr.text : dr.label, !yr && Sr.startsWith("\\") && (Sr = Sr.substring(1)), hasKatex(Sr) && (yr = !0);
+	let wr = await createText(gr, sanitizeText3(decodeEntities(Sr)), {
+		width: calculateTextWidth(Sr, _r) + 50,
+		classes: "markdown-node-label",
+		useHtmlLabels: yr
+	}, _r), Er, Dr = 1;
+	if (yr) {
+		let te = wr.children[0], dr = select_default(wr);
+		Dr = te.innerHTML.split("<br>").length, te.innerHTML.includes("</math>") && (Dr += te.innerHTML.split("<mrow>").length - 1);
+		let fr = te.getElementsByTagName("img");
+		if (fr) {
+			let te = Sr.replace(/<img[^>]*>/g, "").trim() === "";
+			await Promise.all([...fr].map((ur) => new Promise((dr) => {
+				function fr() {
+					if (ur.style.display = "flex", ur.style.flexDirection = "column", te) {
+						let te = _r.fontSize?.toString() ?? window.getComputedStyle(document.body).fontSize, lr = parseInt(te, 10) * 5 + "px";
+						ur.style.minWidth = lr, ur.style.maxWidth = lr;
+					} else ur.style.width = "100%";
+					dr(ur);
+				}
+				__name(fr, "setupImage"), setTimeout(() => {
+					ur.complete && fr();
+				}), ur.addEventListener("error", fr), ur.addEventListener("load", fr);
+			})));
+		}
+		Er = te.getBoundingClientRect(), dr.attr("width", Er.width), dr.attr("height", Er.height);
+	} else {
+		mr.includes("font-weight: bolder") && select_default(wr).selectAll("tspan").attr("font-weight", ""), Dr = wr.children.length;
+		let te = wr.children[0];
+		(wr.textContent === "" || wr.textContent.includes("&gt")) && (te.textContent = Sr[0] + Sr.substring(1).replaceAll("&gt;", ">").replaceAll("&lt;", "<").trim(), Sr[1] === " " && (te.textContent = te.textContent[0] + " " + te.textContent.substring(1))), te.textContent === "undefined" && (te.textContent = ""), Er = wr.getBBox();
+	}
+	return gr.attr("transform", "translate(0," + (-Er.height / (2 * Dr) + fr) + ")"), Er.height;
+}
+__name(addText2, "addText");
+async function classBox(te, lr) {
+	let dr = getConfig2(), fr = dr.class.padding ?? 12, pr = fr, mr = lr.useHtmlLabels ?? evaluate(dr.htmlLabels) ?? !0, hr = lr;
+	hr.annotations = hr.annotations ?? [], hr.members = hr.members ?? [], hr.methods = hr.methods ?? [];
+	let { shapeSvg: _r, bbox: yr } = await textHelper(te, lr, dr, mr, pr), { labelStyles: br, nodeStyles: xr } = styles2String(lr);
+	lr.labelStyle = br, lr.cssStyles = hr.styles || "";
+	let Sr = hr.styles?.join(";") || xr || "";
+	lr.cssStyles ||= Sr.replaceAll("!important", "").split(";");
+	let Cr = hr.members.length === 0 && hr.methods.length === 0 && !dr.class?.hideEmptyMembersBox, wr = at.svg(_r), Tr = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Tr.roughness = 0, Tr.fillStyle = "solid");
+	let Er = yr.width, Dr = yr.height;
+	hr.members.length === 0 && hr.methods.length === 0 ? Dr += pr : hr.members.length > 0 && hr.methods.length === 0 && (Dr += pr * 2);
+	let Ar = -Er / 2, jr = -Dr / 2, Mr = wr.rectangle(Ar - fr, jr - fr - (Cr ? fr : hr.members.length === 0 && hr.methods.length === 0 ? -fr / 2 : 0), Er + 2 * fr, Dr + 2 * fr + (Cr ? fr * 2 : hr.members.length === 0 && hr.methods.length === 0 ? -fr : 0), Tr), Nr = _r.insert(() => Mr, ":first-child");
+	Nr.attr("class", "basic label-container");
+	let Pr = Nr.node().getBBox();
+	_r.selectAll(".text").each((te, lr, dr) => {
+		let pr = select_default(dr[lr]), gr = pr.attr("transform"), vr = 0;
+		if (gr) {
+			let te = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(gr);
+			te && (vr = parseFloat(te[2]));
+		}
+		let yr = vr + jr + fr - (Cr ? fr : hr.members.length === 0 && hr.methods.length === 0 ? -fr / 2 : 0);
+		mr || (yr -= 4);
+		let br = Ar;
+		(pr.attr("class").includes("label-group") || pr.attr("class").includes("annotation-group")) && (br = -pr.node()?.getBBox().width / 2 || 0, _r.selectAll("text").each(function(te, lr, ur) {
+			window.getComputedStyle(ur[lr]).textAnchor === "middle" && (br = 0);
+		})), pr.attr("transform", `translate(${br}, ${yr})`);
+	});
+	let Fr = _r.select(".annotation-group").node().getBBox().height - (Cr ? fr / 2 : 0) || 0, Ir = _r.select(".label-group").node().getBBox().height - (Cr ? fr / 2 : 0) || 0, Lr = _r.select(".members-group").node().getBBox().height - (Cr ? fr / 2 : 0) || 0;
+	if (hr.members.length > 0 || hr.methods.length > 0 || Cr) {
+		let te = wr.line(Pr.x, Fr + Ir + jr + fr, Pr.x + Pr.width, Fr + Ir + jr + fr, Tr);
+		_r.insert(() => te).attr("class", "divider").attr("style", Sr);
+	}
+	if (Cr || hr.members.length > 0 || hr.methods.length > 0) {
+		let te = wr.line(Pr.x, Fr + Ir + Lr + jr + pr * 2 + fr, Pr.x + Pr.width, Fr + Ir + Lr + jr + fr + pr * 2, Tr);
+		_r.insert(() => te).attr("class", "divider").attr("style", Sr);
+	}
+	if (hr.look !== "handDrawn" && _r.selectAll("path").attr("style", Sr), Nr.select(":nth-child(2)").attr("style", Sr), _r.selectAll(".divider").select("path").attr("style", Sr), lr.labelStyle ? _r.selectAll("span").attr("style", lr.labelStyle) : _r.selectAll("span").attr("style", Sr), !mr) {
+		let te = RegExp(/color\s*:\s*([^;]*)/), lr = te.exec(Sr);
+		if (lr) {
+			let te = lr[0].replace("color", "fill");
+			_r.selectAll("tspan").attr("style", te);
+		} else if (br) {
+			let lr = te.exec(br);
+			if (lr) {
+				let te = lr[0].replace("color", "fill");
+				_r.selectAll("tspan").attr("style", te);
+			}
+		}
+	}
+	return updateNodeBounds(lr, Nr), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, _r;
+}
+__name(classBox, "classBox");
+async function requirementBox(te, lr) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(lr);
+	lr.labelStyle = dr;
+	let pr = lr, mr = lr, hr = "verifyMethod" in lr, gr = getNodeClasses(lr), _r = te.insert("g").attr("class", gr).attr("id", lr.domId ?? lr.id), vr;
+	vr = hr ? await addText3(_r, `&lt;&lt;${pr.type}&gt;&gt;`, 0, lr.labelStyle) : await addText3(_r, "&lt;&lt;Element&gt;&gt;", 0, lr.labelStyle);
+	let yr = vr, br = await addText3(_r, pr.name, yr, lr.labelStyle + "; font-weight: bold;");
+	if (yr += br + 20, hr) {
+		let te = await addText3(_r, `${pr.requirementId ? `ID: ${pr.requirementId}` : ""}`, yr, lr.labelStyle);
+		yr += te;
+		let ur = await addText3(_r, `${pr.text ? `Text: ${pr.text}` : ""}`, yr, lr.labelStyle);
+		yr += ur;
+		let dr = await addText3(_r, `${pr.risk ? `Risk: ${pr.risk}` : ""}`, yr, lr.labelStyle);
+		yr += dr, await addText3(_r, `${pr.verifyMethod ? `Verification: ${pr.verifyMethod}` : ""}`, yr, lr.labelStyle);
+	} else {
+		let te = await addText3(_r, `${mr.type ? `Type: ${mr.type}` : ""}`, yr, lr.labelStyle);
+		yr += te, await addText3(_r, `${mr.docRef ? `Doc Ref: ${mr.docRef}` : ""}`, yr, lr.labelStyle);
+	}
+	let xr = (_r.node()?.getBBox().width ?? 200) + 20, Sr = (_r.node()?.getBBox().height ?? 200) + 20, Cr = -xr / 2, wr = -Sr / 2, Tr = at.svg(_r), Er = userNodeOverrides(lr, {});
+	lr.look !== "handDrawn" && (Er.roughness = 0, Er.fillStyle = "solid");
+	let Dr = Tr.rectangle(Cr, wr, xr, Sr, Er), Ar = _r.insert(() => Dr, ":first-child");
+	if (Ar.attr("class", "basic label-container").attr("style", fr), _r.selectAll(".label").each((te, lr, dr) => {
+		let fr = select_default(dr[lr]), pr = fr.attr("transform"), mr = 0, hr = 0;
+		if (pr) {
+			let te = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(pr);
+			te && (mr = parseFloat(te[1]), hr = parseFloat(te[2]));
+		}
+		let gr = hr - Sr / 2, _r = Cr + 20 / 2;
+		(lr === 0 || lr === 1) && (_r = mr), fr.attr("transform", `translate(${_r}, ${gr + 20})`);
+	}), yr > vr + br + 20) {
+		let te = Tr.line(Cr, wr + vr + br + 20, Cr + xr, wr + vr + br + 20, Er);
+		_r.insert(() => te).attr("style", fr);
+	}
+	return updateNodeBounds(lr, Ar), lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, _r;
+}
+__name(requirementBox, "requirementBox");
+async function addText3(te, lr, dr, fr = "") {
+	if (lr === "") return 0;
+	let mr = te.insert("g").attr("class", "label").attr("style", fr), hr = getConfig2(), _r = hr.htmlLabels ?? !0, vr = await createText(mr, sanitizeText3(decodeEntities(lr)), {
+		width: calculateTextWidth(lr, hr) + 50,
+		classes: "markdown-node-label",
+		useHtmlLabels: _r,
+		style: fr
+	}, hr), yr;
+	if (_r) {
+		let te = vr.children[0], lr = select_default(vr);
+		yr = te.getBoundingClientRect(), lr.attr("width", yr.width), lr.attr("height", yr.height);
+	} else {
+		let te = vr.children[0];
+		for (let lr of te.children) lr.textContent = lr.textContent.replaceAll("&gt;", ">").replaceAll("&lt;", "<"), fr && lr.setAttribute("style", fr);
+		yr = vr.getBBox(), yr.height += 6;
+	}
+	return mr.attr("transform", `translate(${-yr.width / 2},${-yr.height / 2 + dr})`), yr.height;
+}
+__name(addText3, "addText");
+var colorFromPriority = /* @__PURE__ */ __name((te) => {
+	switch (te) {
+		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(te, lr, { config: ur }) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(lr);
+	lr.labelStyle = dr || "";
+	let pr = lr.width;
+	lr.width = (lr.width ?? 200) - 10;
+	let { shapeSvg: mr, bbox: hr, label: gr } = await labelHelper(te, lr, getNodeClasses(lr)), _r = lr.padding || 10, vr = "", yr;
+	"ticket" in lr && lr.ticket && ur?.kanban?.ticketBaseUrl && (vr = ur?.kanban?.ticketBaseUrl.replace("#TICKET#", lr.ticket), yr = mr.insert("svg:a", ":first-child").attr("class", "kanban-ticket-link").attr("xlink:href", vr).attr("target", "_blank"));
+	let br = {
+		useHtmlLabels: lr.useHtmlLabels,
+		labelStyle: lr.labelStyle || "",
+		width: lr.width,
+		img: lr.img,
+		padding: lr.padding || 8,
+		centerLabel: !1
+	}, xr, Sr;
+	yr ? {label: xr, bbox: Sr} = await insertLabel(yr, "ticket" in lr && lr.ticket || "", br) : {label: xr, bbox: Sr} = await insertLabel(mr, "ticket" in lr && lr.ticket || "", br);
+	let { label: Cr, bbox: wr } = await insertLabel(mr, "assigned" in lr && lr.assigned || "", br);
+	lr.width = pr;
+	let Tr = lr?.width || 0, Er = Math.max(Sr.height, wr.height) / 2, Dr = Math.max(hr.height + 20, lr?.height || 0) + Er, Ar = -Tr / 2, jr = -Dr / 2;
+	gr.attr("transform", "translate(" + (_r - Tr / 2) + ", " + (-Er - hr.height / 2) + ")"), xr.attr("transform", "translate(" + (_r - Tr / 2) + ", " + (-Er + hr.height / 2) + ")"), Cr.attr("transform", "translate(" + (_r + Tr / 2 - wr.width - 20) + ", " + (-Er + hr.height / 2) + ")");
+	let Mr, { rx: Nr, ry: Pr } = lr, { cssStyles: Fr } = lr;
+	if (lr.look === "handDrawn") {
+		let te = at.svg(mr), ur = userNodeOverrides(lr, {}), dr = Nr || Pr ? te.path(createRoundedRectPathD(Ar, jr, Tr, Dr, Nr || 0), ur) : te.rectangle(Ar, jr, Tr, Dr, ur);
+		Mr = mr.insert(() => dr, ":first-child"), Mr.attr("class", "basic label-container").attr("style", Fr || null);
+	} else {
+		Mr = mr.insert("rect", ":first-child"), Mr.attr("class", "basic label-container __APA__").attr("style", fr).attr("rx", Nr ?? 5).attr("ry", Pr ?? 5).attr("x", Ar).attr("y", jr).attr("width", Tr).attr("height", Dr);
+		let te = "priority" in lr && lr.priority;
+		if (te) {
+			let lr = mr.append("line"), ur = Ar + 2, dr = jr + Math.floor((Nr ?? 0) / 2), fr = jr + Dr - Math.floor((Nr ?? 0) / 2);
+			lr.attr("x1", ur).attr("y1", dr).attr("x2", ur).attr("y2", fr).attr("stroke-width", "4").attr("stroke", colorFromPriority(te));
+		}
+	}
+	return updateNodeBounds(lr, Mr), lr.height = Dr, lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, mr;
+}
+__name(kanbanItem, "kanbanItem");
+async function bang(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr, halfPadding: hr, label: gr } = await labelHelper(lr, ur, getNodeClasses(ur)), _r = mr.width + 10 * hr, vr = mr.height + 8 * hr, yr = .15 * _r, { cssStyles: br } = ur, xr = mr.width + 20, Sr = mr.height + 20, Cr = Math.max(_r, xr), Tr = Math.max(vr, Sr);
+	gr.attr("transform", `translate(${-mr.width / 2}, ${-mr.height / 2})`);
+	let Er, Dr = `M0 0 
+    a${yr},${yr} 1 0,0 ${Cr * .25},${-1 * Tr * .1}
+    a${yr},${yr} 1 0,0 ${Cr * .25},0
+    a${yr},${yr} 1 0,0 ${Cr * .25},0
+    a${yr},${yr} 1 0,0 ${Cr * .25},${Tr * .1}
+
+    a${yr},${yr} 1 0,0 ${Cr * .15},${Tr * .33}
+    a${yr * .8},${yr * .8} 1 0,0 0,${Tr * .34}
+    a${yr},${yr} 1 0,0 ${-1 * Cr * .15},${Tr * .33}
+
+    a${yr},${yr} 1 0,0 ${-1 * Cr * .25},${Tr * .15}
+    a${yr},${yr} 1 0,0 ${-1 * Cr * .25},0
+    a${yr},${yr} 1 0,0 ${-1 * Cr * .25},0
+    a${yr},${yr} 1 0,0 ${-1 * Cr * .25},${-1 * Tr * .15}
+
+    a${yr},${yr} 1 0,0 ${-1 * Cr * .1},${-1 * Tr * .33}
+    a${yr * .8},${yr * .8} 1 0,0 0,${-1 * Tr * .34}
+    a${yr},${yr} 1 0,0 ${Cr * .1},${-1 * Tr * .33}
+  H0 V0 Z`;
+	if (ur.look === "handDrawn") {
+		let te = at.svg(pr), lr = userNodeOverrides(ur, {}), dr = te.path(Dr, lr);
+		Er = pr.insert(() => dr, ":first-child"), Er.attr("class", "basic label-container").attr("style", handleUndefinedAttr(br));
+	} else Er = pr.insert("path", ":first-child").attr("class", "basic label-container").attr("style", fr).attr("d", Dr);
+	return Er.attr("transform", `translate(${-Cr / 2}, ${-Tr / 2})`), updateNodeBounds(ur, Er), ur.calcIntersect = function(te, lr) {
+		return intersect_default.rect(te, lr);
+	}, ur.intersect = function(lr) {
+		return log.info("Bang intersect", ur, lr), intersect_default.rect(ur, lr);
+	}, pr;
+}
+__name(bang, "bang");
+async function cloud(lr, ur) {
+	let { labelStyles: dr, nodeStyles: fr } = styles2String(ur);
+	ur.labelStyle = dr;
+	let { shapeSvg: pr, bbox: mr, halfPadding: hr, label: gr } = await labelHelper(lr, ur, getNodeClasses(ur)), _r = mr.width + 2 * hr, vr = mr.height + 2 * hr, yr = .15 * _r, br = .25 * _r, xr = .35 * _r, Sr = .2 * _r, { cssStyles: Cr } = ur, Tr, Er = `M0 0 
+    a${yr},${yr} 0 0,1 ${_r * .25},${-1 * _r * .1}
+    a${xr},${xr} 1 0,1 ${_r * .4},${-1 * _r * .1}
+    a${br},${br} 1 0,1 ${_r * .35},${_r * .2}
+
+    a${yr},${yr} 1 0,1 ${_r * .15},${vr * .35}
+    a${Sr},${Sr} 1 0,1 ${-1 * _r * .15},${vr * .65}
+
+    a${br},${yr} 1 0,1 ${-1 * _r * .25},${_r * .15}
+    a${xr},${xr} 1 0,1 ${-1 * _r * .5},0
+    a${yr},${yr} 1 0,1 ${-1 * _r * .25},${-1 * _r * .15}
+
+    a${yr},${yr} 1 0,1 ${-1 * _r * .1},${-1 * vr * .35}
+    a${Sr},${Sr} 1 0,1 ${_r * .1},${-1 * vr * .65}
+  H0 V0 Z`;
+	if (ur.look === "handDrawn") {
+		let te = at.svg(pr), lr = userNodeOverrides(ur, {}), dr = te.path(Er, lr);
+		Tr = pr.insert(() => dr, ":first-child"), Tr.attr("class", "basic label-container").attr("style", handleUndefinedAttr(Cr));
+	} else Tr = pr.insert("path", ":first-child").attr("class", "basic label-container").attr("style", fr).attr("d", Er);
+	return gr.attr("transform", `translate(${-mr.width / 2}, ${-mr.height / 2})`), Tr.attr("transform", `translate(${-_r / 2}, ${-vr / 2})`), updateNodeBounds(ur, Tr), ur.calcIntersect = function(te, lr) {
+		return intersect_default.rect(te, lr);
+	}, ur.intersect = function(lr) {
+		return log.info("Cloud intersect", ur, lr), intersect_default.rect(ur, lr);
+	}, pr;
+}
+__name(cloud, "cloud");
+async function defaultMindmapNode(te, lr) {
+	let { labelStyles: ur, nodeStyles: dr } = styles2String(lr);
+	lr.labelStyle = ur;
+	let { shapeSvg: fr, bbox: pr, halfPadding: mr, label: hr } = await labelHelper(te, lr, getNodeClasses(lr)), gr = pr.width + 8 * mr, _r = pr.height + 2 * mr, vr = `
+    M${-gr / 2} ${_r / 2 - 5}
+    v${-_r + 10}
+    q0,-5 5,-5
+    h${gr - 10}
+    q5,0 5,5
+    v${_r - 10}
+    q0,5 -5,5
+    h${-gr + 10}
+    q-5,0 -5,-5
+    Z
+  `, yr = fr.append("path").attr("id", "node-" + lr.id).attr("class", "node-bkg node-" + lr.type).attr("style", dr).attr("d", vr);
+	return fr.append("line").attr("class", "node-line-").attr("x1", -gr / 2).attr("y1", _r / 2).attr("x2", gr / 2).attr("y2", _r / 2), hr.attr("transform", `translate(${-pr.width / 2}, ${-pr.height / 2})`), fr.append(() => hr.node()), updateNodeBounds(lr, yr), lr.calcIntersect = function(te, lr) {
+		return intersect_default.rect(te, lr);
+	}, lr.intersect = function(te) {
+		return intersect_default.rect(lr, te);
+	}, fr;
+}
+__name(defaultMindmapNode, "defaultMindmapNode");
+async function mindmapCircle(te, lr) {
+	return circle(te, lr, { padding: lr.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 te = {
+		state,
+		choice,
+		note,
+		rectWithTitle,
+		labelRect,
+		iconSquare,
+		iconCircle,
+		icon,
+		iconRounded,
+		imageSquare,
+		anchor,
+		kanbanItem,
+		mindmapCircle,
+		defaultMindmapNode,
+		classBox,
+		erBox,
+		requirementBox
+	}, lr = [...Object.entries(te), ...shapesDefs.flatMap((te) => [
+		te.shortName,
+		..."aliases" in te ? te.aliases : [],
+		..."internalAliases" in te ? te.internalAliases : []
+	].map((lr) => [lr, te.handler]))];
+	return Object.fromEntries(lr);
+}, "generateShapeMap"))();
+function isValidShape(te) {
+	return te in shapes2;
+}
+__name(isValidShape, "isValidShape");
+var nodeElems = /* @__PURE__ */ new Map();
+async function insertNode(te, lr, ur) {
+	let dr, fr;
+	lr.shape === "rect" && (lr.rx && lr.ry ? lr.shape = "roundedRect" : lr.shape = "squareRect");
+	let pr = lr.shape ? shapes2[lr.shape] : void 0;
+	if (!pr) throw Error(`No such shape: ${lr.shape}. Please check your syntax.`);
+	if (lr.link) {
+		let mr;
+		ur.config.securityLevel === "sandbox" ? mr = "_top" : lr.linkTarget && (mr = lr.linkTarget || "_blank"), dr = te.insert("svg:a").attr("xlink:href", lr.link).attr("target", mr ?? null), fr = await pr(dr, lr, ur);
+	} else fr = await pr(te, lr, ur), dr = fr;
+	return lr.tooltip && fr.attr("title", lr.tooltip), nodeElems.set(lr.id, dr), lr.haveCallback && dr.attr("class", dr.attr("class") + " clickable"), dr;
+}
+__name(insertNode, "insertNode");
+var setNodeElem = /* @__PURE__ */ __name((te, lr) => {
+	nodeElems.set(lr.id, te);
+}, "setNodeElem"), clear2 = /* @__PURE__ */ __name(() => {
+	nodeElems.clear();
+}, "clear"), positionNode = /* @__PURE__ */ __name((lr) => {
+	let ur = nodeElems.get(lr.id);
+	log.trace("Transforming node", lr.diff, lr, "translate(" + (lr.x - lr.width / 2 - 5) + ", " + lr.width / 2 + ")");
+	let dr = lr.diff || 0;
+	return lr.clusterNode ? ur.attr("transform", "translate(" + (lr.x + dr - lr.width / 2) + ", " + (lr.y - lr.height / 2 - 8) + ")") : ur.attr("transform", "translate(" + lr.x + ", " + lr.y + ")"), dr;
+}, "positionNode");
+export { insertNode as a, positionNode as c, at as d, insertCluster as i, setNodeElem as l, clear2 as n, isValidShape as o, createLabel_default as r, labelHelper as s, clear as t, updateNodeBounds as u };