@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-DU7W62N5.js

@@ -0,0 +1,487 @@
+import {
+  extractExportSvg,
+  runInExportContainer
+} from "./chunk-Y5QGVTVC.js";
+import {
+  renderCollapseBar,
+  renderNodeCard
+} from "./chunk-VOKGH627.js";
+import {
+  CARD_RADIUS,
+  COLLAPSE_BAR_HEIGHT,
+  COLLAPSE_BAR_INSET,
+  CONTAINER_HEADER_HEIGHT,
+  CONTAINER_LABEL_FONT_SIZE,
+  CONTAINER_META_FONT_SIZE,
+  CONTAINER_META_LINE_HEIGHT,
+  CONTAINER_RADIUS,
+  EDGE_STROKE_WIDTH,
+  HEADER_HEIGHT,
+  LABEL_FONT_SIZE,
+  META_FONT_SIZE,
+  META_LINE_HEIGHT,
+  NODE_STROKE_WIDTH,
+  SEPARATOR_GAP
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  layoutOrg
+} from "./chunk-J5FIXQRT.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-YAA6IID3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  EYE_CLOSED_PATH,
+  EYE_OPEN_PATH,
+  LEGEND_EYE_GAP,
+  LEGEND_EYE_SIZE,
+  LEGEND_GROUP_GAP,
+  LEGEND_HEIGHT
+} from "./chunk-QOOUC2J5.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  parseOrg
+} from "./chunk-RVMRZAPB.js";
+import {
+  contrastText,
+  mix,
+  shapeFill,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveTagColor,
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+
+// src/org/renderer.ts
+import * as d3Selection from "d3-selection";
+var DIAGRAM_PADDING = 20;
+var MAX_SCALE = 3;
+var TITLE_HEIGHT = 30;
+var ANCESTOR_DOT_R = 4;
+var ANCESTOR_LABEL_FONT_SIZE = 11;
+var ANCESTOR_ROW_HEIGHT = 22;
+var ANCESTOR_TRAIL_BOTTOM_GAP = 16;
+var LEGEND_FIXED_GAP = 8;
+function nodeFill(palette, isDark, nodeColor, solid) {
+  const color = nodeColor ?? palette.primary;
+  return shapeFill(palette, color, isDark, {
+    ...solid !== void 0 && { solid }
+  });
+}
+function nodeStroke(palette, nodeColor) {
+  return nodeColor ?? palette.primary;
+}
+function containerFill(palette, isDark, nodeColor) {
+  if (nodeColor) {
+    return mix(nodeColor, themeBaseBg(palette, isDark), 10);
+  }
+  return mix(palette.surface, palette.bg, 40);
+}
+function containerStroke(palette, nodeColor) {
+  return nodeColor ?? palette.textMuted;
+}
+function renderOrg(container, parsed, layout, palette, isDark, onClickItem, exportDims, activeTagGroup, hiddenAttributes, ancestorPath, exportMode) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const ctx = ScaleContext.identity();
+  const sDiagramPadding = ctx.aesthetic(DIAGRAM_PADDING);
+  const sTitleHeight = ctx.structural(TITLE_HEIGHT);
+  const sLabelFontSize = ctx.text(LABEL_FONT_SIZE);
+  const sMetaFontSize = ctx.text(META_FONT_SIZE);
+  const sMetaLineHeight = ctx.structural(META_LINE_HEIGHT);
+  const sHeaderHeight = ctx.structural(HEADER_HEIGHT);
+  const sSeparatorGap = ctx.structural(SEPARATOR_GAP);
+  const sEdgeStrokeWidth = ctx.structural(EDGE_STROKE_WIDTH);
+  const sNodeStrokeWidth = ctx.structural(NODE_STROKE_WIDTH);
+  const sCardRadius = ctx.structural(CARD_RADIUS);
+  const sContainerRadius = ctx.structural(CONTAINER_RADIUS);
+  const sContainerLabelFontSize = ctx.text(CONTAINER_LABEL_FONT_SIZE);
+  const sContainerMetaFontSize = ctx.text(CONTAINER_META_FONT_SIZE);
+  const sContainerMetaLineHeight = ctx.structural(CONTAINER_META_LINE_HEIGHT);
+  const sContainerHeaderHeight = ctx.structural(CONTAINER_HEADER_HEIGHT);
+  const sCollapseBarHeight = ctx.structural(COLLAPSE_BAR_HEIGHT);
+  const sCollapseBarInset = ctx.structural(COLLAPSE_BAR_INSET);
+  const sAncestorDotR = ctx.structural(ANCESTOR_DOT_R);
+  const sAncestorLabelFontSize = ctx.text(ANCESTOR_LABEL_FONT_SIZE);
+  const sAncestorRowHeight = ctx.structural(ANCESTOR_ROW_HEIGHT);
+  const sAncestorTrailBottomGap = ctx.structural(ANCESTOR_TRAIL_BOTTOM_GAP);
+  const sLegendFixedGap = ctx.aesthetic(LEGEND_FIXED_GAP);
+  const showTitle = !!parsed.title && parsed.options["no-title"] !== "on";
+  const titleOffset = showTitle ? sTitleHeight : 0;
+  const legendOnly = layout.nodes.length === 0;
+  const hasLegend = layout.legend.length > 0;
+  const layoutLegendShift = LEGEND_HEIGHT + LEGEND_GROUP_GAP;
+  const fixedLegend = !exportDims && hasLegend && !legendOnly;
+  const legendReserve = fixedLegend ? getMaxLegendReservedHeight(
+    {
+      groups: parsed.tagGroups,
+      position: { placement: "top-center", titleRelation: "below-title" },
+      mode: "preview",
+      capsulePillAddonWidth: LEGEND_EYE_SIZE + LEGEND_EYE_GAP
+    },
+    width
+  ) + sLegendFixedGap : 0;
+  const fixedTitle = !exportDims && showTitle;
+  const titleReserve = fixedTitle ? sTitleHeight : 0;
+  const hasAncestorTrail = !exportDims && ancestorPath && ancestorPath.length > 0;
+  const ancestorTrailHeight = hasAncestorTrail ? ancestorPath.length * sAncestorRowHeight + sAncestorTrailBottomGap : 0;
+  const diagramW = layout.width;
+  let diagramH = layout.height + (fixedTitle ? 0 : titleOffset) + ancestorTrailHeight;
+  if (fixedLegend) {
+    diagramH -= layoutLegendShift;
+  }
+  const availH = height - sDiagramPadding * 2 - legendReserve - titleReserve;
+  const scaleX = (width - sDiagramPadding * 2) / diagramW;
+  const scaleY = availH / diagramH;
+  const scale = Math.min(MAX_SCALE, scaleX, scaleY);
+  const scaledW = diagramW * scale;
+  const offsetX = (width - scaledW) / 2;
+  const offsetY = fixedLegend ? sDiagramPadding + legendReserve + titleReserve : sDiagramPadding + titleReserve;
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMin meet").style("font-family", FONT_FAMILY);
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const mainG = svg.append("g").attr("transform", `translate(${offsetX}, ${offsetY}) scale(${scale})`);
+  if (showTitle) {
+    const titleParent = fixedTitle ? svg : mainG;
+    const titleX = fixedTitle ? width / 2 : diagramW / 2;
+    const titleY = fixedTitle ? sDiagramPadding + TITLE_FONT_SIZE : TITLE_FONT_SIZE;
+    const titleEl = titleParent.append("text").attr("x", titleX).attr("y", titleY).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("class", "org-title chart-title").style(
+      "cursor",
+      onClickItem && parsed.titleLineNumber ? "pointer" : "default"
+    ).text(parsed.title);
+    if (parsed.titleLineNumber) {
+      titleEl.attr("data-line-number", parsed.titleLineNumber);
+      if (onClickItem) {
+        titleEl.on("click", () => onClickItem(parsed.titleLineNumber)).on("mouseenter", function() {
+          d3Selection.select(this).attr("opacity", 0.7);
+        }).on("mouseleave", function() {
+          d3Selection.select(this).attr("opacity", 1);
+        });
+      }
+    }
+  }
+  const contentYShift = (fixedTitle ? 0 : titleOffset) + ancestorTrailHeight;
+  const contentG = mainG.append("g").attr("transform", `translate(0, ${contentYShift})`);
+  const displayNames = /* @__PURE__ */ new Map();
+  for (const group of parsed.tagGroups) {
+    displayNames.set(tagAttrKey(group.name), group.name);
+  }
+  const rootNodeIds = new Set(parsed.roots.map((r) => r.id));
+  const colorOff = parsed.options?.["color"] === "off";
+  for (const c of layout.containers) {
+    const cG = contentG.append("g").attr("transform", `translate(${c.x}, ${c.y})`).attr("class", "org-container").attr("data-line-number", String(c.lineNumber));
+    if (activeTagGroup) {
+      const tagKey = tagAttrKey(activeTagGroup);
+      const metaValue = c.tagMetadata[tagKey];
+      if (metaValue) {
+        cG.attr(`data-tag-${tagKey}`, metaValue.toLowerCase());
+      }
+    }
+    if (c.hasChildren) {
+      cG.attr("data-node-toggle", c.nodeId).attr("tabindex", "0").attr("role", "button").attr("aria-expanded", String(!c.hiddenCount)).attr("aria-label", c.label);
+    }
+    if (onClickItem) {
+      cG.style("cursor", "pointer").on("click", () => {
+        onClickItem(c.lineNumber);
+      });
+    }
+    const fill = containerFill(palette, isDark, colorOff ? void 0 : c.color);
+    const stroke = containerStroke(palette, colorOff ? void 0 : c.color);
+    cG.append("rect").attr("x", 0).attr("y", 0).attr("width", c.width).attr("height", c.height).attr("rx", sContainerRadius).attr("fill", fill).attr("stroke", stroke).attr("stroke-opacity", 0.35).attr("stroke-width", sNodeStrokeWidth);
+    cG.append("text").attr("x", c.width / 2).attr("y", sContainerHeaderHeight / 2 + sContainerLabelFontSize / 2 - 2).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-size", sContainerLabelFontSize).attr("font-weight", "bold").text(c.label);
+    const metaEntries = Object.entries(c.metadata);
+    if (metaEntries.length > 0) {
+      const metaDisplayKeys = metaEntries.map(
+        ([k]) => displayNames.get(k) ?? k
+      );
+      const maxKeyWidth = Math.max(
+        ...metaDisplayKeys.map(
+          (k) => measureText(`${k}: `, sContainerMetaFontSize)
+        )
+      );
+      const valueX = 10 + maxKeyWidth;
+      const metaStartY = sContainerHeaderHeight + sContainerMetaFontSize - 2;
+      for (let i = 0; i < metaEntries.length; i++) {
+        const [, value] = metaEntries[i];
+        const displayKey = metaDisplayKeys[i];
+        const rowY = metaStartY + i * sContainerMetaLineHeight;
+        cG.append("text").attr("x", 10).attr("y", rowY).attr("fill", palette.textMuted).attr("font-size", sContainerMetaFontSize).text(`${displayKey}: `);
+        cG.append("text").attr("x", valueX).attr("y", rowY).attr("fill", palette.text).attr("font-size", sContainerMetaFontSize).text(value);
+      }
+    }
+    if (!exportDims && c.hiddenCount && c.hiddenCount > 0) {
+      renderCollapseBar(cG, {
+        width: c.width,
+        height: c.height,
+        barHeight: sCollapseBarHeight,
+        inset: sCollapseBarInset,
+        rx: sContainerRadius,
+        fill: containerStroke(palette, colorOff ? void 0 : c.color),
+        clipId: `clip-${c.nodeId}`,
+        className: "org-collapse-bar"
+      });
+    }
+    if (!exportDims && c.hasChildren && !rootNodeIds.has(c.nodeId)) {
+      const iconSize = 14;
+      const iconPad = 5;
+      const iconX = c.width - iconSize - iconPad;
+      const iconY = iconPad;
+      const focusG = cG.append("g").attr("class", "org-focus-icon").attr("data-focus-node", c.nodeId).attr("data-export-ignore", "true").attr("transform", `translate(${iconX}, ${iconY})`);
+      focusG.append("rect").attr("x", -3).attr("y", -3).attr("width", iconSize + 6).attr("height", iconSize + 6).attr("fill", "transparent");
+      const iconColor = contrastText(
+        fill,
+        palette.textOnFillLight,
+        palette.textOnFillDark
+      );
+      const cx = iconSize / 2;
+      const cy = iconSize / 2;
+      focusG.append("circle").attr("cx", cx).attr("cy", cy).attr("r", iconSize / 2 - 1).attr("fill", "none").attr("stroke", iconColor).attr("stroke-width", 1.5);
+      focusG.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 2).attr("fill", iconColor);
+    }
+  }
+  for (const edge of layout.edges) {
+    if (edge.points.length < 2) continue;
+    const pathParts = [];
+    pathParts.push(`M ${edge.points[0].x} ${edge.points[0].y}`);
+    for (let i = 1; i < edge.points.length; i++) {
+      pathParts.push(`L ${edge.points[i].x} ${edge.points[i].y}`);
+    }
+    contentG.append("path").attr("d", pathParts.join(" ")).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", sEdgeStrokeWidth).attr("class", "org-edge").attr("data-from", edge.sourceId).attr("data-to", edge.targetId);
+  }
+  const containerNodeIds = new Set(layout.containers.map((c) => c.nodeId));
+  for (const node of layout.nodes) {
+    if (containerNodeIds.has(node.id)) continue;
+    const nodeG = contentG.append("g").attr("transform", `translate(${node.x - node.width / 2}, ${node.y})`).attr("class", "org-node").attr("data-line-number", String(node.lineNumber)).attr("data-node-id", node.id);
+    if (activeTagGroup) {
+      const tagKey = tagAttrKey(activeTagGroup);
+      const metaValue = node.tagMetadata[tagKey];
+      if (metaValue) {
+        nodeG.attr(`data-tag-${tagKey}`, metaValue.toLowerCase());
+      }
+    }
+    if (node.hasChildren) {
+      nodeG.attr("data-node-toggle", node.id).attr("tabindex", "0").attr("role", "button").attr("aria-expanded", String(!node.hiddenCount)).attr("aria-label", node.label);
+    }
+    if (onClickItem) {
+      nodeG.style("cursor", "pointer").on("click", () => {
+        onClickItem(node.lineNumber);
+      });
+    }
+    const solid = parsed.options["solid-fill"] === "on";
+    const fill = nodeFill(
+      palette,
+      isDark,
+      colorOff ? void 0 : node.color,
+      solid
+    );
+    const stroke = nodeStroke(palette, colorOff ? void 0 : node.color);
+    const labelColor = contrastText(
+      fill,
+      palette.textOnFillLight,
+      palette.textOnFillDark
+    );
+    const metaEntries = Object.entries(node.metadata);
+    renderNodeCard(nodeG, {
+      width: node.width,
+      height: node.height,
+      rx: sCardRadius,
+      fill,
+      stroke,
+      strokeWidth: sNodeStrokeWidth,
+      ...node.isContainer && { dashed: true },
+      label: node.label,
+      labelColor,
+      labelFontSize: sLabelFontSize,
+      headerHeight: sHeaderHeight,
+      ...metaEntries.length > 0 && {
+        meta: {
+          rows: metaEntries.map(
+            ([k, value]) => [displayNames.get(k) ?? k, value]
+          ),
+          fontSize: sMetaFontSize,
+          lineHeight: sMetaLineHeight,
+          separatorGap: sSeparatorGap,
+          separatorColor: solid ? labelColor : stroke,
+          textColor: labelColor
+        }
+      }
+    });
+    if (!exportDims && node.hiddenCount && node.hiddenCount > 0) {
+      renderCollapseBar(nodeG, {
+        width: node.width,
+        height: node.height,
+        barHeight: sCollapseBarHeight,
+        inset: sCollapseBarInset,
+        rx: sCardRadius,
+        fill: solid ? labelColor : nodeStroke(palette, colorOff ? void 0 : node.color),
+        clipId: `clip-${node.id}`,
+        className: "org-collapse-bar"
+      });
+    }
+    if (!exportDims && node.hasChildren && !rootNodeIds.has(node.id)) {
+      const iconSize = 14;
+      const iconPad = 5;
+      const iconX = node.width - iconSize - iconPad;
+      const iconY = iconPad;
+      const focusG = nodeG.append("g").attr("class", "org-focus-icon").attr("data-focus-node", node.id).attr("data-export-ignore", "true").attr("transform", `translate(${iconX}, ${iconY})`);
+      focusG.append("rect").attr("x", -3).attr("y", -3).attr("width", iconSize + 6).attr("height", iconSize + 6).attr("fill", "transparent");
+      const iconColor = labelColor;
+      const cx = iconSize / 2;
+      const cy = iconSize / 2;
+      focusG.append("circle").attr("cx", cx).attr("cy", cy).attr("r", iconSize / 2 - 1).attr("fill", "none").attr("stroke", iconColor).attr("stroke-width", 1.5);
+      focusG.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 2).attr("fill", iconColor);
+    }
+  }
+  if (hasAncestorTrail) {
+    const rootNode = layout.nodes.find((n) => rootNodeIds.has(n.id));
+    const rootContainer = !rootNode ? layout.containers.find((c) => rootNodeIds.has(c.nodeId)) : null;
+    const rootCenterX = rootNode ? rootNode.x : rootContainer ? rootContainer.x + rootContainer.width / 2 : null;
+    const rootTopY = rootNode ? rootNode.y : rootContainer ? rootContainer.y : null;
+    if (rootCenterX !== null && rootTopY !== null) {
+      const trailBottomY = rootTopY - sAncestorTrailBottomGap;
+      const trailG = contentG.append("g").attr("class", "org-ancestor-trail");
+      const count = ancestorPath.length;
+      const dotPositions = [];
+      for (let i = 0; i < count; i++) {
+        const fromBottom = count - 1 - i;
+        dotPositions.push(trailBottomY - fromBottom * sAncestorRowHeight);
+      }
+      const lineTopY = dotPositions[0];
+      trailG.append("line").attr("x1", rootCenterX).attr("y1", lineTopY).attr("x2", rootCenterX).attr("y2", rootTopY).attr("stroke", palette.textMuted).attr("stroke-width", 1.5).attr("stroke-opacity", 0.4);
+      for (let i = 0; i < count; i++) {
+        const ancestor = ancestorPath[i];
+        const dotY = dotPositions[i];
+        const resolvedColor = ancestor.color ?? resolveTagColor(
+          ancestor.metadata,
+          [...parsed.tagGroups],
+          activeTagGroup ?? null,
+          ancestor.isContainer
+        );
+        const dotColor = resolvedColor ?? palette.textMuted;
+        const rowG = trailG.append("g").attr("class", "org-ancestor-node").attr("data-focus-ancestor", ancestor.id).style("cursor", "pointer").attr("transform", `translate(${rootCenterX}, ${dotY})`);
+        rowG.append("rect").attr("x", -sAncestorDotR - 2).attr("y", -sAncestorDotR - 2).attr("width", 120).attr("height", sAncestorDotR * 2 + 4).attr("fill", "transparent");
+        rowG.append("circle").attr("cx", 0).attr("cy", 0).attr("r", sAncestorDotR).attr("fill", dotColor);
+        rowG.append("text").attr("x", sAncestorDotR + 6).attr("y", sAncestorLabelFontSize * 0.35).attr("fill", palette.textMuted).attr("font-size", sAncestorLabelFontSize).text(ancestor.label);
+        rowG.on("mouseenter", function() {
+          d3Selection.select(this).select("circle").attr("r", sAncestorDotR + 1);
+          d3Selection.select(this).select("text").attr("fill", palette.text);
+        }).on("mouseleave", function() {
+          d3Selection.select(this).select("circle").attr("r", sAncestorDotR);
+          d3Selection.select(this).select("text").attr("fill", palette.textMuted);
+        });
+      }
+    }
+  }
+  if (fixedLegend || legendOnly || exportDims && hasLegend) {
+    const groups = layout.legend.map((g) => ({
+      name: g.name,
+      entries: g.entries.map((e) => ({ value: e.value, color: e.color }))
+    }));
+    const eyeAddonWidth = fixedLegend ? LEGEND_EYE_SIZE + LEGEND_EYE_GAP : 0;
+    const legendParentBase = fixedLegend ? svg.append("g").attr("class", "org-legend-fixed").attr("transform", `translate(0, ${sDiagramPadding + titleReserve})`) : contentG.append("g");
+    let legendHandle;
+    if (legendOnly) {
+      for (const lg of layout.legend) {
+        const singleConfig = {
+          groups: [
+            {
+              name: lg.name,
+              entries: lg.entries.map((e) => ({
+                value: e.value,
+                color: e.color
+              }))
+            }
+          ],
+          position: { placement: "top-center", titleRelation: "below-title" },
+          mode: exportMode ? "export" : "preview"
+        };
+        const groupG = legendParentBase.append("g").attr("transform", `translate(${lg.x}, ${lg.y})`);
+        renderIntegratedLegend(groupG, {
+          ...singleConfig,
+          palette,
+          isDark,
+          width: lg.width,
+          activeGroup: lg.name
+        });
+        groupG.selectAll("[data-legend-group]").classed("org-legend-group", true);
+      }
+      legendHandle = null;
+    } else {
+      const legendConfig = {
+        groups,
+        position: { placement: "top-center", titleRelation: "below-title" },
+        mode: exportMode ? "export" : "preview",
+        capsulePillAddonWidth: eyeAddonWidth
+      };
+      legendHandle = renderIntegratedLegend(legendParentBase, {
+        ...legendConfig,
+        palette,
+        isDark,
+        width: fixedLegend ? width : layout.width,
+        activeGroup: activeTagGroup ?? null
+      });
+      legendParentBase.selectAll("[data-legend-group]").classed("org-legend-group", true);
+    }
+    if (fixedLegend && legendHandle) {
+      const computedLayout = legendHandle.getLayout();
+      if (computedLayout.activeCapsule?.addonX != null) {
+        const capsule = computedLayout.activeCapsule;
+        const groupKey = tagAttrKey(capsule.groupName);
+        const isHidden = hiddenAttributes?.has(groupKey) ?? false;
+        const activeGroupEl = legendParentBase.select(
+          `[data-legend-group="${groupKey}"]`
+        );
+        if (!activeGroupEl.empty()) {
+          const eyeX = capsule.addonX;
+          const eyeY = (LEGEND_HEIGHT - LEGEND_EYE_SIZE) / 2;
+          const hitPad = 6;
+          const eyeG = activeGroupEl.append("g").attr("class", "org-legend-eye").attr("data-legend-visibility", groupKey).style("cursor", "pointer").attr("opacity", isHidden ? 0.4 : 0.7);
+          eyeG.append("rect").attr("x", eyeX - hitPad).attr("y", eyeY - hitPad).attr("width", LEGEND_EYE_SIZE + hitPad * 2).attr("height", LEGEND_EYE_SIZE + hitPad * 2).attr("fill", "transparent").attr("pointer-events", "all");
+          eyeG.append("path").attr("d", isHidden ? EYE_CLOSED_PATH : EYE_OPEN_PATH).attr("transform", `translate(${eyeX}, ${eyeY})`).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1.2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+        }
+      }
+    }
+  }
+}
+function renderOrgForExport(content, theme, palette) {
+  const parsed = parseOrg(content, palette);
+  if (parsed.error) return "";
+  const hideOption = parsed.options?.["hide"];
+  const exportHidden = hideOption ? new Set(hideOption.split(",").map((s) => s.trim().toLowerCase())) : void 0;
+  const layout = layoutOrg(parsed, void 0, void 0, exportHidden);
+  const isDark = theme === "dark";
+  const titleOffset = parsed.title && parsed.options["no-title"] !== "on" ? TITLE_HEIGHT : 0;
+  const exportWidth = layout.width + DIAGRAM_PADDING * 2;
+  const exportHeight = layout.height + DIAGRAM_PADDING * 2 + titleOffset;
+  return runInExportContainer(exportWidth, exportHeight, (container) => {
+    renderOrg(container, parsed, layout, palette, isDark, void 0, {
+      width: exportWidth,
+      height: exportHeight
+    });
+    return extractExportSvg(container, theme);
+  });
+}
+
+export {
+  renderOrg,
+  renderOrgForExport
+};
+//# sourceMappingURL=chunk-DU7W62N5.js.map