@scalar/agent-chat 0.2.1 → 0.2.2

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

@@ -0,0 +1,3117 @@
+import { getSubGraphTitleMargins as Ht } from "./chunk-CVBHYZKI.js";
+import { styles2String as L, userNodeOverrides as N, solidStateFill as is, compileStyles as wt } from "./chunk-ATLVNIR6.js";
+import { createText as gt, getIconSVG as bt } from "./chunk-JA3XYJ7Z.js";
+import { handleUndefinedAttr as K, decodeEntities as xt, parseFontSize as ls, calculateTextWidth as St } from "./chunk-S3R3BYOJ.js";
+import { evaluate as Q, getConfig2 as F, sanitizeText as Pt, defaultConfig_default as ns, getConfig as ut, hasKatex as Wt, renderKatexSanitized as rs, common_default as cs, sanitizeText2 as Et, parseGenericTypes as Lt } from "./chunk-ABZYJK2D.js";
+import { __name as w, log as Y } from "./chunk-AGHRB4JF.js";
+import R from "../../../../../../roughjs@4.6.6/node_modules/roughjs/bundled/rough.esm.js";
+import Z from "../../../../../../d3-selection@3.0.0/node_modules/d3-selection/src/select.js";
+var _ = /* @__PURE__ */ w(async (f, t, h) => {
+  let c;
+  const l = t.useHtmlLabels || Q(F()?.htmlLabels);
+  h ? c = h : c = "node default";
+  const i = f.insert("g").attr("class", c).attr("id", t.domId || t.id), o = i.insert("g").attr("class", "label").attr("style", K(t.labelStyle));
+  let a;
+  t.label === void 0 ? a = "" : a = typeof t.label == "string" ? t.label : t.label[0];
+  const n = await gt(o, Pt(xt(a), F()), {
+    useHtmlLabels: l,
+    width: t.width || F().flowchart?.wrappingWidth,
+    // @ts-expect-error -- This is currently not used. Should this be `classes` instead?
+    cssClasses: "markdown-node-label",
+    style: t.labelStyle,
+    addSvgBackground: !!t.icon || !!t.img
+  });
+  let e = n.getBBox();
+  const s = (t?.padding ?? 0) / 2;
+  if (l) {
+    const r = n.children[0], g = Z(n), y = r.getElementsByTagName("img");
+    if (y) {
+      const p = a.replace(/<img[^>]*>/g, "").trim() === "";
+      await Promise.all(
+        [...y].map(
+          (d) => new Promise((m) => {
+            function u() {
+              if (d.style.display = "flex", d.style.flexDirection = "column", p) {
+                const x = F().fontSize ? F().fontSize : window.getComputedStyle(document.body).fontSize, S = 5, [$ = ns.fontSize] = ls(x), b = $ * S + "px";
+                d.style.minWidth = b, d.style.maxWidth = b;
+              } else
+                d.style.width = "100%";
+              m(d);
+            }
+            w(u, "setupImage"), setTimeout(() => {
+              d.complete && u();
+            }), d.addEventListener("error", u), d.addEventListener("load", u);
+          })
+        )
+      );
+    }
+    e = r.getBoundingClientRect(), g.attr("width", e.width), g.attr("height", e.height);
+  }
+  return l ? o.attr("transform", "translate(" + -e.width / 2 + ", " + -e.height / 2 + ")") : o.attr("transform", "translate(0, " + -e.height / 2 + ")"), t.centerLabel && o.attr("transform", "translate(" + -e.width / 2 + ", " + -e.height / 2 + ")"), o.insert("rect", ":first-child"), { shapeSvg: i, bbox: e, halfPadding: s, label: o };
+}, "labelHelper"), Dt = /* @__PURE__ */ w(async (f, t, h) => {
+  const c = h.useHtmlLabels || Q(F()?.flowchart?.htmlLabels), l = f.insert("g").attr("class", "label").attr("style", h.labelStyle || ""), i = await gt(l, Pt(xt(t), F()), {
+    useHtmlLabels: c,
+    width: h.width || F()?.flowchart?.wrappingWidth,
+    style: h.labelStyle,
+    addSvgBackground: !!h.icon || !!h.img
+  });
+  let o = i.getBBox();
+  const a = h.padding / 2;
+  if (Q(F()?.flowchart?.htmlLabels)) {
+    const n = i.children[0], e = Z(i);
+    o = n.getBoundingClientRect(), e.attr("width", o.width), e.attr("height", o.height);
+  }
+  return c ? l.attr("transform", "translate(" + -o.width / 2 + ", " + -o.height / 2 + ")") : l.attr("transform", "translate(0, " + -o.height / 2 + ")"), h.centerLabel && l.attr("transform", "translate(" + -o.width / 2 + ", " + -o.height / 2 + ")"), l.insert("rect", ":first-child"), { shapeSvg: f, bbox: o, halfPadding: a, label: l };
+}, "insertLabel"), A = /* @__PURE__ */ w((f, t) => {
+  const h = t.node().getBBox();
+  f.width = h.width, f.height = h.height;
+}, "updateNodeBounds"), T = /* @__PURE__ */ w((f, t) => (f.look === "handDrawn" ? "rough-node" : "node") + " " + f.cssClasses + " " + (t || ""), "getNodeClasses");
+function z(f) {
+  const t = f.map((h, c) => `${c === 0 ? "M" : "L"}${h.x},${h.y}`);
+  return t.push("Z"), t.join(" ");
+}
+w(z, "createPathFromPoints");
+function rt(f, t, h, c, l, i) {
+  const o = [], n = h - f, e = c - t, s = n / i, r = 2 * Math.PI / s, g = t + e / 2;
+  for (let y = 0; y <= 50; y++) {
+    const p = y / 50, d = f + p * n, m = g + l * Math.sin(r * (d - f));
+    o.push({ x: d, y: m });
+  }
+  return o;
+}
+w(rt, "generateFullSineWavePoints");
+function mt(f, t, h, c, l, i) {
+  const o = [], a = l * Math.PI / 180, s = (i * Math.PI / 180 - a) / (c - 1);
+  for (let r = 0; r < c; r++) {
+    const g = a + r * s, y = f + h * Math.cos(g), p = t + h * Math.sin(g);
+    o.push({ x: -y, y: -p });
+  }
+  return o;
+}
+w(mt, "generateCirclePoints");
+var os = /* @__PURE__ */ w((f, t) => {
+  var h = f.x, c = f.y, l = t.x - h, i = t.y - c, o = f.width / 2, a = f.height / 2, n, e;
+  return Math.abs(i) * o > Math.abs(l) * a ? (i < 0 && (a = -a), n = i === 0 ? 0 : a * l / i, e = a) : (l < 0 && (o = -o), n = o, e = l === 0 ? 0 : o * i / l), { x: h + n, y: c + e };
+}, "intersectRect"), ft = os;
+function It(f, t) {
+  t && f.attr("style", t);
+}
+w(It, "applyStyle");
+async function Tt(f) {
+  const t = Z(document.createElementNS("http://www.w3.org/2000/svg", "foreignObject")), h = t.append("xhtml:div"), c = F();
+  let l = f.label;
+  f.label && Wt(f.label) && (l = await rs(f.label.replace(cs.lineBreakRegex, `
+`), c));
+  const o = '<span class="' + (f.isNode ? "nodeLabel" : "edgeLabel") + '" ' + (f.labelStyle ? 'style="' + f.labelStyle + '"' : "") + // codeql [js/html-constructed-from-input] : false positive
+  ">" + l + "</span>";
+  return h.html(Pt(o, c)), It(h, f.labelStyle), h.style("display", "inline-block"), h.style("padding-right", "1px"), h.style("white-space", "nowrap"), h.attr("xmlns", "http://www.w3.org/1999/xhtml"), t.node();
+}
+w(Tt, "addHtmlLabel");
+var hs = /* @__PURE__ */ w(async (f, t, h, c) => {
+  let l = f || "";
+  if (typeof l == "object" && (l = l[0]), Q(F().flowchart.htmlLabels)) {
+    l = l.replace(/\\n|\n/g, "<br />"), Y.info("vertexText" + l);
+    const i = {
+      isNode: c,
+      label: xt(l).replace(
+        /fa[blrs]?:fa-[\w-]+/g,
+        (a) => `<i class='${a.replace(":", " ")}'></i>`
+      ),
+      labelStyle: t && t.replace("fill:", "color:")
+    };
+    return await Tt(i);
+  } else {
+    const i = document.createElementNS("http://www.w3.org/2000/svg", "text");
+    i.setAttribute("style", t.replace("color:", "fill:"));
+    let o = [];
+    typeof l == "string" ? o = l.split(/\\n|\n|<br\s*\/?>/gi) : Array.isArray(l) ? o = l : o = [];
+    for (const a of o) {
+      const n = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+      n.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve"), n.setAttribute("dy", "1em"), n.setAttribute("x", "0"), h ? n.setAttribute("class", "title-row") : n.setAttribute("class", "row"), n.textContent = a.trim(), i.appendChild(n);
+    }
+    return i;
+  }
+}, "createLabel"), Bt = hs, ct = /* @__PURE__ */ w((f, t, h, c, l) => [
+  "M",
+  f + l,
+  t,
+  // Move to the first point
+  "H",
+  f + h - l,
+  // Draw horizontal line to the beginning of the right corner
+  "A",
+  l,
+  l,
+  0,
+  0,
+  1,
+  f + h,
+  t + l,
+  // Draw arc to the right top corner
+  "V",
+  t + c - l,
+  // Draw vertical line down to the beginning of the right bottom corner
+  "A",
+  l,
+  l,
+  0,
+  0,
+  1,
+  f + h - l,
+  t + c,
+  // Draw arc to the right bottom corner
+  "H",
+  f + l,
+  // Draw horizontal line to the beginning of the left bottom corner
+  "A",
+  l,
+  l,
+  0,
+  0,
+  1,
+  f,
+  t + c - l,
+  // Draw arc to the left bottom corner
+  "V",
+  t + l,
+  // Draw vertical line up to the beginning of the left top corner
+  "A",
+  l,
+  l,
+  0,
+  0,
+  1,
+  f + l,
+  t,
+  // Draw arc to the left top corner
+  "Z"
+  // Close the path
+].join(" "), "createRoundedRectPathD"), _t = /* @__PURE__ */ w(async (f, t) => {
+  Y.info("Creating subgraph rect for ", t.id, t);
+  const h = F(), { themeVariables: c, handDrawnSeed: l } = h, { clusterBkg: i, clusterBorder: o } = c, { labelStyles: a, nodeStyles: n, borderStyles: e, backgroundStyles: s } = L(t), r = f.insert("g").attr("class", "cluster " + t.cssClasses).attr("id", t.id).attr("data-look", t.look), g = Q(h.flowchart.htmlLabels), y = r.insert("g").attr("class", "cluster-label "), p = await gt(y, t.label, {
+    style: t.labelStyle,
+    useHtmlLabels: g,
+    isNode: !0
+  });
+  let d = p.getBBox();
+  if (Q(h.flowchart.htmlLabels)) {
+    const v = p.children[0], k = Z(p);
+    d = v.getBoundingClientRect(), k.attr("width", d.width), k.attr("height", d.height);
+  }
+  const m = t.width <= d.width + t.padding ? d.width + t.padding : t.width;
+  t.width <= d.width + t.padding ? t.diff = (m - t.width) / 2 - t.padding : t.diff = -t.padding;
+  const u = t.height, x = t.x - m / 2, S = t.y - u / 2;
+  Y.trace("Data ", t, JSON.stringify(t));
+  let $;
+  if (t.look === "handDrawn") {
+    const v = R.svg(r), k = N(t, {
+      roughness: 0.7,
+      fill: i,
+      // fill: 'red',
+      stroke: o,
+      fillWeight: 3,
+      seed: l
+    }), B = v.path(ct(x, S, m, u, 0), k);
+    $ = r.insert(() => (Y.debug("Rough node insert CXC", B), B), ":first-child"), $.select("path:nth-child(2)").attr("style", e.join(";")), $.select("path").attr("style", s.join(";").replace("fill", "stroke"));
+  } else
+    $ = r.insert("rect", ":first-child"), $.attr("style", n).attr("rx", t.rx).attr("ry", t.ry).attr("x", x).attr("y", S).attr("width", m).attr("height", u);
+  const { subGraphTitleTopMargin: b } = Ht(h);
+  if (y.attr(
+    "transform",
+    // This puts the label on top of the box instead of inside it
+    `translate(${t.x - d.width / 2}, ${t.y - t.height / 2 + b})`
+  ), a) {
+    const v = y.select("span");
+    v && v.attr("style", a);
+  }
+  const D = $.node().getBBox();
+  return t.offsetX = 0, t.width = D.width, t.height = D.height, t.offsetY = d.height - t.padding / 2, t.intersect = function(v) {
+    return ft(t, v);
+  }, { cluster: r, labelBBox: d };
+}, "rect"), gs = /* @__PURE__ */ w((f, t) => {
+  const h = f.insert("g").attr("class", "note-cluster").attr("id", t.id), c = h.insert("rect", ":first-child"), l = 0 * t.padding, i = l / 2;
+  c.attr("rx", t.rx).attr("ry", t.ry).attr("x", t.x - t.width / 2 - i).attr("y", t.y - t.height / 2 - i).attr("width", t.width + l).attr("height", t.height + l).attr("fill", "none");
+  const o = c.node().getBBox();
+  return t.width = o.width, t.height = o.height, t.intersect = function(a) {
+    return ft(t, a);
+  }, { cluster: h, labelBBox: { width: 0, height: 0 } };
+}, "noteGroup"), ys = /* @__PURE__ */ w(async (f, t) => {
+  const h = F(), { themeVariables: c, handDrawnSeed: l } = h, { altBackground: i, compositeBackground: o, compositeTitleBackground: a, nodeBorder: n } = c, e = f.insert("g").attr("class", t.cssClasses).attr("id", t.id).attr("data-id", t.id).attr("data-look", t.look), s = e.insert("g", ":first-child"), r = e.insert("g").attr("class", "cluster-label");
+  let g = e.append("rect");
+  const y = r.node().appendChild(await Bt(t.label, t.labelStyle, void 0, !0));
+  let p = y.getBBox();
+  if (Q(h.flowchart.htmlLabels)) {
+    const B = y.children[0], I = Z(y);
+    p = B.getBoundingClientRect(), I.attr("width", p.width), I.attr("height", p.height);
+  }
+  const d = 0 * t.padding, m = d / 2, u = (t.width <= p.width + t.padding ? p.width + t.padding : t.width) + d;
+  t.width <= p.width + t.padding ? t.diff = (u - t.width) / 2 - t.padding : t.diff = -t.padding;
+  const x = t.height + d, S = t.height + d - p.height - 6, $ = t.x - u / 2, b = t.y - x / 2;
+  t.width = u;
+  const D = t.y - t.height / 2 - m + p.height + 2;
+  let v;
+  if (t.look === "handDrawn") {
+    const B = t.cssClasses.includes("statediagram-cluster-alt"), I = R.svg(e), H = t.rx || t.ry ? I.path(ct($, b, u, x, 10), {
+      roughness: 0.7,
+      fill: a,
+      fillStyle: "solid",
+      stroke: n,
+      seed: l
+    }) : I.rectangle($, b, u, x, { seed: l });
+    v = e.insert(() => H, ":first-child");
+    const W = I.rectangle($, D, u, S, {
+      fill: B ? i : o,
+      fillStyle: B ? "hachure" : "solid",
+      stroke: n,
+      seed: l
+    });
+    v = e.insert(() => H, ":first-child"), g = e.insert(() => W);
+  } else
+    v = s.insert("rect", ":first-child"), v.attr("class", "outer").attr("x", $).attr("y", b).attr("width", u).attr("height", x).attr("data-look", t.look), g.attr("class", "inner").attr("x", $).attr("y", D).attr("width", u).attr("height", S);
+  r.attr(
+    "transform",
+    `translate(${t.x - p.width / 2}, ${b + 1 - (Q(h.flowchart.htmlLabels) ? 0 : 3)})`
+  );
+  const k = v.node().getBBox();
+  return t.height = k.height, t.offsetX = 0, t.offsetY = p.height - t.padding / 2, t.labelBBox = p, t.intersect = function(B) {
+    return ft(t, B);
+  }, { cluster: e, labelBBox: p };
+}, "roundedWithTitle"), fs = /* @__PURE__ */ w(async (f, t) => {
+  Y.info("Creating subgraph rect for ", t.id, t);
+  const h = F(), { themeVariables: c, handDrawnSeed: l } = h, { clusterBkg: i, clusterBorder: o } = c, { labelStyles: a, nodeStyles: n, borderStyles: e, backgroundStyles: s } = L(t), r = f.insert("g").attr("class", "cluster " + t.cssClasses).attr("id", t.id).attr("data-look", t.look), g = Q(h.flowchart.htmlLabels), y = r.insert("g").attr("class", "cluster-label "), p = await gt(y, t.label, {
+    style: t.labelStyle,
+    useHtmlLabels: g,
+    isNode: !0,
+    width: t.width
+  });
+  let d = p.getBBox();
+  if (Q(h.flowchart.htmlLabels)) {
+    const v = p.children[0], k = Z(p);
+    d = v.getBoundingClientRect(), k.attr("width", d.width), k.attr("height", d.height);
+  }
+  const m = t.width <= d.width + t.padding ? d.width + t.padding : t.width;
+  t.width <= d.width + t.padding ? t.diff = (m - t.width) / 2 - t.padding : t.diff = -t.padding;
+  const u = t.height, x = t.x - m / 2, S = t.y - u / 2;
+  Y.trace("Data ", t, JSON.stringify(t));
+  let $;
+  if (t.look === "handDrawn") {
+    const v = R.svg(r), k = N(t, {
+      roughness: 0.7,
+      fill: i,
+      // fill: 'red',
+      stroke: o,
+      fillWeight: 4,
+      seed: l
+    }), B = v.path(ct(x, S, m, u, t.rx), k);
+    $ = r.insert(() => (Y.debug("Rough node insert CXC", B), B), ":first-child"), $.select("path:nth-child(2)").attr("style", e.join(";")), $.select("path").attr("style", s.join(";").replace("fill", "stroke"));
+  } else
+    $ = r.insert("rect", ":first-child"), $.attr("style", n).attr("rx", t.rx).attr("ry", t.ry).attr("x", x).attr("y", S).attr("width", m).attr("height", u);
+  const { subGraphTitleTopMargin: b } = Ht(h);
+  if (y.attr(
+    "transform",
+    // This puts the label on top of the box instead of inside it
+    `translate(${t.x - d.width / 2}, ${t.y - t.height / 2 + b})`
+  ), a) {
+    const v = y.select("span");
+    v && v.attr("style", a);
+  }
+  const D = $.node().getBBox();
+  return t.offsetX = 0, t.width = D.width, t.height = D.height, t.offsetY = d.height - t.padding / 2, t.intersect = function(v) {
+    return ft(t, v);
+  }, { cluster: r, labelBBox: d };
+}, "kanbanSection"), ps = /* @__PURE__ */ w((f, t) => {
+  const h = F(), { themeVariables: c, handDrawnSeed: l } = h, { nodeBorder: i } = c, o = f.insert("g").attr("class", t.cssClasses).attr("id", t.id).attr("data-look", t.look), a = o.insert("g", ":first-child"), n = 0 * t.padding, e = t.width + n;
+  t.diff = -t.padding;
+  const s = t.height + n, r = t.x - e / 2, g = t.y - s / 2;
+  t.width = e;
+  let y;
+  if (t.look === "handDrawn") {
+    const m = R.svg(o).rectangle(r, g, e, s, {
+      fill: "lightgrey",
+      roughness: 0.5,
+      strokeLineDash: [5],
+      stroke: i,
+      seed: l
+    });
+    y = o.insert(() => m, ":first-child");
+  } else
+    y = a.insert("rect", ":first-child"), y.attr("class", "divider").attr("x", r).attr("y", g).attr("width", e).attr("height", s).attr("data-look", t.look);
+  const p = y.node().getBBox();
+  return t.height = p.height, t.offsetX = 0, t.offsetY = 0, t.intersect = function(d) {
+    return ft(t, d);
+  }, { cluster: o, labelBBox: {} };
+}, "divider"), ds = _t, us = {
+  rect: _t,
+  squareRect: ds,
+  roundedWithTitle: ys,
+  noteGroup: gs,
+  divider: ps,
+  kanbanSection: fs
+}, Ot = /* @__PURE__ */ new Map(), qs = /* @__PURE__ */ w(async (f, t) => {
+  const h = t.shape || "rect", c = await us[h](f, t);
+  return Ot.set(t.id, c), c;
+}, "insertCluster"), Fs = /* @__PURE__ */ w(() => {
+  Ot = /* @__PURE__ */ new Map();
+}, "clear");
+function Xt(f, t) {
+  return f.intersect(t);
+}
+w(Xt, "intersectNode");
+var ms = Xt;
+function jt(f, t, h, c) {
+  var l = f.x, i = f.y, o = l - c.x, a = i - c.y, n = Math.sqrt(t * t * a * a + h * h * o * o), e = Math.abs(t * h * o / n);
+  c.x < l && (e = -e);
+  var s = Math.abs(t * h * a / n);
+  return c.y < i && (s = -s), { x: l + e, y: i + s };
+}
+w(jt, "intersectEllipse");
+var zt = jt;
+function Yt(f, t, h) {
+  return zt(f, t, t, h);
+}
+w(Yt, "intersectCircle");
+var xs = Yt;
+function qt(f, t, h, c) {
+  {
+    const l = t.y - f.y, i = f.x - t.x, o = t.x * f.y - f.x * t.y, a = l * h.x + i * h.y + o, n = l * c.x + i * c.y + o, e = 1e-6;
+    if (a !== 0 && n !== 0 && Mt(a, n))
+      return;
+    const s = c.y - h.y, r = h.x - c.x, g = c.x * h.y - h.x * c.y, y = s * f.x + r * f.y + g, p = s * t.x + r * t.y + g;
+    if (Math.abs(y) < e && Math.abs(p) < e && Mt(y, p))
+      return;
+    const d = l * r - s * i;
+    if (d === 0)
+      return;
+    const m = Math.abs(d / 2);
+    let u = i * g - r * o;
+    const x = u < 0 ? (u - m) / d : (u + m) / d;
+    u = s * o - l * g;
+    const S = u < 0 ? (u - m) / d : (u + m) / d;
+    return { x, y: S };
+  }
+}
+w(qt, "intersectLine");
+function Mt(f, t) {
+  return f * t > 0;
+}
+w(Mt, "sameSign");
+var ws = qt;
+function Ft(f, t, h) {
+  let c = f.x, l = f.y, i = [], o = Number.POSITIVE_INFINITY, a = Number.POSITIVE_INFINITY;
+  typeof t.forEach == "function" ? t.forEach(function(s) {
+    o = Math.min(o, s.x), a = Math.min(a, s.y);
+  }) : (o = Math.min(o, t.x), a = Math.min(a, t.y));
+  let n = c - f.width / 2 - o, e = l - f.height / 2 - a;
+  for (let s = 0; s < t.length; s++) {
+    let r = t[s], g = t[s < t.length - 1 ? s + 1 : 0], y = ws(
+      f,
+      h,
+      { x: n + r.x, y: e + r.y },
+      { x: n + g.x, y: e + g.y }
+    );
+    y && i.push(y);
+  }
+  return i.length ? (i.length > 1 && i.sort(function(s, r) {
+    let g = s.x - h.x, y = s.y - h.y, p = Math.sqrt(g * g + y * y), d = r.x - h.x, m = r.y - h.y, u = Math.sqrt(d * d + m * m);
+    return p < u ? -1 : p === u ? 0 : 1;
+  }), i[0]) : f;
+}
+w(Ft, "intersectPolygon");
+var bs = Ft, M = {
+  node: ms,
+  circle: xs,
+  ellipse: zt,
+  polygon: bs,
+  rect: ft
+};
+function Gt(f, t) {
+  const { labelStyles: h } = L(t);
+  t.labelStyle = h;
+  const c = T(t);
+  let l = c;
+  c || (l = "anchor");
+  const i = f.insert("g").attr("class", l).attr("id", t.domId || t.id), o = 1, { cssStyles: a } = t, n = R.svg(i), e = N(t, { fill: "black", stroke: "none", fillStyle: "solid" });
+  t.look !== "handDrawn" && (e.roughness = 0);
+  const s = n.circle(0, 0, o * 2, e), r = i.insert(() => s, ":first-child");
+  return r.attr("class", "anchor").attr("style", K(a)), A(t, r), t.intersect = function(g) {
+    return Y.info("Circle intersect", t, o, g), M.circle(t, o, g);
+  }, i;
+}
+w(Gt, "anchor");
+function Ct(f, t, h, c, l, i, o) {
+  const n = (f + h) / 2, e = (t + c) / 2, s = Math.atan2(c - t, h - f), r = (h - f) / 2, g = (c - t) / 2, y = r / l, p = g / i, d = Math.sqrt(y ** 2 + p ** 2);
+  if (d > 1)
+    throw new Error("The given radii are too small to create an arc between the points.");
+  const m = Math.sqrt(1 - d ** 2), u = n + m * i * Math.sin(s) * (o ? -1 : 1), x = e - m * l * Math.cos(s) * (o ? -1 : 1), S = Math.atan2((t - x) / i, (f - u) / l);
+  let b = Math.atan2((c - x) / i, (h - u) / l) - S;
+  o && b < 0 && (b += 2 * Math.PI), !o && b > 0 && (b -= 2 * Math.PI);
+  const D = [];
+  for (let v = 0; v < 20; v++) {
+    const k = v / 19, B = S + k * b, I = u + l * Math.cos(B), H = x + i * Math.sin(B);
+    D.push({ x: I, y: H });
+  }
+  return D;
+}
+w(Ct, "generateArcPoints");
+async function Vt(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = i.width + t.padding + 20, a = i.height + t.padding, n = a / 2, e = n / (2.5 + a / 50), { cssStyles: s } = t, r = [
+    { x: o / 2, y: -a / 2 },
+    { x: -o / 2, y: -a / 2 },
+    ...Ct(-o / 2, -a / 2, -o / 2, a / 2, e, n, !1),
+    { x: o / 2, y: a / 2 },
+    ...Ct(o / 2, a / 2, o / 2, -a / 2, e, n, !0)
+  ], g = R.svg(l), y = N(t, {});
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = z(r), d = g.path(p, y), m = l.insert(() => d, ":first-child");
+  return m.attr("class", "basic label-container"), s && t.look !== "handDrawn" && m.selectAll("path").attr("style", s), c && t.look !== "handDrawn" && m.selectAll("path").attr("style", c), m.attr("transform", `translate(${e / 2}, 0)`), A(t, m), t.intersect = function(u) {
+    return M.polygon(t, r, u);
+  }, l;
+}
+w(Vt, "bowTieRect");
+function ot(f, t, h, c) {
+  return f.insert("polygon", ":first-child").attr(
+    "points",
+    c.map(function(l) {
+      return l.x + "," + l.y;
+    }).join(" ")
+  ).attr("class", "label-container").attr("transform", "translate(" + -t / 2 + "," + h / 2 + ")");
+}
+w(ot, "insertPolygonShape");
+async function Zt(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = i.height + t.padding, a = 12, n = i.width + t.padding + a, e = 0, s = n, r = -o, g = 0, y = [
+    { x: e + a, y: r },
+    { x: s, y: r },
+    { x: s, y: g },
+    { x: e, y: g },
+    { x: e, y: r + a },
+    { x: e + a, y: r }
+  ];
+  let p;
+  const { cssStyles: d } = t;
+  if (t.look === "handDrawn") {
+    const m = R.svg(l), u = N(t, {}), x = z(y), S = m.path(x, u);
+    p = l.insert(() => S, ":first-child").attr("transform", `translate(${-n / 2}, ${o / 2})`), d && p.attr("style", d);
+  } else
+    p = ot(l, n, o, y);
+  return c && p.attr("style", c), A(t, p), t.intersect = function(m) {
+    return M.polygon(t, y, m);
+  }, l;
+}
+w(Zt, "card");
+function Jt(f, t) {
+  const { nodeStyles: h } = L(t);
+  t.label = "";
+  const c = f.insert("g").attr("class", T(t)).attr("id", t.domId ?? t.id), { cssStyles: l } = t, i = Math.max(28, t.width ?? 0), o = [
+    { x: 0, y: i / 2 },
+    { x: i / 2, y: 0 },
+    { x: 0, y: -i / 2 },
+    { x: -i / 2, y: 0 }
+  ], a = R.svg(c), n = N(t, {});
+  t.look !== "handDrawn" && (n.roughness = 0, n.fillStyle = "solid");
+  const e = z(o), s = a.path(e, n), r = c.insert(() => s, ":first-child");
+  return l && t.look !== "handDrawn" && r.selectAll("path").attr("style", l), h && t.look !== "handDrawn" && r.selectAll("path").attr("style", h), t.width = 28, t.height = 28, t.intersect = function(g) {
+    return M.polygon(t, o, g);
+  }, c;
+}
+w(Jt, "choice");
+async function Nt(f, t, h) {
+  const { labelStyles: c, nodeStyles: l } = L(t);
+  t.labelStyle = c;
+  const { shapeSvg: i, bbox: o, halfPadding: a } = await _(f, t, T(t)), n = h?.padding ?? a, e = o.width / 2 + n;
+  let s;
+  const { cssStyles: r } = t;
+  if (t.look === "handDrawn") {
+    const g = R.svg(i), y = N(t, {}), p = g.circle(0, 0, e * 2, y);
+    s = i.insert(() => p, ":first-child"), s.attr("class", "basic label-container").attr("style", K(r));
+  } else
+    s = i.insert("circle", ":first-child").attr("class", "basic label-container").attr("style", l).attr("r", e).attr("cx", 0).attr("cy", 0);
+  return A(t, s), t.calcIntersect = function(g, y) {
+    const p = g.width / 2;
+    return M.circle(g, p, y);
+  }, t.intersect = function(g) {
+    return Y.info("Circle intersect", t, e, g), M.circle(t, e, g);
+  }, i;
+}
+w(Nt, "circle");
+function Qt(f) {
+  const t = Math.cos(Math.PI / 4), h = Math.sin(Math.PI / 4), c = f * 2, l = { x: c / 2 * t, y: c / 2 * h }, i = { x: -(c / 2) * t, y: c / 2 * h }, o = { x: -(c / 2) * t, y: -(c / 2) * h }, a = { x: c / 2 * t, y: -(c / 2) * h };
+  return `M ${i.x},${i.y} L ${a.x},${a.y}
+                   M ${l.x},${l.y} L ${o.x},${o.y}`;
+}
+w(Qt, "createLine");
+function Kt(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h, t.label = "";
+  const l = f.insert("g").attr("class", T(t)).attr("id", t.domId ?? t.id), i = Math.max(30, t?.width ?? 0), { cssStyles: o } = t, a = R.svg(l), n = N(t, {});
+  t.look !== "handDrawn" && (n.roughness = 0, n.fillStyle = "solid");
+  const e = a.circle(0, 0, i * 2, n), s = Qt(i), r = a.path(s, n), g = l.insert(() => e, ":first-child");
+  return g.insert(() => r), o && t.look !== "handDrawn" && g.selectAll("path").attr("style", o), c && t.look !== "handDrawn" && g.selectAll("path").attr("style", c), A(t, g), t.intersect = function(y) {
+    return Y.info("crossedCircle intersect", t, { radius: i, point: y }), M.circle(t, i, y);
+  }, l;
+}
+w(Kt, "crossedCircle");
+function it(f, t, h, c = 100, l = 0, i = 180) {
+  const o = [], a = l * Math.PI / 180, s = (i * Math.PI / 180 - a) / (c - 1);
+  for (let r = 0; r < c; r++) {
+    const g = a + r * s, y = f + h * Math.cos(g), p = t + h * Math.sin(g);
+    o.push({ x: -y, y: -p });
+  }
+  return o;
+}
+w(it, "generateCirclePoints");
+async function Ut(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = i.width + (t.padding ?? 0), n = i.height + (t.padding ?? 0), e = Math.max(5, n * 0.1), { cssStyles: s } = t, r = [
+    ...it(a / 2, -n / 2, e, 30, -90, 0),
+    { x: -a / 2 - e, y: e },
+    ...it(a / 2 + e * 2, -e, e, 20, -180, -270),
+    ...it(a / 2 + e * 2, e, e, 20, -90, -180),
+    { x: -a / 2 - e, y: -n / 2 },
+    ...it(a / 2, n / 2, e, 20, 0, 90)
+  ], g = [
+    { x: a / 2, y: -n / 2 - e },
+    { x: -a / 2, y: -n / 2 - e },
+    ...it(a / 2, -n / 2, e, 20, -90, 0),
+    { x: -a / 2 - e, y: -e },
+    ...it(a / 2 + a * 0.1, -e, e, 20, -180, -270),
+    ...it(a / 2 + a * 0.1, e, e, 20, -90, -180),
+    { x: -a / 2 - e, y: n / 2 },
+    ...it(a / 2, n / 2, e, 20, 0, 90),
+    { x: -a / 2, y: n / 2 + e },
+    { x: a / 2, y: n / 2 + e }
+  ], y = R.svg(l), p = N(t, { fill: "none" });
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const m = z(r).replace("Z", ""), u = y.path(m, p), x = z(g), S = y.path(x, { ...p }), $ = l.insert("g", ":first-child");
+  return $.insert(() => S, ":first-child").attr("stroke-opacity", 0), $.insert(() => u, ":first-child"), $.attr("class", "text"), s && t.look !== "handDrawn" && $.selectAll("path").attr("style", s), c && t.look !== "handDrawn" && $.selectAll("path").attr("style", c), $.attr("transform", `translate(${e}, 0)`), o.attr(
+    "transform",
+    `translate(${-a / 2 + e - (i.x - (i.left ?? 0))},${-n / 2 + (t.padding ?? 0) / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, $), t.intersect = function(b) {
+    return M.polygon(t, g, b);
+  }, l;
+}
+w(Ut, "curlyBraceLeft");
+function lt(f, t, h, c = 100, l = 0, i = 180) {
+  const o = [], a = l * Math.PI / 180, s = (i * Math.PI / 180 - a) / (c - 1);
+  for (let r = 0; r < c; r++) {
+    const g = a + r * s, y = f + h * Math.cos(g), p = t + h * Math.sin(g);
+    o.push({ x: y, y: p });
+  }
+  return o;
+}
+w(lt, "generateCirclePoints");
+async function te(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = i.width + (t.padding ?? 0), n = i.height + (t.padding ?? 0), e = Math.max(5, n * 0.1), { cssStyles: s } = t, r = [
+    ...lt(a / 2, -n / 2, e, 20, -90, 0),
+    { x: a / 2 + e, y: -e },
+    ...lt(a / 2 + e * 2, -e, e, 20, -180, -270),
+    ...lt(a / 2 + e * 2, e, e, 20, -90, -180),
+    { x: a / 2 + e, y: n / 2 },
+    ...lt(a / 2, n / 2, e, 20, 0, 90)
+  ], g = [
+    { x: -a / 2, y: -n / 2 - e },
+    { x: a / 2, y: -n / 2 - e },
+    ...lt(a / 2, -n / 2, e, 20, -90, 0),
+    { x: a / 2 + e, y: -e },
+    ...lt(a / 2 + e * 2, -e, e, 20, -180, -270),
+    ...lt(a / 2 + e * 2, e, e, 20, -90, -180),
+    { x: a / 2 + e, y: n / 2 },
+    ...lt(a / 2, n / 2, e, 20, 0, 90),
+    { x: a / 2, y: n / 2 + e },
+    { x: -a / 2, y: n / 2 + e }
+  ], y = R.svg(l), p = N(t, { fill: "none" });
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const m = z(r).replace("Z", ""), u = y.path(m, p), x = z(g), S = y.path(x, { ...p }), $ = l.insert("g", ":first-child");
+  return $.insert(() => S, ":first-child").attr("stroke-opacity", 0), $.insert(() => u, ":first-child"), $.attr("class", "text"), s && t.look !== "handDrawn" && $.selectAll("path").attr("style", s), c && t.look !== "handDrawn" && $.selectAll("path").attr("style", c), $.attr("transform", `translate(${-e}, 0)`), o.attr(
+    "transform",
+    `translate(${-a / 2 + (t.padding ?? 0) / 2 - (i.x - (i.left ?? 0))},${-n / 2 + (t.padding ?? 0) / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, $), t.intersect = function(b) {
+    return M.polygon(t, g, b);
+  }, l;
+}
+w(te, "curlyBraceRight");
+function V(f, t, h, c = 100, l = 0, i = 180) {
+  const o = [], a = l * Math.PI / 180, s = (i * Math.PI / 180 - a) / (c - 1);
+  for (let r = 0; r < c; r++) {
+    const g = a + r * s, y = f + h * Math.cos(g), p = t + h * Math.sin(g);
+    o.push({ x: -y, y: -p });
+  }
+  return o;
+}
+w(V, "generateCirclePoints");
+async function ee(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = i.width + (t.padding ?? 0), n = i.height + (t.padding ?? 0), e = Math.max(5, n * 0.1), { cssStyles: s } = t, r = [
+    ...V(a / 2, -n / 2, e, 30, -90, 0),
+    { x: -a / 2 - e, y: e },
+    ...V(a / 2 + e * 2, -e, e, 20, -180, -270),
+    ...V(a / 2 + e * 2, e, e, 20, -90, -180),
+    { x: -a / 2 - e, y: -n / 2 },
+    ...V(a / 2, n / 2, e, 20, 0, 90)
+  ], g = [
+    ...V(-a / 2 + e + e / 2, -n / 2, e, 20, -90, -180),
+    { x: a / 2 - e / 2, y: e },
+    ...V(-a / 2 - e / 2, -e, e, 20, 0, 90),
+    ...V(-a / 2 - e / 2, e, e, 20, -90, 0),
+    { x: a / 2 - e / 2, y: -e },
+    ...V(-a / 2 + e + e / 2, n / 2, e, 30, -180, -270)
+  ], y = [
+    { x: a / 2, y: -n / 2 - e },
+    { x: -a / 2, y: -n / 2 - e },
+    ...V(a / 2, -n / 2, e, 20, -90, 0),
+    { x: -a / 2 - e, y: -e },
+    ...V(a / 2 + e * 2, -e, e, 20, -180, -270),
+    ...V(a / 2 + e * 2, e, e, 20, -90, -180),
+    { x: -a / 2 - e, y: n / 2 },
+    ...V(a / 2, n / 2, e, 20, 0, 90),
+    { x: -a / 2, y: n / 2 + e },
+    { x: a / 2 - e - e / 2, y: n / 2 + e },
+    ...V(-a / 2 + e + e / 2, -n / 2, e, 20, -90, -180),
+    { x: a / 2 - e / 2, y: e },
+    ...V(-a / 2 - e / 2, -e, e, 20, 0, 90),
+    ...V(-a / 2 - e / 2, e, e, 20, -90, 0),
+    { x: a / 2 - e / 2, y: -e },
+    ...V(-a / 2 + e + e / 2, n / 2, e, 30, -180, -270)
+  ], p = R.svg(l), d = N(t, { fill: "none" });
+  t.look !== "handDrawn" && (d.roughness = 0, d.fillStyle = "solid");
+  const u = z(r).replace("Z", ""), x = p.path(u, d), $ = z(g).replace("Z", ""), b = p.path($, d), D = z(y), v = p.path(D, { ...d }), k = l.insert("g", ":first-child");
+  return k.insert(() => v, ":first-child").attr("stroke-opacity", 0), k.insert(() => x, ":first-child"), k.insert(() => b, ":first-child"), k.attr("class", "text"), s && t.look !== "handDrawn" && k.selectAll("path").attr("style", s), c && t.look !== "handDrawn" && k.selectAll("path").attr("style", c), k.attr("transform", `translate(${e - e / 4}, 0)`), o.attr(
+    "transform",
+    `translate(${-a / 2 + (t.padding ?? 0) / 2 - (i.x - (i.left ?? 0))},${-n / 2 + (t.padding ?? 0) / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, k), t.intersect = function(B) {
+    return M.polygon(t, y, B);
+  }, l;
+}
+w(ee, "curlyBraces");
+async function se(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = 80, a = 20, n = Math.max(o, (i.width + (t.padding ?? 0) * 2) * 1.25, t?.width ?? 0), e = Math.max(a, i.height + (t.padding ?? 0) * 2, t?.height ?? 0), s = e / 2, { cssStyles: r } = t, g = R.svg(l), y = N(t, {});
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = n, d = e, m = p - s, u = d / 4, x = [
+    { x: m, y: 0 },
+    { x: u, y: 0 },
+    { x: 0, y: d / 2 },
+    { x: u, y: d },
+    { x: m, y: d },
+    ...mt(-m, -d / 2, s, 50, 270, 90)
+  ], S = z(x), $ = g.path(S, y), b = l.insert(() => $, ":first-child");
+  return b.attr("class", "basic label-container"), r && t.look !== "handDrawn" && b.selectChildren("path").attr("style", r), c && t.look !== "handDrawn" && b.selectChildren("path").attr("style", c), b.attr("transform", `translate(${-n / 2}, ${-e / 2})`), A(t, b), t.intersect = function(D) {
+    return M.polygon(t, x, D);
+  }, l;
+}
+w(se, "curvedTrapezoid");
+var Ss = /* @__PURE__ */ w((f, t, h, c, l, i) => [
+  `M${f},${t + i}`,
+  `a${l},${i} 0,0,0 ${h},0`,
+  `a${l},${i} 0,0,0 ${-h},0`,
+  `l0,${c}`,
+  `a${l},${i} 0,0,0 ${h},0`,
+  `l0,${-c}`
+].join(" "), "createCylinderPathD"), $s = /* @__PURE__ */ w((f, t, h, c, l, i) => [
+  `M${f},${t + i}`,
+  `M${f + h},${t + i}`,
+  `a${l},${i} 0,0,0 ${-h},0`,
+  `l0,${c}`,
+  `a${l},${i} 0,0,0 ${h},0`,
+  `l0,${-c}`
+].join(" "), "createOuterCylinderPathD"), vs = /* @__PURE__ */ w((f, t, h, c, l, i) => [`M${f - h / 2},${-c / 2}`, `a${l},${i} 0,0,0 ${h},0`].join(" "), "createInnerCylinderPathD");
+async function ae(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + t.padding, t.width ?? 0), n = a / 2, e = n / (2.5 + a / 50), s = Math.max(i.height + e + t.padding, t.height ?? 0);
+  let r;
+  const { cssStyles: g } = t;
+  if (t.look === "handDrawn") {
+    const y = R.svg(l), p = $s(0, 0, a, s, n, e), d = vs(0, e, a, s, n, e), m = y.path(p, N(t, {})), u = y.path(d, N(t, { fill: "none" }));
+    r = l.insert(() => u, ":first-child"), r = l.insert(() => m, ":first-child"), r.attr("class", "basic label-container"), g && r.attr("style", g);
+  } else {
+    const y = Ss(0, 0, a, s, n, e);
+    r = l.insert("path", ":first-child").attr("d", y).attr("class", "basic label-container").attr("style", K(g)).attr("style", c);
+  }
+  return r.attr("label-offset-y", e), r.attr("transform", `translate(${-a / 2}, ${-(s / 2 + e)})`), A(t, r), o.attr(
+    "transform",
+    `translate(${-(i.width / 2) - (i.x - (i.left ?? 0))}, ${-(i.height / 2) + (t.padding ?? 0) / 1.5 - (i.y - (i.top ?? 0))})`
+  ), t.intersect = function(y) {
+    const p = M.rect(t, y), d = p.x - (t.x ?? 0);
+    if (n != 0 && (Math.abs(d) < (t.width ?? 0) / 2 || Math.abs(d) == (t.width ?? 0) / 2 && Math.abs(p.y - (t.y ?? 0)) > (t.height ?? 0) / 2 - e)) {
+      let m = e * e * (1 - d * d / (n * n));
+      m > 0 && (m = Math.sqrt(m)), m = e - m, y.y - (t.y ?? 0) > 0 && (m = -m), p.y += m;
+    }
+    return p;
+  }, l;
+}
+w(ae, "cylinder");
+async function ie(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = i.width + t.padding, n = i.height + t.padding, e = n * 0.2, s = -a / 2, r = -n / 2 - e / 2, { cssStyles: g } = t, y = R.svg(l), p = N(t, {});
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const d = [
+    { x: s, y: r + e },
+    { x: -s, y: r + e },
+    { x: -s, y: -r },
+    { x: s, y: -r },
+    { x: s, y: r },
+    { x: -s, y: r },
+    { x: -s, y: r + e }
+  ], m = y.polygon(
+    d.map((x) => [x.x, x.y]),
+    p
+  ), u = l.insert(() => m, ":first-child");
+  return u.attr("class", "basic label-container"), g && t.look !== "handDrawn" && u.selectAll("path").attr("style", g), c && t.look !== "handDrawn" && u.selectAll("path").attr("style", c), o.attr(
+    "transform",
+    `translate(${s + (t.padding ?? 0) / 2 - (i.x - (i.left ?? 0))}, ${r + e + (t.padding ?? 0) / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, u), t.intersect = function(x) {
+    return M.rect(t, x);
+  }, l;
+}
+w(ie, "dividedRectangle");
+async function le(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, halfPadding: o } = await _(f, t, T(t)), n = i.width / 2 + o + 5, e = i.width / 2 + o;
+  let s;
+  const { cssStyles: r } = t;
+  if (t.look === "handDrawn") {
+    const g = R.svg(l), y = N(t, { roughness: 0.2, strokeWidth: 2.5 }), p = N(t, { roughness: 0.2, strokeWidth: 1.5 }), d = g.circle(0, 0, n * 2, y), m = g.circle(0, 0, e * 2, p);
+    s = l.insert("g", ":first-child"), s.attr("class", K(t.cssClasses)).attr("style", K(r)), s.node()?.appendChild(d), s.node()?.appendChild(m);
+  } else {
+    s = l.insert("g", ":first-child");
+    const g = s.insert("circle", ":first-child"), y = s.insert("circle");
+    s.attr("class", "basic label-container").attr("style", c), g.attr("class", "outer-circle").attr("style", c).attr("r", n).attr("cx", 0).attr("cy", 0), y.attr("class", "inner-circle").attr("style", c).attr("r", e).attr("cx", 0).attr("cy", 0);
+  }
+  return A(t, s), t.intersect = function(g) {
+    return Y.info("DoubleCircle intersect", t, n, g), M.circle(t, n, g);
+  }, l;
+}
+w(le, "doublecircle");
+function ne(f, t, { config: { themeVariables: h } }) {
+  const { labelStyles: c, nodeStyles: l } = L(t);
+  t.label = "", t.labelStyle = c;
+  const i = f.insert("g").attr("class", T(t)).attr("id", t.domId ?? t.id), o = 7, { cssStyles: a } = t, n = R.svg(i), { nodeBorder: e } = h, s = N(t, { fillStyle: "solid" });
+  t.look !== "handDrawn" && (s.roughness = 0);
+  const r = n.circle(0, 0, o * 2, s), g = i.insert(() => r, ":first-child");
+  return g.selectAll("path").attr("style", `fill: ${e} !important;`), a && a.length > 0 && t.look !== "handDrawn" && g.selectAll("path").attr("style", a), l && t.look !== "handDrawn" && g.selectAll("path").attr("style", l), A(t, g), t.intersect = function(y) {
+    return Y.info("filledCircle intersect", t, { radius: o, point: y }), M.circle(t, o, y);
+  }, i;
+}
+w(ne, "filledCircle");
+async function re(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = i.width + (t.padding ?? 0), n = a + i.height, e = a + i.height, s = [
+    { x: 0, y: -n },
+    { x: e, y: -n },
+    { x: e / 2, y: 0 }
+  ], { cssStyles: r } = t, g = R.svg(l), y = N(t, {});
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = z(s), d = g.path(p, y), m = l.insert(() => d, ":first-child").attr("transform", `translate(${-n / 2}, ${n / 2})`);
+  return r && t.look !== "handDrawn" && m.selectChildren("path").attr("style", r), c && t.look !== "handDrawn" && m.selectChildren("path").attr("style", c), t.width = a, t.height = n, A(t, m), o.attr(
+    "transform",
+    `translate(${-i.width / 2 - (i.x - (i.left ?? 0))}, ${-n / 2 + (t.padding ?? 0) / 2 + (i.y - (i.top ?? 0))})`
+  ), t.intersect = function(u) {
+    return Y.info("Triangle intersect", t, s, u), M.polygon(t, s, u);
+  }, l;
+}
+w(re, "flippedTriangle");
+function ce(f, t, { dir: h, config: { state: c, themeVariables: l } }) {
+  const { nodeStyles: i } = L(t);
+  t.label = "";
+  const o = f.insert("g").attr("class", T(t)).attr("id", t.domId ?? t.id), { cssStyles: a } = t;
+  let n = Math.max(70, t?.width ?? 0), e = Math.max(10, t?.height ?? 0);
+  h === "LR" && (n = Math.max(10, t?.width ?? 0), e = Math.max(70, t?.height ?? 0));
+  const s = -1 * n / 2, r = -1 * e / 2, g = R.svg(o), y = N(t, {
+    stroke: l.lineColor,
+    fill: l.lineColor
+  });
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = g.rectangle(s, r, n, e, y), d = o.insert(() => p, ":first-child");
+  a && t.look !== "handDrawn" && d.selectAll("path").attr("style", a), i && t.look !== "handDrawn" && d.selectAll("path").attr("style", i), A(t, d);
+  const m = c?.padding ?? 0;
+  return t.width && t.height && (t.width += m / 2 || 0, t.height += m / 2 || 0), t.intersect = function(u) {
+    return M.rect(t, u);
+  }, o;
+}
+w(ce, "forkJoin");
+async function oe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const l = 80, i = 50, { shapeSvg: o, bbox: a } = await _(f, t, T(t)), n = Math.max(l, a.width + (t.padding ?? 0) * 2, t?.width ?? 0), e = Math.max(i, a.height + (t.padding ?? 0) * 2, t?.height ?? 0), s = e / 2, { cssStyles: r } = t, g = R.svg(o), y = N(t, {});
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = [
+    { x: -n / 2, y: -e / 2 },
+    { x: n / 2 - s, y: -e / 2 },
+    ...mt(-n / 2 + s, 0, s, 50, 90, 270),
+    { x: n / 2 - s, y: e / 2 },
+    { x: -n / 2, y: e / 2 }
+  ], d = z(p), m = g.path(d, y), u = o.insert(() => m, ":first-child");
+  return u.attr("class", "basic label-container"), r && t.look !== "handDrawn" && u.selectChildren("path").attr("style", r), c && t.look !== "handDrawn" && u.selectChildren("path").attr("style", c), A(t, u), t.intersect = function(x) {
+    return Y.info("Pill intersect", t, { radius: s, point: x }), M.polygon(t, p, x);
+  }, o;
+}
+w(oe, "halfRoundedRectangle");
+async function he(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = i.height + (t.padding ?? 0), a = i.width + (t.padding ?? 0) * 2.5, { cssStyles: n } = t, e = R.svg(l), s = N(t, {});
+  t.look !== "handDrawn" && (s.roughness = 0, s.fillStyle = "solid");
+  let r = a / 2;
+  const g = r / 6;
+  r = r + g;
+  const y = o / 2, p = y / 2, d = r - p, m = [
+    { x: -d, y: -y },
+    { x: 0, y: -y },
+    { x: d, y: -y },
+    { x: r, y: 0 },
+    { x: d, y },
+    { x: 0, y },
+    { x: -d, y },
+    { x: -r, y: 0 }
+  ], u = z(m), x = e.path(u, s), S = l.insert(() => x, ":first-child");
+  return S.attr("class", "basic label-container"), n && t.look !== "handDrawn" && S.selectChildren("path").attr("style", n), c && t.look !== "handDrawn" && S.selectChildren("path").attr("style", c), t.width = a, t.height = o, A(t, S), t.intersect = function($) {
+    return M.polygon(t, m, $);
+  }, l;
+}
+w(he, "hexagon");
+async function ge(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.label = "", t.labelStyle = h;
+  const { shapeSvg: l } = await _(f, t, T(t)), i = Math.max(30, t?.width ?? 0), o = Math.max(30, t?.height ?? 0), { cssStyles: a } = t, n = R.svg(l), e = N(t, {});
+  t.look !== "handDrawn" && (e.roughness = 0, e.fillStyle = "solid");
+  const s = [
+    { x: 0, y: 0 },
+    { x: i, y: 0 },
+    { x: 0, y: o },
+    { x: i, y: o }
+  ], r = z(s), g = n.path(r, e), y = l.insert(() => g, ":first-child");
+  return y.attr("class", "basic label-container"), a && t.look !== "handDrawn" && y.selectChildren("path").attr("style", a), c && t.look !== "handDrawn" && y.selectChildren("path").attr("style", c), y.attr("transform", `translate(${-i / 2}, ${-o / 2})`), A(t, y), t.intersect = function(p) {
+    return Y.info("Pill intersect", t, { points: s }), M.polygon(t, s, p);
+  }, l;
+}
+w(ge, "hourglass");
+async function ye(f, t, { config: { themeVariables: h, flowchart: c } }) {
+  const { labelStyles: l } = L(t);
+  t.labelStyle = l;
+  const i = t.assetHeight ?? 48, o = t.assetWidth ?? 48, a = Math.max(i, o), n = c?.wrappingWidth;
+  t.width = Math.max(a, n ?? 0);
+  const { shapeSvg: e, bbox: s, label: r } = await _(f, t, "icon-shape default"), g = t.pos === "t", y = a, p = a, { nodeBorder: d } = h, { stylesMap: m } = wt(t), u = -p / 2, x = -y / 2, S = t.label ? 8 : 0, $ = R.svg(e), b = N(t, { stroke: "none", fill: "none" });
+  t.look !== "handDrawn" && (b.roughness = 0, b.fillStyle = "solid");
+  const D = $.rectangle(u, x, p, y, b), v = Math.max(p, s.width), k = y + s.height + S, B = $.rectangle(-v / 2, -k / 2, v, k, {
+    ...b,
+    fill: "transparent",
+    stroke: "none"
+  }), I = e.insert(() => D, ":first-child"), H = e.insert(() => B);
+  if (t.icon) {
+    const W = e.append("g");
+    W.html(
+      `<g>${await bt(t.icon, {
+        height: a,
+        width: a,
+        fallbackPrefix: ""
+      })}</g>`
+    );
+    const C = W.node().getBBox(), E = C.width, X = C.height, P = C.x, j = C.y;
+    W.attr(
+      "transform",
+      `translate(${-E / 2 - P},${g ? s.height / 2 + S / 2 - X / 2 - j : -s.height / 2 - S / 2 - X / 2 - j})`
+    ), W.attr("style", `color: ${m.get("stroke") ?? d};`);
+  }
+  return r.attr(
+    "transform",
+    `translate(${-s.width / 2 - (s.x - (s.left ?? 0))},${g ? -k / 2 : k / 2 - s.height})`
+  ), I.attr(
+    "transform",
+    `translate(0,${g ? s.height / 2 + S / 2 : -s.height / 2 - S / 2})`
+  ), A(t, H), t.intersect = function(W) {
+    if (Y.info("iconSquare intersect", t, W), !t.label)
+      return M.rect(t, W);
+    const C = t.x ?? 0, E = t.y ?? 0, X = t.height ?? 0;
+    let P = [];
+    return g ? P = [
+      { x: C - s.width / 2, y: E - X / 2 },
+      { x: C + s.width / 2, y: E - X / 2 },
+      { x: C + s.width / 2, y: E - X / 2 + s.height + S },
+      { x: C + p / 2, y: E - X / 2 + s.height + S },
+      { x: C + p / 2, y: E + X / 2 },
+      { x: C - p / 2, y: E + X / 2 },
+      { x: C - p / 2, y: E - X / 2 + s.height + S },
+      { x: C - s.width / 2, y: E - X / 2 + s.height + S }
+    ] : P = [
+      { x: C - p / 2, y: E - X / 2 },
+      { x: C + p / 2, y: E - X / 2 },
+      { x: C + p / 2, y: E - X / 2 + y },
+      { x: C + s.width / 2, y: E - X / 2 + y },
+      { x: C + s.width / 2 / 2, y: E + X / 2 },
+      { x: C - s.width / 2, y: E + X / 2 },
+      { x: C - s.width / 2, y: E - X / 2 + y },
+      { x: C - p / 2, y: E - X / 2 + y }
+    ], M.polygon(t, P, W);
+  }, e;
+}
+w(ye, "icon");
+async function fe(f, t, { config: { themeVariables: h, flowchart: c } }) {
+  const { labelStyles: l } = L(t);
+  t.labelStyle = l;
+  const i = t.assetHeight ?? 48, o = t.assetWidth ?? 48, a = Math.max(i, o), n = c?.wrappingWidth;
+  t.width = Math.max(a, n ?? 0);
+  const { shapeSvg: e, bbox: s, label: r } = await _(f, t, "icon-shape default"), g = 20, y = t.label ? 8 : 0, p = t.pos === "t", { nodeBorder: d, mainBkg: m } = h, { stylesMap: u } = wt(t), x = R.svg(e), S = N(t, {});
+  t.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+  const $ = u.get("fill");
+  S.stroke = $ ?? m;
+  const b = e.append("g");
+  t.icon && b.html(
+    `<g>${await bt(t.icon, {
+      height: a,
+      width: a,
+      fallbackPrefix: ""
+    })}</g>`
+  );
+  const D = b.node().getBBox(), v = D.width, k = D.height, B = D.x, I = D.y, H = Math.max(v, k) * Math.SQRT2 + g * 2, W = x.circle(0, 0, H, S), C = Math.max(H, s.width), E = H + s.height + y, X = x.rectangle(-C / 2, -E / 2, C, E, {
+    ...S,
+    fill: "transparent",
+    stroke: "none"
+  }), P = e.insert(() => W, ":first-child"), j = e.insert(() => X);
+  return b.attr(
+    "transform",
+    `translate(${-v / 2 - B},${p ? s.height / 2 + y / 2 - k / 2 - I : -s.height / 2 - y / 2 - k / 2 - I})`
+  ), b.attr("style", `color: ${u.get("stroke") ?? d};`), r.attr(
+    "transform",
+    `translate(${-s.width / 2 - (s.x - (s.left ?? 0))},${p ? -E / 2 : E / 2 - s.height})`
+  ), P.attr(
+    "transform",
+    `translate(0,${p ? s.height / 2 + y / 2 : -s.height / 2 - y / 2})`
+  ), A(t, j), t.intersect = function(O) {
+    return Y.info("iconSquare intersect", t, O), M.rect(t, O);
+  }, e;
+}
+w(fe, "iconCircle");
+async function pe(f, t, { config: { themeVariables: h, flowchart: c } }) {
+  const { labelStyles: l } = L(t);
+  t.labelStyle = l;
+  const i = t.assetHeight ?? 48, o = t.assetWidth ?? 48, a = Math.max(i, o), n = c?.wrappingWidth;
+  t.width = Math.max(a, n ?? 0);
+  const { shapeSvg: e, bbox: s, halfPadding: r, label: g } = await _(
+    f,
+    t,
+    "icon-shape default"
+  ), y = t.pos === "t", p = a + r * 2, d = a + r * 2, { nodeBorder: m, mainBkg: u } = h, { stylesMap: x } = wt(t), S = -d / 2, $ = -p / 2, b = t.label ? 8 : 0, D = R.svg(e), v = N(t, {});
+  t.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+  const k = x.get("fill");
+  v.stroke = k ?? u;
+  const B = D.path(ct(S, $, d, p, 5), v), I = Math.max(d, s.width), H = p + s.height + b, W = D.rectangle(-I / 2, -H / 2, I, H, {
+    ...v,
+    fill: "transparent",
+    stroke: "none"
+  }), C = e.insert(() => B, ":first-child").attr("class", "icon-shape2"), E = e.insert(() => W);
+  if (t.icon) {
+    const X = e.append("g");
+    X.html(
+      `<g>${await bt(t.icon, {
+        height: a,
+        width: a,
+        fallbackPrefix: ""
+      })}</g>`
+    );
+    const P = X.node().getBBox(), j = P.width, O = P.height, J = P.x, st = P.y;
+    X.attr(
+      "transform",
+      `translate(${-j / 2 - J},${y ? s.height / 2 + b / 2 - O / 2 - st : -s.height / 2 - b / 2 - O / 2 - st})`
+    ), X.attr("style", `color: ${x.get("stroke") ?? m};`);
+  }
+  return g.attr(
+    "transform",
+    `translate(${-s.width / 2 - (s.x - (s.left ?? 0))},${y ? -H / 2 : H / 2 - s.height})`
+  ), C.attr(
+    "transform",
+    `translate(0,${y ? s.height / 2 + b / 2 : -s.height / 2 - b / 2})`
+  ), A(t, E), t.intersect = function(X) {
+    if (Y.info("iconSquare intersect", t, X), !t.label)
+      return M.rect(t, X);
+    const P = t.x ?? 0, j = t.y ?? 0, O = t.height ?? 0;
+    let J = [];
+    return y ? J = [
+      { x: P - s.width / 2, y: j - O / 2 },
+      { x: P + s.width / 2, y: j - O / 2 },
+      { x: P + s.width / 2, y: j - O / 2 + s.height + b },
+      { x: P + d / 2, y: j - O / 2 + s.height + b },
+      { x: P + d / 2, y: j + O / 2 },
+      { x: P - d / 2, y: j + O / 2 },
+      { x: P - d / 2, y: j - O / 2 + s.height + b },
+      { x: P - s.width / 2, y: j - O / 2 + s.height + b }
+    ] : J = [
+      { x: P - d / 2, y: j - O / 2 },
+      { x: P + d / 2, y: j - O / 2 },
+      { x: P + d / 2, y: j - O / 2 + p },
+      { x: P + s.width / 2, y: j - O / 2 + p },
+      { x: P + s.width / 2 / 2, y: j + O / 2 },
+      { x: P - s.width / 2, y: j + O / 2 },
+      { x: P - s.width / 2, y: j - O / 2 + p },
+      { x: P - d / 2, y: j - O / 2 + p }
+    ], M.polygon(t, J, X);
+  }, e;
+}
+w(pe, "iconRounded");
+async function de(f, t, { config: { themeVariables: h, flowchart: c } }) {
+  const { labelStyles: l } = L(t);
+  t.labelStyle = l;
+  const i = t.assetHeight ?? 48, o = t.assetWidth ?? 48, a = Math.max(i, o), n = c?.wrappingWidth;
+  t.width = Math.max(a, n ?? 0);
+  const { shapeSvg: e, bbox: s, halfPadding: r, label: g } = await _(
+    f,
+    t,
+    "icon-shape default"
+  ), y = t.pos === "t", p = a + r * 2, d = a + r * 2, { nodeBorder: m, mainBkg: u } = h, { stylesMap: x } = wt(t), S = -d / 2, $ = -p / 2, b = t.label ? 8 : 0, D = R.svg(e), v = N(t, {});
+  t.look !== "handDrawn" && (v.roughness = 0, v.fillStyle = "solid");
+  const k = x.get("fill");
+  v.stroke = k ?? u;
+  const B = D.path(ct(S, $, d, p, 0.1), v), I = Math.max(d, s.width), H = p + s.height + b, W = D.rectangle(-I / 2, -H / 2, I, H, {
+    ...v,
+    fill: "transparent",
+    stroke: "none"
+  }), C = e.insert(() => B, ":first-child"), E = e.insert(() => W);
+  if (t.icon) {
+    const X = e.append("g");
+    X.html(
+      `<g>${await bt(t.icon, {
+        height: a,
+        width: a,
+        fallbackPrefix: ""
+      })}</g>`
+    );
+    const P = X.node().getBBox(), j = P.width, O = P.height, J = P.x, st = P.y;
+    X.attr(
+      "transform",
+      `translate(${-j / 2 - J},${y ? s.height / 2 + b / 2 - O / 2 - st : -s.height / 2 - b / 2 - O / 2 - st})`
+    ), X.attr("style", `color: ${x.get("stroke") ?? m};`);
+  }
+  return g.attr(
+    "transform",
+    `translate(${-s.width / 2 - (s.x - (s.left ?? 0))},${y ? -H / 2 : H / 2 - s.height})`
+  ), C.attr(
+    "transform",
+    `translate(0,${y ? s.height / 2 + b / 2 : -s.height / 2 - b / 2})`
+  ), A(t, E), t.intersect = function(X) {
+    if (Y.info("iconSquare intersect", t, X), !t.label)
+      return M.rect(t, X);
+    const P = t.x ?? 0, j = t.y ?? 0, O = t.height ?? 0;
+    let J = [];
+    return y ? J = [
+      { x: P - s.width / 2, y: j - O / 2 },
+      { x: P + s.width / 2, y: j - O / 2 },
+      { x: P + s.width / 2, y: j - O / 2 + s.height + b },
+      { x: P + d / 2, y: j - O / 2 + s.height + b },
+      { x: P + d / 2, y: j + O / 2 },
+      { x: P - d / 2, y: j + O / 2 },
+      { x: P - d / 2, y: j - O / 2 + s.height + b },
+      { x: P - s.width / 2, y: j - O / 2 + s.height + b }
+    ] : J = [
+      { x: P - d / 2, y: j - O / 2 },
+      { x: P + d / 2, y: j - O / 2 },
+      { x: P + d / 2, y: j - O / 2 + p },
+      { x: P + s.width / 2, y: j - O / 2 + p },
+      { x: P + s.width / 2 / 2, y: j + O / 2 },
+      { x: P - s.width / 2, y: j + O / 2 },
+      { x: P - s.width / 2, y: j - O / 2 + p },
+      { x: P - d / 2, y: j - O / 2 + p }
+    ], M.polygon(t, J, X);
+  }, e;
+}
+w(de, "iconSquare");
+async function ue(f, t, { config: { flowchart: h } }) {
+  const c = new Image();
+  c.src = t?.img ?? "", await c.decode();
+  const l = Number(c.naturalWidth.toString().replace("px", "")), i = Number(c.naturalHeight.toString().replace("px", ""));
+  t.imageAspectRatio = l / i;
+  const { labelStyles: o } = L(t);
+  t.labelStyle = o;
+  const a = h?.wrappingWidth;
+  t.defaultWidth = h?.wrappingWidth;
+  const n = Math.max(
+    t.label ? a ?? 0 : 0,
+    t?.assetWidth ?? l
+  ), e = t.constraint === "on" && t?.assetHeight ? t.assetHeight * t.imageAspectRatio : n, s = t.constraint === "on" ? e / t.imageAspectRatio : t?.assetHeight ?? i;
+  t.width = Math.max(e, a ?? 0);
+  const { shapeSvg: r, bbox: g, label: y } = await _(f, t, "image-shape default"), p = t.pos === "t", d = -e / 2, m = -s / 2, u = t.label ? 8 : 0, x = R.svg(r), S = N(t, {});
+  t.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+  const $ = x.rectangle(d, m, e, s, S), b = Math.max(e, g.width), D = s + g.height + u, v = x.rectangle(-b / 2, -D / 2, b, D, {
+    ...S,
+    fill: "none",
+    stroke: "none"
+  }), k = r.insert(() => $, ":first-child"), B = r.insert(() => v);
+  if (t.img) {
+    const I = r.append("image");
+    I.attr("href", t.img), I.attr("width", e), I.attr("height", s), I.attr("preserveAspectRatio", "none"), I.attr(
+      "transform",
+      `translate(${-e / 2},${p ? D / 2 - s : -D / 2})`
+    );
+  }
+  return y.attr(
+    "transform",
+    `translate(${-g.width / 2 - (g.x - (g.left ?? 0))},${p ? -s / 2 - g.height / 2 - u / 2 : s / 2 - g.height / 2 + u / 2})`
+  ), k.attr(
+    "transform",
+    `translate(0,${p ? g.height / 2 + u / 2 : -g.height / 2 - u / 2})`
+  ), A(t, B), t.intersect = function(I) {
+    if (Y.info("iconSquare intersect", t, I), !t.label)
+      return M.rect(t, I);
+    const H = t.x ?? 0, W = t.y ?? 0, C = t.height ?? 0;
+    let E = [];
+    return p ? E = [
+      { x: H - g.width / 2, y: W - C / 2 },
+      { x: H + g.width / 2, y: W - C / 2 },
+      { x: H + g.width / 2, y: W - C / 2 + g.height + u },
+      { x: H + e / 2, y: W - C / 2 + g.height + u },
+      { x: H + e / 2, y: W + C / 2 },
+      { x: H - e / 2, y: W + C / 2 },
+      { x: H - e / 2, y: W - C / 2 + g.height + u },
+      { x: H - g.width / 2, y: W - C / 2 + g.height + u }
+    ] : E = [
+      { x: H - e / 2, y: W - C / 2 },
+      { x: H + e / 2, y: W - C / 2 },
+      { x: H + e / 2, y: W - C / 2 + s },
+      { x: H + g.width / 2, y: W - C / 2 + s },
+      { x: H + g.width / 2 / 2, y: W + C / 2 },
+      { x: H - g.width / 2, y: W + C / 2 },
+      { x: H - g.width / 2, y: W - C / 2 + s },
+      { x: H - e / 2, y: W - C / 2 + s }
+    ], M.polygon(t, E, I);
+  }, r;
+}
+w(ue, "imageSquare");
+async function me(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), a = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), n = [
+    { x: 0, y: 0 },
+    { x: o, y: 0 },
+    { x: o + 3 * a / 6, y: -a },
+    { x: -3 * a / 6, y: -a }
+  ];
+  let e;
+  const { cssStyles: s } = t;
+  if (t.look === "handDrawn") {
+    const r = R.svg(l), g = N(t, {}), y = z(n), p = r.path(y, g);
+    e = l.insert(() => p, ":first-child").attr("transform", `translate(${-o / 2}, ${a / 2})`), s && e.attr("style", s);
+  } else
+    e = ot(l, o, a, n);
+  return c && e.attr("style", c), t.width = o, t.height = a, A(t, e), t.intersect = function(r) {
+    return M.polygon(t, n, r);
+  }, l;
+}
+w(me, "inv_trapezoid");
+async function $t(f, t, h) {
+  const { labelStyles: c, nodeStyles: l } = L(t);
+  t.labelStyle = c;
+  const { shapeSvg: i, bbox: o } = await _(f, t, T(t)), a = Math.max(o.width + h.labelPaddingX * 2, t?.width || 0), n = Math.max(o.height + h.labelPaddingY * 2, t?.height || 0), e = -a / 2, s = -n / 2;
+  let r, { rx: g, ry: y } = t;
+  const { cssStyles: p } = t;
+  if (h?.rx && h.ry && (g = h.rx, y = h.ry), t.look === "handDrawn") {
+    const d = R.svg(i), m = N(t, {}), u = g || y ? d.path(ct(e, s, a, n, g || 0), m) : d.rectangle(e, s, a, n, m);
+    r = i.insert(() => u, ":first-child"), r.attr("class", "basic label-container").attr("style", K(p));
+  } else
+    r = i.insert("rect", ":first-child"), r.attr("class", "basic label-container").attr("style", l).attr("rx", K(g)).attr("ry", K(y)).attr("x", e).attr("y", s).attr("width", a).attr("height", n);
+  return A(t, r), t.calcIntersect = function(d, m) {
+    return M.rect(d, m);
+  }, t.intersect = function(d) {
+    return M.rect(t, d);
+  }, i;
+}
+w($t, "drawRect");
+async function xe(f, t) {
+  const { shapeSvg: h, bbox: c, label: l } = await _(f, t, "label"), i = h.insert("rect", ":first-child");
+  return i.attr("width", 0.1).attr("height", 0.1), h.attr("class", "label edgeLabel"), l.attr(
+    "transform",
+    `translate(${-(c.width / 2) - (c.x - (c.left ?? 0))}, ${-(c.height / 2) - (c.y - (c.top ?? 0))})`
+  ), A(t, i), t.intersect = function(n) {
+    return M.rect(t, n);
+  }, h;
+}
+w(xe, "labelRect");
+async function we(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = Math.max(i.width + (t.padding ?? 0), t?.width ?? 0), a = Math.max(i.height + (t.padding ?? 0), t?.height ?? 0), n = [
+    { x: 0, y: 0 },
+    { x: o + 3 * a / 6, y: 0 },
+    { x: o, y: -a },
+    { x: -(3 * a) / 6, y: -a }
+  ];
+  let e;
+  const { cssStyles: s } = t;
+  if (t.look === "handDrawn") {
+    const r = R.svg(l), g = N(t, {}), y = z(n), p = r.path(y, g);
+    e = l.insert(() => p, ":first-child").attr("transform", `translate(${-o / 2}, ${a / 2})`), s && e.attr("style", s);
+  } else
+    e = ot(l, o, a, n);
+  return c && e.attr("style", c), t.width = o, t.height = a, A(t, e), t.intersect = function(r) {
+    return M.polygon(t, n, r);
+  }, l;
+}
+w(we, "lean_left");
+async function be(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = Math.max(i.width + (t.padding ?? 0), t?.width ?? 0), a = Math.max(i.height + (t.padding ?? 0), t?.height ?? 0), n = [
+    { x: -3 * a / 6, y: 0 },
+    { x: o, y: 0 },
+    { x: o + 3 * a / 6, y: -a },
+    { x: 0, y: -a }
+  ];
+  let e;
+  const { cssStyles: s } = t;
+  if (t.look === "handDrawn") {
+    const r = R.svg(l), g = N(t, {}), y = z(n), p = r.path(y, g);
+    e = l.insert(() => p, ":first-child").attr("transform", `translate(${-o / 2}, ${a / 2})`), s && e.attr("style", s);
+  } else
+    e = ot(l, o, a, n);
+  return c && e.attr("style", c), t.width = o, t.height = a, A(t, e), t.intersect = function(r) {
+    return M.polygon(t, n, r);
+  }, l;
+}
+w(be, "lean_right");
+function Se(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.label = "", t.labelStyle = h;
+  const l = f.insert("g").attr("class", T(t)).attr("id", t.domId ?? t.id), { cssStyles: i } = t, o = Math.max(35, t?.width ?? 0), a = Math.max(35, t?.height ?? 0), n = 7, e = [
+    { x: o, y: 0 },
+    { x: 0, y: a + n / 2 },
+    { x: o - 2 * n, y: a + n / 2 },
+    { x: 0, y: 2 * a },
+    { x: o, y: a - n / 2 },
+    { x: 2 * n, y: a - n / 2 }
+  ], s = R.svg(l), r = N(t, {});
+  t.look !== "handDrawn" && (r.roughness = 0, r.fillStyle = "solid");
+  const g = z(e), y = s.path(g, r), p = l.insert(() => y, ":first-child");
+  return i && t.look !== "handDrawn" && p.selectAll("path").attr("style", i), c && t.look !== "handDrawn" && p.selectAll("path").attr("style", c), p.attr("transform", `translate(-${o / 2},${-a})`), A(t, p), t.intersect = function(d) {
+    return Y.info("lightningBolt intersect", t, d), M.polygon(t, e, d);
+  }, l;
+}
+w(Se, "lightningBolt");
+var ks = /* @__PURE__ */ w((f, t, h, c, l, i, o) => [
+  `M${f},${t + i}`,
+  `a${l},${i} 0,0,0 ${h},0`,
+  `a${l},${i} 0,0,0 ${-h},0`,
+  `l0,${c}`,
+  `a${l},${i} 0,0,0 ${h},0`,
+  `l0,${-c}`,
+  `M${f},${t + i + o}`,
+  `a${l},${i} 0,0,0 ${h},0`
+].join(" "), "createCylinderPathD"), Ds = /* @__PURE__ */ w((f, t, h, c, l, i, o) => [
+  `M${f},${t + i}`,
+  `M${f + h},${t + i}`,
+  `a${l},${i} 0,0,0 ${-h},0`,
+  `l0,${c}`,
+  `a${l},${i} 0,0,0 ${h},0`,
+  `l0,${-c}`,
+  `M${f},${t + i + o}`,
+  `a${l},${i} 0,0,0 ${h},0`
+].join(" "), "createOuterCylinderPathD"), Bs = /* @__PURE__ */ w((f, t, h, c, l, i) => [`M${f - h / 2},${-c / 2}`, `a${l},${i} 0,0,0 ${h},0`].join(" "), "createInnerCylinderPathD");
+async function $e(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0), t.width ?? 0), n = a / 2, e = n / (2.5 + a / 50), s = Math.max(i.height + e + (t.padding ?? 0), t.height ?? 0), r = s * 0.1;
+  let g;
+  const { cssStyles: y } = t;
+  if (t.look === "handDrawn") {
+    const p = R.svg(l), d = Ds(0, 0, a, s, n, e, r), m = Bs(0, e, a, s, n, e), u = N(t, {}), x = p.path(d, u), S = p.path(m, u);
+    l.insert(() => S, ":first-child").attr("class", "line"), g = l.insert(() => x, ":first-child"), g.attr("class", "basic label-container"), y && g.attr("style", y);
+  } else {
+    const p = ks(0, 0, a, s, n, e, r);
+    g = l.insert("path", ":first-child").attr("d", p).attr("class", "basic label-container").attr("style", K(y)).attr("style", c);
+  }
+  return g.attr("label-offset-y", e), g.attr("transform", `translate(${-a / 2}, ${-(s / 2 + e)})`), A(t, g), o.attr(
+    "transform",
+    `translate(${-(i.width / 2) - (i.x - (i.left ?? 0))}, ${-(i.height / 2) + e - (i.y - (i.top ?? 0))})`
+  ), t.intersect = function(p) {
+    const d = M.rect(t, p), m = d.x - (t.x ?? 0);
+    if (n != 0 && (Math.abs(m) < (t.width ?? 0) / 2 || Math.abs(m) == (t.width ?? 0) / 2 && Math.abs(d.y - (t.y ?? 0)) > (t.height ?? 0) / 2 - e)) {
+      let u = e * e * (1 - m * m / (n * n));
+      u > 0 && (u = Math.sqrt(u)), u = e - u, p.y - (t.y ?? 0) > 0 && (u = -u), d.y += u;
+    }
+    return d;
+  }, l;
+}
+w($e, "linedCylinder");
+async function ve(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = n / 4, s = n + e, { cssStyles: r } = t, g = R.svg(l), y = N(t, {});
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = [
+    { x: -a / 2 - a / 2 * 0.1, y: -s / 2 },
+    { x: -a / 2 - a / 2 * 0.1, y: s / 2 },
+    ...rt(
+      -a / 2 - a / 2 * 0.1,
+      s / 2,
+      a / 2 + a / 2 * 0.1,
+      s / 2,
+      e,
+      0.8
+    ),
+    { x: a / 2 + a / 2 * 0.1, y: -s / 2 },
+    { x: -a / 2 - a / 2 * 0.1, y: -s / 2 },
+    { x: -a / 2, y: -s / 2 },
+    { x: -a / 2, y: s / 2 * 1.1 },
+    { x: -a / 2, y: -s / 2 }
+  ], d = g.polygon(
+    p.map((u) => [u.x, u.y]),
+    y
+  ), m = l.insert(() => d, ":first-child");
+  return m.attr("class", "basic label-container"), r && t.look !== "handDrawn" && m.selectAll("path").attr("style", r), c && t.look !== "handDrawn" && m.selectAll("path").attr("style", c), m.attr("transform", `translate(0,${-e / 2})`), o.attr(
+    "transform",
+    `translate(${-a / 2 + (t.padding ?? 0) + a / 2 * 0.1 / 2 - (i.x - (i.left ?? 0))},${-n / 2 + (t.padding ?? 0) - e / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, m), t.intersect = function(u) {
+    return M.polygon(t, p, u);
+  }, l;
+}
+w(ve, "linedWaveEdgedRect");
+async function ke(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = 5, s = -a / 2, r = -n / 2, { cssStyles: g } = t, y = R.svg(l), p = N(t, {}), d = [
+    { x: s - e, y: r + e },
+    { x: s - e, y: r + n + e },
+    { x: s + a - e, y: r + n + e },
+    { x: s + a - e, y: r + n },
+    { x: s + a, y: r + n },
+    { x: s + a, y: r + n - e },
+    { x: s + a + e, y: r + n - e },
+    { x: s + a + e, y: r - e },
+    { x: s + e, y: r - e },
+    { x: s + e, y: r },
+    { x: s, y: r },
+    { x: s, y: r + e }
+  ], m = [
+    { x: s, y: r + e },
+    { x: s + a - e, y: r + e },
+    { x: s + a - e, y: r + n },
+    { x: s + a, y: r + n },
+    { x: s + a, y: r },
+    { x: s, y: r }
+  ];
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const u = z(d), x = y.path(u, p), S = z(m), $ = y.path(S, { ...p, fill: "none" }), b = l.insert(() => $, ":first-child");
+  return b.insert(() => x, ":first-child"), b.attr("class", "basic label-container"), g && t.look !== "handDrawn" && b.selectAll("path").attr("style", g), c && t.look !== "handDrawn" && b.selectAll("path").attr("style", c), o.attr(
+    "transform",
+    `translate(${-(i.width / 2) - e - (i.x - (i.left ?? 0))}, ${-(i.height / 2) + e - (i.y - (i.top ?? 0))})`
+  ), A(t, b), t.intersect = function(D) {
+    return M.polygon(t, d, D);
+  }, l;
+}
+w(ke, "multiRect");
+async function De(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = n / 4, s = n + e, r = -a / 2, g = -s / 2, y = 5, { cssStyles: p } = t, d = rt(
+    r - y,
+    g + s + y,
+    r + a - y,
+    g + s + y,
+    e,
+    0.8
+  ), m = d?.[d.length - 1], u = [
+    { x: r - y, y: g + y },
+    { x: r - y, y: g + s + y },
+    ...d,
+    { x: r + a - y, y: m.y - y },
+    { x: r + a, y: m.y - y },
+    { x: r + a, y: m.y - 2 * y },
+    { x: r + a + y, y: m.y - 2 * y },
+    { x: r + a + y, y: g - y },
+    { x: r + y, y: g - y },
+    { x: r + y, y: g },
+    { x: r, y: g },
+    { x: r, y: g + y }
+  ], x = [
+    { x: r, y: g + y },
+    { x: r + a - y, y: g + y },
+    { x: r + a - y, y: m.y - y },
+    { x: r + a, y: m.y - y },
+    { x: r + a, y: g },
+    { x: r, y: g }
+  ], S = R.svg(l), $ = N(t, {});
+  t.look !== "handDrawn" && ($.roughness = 0, $.fillStyle = "solid");
+  const b = z(u), D = S.path(b, $), v = z(x), k = S.path(v, $), B = l.insert(() => D, ":first-child");
+  return B.insert(() => k), B.attr("class", "basic label-container"), p && t.look !== "handDrawn" && B.selectAll("path").attr("style", p), c && t.look !== "handDrawn" && B.selectAll("path").attr("style", c), B.attr("transform", `translate(0,${-e / 2})`), o.attr(
+    "transform",
+    `translate(${-(i.width / 2) - y - (i.x - (i.left ?? 0))}, ${-(i.height / 2) + y - e / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, B), t.intersect = function(I) {
+    return M.polygon(t, u, I);
+  }, l;
+}
+w(De, "multiWaveEdgedRectangle");
+async function Be(f, t, { config: { themeVariables: h } }) {
+  const { labelStyles: c, nodeStyles: l } = L(t);
+  t.labelStyle = c, t.useHtmlLabels || ut().flowchart?.htmlLabels !== !1 || (t.centerLabel = !0);
+  const { shapeSvg: o, bbox: a, label: n } = await _(f, t, T(t)), e = Math.max(a.width + (t.padding ?? 0) * 2, t?.width ?? 0), s = Math.max(a.height + (t.padding ?? 0) * 2, t?.height ?? 0), r = -e / 2, g = -s / 2, { cssStyles: y } = t, p = R.svg(o), d = N(t, {
+    fill: h.noteBkgColor,
+    stroke: h.noteBorderColor
+  });
+  t.look !== "handDrawn" && (d.roughness = 0, d.fillStyle = "solid");
+  const m = p.rectangle(r, g, e, s, d), u = o.insert(() => m, ":first-child");
+  return u.attr("class", "basic label-container"), y && t.look !== "handDrawn" && u.selectAll("path").attr("style", y), l && t.look !== "handDrawn" && u.selectAll("path").attr("style", l), n.attr(
+    "transform",
+    `translate(${-a.width / 2 - (a.x - (a.left ?? 0))}, ${-(a.height / 2) - (a.y - (a.top ?? 0))})`
+  ), A(t, u), t.intersect = function(x) {
+    return M.rect(t, x);
+  }, o;
+}
+w(Be, "note");
+var Ms = /* @__PURE__ */ w((f, t, h) => [
+  `M${f + h / 2},${t}`,
+  `L${f + h},${t - h / 2}`,
+  `L${f + h / 2},${t - h}`,
+  `L${f},${t - h / 2}`,
+  "Z"
+].join(" "), "createDecisionBoxPathD");
+async function Me(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = i.width + t.padding, a = i.height + t.padding, n = o + a, e = 0.5, s = [
+    { x: n / 2, y: 0 },
+    { x: n, y: -n / 2 },
+    { x: n / 2, y: -n },
+    { x: 0, y: -n / 2 }
+  ];
+  let r;
+  const { cssStyles: g } = t;
+  if (t.look === "handDrawn") {
+    const y = R.svg(l), p = N(t, {}), d = Ms(0, 0, n), m = y.path(d, p);
+    r = l.insert(() => m, ":first-child").attr("transform", `translate(${-n / 2 + e}, ${n / 2})`), g && r.attr("style", g);
+  } else
+    r = ot(l, n, n, s), r.attr("transform", `translate(${-n / 2 + e}, ${n / 2})`);
+  return c && r.attr("style", c), A(t, r), t.calcIntersect = function(y, p) {
+    const d = y.width, m = [
+      { x: d / 2, y: 0 },
+      { x: d, y: -d / 2 },
+      { x: d / 2, y: -d },
+      { x: 0, y: -d / 2 }
+    ], u = M.polygon(y, m, p);
+    return { x: u.x - 0.5, y: u.y - 0.5 };
+  }, t.intersect = function(y) {
+    return this.calcIntersect(t, y);
+  }, l;
+}
+w(Me, "question");
+async function Ce(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0), t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0), t?.height ?? 0), e = -a / 2, s = -n / 2, r = s / 2, g = [
+    { x: e + r, y: s },
+    { x: e, y: 0 },
+    { x: e + r, y: -s },
+    { x: -e, y: -s },
+    { x: -e, y: s }
+  ], { cssStyles: y } = t, p = R.svg(l), d = N(t, {});
+  t.look !== "handDrawn" && (d.roughness = 0, d.fillStyle = "solid");
+  const m = z(g), u = p.path(m, d), x = l.insert(() => u, ":first-child");
+  return x.attr("class", "basic label-container"), y && t.look !== "handDrawn" && x.selectAll("path").attr("style", y), c && t.look !== "handDrawn" && x.selectAll("path").attr("style", c), x.attr("transform", `translate(${-r / 2},0)`), o.attr(
+    "transform",
+    `translate(${-r / 2 - i.width / 2 - (i.x - (i.left ?? 0))}, ${-(i.height / 2) - (i.y - (i.top ?? 0))})`
+  ), A(t, x), t.intersect = function(S) {
+    return M.polygon(t, g, S);
+  }, l;
+}
+w(Ce, "rect_left_inv_arrow");
+async function Pe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  let l;
+  t.cssClasses ? l = "node " + t.cssClasses : l = "node default";
+  const i = f.insert("g").attr("class", l).attr("id", t.domId || t.id), o = i.insert("g"), a = i.insert("g").attr("class", "label").attr("style", c), n = t.description, e = t.label, s = a.node().appendChild(await Bt(e, t.labelStyle, !0, !0));
+  let r = { width: 0, height: 0 };
+  if (Q(F()?.flowchart?.htmlLabels)) {
+    const k = s.children[0], B = Z(s);
+    r = k.getBoundingClientRect(), B.attr("width", r.width), B.attr("height", r.height);
+  }
+  Y.info("Text 2", n);
+  const g = n || [], y = s.getBBox(), p = a.node().appendChild(
+    await Bt(
+      g.join ? g.join("<br/>") : g,
+      t.labelStyle,
+      !0,
+      !0
+    )
+  ), d = p.children[0], m = Z(p);
+  r = d.getBoundingClientRect(), m.attr("width", r.width), m.attr("height", r.height);
+  const u = (t.padding || 0) / 2;
+  Z(p).attr(
+    "transform",
+    "translate( " + (r.width > y.width ? 0 : (y.width - r.width) / 2) + ", " + (y.height + u + 5) + ")"
+  ), Z(s).attr(
+    "transform",
+    "translate( " + (r.width < y.width ? 0 : -(y.width - r.width) / 2) + ", 0)"
+  ), r = a.node().getBBox(), a.attr(
+    "transform",
+    "translate(" + -r.width / 2 + ", " + (-r.height / 2 - u + 3) + ")"
+  );
+  const x = r.width + (t.padding || 0), S = r.height + (t.padding || 0), $ = -r.width / 2 - u, b = -r.height / 2 - u;
+  let D, v;
+  if (t.look === "handDrawn") {
+    const k = R.svg(i), B = N(t, {}), I = k.path(
+      ct($, b, x, S, t.rx || 0),
+      B
+    ), H = k.line(
+      -r.width / 2 - u,
+      -r.height / 2 - u + y.height + u,
+      r.width / 2 + u,
+      -r.height / 2 - u + y.height + u,
+      B
+    );
+    v = i.insert(() => (Y.debug("Rough node insert CXC", I), H), ":first-child"), D = i.insert(() => (Y.debug("Rough node insert CXC", I), I), ":first-child");
+  } else
+    D = o.insert("rect", ":first-child"), v = o.insert("line"), D.attr("class", "outer title-state").attr("style", c).attr("x", -r.width / 2 - u).attr("y", -r.height / 2 - u).attr("width", r.width + (t.padding || 0)).attr("height", r.height + (t.padding || 0)), v.attr("class", "divider").attr("x1", -r.width / 2 - u).attr("x2", r.width / 2 + u).attr("y1", -r.height / 2 - u + y.height + u).attr("y2", -r.height / 2 - u + y.height + u);
+  return A(t, D), t.intersect = function(k) {
+    return M.rect(t, k);
+  }, i;
+}
+w(Pe, "rectWithTitle");
+function pt(f, t, h, c, l, i, o) {
+  const n = (f + h) / 2, e = (t + c) / 2, s = Math.atan2(c - t, h - f), r = (h - f) / 2, g = (c - t) / 2, y = r / l, p = g / i, d = Math.sqrt(y ** 2 + p ** 2);
+  if (d > 1)
+    throw new Error("The given radii are too small to create an arc between the points.");
+  const m = Math.sqrt(1 - d ** 2), u = n + m * i * Math.sin(s) * (o ? -1 : 1), x = e - m * l * Math.cos(s) * (o ? -1 : 1), S = Math.atan2((t - x) / i, (f - u) / l);
+  let b = Math.atan2((c - x) / i, (h - u) / l) - S;
+  o && b < 0 && (b += 2 * Math.PI), !o && b > 0 && (b -= 2 * Math.PI);
+  const D = [];
+  for (let v = 0; v < 20; v++) {
+    const k = v / 19, B = S + k * b, I = u + l * Math.cos(B), H = x + i * Math.sin(B);
+    D.push({ x: I, y: H });
+  }
+  return D;
+}
+w(pt, "generateArcPoints");
+async function Ne(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = t?.padding ?? 0, a = t?.padding ?? 0, n = (t?.width ? t?.width : i.width) + o * 2, e = (t?.height ? t?.height : i.height) + a * 2, s = t.radius || 5, r = t.taper || 5, { cssStyles: g } = t, y = R.svg(l), p = N(t, {});
+  t.stroke && (p.stroke = t.stroke), t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const d = [
+    // Top edge (left to right)
+    { x: -n / 2 + r, y: -e / 2 },
+    // Top-left corner start (1)
+    { x: n / 2 - r, y: -e / 2 },
+    // Top-right corner start (2)
+    ...pt(n / 2 - r, -e / 2, n / 2, -e / 2 + r, s, s, !0),
+    // Top-left arc (2 to 3)
+    // Right edge (top to bottom)
+    { x: n / 2, y: -e / 2 + r },
+    // Top-right taper point (3)
+    { x: n / 2, y: e / 2 - r },
+    // Bottom-right taper point (4)
+    ...pt(n / 2, e / 2 - r, n / 2 - r, e / 2, s, s, !0),
+    // Top-left arc (4 to 5)
+    // Bottom edge (right to left)
+    { x: n / 2 - r, y: e / 2 },
+    // Bottom-right corner start (5)
+    { x: -n / 2 + r, y: e / 2 },
+    // Bottom-left corner start (6)
+    ...pt(-n / 2 + r, e / 2, -n / 2, e / 2 - r, s, s, !0),
+    // Top-left arc (4 to 5)
+    // Left edge (bottom to top)
+    { x: -n / 2, y: e / 2 - r },
+    // Bottom-left taper point (7)
+    { x: -n / 2, y: -e / 2 + r },
+    // Top-left taper point (8)
+    ...pt(-n / 2, -e / 2 + r, -n / 2 + r, -e / 2, s, s, !0)
+    // Top-left arc (4 to 5)
+  ], m = z(d), u = y.path(m, p), x = l.insert(() => u, ":first-child");
+  return x.attr("class", "basic label-container outer-path"), g && t.look !== "handDrawn" && x.selectChildren("path").attr("style", g), c && t.look !== "handDrawn" && x.selectChildren("path").attr("style", c), A(t, x), t.intersect = function(S) {
+    return M.polygon(t, d, S);
+  }, l;
+}
+w(Ne, "roundedRect");
+async function Re(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = t?.padding ?? 0, n = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), e = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), s = -i.width / 2 - a, r = -i.height / 2 - a, { cssStyles: g } = t, y = R.svg(l), p = N(t, {});
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const d = [
+    { x: s, y: r },
+    { x: s + n + 8, y: r },
+    { x: s + n + 8, y: r + e },
+    { x: s - 8, y: r + e },
+    { x: s - 8, y: r },
+    { x: s, y: r },
+    { x: s, y: r + e }
+  ], m = y.polygon(
+    d.map((x) => [x.x, x.y]),
+    p
+  ), u = l.insert(() => m, ":first-child");
+  return u.attr("class", "basic label-container").attr("style", K(g)), c && t.look !== "handDrawn" && u.selectAll("path").attr("style", c), g && t.look !== "handDrawn" && u.selectAll("path").attr("style", c), o.attr(
+    "transform",
+    `translate(${-n / 2 + 4 + (t.padding ?? 0) - (i.x - (i.left ?? 0))},${-e / 2 + (t.padding ?? 0) - (i.y - (i.top ?? 0))})`
+  ), A(t, u), t.intersect = function(x) {
+    return M.rect(t, x);
+  }, l;
+}
+w(Re, "shadedProcess");
+async function Ae(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = -a / 2, s = -n / 2, { cssStyles: r } = t, g = R.svg(l), y = N(t, {});
+  t.look !== "handDrawn" && (y.roughness = 0, y.fillStyle = "solid");
+  const p = [
+    { x: e, y: s },
+    { x: e, y: s + n },
+    { x: e + a, y: s + n },
+    { x: e + a, y: s - n / 2 }
+  ], d = z(p), m = g.path(d, y), u = l.insert(() => m, ":first-child");
+  return u.attr("class", "basic label-container"), r && t.look !== "handDrawn" && u.selectChildren("path").attr("style", r), c && t.look !== "handDrawn" && u.selectChildren("path").attr("style", c), u.attr("transform", `translate(0, ${n / 4})`), o.attr(
+    "transform",
+    `translate(${-a / 2 + (t.padding ?? 0) - (i.x - (i.left ?? 0))}, ${-n / 4 + (t.padding ?? 0) - (i.y - (i.top ?? 0))})`
+  ), A(t, u), t.intersect = function(x) {
+    return M.polygon(t, p, x);
+  }, l;
+}
+w(Ae, "slopedRect");
+async function Le(f, t) {
+  const h = {
+    rx: 0,
+    ry: 0,
+    labelPaddingX: t.labelPaddingX ?? (t?.padding || 0) * 2,
+    labelPaddingY: (t?.padding || 0) * 1
+  };
+  return $t(f, t, h);
+}
+w(Le, "squareRect");
+async function He(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = i.height + t.padding, a = i.width + o / 4 + t.padding, n = o / 2, { cssStyles: e } = t, s = R.svg(l), r = N(t, {});
+  t.look !== "handDrawn" && (r.roughness = 0, r.fillStyle = "solid");
+  const g = [
+    { x: -a / 2 + n, y: -o / 2 },
+    { x: a / 2 - n, y: -o / 2 },
+    ...mt(-a / 2 + n, 0, n, 50, 90, 270),
+    { x: a / 2 - n, y: o / 2 },
+    ...mt(a / 2 - n, 0, n, 50, 270, 450)
+  ], y = z(g), p = s.path(y, r), d = l.insert(() => p, ":first-child");
+  return d.attr("class", "basic label-container outer-path"), e && t.look !== "handDrawn" && d.selectChildren("path").attr("style", e), c && t.look !== "handDrawn" && d.selectChildren("path").attr("style", c), A(t, d), t.intersect = function(m) {
+    return M.polygon(t, g, m);
+  }, l;
+}
+w(He, "stadium");
+async function We(f, t) {
+  return $t(f, t, {
+    rx: 5,
+    ry: 5
+  });
+}
+w(We, "state");
+function Ee(f, t, { config: { themeVariables: h } }) {
+  const { labelStyles: c, nodeStyles: l } = L(t);
+  t.labelStyle = c;
+  const { cssStyles: i } = t, { lineColor: o, stateBorder: a, nodeBorder: n } = h, e = f.insert("g").attr("class", "node default").attr("id", t.domId || t.id), s = R.svg(e), r = N(t, {});
+  t.look !== "handDrawn" && (r.roughness = 0, r.fillStyle = "solid");
+  const g = s.circle(0, 0, 14, {
+    ...r,
+    stroke: o,
+    strokeWidth: 2
+  }), y = a ?? n, p = s.circle(0, 0, 5, {
+    ...r,
+    fill: y,
+    stroke: y,
+    strokeWidth: 2,
+    fillStyle: "solid"
+  }), d = e.insert(() => g, ":first-child");
+  return d.insert(() => p), i && d.selectAll("path").attr("style", i), l && d.selectAll("path").attr("style", l), A(t, d), t.intersect = function(m) {
+    return M.circle(t, 7, m);
+  }, e;
+}
+w(Ee, "stateEnd");
+function Ie(f, t, { config: { themeVariables: h } }) {
+  const { lineColor: c } = h, l = f.insert("g").attr("class", "node default").attr("id", t.domId || t.id);
+  let i;
+  if (t.look === "handDrawn") {
+    const a = R.svg(l).circle(0, 0, 14, is(c));
+    i = l.insert(() => a), i.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14);
+  } else
+    i = l.insert("circle", ":first-child"), i.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14);
+  return A(t, i), t.intersect = function(o) {
+    return M.circle(t, 7, o);
+  }, l;
+}
+w(Ie, "stateStart");
+async function Te(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = (t?.padding || 0) / 2, a = i.width + t.padding, n = i.height + t.padding, e = -i.width / 2 - o, s = -i.height / 2 - o, r = [
+    { x: 0, y: 0 },
+    { x: a, y: 0 },
+    { x: a, y: -n },
+    { x: 0, y: -n },
+    { x: 0, y: 0 },
+    { x: -8, y: 0 },
+    { x: a + 8, y: 0 },
+    { x: a + 8, y: -n },
+    { x: -8, y: -n },
+    { x: -8, y: 0 }
+  ];
+  if (t.look === "handDrawn") {
+    const g = R.svg(l), y = N(t, {}), p = g.rectangle(e - 8, s, a + 16, n, y), d = g.line(e, s, e, s + n, y), m = g.line(e + a, s, e + a, s + n, y);
+    l.insert(() => d, ":first-child"), l.insert(() => m, ":first-child");
+    const u = l.insert(() => p, ":first-child"), { cssStyles: x } = t;
+    u.attr("class", "basic label-container").attr("style", K(x)), A(t, u);
+  } else {
+    const g = ot(l, a, n, r);
+    c && g.attr("style", c), A(t, g);
+  }
+  return t.intersect = function(g) {
+    return M.polygon(t, r, g);
+  }, l;
+}
+w(Te, "subroutine");
+async function _e(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), a = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), n = -o / 2, e = -a / 2, s = 0.2 * a, r = 0.2 * a, { cssStyles: g } = t, y = R.svg(l), p = N(t, {}), d = [
+    { x: n - s / 2, y: e },
+    { x: n + o + s / 2, y: e },
+    { x: n + o + s / 2, y: e + a },
+    { x: n - s / 2, y: e + a }
+  ], m = [
+    { x: n + o - s / 2, y: e + a },
+    { x: n + o + s / 2, y: e + a },
+    { x: n + o + s / 2, y: e + a - r }
+  ];
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const u = z(d), x = y.path(u, p), S = z(m), $ = y.path(S, { ...p, fillStyle: "solid" }), b = l.insert(() => $, ":first-child");
+  return b.insert(() => x, ":first-child"), b.attr("class", "basic label-container"), g && t.look !== "handDrawn" && b.selectAll("path").attr("style", g), c && t.look !== "handDrawn" && b.selectAll("path").attr("style", c), A(t, b), t.intersect = function(D) {
+    return M.polygon(t, d, D);
+  }, l;
+}
+w(_e, "taggedRect");
+async function Oe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = n / 4, s = 0.2 * a, r = 0.2 * n, g = n + e, { cssStyles: y } = t, p = R.svg(l), d = N(t, {});
+  t.look !== "handDrawn" && (d.roughness = 0, d.fillStyle = "solid");
+  const m = [
+    { x: -a / 2 - a / 2 * 0.1, y: g / 2 },
+    ...rt(
+      -a / 2 - a / 2 * 0.1,
+      g / 2,
+      a / 2 + a / 2 * 0.1,
+      g / 2,
+      e,
+      0.8
+    ),
+    { x: a / 2 + a / 2 * 0.1, y: -g / 2 },
+    { x: -a / 2 - a / 2 * 0.1, y: -g / 2 }
+  ], u = -a / 2 + a / 2 * 0.1, x = -g / 2 - r * 0.4, S = [
+    { x: u + a - s, y: (x + n) * 1.4 },
+    { x: u + a, y: x + n - r },
+    { x: u + a, y: (x + n) * 0.9 },
+    ...rt(
+      u + a,
+      (x + n) * 1.3,
+      u + a - s,
+      (x + n) * 1.5,
+      -n * 0.03,
+      0.5
+    )
+  ], $ = z(m), b = p.path($, d), D = z(S), v = p.path(D, {
+    ...d,
+    fillStyle: "solid"
+  }), k = l.insert(() => v, ":first-child");
+  return k.insert(() => b, ":first-child"), k.attr("class", "basic label-container"), y && t.look !== "handDrawn" && k.selectAll("path").attr("style", y), c && t.look !== "handDrawn" && k.selectAll("path").attr("style", c), k.attr("transform", `translate(0,${-e / 2})`), o.attr(
+    "transform",
+    `translate(${-a / 2 + (t.padding ?? 0) - (i.x - (i.left ?? 0))},${-n / 2 + (t.padding ?? 0) - e / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, k), t.intersect = function(B) {
+    return M.polygon(t, m, B);
+  }, l;
+}
+w(Oe, "taggedWaveEdgedRectangle");
+async function Xe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = Math.max(i.width + t.padding, t?.width || 0), a = Math.max(i.height + t.padding, t?.height || 0), n = -o / 2, e = -a / 2, s = l.insert("rect", ":first-child");
+  return s.attr("class", "text").attr("style", c).attr("rx", 0).attr("ry", 0).attr("x", n).attr("y", e).attr("width", o).attr("height", a), A(t, s), t.intersect = function(r) {
+    return M.rect(t, r);
+  }, l;
+}
+w(Xe, "text");
+var Cs = /* @__PURE__ */ w((f, t, h, c, l, i) => `M${f},${t}
+    a${l},${i} 0,0,1 0,${-c}
+    l${h},0
+    a${l},${i} 0,0,1 0,${c}
+    M${h},${-c}
+    a${l},${i} 0,0,0 0,${c}
+    l${-h},0`, "createCylinderPathD"), Ps = /* @__PURE__ */ w((f, t, h, c, l, i) => [
+  `M${f},${t}`,
+  `M${f + h},${t}`,
+  `a${l},${i} 0,0,0 0,${-c}`,
+  `l${-h},0`,
+  `a${l},${i} 0,0,0 0,${c}`,
+  `l${h},0`
+].join(" "), "createOuterCylinderPathD"), Ns = /* @__PURE__ */ w((f, t, h, c, l, i) => [`M${f + h / 2},${-c / 2}`, `a${l},${i} 0,0,0 0,${c}`].join(" "), "createInnerCylinderPathD");
+async function je(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o, halfPadding: a } = await _(
+    f,
+    t,
+    T(t)
+  ), n = t.look === "neo" ? a * 2 : a, e = i.height + n, s = e / 2, r = s / (2.5 + e / 50), g = i.width + r + n, { cssStyles: y } = t;
+  let p;
+  if (t.look === "handDrawn") {
+    const d = R.svg(l), m = Ps(0, 0, g, e, r, s), u = Ns(0, 0, g, e, r, s), x = d.path(m, N(t, {})), S = d.path(u, N(t, { fill: "none" }));
+    p = l.insert(() => S, ":first-child"), p = l.insert(() => x, ":first-child"), p.attr("class", "basic label-container"), y && p.attr("style", y);
+  } else {
+    const d = Cs(0, 0, g, e, r, s);
+    p = l.insert("path", ":first-child").attr("d", d).attr("class", "basic label-container").attr("style", K(y)).attr("style", c), p.attr("class", "basic label-container"), y && p.selectAll("path").attr("style", y), c && p.selectAll("path").attr("style", c);
+  }
+  return p.attr("label-offset-x", r), p.attr("transform", `translate(${-g / 2}, ${e / 2} )`), o.attr(
+    "transform",
+    `translate(${-(i.width / 2) - r - (i.x - (i.left ?? 0))}, ${-(i.height / 2) - (i.y - (i.top ?? 0))})`
+  ), A(t, p), t.intersect = function(d) {
+    const m = M.rect(t, d), u = m.y - (t.y ?? 0);
+    if (s != 0 && (Math.abs(u) < (t.height ?? 0) / 2 || Math.abs(u) == (t.height ?? 0) / 2 && Math.abs(m.x - (t.x ?? 0)) > (t.width ?? 0) / 2 - r)) {
+      let x = r * r * (1 - u * u / (s * s));
+      x != 0 && (x = Math.sqrt(Math.abs(x))), x = r - x, d.x - (t.x ?? 0) > 0 && (x = -x), m.x += x;
+    }
+    return m;
+  }, l;
+}
+w(je, "tiltedCylinder");
+async function ze(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = i.width + t.padding, a = i.height + t.padding, n = [
+    { x: -3 * a / 6, y: 0 },
+    { x: o + 3 * a / 6, y: 0 },
+    { x: o, y: -a },
+    { x: 0, y: -a }
+  ];
+  let e;
+  const { cssStyles: s } = t;
+  if (t.look === "handDrawn") {
+    const r = R.svg(l), g = N(t, {}), y = z(n), p = r.path(y, g);
+    e = l.insert(() => p, ":first-child").attr("transform", `translate(${-o / 2}, ${a / 2})`), s && e.attr("style", s);
+  } else
+    e = ot(l, o, a, n);
+  return c && e.attr("style", c), t.width = o, t.height = a, A(t, e), t.intersect = function(r) {
+    return M.polygon(t, n, r);
+  }, l;
+}
+w(ze, "trapezoid");
+async function Ye(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = 60, a = 20, n = Math.max(o, i.width + (t.padding ?? 0) * 2, t?.width ?? 0), e = Math.max(a, i.height + (t.padding ?? 0) * 2, t?.height ?? 0), { cssStyles: s } = t, r = R.svg(l), g = N(t, {});
+  t.look !== "handDrawn" && (g.roughness = 0, g.fillStyle = "solid");
+  const y = [
+    { x: -n / 2 * 0.8, y: -e / 2 },
+    { x: n / 2 * 0.8, y: -e / 2 },
+    { x: n / 2, y: -e / 2 * 0.6 },
+    { x: n / 2, y: e / 2 },
+    { x: -n / 2, y: e / 2 },
+    { x: -n / 2, y: -e / 2 * 0.6 }
+  ], p = z(y), d = r.path(p, g), m = l.insert(() => d, ":first-child");
+  return m.attr("class", "basic label-container"), s && t.look !== "handDrawn" && m.selectChildren("path").attr("style", s), c && t.look !== "handDrawn" && m.selectChildren("path").attr("style", c), A(t, m), t.intersect = function(u) {
+    return M.polygon(t, y, u);
+  }, l;
+}
+w(Ye, "trapezoidalPentagon");
+async function qe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Q(F().flowchart?.htmlLabels), n = i.width + (t.padding ?? 0), e = n + i.height, s = n + i.height, r = [
+    { x: 0, y: 0 },
+    { x: s, y: 0 },
+    { x: s / 2, y: -e }
+  ], { cssStyles: g } = t, y = R.svg(l), p = N(t, {});
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const d = z(r), m = y.path(d, p), u = l.insert(() => m, ":first-child").attr("transform", `translate(${-e / 2}, ${e / 2})`);
+  return g && t.look !== "handDrawn" && u.selectChildren("path").attr("style", g), c && t.look !== "handDrawn" && u.selectChildren("path").attr("style", c), t.width = n, t.height = e, A(t, u), o.attr(
+    "transform",
+    `translate(${-i.width / 2 - (i.x - (i.left ?? 0))}, ${e / 2 - (i.height + (t.padding ?? 0) / (a ? 2 : 1) - (i.y - (i.top ?? 0)))})`
+  ), t.intersect = function(x) {
+    return Y.info("Triangle intersect", t, r, x), M.polygon(t, r, x);
+  }, l;
+}
+w(qe, "triangle");
+async function Fe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = n / 8, s = n + e, { cssStyles: r } = t, y = 70 - a, p = y > 0 ? y / 2 : 0, d = R.svg(l), m = N(t, {});
+  t.look !== "handDrawn" && (m.roughness = 0, m.fillStyle = "solid");
+  const u = [
+    { x: -a / 2 - p, y: s / 2 },
+    ...rt(
+      -a / 2 - p,
+      s / 2,
+      a / 2 + p,
+      s / 2,
+      e,
+      0.8
+    ),
+    { x: a / 2 + p, y: -s / 2 },
+    { x: -a / 2 - p, y: -s / 2 }
+  ], x = z(u), S = d.path(x, m), $ = l.insert(() => S, ":first-child");
+  return $.attr("class", "basic label-container"), r && t.look !== "handDrawn" && $.selectAll("path").attr("style", r), c && t.look !== "handDrawn" && $.selectAll("path").attr("style", c), $.attr("transform", `translate(0,${-e / 2})`), o.attr(
+    "transform",
+    `translate(${-a / 2 + (t.padding ?? 0) - (i.x - (i.left ?? 0))},${-n / 2 + (t.padding ?? 0) - e - (i.y - (i.top ?? 0))})`
+  ), A(t, $), t.intersect = function(b) {
+    return M.polygon(t, u, b);
+  }, l;
+}
+w(Fe, "waveEdgedRectangle");
+async function Ge(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i } = await _(f, t, T(t)), o = 100, a = 50, n = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), e = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), s = n / e;
+  let r = n, g = e;
+  r > g * s ? g = r / s : r = g * s, r = Math.max(r, o), g = Math.max(g, a);
+  const y = Math.min(g * 0.2, g / 4), p = g + y * 2, { cssStyles: d } = t, m = R.svg(l), u = N(t, {});
+  t.look !== "handDrawn" && (u.roughness = 0, u.fillStyle = "solid");
+  const x = [
+    { x: -r / 2, y: p / 2 },
+    ...rt(-r / 2, p / 2, r / 2, p / 2, y, 1),
+    { x: r / 2, y: -p / 2 },
+    ...rt(r / 2, -p / 2, -r / 2, -p / 2, y, -1)
+  ], S = z(x), $ = m.path(S, u), b = l.insert(() => $, ":first-child");
+  return b.attr("class", "basic label-container"), d && t.look !== "handDrawn" && b.selectAll("path").attr("style", d), c && t.look !== "handDrawn" && b.selectAll("path").attr("style", c), A(t, b), t.intersect = function(D) {
+    return M.polygon(t, x, D);
+  }, l;
+}
+w(Ge, "waveRectangle");
+async function Ve(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, label: o } = await _(f, t, T(t)), a = Math.max(i.width + (t.padding ?? 0) * 2, t?.width ?? 0), n = Math.max(i.height + (t.padding ?? 0) * 2, t?.height ?? 0), e = 5, s = -a / 2, r = -n / 2, { cssStyles: g } = t, y = R.svg(l), p = N(t, {}), d = [
+    { x: s - e, y: r - e },
+    { x: s - e, y: r + n },
+    { x: s + a, y: r + n },
+    { x: s + a, y: r - e }
+  ], m = `M${s - e},${r - e} L${s + a},${r - e} L${s + a},${r + n} L${s - e},${r + n} L${s - e},${r - e}
+                M${s - e},${r} L${s + a},${r}
+                M${s},${r - e} L${s},${r + n}`;
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const u = y.path(m, p), x = l.insert(() => u, ":first-child");
+  return x.attr("transform", `translate(${e / 2}, ${e / 2})`), x.attr("class", "basic label-container"), g && t.look !== "handDrawn" && x.selectAll("path").attr("style", g), c && t.look !== "handDrawn" && x.selectAll("path").attr("style", c), o.attr(
+    "transform",
+    `translate(${-(i.width / 2) + e / 2 - (i.x - (i.left ?? 0))}, ${-(i.height / 2) + e / 2 - (i.y - (i.top ?? 0))})`
+  ), A(t, x), t.intersect = function(S) {
+    return M.polygon(t, d, S);
+  }, l;
+}
+w(Ve, "windowPane");
+async function Rt(f, t) {
+  const h = t;
+  if (h.alias && (t.label = h.alias), t.look === "handDrawn") {
+    const { themeVariables: q } = ut(), { background: G } = q, U = {
+      ...t,
+      id: t.id + "-background",
+      look: "default",
+      cssStyles: ["stroke: none", `fill: ${G}`]
+    };
+    await Rt(f, U);
+  }
+  const c = ut();
+  t.useHtmlLabels = c.htmlLabels;
+  let l = c.er?.diagramPadding ?? 10, i = c.er?.entityPadding ?? 6;
+  const { cssStyles: o } = t, { labelStyles: a, nodeStyles: n } = L(t);
+  if (h.attributes.length === 0 && t.label) {
+    const q = {
+      rx: 0,
+      ry: 0,
+      labelPaddingX: l,
+      labelPaddingY: l * 1.5
+    };
+    St(t.label, c) + q.labelPaddingX * 2 < c.er.minEntityWidth && (t.width = c.er.minEntityWidth);
+    const G = await $t(f, t, q);
+    if (!Q(c.htmlLabels)) {
+      const U = G.select("text"), tt = U.node()?.getBBox();
+      U.attr("transform", `translate(${-tt.width / 2}, 0)`);
+    }
+    return G;
+  }
+  c.htmlLabels || (l *= 1.25, i *= 1.25);
+  let e = T(t);
+  e || (e = "node default");
+  const s = f.insert("g").attr("class", e).attr("id", t.domId || t.id), r = await yt(s, t.label ?? "", c, 0, 0, ["name"], a);
+  r.height += i;
+  let g = 0;
+  const y = [], p = [];
+  let d = 0, m = 0, u = 0, x = 0, S = !0, $ = !0;
+  for (const q of h.attributes) {
+    const G = await yt(
+      s,
+      q.type,
+      c,
+      0,
+      g,
+      ["attribute-type"],
+      a
+    );
+    d = Math.max(d, G.width + l);
+    const U = await yt(
+      s,
+      q.name,
+      c,
+      0,
+      g,
+      ["attribute-name"],
+      a
+    );
+    m = Math.max(m, U.width + l);
+    const tt = await yt(
+      s,
+      q.keys.join(),
+      c,
+      0,
+      g,
+      ["attribute-keys"],
+      a
+    );
+    u = Math.max(u, tt.width + l);
+    const ht = await yt(
+      s,
+      q.comment,
+      c,
+      0,
+      g,
+      ["attribute-comment"],
+      a
+    );
+    x = Math.max(x, ht.width + l);
+    const nt = Math.max(G.height, U.height, tt.height, ht.height) + i;
+    p.push({ yOffset: g, rowHeight: nt }), g += nt;
+  }
+  let b = 4;
+  u <= l && (S = !1, u = 0, b--), x <= l && ($ = !1, x = 0, b--);
+  const D = s.node().getBBox();
+  if (r.width + l * 2 - (d + m + u + x) > 0) {
+    const q = r.width + l * 2 - (d + m + u + x);
+    d += q / b, m += q / b, u > 0 && (u += q / b), x > 0 && (x += q / b);
+  }
+  const v = d + m + u + x, k = R.svg(s), B = N(t, {});
+  t.look !== "handDrawn" && (B.roughness = 0, B.fillStyle = "solid");
+  let I = 0;
+  p.length > 0 && (I = p.reduce((q, G) => q + (G?.rowHeight ?? 0), 0));
+  const H = Math.max(D.width + l * 2, t?.width || 0, v), W = Math.max((I ?? 0) + r.height, t?.height || 0), C = -H / 2, E = -W / 2;
+  s.selectAll("g:not(:first-child)").each((q, G, U) => {
+    const tt = Z(U[G]), ht = tt.attr("transform");
+    let nt = 0, At = 0;
+    if (ht) {
+      const kt = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(ht);
+      kt && (nt = parseFloat(kt[1]), At = parseFloat(kt[2]), tt.attr("class").includes("attribute-name") ? nt += d : tt.attr("class").includes("attribute-keys") ? nt += d + m : tt.attr("class").includes("attribute-comment") && (nt += d + m + u));
+    }
+    tt.attr(
+      "transform",
+      `translate(${C + l / 2 + nt}, ${At + E + r.height + i / 2})`
+    );
+  }), s.select(".name").attr("transform", "translate(" + -r.width / 2 + ", " + (E + i / 2) + ")");
+  const X = k.rectangle(C, E, H, W, B), P = s.insert(() => X, ":first-child").attr("style", o.join("")), { themeVariables: j } = ut(), { rowEven: O, rowOdd: J, nodeBorder: st } = j;
+  y.push(0);
+  for (const [q, G] of p.entries()) {
+    const tt = (q + 1) % 2 === 0 && G.yOffset !== 0, ht = k.rectangle(C, r.height + E + G?.yOffset, H, G?.rowHeight, {
+      ...B,
+      fill: tt ? O : J,
+      stroke: st
+    });
+    s.insert(() => ht, "g.label").attr("style", o.join("")).attr("class", `row-rect-${tt ? "even" : "odd"}`);
+  }
+  let at = k.line(C, r.height + E, H + C, r.height + E, B);
+  s.insert(() => at).attr("class", "divider"), at = k.line(d + C, r.height + E, d + C, W + E, B), s.insert(() => at).attr("class", "divider"), S && (at = k.line(
+    d + m + C,
+    r.height + E,
+    d + m + C,
+    W + E,
+    B
+  ), s.insert(() => at).attr("class", "divider")), $ && (at = k.line(
+    d + m + u + C,
+    r.height + E,
+    d + m + u + C,
+    W + E,
+    B
+  ), s.insert(() => at).attr("class", "divider"));
+  for (const q of y)
+    at = k.line(
+      C,
+      r.height + E + q,
+      H + C,
+      r.height + E + q,
+      B
+    ), s.insert(() => at).attr("class", "divider");
+  if (A(t, P), n && t.look !== "handDrawn") {
+    const G = n.split(";")?.filter((U) => U.includes("stroke"))?.map((U) => `${U}`).join("; ");
+    s.selectAll("path").attr("style", G ?? ""), s.selectAll(".row-rect-even path").attr("style", n);
+  }
+  return t.intersect = function(q) {
+    return M.rect(t, q);
+  }, s;
+}
+w(Rt, "erBox");
+async function yt(f, t, h, c = 0, l = 0, i = [], o = "") {
+  const a = f.insert("g").attr("class", `label ${i.join(" ")}`).attr("transform", `translate(${c}, ${l})`).attr("style", o);
+  t !== Lt(t) && (t = Lt(t), t = t.replaceAll("<", "&lt;").replaceAll(">", "&gt;"));
+  const n = a.node().appendChild(
+    await gt(
+      a,
+      t,
+      {
+        width: St(t, h) + 100,
+        style: o,
+        useHtmlLabels: h.htmlLabels
+      },
+      h
+    )
+  );
+  if (t.includes("&lt;") || t.includes("&gt;")) {
+    let s = n.children[0];
+    for (s.textContent = s.textContent.replaceAll("&lt;", "<").replaceAll("&gt;", ">"); s.childNodes[0]; )
+      s = s.childNodes[0], s.textContent = s.textContent.replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+  }
+  let e = n.getBBox();
+  if (Q(h.htmlLabels)) {
+    const s = n.children[0];
+    s.style.textAlign = "start";
+    const r = Z(n);
+    e = s.getBoundingClientRect(), r.attr("width", e.width), r.attr("height", e.height);
+  }
+  return e;
+}
+w(yt, "addText");
+async function Ze(f, t, h, c, l = h.class.padding ?? 12) {
+  const i = c ? 0 : 3, o = f.insert("g").attr("class", T(t)).attr("id", t.domId || t.id);
+  let a = null, n = null, e = null, s = null, r = 0, g = 0, y = 0;
+  if (a = o.insert("g").attr("class", "annotation-group text"), t.annotations.length > 0) {
+    const x = t.annotations[0];
+    await dt(a, { text: `«${x}»` }, 0), r = a.node().getBBox().height;
+  }
+  n = o.insert("g").attr("class", "label-group text"), await dt(n, t, 0, ["font-weight: bolder"]);
+  const p = n.node().getBBox();
+  g = p.height, e = o.insert("g").attr("class", "members-group text");
+  let d = 0;
+  for (const x of t.members) {
+    const S = await dt(e, x, d, [x.parseClassifier()]);
+    d += S + i;
+  }
+  y = e.node().getBBox().height, y <= 0 && (y = l / 2), s = o.insert("g").attr("class", "methods-group text");
+  let m = 0;
+  for (const x of t.methods) {
+    const S = await dt(s, x, m, [x.parseClassifier()]);
+    m += S + i;
+  }
+  let u = o.node().getBBox();
+  if (a !== null) {
+    const x = a.node().getBBox();
+    a.attr("transform", `translate(${-x.width / 2})`);
+  }
+  return n.attr("transform", `translate(${-p.width / 2}, ${r})`), u = o.node().getBBox(), e.attr(
+    "transform",
+    `translate(0, ${r + g + l * 2})`
+  ), u = o.node().getBBox(), s.attr(
+    "transform",
+    `translate(0, ${r + g + (y ? y + l * 4 : l * 2)})`
+  ), u = o.node().getBBox(), { shapeSvg: o, bbox: u };
+}
+w(Ze, "textHelper");
+async function dt(f, t, h, c = []) {
+  const l = f.insert("g").attr("class", "label").attr("style", c.join("; ")), i = ut();
+  let o = "useHtmlLabels" in t ? t.useHtmlLabels : Q(i.htmlLabels) ?? !0, a = "";
+  "text" in t ? a = t.text : a = t.label, !o && a.startsWith("\\") && (a = a.substring(1)), Wt(a) && (o = !0);
+  const n = await gt(
+    l,
+    Et(xt(a)),
+    {
+      width: St(a, i) + 50,
+      // Add room for error when splitting text into multiple lines
+      classes: "markdown-node-label",
+      useHtmlLabels: o
+    },
+    i
+  );
+  let e, s = 1;
+  if (o) {
+    const r = n.children[0], g = Z(n);
+    s = r.innerHTML.split("<br>").length, r.innerHTML.includes("</math>") && (s += r.innerHTML.split("<mrow>").length - 1);
+    const y = r.getElementsByTagName("img");
+    if (y) {
+      const p = a.replace(/<img[^>]*>/g, "").trim() === "";
+      await Promise.all(
+        [...y].map(
+          (d) => new Promise((m) => {
+            function u() {
+              if (d.style.display = "flex", d.style.flexDirection = "column", p) {
+                const x = i.fontSize?.toString() ?? window.getComputedStyle(document.body).fontSize, $ = parseInt(x, 10) * 5 + "px";
+                d.style.minWidth = $, d.style.maxWidth = $;
+              } else
+                d.style.width = "100%";
+              m(d);
+            }
+            w(u, "setupImage"), setTimeout(() => {
+              d.complete && u();
+            }), d.addEventListener("error", u), d.addEventListener("load", u);
+          })
+        )
+      );
+    }
+    e = r.getBoundingClientRect(), g.attr("width", e.width), g.attr("height", e.height);
+  } else {
+    c.includes("font-weight: bolder") && Z(n).selectAll("tspan").attr("font-weight", ""), s = n.children.length;
+    const r = n.children[0];
+    (n.textContent === "" || n.textContent.includes("&gt")) && (r.textContent = a[0] + a.substring(1).replaceAll("&gt;", ">").replaceAll("&lt;", "<").trim(), a[1] === " " && (r.textContent = r.textContent[0] + " " + r.textContent.substring(1))), r.textContent === "undefined" && (r.textContent = ""), e = n.getBBox();
+  }
+  return l.attr("transform", "translate(0," + (-e.height / (2 * s) + h) + ")"), e.height;
+}
+w(dt, "addText");
+async function Je(f, t) {
+  const h = F(), c = h.class.padding ?? 12, l = c, i = t.useHtmlLabels ?? Q(h.htmlLabels) ?? !0, o = t;
+  o.annotations = o.annotations ?? [], o.members = o.members ?? [], o.methods = o.methods ?? [];
+  const { shapeSvg: a, bbox: n } = await Ze(f, t, h, i, l), { labelStyles: e, nodeStyles: s } = L(t);
+  t.labelStyle = e, t.cssStyles = o.styles || "";
+  const r = o.styles?.join(";") || s || "";
+  t.cssStyles || (t.cssStyles = r.replaceAll("!important", "").split(";"));
+  const g = o.members.length === 0 && o.methods.length === 0 && !h.class?.hideEmptyMembersBox, y = R.svg(a), p = N(t, {});
+  t.look !== "handDrawn" && (p.roughness = 0, p.fillStyle = "solid");
+  const d = n.width;
+  let m = n.height;
+  o.members.length === 0 && o.methods.length === 0 ? m += l : o.members.length > 0 && o.methods.length === 0 && (m += l * 2);
+  const u = -d / 2, x = -m / 2, S = y.rectangle(
+    u - c,
+    x - c - (g ? c : o.members.length === 0 && o.methods.length === 0 ? -c / 2 : 0),
+    d + 2 * c,
+    m + 2 * c + (g ? c * 2 : o.members.length === 0 && o.methods.length === 0 ? -c : 0),
+    p
+  ), $ = a.insert(() => S, ":first-child");
+  $.attr("class", "basic label-container");
+  const b = $.node().getBBox();
+  a.selectAll(".text").each((B, I, H) => {
+    const W = Z(H[I]), C = W.attr("transform");
+    let E = 0;
+    if (C) {
+      const O = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(C);
+      O && (E = parseFloat(O[2]));
+    }
+    let X = E + x + c - (g ? c : o.members.length === 0 && o.methods.length === 0 ? -c / 2 : 0);
+    i || (X -= 4);
+    let P = u;
+    (W.attr("class").includes("label-group") || W.attr("class").includes("annotation-group")) && (P = -W.node()?.getBBox().width / 2 || 0, a.selectAll("text").each(function(j, O, J) {
+      window.getComputedStyle(J[O]).textAnchor === "middle" && (P = 0);
+    })), W.attr("transform", `translate(${P}, ${X})`);
+  });
+  const D = a.select(".annotation-group").node().getBBox().height - (g ? c / 2 : 0) || 0, v = a.select(".label-group").node().getBBox().height - (g ? c / 2 : 0) || 0, k = a.select(".members-group").node().getBBox().height - (g ? c / 2 : 0) || 0;
+  if (o.members.length > 0 || o.methods.length > 0 || g) {
+    const B = y.line(
+      b.x,
+      D + v + x + c,
+      b.x + b.width,
+      D + v + x + c,
+      p
+    );
+    a.insert(() => B).attr("class", "divider").attr("style", r);
+  }
+  if (g || o.members.length > 0 || o.methods.length > 0) {
+    const B = y.line(
+      b.x,
+      D + v + k + x + l * 2 + c,
+      b.x + b.width,
+      D + v + k + x + c + l * 2,
+      p
+    );
+    a.insert(() => B).attr("class", "divider").attr("style", r);
+  }
+  if (o.look !== "handDrawn" && a.selectAll("path").attr("style", r), $.select(":nth-child(2)").attr("style", r), a.selectAll(".divider").select("path").attr("style", r), t.labelStyle ? a.selectAll("span").attr("style", t.labelStyle) : a.selectAll("span").attr("style", r), !i) {
+    const B = RegExp(/color\s*:\s*([^;]*)/), I = B.exec(r);
+    if (I) {
+      const H = I[0].replace("color", "fill");
+      a.selectAll("tspan").attr("style", H);
+    } else if (e) {
+      const H = B.exec(e);
+      if (H) {
+        const W = H[0].replace("color", "fill");
+        a.selectAll("tspan").attr("style", W);
+      }
+    }
+  }
+  return A(t, $), t.intersect = function(B) {
+    return M.rect(t, B);
+  }, a;
+}
+w(Je, "classBox");
+async function Qe(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const l = t, i = t, o = 20, a = 20, n = "verifyMethod" in t, e = T(t), s = f.insert("g").attr("class", e).attr("id", t.domId ?? t.id);
+  let r;
+  n ? r = await et(
+    s,
+    `&lt;&lt;${l.type}&gt;&gt;`,
+    0,
+    t.labelStyle
+  ) : r = await et(s, "&lt;&lt;Element&gt;&gt;", 0, t.labelStyle);
+  let g = r;
+  const y = await et(
+    s,
+    l.name,
+    g,
+    t.labelStyle + "; font-weight: bold;"
+  );
+  if (g += y + a, n) {
+    const D = await et(
+      s,
+      `${l.requirementId ? `ID: ${l.requirementId}` : ""}`,
+      g,
+      t.labelStyle
+    );
+    g += D;
+    const v = await et(
+      s,
+      `${l.text ? `Text: ${l.text}` : ""}`,
+      g,
+      t.labelStyle
+    );
+    g += v;
+    const k = await et(
+      s,
+      `${l.risk ? `Risk: ${l.risk}` : ""}`,
+      g,
+      t.labelStyle
+    );
+    g += k, await et(
+      s,
+      `${l.verifyMethod ? `Verification: ${l.verifyMethod}` : ""}`,
+      g,
+      t.labelStyle
+    );
+  } else {
+    const D = await et(
+      s,
+      `${i.type ? `Type: ${i.type}` : ""}`,
+      g,
+      t.labelStyle
+    );
+    g += D, await et(
+      s,
+      `${i.docRef ? `Doc Ref: ${i.docRef}` : ""}`,
+      g,
+      t.labelStyle
+    );
+  }
+  const p = (s.node()?.getBBox().width ?? 200) + o, d = (s.node()?.getBBox().height ?? 200) + o, m = -p / 2, u = -d / 2, x = R.svg(s), S = N(t, {});
+  t.look !== "handDrawn" && (S.roughness = 0, S.fillStyle = "solid");
+  const $ = x.rectangle(m, u, p, d, S), b = s.insert(() => $, ":first-child");
+  if (b.attr("class", "basic label-container").attr("style", c), s.selectAll(".label").each((D, v, k) => {
+    const B = Z(k[v]), I = B.attr("transform");
+    let H = 0, W = 0;
+    if (I) {
+      const P = RegExp(/translate\(([^,]+),([^)]+)\)/).exec(I);
+      P && (H = parseFloat(P[1]), W = parseFloat(P[2]));
+    }
+    const C = W - d / 2;
+    let E = m + o / 2;
+    (v === 0 || v === 1) && (E = H), B.attr("transform", `translate(${E}, ${C + o})`);
+  }), g > r + y + a) {
+    const D = x.line(
+      m,
+      u + r + y + a,
+      m + p,
+      u + r + y + a,
+      S
+    );
+    s.insert(() => D).attr("style", c);
+  }
+  return A(t, b), t.intersect = function(D) {
+    return M.rect(t, D);
+  }, s;
+}
+w(Qe, "requirementBox");
+async function et(f, t, h, c = "") {
+  if (t === "")
+    return 0;
+  const l = f.insert("g").attr("class", "label").attr("style", c), i = F(), o = i.htmlLabels ?? !0, a = await gt(
+    l,
+    Et(xt(t)),
+    {
+      width: St(t, i) + 50,
+      // Add room for error when splitting text into multiple lines
+      classes: "markdown-node-label",
+      useHtmlLabels: o,
+      style: c
+    },
+    i
+  );
+  let n;
+  if (o) {
+    const e = a.children[0], s = Z(a);
+    n = e.getBoundingClientRect(), s.attr("width", n.width), s.attr("height", n.height);
+  } else {
+    const e = a.children[0];
+    for (const s of e.children)
+      s.textContent = s.textContent.replaceAll("&gt;", ">").replaceAll("&lt;", "<"), c && s.setAttribute("style", c);
+    n = a.getBBox(), n.height += 6;
+  }
+  return l.attr("transform", `translate(${-n.width / 2},${-n.height / 2 + h})`), n.height;
+}
+w(et, "addText");
+var Rs = /* @__PURE__ */ w((f) => {
+  switch (f) {
+    case "Very High":
+      return "red";
+    case "High":
+      return "orange";
+    case "Medium":
+      return null;
+    // no stroke
+    case "Low":
+      return "blue";
+    case "Very Low":
+      return "lightblue";
+  }
+}, "colorFromPriority");
+async function Ke(f, t, { config: h }) {
+  const { labelStyles: c, nodeStyles: l } = L(t);
+  t.labelStyle = c || "";
+  const i = 10, o = t.width;
+  t.width = (t.width ?? 200) - 10;
+  const {
+    shapeSvg: a,
+    bbox: n,
+    label: e
+  } = await _(f, t, T(t)), s = t.padding || 10;
+  let r = "", g;
+  "ticket" in t && t.ticket && h?.kanban?.ticketBaseUrl && (r = h?.kanban?.ticketBaseUrl.replace("#TICKET#", t.ticket), g = a.insert("svg:a", ":first-child").attr("class", "kanban-ticket-link").attr("xlink:href", r).attr("target", "_blank"));
+  const y = {
+    useHtmlLabels: t.useHtmlLabels,
+    labelStyle: t.labelStyle || "",
+    width: t.width,
+    img: t.img,
+    padding: t.padding || 8,
+    centerLabel: !1
+  };
+  let p, d;
+  g ? { label: p, bbox: d } = await Dt(
+    g,
+    "ticket" in t && t.ticket || "",
+    y
+  ) : { label: p, bbox: d } = await Dt(
+    a,
+    "ticket" in t && t.ticket || "",
+    y
+  );
+  const { label: m, bbox: u } = await Dt(
+    a,
+    "assigned" in t && t.assigned || "",
+    y
+  );
+  t.width = o;
+  const x = 10, S = t?.width || 0, $ = Math.max(d.height, u.height) / 2, b = Math.max(n.height + x * 2, t?.height || 0) + $, D = -S / 2, v = -b / 2;
+  e.attr(
+    "transform",
+    "translate(" + (s - S / 2) + ", " + (-$ - n.height / 2) + ")"
+  ), p.attr(
+    "transform",
+    "translate(" + (s - S / 2) + ", " + (-$ + n.height / 2) + ")"
+  ), m.attr(
+    "transform",
+    "translate(" + (s + S / 2 - u.width - 2 * i) + ", " + (-$ + n.height / 2) + ")"
+  );
+  let k;
+  const { rx: B, ry: I } = t, { cssStyles: H } = t;
+  if (t.look === "handDrawn") {
+    const W = R.svg(a), C = N(t, {}), E = B || I ? W.path(ct(D, v, S, b, B || 0), C) : W.rectangle(D, v, S, b, C);
+    k = a.insert(() => E, ":first-child"), k.attr("class", "basic label-container").attr("style", H || null);
+  } else {
+    k = a.insert("rect", ":first-child"), k.attr("class", "basic label-container __APA__").attr("style", l).attr("rx", B ?? 5).attr("ry", I ?? 5).attr("x", D).attr("y", v).attr("width", S).attr("height", b);
+    const W = "priority" in t && t.priority;
+    if (W) {
+      const C = a.append("line"), E = D + 2, X = v + Math.floor((B ?? 0) / 2), P = v + b - Math.floor((B ?? 0) / 2);
+      C.attr("x1", E).attr("y1", X).attr("x2", E).attr("y2", P).attr("stroke-width", "4").attr("stroke", Rs(W));
+    }
+  }
+  return A(t, k), t.height = b, t.intersect = function(W) {
+    return M.rect(t, W);
+  }, a;
+}
+w(Ke, "kanbanItem");
+async function Ue(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, halfPadding: o, label: a } = await _(
+    f,
+    t,
+    T(t)
+  ), n = i.width + 10 * o, e = i.height + 8 * o, s = 0.15 * n, { cssStyles: r } = t, g = i.width + 20, y = i.height + 20, p = Math.max(n, g), d = Math.max(e, y);
+  a.attr("transform", `translate(${-i.width / 2}, ${-i.height / 2})`);
+  let m;
+  const u = `M0 0 
+    a${s},${s} 1 0,0 ${p * 0.25},${-1 * d * 0.1}
+    a${s},${s} 1 0,0 ${p * 0.25},0
+    a${s},${s} 1 0,0 ${p * 0.25},0
+    a${s},${s} 1 0,0 ${p * 0.25},${d * 0.1}
+
+    a${s},${s} 1 0,0 ${p * 0.15},${d * 0.33}
+    a${s * 0.8},${s * 0.8} 1 0,0 0,${d * 0.34}
+    a${s},${s} 1 0,0 ${-1 * p * 0.15},${d * 0.33}
+
+    a${s},${s} 1 0,0 ${-1 * p * 0.25},${d * 0.15}
+    a${s},${s} 1 0,0 ${-1 * p * 0.25},0
+    a${s},${s} 1 0,0 ${-1 * p * 0.25},0
+    a${s},${s} 1 0,0 ${-1 * p * 0.25},${-1 * d * 0.15}
+
+    a${s},${s} 1 0,0 ${-1 * p * 0.1},${-1 * d * 0.33}
+    a${s * 0.8},${s * 0.8} 1 0,0 0,${-1 * d * 0.34}
+    a${s},${s} 1 0,0 ${p * 0.1},${-1 * d * 0.33}
+  H0 V0 Z`;
+  if (t.look === "handDrawn") {
+    const x = R.svg(l), S = N(t, {}), $ = x.path(u, S);
+    m = l.insert(() => $, ":first-child"), m.attr("class", "basic label-container").attr("style", K(r));
+  } else
+    m = l.insert("path", ":first-child").attr("class", "basic label-container").attr("style", c).attr("d", u);
+  return m.attr("transform", `translate(${-p / 2}, ${-d / 2})`), A(t, m), t.calcIntersect = function(x, S) {
+    return M.rect(x, S);
+  }, t.intersect = function(x) {
+    return Y.info("Bang intersect", t, x), M.rect(t, x);
+  }, l;
+}
+w(Ue, "bang");
+async function ts(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, halfPadding: o, label: a } = await _(
+    f,
+    t,
+    T(t)
+  ), n = i.width + 2 * o, e = i.height + 2 * o, s = 0.15 * n, r = 0.25 * n, g = 0.35 * n, y = 0.2 * n, { cssStyles: p } = t;
+  let d;
+  const m = `M0 0 
+    a${s},${s} 0 0,1 ${n * 0.25},${-1 * n * 0.1}
+    a${g},${g} 1 0,1 ${n * 0.4},${-1 * n * 0.1}
+    a${r},${r} 1 0,1 ${n * 0.35},${n * 0.2}
+
+    a${s},${s} 1 0,1 ${n * 0.15},${e * 0.35}
+    a${y},${y} 1 0,1 ${-1 * n * 0.15},${e * 0.65}
+
+    a${r},${s} 1 0,1 ${-1 * n * 0.25},${n * 0.15}
+    a${g},${g} 1 0,1 ${-1 * n * 0.5},0
+    a${s},${s} 1 0,1 ${-1 * n * 0.25},${-1 * n * 0.15}
+
+    a${s},${s} 1 0,1 ${-1 * n * 0.1},${-1 * e * 0.35}
+    a${y},${y} 1 0,1 ${n * 0.1},${-1 * e * 0.65}
+  H0 V0 Z`;
+  if (t.look === "handDrawn") {
+    const u = R.svg(l), x = N(t, {}), S = u.path(m, x);
+    d = l.insert(() => S, ":first-child"), d.attr("class", "basic label-container").attr("style", K(p));
+  } else
+    d = l.insert("path", ":first-child").attr("class", "basic label-container").attr("style", c).attr("d", m);
+  return a.attr("transform", `translate(${-i.width / 2}, ${-i.height / 2})`), d.attr("transform", `translate(${-n / 2}, ${-e / 2})`), A(t, d), t.calcIntersect = function(u, x) {
+    return M.rect(u, x);
+  }, t.intersect = function(u) {
+    return Y.info("Cloud intersect", t, u), M.rect(t, u);
+  }, l;
+}
+w(ts, "cloud");
+async function es(f, t) {
+  const { labelStyles: h, nodeStyles: c } = L(t);
+  t.labelStyle = h;
+  const { shapeSvg: l, bbox: i, halfPadding: o, label: a } = await _(
+    f,
+    t,
+    T(t)
+  ), n = i.width + 8 * o, e = i.height + 2 * o, s = 5, r = `
+    M${-n / 2} ${e / 2 - s}
+    v${-e + 2 * s}
+    q0,-${s} ${s},-${s}
+    h${n - 2 * s}
+    q${s},0 ${s},${s}
+    v${e - 2 * s}
+    q0,${s} -${s},${s}
+    h${-n + 2 * s}
+    q-${s},0 -${s},-${s}
+    Z
+  `, g = l.append("path").attr("id", "node-" + t.id).attr("class", "node-bkg node-" + t.type).attr("style", c).attr("d", r);
+  return l.append("line").attr("class", "node-line-").attr("x1", -n / 2).attr("y1", e / 2).attr("x2", n / 2).attr("y2", e / 2), a.attr("transform", `translate(${-i.width / 2}, ${-i.height / 2})`), l.append(() => a.node()), A(t, g), t.calcIntersect = function(y, p) {
+    return M.rect(y, p);
+  }, t.intersect = function(y) {
+    return M.rect(t, y);
+  }, l;
+}
+w(es, "defaultMindmapNode");
+async function ss(f, t) {
+  const h = {
+    padding: t.padding ?? 0
+  };
+  return Nt(f, t, h);
+}
+w(ss, "mindmapCircle");
+var As = [
+  {
+    semanticName: "Process",
+    name: "Rectangle",
+    shortName: "rect",
+    description: "Standard process shape",
+    aliases: ["proc", "process", "rectangle"],
+    internalAliases: ["squareRect"],
+    handler: Le
+  },
+  {
+    semanticName: "Event",
+    name: "Rounded Rectangle",
+    shortName: "rounded",
+    description: "Represents an event",
+    aliases: ["event"],
+    internalAliases: ["roundedRect"],
+    handler: Ne
+  },
+  {
+    semanticName: "Terminal Point",
+    name: "Stadium",
+    shortName: "stadium",
+    description: "Terminal point",
+    aliases: ["terminal", "pill"],
+    handler: He
+  },
+  {
+    semanticName: "Subprocess",
+    name: "Framed Rectangle",
+    shortName: "fr-rect",
+    description: "Subprocess",
+    aliases: ["subprocess", "subproc", "framed-rectangle", "subroutine"],
+    handler: Te
+  },
+  {
+    semanticName: "Database",
+    name: "Cylinder",
+    shortName: "cyl",
+    description: "Database storage",
+    aliases: ["db", "database", "cylinder"],
+    handler: ae
+  },
+  {
+    semanticName: "Start",
+    name: "Circle",
+    shortName: "circle",
+    description: "Starting point",
+    aliases: ["circ"],
+    handler: Nt
+  },
+  {
+    semanticName: "Bang",
+    name: "Bang",
+    shortName: "bang",
+    description: "Bang",
+    aliases: ["bang"],
+    handler: Ue
+  },
+  {
+    semanticName: "Cloud",
+    name: "Cloud",
+    shortName: "cloud",
+    description: "cloud",
+    aliases: ["cloud"],
+    handler: ts
+  },
+  {
+    semanticName: "Decision",
+    name: "Diamond",
+    shortName: "diam",
+    description: "Decision-making step",
+    aliases: ["decision", "diamond", "question"],
+    handler: Me
+  },
+  {
+    semanticName: "Prepare Conditional",
+    name: "Hexagon",
+    shortName: "hex",
+    description: "Preparation or condition step",
+    aliases: ["hexagon", "prepare"],
+    handler: he
+  },
+  {
+    semanticName: "Data Input/Output",
+    name: "Lean Right",
+    shortName: "lean-r",
+    description: "Represents input or output",
+    aliases: ["lean-right", "in-out"],
+    internalAliases: ["lean_right"],
+    handler: be
+  },
+  {
+    semanticName: "Data Input/Output",
+    name: "Lean Left",
+    shortName: "lean-l",
+    description: "Represents output or input",
+    aliases: ["lean-left", "out-in"],
+    internalAliases: ["lean_left"],
+    handler: we
+  },
+  {
+    semanticName: "Priority Action",
+    name: "Trapezoid Base Bottom",
+    shortName: "trap-b",
+    description: "Priority action",
+    aliases: ["priority", "trapezoid-bottom", "trapezoid"],
+    handler: ze
+  },
+  {
+    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: me
+  },
+  {
+    semanticName: "Stop",
+    name: "Double Circle",
+    shortName: "dbl-circ",
+    description: "Represents a stop point",
+    aliases: ["double-circle"],
+    internalAliases: ["doublecircle"],
+    handler: le
+  },
+  {
+    semanticName: "Text Block",
+    name: "Text Block",
+    shortName: "text",
+    description: "Text block",
+    handler: Xe
+  },
+  {
+    semanticName: "Card",
+    name: "Notched Rectangle",
+    shortName: "notch-rect",
+    description: "Represents a card",
+    aliases: ["card", "notched-rectangle"],
+    handler: Zt
+  },
+  {
+    semanticName: "Lined/Shaded Process",
+    name: "Lined Rectangle",
+    shortName: "lin-rect",
+    description: "Lined process shape",
+    aliases: ["lined-rectangle", "lined-process", "lin-proc", "shaded-process"],
+    handler: Re
+  },
+  {
+    semanticName: "Start",
+    name: "Small Circle",
+    shortName: "sm-circ",
+    description: "Small starting point",
+    aliases: ["start", "small-circle"],
+    internalAliases: ["stateStart"],
+    handler: Ie
+  },
+  {
+    semanticName: "Stop",
+    name: "Framed Circle",
+    shortName: "fr-circ",
+    description: "Stop point",
+    aliases: ["stop", "framed-circle"],
+    internalAliases: ["stateEnd"],
+    handler: Ee
+  },
+  {
+    semanticName: "Fork/Join",
+    name: "Filled Rectangle",
+    shortName: "fork",
+    description: "Fork or join in process flow",
+    aliases: ["join"],
+    internalAliases: ["forkJoin"],
+    handler: ce
+  },
+  {
+    semanticName: "Collate",
+    name: "Hourglass",
+    shortName: "hourglass",
+    description: "Represents a collate operation",
+    aliases: ["hourglass", "collate"],
+    handler: ge
+  },
+  {
+    semanticName: "Comment",
+    name: "Curly Brace",
+    shortName: "brace",
+    description: "Adds a comment",
+    aliases: ["comment", "brace-l"],
+    handler: Ut
+  },
+  {
+    semanticName: "Comment Right",
+    name: "Curly Brace",
+    shortName: "brace-r",
+    description: "Adds a comment",
+    handler: te
+  },
+  {
+    semanticName: "Comment with braces on both sides",
+    name: "Curly Braces",
+    shortName: "braces",
+    description: "Adds a comment",
+    handler: ee
+  },
+  {
+    semanticName: "Com Link",
+    name: "Lightning Bolt",
+    shortName: "bolt",
+    description: "Communication link",
+    aliases: ["com-link", "lightning-bolt"],
+    handler: Se
+  },
+  {
+    semanticName: "Document",
+    name: "Document",
+    shortName: "doc",
+    description: "Represents a document",
+    aliases: ["doc", "document"],
+    handler: Fe
+  },
+  {
+    semanticName: "Delay",
+    name: "Half-Rounded Rectangle",
+    shortName: "delay",
+    description: "Represents a delay",
+    aliases: ["half-rounded-rectangle"],
+    handler: oe
+  },
+  {
+    semanticName: "Direct Access Storage",
+    name: "Horizontal Cylinder",
+    shortName: "h-cyl",
+    description: "Direct access storage",
+    aliases: ["das", "horizontal-cylinder"],
+    handler: je
+  },
+  {
+    semanticName: "Disk Storage",
+    name: "Lined Cylinder",
+    shortName: "lin-cyl",
+    description: "Disk storage",
+    aliases: ["disk", "lined-cylinder"],
+    handler: $e
+  },
+  {
+    semanticName: "Display",
+    name: "Curved Trapezoid",
+    shortName: "curv-trap",
+    description: "Represents a display",
+    aliases: ["curved-trapezoid", "display"],
+    handler: se
+  },
+  {
+    semanticName: "Divided Process",
+    name: "Divided Rectangle",
+    shortName: "div-rect",
+    description: "Divided process shape",
+    aliases: ["div-proc", "divided-rectangle", "divided-process"],
+    handler: ie
+  },
+  {
+    semanticName: "Extract",
+    name: "Triangle",
+    shortName: "tri",
+    description: "Extraction process",
+    aliases: ["extract", "triangle"],
+    handler: qe
+  },
+  {
+    semanticName: "Internal Storage",
+    name: "Window Pane",
+    shortName: "win-pane",
+    description: "Internal storage",
+    aliases: ["internal-storage", "window-pane"],
+    handler: Ve
+  },
+  {
+    semanticName: "Junction",
+    name: "Filled Circle",
+    shortName: "f-circ",
+    description: "Junction point",
+    aliases: ["junction", "filled-circle"],
+    handler: ne
+  },
+  {
+    semanticName: "Loop Limit",
+    name: "Trapezoidal Pentagon",
+    shortName: "notch-pent",
+    description: "Loop limit step",
+    aliases: ["loop-limit", "notched-pentagon"],
+    handler: Ye
+  },
+  {
+    semanticName: "Manual File",
+    name: "Flipped Triangle",
+    shortName: "flip-tri",
+    description: "Manual file operation",
+    aliases: ["manual-file", "flipped-triangle"],
+    handler: re
+  },
+  {
+    semanticName: "Manual Input",
+    name: "Sloped Rectangle",
+    shortName: "sl-rect",
+    description: "Manual input step",
+    aliases: ["manual-input", "sloped-rectangle"],
+    handler: Ae
+  },
+  {
+    semanticName: "Multi-Document",
+    name: "Stacked Document",
+    shortName: "docs",
+    description: "Multiple documents",
+    aliases: ["documents", "st-doc", "stacked-document"],
+    handler: De
+  },
+  {
+    semanticName: "Multi-Process",
+    name: "Stacked Rectangle",
+    shortName: "st-rect",
+    description: "Multiple processes",
+    aliases: ["procs", "processes", "stacked-rectangle"],
+    handler: ke
+  },
+  {
+    semanticName: "Stored Data",
+    name: "Bow Tie Rectangle",
+    shortName: "bow-rect",
+    description: "Stored data",
+    aliases: ["stored-data", "bow-tie-rectangle"],
+    handler: Vt
+  },
+  {
+    semanticName: "Summary",
+    name: "Crossed Circle",
+    shortName: "cross-circ",
+    description: "Summary",
+    aliases: ["summary", "crossed-circle"],
+    handler: Kt
+  },
+  {
+    semanticName: "Tagged Document",
+    name: "Tagged Document",
+    shortName: "tag-doc",
+    description: "Tagged document",
+    aliases: ["tag-doc", "tagged-document"],
+    handler: Oe
+  },
+  {
+    semanticName: "Tagged Process",
+    name: "Tagged Rectangle",
+    shortName: "tag-rect",
+    description: "Tagged process",
+    aliases: ["tagged-rectangle", "tag-proc", "tagged-process"],
+    handler: _e
+  },
+  {
+    semanticName: "Paper Tape",
+    name: "Flag",
+    shortName: "flag",
+    description: "Paper tape",
+    aliases: ["paper-tape"],
+    handler: Ge
+  },
+  {
+    semanticName: "Odd",
+    name: "Odd",
+    shortName: "odd",
+    description: "Odd shape",
+    internalAliases: ["rect_left_inv_arrow"],
+    handler: Ce
+  },
+  {
+    semanticName: "Lined Document",
+    name: "Lined Document",
+    shortName: "lin-doc",
+    description: "Lined document",
+    aliases: ["lined-document"],
+    handler: ve
+  }
+], Ls = /* @__PURE__ */ w(() => {
+  const t = [
+    ...Object.entries({
+      // States
+      state: We,
+      choice: Jt,
+      note: Be,
+      // Rectangles
+      rectWithTitle: Pe,
+      labelRect: xe,
+      // Icons
+      iconSquare: de,
+      iconCircle: fe,
+      icon: ye,
+      iconRounded: pe,
+      imageSquare: ue,
+      anchor: Gt,
+      // Kanban diagram
+      kanbanItem: Ke,
+      //Mindmap diagram
+      mindmapCircle: ss,
+      defaultMindmapNode: es,
+      // class diagram
+      classBox: Je,
+      // er diagram
+      erBox: Rt,
+      // Requirement diagram
+      requirementBox: Qe
+    }),
+    ...As.flatMap((h) => [
+      h.shortName,
+      ..."aliases" in h ? h.aliases : [],
+      ..."internalAliases" in h ? h.internalAliases : []
+    ].map((l) => [l, h.handler]))
+  ];
+  return Object.fromEntries(t);
+}, "generateShapeMap"), as = Ls();
+function Hs(f) {
+  return f in as;
+}
+w(Hs, "isValidShape");
+var vt = /* @__PURE__ */ new Map();
+async function Ws(f, t, h) {
+  let c, l;
+  t.shape === "rect" && (t.rx && t.ry ? t.shape = "roundedRect" : t.shape = "squareRect");
+  const i = t.shape ? as[t.shape] : void 0;
+  if (!i)
+    throw new Error(`No such shape: ${t.shape}. Please check your syntax.`);
+  if (t.link) {
+    let o;
+    h.config.securityLevel === "sandbox" ? o = "_top" : t.linkTarget && (o = t.linkTarget || "_blank"), c = f.insert("svg:a").attr("xlink:href", t.link).attr("target", o ?? null), l = await i(c, t, h);
+  } else
+    l = await i(f, t, h), c = l;
+  return t.tooltip && l.attr("title", t.tooltip), vt.set(t.id, c), t.haveCallback && c.attr("class", c.attr("class") + " clickable"), c;
+}
+w(Ws, "insertNode");
+var Gs = /* @__PURE__ */ w((f, t) => {
+  vt.set(t.id, f);
+}, "setNodeElem"), Vs = /* @__PURE__ */ w(() => {
+  vt.clear();
+}, "clear"), Zs = /* @__PURE__ */ w((f) => {
+  const t = vt.get(f.id);
+  Y.trace(
+    "Transforming node",
+    f.diff,
+    f,
+    "translate(" + (f.x - f.width / 2 - 5) + ", " + f.width / 2 + ")"
+  );
+  const h = 8, c = f.diff || 0;
+  return f.clusterNode ? t.attr(
+    "transform",
+    "translate(" + (f.x + c - f.width / 2) + ", " + (f.y - f.height / 2 - h) + ")"
+  ) : t.attr("transform", "translate(" + f.x + ", " + f.y + ")"), c;
+}, "positionNode");
+export {
+  Fs as clear,
+  Vs as clear2,
+  Bt as createLabel_default,
+  qs as insertCluster,
+  Ws as insertNode,
+  Hs as isValidShape,
+  _ as labelHelper,
+  Zs as positionNode,
+  Gs as setNodeElem,
+  A as updateNodeBounds
+};