@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/mindmap-definition-6CBA2TL7.mjs → mermaid@11.12.1/node_modules/mermaid/dist/chunks/mermaid.core/mindmap-definition-VGOIOE7T.mjs}

@@ -1,18 +1,20 @@
-import { createText } from './chunk-QESNASVV.mjs';
-import { parseFontSize } from './chunk-55PJQP7W.mjs';
-import { selectSvgElement } from './chunk-P3VETL53.mjs';
-import { __name, log, getConfig2, setupGraphViewbox, defaultConfig_default, sanitizeText } from './chunk-3XYRH5AP.mjs';
-import cytoscape from '../../../../../../cytoscape@3.33.1/node_modules/cytoscape/dist/cytoscape.esm.mjs';
-import coseBilkent from '../../../../../../../../_virtual/cytoscape-cose-bilkent.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 { getDiagramElement } from './chunk-55IACEB6.mjs';
+import { setupViewPortForSVG } from './chunk-QN33PNHL.mjs';
+import { getRegisteredLayoutAlgorithm, render } from './chunk-N4CR4FBY.mjs';
+import './chunk-QXUST7PY.mjs';
+import './chunk-HN2XXSSU.mjs';
+import './chunk-JZLCHNYA.mjs';
+import { __name, log } from './chunk-AGHRB4JF.mjs';
+import { defaultConfig_default, getConfig2, sanitizeText, getUserDefinedConfig } from './chunk-ABZYJK2D.mjs';
+import './chunk-JA3XYJ7Z.mjs';
+import './chunk-S3R3BYOJ.mjs';
+import v4 from '../../../../../../uuid@11.1.0/node_modules/uuid/dist/esm-browser/v4.mjs';
 import isDark from '../../../../../../khroma@2.1.0/node_modules/khroma/dist/methods/is_dark.mjs';
 import lighten from '../../../../../../khroma@2.1.0/node_modules/khroma/dist/methods/lighten.mjs';
 import darken from '../../../../../../khroma@2.1.0/node_modules/khroma/dist/methods/darken.mjs';
-import select from '../../../../../../d3-selection@3.0.0/node_modules/d3-selection/src/select.mjs';
 
 // src/diagrams/mindmap/parser/mindmap.jison
