@windrun-huaiin/third-ui 7.6.1 → 10.1.0

package/dist/node_modules/.pnpm/{mermaid@11.9.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-JW4RIYDF.mjs → mermaid@11.12.1/node_modules/mermaid/dist/chunks/mermaid.core/chunk-JZLCHNYA.mjs}

@@ -1,8 +1,9 @@
-import { getSubGraphTitleMargins } from './chunk-AC5SNWB5.mjs';
-import { styles2String, userNodeOverrides, solidStateFill, compileStyles } from './chunk-UWXLY5YG.mjs';
-import { createText, getIconSVG } from './chunk-QESNASVV.mjs';
-import { handleUndefinedAttr, decodeEntities, parseFontSize, calculateTextWidth } from './chunk-55PJQP7W.mjs';
-import { __name, log, evaluate, getConfig2, sanitizeText, defaultConfig_default, getConfig, hasKatex, renderKatex, common_default, sanitizeText2 as sanitizeText3, parseGenericTypes } from './chunk-3XYRH5AP.mjs';
+import { getSubGraphTitleMargins } from './chunk-CVBHYZKI.mjs';
+import { styles2String, userNodeOverrides, solidStateFill, compileStyles } from './chunk-ATLVNIR6.mjs';
+import { createText, getIconSVG } from './chunk-JA3XYJ7Z.mjs';
+import { handleUndefinedAttr, decodeEntities, parseFontSize, calculateTextWidth } from './chunk-S3R3BYOJ.mjs';
+import { evaluate, getConfig2, sanitizeText, defaultConfig_default, getConfig, hasKatex, renderKatexSanitized, common_default, sanitizeText2 as sanitizeText3, parseGenericTypes } from './chunk-ABZYJK2D.mjs';
+import { __name, log } from './chunk-AGHRB4JF.mjs';
 import '../../../../../../d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/selection/index.mjs';
 import '../../../../../../d3-zoom@3.0.0/node_modules/d3-zoom/src/transform.mjs';
 import at from '../../../../../../roughjs@4.6.6/node_modules/roughjs/bundled/rough.esm.mjs';
