{
  "version": 3,
  "sources": ["../../../src/rendering-util/layout-algorithms/dagre/index.js"],
  "sourcesContent": ["/* global injected */ // build-time constant injected via esbuild `define` (see .esbuild/util.ts)\nimport { layout as dagreLayout } from 'dagre-d3-es/src/dagre/index.js';\nimport * as graphlib from 'dagre-d3-es/src/graphlib/index.js';\nimport { createLayoutElementGroups, insertMeasuredNode } from '../../createGraph.js';\nimport { createCommonLayoutRenderer } from '../common/index.js';\nimport { profiler } from '../../../profiler.js';\nimport { updateNodeBounds } from '../../rendering-elements/shapes/util.js';\nimport {\n  clusterDb,\n  adjustClustersAndEdges,\n  findNonClusterChild,\n  sortNodesByHierarchy,\n} from './mermaid-graphlib.js';\nimport { positionNode, setNodeElem } from '../../rendering-elements/nodes.js';\nimport { insertCluster } from '../../rendering-elements/clusters.js';\nimport { insertEdgeLabel, positionEdgeLabel, insertEdge } from '../../rendering-elements/edges.js';\nimport { log } from '../../../logger.js';\nimport { getSubGraphTitleMargins } from '../../../utils/subGraphTitleMargins.js';\nimport { getConfig } from '../../../diagram-api/diagramAPI.js';\n\nconst clamp = (value, min, max) => Math.max(min, Math.min(max, value));\n\nconst getDefaultSelfLoopSide = (rankdir = 'TB') => {\n  switch (rankdir) {\n    case 'BT':\n      return 'bottom';\n    case 'LR':\n      return 'right';\n    case 'RL':\n      return 'left';\n    case 'TB':\n    default:\n      return 'top';\n  }\n};\n\nconst shouldMergeSelfLoopSegments = (diagramType) =>\n  diagramType === 'flowchart' ||\n  diagramType === 'flowchart-v2' ||\n  diagramType === 'stateDiagram' ||\n  diagramType === 'er' ||\n  diagramType === 'classDiagram';\n\n// Keep this a fixed literal allowlist \u2014 never derive keys from graph data, since node ids and\n// other graph keys are user-controlled and copying them wholesale onto LayoutData would open a\n// property-injection surface. `intersect`/`calcIntersect` are function references installed by\n// the shape handlers; the painter needs them alongside the geometry.\nconst DAGRE_NODE_LAYOUT_PROPERTIES = [\n  'x',\n  'y',\n  'width',\n  'height',\n  'labelBBox',\n  'intersect',\n  'calcIntersect',\n  'diff',\n  'clusterNode',\n];\n\n// Use dagre's dummy self-loop placement as a hint, so loops are not always forced above the node.\nconst getSelfLoopSide = (graph, node, segments, originalNodeId, rankdir) => {\n  const layoutHints = [];\n  const dummyNodeIds = new Set();\n\n  segments.forEach(({ start, end }) => {\n    if (start !== originalNodeId) {\n      dummyNodeIds.add(start);\n    }\n    if (end !== originalNodeId) {\n      dummyNodeIds.add(end);\n    }\n  });\n\n  dummyNodeIds.forEach((id) => {\n    const dummyNode = graph.node(id);\n    if (typeof dummyNode?.x === 'number' && typeof dummyNode?.y === 'number') {\n      layoutHints.push(dummyNode);\n    }\n  });\n\n  if (layoutHints.length === 0) {\n    segments.forEach(({ edge }) => {\n      (edge.points ?? []).forEach((point) => {\n        if (typeof point?.x === 'number' && typeof point?.y === 'number') {\n          layoutHints.push(point);\n        }\n      });\n    });\n  }\n\n  if (layoutHints.length === 0) {\n    return getDefaultSelfLoopSide(rankdir);\n  }\n\n  const center = layoutHints.reduce(\n    (acc, point) => ({\n      x: acc.x + point.x / layoutHints.length,\n      y: acc.y + point.y / layoutHints.length,\n    }),\n    { x: 0, y: 0 }\n  );\n  const dx = center.x - node.x;\n  const dy = center.y - node.y;\n\n  if (Math.abs(dx) > Math.abs(dy)) {\n    return dx > 0 ? 'right' : 'left';\n  }\n  if (Math.abs(dy) > 0) {\n    return dy > 0 ? 'bottom' : 'top';\n  }\n  return getDefaultSelfLoopSide(rankdir);\n};\n\n// Build a compact loop around the node instead of rendering dagre's long dummy-edge route.\nconst getSelfLoopPoints = (node, side = 'top', yOffset = 0, labelWidth = 0) => {\n  const x = node.x;\n  const y = node.y - yOffset;\n  const halfWidth = node.width / 2;\n  const halfHeight = node.height / 2;\n  const maxSpan = Math.max(36, Math.min(100, node.width * 0.8));\n  const span = clamp(Math.max(labelWidth, node.width * 0.35), 36, maxSpan);\n  const depth = clamp(Math.min(node.width, node.height) * 0.45, 24, 48);\n\n  switch (side) {\n    case 'bottom': {\n      const bottom = y + halfHeight;\n      return [\n        { x: x - span / 2, y: bottom },\n        { x: x - span / 2, y: bottom + depth },\n        { x: x + span / 2, y: bottom + depth },\n        { x: x + span / 2, y: bottom },\n      ];\n    }\n    case 'right': {\n      const right = x + halfWidth;\n      return [\n        { x: right, y: y - span / 2 },\n        { x: right + depth, y: y - span / 2 },\n        { x: right + depth, y: y + span / 2 },\n        { x: right, y: y + span / 2 },\n      ];\n    }\n    case 'left': {\n      const left = x - halfWidth;\n      return [\n        { x: left, y: y - span / 2 },\n        { x: left - depth, y: y - span / 2 },\n        { x: left - depth, y: y + span / 2 },\n        { x: left, y: y + span / 2 },\n      ];\n    }\n    case 'top':\n    default: {\n      const top = y - halfHeight;\n      return [\n        { x: x - span / 2, y: top },\n        { x: x - span / 2, y: top - depth },\n        { x: x + span / 2, y: top - depth },\n        { x: x + span / 2, y: top },\n      ];\n    }\n  }\n};\n\nconst getSelfLoopLabelPosition = (node, points, side = 'top', yOffset = 0, label = {}) => {\n  const gap = 4;\n  const x = node.x;\n  const y = node.y - yOffset;\n  const labelWidth = label.width ?? 0;\n  const labelHeight = label.height ?? 0;\n\n  switch (side) {\n    case 'bottom':\n      return { x, y: Math.max(...points.map((point) => point.y)) + labelHeight / 2 + gap };\n    case 'right':\n      return { x: Math.max(...points.map((point) => point.x)) + labelWidth / 2 + gap, y };\n    case 'left':\n      return { x: Math.min(...points.map((point) => point.x)) - labelWidth / 2 - gap, y };\n    case 'top':\n    default:\n      return { x, y: Math.min(...points.map((point) => point.y)) - labelHeight / 2 - gap };\n  }\n};\n\n// Convert internal dagre layout edges into the public SVG edges we actually render.\nexport const getEdgesToRender = (graph, yOffset = 0, { mergeSelfLoops = true } = {}) => {\n  const selfLoopEdgeGroups = new Map();\n  const edgesToRender = [];\n  const rankdir = graph.graph()?.rankdir;\n\n  graph.edges().forEach((e) => {\n    const edge = graph.edge(e);\n    if (mergeSelfLoops && edge.selfLoop) {\n      const key = edge.selfLoop.id;\n      if (!selfLoopEdgeGroups.has(key)) {\n        selfLoopEdgeGroups.set(key, []);\n      }\n      selfLoopEdgeGroups.get(key).push({ edge, start: e.v, end: e.w });\n    } else {\n      edgesToRender.push({ edge, start: e.v, end: e.w });\n    }\n  });\n\n  selfLoopEdgeGroups.forEach((segments) => {\n    if (segments.length !== 3) {\n      // Unexpected self-loop state: preserve the old rendering behavior rather than dropping edges.\n      segments.forEach((segment) => edgesToRender.push(segment));\n      return;\n    }\n\n    segments.sort((a, b) => a.edge.selfLoop.order - b.edge.selfLoop.order);\n    const [firstSegment, middleSegment, lastSegment] = segments;\n    const originalEdge =\n      firstSegment.edge.originalEdge ??\n      middleSegment.edge.originalEdge ??\n      lastSegment.edge.originalEdge ??\n      middleSegment.edge;\n    const node = graph.node(originalEdge.start);\n    if (!node) {\n      segments.forEach((segment) => edgesToRender.push(segment));\n      return;\n    }\n    const label = {\n      width: middleSegment.edge.width,\n      height: middleSegment.edge.height,\n    };\n    // Dagre uses the dummy route for layout; the SVG output should still be one logical edge.\n    const side = getSelfLoopSide(graph, node, segments, originalEdge.start, rankdir);\n    const points = getSelfLoopPoints(node, side, yOffset, label.width ?? 0);\n    const labelPosition = getSelfLoopLabelPosition(node, points, side, yOffset, label);\n    const mergedEdge = {\n      ...middleSegment.edge,\n      ...originalEdge,\n      id: originalEdge.id,\n      points,\n      start: originalEdge.start,\n      end: originalEdge.end,\n      x: labelPosition.x,\n      y: labelPosition.y,\n      width: label.width,\n      height: label.height,\n      labelStyle: middleSegment.edge.labelStyle,\n      fromCluster:\n        firstSegment.edge.fromCluster ??\n        middleSegment.edge.fromCluster ??\n        lastSegment.edge.fromCluster,\n      toCluster:\n        firstSegment.edge.toCluster ?? middleSegment.edge.toCluster ?? lastSegment.edge.toCluster,\n    };\n    delete mergedEdge.selfLoop;\n    delete mergedEdge.originalEdge;\n\n    edgesToRender.push({ edge: mergedEdge, start: mergedEdge.start, end: mergedEdge.end });\n  });\n\n  return edgesToRender;\n};\n\nconst measureDagreGraph = async ({\n  element: _elem,\n  graph,\n  diagramType,\n  id,\n  parentCluster,\n  siteConfig,\n}) => {\n  // perf: skip eager graphlibJson.write() serialization (the arg runs every render even when the log is a no-op)\n  // log.warn('Graph in recursive render:XAX', graphlibJson.write(graph), parentCluster);\n  const dir = graph.graph().rankdir;\n  log.trace('Dir in recursive render - dir:', dir);\n\n  const {\n    clusters,\n    edgePaths,\n    edgeLabels,\n    nodes,\n    rootGroups: elem,\n  } = createLayoutElementGroups(_elem, {\n    edgePathsClass: 'edgePaths',\n  });\n  if (!graph.nodes()) {\n    log.info('No nodes found for', graph);\n  } else {\n    log.info('Recursive render XXX', graph.nodes());\n  }\n  if (graph.edges().length > 0) {\n    log.info('Recursive edges', graph.edge(graph.edges()[0]));\n  }\n  const mergeSelfLoops = shouldMergeSelfLoopSegments(diagramType);\n\n  // Insert nodes, this will insert them into the dom and each node will get a size. The size is updated\n  // to the abstract node and is later used by dagre for the layout\n  await Promise.all(\n    graph.nodes().map(async function (v) {\n      const node = graph.node(v);\n      if (parentCluster !== undefined) {\n        const data = JSON.parse(JSON.stringify(parentCluster.clusterData));\n        // data.clusterPositioning = true;\n        log.trace(\n          'Setting data for parent cluster XXX\\n Node.id = ',\n          v,\n          '\\n data=',\n          data.height,\n          '\\nParent cluster',\n          parentCluster.height\n        );\n        graph.setNode(parentCluster.id, data);\n        if (!graph.parent(v)) {\n          log.trace('Setting parent', v, parentCluster.id);\n          graph.setParent(v, parentCluster.id, data);\n        }\n      }\n      log.info('(Insert) Node XXX' + v + ': ' + JSON.stringify(graph.node(v)));\n      if (node?.clusterNode) {\n        // const children = graph.children(v);\n        log.info('Cluster identified XBX', v, node.width, graph.node(v));\n\n        // `node.graph.setGraph` applies the graph configurations such as nodeSpacing to subgraphs as without this the default values would be used\n        // We override only the `ranksep` and `nodesep` configurations to allow for setting subgraph spacing while avoiding overriding other properties\n        const { ranksep, nodesep } = graph.graph();\n        node.graph.setGraph({\n          ...node.graph.graph(),\n          ranksep: ranksep + 25,\n          nodesep,\n        });\n\n        // \"o\" will contain the full cluster not just the children\n        const o = await renderDagreSubgraph({\n          element: nodes,\n          graph: node.graph,\n          diagramType,\n          id,\n          parentCluster: graph.node(v),\n          siteConfig,\n        });\n        const newEl = o.elem;\n        updateNodeBounds(node, newEl);\n        // node.height = o.diff;\n        node.diff = o.diff || 0;\n        log.info(\n          'New compound node after recursive render XAX',\n          v,\n          'width',\n          // node,\n          node.width,\n          'height',\n          node.height\n          // node.x,\n          // node.y\n        );\n        setNodeElem(newEl, node);\n      } else {\n        if (graph.children(v).length > 0) {\n          // This is a cluster but not to be rendered recursively\n          // Render as before\n          log.trace(\n            'Cluster - the non recursive path XBX',\n            v,\n            node.id,\n            node,\n            node.width,\n            'Graph:',\n            graph\n          );\n          log.trace(findNonClusterChild(node.id, graph));\n          clusterDb.set(node.id, { id: findNonClusterChild(node.id, graph), node });\n          // insertCluster(clusters, graph.node(v));\n        } else {\n          log.trace('Node - the non recursive path XAX', v, nodes, graph.node(v), dir);\n          await insertMeasuredNode(nodes, graph.node(v), { config: siteConfig, dir });\n        }\n      }\n    })\n  );\n\n  const processEdges = async () => {\n    const edgePromises = graph.edges().map(async function (e) {\n      const edge = graph.edge(e.v, e.w, e.name);\n      log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));\n      log.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));\n\n      // Check if link is either from or to a cluster\n      log.info(\n        'Fix',\n        clusterDb,\n        'ids:',\n        e.v,\n        e.w,\n        'Translating: ',\n        clusterDb.get(e.v),\n        clusterDb.get(e.w)\n      );\n      if (mergeSelfLoops && edge.selfLoop) {\n        // Only the middle layout segment owns the label, using the original edge id for lookup.\n        if (edge.selfLoop.order !== 1) {\n          return;\n        }\n        const labelEdge = {\n          ...edge.originalEdge,\n          ...edge,\n          id: edge.selfLoop.id,\n          startLabelLeft: edge.originalEdge?.startLabelLeft ?? edge.startLabelLeft,\n          startLabelRight: edge.originalEdge?.startLabelRight ?? edge.startLabelRight,\n          endLabelLeft: edge.originalEdge?.endLabelLeft ?? edge.endLabelLeft,\n          endLabelRight: edge.originalEdge?.endLabelRight ?? edge.endLabelRight,\n        };\n        await insertEdgeLabel(edgeLabels, labelEdge);\n        edge.width = labelEdge.width;\n        edge.height = labelEdge.height;\n        edge.labelStyle = labelEdge.labelStyle;\n        return;\n      }\n      await insertEdgeLabel(edgeLabels, edge);\n    });\n\n    await Promise.all(edgePromises);\n  };\n\n  await processEdges();\n\n  const { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig);\n  return {\n    elem,\n    graph,\n    groups: { clusters, edgePaths, edgeLabels, nodes, rootGroups: elem },\n    diagramType,\n    id,\n    mergeSelfLoops,\n    subGraphTitleTotalMargin,\n  };\n};\n\nconst runDagreGraphLayout = (graph) => {\n  // perf: skip eager graphlibJson.write() serialization (the arg runs every render even when the log is a no-op)\n  // log.info('Graph before layout:', JSON.stringify(graphlibJson.write(graph)));\n\n  log.info('############################################# XXX');\n  log.info('###                Layout                 ### XXX');\n  log.info('############################################# XXX');\n\n  // Time the actual external dagre call on its own (\"layoutCore\"); the rest of\n  // this function is our wrapper (DOM, graph (de)serialization, \u2026).\n  if (injected.profiling) {\n    profiler.begin('layoutCore');\n  }\n  dagreLayout(graph);\n  if (injected.profiling) {\n    profiler.end(); // layoutCore\n  }\n\n  // perf: skip eager graphlibJson.write() serialization (the arg runs every render even when the log is a no-op)\n  // log.info('Graph after layout:', JSON.stringify(graphlibJson.write(graph)));\n};\n\nconst normalizeDagreNode = (graph, nodeId, subGraphTitleTotalMargin) => {\n  const node = graph.node(nodeId);\n  if (!node) {\n    return undefined;\n  }\n\n  const normalizedNode = { ...node };\n  if (node?.clusterNode) {\n    normalizedNode.y = (node.y ?? 0) + subGraphTitleTotalMargin;\n  } else if (graph.children(nodeId).length > 0) {\n    normalizedNode.height = (node.height ?? 0) + subGraphTitleTotalMargin;\n  } else {\n    normalizedNode.y = (node.y ?? 0) + subGraphTitleTotalMargin / 2;\n  }\n  return normalizedNode;\n};\n\nconst applyDagreNodeLayout = (targetNode, dagreNode) => {\n  DAGRE_NODE_LAYOUT_PROPERTIES.forEach((property) => {\n    if (dagreNode[property] !== undefined) {\n      targetNode[property] = dagreNode[property];\n    }\n  });\n};\n\nconst normalizeDagreEdge = (edge, start, end, edgeOffsetY) => ({\n  ...edge,\n  start: edge.start ?? start,\n  end: edge.end ?? end,\n  points: (edge.points ?? []).map((point) => ({\n    ...point,\n    y: typeof point.y === 'number' ? point.y + edgeOffsetY : point.y,\n  })),\n});\n\n/**\n * Copy the Dagre layout results back onto LayoutData.\n *\n * Known limitations \u2014 the normalization only covers the top-level graph:\n * - Recursive clusters: `adjustClustersAndEdges` moves cluster children and intra-cluster edges\n *   into the nested `node.graph`, where they are laid out and painted during the recursive\n *   measure pass in their own coordinate space. Those nodes keep their pre-layout LayoutData\n *   values, and intra-cluster edges are absent from the normalized `data4Layout.edges`.\n * - Self-loops on diagram types where segments are not merged: the three `*-cyclic-special-*`\n *   layout segments replace the original self-edge in `data4Layout.edges`, since they are what\n *   is actually rendered.\n * Consumers of the normalized LayoutData must not assume it is a complete description of the\n * rendered output for cluster diagrams \u2014 the recursive paint path owns the nested content.\n */\nexport const applyDagreLayoutResult = (data4Layout, measuredLayout) => {\n  const { graph, mergeSelfLoops, subGraphTitleTotalMargin = 0 } = measuredLayout;\n  const nodeById = new Map(data4Layout.nodes.map((node) => [node.id, node]));\n\n  sortNodesByHierarchy(graph).forEach((nodeId) => {\n    const dagreNode = normalizeDagreNode(graph, nodeId, subGraphTitleTotalMargin);\n    if (!dagreNode) {\n      return;\n    }\n\n    applyDagreNodeLayout(graph.node(nodeId), dagreNode);\n\n    const targetNode = nodeById.get(nodeId);\n    if (targetNode) {\n      applyDagreNodeLayout(targetNode, dagreNode);\n    }\n  });\n\n  const edgeOffsetY = subGraphTitleTotalMargin / 2;\n  data4Layout.edges = getEdgesToRender(graph, edgeOffsetY, { mergeSelfLoops }).map(\n    ({ edge, start, end }) => normalizeDagreEdge(edge, start, end, edgeOffsetY)\n  );\n\n  return data4Layout;\n};\n\nconst paintDagreLayoutCore = async ({\n  elem,\n  graph,\n  groups: { clusters, edgePaths },\n  diagramType,\n  id,\n  mergeSelfLoops,\n  subGraphTitleTotalMargin,\n}) => {\n  // Move the nodes to the correct place\n  let diff = 0;\n  await Promise.all(\n    sortNodesByHierarchy(graph).map(async function (v) {\n      const node = graph.node(v);\n      log.info(\n        'Position XBX => ' + v + ': (' + node.x,\n        ',' + node.y,\n        ') width: ',\n        node.width,\n        ' height: ',\n        node.height\n      );\n      if (node?.clusterNode) {\n        // Adjust for padding when on root level\n        node.y += subGraphTitleTotalMargin;\n\n        log.info(\n          'A tainted cluster node XBX1',\n          v,\n          node.id,\n          node.width,\n          node.height,\n          node.x,\n          node.y,\n          graph.parent(v)\n        );\n        clusterDb.get(node.id).node = node;\n        positionNode(node);\n      } else {\n        // A tainted cluster node\n        if (graph.children(v).length > 0) {\n          log.info(\n            'A pure cluster node XBX1',\n            v,\n            node.id,\n            node.x,\n            node.y,\n            node.width,\n            node.height,\n            graph.parent(v)\n          );\n          node.height += subGraphTitleTotalMargin;\n          graph.node(node.parentId);\n          const halfPadding = node?.padding / 2 || 0;\n          const labelHeight = node?.labelBBox?.height || 0;\n          const offsetY = labelHeight - halfPadding || 0;\n          log.debug('OffsetY', offsetY, 'labelHeight', labelHeight, 'halfPadding', halfPadding);\n          await insertCluster(clusters, node);\n\n          // A cluster in the non-recursive way\n          clusterDb.get(node.id).node = node;\n        } else {\n          // Regular node\n          const parent = graph.node(node.parentId);\n          node.y += subGraphTitleTotalMargin / 2;\n          log.info(\n            'A regular node XBX1 - using the padding',\n            node.id,\n            'parent',\n            node.parentId,\n            node.width,\n            node.height,\n            node.x,\n            node.y,\n            'offsetY',\n            node.offsetY,\n            'parent',\n            parent,\n            parent?.offsetY,\n            node\n          );\n\n          positionNode(node);\n        }\n      }\n    })\n  );\n\n  // Move the edge labels to the correct place after layout\n  const edgeOffsetY = subGraphTitleTotalMargin / 2;\n  const edgesToRender = getEdgesToRender(graph, edgeOffsetY, { mergeSelfLoops });\n\n  edgesToRender.forEach(function ({ edge, start, end }) {\n    log.info('Edge ' + start + ' -> ' + end + ': ' + JSON.stringify(edge), edge);\n\n    edge.points.forEach((point) => (point.y += edgeOffsetY));\n    const startNode = graph.node(start);\n    const endNode = graph.node(end);\n    const paths = insertEdge(edgePaths, edge, clusterDb, diagramType, startNode, endNode, id);\n    positionEdgeLabel(edge, paths);\n  });\n\n  graph.nodes().forEach(function (v) {\n    const n = graph.node(v);\n    log.info(v, n.type, n.diff);\n    if (n.isGroup) {\n      diff = n.diff;\n    }\n  });\n  log.warn('Returning from recursive render XAX', elem, diff);\n  return { elem, diff };\n};\n\nconst renderDagreSubgraph = async (options) => {\n  const measuredLayout = await measureDagreGraph(options);\n  runDagreGraphLayout(measuredLayout.graph);\n  return await paintDagreLayoutCore(measuredLayout);\n};\n\nexport const prepareLayoutForDagre = (data4Layout) => {\n  const graph = new graphlib.Graph({\n    multigraph: true,\n    compound: true,\n  })\n    .setGraph({\n      rankdir: data4Layout.direction,\n      // Precedence: an explicit top-level config override (only present when a\n      // user sets it - it has no schema default) > the value the diagram's own\n      // renderer put on data4Layout (usually derived from that diagram's config)\n      // > the flowchart config as a generic fallback. The flowchart keys have\n      // schema defaults and therefore always exist, so they must come last or\n      // they silently shadow every diagram's own spacing (see #7932).\n      nodesep:\n        data4Layout.config?.nodeSpacing ||\n        data4Layout.nodeSpacing ||\n        data4Layout.config?.flowchart?.nodeSpacing,\n      ranksep:\n        data4Layout.config?.rankSpacing ||\n        data4Layout.rankSpacing ||\n        data4Layout.config?.flowchart?.rankSpacing,\n      marginx: 8,\n      marginy: 8,\n    })\n    .setDefaultEdgeLabel(function () {\n      return {};\n    });\n\n  data4Layout.nodes.forEach((node) => {\n    graph.setNode(node.id, { ...node });\n    if (node.parentId) {\n      graph.setParent(node.id, node.parentId);\n    }\n  });\n\n  log.debug('Edges:', data4Layout.edges);\n  data4Layout.edges.forEach((edge) => {\n    if (edge.start === edge.end) {\n      // Keep the dagre dummy-node workaround for layout, then merge these segments before rendering.\n      const nodeId = edge.start;\n      const specialId1 = nodeId + '---' + nodeId + '---1';\n      const specialId2 = nodeId + '---' + nodeId + '---2';\n      const node = graph.node(nodeId);\n      graph.setNode(specialId1, {\n        domId: specialId1,\n        id: specialId1,\n        parentId: node.parentId,\n        labelStyle: '',\n        label: '',\n        padding: 0,\n        shape: 'labelRect',\n        // shape: 'rect',\n        style: '',\n        width: 10,\n        height: 10,\n      });\n      graph.setParent(specialId1, node.parentId);\n      graph.setNode(specialId2, {\n        domId: specialId2,\n        id: specialId2,\n        parentId: node.parentId,\n        labelStyle: '',\n        padding: 0,\n        // shape: 'rect',\n        shape: 'labelRect',\n        label: '',\n        style: '',\n        width: 10,\n        height: 10,\n      });\n      graph.setParent(specialId2, node.parentId);\n\n      const originalEdge = structuredClone(edge);\n      const edge1 = structuredClone(edge);\n      const edgeMid = structuredClone(edge);\n      const edge2 = structuredClone(edge);\n      // Preserve the original edge so the final SVG path uses the logical self-loop id and data.\n      edge1.originalEdge = originalEdge;\n      edge1.selfLoop = { id: originalEdge.id, order: 0 };\n      edgeMid.originalEdge = originalEdge;\n      edgeMid.selfLoop = { id: originalEdge.id, order: 1 };\n      edge2.originalEdge = originalEdge;\n      edge2.selfLoop = { id: originalEdge.id, order: 2 };\n      edge1.label = '';\n      edge1.arrowTypeEnd = 'none';\n      edge1.endLabelLeft = '';\n      edge1.endLabelRight = ''; // defensive\n      edge1.startLabelLeft = ''; // defensive\n      edge1.id = nodeId + '-cyclic-special-1';\n      edgeMid.startLabelRight = '';\n      edgeMid.startLabelLeft = ''; // defensive\n      edgeMid.endLabelLeft = '';\n      edgeMid.endLabelRight = ''; // defensive\n      edgeMid.arrowTypeStart = 'none';\n      edgeMid.arrowTypeEnd = 'none';\n      edgeMid.id = nodeId + '-cyclic-special-mid';\n      edge2.label = '';\n      edge2.startLabelRight = '';\n      edge2.startLabelLeft = ''; // defensive\n      edge2.arrowTypeStart = 'none';\n      if (node.isGroup) {\n        edge1.fromCluster = nodeId;\n        edge2.toCluster = nodeId;\n      }\n      edge2.id = nodeId + '-cyclic-special-2';\n      edge2.arrowTypeStart = 'none';\n      graph.setEdge(nodeId, specialId1, edge1, nodeId + '-cyclic-special-0');\n      graph.setEdge(specialId1, specialId2, edgeMid, nodeId + '-cyclic-special-1');\n      graph.setEdge(specialId2, nodeId, edge2, nodeId + '-cyclic-special-2');\n    } else {\n      graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);\n    }\n  });\n\n  // perf: skip eager graphlibJson.write() serialization (the arg runs every render even when the log is a no-op)\n  // log.debug('Graph at first:', JSON.stringify(graphlibJson.write(graph)));\n  adjustClustersAndEdges(graph);\n  // perf: skip eager graphlibJson.write() serialization (the arg runs every render even when the log is a no-op)\n  // log.warn('Graph after XAX:', JSON.stringify(graphlibJson.write(graph)));\n\n  return { graph };\n};\n\nexport const measureDagreLayout = async (data4Layout, { element, preparedLayout }) => {\n  const prepared = preparedLayout ?? prepareLayoutForDagre(data4Layout);\n  const siteConfig = getConfig();\n  const measuredLayout = await measureDagreGraph({\n    element,\n    graph: prepared.graph,\n    diagramType: data4Layout.type,\n    id: data4Layout.diagramId,\n    parentCluster: undefined,\n    siteConfig,\n  });\n  prepared.measuredLayout = measuredLayout;\n  return measuredLayout;\n};\n\nexport const runDagreLayoutCore = (data4Layout, context) => {\n  const measuredLayout = context.preparedLayout?.measuredLayout;\n\n  if (!measuredLayout) {\n    throw new Error('runDagreLayoutCore requires measureDagreLayout to run first');\n  }\n\n  runDagreGraphLayout(measuredLayout.graph);\n  applyDagreLayoutResult(data4Layout, measuredLayout);\n  return measuredLayout;\n};\n\nconst getDagrePaintNodes = (_data4Layout, { measure }) =>\n  sortNodesByHierarchy(measure.graph)\n    .map((nodeId) => measure.graph.node(nodeId))\n    .filter(Boolean);\n\nconst getDagreEdgeNode = (nodeId, _edge, { measure }) =>\n  nodeId ? measure.graph.node(nodeId) : undefined;\n\nexport const render = createCommonLayoutRenderer({\n  prepareLayout: prepareLayoutForDagre,\n  measureLayout: measureDagreLayout,\n  runLayoutCore: runDagreLayoutCore,\n  paintOptions: {\n    clusterDb,\n    getNodes: getDagrePaintNodes,\n    getEdgeNode: getDagreEdgeNode,\n    skipNode: (node, { measure }) => !measure.graph.hasNode(node.id),\n    isCluster: (node, { measure }) =>\n      measure.graph.hasNode(node.id) && (measure.graph.children(node.id) ?? []).length > 0,\n  },\n});\n"],
  "mappings": "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",
  "names": ["clamp", "__name", "value", "min", "max", "getDefaultSelfLoopSide", "rankdir", "shouldMergeSelfLoopSegments", "diagramType", "DAGRE_NODE_LAYOUT_PROPERTIES", "getSelfLoopSide", "graph", "node", "segments", "originalNodeId", "layoutHints", "dummyNodeIds", "start", "end", "id", "dummyNode", "edge", "point", "center", "acc", "dx", "dy", "getSelfLoopPoints", "side", "yOffset", "labelWidth", "x", "y", "halfWidth", "halfHeight", "maxSpan", "span", "depth", "bottom", "right", "left", "top", "getSelfLoopLabelPosition", "points", "label", "labelHeight", "getEdgesToRender", "mergeSelfLoops", "selfLoopEdgeGroups", "edgesToRender", "e", "key", "segment", "a", "b", "firstSegment", "middleSegment", "lastSegment", "originalEdge", "labelPosition", "mergedEdge", "measureDagreGraph", "_elem", "parentCluster", "siteConfig", "dir", "log", "clusters", "edgePaths", "edgeLabels", "nodes", "elem", "createLayoutElementGroups", "v", "data", "ranksep", "nodesep", "o", "renderDagreSubgraph", "newEl", "updateNodeBounds", "setNodeElem", "findNonClusterChild", "clusterDb", "insertMeasuredNode", "edgePromises", "labelEdge", "insertEdgeLabel", "subGraphTitleTotalMargin", "getSubGraphTitleMargins", "runDagreGraphLayout", "layout", "normalizeDagreNode", "nodeId", "normalizedNode", "applyDagreNodeLayout", "targetNode", "dagreNode", "property", "normalizeDagreEdge", "edgeOffsetY", "applyDagreLayoutResult", "data4Layout", "measuredLayout", "nodeById", "sortNodesByHierarchy", "paintDagreLayoutCore", "diff", "positionNode", "halfPadding", "offsetY", "insertCluster", "parent", "startNode", "endNode", "paths", "insertEdge", "positionEdgeLabel", "n", "options", "prepareLayoutForDagre", "Graph", "specialId1", "specialId2", "edge1", "edgeMid", "edge2", "adjustClustersAndEdges", "measureDagreLayout", "element", "preparedLayout", "prepared", "getConfig", "runDagreLayoutCore", "context", "getDagrePaintNodes", "_data4Layout", "measure", "getDagreEdgeNode", "_edge", "render", "createCommonLayoutRenderer"]
}