@marimo-team/islands 0.23.17-dev9 → 0.24.0

package/dist/chunk-QR6OTTB3-C4L1dLRd.js

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