@wzh-/ai-chat-example 1.0.2 → 1.0.4

package/dist/chunk-JZLCHNYA-vrb_Ucuc.js

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