@@ -193,15 +194,15 @@ __name(applyStyle, "applyStyle");
 async function addHtmlLabel(node) {
   const fo = select(document.createElementNS("http://www.w3.org/2000/svg", "foreignObject"));
   const div = fo.append("xhtml:div");
+  const config = getConfig2();
   let label = node.label;
   if (node.label && hasKatex(node.label)) {
-    label = await renderKatex(node.label.replace(common_default.lineBreakRegex, "\n"), getConfig2());
+    label = await renderKatexSanitized(node.label.replace(common_default.lineBreakRegex, "\n"), config);
   }
   const labelClass = node.isNode ? "nodeLabel" : "edgeLabel";
-  div.html(
-    '<span class="' + labelClass + '" ' + (node.labelStyle ? 'style="' + node.labelStyle + '"' : "") + // codeql [js/html-constructed-from-input] : false positive
-    ">" + label + "</span>"
-  );
+  const labelSpan = '<span class="' + labelClass + '" ' + (node.labelStyle ? 'style="' + node.labelStyle + '"' : "") + // codeql [js/html-constructed-from-input] : false positive
+  ">" + label + "</span>";
+  div.html(sanitizeText(labelSpan, config));
   applyStyle(div, node.labelStyle);
   div.style("display", "inline-block");
   div.style("padding-right", "1px");
@@ -648,36 +649,35 @@ var intersect_circle_default = intersectCircle;
 
 // src/rendering-util/rendering-elements/intersect/intersect-line.js
 function intersectLine(p1, p2, q1, q2) {
-  var a1, a2, b1, b2, c1, c2;
-  var r1, r2, r3, r4;
-  var denom, offset, num;
-  var x, y;
-  a1 = p2.y - p1.y;
-  b1 = p1.x - p2.x;
-  c1 = p2.x * p1.y - p1.x * p2.y;
-  r3 = a1 * q1.x + b1 * q1.y + c1;
-  r4 = a1 * q2.x + b1 * q2.y + c1;
-  if (r3 !== 0 && r4 !== 0 && sameSign(r3, r4)) {
-    return;
-  }
-  a2 = q2.y - q1.y;
-  b2 = q1.x - q2.x;
-  c2 = q2.x * q1.y - q1.x * q2.y;
-  r1 = a2 * p1.x + b2 * p1.y + c2;
-  r2 = a2 * p2.x + b2 * p2.y + c2;
-  if (r1 !== 0 && r2 !== 0 && sameSign(r1, r2)) {
-    return;
-  }
-  denom = a1 * b2 - a2 * b1;
-  if (denom === 0) {
-    return;
-  }
-  offset = Math.abs(denom / 2);
-  num = b1 * c2 - b2 * c1;
-  x = num < 0 ? (num - offset) / denom : (num + offset) / denom;
-  num = a2 * c1 - a1 * c2;
-  y = num < 0 ? (num - offset) / denom : (num + offset) / denom;
-  return { x, y };
+  {
+    const a1 = p2.y - p1.y;
+    const b1 = p1.x - p2.x;
+    const c1 = p2.x * p1.y - p1.x * p2.y;
+    const r3 = a1 * q1.x + b1 * q1.y + c1;
+    const r4 = a1 * q2.x + b1 * q2.y + c1;
+    const epsilon = 1e-6;
+    if (r3 !== 0 && r4 !== 0 && sameSign(r3, r4)) {
+      return;
+    }
+    const a2 = q2.y - q1.y;
+    const b2 = q1.x - q2.x;
+    const c2 = q2.x * q1.y - q1.x * q2.y;
+    const r1 = a2 * p1.x + b2 * p1.y + c2;
+    const r2 = a2 * p2.x + b2 * p2.y + c2;
+    if (Math.abs(r1) < epsilon && Math.abs(r2) < epsilon && sameSign(r1, r2)) {
+      return;
+    }
+    const denom = a1 * b2 - a2 * b1;
+    if (denom === 0) {
+      return;
+    }
+    const offset = Math.abs(denom / 2);
+    let num = b1 * c2 - b2 * c1;
+    const x = num < 0 ? (num - offset) / denom : (num + offset) / denom;
+    num = a2 * c1 - a1 * c2;
+    const y = num < 0 ? (num - offset) / denom : (num + offset) / denom;
+    return { x, y };
+  }
 }
 __name(intersectLine, "intersectLine");
 function sameSign(r1, r2) {
@@ -939,23 +939,28 @@ function choice(parent, node) {
   return shapeSvg;
 }
 __name(choice, "choice");
-async function circle(parent, node) {
+async function circle(parent, node, options) {
   const { labelStyles, nodeStyles } = styles2String(node);
   node.labelStyle = labelStyles;
   const { shapeSvg, bbox, halfPadding } = await labelHelper(parent, node, getNodeClasses(node));
-  const radius = bbox.width / 2 + halfPadding;
+  const padding = options?.padding ?? halfPadding;
+  const radius = bbox.width / 2 + padding;
   let circleElem;
   const { cssStyles } = node;
   if (node.look === "handDrawn") {
     const rc = at.svg(shapeSvg);
-    const options = userNodeOverrides(node, {});
-    const roughNode = rc.circle(0, 0, radius * 2, options);
+    const options2 = userNodeOverrides(node, {});
+    const roughNode = rc.circle(0, 0, radius * 2, options2);
     circleElem = shapeSvg.insert(() => roughNode, ":first-child");
     circleElem.attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles));
   } else {
     circleElem = shapeSvg.insert("circle", ":first-child").attr("class", "basic label-container").attr("style", nodeStyles).attr("r", radius).attr("cx", 0).attr("cy", 0);
   }
   updateNodeBounds(node, circleElem);
+  node.calcIntersect = function(bounds, point) {
+    const radius2 = bounds.width / 2;
+    return intersect_default.circle(bounds, radius2, point);
+  };
   node.intersect = function(point) {
     log.info("Circle intersect", node, radius, point);
     return intersect_default.circle(node, radius, point);
@@ -1617,49 +1622,44 @@ async function halfRoundedRectangle(parent, node) {
   return shapeSvg;
 }
 __name(halfRoundedRectangle, "halfRoundedRectangle");
-var createHexagonPathD = /* @__PURE__ */ __name((x, y, width, height, m) => {
-  return [
-    `M${x + m},${y}`,
-    `L${x + width - m},${y}`,
-    `L${x + width},${y - height / 2}`,
-    `L${x + width - m},${y - height}`,
-    `L${x + m},${y - height}`,
-    `L${x},${y - height / 2}`,
-    "Z"
-  ].join(" ");
-}, "createHexagonPathD");
 async function hexagon(parent, node) {
   const { labelStyles, nodeStyles } = styles2String(node);
   node.labelStyle = labelStyles;
   const { shapeSvg, bbox } = await labelHelper(parent, node, getNodeClasses(node));
-  const f = 4;
-  const h = bbox.height + node.padding;
-  const m = h / f;
-  const w = bbox.width + 2 * m + node.padding;
+  const h = bbox.height + (node.padding ?? 0);
+  const w = bbox.width + (node.padding ?? 0) * 2.5;
+  const { cssStyles } = node;
+  const rc = at.svg(shapeSvg);
+  const options = userNodeOverrides(node, {});
+  if (node.look !== "handDrawn") {
+    options.roughness = 0;
+    options.fillStyle = "solid";
+  }
+  let halfWidth = w / 2;
+  const m = halfWidth / 6;
+  halfWidth = halfWidth + m;
+  const halfHeight = h / 2;
+  const fixedLength = halfHeight / 2;
+  const deducedWidth = halfWidth - fixedLength;
   const points = [
-    { x: m, y: 0 },
-    { x: w - m, y: 0 },
-    { x: w, y: -h / 2 },
-    { x: w - m, y: -h },
-    { x: m, y: -h },
-    { x: 0, y: -h / 2 }
+    { x: -deducedWidth, y: -halfHeight },
+    { x: 0, y: -halfHeight },
+    { x: deducedWidth, y: -halfHeight },
+    { x: halfWidth, y: 0 },
+    { x: deducedWidth, y: halfHeight },
+    { x: 0, y: halfHeight },
+    { x: -deducedWidth, y: halfHeight },
+    { x: -halfWidth, y: 0 }
   ];
-  let polygon;
-  const { cssStyles } = node;
-  if (node.look === "handDrawn") {
-    const rc = at.svg(shapeSvg);
-    const options = userNodeOverrides(node, {});
-    const pathData = createHexagonPathD(0, 0, w, h, m);
-    const roughNode = rc.path(pathData, options);
-    polygon = shapeSvg.insert(() => roughNode, ":first-child").attr("transform", `translate(${-w / 2}, ${h / 2})`);
-    if (cssStyles) {
-      polygon.attr("style", cssStyles);
-    }
-  } else {
-    polygon = insertPolygonShape(shapeSvg, w, h, points);
+  const pathData = createPathFromPoints(points);
+  const shapeNode = rc.path(pathData, options);
+  const polygon = shapeSvg.insert(() => shapeNode, ":first-child");
+  polygon.attr("class", "basic label-container");
+  if (cssStyles && node.look !== "handDrawn") {
+    polygon.selectChildren("path").attr("style", cssStyles);
   }
-  if (nodeStyles) {
-    polygon.attr("style", nodeStyles);
+  if (nodeStyles && node.look !== "handDrawn") {
+    polygon.selectChildren("path").attr("style", nodeStyles);
   }
   node.width = w;
   node.height = h;
@@ -2253,6 +2253,9 @@ async function drawRect(parent, node, options) {
     rect2.attr("class", "basic label-container").attr("style", nodeStyles).attr("rx", handleUndefinedAttr(rx)).attr("ry", handleUndefinedAttr(ry)).attr("x", x).attr("y", y).attr("width", totalWidth).attr("height", totalHeight);
   }
   updateNodeBounds(node, rect2);
+  node.calcIntersect = function(bounds, point) {
+    return intersect_default.rect(bounds, point);
+  };
   node.intersect = function(point) {
     return intersect_default.rect(node, point);
   };
@@ -2732,6 +2735,7 @@ async function question(parent, node) {
   const w = bbox.width + node.padding;
   const h = bbox.height + node.padding;
   const s = w + h;
+  const adjustment = 0.5;
   const points = [
     { x: s / 2, y: 0 },
     { x: s, y: -s / 2 },
@@ -2745,27 +2749,31 @@ async function question(parent, node) {
     const options = userNodeOverrides(node, {});
     const pathData = createDecisionBoxPathD(0, 0, s);
     const roughNode = rc.path(pathData, options);
-    polygon = shapeSvg.insert(() => roughNode, ":first-child").attr("transform", `translate(${-s / 2}, ${s / 2})`);
+    polygon = shapeSvg.insert(() => roughNode, ":first-child").attr("transform", `translate(${-s / 2 + adjustment}, ${s / 2})`);
     if (cssStyles) {
       polygon.attr("style", cssStyles);
     }
   } else {
     polygon = insertPolygonShape(shapeSvg, s, s, points);
+    polygon.attr("transform", `translate(${-s / 2 + adjustment}, ${s / 2})`);
   }
   if (nodeStyles) {
     polygon.attr("style", nodeStyles);
   }
   updateNodeBounds(node, polygon);
+  node.calcIntersect = function(bounds, point) {
+    const s2 = bounds.width;
+    const points2 = [
+      { x: s2 / 2, y: 0 },
+      { x: s2, y: -s2 / 2 },
+      { x: s2 / 2, y: -s2 },
+      { x: 0, y: -s2 / 2 }
+    ];
+    const res = intersect_default.polygon(bounds, points2, point);
+    return { x: res.x - 0.5, y: res.y - 0.5 };
+  };
   node.intersect = function(point) {
-    log.debug(
-      "APA12 Intersect called SPLIT\npoint:",
-      point,
-      "\nnode:\n",
-      node,
-      "\nres:",
-      intersect_default.polygon(node, points, point)
-    );
-    return intersect_default.polygon(node, points, point);
+    return this.calcIntersect(node, point);
   };
   return shapeSvg;
 }
@@ -2909,16 +2917,108 @@ async function rectWithTitle(parent, node) {
   return shapeSvg;
 }
 __name(rectWithTitle, "rectWithTitle");
-
-// src/rendering-util/rendering-elements/shapes/roundedRect.ts
+function generateArcPoints2(x1, y1, x2, y2, rx, ry, clockwise) {
+  const numPoints = 20;
+  const midX = (x1 + x2) / 2;
+  const midY = (y1 + y2) / 2;
+  const angle = Math.atan2(y2 - y1, x2 - x1);
+  const dx = (x2 - x1) / 2;
+  const dy = (y2 - y1) / 2;
+  const transformedX = dx / rx;
+  const transformedY = dy / ry;
+  const distance = Math.sqrt(transformedX ** 2 + transformedY ** 2);
+  if (distance > 1) {
+    throw new Error("The given radii are too small to create an arc between the points.");
+  }
+  const scaledCenterDistance = Math.sqrt(1 - distance ** 2);
+  const centerX = midX + scaledCenterDistance * ry * Math.sin(angle) * (clockwise ? -1 : 1);
+  const centerY = midY - scaledCenterDistance * rx * Math.cos(angle) * (clockwise ? -1 : 1);
+  const startAngle = Math.atan2((y1 - centerY) / ry, (x1 - centerX) / rx);
+  const endAngle = Math.atan2((y2 - centerY) / ry, (x2 - centerX) / rx);
+  let angleRange = endAngle - startAngle;
+  if (clockwise && angleRange < 0) {
+    angleRange += 2 * Math.PI;
+  }
+  if (!clockwise && angleRange > 0) {
+    angleRange -= 2 * Math.PI;
+  }
+  const points = [];
+  for (let i = 0; i < numPoints; i++) {
+    const t = i / (numPoints - 1);
+    const angle2 = startAngle + t * angleRange;
+    const x = centerX + rx * Math.cos(angle2);
+    const y = centerY + ry * Math.sin(angle2);
+    points.push({ x, y });
+  }
+  return points;
+}
+__name(generateArcPoints2, "generateArcPoints");
 async function roundedRect(parent, node) {
-  const options = {
-    rx: 5,
-    ry: 5,
-    labelPaddingX: (node?.padding || 0) * 1,
-    labelPaddingY: (node?.padding || 0) * 1
+  const { labelStyles, nodeStyles } = styles2String(node);
+  node.labelStyle = labelStyles;
+  const { shapeSvg, bbox } = await labelHelper(parent, node, getNodeClasses(node));
+  const labelPaddingX = node?.padding ?? 0;
+  const labelPaddingY = node?.padding ?? 0;
+  const w = (node?.width ? node?.width : bbox.width) + labelPaddingX * 2;
+  const h = (node?.height ? node?.height : bbox.height) + labelPaddingY * 2;
+  const radius = node.radius || 5;
+  const taper = node.taper || 5;
+  const { cssStyles } = node;
+  const rc = at.svg(shapeSvg);
+  const options = userNodeOverrides(node, {});
+  if (node.stroke) {
+    options.stroke = node.stroke;
+  }
+  if (node.look !== "handDrawn") {
+    options.roughness = 0;
+    options.fillStyle = "solid";
+  }
+  const points = [
+    // Top edge (left to right)
+    { x: -w / 2 + taper, y: -h / 2 },
+    // Top-left corner start (1)
+    { x: w / 2 - taper, y: -h / 2 },
+    // Top-right corner start (2)
+    ...generateArcPoints2(w / 2 - taper, -h / 2, w / 2, -h / 2 + taper, radius, radius, true),
+    // Top-left arc (2 to 3)
+    // Right edge (top to bottom)
+    { x: w / 2, y: -h / 2 + taper },
+    // Top-right taper point (3)
+    { x: w / 2, y: h / 2 - taper },
+    // Bottom-right taper point (4)
+    ...generateArcPoints2(w / 2, h / 2 - taper, w / 2 - taper, h / 2, radius, radius, true),
+    // Top-left arc (4 to 5)
+    // Bottom edge (right to left)
+    { x: w / 2 - taper, y: h / 2 },
+    // Bottom-right corner start (5)
+    { x: -w / 2 + taper, y: h / 2 },
+    // Bottom-left corner start (6)
+    ...generateArcPoints2(-w / 2 + taper, h / 2, -w / 2, h / 2 - taper, radius, radius, true),
+    // Top-left arc (4 to 5)
+    // Left edge (bottom to top)
+    { x: -w / 2, y: h / 2 - taper },
+    // Bottom-left taper point (7)
+    { x: -w / 2, y: -h / 2 + taper },
+    // Top-left taper point (8)
+    ...generateArcPoints2(-w / 2, -h / 2 + taper, -w / 2 + taper, -h / 2, radius, radius, true)
+    // Top-left arc (4 to 5)
+  ];
+  const pathData = createPathFromPoints(points);
+  const shapeNode = rc.path(pathData, options);
+  const polygon = shapeSvg.insert(() => shapeNode, ":first-child");
+  polygon.attr("class", "basic label-container outer-path");
+  if (cssStyles && node.look !== "handDrawn") {
+    polygon.selectChildren("path").attr("style", cssStyles);
+  }
+  if (nodeStyles && node.look !== "handDrawn") {
+    polygon.selectChildren("path").attr("style", nodeStyles);
+  }
+  updateNodeBounds(node, polygon);
+  node.intersect = function(point) {
+    const pos = intersect_default.polygon(node, points, point);
+    return pos;
   };
-  return drawRect(parent, node, options);
+  return shapeSvg;
 }
 __name(roundedRect, "roundedRect");
 async function shadedProcess(parent, node) {
@@ -3019,7 +3119,7 @@ async function squareRect2(parent, node) {
   const options = {
     rx: 0,
     ry: 0,
-    labelPaddingX: (node?.padding || 0) * 2,
+    labelPaddingX: node.labelPaddingX ?? (node?.padding || 0) * 2,
     labelPaddingY: (node?.padding || 0) * 1
   };
   return drawRect(parent, node, options);
@@ -3031,22 +3131,35 @@ async function stadium(parent, node) {
   const { shapeSvg, bbox } = await labelHelper(parent, node, getNodeClasses(node));
   const h = bbox.height + node.padding;
   const w = bbox.width + h / 4 + node.padding;
-  let rect2;
+  const radius = h / 2;
   const { cssStyles } = node;
-  if (node.look === "handDrawn") {
-    const rc = at.svg(shapeSvg);
-    const options = userNodeOverrides(node, {});
-    const pathData = createRoundedRectPathD(-w / 2, -h / 2, w, h, h / 2);
-    const roughNode = rc.path(pathData, options);
-    rect2 = shapeSvg.insert(() => roughNode, ":first-child");
-    rect2.attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles));
-  } else {
-    rect2 = shapeSvg.insert("rect", ":first-child");
-    rect2.attr("class", "basic label-container").attr("style", nodeStyles).attr("rx", h / 2).attr("ry", h / 2).attr("x", -w / 2).attr("y", -h / 2).attr("width", w).attr("height", h);
+  const rc = at.svg(shapeSvg);
+  const options = userNodeOverrides(node, {});
+  if (node.look !== "handDrawn") {
+    options.roughness = 0;
+    options.fillStyle = "solid";
   }
-  updateNodeBounds(node, rect2);
+  const points = [
+    { x: -w / 2 + radius, y: -h / 2 },
+    { x: w / 2 - radius, y: -h / 2 },
+    ...generateCirclePoints(-w / 2 + radius, 0, radius, 50, 90, 270),
+    { x: w / 2 - radius, y: h / 2 },
+    ...generateCirclePoints(w / 2 - radius, 0, radius, 50, 270, 450)
+  ];
+  const pathData = createPathFromPoints(points);
+  const shapeNode = rc.path(pathData, options);
+  const polygon = shapeSvg.insert(() => shapeNode, ":first-child");
+  polygon.attr("class", "basic label-container outer-path");
+  if (cssStyles && node.look !== "handDrawn") {
+    polygon.selectChildren("path").attr("style", cssStyles);
+  }
+  if (nodeStyles && node.look !== "handDrawn") {
+    polygon.selectChildren("path").attr("style", nodeStyles);
+  }
+  updateNodeBounds(node, polygon);
   node.intersect = function(point) {
-    return intersect_default.rect(node, point);
+    const pos = intersect_default.polygon(node, points, point);
+    return pos;
   };
   return shapeSvg;
 }
@@ -4246,7 +4359,7 @@ async function requirementBox(parent, node) {
   if (isRequirementNode) {
     const idHeight = await addText3(
       shapeSvg,
-      `${requirementNode.requirementId ? `id: ${requirementNode.requirementId}` : ""}`,
+      `${requirementNode.requirementId ? `ID: ${requirementNode.requirementId}` : ""}`,
       accumulativeHeight,
       node.labelStyle
     );
@@ -4486,6 +4599,165 @@ async function kanbanItem(parent, kanbanNode, { config }) {
   return shapeSvg;
 }
 __name(kanbanItem, "kanbanItem");
+async function bang(parent, node) {
+  const { labelStyles, nodeStyles } = styles2String(node);
+  node.labelStyle = labelStyles;
+  const { shapeSvg, bbox, halfPadding, label } = await labelHelper(
+    parent,
+    node,
+    getNodeClasses(node)
+  );
+  const w = bbox.width + 10 * halfPadding;
+  const h = bbox.height + 8 * halfPadding;
+  const r = 0.15 * w;
+  const { cssStyles } = node;
+  const minWidth = bbox.width + 20;
+  const minHeight = bbox.height + 20;
+  const effectiveWidth = Math.max(w, minWidth);
+  const effectiveHeight = Math.max(h, minHeight);
+  label.attr("transform", `translate(${-bbox.width / 2}, ${-bbox.height / 2})`);
+  let bangElem;
+  const path = `M0 0 
+    a${r},${r} 1 0,0 ${effectiveWidth * 0.25},${ -1 * effectiveHeight * 0.1}
+    a${r},${r} 1 0,0 ${effectiveWidth * 0.25},${0}
+    a${r},${r} 1 0,0 ${effectiveWidth * 0.25},${0}
+    a${r},${r} 1 0,0 ${effectiveWidth * 0.25},${effectiveHeight * 0.1}
+
+    a${r},${r} 1 0,0 ${effectiveWidth * 0.15},${effectiveHeight * 0.33}
+    a${r * 0.8},${r * 0.8} 1 0,0 0,${effectiveHeight * 0.34}
+    a${r},${r} 1 0,0 ${ -1 * effectiveWidth * 0.15},${effectiveHeight * 0.33}
+
+    a${r},${r} 1 0,0 ${ -1 * effectiveWidth * 0.25},${effectiveHeight * 0.15}
+    a${r},${r} 1 0,0 ${ -1 * effectiveWidth * 0.25},0
+    a${r},${r} 1 0,0 ${ -1 * effectiveWidth * 0.25},0
+    a${r},${r} 1 0,0 ${ -1 * effectiveWidth * 0.25},${ -1 * effectiveHeight * 0.15}
+
+    a${r},${r} 1 0,0 ${ -1 * effectiveWidth * 0.1},${ -1 * effectiveHeight * 0.33}
+    a${r * 0.8},${r * 0.8} 1 0,0 0,${ -1 * effectiveHeight * 0.34}
+    a${r},${r} 1 0,0 ${effectiveWidth * 0.1},${ -1 * effectiveHeight * 0.33}
+  H0 V0 Z`;
+  if (node.look === "handDrawn") {
+    const rc = at.svg(shapeSvg);
+    const options = userNodeOverrides(node, {});
+    const roughNode = rc.path(path, options);
+    bangElem = shapeSvg.insert(() => roughNode, ":first-child");
+    bangElem.attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles));
+  } else {
+    bangElem = shapeSvg.insert("path", ":first-child").attr("class", "basic label-container").attr("style", nodeStyles).attr("d", path);
+  }
+  bangElem.attr("transform", `translate(${-effectiveWidth / 2}, ${-effectiveHeight / 2})`);
+  updateNodeBounds(node, bangElem);
+  node.calcIntersect = function(bounds, point) {
+    return intersect_default.rect(bounds, point);
+  };
+  node.intersect = function(point) {
+    log.info("Bang intersect", node, point);
+    return intersect_default.rect(node, point);
+  };
+  return shapeSvg;
+}
+__name(bang, "bang");
+async function cloud(parent, node) {
+  const { labelStyles, nodeStyles } = styles2String(node);
+  node.labelStyle = labelStyles;
+  const { shapeSvg, bbox, halfPadding, label } = await labelHelper(
+    parent,
+    node,
+    getNodeClasses(node)
+  );
+  const w = bbox.width + 2 * halfPadding;
+  const h = bbox.height + 2 * halfPadding;
+  const r1 = 0.15 * w;
+  const r2 = 0.25 * w;
+  const r3 = 0.35 * w;
+  const r4 = 0.2 * w;
+  const { cssStyles } = node;
+  let cloudElem;
+  const path = `M0 0 
+    a${r1},${r1} 0 0,1 ${w * 0.25},${ -1 * w * 0.1}
+    a${r3},${r3} 1 0,1 ${w * 0.4},${ -1 * w * 0.1}
+    a${r2},${r2} 1 0,1 ${w * 0.35},${w * 0.2}
+
+    a${r1},${r1} 1 0,1 ${w * 0.15},${h * 0.35}
+    a${r4},${r4} 1 0,1 ${ -1 * w * 0.15},${h * 0.65}
+
+    a${r2},${r1} 1 0,1 ${ -1 * w * 0.25},${w * 0.15}
+    a${r3},${r3} 1 0,1 ${ -1 * w * 0.5},0
+    a${r1},${r1} 1 0,1 ${ -1 * w * 0.25},${ -1 * w * 0.15}
+
+    a${r1},${r1} 1 0,1 ${ -1 * w * 0.1},${ -1 * h * 0.35}
+    a${r4},${r4} 1 0,1 ${w * 0.1},${ -1 * h * 0.65}
+  H0 V0 Z`;
+  if (node.look === "handDrawn") {
+    const rc = at.svg(shapeSvg);
+    const options = userNodeOverrides(node, {});
+    const roughNode = rc.path(path, options);
+    cloudElem = shapeSvg.insert(() => roughNode, ":first-child");
+    cloudElem.attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles));
+  } else {
+    cloudElem = shapeSvg.insert("path", ":first-child").attr("class", "basic label-container").attr("style", nodeStyles).attr("d", path);
+  }
+  label.attr("transform", `translate(${-bbox.width / 2}, ${-bbox.height / 2})`);
+  cloudElem.attr("transform", `translate(${-w / 2}, ${-h / 2})`);
+  updateNodeBounds(node, cloudElem);
+  node.calcIntersect = function(bounds, point) {
+    return intersect_default.rect(bounds, point);
+  };
+  node.intersect = function(point) {
+    log.info("Cloud intersect", node, point);
+    return intersect_default.rect(node, point);
+  };
+  return shapeSvg;
+}
+__name(cloud, "cloud");
+
+// src/rendering-util/rendering-elements/shapes/defaultMindmapNode.ts
+async function defaultMindmapNode(parent, node) {
+  const { labelStyles, nodeStyles } = styles2String(node);
+  node.labelStyle = labelStyles;
+  const { shapeSvg, bbox, halfPadding, label } = await labelHelper(
+    parent,
+    node,
+    getNodeClasses(node)
+  );
+  const w = bbox.width + 8 * halfPadding;
+  const h = bbox.height + 2 * halfPadding;
+  const rd = 5;
+  const rectPath = `
+    M${-w / 2} ${h / 2 - rd}
+    v${-h + 2 * rd}
+    q0,-${rd} ${rd},-${rd}
+    h${w - 2 * rd}
+    q${rd},0 ${rd},${rd}
+    v${h - 2 * rd}
+    q0,${rd} -${rd},${rd}
+    h${-w + 2 * rd}
+    q-${rd},0 -${rd},-${rd}
+    Z
+  `;
+  const bg = shapeSvg.append("path").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + node.type).attr("style", nodeStyles).attr("d", rectPath);
+  shapeSvg.append("line").attr("class", "node-line-").attr("x1", -w / 2).attr("y1", h / 2).attr("x2", w / 2).attr("y2", h / 2);
+  label.attr("transform", `translate(${-bbox.width / 2}, ${-bbox.height / 2})`);
+  shapeSvg.append(() => label.node());
+  updateNodeBounds(node, bg);
+  node.calcIntersect = function(bounds, point) {
+    return intersect_default.rect(bounds, point);
+  };
+  node.intersect = function(point) {
+    return intersect_default.rect(node, point);
+  };
+  return shapeSvg;
+}
+__name(defaultMindmapNode, "defaultMindmapNode");
+
+// src/rendering-util/rendering-elements/shapes/mindmapCircle.ts
+async function mindmapCircle(parent, node) {
+  const options = {
+    padding: node.padding ?? 0
+  };
+  return circle(parent, node, options);
+}
+__name(mindmapCircle, "mindmapCircle");
 
 // src/rendering-util/rendering-elements/shapes.ts
 var shapesDefs = [
@@ -4539,6 +4811,22 @@ var shapesDefs = [
     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",
@@ -4874,6 +5162,9 @@ var generateShapeMap = /* @__PURE__ */ __name(() => {
     anchor,
     // Kanban diagram
     kanbanItem,
+    //Mindmap diagram
+    mindmapCircle,
+    defaultMindmapNode,
     // class diagram
     classBox,
     // er diagram