-var parser = function() {
+var parser = (function() {
   var o = /* @__PURE__ */ __name(function(k, v, o2, l) {
     for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v) ;
     return o2;
@@ -225,7 +227,7 @@ var parser = function() {
       return true;
     }, "parse")
   };
-  var lexer = /* @__PURE__ */ function() {
+  var lexer = /* @__PURE__ */ (function() {
     var lexer2 = {
       EOF: 1,
       parseError: /* @__PURE__ */ __name(function parseError(str, hash) {
@@ -632,7 +634,7 @@ var parser = function() {
       conditions: { "CLASS": { "rules": [3, 4], "inclusive": false }, "ICON": { "rules": [8, 9], "inclusive": false }, "NSTR2": { "rules": [22, 23], "inclusive": false }, "NSTR": { "rules": [25, 26], "inclusive": false }, "NODE": { "rules": [21, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], "inclusive": false }, "INITIAL": { "rules": [0, 1, 2, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], "inclusive": true } }
     };
     return lexer2;
-  }();
+  })();
   parser2.lexer = lexer;
   function Parser() {
     this.yy = {};
@@ -641,11 +643,9 @@ var parser = function() {
   Parser.prototype = parser2;
   parser2.Parser = Parser;
   return new Parser();
-}();
+})();
 parser.parser = parser;
 var mindmap_default = parser;
-
-// src/diagrams/mindmap/mindmapDb.ts
 var nodeType = {
   DEFAULT: 0,
   NO_BORDER: 0,
@@ -665,7 +665,6 @@ var MindmapDB = class {
     this.nodeType = nodeType;
     this.clear();
     this.getType = this.getType.bind(this);
-    this.getMindmap = this.getMindmap.bind(this);
     this.getElementById = this.getElementById.bind(this);
     this.getParent = this.getParent.bind(this);
     this.getMindmap = this.getMindmap.bind(this);
@@ -679,6 +678,7 @@ var MindmapDB = class {
     this.nodes = [];
     this.count = 0;
     this.elements = {};
+    this.baseLevel = void 0;
   }
   getParent(level) {
     for (let i = this.nodes.length - 1; i >= 0; i--) {
@@ -693,6 +693,15 @@ var MindmapDB = class {
   }
   addNode(level, id, descr, type) {
     log.info("addNode", level, id, descr, type);
+    let isRoot = false;
+    if (this.nodes.length === 0) {
+      this.baseLevel = level;
+      level = 0;
+      isRoot = true;
+    } else if (this.baseLevel !== void 0) {
+      level = level - this.baseLevel;
+      isRoot = false;
+    }
     const conf = getConfig2();
     let padding = conf.mindmap?.padding ?? defaultConfig_default.mindmap.padding;
     switch (type) {
@@ -710,14 +719,15 @@ var MindmapDB = class {
       type,
       children: [],
       width: conf.mindmap?.maxNodeWidth ?? defaultConfig_default.mindmap.maxNodeWidth,
-      padding
+      padding,
+      isRoot
     };
     const parent = this.getParent(level);
     if (parent) {
       parent.children.push(node);
       this.nodes.push(node);
     } else {
-      if (this.nodes.length === 0) {
+      if (isRoot) {
         this.nodes.push(node);
       } else {
         throw new Error(
@@ -785,342 +795,224 @@ var MindmapDB = class {
         return "no-border";
     }
   }
-  getLogger() {
-    return log;
-  }
-};
-
-// src/diagrams/mindmap/svgDraw.ts
-var MAX_SECTIONS = 12;
-var defaultBkg = /* @__PURE__ */ __name(function(db, elem, node, section) {
-  const rd = 5;
-  elem.append("path").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + db.type2Str(node.type)).attr(
-    "d",
-    `M0 ${node.height - rd} v${-node.height + 2 * rd} q0,-5 5,-5 h${node.width - 2 * rd} q5,0 5,5 v${node.height - rd} H0 Z`
-  );
-  elem.append("line").attr("class", "node-line-" + section).attr("x1", 0).attr("y1", node.height).attr("x2", node.width).attr("y2", node.height);
-}, "defaultBkg");
-var rectBkg = /* @__PURE__ */ __name(function(db, elem, node) {
-  elem.append("rect").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + db.type2Str(node.type)).attr("height", node.height).attr("width", node.width);
-}, "rectBkg");
-var cloudBkg = /* @__PURE__ */ __name(function(db, elem, node) {
-  const w = node.width;
-  const h = node.height;
-  const r1 = 0.15 * w;
-  const r2 = 0.25 * w;
-  const r3 = 0.35 * w;
-  const r4 = 0.2 * w;
-  elem.append("path").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + db.type2Str(node.type)).attr(
-    "d",
-    `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},${1 * w * 0.2}
-
-      a${r1},${r1} 1 0,1 ${w * 0.15},${1 * h * 0.35}
-      a${r4},${r4} 1 0,1 ${ -1 * w * 0.15},${1 * 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`
-  );
-}, "cloudBkg");
-var bangBkg = /* @__PURE__ */ __name(function(db, elem, node) {
-  const w = node.width;
-  const h = node.height;
-  const r = 0.15 * w;
-  elem.append("path").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + db.type2Str(node.type)).attr(
-    "d",
-    `M0 0 a${r},${r} 1 0,0 ${w * 0.25},${ -1 * h * 0.1}
-      a${r},${r} 1 0,0 ${w * 0.25},${0}
-      a${r},${r} 1 0,0 ${w * 0.25},${0}
-      a${r},${r} 1 0,0 ${w * 0.25},${1 * h * 0.1}
-
-      a${r},${r} 1 0,0 ${w * 0.15},${1 * h * 0.33}
-      a${r * 0.8},${r * 0.8} 1 0,0 ${0},${1 * h * 0.34}
-      a${r},${r} 1 0,0 ${ -1 * w * 0.15},${1 * h * 0.33}
-
-      a${r},${r} 1 0,0 ${ -1 * w * 0.25},${h * 0.15}
-      a${r},${r} 1 0,0 ${ -1 * w * 0.25},${0}
-      a${r},${r} 1 0,0 ${ -1 * w * 0.25},${0}
-      a${r},${r} 1 0,0 ${ -1 * w * 0.25},${ -1 * h * 0.15}
-
-      a${r},${r} 1 0,0 ${ -1 * w * 0.1},${ -1 * h * 0.33}
-      a${r * 0.8},${r * 0.8} 1 0,0 ${0},${ -1 * h * 0.34}
-      a${r},${r} 1 0,0 ${w * 0.1},${ -1 * h * 0.33}
-
-    H0 V0 Z`
-  );
-}, "bangBkg");
-var circleBkg = /* @__PURE__ */ __name(function(db, elem, node) {
-  elem.append("circle").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + db.type2Str(node.type)).attr("r", node.width / 2);
-}, "circleBkg");
-function insertPolygonShape(parent, w, h, points, node) {
-  return parent.insert("polygon", ":first-child").attr(
-    "points",
-    points.map(function(d) {
-      return d.x + "," + d.y;
-    }).join(" ")
-  ).attr("transform", "translate(" + (node.width - w) / 2 + ", " + h + ")");
-}
-__name(insertPolygonShape, "insertPolygonShape");
-var hexagonBkg = /* @__PURE__ */ __name(function(_db, elem, node) {
-  const h = node.height;
-  const f = 4;
-  const m = h / f;
-  const w = node.width - node.padding + 2 * m;
-  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 }
-  ];
-  insertPolygonShape(elem, w, h, points, node);
-}, "hexagonBkg");
-var roundedRectBkg = /* @__PURE__ */ __name(function(db, elem, node) {
-  elem.append("rect").attr("id", "node-" + node.id).attr("class", "node-bkg node-" + db.type2Str(node.type)).attr("height", node.height).attr("rx", node.padding).attr("ry", node.padding).attr("width", node.width);
-}, "roundedRectBkg");
-var drawNode = /* @__PURE__ */ __name(async function(db, elem, node, fullSection, conf) {
-  const htmlLabels = conf.htmlLabels;
-  const section = fullSection % (MAX_SECTIONS - 1);
-  const nodeElem = elem.append("g");
-  node.section = section;
-  let sectionClass = "section-" + section;
-  if (section < 0) {
-    sectionClass += " section-root";
-  }
-  nodeElem.attr("class", (node.class ? node.class + " " : "") + "mindmap-node " + sectionClass);
-  const bkgElem = nodeElem.append("g");
-  const textElem = nodeElem.append("g");
-  const description = node.descr.replace(/(<br\/*>)/g, "\n");
-  await createText(
-    textElem,
-    description,
-    {
-      useHtmlLabels: htmlLabels,
-      width: node.width,
-      classes: "mindmap-node-label"
-    },
-    conf
-  );
-  if (!htmlLabels) {
-    textElem.attr("dy", "1em").attr("alignment-baseline", "middle").attr("dominant-baseline", "middle").attr("text-anchor", "middle");
-  }
-  const bbox = textElem.node().getBBox();
-  const [fontSize] = parseFontSize(conf.fontSize);
-  node.height = bbox.height + fontSize * 1.1 * 0.5 + node.padding;
-  node.width = bbox.width + 2 * node.padding;
-  if (node.icon) {
-    if (node.type === db.nodeType.CIRCLE) {
-      node.height += 50;
-      node.width += 50;
-      const icon = nodeElem.append("foreignObject").attr("height", "50px").attr("width", node.width).attr("style", "text-align: center;");
-      icon.append("div").attr("class", "icon-container").append("i").attr("class", "node-icon-" + section + " " + node.icon);
-      textElem.attr(
-        "transform",
-        "translate(" + node.width / 2 + ", " + (node.height / 2 - 1.5 * node.padding) + ")"
-      );
+  /**
+   * Assign section numbers to nodes based on their position relative to root
+   * @param node - The mindmap node to process
+   * @param sectionNumber - The section number to assign (undefined for root)
+   */
+  assignSections(node, sectionNumber) {
+    if (node.level === 0) {
+      node.section = void 0;
     } else {
-      node.width += 50;
-      const orgHeight = node.height;
-      node.height = Math.max(orgHeight, 60);
-      const heightDiff = Math.abs(node.height - orgHeight);
-      const icon = nodeElem.append("foreignObject").attr("width", "60px").attr("height", node.height).attr("style", "text-align: center;margin-top:" + heightDiff / 2 + "px;");
-      icon.append("div").attr("class", "icon-container").append("i").attr("class", "node-icon-" + section + " " + node.icon);
-      textElem.attr(
-        "transform",
-        "translate(" + (25 + node.width / 2) + ", " + (heightDiff / 2 + node.padding / 2) + ")"
-      );
+      node.section = sectionNumber;
     }
-  } else {
-    if (!htmlLabels) {
-      const dx = node.width / 2;
-      const dy = node.padding / 2;
-      textElem.attr("transform", "translate(" + dx + ", " + dy + ")");
-    } else {
-      const dx = (node.width - bbox.width) / 2;
-      const dy = (node.height - bbox.height) / 2;
-      textElem.attr("transform", "translate(" + dx + ", " + dy + ")");
+    if (node.children) {
+      for (const [index, child] of node.children.entries()) {
+        const childSectionNumber = node.level === 0 ? index : sectionNumber;
+        this.assignSections(child, childSectionNumber);
+      }
     }
   }
-  switch (node.type) {
-    case db.nodeType.DEFAULT:
-      defaultBkg(db, bkgElem, node, section);
-      break;
-    case db.nodeType.ROUNDED_RECT:
-      roundedRectBkg(db, bkgElem, node, section);
-      break;
-    case db.nodeType.RECT:
-      rectBkg(db, bkgElem, node, section);
-      break;
-    case db.nodeType.CIRCLE:
-      bkgElem.attr("transform", "translate(" + node.width / 2 + ", " + +node.height / 2 + ")");
-      circleBkg(db, bkgElem, node, section);
-      break;
-    case db.nodeType.CLOUD:
-      cloudBkg(db, bkgElem, node, section);
-      break;
-    case db.nodeType.BANG:
-      bangBkg(db, bkgElem, node, section);
-      break;
-    case db.nodeType.HEXAGON:
-      hexagonBkg(db, bkgElem, node, section);
-      break;
-  }
-  db.setElementForId(node.id, nodeElem);
-  return node.height;
-}, "drawNode");
-var positionNode = /* @__PURE__ */ __name(function(db, node) {
-  const nodeElem = db.getElementById(node.id);
-  const x = node.x || 0;
-  const y = node.y || 0;
-  nodeElem.attr("transform", "translate(" + x + "," + y + ")");
-}, "positionNode");
-
-// src/diagrams/mindmap/mindmapRenderer.ts
-cytoscape.use(coseBilkent);
-async function drawNodes(db, svg, mindmap, section, conf) {
-  await drawNode(db, svg, mindmap, section, conf);
-  if (mindmap.children) {
-    await Promise.all(
-      mindmap.children.map(
-        (child, index) => drawNodes(db, svg, child, section < 0 ? index : section, conf)
-      )
-    );
+  /**
+   * Convert mindmap tree structure to flat array of nodes
+   * @param node - The mindmap node to process
+   * @param processedNodes - Array to collect processed nodes
+   */
+  flattenNodes(node, processedNodes) {
+    const cssClasses = ["mindmap-node"];
+    if (node.isRoot === true) {
+      cssClasses.push("section-root", "section--1");
+    } else if (node.section !== void 0) {
+      cssClasses.push(`section-${node.section}`);
+    }
+    if (node.class) {
+      cssClasses.push(node.class);
+    }
+    const classes = cssClasses.join(" ");
+    const getShapeFromType = /* @__PURE__ */ __name((type) => {
+      switch (type) {
+        case nodeType.CIRCLE:
+          return "mindmapCircle";
+        case nodeType.RECT:
+          return "rect";
+        case nodeType.ROUNDED_RECT:
+          return "rounded";
+        case nodeType.CLOUD:
+          return "cloud";
+        case nodeType.BANG:
+          return "bang";
+        case nodeType.HEXAGON:
+          return "hexagon";
+        case nodeType.DEFAULT:
+          return "defaultMindmapNode";
+        case nodeType.NO_BORDER:
+        default:
+          return "rect";
+      }
+    }, "getShapeFromType");
+    const processedNode = {
+      id: node.id.toString(),
+      domId: "node_" + node.id.toString(),
+      label: node.descr,
+      isGroup: false,
+      shape: getShapeFromType(node.type),
+      width: node.width,
+      height: node.height ?? 0,
+      padding: node.padding,
+      cssClasses: classes,
+      cssStyles: [],
+      look: "default",
+      icon: node.icon,
+      x: node.x,
+      y: node.y,
+      // Mindmap-specific properties
+      level: node.level,
+      nodeId: node.nodeId,
+      type: node.type,
+      section: node.section
+    };
+    processedNodes.push(processedNode);
+    if (node.children) {
+      for (const child of node.children) {
+        this.flattenNodes(child, processedNodes);
+      }
+    }
   }
-}
-__name(drawNodes, "drawNodes");
-function drawEdges(edgesEl, cy) {
-  cy.edges().map((edge, id) => {
-    const data = edge.data();
-    if (edge[0]._private.bodyBounds) {
-      const bounds = edge[0]._private.rscratch;
-      log.trace("Edge: ", id, data);
-      edgesEl.insert("path").attr(
-        "d",
-        `M ${bounds.startX},${bounds.startY} L ${bounds.midX},${bounds.midY} L${bounds.endX},${bounds.endY} `
-      ).attr("class", "edge section-edge-" + data.section + " edge-depth-" + data.depth);
+  /**
+   * Generate edges from parent-child relationships in mindmap tree
+   * @param node - The mindmap node to process
+   * @param edges - Array to collect edges
+   */
+  generateEdges(node, edges) {
+    if (!node.children) {
+      return;
     }
-  });
-}
-__name(drawEdges, "drawEdges");
-function addNodes(mindmap, cy, conf, level) {
-  cy.add({
-    group: "nodes",
-    data: {
-      id: mindmap.id.toString(),
-      labelText: mindmap.descr,
-      height: mindmap.height,
-      width: mindmap.width,
-      level,
-      nodeId: mindmap.id,
-      padding: mindmap.padding,
-      type: mindmap.type
-    },
-    position: {
-      x: mindmap.x,
-      y: mindmap.y
+    for (const child of node.children) {
+      let edgeClasses = "edge";
+      if (child.section !== void 0) {
+        edgeClasses += ` section-edge-${child.section}`;
+      }
+      const edgeDepth = node.level + 1;
+      edgeClasses += ` edge-depth-${edgeDepth}`;
+      const edge = {
+        id: `edge_${node.id}_${child.id}`,
+        start: node.id.toString(),
+        end: child.id.toString(),
+        type: "normal",
+        curve: "basis",
+        thickness: "normal",
+        look: "default",
+        classes: edgeClasses,
+        // Store mindmap-specific data
+        depth: node.level,
+        section: child.section
+      };
+      edges.push(edge);
+      this.generateEdges(child, edges);
     }
-  });
-  if (mindmap.children) {
-    mindmap.children.forEach((child) => {
-      addNodes(child, cy, conf, level + 1);
-      cy.add({
-        group: "edges",
-        data: {
-          id: `${mindmap.id}_${child.id}`,
-          source: mindmap.id,
-          target: child.id,
-          depth: level,
-          section: child.section
-        }
-      });
-    });
   }
-}
-__name(addNodes, "addNodes");
-function layoutMindmap(node, conf) {
-  return new Promise((resolve) => {
-    const renderEl = select("body").append("div").attr("id", "cy").attr("style", "display:none");
-    const cy = cytoscape({
-      container: document.getElementById("cy"),
-      // container to render in
-      style: [
-        {
-          selector: "edge",
-          style: {
-            "curve-style": "bezier"
-          }
-        }
-      ]
-    });
-    renderEl.remove();
-    addNodes(node, cy, conf, 0);
-    cy.nodes().forEach(function(n) {
-      n.layoutDimensions = () => {
-        const data = n.data();
-        return { w: data.width, h: data.height };
+  /**
+   * Get structured data for layout algorithms
+   * Following the pattern established by ER diagrams
+   * @returns Structured data containing nodes, edges, and config
+   */
+  getData() {
+    const mindmapRoot = this.getMindmap();
+    const config = getConfig2();
+    const userDefinedConfig = getUserDefinedConfig();
+    const hasUserDefinedLayout = userDefinedConfig.layout !== void 0;
+    const finalConfig = config;
+    if (!hasUserDefinedLayout) {
+      finalConfig.layout = "cose-bilkent";
+    }
+    if (!mindmapRoot) {
+      return {
+        nodes: [],
+        edges: [],
+        config: finalConfig
       };
-    });
-    cy.layout({
-      name: "cose-bilkent",
-      // @ts-ignore Types for cose-bilkent are not correct?
-      quality: "proof",
-      styleEnabled: false,
-      animate: false
-    }).run();
-    cy.ready((e) => {
-      log.info("Ready", e);
-      resolve(cy);
-    });
-  });
-}
-__name(layoutMindmap, "layoutMindmap");
-function positionNodes(db, cy) {
-  cy.nodes().map((node, id) => {
-    const data = node.data();
-    data.x = node.position().x;
-    data.y = node.position().y;
-    positionNode(db, data);
-    const el = db.getElementById(data.nodeId);
-    log.info("id:", id, "Position: (", node.position().x, ", ", node.position().y, ")", data);
-    el.attr(
-      "transform",
-      `translate(${node.position().x - data.width / 2}, ${node.position().y - data.height / 2})`
+    }
+    log.debug("getData: mindmapRoot", mindmapRoot, config);
+    this.assignSections(mindmapRoot);
+    const processedNodes = [];
+    const processedEdges = [];
+    this.flattenNodes(mindmapRoot, processedNodes);
+    this.generateEdges(mindmapRoot, processedEdges);
+    log.debug(
+      `getData: processed ${processedNodes.length} nodes and ${processedEdges.length} edges`
     );
-    el.attr("attr", `apa-${id})`);
-  });
-}
-__name(positionNodes, "positionNodes");
+    const shapes = /* @__PURE__ */ new Map();
+    for (const node of processedNodes) {
+      shapes.set(node.id, {
+        shape: node.shape,
+        width: node.width,
+        height: node.height,
+        padding: node.padding
+      });
+    }
+    return {
+      nodes: processedNodes,
+      edges: processedEdges,
+      config: finalConfig,
+      // Store the root node for mindmap-specific layout algorithms
+      rootNode: mindmapRoot,
+      // Properties required by dagre layout algorithm
+      markers: ["point"],
+      // Mindmaps don't use markers
+      direction: "TB",
+      // Top-to-bottom direction for mindmaps
+      nodeSpacing: 50,
+      // Default spacing between nodes
+      rankSpacing: 50,
+      // Default spacing between ranks
+      // Add shapes for ELK compatibility
+      shapes: Object.fromEntries(shapes),
+      // Additional properties that layout algorithms might expect
+      type: "mindmap",
+      diagramId: "mindmap-" + v4()
+    };
+  }
+  // Expose logger to grammar
+  getLogger() {
+    return log;
+  }
+};
+
+// src/diagrams/mindmap/mindmapRenderer.ts
 var draw = /* @__PURE__ */ __name(async (text, id, _version, diagObj) => {
   log.debug("Rendering mindmap diagram\n" + text);
   const db = diagObj.db;
+  const data4Layout = db.getData();
+  const svg = getDiagramElement(id, data4Layout.config.securityLevel);
+  data4Layout.type = diagObj.type;
+  data4Layout.layoutAlgorithm = getRegisteredLayoutAlgorithm(data4Layout.config.layout, {
+    fallback: "cose-bilkent"
+  });
+  data4Layout.diagramId = id;
   const mm = db.getMindmap();
   if (!mm) {
     return;
   }
-  const conf = getConfig2();
-  conf.htmlLabels = false;
-  const svg = selectSvgElement(id);
-  const edgesElem = svg.append("g");
-  edgesElem.attr("class", "mindmap-edges");
-  const nodesElem = svg.append("g");
-  nodesElem.attr("class", "mindmap-nodes");
-  await drawNodes(db, nodesElem, mm, -1, conf);
-  const cy = await layoutMindmap(mm, conf);
-  drawEdges(edgesElem, cy);
-  positionNodes(db, cy);
-  setupGraphViewbox(
-    void 0,
+  data4Layout.nodes.forEach((node) => {
+    if (node.shape === "rounded") {
+      node.radius = 15;
+      node.taper = 15;
+      node.stroke = "none";
+      node.width = 0;
+      node.padding = 15;
+    } else if (node.shape === "circle") {
+      node.padding = 10;
+    } else if (node.shape === "rect") {
+      node.width = 0;
+      node.padding = 10;
+    }
+  });
+  await render(data4Layout, svg);
+  setupViewPortForSVG(
     svg,
-    conf.mindmap?.padding ?? defaultConfig_default.mindmap.padding,
-    conf.mindmap?.useMaxWidth ?? defaultConfig_default.mindmap.useMaxWidth
+    data4Layout.config.mindmap?.padding ?? defaultConfig_default.mindmap.padding,
+    "mindmapDiagram",
+    data4Layout.config.mindmap?.useMaxWidth ?? defaultConfig_default.mindmap.useMaxWidth
   );
 }, "draw");
 var mindmapRenderer_default = {
@@ -1181,6 +1073,12 @@ var getStyles = /* @__PURE__ */ __name((options) => `
   .section-root text {
     fill: ${options.gitBranchLabel0};
   }
+  .section-root span {
+    color: ${options.gitBranchLabel0};
+  }
+  .section-2 span {
+    color: ${options.gitBranchLabel0};
+  }
   .icon-container {
     height:100%;
     display: flex;