@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-IH6ZMVQ5.js

@@ -0,0 +1,3950 @@
+import {
+  computeQuadrantPointLabels
+} from "./chunk-PBAHEPLQ.js";
+import {
+  renderDataChartD3
+} from "./chunk-OJR3MQYV.js";
+import {
+  renderTimeline
+} from "./chunk-UWN33VNX.js";
+import {
+  EXPORT_HEIGHT,
+  EXPORT_WIDTH,
+  createExportContainer,
+  createTooltip,
+  finalizeSvgExport,
+  hideTooltip,
+  initD3Chart,
+  renderChartTitle,
+  resolveExportPalette,
+  showTooltip
+} from "./chunk-U6EQI3U6.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  measureText,
+  wrapTextToWidth
+} from "./chunk-WCT3NYCV.js";
+import {
+  getRenderCategory,
+  parseArc,
+  parseDgmo,
+  parseQuadrant,
+  parseSlope,
+  parseTimeline,
+  parseVenn,
+  parseVisualization,
+  parseWordcloud
+} from "./chunk-6FZYCKXB.js";
+import {
+  getPalette
+} from "./chunk-R3XI2VC7.js";
+import {
+  getSeriesColors,
+  mix,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveActiveTagGroup,
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-5WRI5ZAA.js";
+
+// node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js
+var require_lz_string = __commonJS({
+  "node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js"(exports, module) {
+    "use strict";
+    var LZString = (function() {
+      var f = String.fromCharCode;
+      var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+      var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
+      var baseReverseDic = {};
+      function getBaseValue(alphabet, character) {
+        if (!baseReverseDic[alphabet]) {
+          baseReverseDic[alphabet] = {};
+          for (var i = 0; i < alphabet.length; i++) {
+            baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+          }
+        }
+        return baseReverseDic[alphabet][character];
+      }
+      var LZString2 = {
+        compressToBase64: function(input) {
+          if (input == null) return "";
+          var res = LZString2._compress(input, 6, function(a) {
+            return keyStrBase64.charAt(a);
+          });
+          switch (res.length % 4) {
+            // To produce valid Base64
+            default:
+            // When could this happen ?
+            case 0:
+              return res;
+            case 1:
+              return res + "===";
+            case 2:
+              return res + "==";
+            case 3:
+              return res + "=";
+          }
+        },
+        decompressFromBase64: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrBase64, input.charAt(index));
+          });
+        },
+        compressToUTF16: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 15, function(a) {
+            return f(a + 32);
+          }) + " ";
+        },
+        decompressFromUTF16: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 16384, function(index) {
+            return compressed.charCodeAt(index) - 32;
+          });
+        },
+        //compress into uint8array (UCS-2 big endian format)
+        compressToUint8Array: function(uncompressed) {
+          var compressed = LZString2.compress(uncompressed);
+          var buf = new Uint8Array(compressed.length * 2);
+          for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
+            var current_value = compressed.charCodeAt(i);
+            buf[i * 2] = current_value >>> 8;
+            buf[i * 2 + 1] = current_value % 256;
+          }
+          return buf;
+        },
+        //decompress from uint8array (UCS-2 big endian format)
+        decompressFromUint8Array: function(compressed) {
+          if (compressed === null || compressed === void 0) {
+            return LZString2.decompress(compressed);
+          } else {
+            var buf = new Array(compressed.length / 2);
+            for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) {
+              buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+            }
+            var result = [];
+            buf.forEach(function(c) {
+              result.push(f(c));
+            });
+            return LZString2.decompress(result.join(""));
+          }
+        },
+        //compress into a string that is already URI encoded
+        compressToEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 6, function(a) {
+            return keyStrUriSafe.charAt(a);
+          });
+        },
+        //decompress from an output of compressToEncodedURIComponent
+        decompressFromEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          input = input.replace(/ /g, "+");
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrUriSafe, input.charAt(index));
+          });
+        },
+        compress: function(uncompressed) {
+          return LZString2._compress(uncompressed, 16, function(a) {
+            return f(a);
+          });
+        },
+        _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
+          if (uncompressed == null) return "";
+          var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
+          for (ii = 0; ii < uncompressed.length; ii += 1) {
+            context_c = uncompressed.charAt(ii);
+            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+              context_dictionary[context_c] = context_dictSize++;
+              context_dictionaryToCreate[context_c] = true;
+            }
+            context_wc = context_w + context_c;
+            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+              context_w = context_wc;
+            } else {
+              if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+                if (context_w.charCodeAt(0) < 256) {
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 8; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                } else {
+                  value = 1;
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1 | value;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = 0;
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 16; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                }
+                context_enlargeIn--;
+                if (context_enlargeIn == 0) {
+                  context_enlargeIn = Math.pow(2, context_numBits);
+                  context_numBits++;
+                }
+                delete context_dictionaryToCreate[context_w];
+              } else {
+                value = context_dictionary[context_w];
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              context_dictionary[context_wc] = context_dictSize++;
+              context_w = String(context_c);
+            }
+          }
+          if (context_w !== "") {
+            if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+              if (context_w.charCodeAt(0) < 256) {
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 8; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              } else {
+                value = 1;
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = 0;
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 16; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              delete context_dictionaryToCreate[context_w];
+            } else {
+              value = context_dictionary[context_w];
+              for (i = 0; i < context_numBits; i++) {
+                context_data_val = context_data_val << 1 | value & 1;
+                if (context_data_position == bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = value >> 1;
+              }
+            }
+            context_enlargeIn--;
+            if (context_enlargeIn == 0) {
+              context_enlargeIn = Math.pow(2, context_numBits);
+              context_numBits++;
+            }
+          }
+          value = 2;
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = context_data_val << 1 | value & 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+          while (true) {
+            context_data_val = context_data_val << 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data.push(getCharFromInt(context_data_val));
+              break;
+            } else context_data_position++;
+          }
+          return context_data.join("");
+        },
+        decompress: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 32768, function(index) {
+            return compressed.charCodeAt(index);
+          });
+        },
+        _decompress: function(length, resetValue, getNextValue) {
+          var dictionary = [], next, enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i, w, bits, resb, maxpower, power, c, data = { val: getNextValue(0), position: resetValue, index: 1 };
+          for (i = 0; i < 3; i += 1) {
+            dictionary[i] = i;
+          }
+          bits = 0;
+          maxpower = Math.pow(2, 2);
+          power = 1;
+          while (power != maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = resetValue;
+              data.val = getNextValue(data.index++);
+            }
+            bits |= (resb > 0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+          switch (next = bits) {
+            case 0:
+              bits = 0;
+              maxpower = Math.pow(2, 8);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 1:
+              bits = 0;
+              maxpower = Math.pow(2, 16);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 2:
+              return "";
+          }
+          dictionary[3] = c;
+          w = c;
+          result.push(c);
+          while (true) {
+            if (data.index > length) {
+              return "";
+            }
+            bits = 0;
+            maxpower = Math.pow(2, numBits);
+            power = 1;
+            while (power != maxpower) {
+              resb = data.val & data.position;
+              data.position >>= 1;
+              if (data.position == 0) {
+                data.position = resetValue;
+                data.val = getNextValue(data.index++);
+              }
+              bits |= (resb > 0 ? 1 : 0) * power;
+              power <<= 1;
+            }
+            switch (c = bits) {
+              case 0:
+                bits = 0;
+                maxpower = Math.pow(2, 8);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 1:
+                bits = 0;
+                maxpower = Math.pow(2, 16);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 2:
+                return result.join("");
+            }
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+            if (dictionary[c]) {
+              entry = dictionary[c];
+            } else {
+              if (c === dictSize) {
+                entry = w + w.charAt(0);
+              } else {
+                return null;
+              }
+            }
+            result.push(entry);
+            dictionary[dictSize++] = w + entry.charAt(0);
+            enlargeIn--;
+            w = entry;
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+          }
+        }
+      };
+      return LZString2;
+    })();
+    if (typeof define === "function" && define.amd) {
+      define(function() {
+        return LZString;
+      });
+    } else if (typeof module !== "undefined" && module != null) {
+      module.exports = LZString;
+    } else if (typeof angular !== "undefined" && angular != null) {
+      angular.module("LZString", []).factory("LZString", function() {
+        return LZString;
+      });
+    }
+  }
+});
+
+// src/slope/renderer.ts
+import * as d3Scale from "d3-scale";
+import * as d3Shape from "d3-shape";
+import * as d3Array from "d3-array";
+function resolveVerticalCollisions(items, minGap, maxY) {
+  if (items.length === 0) return [];
+  const sorted = items.map((it, i) => ({ ...it, idx: i })).sort((a, b) => a.naturalY - b.naturalY);
+  const adjustedY = new Array(items.length);
+  let prevBottom = -Infinity;
+  for (const item of sorted) {
+    const halfH = item.height / 2;
+    let top = Math.max(item.naturalY - halfH, prevBottom + minGap);
+    if (maxY !== void 0) {
+      top = Math.min(top, maxY - item.height);
+    }
+    adjustedY[item.idx] = top + halfH;
+    prevBottom = top + item.height;
+  }
+  return adjustedY;
+}
+var SLOPE_MARGIN = { top: 80, bottom: 40, left: 80 };
+var SLOPE_LABEL_FONT_SIZE = 14;
+function renderSlopeChart(container, parsed, palette, isDark, onClickItem, exportDims) {
+  const { periods, data } = parsed;
+  const title = parsed.noTitle ? null : parsed.title;
+  if (data.length === 0 || periods.length < 2) return;
+  const init = initD3Chart(container, palette, exportDims);
+  if (!init) return;
+  const { svg, width, height, textColor, mutedColor, bgColor, colors } = init;
+  const idealWidth = SLOPE_MARGIN.left + periods.length * 100 + 150;
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  const sMarginTop = ctx.aesthetic(SLOPE_MARGIN.top);
+  const sMarginBottom = ctx.aesthetic(SLOPE_MARGIN.bottom);
+  const sMarginLeft = ctx.aesthetic(SLOPE_MARGIN.left);
+  const sLabelFontSize = ctx.text(SLOPE_LABEL_FONT_SIZE);
+  const sPeriodFont = ctx.text(18);
+  const sValueFont = ctx.text(16);
+  const sPeriodHeaderY = ctx.structural(15);
+  const sDash = `${ctx.structural(4)},${ctx.structural(4)}`;
+  const sLineStroke = ctx.structural(2.5);
+  const sHitWidth = ctx.structural(14);
+  const sPointR = ctx.structural(4);
+  const sPointStroke = ctx.structural(1.5);
+  const sValueLabelXOff = ctx.structural(10);
+  const sLabelGap = ctx.structural(10);
+  svg.attr("preserveAspectRatio", "xMidYMin meet");
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const maxLabelText = data.reduce((longest, item) => {
+    const text = `${item.values[item.values.length - 1]} \u2014 ${item.label}`;
+    return text.length > longest.length ? text : longest;
+  }, "");
+  const estimatedLabelWidth = measureText(maxLabelText, sLabelFontSize);
+  const maxRightMargin = Math.floor(width * 0.35);
+  const rightMargin = Math.min(
+    Math.max(estimatedLabelWidth + ctx.aesthetic(30), ctx.aesthetic(120)),
+    maxRightMargin
+  );
+  const innerWidth = width - sMarginLeft - rightMargin;
+  const innerHeight = height - sMarginTop - sMarginBottom;
+  const allValues = data.flatMap((d) => d.values);
+  const [minVal, maxVal] = d3Array.extent(allValues);
+  const valuePadding = (maxVal - minVal) * 0.1 || 1;
+  const yScale = d3Scale.scaleLinear().domain([minVal - valuePadding, maxVal + valuePadding]).range([innerHeight, 0]);
+  const xScale = d3Scale.scalePoint().domain(periods).range([0, innerWidth]).padding(0);
+  const g = svg.append("g").attr("transform", `translate(${sMarginLeft},${sMarginTop})`);
+  const tooltip = createTooltip(container, palette, isDark);
+  renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem
+  );
+  for (const period of periods) {
+    const x = xScale(period);
+    g.append("text").attr("x", x).attr("y", -sPeriodHeaderY).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sPeriodFont}px`).attr("font-weight", "600").text(period);
+    g.append("line").attr("x1", x).attr("y1", 0).attr("x2", x).attr("y2", innerHeight).attr("stroke", mutedColor).attr("stroke-width", 1).attr("stroke-dasharray", sDash);
+  }
+  const lineGen = d3Shape.line().x((_d, i) => xScale(periods[i])).y((d) => yScale(d));
+  const seriesInfo = data.map((item, idx) => {
+    const color = item.color ?? colors[idx % colors.length];
+    const firstVal = item.values[0];
+    const lastVal = item.values[item.values.length - 1];
+    const absChange = lastVal - firstVal;
+    const pctChange = firstVal !== 0 ? absChange / firstVal * 100 : null;
+    const sign = absChange > 0 ? "+" : "";
+    const tipLines = [`${sign}${parseFloat(absChange.toFixed(2))}`];
+    if (pctChange !== null) tipLines.push(`${sign}${pctChange.toFixed(1)}%`);
+    const tipHtml = tipLines.join("<br>");
+    const lastX = xScale(periods[periods.length - 1]);
+    const labelText = `${lastVal} \u2014 ${item.label}`;
+    const availableWidth = rightMargin - ctx.aesthetic(15);
+    let labelLineCount = 1;
+    let wrappedLines = null;
+    if (measureText(labelText, sLabelFontSize) > availableWidth) {
+      const lines = wrapTextToWidth(labelText, sLabelFontSize, availableWidth);
+      labelLineCount = lines.length;
+      wrappedLines = lines;
+    }
+    const lineHeight = sLabelFontSize * 1.2;
+    const labelHeight = labelLineCount === 1 ? sLabelFontSize : labelLineCount * lineHeight;
+    return {
+      item,
+      idx,
+      color,
+      firstVal,
+      lastVal,
+      tipHtml,
+      lastX,
+      labelText,
+      wrappedLines,
+      labelHeight
+    };
+  });
+  const leftLabelHeight = sValueFont * 1.25;
+  const leftLabelCollisions = /* @__PURE__ */ new Map();
+  for (let pi = 0; pi < periods.length - 1; pi++) {
+    const entries = data.map((item) => ({
+      // pi is in-bounds by loop guard against periods.length, and each data row has periods.length values.
+      naturalY: yScale(item.values[pi]),
+      height: leftLabelHeight
+    }));
+    leftLabelCollisions.set(
+      pi,
+      resolveVerticalCollisions(entries, 4, innerHeight)
+    );
+  }
+  const rightEntries = seriesInfo.map((si) => ({
+    naturalY: yScale(si.lastVal),
+    height: Math.max(si.labelHeight, sLabelFontSize * 1.4)
+  }));
+  const rightAdjustedY = resolveVerticalCollisions(
+    rightEntries,
+    4,
+    innerHeight
+  );
+  data.forEach((item, idx) => {
+    const si = seriesInfo[idx];
+    const color = si.color;
+    const seriesG = g.append("g").attr("class", "slope-series").attr("data-line-number", String(item.lineNumber));
+    seriesG.append("path").datum(item.values).attr("fill", "none").attr("stroke", color).attr("stroke-width", sLineStroke).attr("d", lineGen);
+    seriesG.append("path").datum(item.values).attr("fill", "none").attr("stroke", "transparent").attr("stroke-width", sHitWidth).attr("d", lineGen).style("cursor", onClickItem ? "pointer" : "default").on(
+      "mouseenter",
+      (event) => showTooltip(tooltip, si.tipHtml, event)
+    ).on(
+      "mousemove",
+      (event) => showTooltip(tooltip, si.tipHtml, event)
+    ).on("mouseleave", () => hideTooltip(tooltip)).on("click", () => {
+      if (onClickItem && item.lineNumber) onClickItem(item.lineNumber);
+    });
+    item.values.forEach((val, i) => {
+      const x = xScale(periods[i]);
+      const y = yScale(val);
+      seriesG.append("circle").attr("cx", x).attr("cy", y).attr("r", sPointR).attr("fill", color).attr("stroke", bgColor).attr("stroke-width", sPointStroke).style("cursor", onClickItem ? "pointer" : "default").on(
+        "mouseenter",
+        (event) => showTooltip(tooltip, si.tipHtml, event)
+      ).on(
+        "mousemove",
+        (event) => showTooltip(tooltip, si.tipHtml, event)
+      ).on("mouseleave", () => hideTooltip(tooltip)).on("click", () => {
+        if (onClickItem && item.lineNumber) onClickItem(item.lineNumber);
+      });
+      const isFirst = i === 0;
+      const isLast = i === periods.length - 1;
+      if (!isLast) {
+        const adjustedY = leftLabelCollisions.get(i)[idx];
+        seriesG.append("text").attr("x", isFirst ? x - sValueLabelXOff : x).attr("y", adjustedY).attr("dy", "0.35em").attr("text-anchor", isFirst ? "end" : "middle").attr("fill", color).attr("font-size", `${sValueFont}px`).text(val.toString());
+      }
+    });
+    const adjustedLastY = rightAdjustedY[idx];
+    const labelEl = seriesG.append("text").attr("x", si.lastX + sLabelGap).attr("y", adjustedLastY).attr("text-anchor", "start").attr("fill", color).attr("font-size", `${sLabelFontSize}px`).attr("font-weight", "500");
+    if (!si.wrappedLines) {
+      labelEl.attr("dy", "0.35em").text(si.labelText);
+    } else {
+      const lineHeight = sLabelFontSize * 1.2;
+      const totalHeight = (si.wrappedLines.length - 1) * lineHeight;
+      const startDy = -totalHeight / 2;
+      si.wrappedLines.forEach((line2, li) => {
+        labelEl.append("tspan").attr("x", si.lastX + sLabelGap).attr(
+          "dy",
+          li === 0 ? `${startDy + sLabelFontSize * 0.35}px` : `${lineHeight}px`
+        ).text(line2);
+      });
+    }
+  });
+}
+
+// src/arc/renderer.ts
+import * as d3Scale2 from "d3-scale";
+import * as d3Selection from "d3-selection";
+import * as d3Array2 from "d3-array";
+function orderArcNodes(links, order, groups) {
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (const link of links) {
+    nodeSet.add(link.source);
+    nodeSet.add(link.target);
+  }
+  const allNodes = Array.from(nodeSet);
+  if (order === "name") {
+    return allNodes.slice().sort((a, b) => a.localeCompare(b));
+  }
+  if (order === "degree") {
+    const degree = /* @__PURE__ */ new Map();
+    for (const node of allNodes) degree.set(node, 0);
+    for (const link of links) {
+      degree.set(link.source, degree.get(link.source) + link.value);
+      degree.set(link.target, degree.get(link.target) + link.value);
+    }
+    return allNodes.slice().sort((a, b) => {
+      const diff = degree.get(b) - degree.get(a);
+      return diff !== 0 ? diff : a.localeCompare(b);
+    });
+  }
+  if (order === "group") {
+    if (groups.length > 0) {
+      const ordered = [];
+      const placed = /* @__PURE__ */ new Set();
+      for (const group of groups) {
+        for (const node of group.nodes) {
+          if (!placed.has(node)) {
+            ordered.push(node);
+            placed.add(node);
+          }
+        }
+      }
+      for (const node of allNodes) {
+        if (!placed.has(node)) {
+          ordered.push(node);
+          placed.add(node);
+        }
+      }
+      return ordered;
+    }
+    const adj = /* @__PURE__ */ new Map();
+    for (const node of allNodes) adj.set(node, /* @__PURE__ */ new Set());
+    for (const link of links) {
+      adj.get(link.source).add(link.target);
+      adj.get(link.target).add(link.source);
+    }
+    const degree = /* @__PURE__ */ new Map();
+    for (const node of allNodes) degree.set(node, 0);
+    for (const link of links) {
+      degree.set(link.source, degree.get(link.source) + link.value);
+      degree.set(link.target, degree.get(link.target) + link.value);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const components = [];
+    const remaining = new Set(allNodes);
+    while (remaining.size > 0) {
+      let root = "";
+      let maxDeg = -1;
+      for (const node of remaining) {
+        if (degree.get(node) > maxDeg) {
+          maxDeg = degree.get(node);
+          root = node;
+        }
+      }
+      const component = [];
+      const queue = [root];
+      visited.add(root);
+      remaining.delete(root);
+      while (queue.length > 0) {
+        const curr = queue.shift();
+        component.push(curr);
+        for (const neighbor of adj.get(curr)) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            remaining.delete(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      components.push(component);
+    }
+    components.sort((a, b) => b.length - a.length);
+    return components.flat();
+  }
+  return allNodes;
+}
+var ARC_MARGIN_TOP = 60;
+var ARC_MARGIN_RIGHT = 40;
+var ARC_MARGIN_BOTTOM = 60;
+var ARC_MARGIN_LEFT = 40;
+var ARC_MARGIN_LEFT_VERTICAL = 120;
+var ARC_NODE_RADIUS = 5;
+var ARC_NODE_STROKE_WIDTH = 1.5;
+var ARC_NODE_LABEL_FONT = 11;
+var ARC_GROUP_LABEL_FONT = 12;
+var ARC_BAND_HALF_W = 60;
+var ARC_BAND_HALF_H = 40;
+var ARC_BAND_RADIUS = 4;
+var ARC_BAND_LABEL_X_OFFSET = 6;
+var ARC_BAND_LABEL_Y_OFFSET = 14;
+var ARC_BAND_LABEL_BOTTOM_OFFSET = 4;
+var ARC_NODE_LABEL_X_OFFSET = 14;
+var ARC_NODE_LABEL_Y_OFFSET = 20;
+var ARC_STROKE_MIN = 1.5;
+var ARC_STROKE_MAX = 6;
+var ARC_BASELINE_STROKE_WIDTH = 1;
+function renderArcDiagram(container, parsed, palette, _isDark, onClickItem, exportDims) {
+  const { links, orientation, arcOrder, arcNodeGroups } = parsed;
+  const title = parsed.noTitle ? null : parsed.title;
+  if (links.length === 0) return;
+  const init = initD3Chart(container, palette, exportDims);
+  if (!init) return;
+  const { svg, width, height, textColor, mutedColor, bgColor, colors } = init;
+  const isVertical = orientation === "vertical";
+  const nodes = orderArcNodes(links, arcOrder, arcNodeGroups);
+  const idealWidth = isVertical ? ARC_MARGIN_LEFT_VERTICAL + ARC_MARGIN_RIGHT + ARC_BAND_HALF_W * 2 + 100 : nodes.length * 20 + ARC_MARGIN_LEFT + ARC_MARGIN_RIGHT;
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  const sMarginTop = ctx.aesthetic(ARC_MARGIN_TOP);
+  const sMarginRight = ctx.aesthetic(ARC_MARGIN_RIGHT);
+  const sMarginBottom = ctx.aesthetic(ARC_MARGIN_BOTTOM);
+  const sMarginLeft = isVertical ? ctx.aesthetic(ARC_MARGIN_LEFT_VERTICAL) : ctx.aesthetic(ARC_MARGIN_LEFT);
+  const sNodeRadius = ctx.structural(ARC_NODE_RADIUS);
+  const sNodeStrokeWidth = ctx.structural(ARC_NODE_STROKE_WIDTH);
+  const sNodeLabelFont = ctx.text(ARC_NODE_LABEL_FONT);
+  const sGroupLabelFont = ctx.text(ARC_GROUP_LABEL_FONT);
+  const sBandHalfW = ctx.aesthetic(ARC_BAND_HALF_W);
+  const sBandHalfH = ctx.aesthetic(ARC_BAND_HALF_H);
+  const sBandRadius = ctx.structural(ARC_BAND_RADIUS);
+  const sBandLabelXOffset = ctx.structural(ARC_BAND_LABEL_X_OFFSET);
+  const sBandLabelYOffset = ctx.structural(ARC_BAND_LABEL_Y_OFFSET);
+  const sBandLabelBottomOffset = ctx.structural(ARC_BAND_LABEL_BOTTOM_OFFSET);
+  const sNodeLabelXOffset = ctx.structural(ARC_NODE_LABEL_X_OFFSET);
+  const sNodeLabelYOffset = ctx.structural(ARC_NODE_LABEL_Y_OFFSET);
+  const sStrokeMin = ctx.structural(ARC_STROKE_MIN);
+  const sStrokeMax = ctx.structural(ARC_STROKE_MAX);
+  const sBaselineDash = `${ctx.structural(4)},${ctx.structural(4)}`;
+  const sBaselineStrokeWidth = ctx.structural(ARC_BASELINE_STROKE_WIDTH);
+  svg.attr("preserveAspectRatio", "xMidYMin meet");
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const margin = {
+    top: sMarginTop,
+    right: sMarginRight,
+    bottom: sMarginBottom,
+    left: sMarginLeft
+  };
+  const innerWidth = width - margin.left - margin.right;
+  const innerHeight = height - margin.top - margin.bottom;
+  const nodeColorMap = /* @__PURE__ */ new Map();
+  for (const group of arcNodeGroups) {
+    if (group.color) {
+      for (const node of group.nodes) {
+        if (!nodeColorMap.has(node)) {
+          nodeColorMap.set(node, group.color);
+        }
+      }
+    }
+  }
+  const groupNodeSets = /* @__PURE__ */ new Map();
+  for (const group of arcNodeGroups) {
+    groupNodeSets.set(group.name, new Set(group.nodes));
+  }
+  const values = links.map((l) => l.value);
+  const [minVal, maxVal] = d3Array2.extent(values);
+  const strokeScale = d3Scale2.scaleLinear().domain([minVal, maxVal]).range([sStrokeMin, sStrokeMax]);
+  const g = svg.append("g").attr("transform", `translate(${margin.left},${margin.top})`);
+  renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem
+  );
+  const neighbors = /* @__PURE__ */ new Map();
+  for (const node of nodes) neighbors.set(node, /* @__PURE__ */ new Set());
+  for (const link of links) {
+    neighbors.get(link.source).add(link.target);
+    neighbors.get(link.target).add(link.source);
+  }
+  const FADE_OPACITY = 0.1;
+  function handleMouseEnter(hovered) {
+    const connected = neighbors.get(hovered);
+    g.selectAll(".arc-link").each(function() {
+      const el = d3Selection.select(this);
+      const src = el.attr("data-source");
+      const tgt = el.attr("data-target");
+      const isRelated = src === hovered || tgt === hovered;
+      el.attr("stroke-opacity", isRelated ? 0.85 : FADE_OPACITY);
+    });
+    g.selectAll(".arc-node").each(function() {
+      const el = d3Selection.select(this);
+      const name = el.attr("data-node");
+      const isRelated = name === hovered || connected.has(name);
+      el.attr("opacity", isRelated ? 1 : FADE_OPACITY);
+    });
+  }
+  function handleMouseLeave() {
+    g.selectAll(".arc-link").attr(
+      "stroke-opacity",
+      0.7
+    );
+    g.selectAll(".arc-node").attr("opacity", 1);
+    g.selectAll(".arc-group-band").attr(
+      "fill-opacity",
+      0.06
+    );
+    g.selectAll(".arc-group-label").attr(
+      "fill-opacity",
+      0.5
+    );
+  }
+  function handleGroupEnter(groupName) {
+    const members = groupNodeSets.get(groupName);
+    if (!members) return;
+    g.selectAll(".arc-link").each(function() {
+      const el = d3Selection.select(this);
+      const isRelated = members.has(el.attr("data-source")) || members.has(el.attr("data-target"));
+      el.attr("stroke-opacity", isRelated ? 0.85 : FADE_OPACITY);
+    });
+    g.selectAll(".arc-node").each(function() {
+      const el = d3Selection.select(this);
+      el.attr("opacity", members.has(el.attr("data-node")) ? 1 : FADE_OPACITY);
+    });
+    g.selectAll(".arc-group-band").each(function() {
+      const el = d3Selection.select(this);
+      el.attr(
+        "fill-opacity",
+        el.attr("data-group") === groupName ? 0.18 : 0.03
+      );
+    });
+    g.selectAll(".arc-group-label").each(function() {
+      const el = d3Selection.select(this);
+      el.attr("fill-opacity", el.attr("data-group") === groupName ? 1 : 0.2);
+    });
+  }
+  if (isVertical) {
+    const yScale = d3Scale2.scalePoint().domain(nodes).range([0, innerHeight]).padding(0.5);
+    const baseX = innerWidth / 2;
+    if (arcNodeGroups.length > 0) {
+      const bandPad = (yScale.step?.() ?? 20) * 0.4;
+      for (const group of arcNodeGroups) {
+        const groupNodes = group.nodes.filter((n) => nodes.includes(n));
+        if (groupNodes.length === 0) continue;
+        const positions = groupNodes.map((n) => yScale(n));
+        const minY = Math.min(...positions) - bandPad;
+        const maxY = Math.max(...positions) + bandPad;
+        g.append("rect").attr("class", "arc-group-band").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).attr("x", baseX - sBandHalfW).attr("y", minY).attr("width", sBandHalfW * 2).attr("height", maxY - minY).attr("rx", sBandRadius).attr("fill", textColor).attr("fill-opacity", 0.06).style("cursor", "pointer").on("mouseenter", () => handleGroupEnter(group.name)).on("mouseleave", handleMouseLeave).on("click", () => {
+          if (onClickItem) onClickItem(group.lineNumber);
+        });
+        g.append("text").attr("class", "arc-group-label").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).attr("x", baseX - sBandHalfW + sBandLabelXOffset).attr("y", minY + sBandLabelYOffset).attr("fill", textColor).attr("font-size", `${sGroupLabelFont}px`).attr("font-weight", "600").attr("fill-opacity", 0.5).style("cursor", onClickItem ? "pointer" : "default").text(group.name).on("mouseenter", () => handleGroupEnter(group.name)).on("mouseleave", handleMouseLeave).on("click", () => {
+          if (onClickItem) onClickItem(group.lineNumber);
+        });
+      }
+    }
+    g.append("line").attr("x1", baseX).attr("y1", 0).attr("x2", baseX).attr("y2", innerHeight).attr("stroke", mutedColor).attr("stroke-width", sBaselineStrokeWidth).attr("stroke-dasharray", sBaselineDash);
+    links.forEach((link, idx) => {
+      const y1 = yScale(link.source);
+      const y2 = yScale(link.target);
+      const midY = (y1 + y2) / 2;
+      const distance = Math.abs(y2 - y1);
+      const controlX = baseX + distance * 0.4;
+      const color = link.color ?? colors[idx % colors.length];
+      g.append("path").attr("class", "arc-link").attr("data-source", link.source).attr("data-target", link.target).attr("data-line-number", String(link.lineNumber)).attr("d", `M ${baseX},${y1} Q ${controlX},${midY} ${baseX},${y2}`).attr("fill", "none").attr("stroke", color).attr("stroke-width", strokeScale(link.value)).attr("stroke-opacity", 0.7).style("cursor", onClickItem ? "pointer" : "default").on("click", () => {
+        if (onClickItem && link.lineNumber) onClickItem(link.lineNumber);
+      });
+    });
+    for (const node of nodes) {
+      const y = yScale(node);
+      const nodeColor = nodeColorMap.get(node) ?? textColor;
+      const nodeLink = links.find(
+        (l) => l.source === node || l.target === node
+      );
+      const nodeG = g.append("g").attr("class", "arc-node").attr("data-node", node).attr(
+        "data-line-number",
+        nodeLink?.lineNumber ? String(nodeLink.lineNumber) : null
+      ).style("cursor", "pointer").on("mouseenter", () => handleMouseEnter(node)).on("mouseleave", handleMouseLeave).on("click", () => {
+        if (onClickItem && nodeLink?.lineNumber)
+          onClickItem(nodeLink.lineNumber);
+      });
+      nodeG.append("circle").attr("cx", baseX).attr("cy", y).attr("r", sNodeRadius).attr("fill", nodeColor).attr("stroke", bgColor).attr("stroke-width", sNodeStrokeWidth);
+      nodeG.append("text").attr("x", baseX - sNodeLabelXOffset).attr("y", y).attr("dy", "0.35em").attr("text-anchor", "end").attr("fill", textColor).attr("font-size", `${sNodeLabelFont}px`).text(node);
+    }
+  } else {
+    const xScale = d3Scale2.scalePoint().domain(nodes).range([0, innerWidth]).padding(0.5);
+    let baseY = innerHeight / 2;
+    if (exportDims) {
+      let maxDist = 0;
+      for (const l of links) {
+        const a = xScale(l.source);
+        const b = xScale(l.target);
+        if (a != null && b != null)
+          maxDist = Math.max(maxDist, Math.abs(b - a));
+      }
+      const above = maxDist * 0.2 + sNodeRadius;
+      const below = Math.max(sBandHalfH, sNodeLabelYOffset + sNodeLabelFont);
+      baseY = above;
+      const tightHeight = margin.top + above + below + margin.bottom;
+      svg.attr("height", tightHeight).attr("viewBox", `0 0 ${width} ${tightHeight}`);
+    }
+    if (arcNodeGroups.length > 0) {
+      const bandPad = (xScale.step?.() ?? 20) * 0.4;
+      for (const group of arcNodeGroups) {
+        const groupNodes = group.nodes.filter((n) => nodes.includes(n));
+        if (groupNodes.length === 0) continue;
+        const positions = groupNodes.map((n) => xScale(n));
+        const minX = Math.min(...positions) - bandPad;
+        const maxX = Math.max(...positions) + bandPad;
+        g.append("rect").attr("class", "arc-group-band").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).attr("x", minX).attr("y", baseY - sBandHalfH).attr("width", maxX - minX).attr("height", sBandHalfH * 2).attr("rx", sBandRadius).attr("fill", textColor).attr("fill-opacity", 0.06).style("cursor", "pointer").on("mouseenter", () => handleGroupEnter(group.name)).on("mouseleave", handleMouseLeave).on("click", () => {
+          if (onClickItem) onClickItem(group.lineNumber);
+        });
+        g.append("text").attr("class", "arc-group-label").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).attr("x", (minX + maxX) / 2).attr("y", baseY + sBandHalfH - sBandLabelBottomOffset).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sGroupLabelFont}px`).attr("font-weight", "600").attr("fill-opacity", 0.5).style("cursor", onClickItem ? "pointer" : "default").text(group.name).on("mouseenter", () => handleGroupEnter(group.name)).on("mouseleave", handleMouseLeave).on("click", () => {
+          if (onClickItem) onClickItem(group.lineNumber);
+        });
+      }
+    }
+    g.append("line").attr("x1", 0).attr("y1", baseY).attr("x2", innerWidth).attr("y2", baseY).attr("stroke", mutedColor).attr("stroke-width", sBaselineStrokeWidth).attr("stroke-dasharray", sBaselineDash);
+    links.forEach((link, idx) => {
+      const x1 = xScale(link.source);
+      const x2 = xScale(link.target);
+      const midX = (x1 + x2) / 2;
+      const distance = Math.abs(x2 - x1);
+      const controlY = baseY - distance * 0.4;
+      const color = link.color ?? colors[idx % colors.length];
+      g.append("path").attr("class", "arc-link").attr("data-source", link.source).attr("data-target", link.target).attr("data-line-number", String(link.lineNumber)).attr("d", `M ${x1},${baseY} Q ${midX},${controlY} ${x2},${baseY}`).attr("fill", "none").attr("stroke", color).attr("stroke-width", strokeScale(link.value)).attr("stroke-opacity", 0.7).style("cursor", onClickItem ? "pointer" : "default").on("click", () => {
+        if (onClickItem && link.lineNumber) onClickItem(link.lineNumber);
+      });
+    });
+    for (const node of nodes) {
+      const x = xScale(node);
+      const nodeColor = nodeColorMap.get(node) ?? textColor;
+      const nodeLink = links.find(
+        (l) => l.source === node || l.target === node
+      );
+      const nodeG = g.append("g").attr("class", "arc-node").attr("data-node", node).attr(
+        "data-line-number",
+        nodeLink?.lineNumber ? String(nodeLink.lineNumber) : null
+      ).style("cursor", "pointer").on("mouseenter", () => handleMouseEnter(node)).on("mouseleave", handleMouseLeave).on("click", () => {
+        if (onClickItem && nodeLink?.lineNumber)
+          onClickItem(nodeLink.lineNumber);
+      });
+      nodeG.append("circle").attr("cx", x).attr("cy", baseY).attr("r", sNodeRadius).attr("fill", nodeColor).attr("stroke", bgColor).attr("stroke-width", sNodeStrokeWidth);
+      nodeG.append("text").attr("x", x).attr("y", baseY + sNodeLabelYOffset).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sNodeLabelFont}px`).text(node);
+    }
+  }
+}
+
+// src/wordcloud/renderer.ts
+import * as d3Selection2 from "d3-selection";
+import cloud from "d3-cloud";
+function getRotateFn(mode) {
+  if (mode === "mixed") return () => Math.random() > 0.5 ? 0 : 90;
+  if (mode === "angled") return () => Math.round(Math.random() * 30 - 15);
+  return () => 0;
+}
+function hasCanvas2d() {
+  try {
+    if (typeof document === "undefined") return false;
+    const canvas = document.createElement("canvas");
+    return typeof canvas.getContext === "function" && !!canvas.getContext("2d");
+  } catch {
+    return false;
+  }
+}
+function estimateWordWidth(text, size) {
+  return measureText(text, size);
+}
+function layoutWordsNoCanvas(words, width, height, padding, rotateFn) {
+  const sorted = [...words].sort((a, b) => b.size - a.size);
+  const placed = [];
+  const maxR = Math.sqrt(width * width + height * height) / 2;
+  const aspect = width > 0 ? height / width : 1;
+  for (const w of sorted) {
+    const rotate = rotateFn();
+    const rawW = estimateWordWidth(w.text, w.size) + padding * 2;
+    const rawH = w.size + padding * 2;
+    const rad = rotate * Math.PI / 180;
+    const cos = Math.abs(Math.cos(rad));
+    const sin = Math.abs(Math.sin(rad));
+    const halfW = (rawW * cos + rawH * sin) / 2;
+    const halfH = (rawW * sin + rawH * cos) / 2;
+    let spot = null;
+    for (let t = 0; t < 4e3; t++) {
+      const a = t * 0.25;
+      const r = a * 1.4;
+      if (r > maxR) break;
+      const x = Math.cos(a) * r;
+      const y = Math.sin(a) * r * aspect;
+      if (x - halfW < -width / 2 || x + halfW > width / 2 || y - halfH < -height / 2 || y + halfH > height / 2) {
+        continue;
+      }
+      let collides = false;
+      for (const p of placed) {
+        if (Math.abs(x - p.x) < halfW + p.halfW && Math.abs(y - p.y) < halfH + p.halfH) {
+          collides = true;
+          break;
+        }
+      }
+      if (!collides) {
+        spot = { x, y };
+        break;
+      }
+    }
+    if (!spot) continue;
+    placed.push({ ...w, rotate, x: spot.x, y: spot.y, halfW, halfH });
+  }
+  return placed;
+}
+function renderWordCloud(container, parsed, palette, _isDark, onClickItem, exportDims) {
+  const { words, cloudOptions } = parsed;
+  const title = parsed.noTitle ? null : parsed.title;
+  if (words.length === 0) return;
+  const init = initD3Chart(container, palette, exportDims);
+  if (!init) return;
+  const { svg, width, height, textColor, colors } = init;
+  const idealWidth = Math.max(400, words.length * 30);
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  const sTitleHeight = title ? ctx.aesthetic(40) : 0;
+  const cloudHeight = height - sTitleHeight;
+  const sPadding = ctx.structural(2);
+  svg.attr("preserveAspectRatio", "xMidYMid meet");
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const { minSize, maxSize } = cloudOptions;
+  const sMinSize = ctx.text(minSize);
+  const sMaxSize = ctx.text(maxSize);
+  const weights = words.map((w) => w.weight);
+  const minWeight = Math.min(...weights);
+  const maxWeight = Math.max(...weights);
+  const range = maxWeight - minWeight || 1;
+  const fontSize = (weight) => {
+    const t = (weight - minWeight) / range;
+    return sMinSize + Math.sqrt(t) * (sMaxSize - sMinSize);
+  };
+  const rotateFn = getRotateFn(cloudOptions.rotate);
+  renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem
+  );
+  const g = svg.append("g").attr(
+    "transform",
+    `translate(${width / 2},${sTitleHeight + cloudHeight / 2})`
+  );
+  const sized = words.map((w) => ({ ...w, size: fontSize(w.weight) }));
+  const draw = (layoutWords) => {
+    g.selectAll("text").data(layoutWords).join("text").style("font-size", (d) => `${d.size}px`).style("font-family", FONT_FAMILY).style("font-weight", "600").style("fill", (_d, i) => colors[i % colors.length]).style(
+      "cursor",
+      (d) => onClickItem && d.lineNumber ? "pointer" : "default"
+    ).attr("text-anchor", "middle").attr("transform", (d) => `translate(${d.x},${d.y}) rotate(${d.rotate})`).attr("data-line-number", (d) => {
+      const ln = d.lineNumber;
+      return ln ? String(ln) : null;
+    }).text((d) => d.text).on("click", (_event, d) => {
+      const ln = d.lineNumber;
+      if (onClickItem && ln) onClickItem(ln);
+    });
+  };
+  if (!hasCanvas2d()) {
+    draw(layoutWordsNoCanvas(sized, width, cloudHeight, sPadding, rotateFn));
+    return;
+  }
+  cloud().size([width, cloudHeight]).words(sized).padding(sPadding).rotate(rotateFn).fontSize((d) => d.size).font(FONT_FAMILY).on("end", draw).start();
+}
+function renderWordCloudAsync(container, parsed, palette, _isDark, exportDims) {
+  return new Promise((resolve) => {
+    d3Selection2.select(container).selectAll(":not([data-d3-tooltip])").remove();
+    const { words, cloudOptions } = parsed;
+    const title = parsed.noTitle ? null : parsed.title;
+    if (words.length === 0) {
+      resolve();
+      return;
+    }
+    const width = exportDims?.width ?? container.clientWidth;
+    const height = exportDims?.height ?? container.clientHeight;
+    if (width <= 0 || height <= 0) {
+      resolve();
+      return;
+    }
+    const titleHeight = title ? 40 : 0;
+    const cloudHeight = height - titleHeight;
+    const textColor = palette.text;
+    const bgColor = palette.bg;
+    const colors = getSeriesColors(palette);
+    const { minSize, maxSize } = cloudOptions;
+    const weights = words.map((w) => w.weight);
+    const minWeight = Math.min(...weights);
+    const maxWeight = Math.max(...weights);
+    const range = maxWeight - minWeight || 1;
+    const fontSize = (weight) => {
+      const t = (weight - minWeight) / range;
+      return minSize + Math.sqrt(t) * (maxSize - minSize);
+    };
+    const rotateFn = getRotateFn(cloudOptions.rotate);
+    const svg = d3Selection2.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMid meet").style("background", bgColor);
+    renderChartTitle(svg, title, parsed.titleLineNumber, width, textColor);
+    const g = svg.append("g").attr(
+      "transform",
+      `translate(${width / 2},${titleHeight + cloudHeight / 2})`
+    );
+    const sized = words.map((w) => ({ ...w, size: fontSize(w.weight) }));
+    const draw = (layoutWords) => {
+      g.selectAll("text").data(layoutWords).join("text").style("font-size", (d) => `${d.size}px`).style("font-family", FONT_FAMILY).style("font-weight", "600").style("fill", (_d, i) => colors[i % colors.length]).attr("text-anchor", "middle").attr(
+        "transform",
+        (d) => `translate(${d.x},${d.y}) rotate(${d.rotate})`
+      ).text((d) => d.text);
+      resolve();
+    };
+    if (!hasCanvas2d()) {
+      draw(layoutWordsNoCanvas(sized, width, cloudHeight, 2, rotateFn));
+      return;
+    }
+    cloud().size([width, cloudHeight]).words(sized).padding(2).rotate(rotateFn).fontSize((d) => d.size).font(FONT_FAMILY).on("end", draw).start();
+  });
+}
+
+// src/venn/renderer.ts
+function fitCirclesToContainerAsymmetric(circles, w, h, mLeft, mRight, mTop, mBottom) {
+  if (circles.length === 0) return [];
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  for (const c of circles) {
+    minX = Math.min(minX, c.x - c.r);
+    maxX = Math.max(maxX, c.x + c.r);
+    minY = Math.min(minY, c.y - c.r);
+    maxY = Math.max(maxY, c.y + c.r);
+  }
+  const bw = maxX - minX;
+  const bh = maxY - minY;
+  const availW = w - mLeft - mRight;
+  const availH = h - mTop - mBottom;
+  const scale = Math.min(availW / bw, availH / bh);
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const tx = mLeft + availW / 2;
+  const ty = mTop + availH / 2;
+  return circles.map((c) => ({
+    x: (c.x - cx) * scale + tx,
+    y: (c.y - cy) * scale + ty,
+    r: c.r * scale
+  }));
+}
+function pointInCircle(p, c) {
+  const dx = p.x - c.x;
+  const dy = p.y - c.y;
+  return dx * dx + dy * dy <= c.r * c.r + 1e-6;
+}
+function regionCentroid(circles, inside) {
+  const GRID = 50;
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  for (const c of circles) {
+    minX = Math.min(minX, c.x - c.r);
+    maxX = Math.max(maxX, c.x + c.r);
+    minY = Math.min(minY, c.y - c.r);
+    maxY = Math.max(maxY, c.y + c.r);
+  }
+  const stepX = (maxX - minX) / GRID;
+  const stepY = (maxY - minY) / GRID;
+  let sx = 0, sy = 0, count = 0;
+  for (let gi = 0; gi <= GRID; gi++) {
+    const x = minX + gi * stepX;
+    for (let gj = 0; gj <= GRID; gj++) {
+      const y = minY + gj * stepY;
+      let match = true;
+      for (let j = 0; j < circles.length; j++) {
+        const isIn = pointInCircle({ x, y }, circles[j]);
+        if (isIn !== inside[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        sx += x;
+        sy += y;
+        count++;
+      }
+    }
+  }
+  if (count === 0) {
+    let fx = 0, fy = 0, fc = 0;
+    for (let j = 0; j < circles.length; j++) {
+      if (inside[j]) {
+        fx += circles[j].x;
+        fy += circles[j].y;
+        fc++;
+      }
+    }
+    return { x: fx / (fc || 1), y: fy / (fc || 1) };
+  }
+  return { x: sx / count, y: sy / count };
+}
+function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims) {
+  const { vennSets, vennOverlaps } = parsed;
+  const solid = parsed.solidFill === true;
+  const title = parsed.noTitle ? null : parsed.title;
+  if (vennSets.length < 2 || vennSets.length > 3) return;
+  const init = initD3Chart(container, palette, exportDims);
+  if (!init) return;
+  const { svg, width, height, textColor, colors } = init;
+  const n = vennSets.length;
+  const idealWidth = n === 2 ? 500 : 600;
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  const sTitleHeight = title ? ctx.aesthetic(40) : 0;
+  svg.attr("preserveAspectRatio", "xMidYMid meet");
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const BASE_R = 100;
+  const OVERLAP_DISTANCE = BASE_R * 1.4;
+  let rawCircles;
+  if (n === 2) {
+    rawCircles = [
+      { x: -OVERLAP_DISTANCE / 2, y: 0, r: BASE_R },
+      { x: OVERLAP_DISTANCE / 2, y: 0, r: BASE_R }
+    ];
+  } else {
+    const s = OVERLAP_DISTANCE;
+    const h = Math.sqrt(3) / 2 * s;
+    rawCircles = [
+      { x: -s / 2, y: h / 3, r: BASE_R },
+      { x: s / 2, y: h / 3, r: BASE_R },
+      { x: 0, y: -(2 * h) / 3, r: BASE_R }
+    ];
+  }
+  const setColors = vennSets.map(
+    // colors is non-empty; modulo guarantees in-bounds.
+    (s, i) => s.color ?? colors[i % colors.length]
+  );
+  const clusterCx = rawCircles.reduce((s, c) => s + c.x, 0) / n;
+  const clusterCy = rawCircles.reduce((s, c) => s + c.y, 0) / n;
+  let marginLeft = ctx.aesthetic(30), marginRight = ctx.aesthetic(30), marginTop = ctx.aesthetic(30), marginBottom = ctx.aesthetic(30);
+  const stubLen = ctx.structural(20);
+  const edgePad = ctx.aesthetic(8);
+  const labelTextPad = ctx.aesthetic(4);
+  const sSetLabelFont = ctx.text(14);
+  for (let i = 0; i < n; i++) {
+    const estimatedWidth = measureText(vennSets[i].name, sSetLabelFont) + stubLen + edgePad + labelTextPad;
+    const dx = rawCircles[i].x - clusterCx;
+    const dy = rawCircles[i].y - clusterCy;
+    if (Math.abs(dx) >= Math.abs(dy)) {
+      if (dx >= 0) marginRight = Math.max(marginRight, estimatedWidth);
+      else marginLeft = Math.max(marginLeft, estimatedWidth);
+    } else {
+      const halfEstimate = estimatedWidth * 0.5;
+      if (dy >= 0)
+        marginBottom = Math.max(marginBottom, halfEstimate + ctx.aesthetic(20));
+      else marginTop = Math.max(marginTop, halfEstimate + ctx.aesthetic(20));
+    }
+  }
+  const OVERLAP_FONT = ctx.text(13);
+  const OVERLAP_LINE_H = ctx.structural(16);
+  const OVERLAP_LEADER_PAD = ctx.structural(18);
+  const OVERLAP_TEXT_GAP = ctx.aesthetic(6);
+  const OVERLAP_MARGIN_PAD = ctx.aesthetic(12);
+  const OVERLAP_WRAP_TARGET_W = Math.max(
+    ctx.structural(80),
+    Math.min(ctx.structural(170), width * 0.18)
+  );
+  function predictOverlapDirRaw(idxs) {
+    const excluded = rawCircles.map((_, j) => j).filter((j) => !idxs.includes(j));
+    if (excluded.length > 0) {
+      let sx = 0, sy = 0;
+      for (const ei of excluded) {
+        sx += rawCircles[ei].x;
+        sy += rawCircles[ei].y;
+      }
+      sx /= excluded.length;
+      sy /= excluded.length;
+      let cx = 0, cy = 0;
+      for (const ci of idxs) {
+        cx += rawCircles[ci].x;
+        cy += rawCircles[ci].y;
+      }
+      cx /= idxs.length;
+      cy /= idxs.length;
+      const dx = cx - sx;
+      const dy = cy - sy;
+      const m = Math.sqrt(dx * dx + dy * dy);
+      if (m >= 1e-6) return { x: dx / m, y: dy / m };
+    }
+    if (n === 3) return { x: 0, y: -1 };
+    return { x: 0, y: 1 };
+  }
+  const wrappedOverlapLabels = /* @__PURE__ */ new Map();
+  for (const ov of vennOverlaps) {
+    if (!ov.label) continue;
+    const idxs = ov.sets.map((s) => vennSets.findIndex((vs) => vs.name === s));
+    if (idxs.some((idx) => idx < 0)) continue;
+    const lines = wrapTextToWidth(
+      ov.label,
+      OVERLAP_FONT,
+      OVERLAP_WRAP_TARGET_W
+    );
+    wrappedOverlapLabels.set(ov, lines);
+    const dir = predictOverlapDirRaw(idxs);
+    const labelW = lines.reduce(
+      (m, l) => Math.max(m, measureText(l, OVERLAP_FONT)),
+      0
+    );
+    const labelH = lines.length * OVERLAP_LINE_H;
+    const baseLeader = OVERLAP_LEADER_PAD + OVERLAP_TEXT_GAP + OVERLAP_MARGIN_PAD;
+    if (Math.abs(dir.x) >= Math.abs(dir.y)) {
+      const need = labelW + baseLeader;
+      if (dir.x >= 0) marginRight = Math.max(marginRight, need);
+      else marginLeft = Math.max(marginLeft, need);
+      const halfH = labelH / 2;
+      if (dir.y >= 0) marginBottom = Math.max(marginBottom, halfH + 8);
+      else marginTop = Math.max(marginTop, halfH + 8);
+    } else {
+      const isStackedTriple = idxs.length === 3 && n === 3 && dir.y < 0;
+      const padBoost = isStackedTriple ? 32 : 0;
+      const need = labelH + baseLeader + padBoost;
+      if (dir.y >= 0) marginBottom = Math.max(marginBottom, need);
+      else marginTop = Math.max(marginTop, need);
+    }
+  }
+  const drawH = height - sTitleHeight;
+  const maxSideMarginX = width * 0.32;
+  const maxSideMarginY = drawH * 0.4;
+  marginLeft = Math.min(marginLeft, maxSideMarginX);
+  marginRight = Math.min(marginRight, maxSideMarginX);
+  marginTop = Math.min(marginTop, maxSideMarginY);
+  marginBottom = Math.min(marginBottom, maxSideMarginY);
+  const circles = fitCirclesToContainerAsymmetric(
+    rawCircles,
+    width,
+    drawH,
+    marginLeft,
+    marginRight,
+    marginTop,
+    marginBottom
+  ).map((c) => ({ ...c, y: c.y + sTitleHeight }));
+  const scaledR = circles[0].r;
+  svg.append("style").text(
+    "circle:focus, circle:focus-visible { outline-solid: none !important; }"
+  );
+  renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem
+  );
+  const circleEls = [];
+  const circleGroup = svg.append("g");
+  circles.forEach((c, i) => {
+    const el = circleGroup.append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r).attr("fill", setColors[i]).attr("fill-opacity", solid ? 0.6 : 0.35).attr("stroke", setColors[i]).attr("stroke-width", ctx.structural(2)).style("pointer-events", "none");
+    circleEls.push(el);
+  });
+  const defs = svg.append("defs");
+  circles.forEach((c, i) => {
+    defs.append("clipPath").attr("id", `vcp-${i}`).append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r);
+  });
+  const regionIdxSets = circles.map((_, i) => [i]);
+  if (n === 2) {
+    regionIdxSets.push([0, 1]);
+  } else {
+    regionIdxSets.push([0, 1], [0, 2], [1, 2], [0, 1, 2]);
+  }
+  const overlayGroup = svg.append("g").style("pointer-events", "none");
+  const overlayEls = /* @__PURE__ */ new Map();
+  for (const idxs of regionIdxSets) {
+    const key = idxs.join("-");
+    const excluded = Array.from({ length: n }, (_, j) => j).filter(
+      (j) => !idxs.includes(j)
+    );
+    let clipId = `vcp-${idxs[0]}`;
+    for (let k = 1; k < idxs.length; k++) {
+      const nestedId = `vcp-n-${idxs.slice(0, k + 1).join("-")}`;
+      const ci = idxs[k];
+      defs.append("clipPath").attr("id", nestedId).append("circle").attr("cx", circles[ci].x).attr("cy", circles[ci].y).attr("r", circles[ci].r).attr("clip-path", `url(#${clipId})`);
+      clipId = nestedId;
+    }
+    let regionLineNumber = null;
+    if (idxs.length === 1) {
+      regionLineNumber = vennSets[idxs[0]].lineNumber;
+    } else {
+      const sortedNames = idxs.map((i) => vennSets[i].name).sort();
+      const ov = vennOverlaps.find(
+        (o) => o.sets.length === sortedNames.length && o.sets.every((s, k) => s === sortedNames[k])
+      );
+      regionLineNumber = ov?.lineNumber ?? null;
+    }
+    const el = overlayGroup.append("rect").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height).attr("fill", "white").attr("fill-opacity", 0).attr("class", "venn-region-overlay").attr(
+      "data-line-number",
+      regionLineNumber != null ? String(regionLineNumber) : "0"
+    ).attr("clip-path", `url(#${clipId})`);
+    if (excluded.length > 0) {
+      const maskId = `vvm-${key}`;
+      const mask = defs.append("mask").attr("id", maskId);
+      mask.append("rect").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height).attr("fill", "white");
+      for (const j of excluded) {
+        mask.append("circle").attr("cx", circles[j].x).attr("cy", circles[j].y).attr("r", circles[j].r).attr("fill", "black");
+      }
+      el.attr("mask", `url(#${maskId})`);
+    }
+    overlayEls.set(key, el);
+  }
+  const labelEls = /* @__PURE__ */ new Map();
+  function registerLabel(key, el) {
+    if (!labelEls.has(key)) labelEls.set(key, []);
+    labelEls.get(key).push(el);
+  }
+  function dimLabelsExcept(matchKey) {
+    labelEls.forEach((els, k) => {
+      const op = matchKey === null || k === matchKey ? 1 : 0.2;
+      els.forEach((el) => el.attr("opacity", op));
+    });
+  }
+  const showRegionOverlay = (idxs) => {
+    const key = [...idxs].sort((a, b) => a - b).join("-");
+    overlayEls.forEach(
+      (el, k) => el.attr("fill-opacity", k === key ? 0 : 0.55)
+    );
+    dimLabelsExcept(key);
+  };
+  const hideAllOverlays = () => {
+    overlayEls.forEach((el) => el.attr("fill-opacity", 0));
+    dimLabelsExcept(null);
+  };
+  const gcx = circles.reduce((s, c) => s + c.x, 0) / n;
+  const gcy = circles.reduce((s, c) => s + c.y, 0) / n;
+  function exclusiveHSpan(_px, py, ci) {
+    const cci = circles[ci];
+    const dy = py - cci.y;
+    const halfChord = Math.sqrt(Math.max(0, cci.r * cci.r - dy * dy));
+    let left = cci.x - halfChord;
+    let right = cci.x + halfChord;
+    for (let j = 0; j < n; j++) {
+      if (j === ci) continue;
+      const cj = circles[j];
+      const djy = py - cj.y;
+      if (Math.abs(djy) >= cj.r) continue;
+      const hc = Math.sqrt(cj.r * cj.r - djy * djy);
+      const jLeft = cj.x - hc;
+      const jRight = cj.x + hc;
+      if (jLeft <= left && jRight >= right) return 0;
+      if (jLeft <= left && jRight > left) left = jRight;
+      if (jRight >= right && jLeft < right) right = jLeft;
+    }
+    return Math.max(0, right - left);
+  }
+  const MIN_FONT = ctx.text(10);
+  const MAX_FONT = ctx.text(22);
+  const INTERNAL_PAD = ctx.aesthetic(12);
+  const labelGroup = svg.append("g");
+  const setLabelBBoxes = circles.map(() => null);
+  circles.forEach((c, i) => {
+    const text = vennSets[i].name;
+    const inside = circles.map((_, j) => j === i);
+    const centroid = regionCentroid(circles, inside);
+    const availW = exclusiveHSpan(centroid.x, centroid.y, i);
+    const textWidthPerPx = measureText(text, 1);
+    const fitFont = Math.min(
+      MAX_FONT,
+      Math.max(MIN_FONT, (availW - INTERNAL_PAD * 2) / textWidthPerPx)
+    );
+    const estTextW = measureText(text, fitFont);
+    const fitsInside = estTextW + INTERNAL_PAD * 2 < availW && pointInCircle({ x: centroid.x, y: centroid.y - fitFont / 2 }, c) && pointInCircle({ x: centroid.x, y: centroid.y + fitFont / 2 }, c);
+    const setKey = String(i);
+    const labelG = labelGroup.append("g").style("cursor", "default").on("mouseenter", () => showRegionOverlay([i])).on("mouseleave", () => hideAllOverlays());
+    registerLabel(setKey, labelG);
+    if (fitsInside) {
+      labelG.append("text").attr("x", centroid.x).attr("y", centroid.y).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", textColor).attr("font-size", `${Math.round(fitFont)}px`).attr("font-weight", "bold").text(text);
+      setLabelBBoxes[i] = {
+        x: centroid.x - estTextW / 2,
+        y: centroid.y - fitFont / 2,
+        w: estTextW,
+        h: fitFont
+      };
+    } else {
+      let dx = c.x - gcx;
+      let dy = c.y - gcy;
+      const mag = Math.sqrt(dx * dx + dy * dy);
+      if (mag < 1e-6) {
+        dx = 1;
+        dy = 0;
+      } else {
+        dx /= mag;
+        dy /= mag;
+      }
+      const exitX = c.x + dx * c.r;
+      const exitY = c.y + dy * c.r;
+      const edgeX = exitX + dx * edgePad;
+      const edgeY = exitY + dy * edgePad;
+      const stubEndX = edgeX + dx * stubLen;
+      const stubEndY = edgeY + dy * stubLen;
+      labelG.append("line").attr("x1", edgeX).attr("y1", edgeY).attr("x2", stubEndX).attr("y2", stubEndY).attr("stroke", textColor).attr("stroke-width", ctx.structural(1));
+      const isRight = stubEndX >= gcx;
+      const textAnchor = isRight ? "start" : "end";
+      let textX = stubEndX + (isRight ? labelTextPad : -labelTextPad);
+      const textY = stubEndY;
+      const estW = measureText(text, sSetLabelFont);
+      if (isRight) textX = Math.min(textX, width - estW - 4);
+      else textX = Math.max(textX, estW + 4);
+      const renderedTextY = Math.max(
+        sSetLabelFont,
+        Math.min(height - 4, textY)
+      );
+      labelG.append("text").attr("x", textX).attr("y", renderedTextY).attr("text-anchor", textAnchor).attr("dominant-baseline", "central").attr("fill", textColor).attr("font-size", `${sSetLabelFont}px`).attr("font-weight", "bold").text(text);
+      const externalEstW = measureText(text, sSetLabelFont);
+      setLabelBBoxes[i] = {
+        x: isRight ? textX : textX - externalEstW,
+        y: renderedTextY - sSetLabelFont / 2,
+        w: externalEstW,
+        h: sSetLabelFont
+      };
+    }
+  });
+  function clipLineByRects(x1, y1, x2, y2, rects, pad = 4) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const skips = [];
+    for (const raw of rects) {
+      const rx = raw.x - pad;
+      const ry = raw.y - pad;
+      const rw = raw.w + 2 * pad;
+      const rh = raw.h + 2 * pad;
+      let tMin = 0;
+      let tMax = 1;
+      if (Math.abs(dx) < 1e-9) {
+        if (x1 < rx || x1 > rx + rw) continue;
+      } else {
+        const t1 = (rx - x1) / dx;
+        const t2 = (rx + rw - x1) / dx;
+        tMin = Math.max(tMin, Math.min(t1, t2));
+        tMax = Math.min(tMax, Math.max(t1, t2));
+      }
+      if (Math.abs(dy) < 1e-9) {
+        if (y1 < ry || y1 > ry + rh) continue;
+      } else {
+        const t1 = (ry - y1) / dy;
+        const t2 = (ry + rh - y1) / dy;
+        tMin = Math.max(tMin, Math.min(t1, t2));
+        tMax = Math.min(tMax, Math.max(t1, t2));
+      }
+      if (tMin < tMax) skips.push([Math.max(0, tMin), Math.min(1, tMax)]);
+    }
+    skips.sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    for (const s of skips) {
+      const last = merged[merged.length - 1];
+      if (!last || s[0] > last[1]) merged.push([s[0], s[1]]);
+      else last[1] = Math.max(last[1], s[1]);
+    }
+    const segs = [];
+    let cursor = 0;
+    for (const [s, e] of merged) {
+      if (s > cursor)
+        segs.push({
+          x1: x1 + dx * cursor,
+          y1: y1 + dy * cursor,
+          x2: x1 + dx * s,
+          y2: y1 + dy * s
+        });
+      cursor = Math.max(cursor, e);
+    }
+    if (cursor < 1)
+      segs.push({
+        x1: x1 + dx * cursor,
+        y1: y1 + dy * cursor,
+        x2,
+        y2
+      });
+    return segs;
+  }
+  function overlapOutwardDir(centroid, idxs) {
+    const excluded = circles.map((_, j) => j).filter((j) => !idxs.includes(j));
+    if (excluded.length > 0) {
+      let sx = 0, sy = 0;
+      for (const ei of excluded) {
+        sx += circles[ei].x;
+        sy += circles[ei].y;
+      }
+      sx /= excluded.length;
+      sy /= excluded.length;
+      const dx = centroid.x - sx;
+      const dy = centroid.y - sy;
+      const m = Math.sqrt(dx * dx + dy * dy);
+      if (m >= 1e-6) {
+        const nx = Math.abs(dx / m) < 1e-9 ? 0 : dx / m;
+        const ny = Math.abs(dy / m) < 1e-9 ? 0 : dy / m;
+        return { x: nx, y: ny };
+      }
+    }
+    if (n === 3) return { x: 0, y: -1 };
+    return { x: 0, y: 1 };
+  }
+  function lensExit(c0, dir, idxs) {
+    let minT = Infinity;
+    for (const i of idxs) {
+      const c = circles[i];
+      const dx = c0.x - c.x;
+      const dy = c0.y - c.y;
+      const B = dx * dir.x + dy * dir.y;
+      const C = dx * dx + dy * dy - c.r * c.r;
+      const disc = B * B - C;
+      if (disc < 0) continue;
+      const t = -B + Math.sqrt(disc);
+      if (t > 0 && t < minT) minT = t;
+    }
+    if (!isFinite(minT)) return { x: c0.x, y: c0.y };
+    return { x: c0.x + dir.x * minT, y: c0.y + dir.y * minT };
+  }
+  function unionExit(c0, dir, idxs) {
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const c of circles) {
+      minX = Math.min(minX, c.x - c.r);
+      maxX = Math.max(maxX, c.x + c.r);
+      minY = Math.min(minY, c.y - c.r);
+      maxY = Math.max(maxY, c.y + c.r);
+    }
+    const STEP = 3;
+    const MAX_ITERS = 400;
+    const axisAligned = dir.x === 0 || dir.y === 0;
+    let p = { x: c0.x, y: c0.y };
+    let leftOverlap = false;
+    for (let i = 0; i < MAX_ITERS; i++) {
+      const next = { x: p.x + dir.x * STEP, y: p.y + dir.y * STEP };
+      p = next;
+      if (!leftOverlap) {
+        leftOverlap = !idxs.every((ci) => pointInCircle(next, circles[ci]));
+        if (!leftOverlap) continue;
+      }
+      const insideAny = circles.some((c) => pointInCircle(next, c));
+      if (insideAny) continue;
+      if (axisAligned) {
+        const passedX = dir.x > 0 ? next.x >= maxX : next.x <= minX;
+        const passedY = dir.y > 0 ? next.y >= maxY : next.y <= minY;
+        if (dir.x !== 0 && !passedX) continue;
+        if (dir.y !== 0 && !passedY) continue;
+      }
+      break;
+    }
+    return p;
+  }
+  for (const ov of vennOverlaps) {
+    if (!ov.label) continue;
+    const idxs = ov.sets.map((s) => vennSets.findIndex((vs) => vs.name === s));
+    if (idxs.some((idx) => idx < 0)) continue;
+    const lines = wrappedOverlapLabels.get(ov) ?? [ov.label];
+    const inside = circles.map((_, j) => idxs.includes(j));
+    const centroid = regionCentroid(circles, inside);
+    const dir = overlapOutwardDir(centroid, idxs);
+    const isTriple = idxs.length === 3 && n === 3;
+    const padBoost = isTriple && dir.y < 0 ? 32 : 0;
+    const leaderPad = OVERLAP_LEADER_PAD + padBoost;
+    const lensPt = lensExit(centroid, dir, idxs);
+    const farExit = unionExit(centroid, dir, idxs);
+    const stubEndX = farExit.x + dir.x * leaderPad;
+    const stubEndY = farExit.y + dir.y * leaderPad;
+    const horizontal = Math.abs(dir.x) >= Math.abs(dir.y);
+    let textAnchor;
+    let baseline = "central";
+    if (horizontal) {
+      textAnchor = dir.x >= 0 ? "start" : "end";
+    } else {
+      textAnchor = "middle";
+      baseline = dir.y >= 0 ? "hanging" : "auto";
+    }
+    let textX, textY;
+    if (horizontal) {
+      const sign = dir.x >= 0 ? 1 : -1;
+      textX = stubEndX + sign * OVERLAP_TEXT_GAP;
+      textY = stubEndY;
+    } else {
+      const sign = dir.y >= 0 ? 1 : -1;
+      textX = stubEndX;
+      textY = stubEndY + sign * OVERLAP_TEXT_GAP;
+    }
+    const blockW = lines.reduce(
+      (m, l) => Math.max(m, measureText(l, OVERLAP_FONT)),
+      0
+    );
+    const blockH = lines.length * OVERLAP_LINE_H;
+    if (textAnchor === "start") textX = Math.min(textX, width - blockW - 4);
+    else if (textAnchor === "end") textX = Math.max(textX, blockW + 4);
+    else
+      textX = Math.max(blockW / 2 + 4, Math.min(width - blockW / 2 - 4, textX));
+    let topY, bottomY;
+    if (baseline === "hanging") {
+      topY = textY;
+      bottomY = textY + blockH;
+    } else if (baseline === "auto") {
+      bottomY = textY;
+      topY = textY - blockH;
+    } else {
+      topY = textY - blockH / 2;
+      bottomY = textY + blockH / 2;
+    }
+    if (topY < sTitleHeight + 6) textY += sTitleHeight + 6 - topY;
+    else if (bottomY > height - 4) textY -= bottomY - (height - 4);
+    const startY = baseline === "hanging" ? textY : baseline === "auto" ? textY - (lines.length - 1) * OVERLAP_LINE_H : textY - (lines.length - 1) * OVERLAP_LINE_H / 2;
+    const leaderStartX = isTriple ? centroid.x : lensPt.x;
+    const leaderStartY = isTriple ? centroid.y : lensPt.y;
+    let tinted = setColors[idxs[0]];
+    for (let k = 1; k < idxs.length; k++) {
+      const pct = k / (k + 1) * 100;
+      tinted = mix(tinted, setColors[idxs[k]], pct);
+    }
+    const overlapColor = mix(tinted, textColor, 90);
+    const ovKey = [...idxs].sort((a, b) => a - b).join("-");
+    const ovLabelG = labelGroup.append("g").style("cursor", "default").on("mouseenter", () => showRegionOverlay(idxs)).on("mouseleave", () => hideAllOverlays());
+    registerLabel(ovKey, ovLabelG);
+    const labelRects = setLabelBBoxes.filter((b) => b !== null);
+    const segments = clipLineByRects(
+      leaderStartX,
+      leaderStartY,
+      stubEndX,
+      stubEndY,
+      labelRects,
+      4
+    );
+    for (const seg of segments) {
+      ovLabelG.append("line").attr("x1", seg.x1).attr("y1", seg.y1).attr("x2", seg.x2).attr("y2", seg.y2).attr("stroke", overlapColor).attr("stroke-width", ctx.structural(1.25)).attr("opacity", 0.85);
+    }
+    const textEl = ovLabelG.append("text").attr("text-anchor", textAnchor).attr("dominant-baseline", baseline).attr("fill", overlapColor).attr("font-size", `${OVERLAP_FONT}px`).attr("font-weight", "600");
+    lines.forEach((line2, i) => {
+      const tspan = textEl.append("tspan").attr("x", textX);
+      if (i === 0) tspan.attr("y", startY);
+      else tspan.attr("dy", OVERLAP_LINE_H);
+      tspan.text(line2);
+    });
+  }
+  const hoverGroup = svg.append("g");
+  circles.forEach((c, i) => {
+    hoverGroup.append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r).attr("fill", "transparent").attr("stroke", "none").attr("class", "venn-hit-target").attr("data-line-number", String(vennSets[i].lineNumber)).style("cursor", onClickItem ? "pointer" : "default").style("outline-solid", "none").on("mouseenter", () => {
+      showRegionOverlay([i]);
+    }).on("mouseleave", () => {
+      hideAllOverlays();
+    }).on("click", function() {
+      this.blur?.();
+      if (onClickItem && vennSets[i].lineNumber)
+        onClickItem(vennSets[i].lineNumber);
+    });
+  });
+  const overlayR = scaledR * 0.35;
+  const subsets = [];
+  if (n === 2) {
+    subsets.push({
+      idxs: [0, 1],
+      sets: [vennSets[0].name, vennSets[1].name].sort()
+    });
+  } else {
+    for (let a = 0; a < n; a++) {
+      for (let b = a + 1; b < n; b++) {
+        subsets.push({
+          idxs: [a, b],
+          sets: [vennSets[a].name, vennSets[b].name].sort()
+        });
+      }
+    }
+    subsets.push({
+      idxs: [0, 1, 2],
+      sets: [vennSets[0].name, vennSets[1].name, vennSets[2].name].sort()
+    });
+  }
+  for (const subset of subsets) {
+    const { idxs, sets } = subset;
+    const inside = circles.map((_, j) => idxs.includes(j));
+    const centroid = regionCentroid(circles, inside);
+    const declaredOv = vennOverlaps.find(
+      (ov) => ov.sets.length === sets.length && ov.sets.every((s, k) => s === sets[k])
+    );
+    hoverGroup.append("circle").attr("cx", centroid.x).attr("cy", centroid.y).attr("r", overlayR).attr("fill", "transparent").attr("stroke", "none").attr("class", "venn-hit-target").attr("data-line-number", declaredOv ? String(declaredOv.lineNumber) : "").style("cursor", onClickItem && declaredOv ? "pointer" : "default").style("outline-solid", "none").on("mouseenter", () => {
+      showRegionOverlay(idxs);
+    }).on("mouseleave", () => {
+      hideAllOverlays();
+    }).on("click", function() {
+      this.blur?.();
+      if (onClickItem && declaredOv) onClickItem(declaredOv.lineNumber);
+    });
+  }
+}
+
+// src/quadrant/renderer.ts
+import * as d3Scale3 from "d3-scale";
+import * as d3Selection3 from "d3-selection";
+function renderQuadrant(container, parsed, palette, isDark, onClickItem, exportDims) {
+  const {
+    quadrantLabels,
+    quadrantPoints,
+    quadrantXAxis,
+    quadrantYAxis,
+    quadrantTitleLineNumber,
+    quadrantXAxisLineNumber,
+    quadrantYAxisLineNumber
+  } = parsed;
+  const title = parsed.noTitle ? null : parsed.title;
+  if (quadrantPoints.length === 0) return;
+  const init = initD3Chart(container, palette, exportDims);
+  if (!init) return;
+  const { svg, width, height, textColor } = init;
+  const borderColor = palette.border;
+  const idealWidth = 600;
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  svg.attr("preserveAspectRatio", "xMidYMid meet");
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const defaultColors = [
+    palette.colors.blue,
+    palette.colors.green,
+    palette.colors.yellow,
+    palette.colors.purple
+  ];
+  const hasXAxis = !!quadrantXAxis;
+  const hasYAxis = !!quadrantYAxis;
+  const margin = {
+    top: title ? ctx.aesthetic(60) : ctx.aesthetic(30),
+    right: ctx.aesthetic(30),
+    bottom: hasXAxis ? ctx.aesthetic(70) : ctx.aesthetic(40),
+    left: hasYAxis ? ctx.aesthetic(80) : ctx.aesthetic(40)
+  };
+  const chartWidth = width - margin.left - margin.right;
+  const chartHeight = height - margin.top - margin.bottom;
+  const xScale = d3Scale3.scaleLinear().domain([0, 1]).range([0, chartWidth]);
+  const yScale = d3Scale3.scaleLinear().domain([0, 1]).range([chartHeight, 0]);
+  renderChartTitle(
+    svg,
+    title,
+    quadrantTitleLineNumber,
+    width,
+    textColor,
+    onClickItem
+  );
+  const chartG = svg.append("g").attr("transform", `translate(${margin.left}, ${margin.top})`);
+  const bg = themeBaseBg(palette, isDark);
+  const getQuadrantColor = (label, defaultIdx) => {
+    return label?.color ?? defaultColors[defaultIdx % defaultColors.length];
+  };
+  const getQuadrantFill = (label, defaultIdx) => {
+    return mix(getQuadrantColor(label, defaultIdx), bg, 30);
+  };
+  const quadrantDefs = [
+    {
+      position: "top-left",
+      x: 0,
+      y: 0,
+      w: chartWidth / 2,
+      h: chartHeight / 2,
+      labelX: chartWidth / 4,
+      labelY: chartHeight / 4,
+      label: quadrantLabels.topLeft,
+      colorIdx: 1
+      // green
+    },
+    {
+      position: "top-right",
+      x: chartWidth / 2,
+      y: 0,
+      w: chartWidth / 2,
+      h: chartHeight / 2,
+      labelX: chartWidth * 3 / 4,
+      labelY: chartHeight / 4,
+      label: quadrantLabels.topRight,
+      colorIdx: 0
+      // blue
+    },
+    {
+      position: "bottom-left",
+      x: 0,
+      y: chartHeight / 2,
+      w: chartWidth / 2,
+      h: chartHeight / 2,
+      labelX: chartWidth / 4,
+      labelY: chartHeight * 3 / 4,
+      label: quadrantLabels.bottomLeft,
+      colorIdx: 2
+      // yellow
+    },
+    {
+      position: "bottom-right",
+      x: chartWidth / 2,
+      y: chartHeight / 2,
+      w: chartWidth / 2,
+      h: chartHeight / 2,
+      labelX: chartWidth * 3 / 4,
+      labelY: chartHeight * 3 / 4,
+      label: quadrantLabels.bottomRight,
+      colorIdx: 3
+      // purple
+    }
+  ];
+  const quadrantRects = chartG.selectAll("rect.quadrant").data(quadrantDefs).enter().append("rect").attr("class", "quadrant").attr("x", (d) => d.x).attr("y", (d) => d.y).attr("width", (d) => d.w).attr("height", (d) => d.h).attr("fill", (d) => getQuadrantFill(d.label, d.colorIdx)).attr("stroke", (d) => getQuadrantColor(d.label, d.colorIdx)).attr("stroke-width", ctx.structural(2));
+  const shadowColor = "rgba(0,0,0,0.4)";
+  const quadrantLabelColor = mix(textColor, bg, 35);
+  const LABEL_MAX_FONT = ctx.text(48);
+  const LABEL_MIN_FONT = ctx.text(14);
+  const LABEL_PAD = ctx.aesthetic(40);
+  const quadrantLabelLayout = (text, qw2, qh2) => {
+    const availW = qw2 - LABEL_PAD;
+    const availH = qh2 - LABEL_PAD;
+    if (measureText(text, LABEL_MAX_FONT) <= availW) {
+      const fs = Math.min(LABEL_MAX_FONT, availH);
+      return {
+        lines: [text],
+        fontSize: Math.max(LABEL_MIN_FONT, Math.round(fs))
+      };
+    }
+    const wrapLines = (fs) => wrapTextToWidth(text, fs, availW);
+    let lo = LABEL_MIN_FONT;
+    let hi = LABEL_MAX_FONT;
+    let bestLines = wrapLines(lo);
+    let bestFs = lo;
+    while (lo <= hi) {
+      const mid = Math.round((lo + hi) / 2);
+      const lines = wrapLines(mid);
+      const totalH = lines.length * mid * 1.2;
+      const maxLineW = Math.max(...lines.map((l) => measureText(l, mid)));
+      if (maxLineW <= availW && totalH <= availH) {
+        bestFs = mid;
+        bestLines = lines;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return { lines: bestLines, fontSize: Math.max(LABEL_MIN_FONT, bestFs) };
+  };
+  const qw = chartWidth / 2;
+  const qh = chartHeight / 2;
+  const quadrantDefsWithLabel = quadrantDefs.filter((d) => d.label !== null);
+  const labelLayouts = new Map(
+    quadrantDefsWithLabel.map((d) => [
+      d.label.text,
+      quadrantLabelLayout(d.label.text, qw, qh)
+    ])
+  );
+  const renderWatermarkOriginal = (textEl, d) => {
+    const layout = labelLayouts.get(d.label.text);
+    const el = d3Selection3.select(textEl);
+    el.text(null).attr("font-size", `${layout.fontSize}px`).attr("font-weight", "700");
+    if (layout.lines.length === 1) {
+      el.text(layout.lines[0]);
+    } else {
+      const lineH = layout.fontSize * 1.2;
+      const totalH = layout.lines.length * lineH;
+      const startY = -totalH / 2 + lineH / 2;
+      layout.lines.forEach((line2, i) => {
+        el.append("tspan").attr("x", d.labelX).attr("dy", i === 0 ? `${startY}px` : `${lineH}px`).text(line2);
+      });
+    }
+  };
+  const quadrantLabelTexts = chartG.selectAll("text.quadrant-label").data(quadrantDefsWithLabel).enter().append("text").attr("class", "quadrant-label").attr("x", (d) => d.labelX).attr("y", (d) => d.labelY).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", quadrantLabelColor).attr(
+    "data-line-number",
+    (d) => d.label?.lineNumber ? String(d.label.lineNumber) : null
+  ).style(
+    "cursor",
+    (d) => onClickItem && d.label?.lineNumber ? "pointer" : "default"
+  ).each(function(d) {
+    renderWatermarkOriginal(this, d);
+  });
+  if (onClickItem) {
+    quadrantLabelTexts.on("click", (_, d) => {
+      if (d.label?.lineNumber) onClickItem(d.label.lineNumber);
+    }).on("mouseenter", function() {
+      d3Selection3.select(this).attr("opacity", 0.7);
+    }).on("mouseleave", function() {
+      d3Selection3.select(this).attr("opacity", 1);
+    });
+  }
+  const sAxisFont = ctx.text(18);
+  const sAxisPad = ctx.aesthetic(20);
+  const sAxisX = ctx.aesthetic(22);
+  if (quadrantXAxis) {
+    const xLowLabel = svg.append("text").attr("class", "quadrant-axis-label").attr("x", margin.left + chartWidth / 4).attr("y", height - sAxisPad).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sAxisFont}px`).attr(
+      "data-line-number",
+      quadrantXAxisLineNumber ? String(quadrantXAxisLineNumber) : null
+    ).style(
+      "cursor",
+      onClickItem && quadrantXAxisLineNumber ? "pointer" : "default"
+    ).text(quadrantXAxis[0]);
+    const xHighLabel = svg.append("text").attr("class", "quadrant-axis-label").attr("x", margin.left + chartWidth * 3 / 4).attr("y", height - sAxisPad).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sAxisFont}px`).attr(
+      "data-line-number",
+      quadrantXAxisLineNumber ? String(quadrantXAxisLineNumber) : null
+    ).style(
+      "cursor",
+      onClickItem && quadrantXAxisLineNumber ? "pointer" : "default"
+    ).text(quadrantXAxis[1]);
+    if (onClickItem && quadrantXAxisLineNumber) {
+      [xLowLabel, xHighLabel].forEach((label) => {
+        label.on("click", () => onClickItem(quadrantXAxisLineNumber)).on("mouseenter", function() {
+          d3Selection3.select(this).attr("opacity", 0.7);
+        }).on("mouseleave", function() {
+          d3Selection3.select(this).attr("opacity", 1);
+        });
+      });
+    }
+  }
+  if (quadrantYAxis) {
+    const yMidBottom = margin.top + chartHeight * 3 / 4;
+    const yMidTop = margin.top + chartHeight / 4;
+    const yLowLabel = svg.append("text").attr("class", "quadrant-axis-label").attr("x", sAxisX).attr("y", yMidBottom).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sAxisFont}px`).attr("transform", `rotate(-90, ${sAxisX}, ${yMidBottom})`).attr(
+      "data-line-number",
+      quadrantYAxisLineNumber ? String(quadrantYAxisLineNumber) : null
+    ).style(
+      "cursor",
+      onClickItem && quadrantYAxisLineNumber ? "pointer" : "default"
+    ).text(quadrantYAxis[0]);
+    const yHighLabel = svg.append("text").attr("class", "quadrant-axis-label").attr("x", sAxisX).attr("y", yMidTop).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", `${sAxisFont}px`).attr("transform", `rotate(-90, ${sAxisX}, ${yMidTop})`).attr(
+      "data-line-number",
+      quadrantYAxisLineNumber ? String(quadrantYAxisLineNumber) : null
+    ).style(
+      "cursor",
+      onClickItem && quadrantYAxisLineNumber ? "pointer" : "default"
+    ).text(quadrantYAxis[1]);
+    if (onClickItem && quadrantYAxisLineNumber) {
+      [yLowLabel, yHighLabel].forEach((label) => {
+        label.on("click", () => onClickItem(quadrantYAxisLineNumber)).on("mouseenter", function() {
+          d3Selection3.select(this).attr("opacity", 0.7);
+        }).on("mouseleave", function() {
+          d3Selection3.select(this).attr("opacity", 1);
+        });
+      });
+    }
+  }
+  chartG.append("line").attr("x1", chartWidth / 2).attr("y1", 0).attr("x2", chartWidth / 2).attr("y2", chartHeight).attr("stroke", borderColor).attr("stroke-width", 1);
+  chartG.append("line").attr("x1", 0).attr("y1", chartHeight / 2).attr("x2", chartWidth).attr("y2", chartHeight / 2).attr("stroke", borderColor).attr("stroke-width", 1);
+  const getPointQuadrant = (x, y) => {
+    if (x >= 0.5 && y >= 0.5) return "top-right";
+    if (x < 0.5 && y >= 0.5) return "top-left";
+    if (x < 0.5 && y < 0.5) return "bottom-left";
+    return "bottom-right";
+  };
+  const POINT_RADIUS = ctx.structural(6);
+  const POINT_LABEL_FONT_SIZE = ctx.text(12);
+  const quadrantLabelObstacles = quadrantDefsWithLabel.map((d) => {
+    const layout = labelLayouts.get(d.label.text);
+    const totalW = Math.max(
+      ...layout.lines.map((l) => measureText(l, layout.fontSize))
+    );
+    const totalH = layout.lines.length * layout.fontSize * 1.2;
+    return {
+      x: d.labelX - totalW / 2,
+      y: d.labelY - totalH / 2,
+      w: totalW,
+      h: totalH
+    };
+  });
+  const pointPixels = quadrantPoints.map((point) => ({
+    label: point.label,
+    cx: xScale(point.x),
+    cy: yScale(point.y)
+  }));
+  const placedPointLabels = computeQuadrantPointLabels(
+    pointPixels,
+    { left: 0, top: 0, right: chartWidth, bottom: chartHeight },
+    quadrantLabelObstacles,
+    POINT_RADIUS,
+    POINT_LABEL_FONT_SIZE
+  );
+  const pointsG = chartG.append("g").attr("class", "points");
+  quadrantPoints.forEach((point, i) => {
+    const cx = xScale(point.x);
+    const cy = yScale(point.y);
+    const quadrant = getPointQuadrant(point.x, point.y);
+    const quadDef = quadrantDefs.find((d) => d.position === quadrant);
+    const pointColor = quadDef?.label?.color ?? defaultColors[quadDef?.colorIdx ?? 0];
+    const placed = placedPointLabels[i];
+    const pointG = pointsG.append("g").attr("class", "point-group").attr("data-line-number", String(point.lineNumber)).attr("data-quadrant", quadrant);
+    if (placed.connectorLine) {
+      pointG.append("line").attr("x1", placed.connectorLine.x1).attr("y1", placed.connectorLine.y1).attr("x2", placed.connectorLine.x2).attr("y2", placed.connectorLine.y2).attr("stroke", pointColor).attr("stroke-width", 1).attr("opacity", 0.5);
+    }
+    pointG.append("circle").attr("cx", cx).attr("cy", cy).attr("r", POINT_RADIUS).attr("fill", "#ffffff").attr("stroke", pointColor).attr("stroke-width", ctx.structural(2));
+    const labelText = pointG.append("text").attr("x", placed.x).attr("y", placed.y).attr("text-anchor", placed.anchor).attr("dominant-baseline", "central").attr("fill", textColor).attr("font-size", `${POINT_LABEL_FONT_SIZE}px`).attr("font-weight", "700").style("text-shadow", `0 1px 2px ${shadowColor}`).style("transition", "y 120ms ease-out");
+    labelText.append("tspan").text(point.label);
+    const coordsTspan = labelText.append("tspan").attr("class", "point-coords").attr("x", placed.x).attr("dy", `${POINT_LABEL_FONT_SIZE}px`).attr("font-size", `${ctx.text(10)}px`).attr("font-weight", "500").attr("opacity", 0).text(`${point.x.toFixed(2)}, ${point.y.toFixed(2)}`);
+    const COORDS_LINE_H = ctx.structural(14);
+    const bumpDy = placed.y < cy ? -COORDS_LINE_H : COORDS_LINE_H;
+    pointG.style("cursor", onClickItem ? "pointer" : "default").on("mouseenter", () => {
+      pointG.select("circle").attr("r", ctx.structural(8));
+      labelText.attr("y", placed.y + bumpDy);
+      coordsTspan.attr("opacity", 1);
+      quadrantRects.attr(
+        "opacity",
+        (qd) => qd.position === quadrant ? 1 : 0.3
+      );
+      quadrantLabelTexts.attr(
+        "opacity",
+        (qd) => qd.position === quadrant ? 1 : 0.3
+      );
+      pointsG.selectAll("g.point-group").filter((_, j) => j !== i).attr("opacity", 0.3);
+    }).on("mouseleave", () => {
+      pointG.select("circle").attr("r", POINT_RADIUS);
+      labelText.attr("y", placed.y);
+      coordsTspan.attr("opacity", 0);
+      quadrantRects.attr("opacity", 1);
+      quadrantLabelTexts.attr("opacity", 1);
+      pointsG.selectAll("g.point-group").attr("opacity", 1);
+    }).on("click", () => {
+      if (onClickItem && point.lineNumber) onClickItem(point.lineNumber);
+    });
+  });
+  quadrantRects.style("cursor", onClickItem ? "pointer" : "default").on("mouseenter", function(_, d) {
+    quadrantRects.attr(
+      "opacity",
+      (qd) => qd.position === d.position ? 1 : 0.3
+    );
+    quadrantLabelTexts.attr(
+      "opacity",
+      (qd) => qd.position === d.position ? 1 : 0.3
+    );
+    pointsG.selectAll("g.point-group").each(function(_2, i) {
+      const pt = quadrantPoints[i];
+      const ptQuad = getPointQuadrant(pt.x, pt.y);
+      d3Selection3.select(this).attr("opacity", ptQuad === d.position ? 1 : 0.2);
+    });
+  }).on("mouseleave", () => {
+    quadrantRects.attr("opacity", 1);
+    quadrantLabelTexts.attr("opacity", 1);
+    pointsG.selectAll("g.point-group").attr("opacity", 1);
+  }).on("click", (_, d) => {
+    if (onClickItem && d.label?.lineNumber) {
+      onClickItem(d.label.lineNumber);
+    }
+  });
+}
+
+// src/d3.ts
+var DIAGRAM_EXPORT_HANDLERS = {
+  org: exportOrg,
+  sitemap: exportSitemap,
+  kanban: exportKanban,
+  class: exportClass,
+  er: exportEr,
+  "boxes-and-lines": exportBoxesAndLines,
+  swimlane: exportSwimlane,
+  "version-control": exportVersionControl,
+  mindmap: exportMindmap,
+  wireframe: exportWireframe,
+  c4: exportC4,
+  flowchart: exportFlowchart,
+  infra: exportInfra,
+  pert: exportPert,
+  gantt: exportGantt,
+  state: exportState,
+  "tech-radar": exportTechRadar,
+  "journey-map": exportJourneyMap,
+  cycle: exportCycle,
+  map: exportMap,
+  pyramid: exportPyramid,
+  ring: exportRing,
+  treemap: exportTreemap,
+  block: exportBlock,
+  raci: exportRaci,
+  // D3 visualizations — own handler per type (Story 109.2). Only `sequence`
+  // still falls through to exportVisualization (no chart-type of its own).
+  slope: exportSlope,
+  arc: exportArc,
+  timeline: exportTimeline,
+  "event-line": exportEventLine,
+  wordcloud: exportWordcloud,
+  venn: exportVenn,
+  quadrant: exportQuadrant
+};
+function resolveArcChordOverride(content, detectedType, palette) {
+  if (detectedType === "arc") {
+    const p = parseArc(content, palette);
+    if (!p.error && p.layout === "chord" && p.links.length) {
+      const emitted = [
+        `chord ${p.title ?? ""}`.trimEnd(),
+        ...p.links.map((l) => `${l.source} -> ${l.target} ${l.value}`)
+      ].join("\n");
+      return { content: emitted, type: "chord" };
+    }
+  }
+  return null;
+}
+async function renderForExport(content, theme, palette, viewState, options) {
+  const exportMode = options?.exportMode ?? false;
+  const { parseDgmoChartType } = await import("./dgmo-router-DZCIDUO5.js");
+  const detectedTypeRaw = parseDgmoChartType(content);
+  const override = resolveArcChordOverride(content, detectedTypeRaw, palette);
+  const renderContent = override?.content ?? content;
+  const detectedType = override?.type ?? detectedTypeRaw;
+  if (detectedType !== null) {
+    const { supportsD3DataChart, renderDataChartD3: renderDataChartD32 } = await import("./charts-d3-QOZHKTCT.js");
+    if (supportsD3DataChart(detectedType)) {
+      return renderDataChartD32(renderContent, theme, palette);
+    }
+  }
+  const ctx = {
+    content: renderContent,
+    theme,
+    palette,
+    viewState,
+    options,
+    exportMode,
+    isDark: theme === "dark"
+  };
+  const handler = detectedType !== null ? DIAGRAM_EXPORT_HANDLERS[detectedType] : void 0;
+  return (handler ?? exportVisualization)(ctx);
+}
+function ctxTagOverride(ctx) {
+  return ctx.viewState?.tag ?? ctx.options?.tagGroup;
+}
+async function exportEventLine(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseEventLine } = await import("./parser-JAL2HD4I.js");
+  const { renderEventLineForExport } = await import("./renderer-RPOA5YPZ.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const parsed = parseEventLine(content, effectivePalette);
+  if (parsed.error || parsed.events.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderEventLineForExport(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT },
+    ctxTagOverride(ctx)
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportVersionControl(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseVersionControl } = await import("./parser-TFZFBVWN.js");
+  const { renderVersionControlForExport } = await import("./renderer-GHPZMFU2.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const parsed = parseVersionControl(content, effectivePalette);
+  if (parsed.error || parsed.nodes.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderVersionControlForExport(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    {
+      width: EXPORT_WIDTH,
+      height: EXPORT_HEIGHT
+    }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+function unionHiddenAttributes(hideOption, ha) {
+  const sourceHidden = hideOption ? hideOption.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean) : [];
+  const union = /* @__PURE__ */ new Set([...sourceHidden, ...ha ?? []]);
+  return union.size > 0 ? union : void 0;
+}
+async function exportOrg(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseOrg } = await import("./parser-6BTRLKRZ.js");
+  const { layoutOrg } = await import("./layout-OB3RI63S.js");
+  const { collapseOrgTree } = await import("./collapse-CLPJD2RL.js");
+  const { renderOrg } = await import("./renderer-T7YKC5VP.js");
+  const isDark = ctx.isDark;
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const orgParsed = parseOrg(content, effectivePalette);
+  if (orgParsed.error) return "";
+  const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : void 0;
+  const activeTagGroup = resolveActiveTagGroup(
+    orgParsed.tagGroups,
+    orgParsed.options["active-tag"],
+    ctxTagOverride(ctx)
+  );
+  const hiddenAttributes = unionHiddenAttributes(
+    orgParsed.options["hide"],
+    viewState?.ha
+  );
+  const { parsed: effectiveParsed, hiddenCounts } = collapsedNodes && collapsedNodes.size > 0 ? collapseOrgTree(orgParsed, collapsedNodes) : { parsed: orgParsed, hiddenCounts: /* @__PURE__ */ new Map() };
+  const orgLayout = layoutOrg(
+    effectiveParsed,
+    hiddenCounts.size > 0 ? hiddenCounts : void 0,
+    activeTagGroup,
+    hiddenAttributes,
+    false
+    // expandAllLegend off — collapsed-by-default per §1.3
+  );
+  const PADDING = 20;
+  const titleOffset = effectiveParsed.title ? 30 : 0;
+  const exportWidth = orgLayout.width + PADDING * 2;
+  const exportHeight = orgLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderOrg(
+    container,
+    effectiveParsed,
+    orgLayout,
+    effectivePalette,
+    isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    activeTagGroup,
+    hiddenAttributes,
+    void 0,
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportSitemap(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseSitemap } = await import("./parser-NGU3ETO6.js");
+  const { layoutSitemap } = await import("./layout-5T6RH5M6.js");
+  const { collapseSitemapTree } = await import("./collapse-ZWUFFCK2.js");
+  const { renderSitemap } = await import("./renderer-5NDVNDAZ.js");
+  const isDark = ctx.isDark;
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const sitemapParsed = parseSitemap(content, effectivePalette);
+  if (sitemapParsed.error || sitemapParsed.roots.length === 0) return "";
+  const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : void 0;
+  const activeTagGroup = resolveActiveTagGroup(
+    sitemapParsed.tagGroups,
+    sitemapParsed.options["active-tag"],
+    ctxTagOverride(ctx)
+  );
+  const hiddenAttributes = unionHiddenAttributes(
+    sitemapParsed.options["hide"],
+    viewState?.ha
+  );
+  const { parsed: effectiveParsed, hiddenCounts } = collapsedNodes && collapsedNodes.size > 0 ? collapseSitemapTree(sitemapParsed, collapsedNodes) : { parsed: sitemapParsed, hiddenCounts: /* @__PURE__ */ new Map() };
+  const sitemapLayout = layoutSitemap(
+    effectiveParsed,
+    hiddenCounts.size > 0 ? hiddenCounts : void 0,
+    activeTagGroup,
+    hiddenAttributes,
+    true
+  );
+  const PADDING = 20;
+  const titleOffset = effectiveParsed.title ? 30 : 0;
+  const exportWidth = sitemapLayout.width + PADDING * 2;
+  const exportHeight = sitemapLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderSitemap(
+    container,
+    effectiveParsed,
+    sitemapLayout,
+    effectivePalette,
+    isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    activeTagGroup,
+    hiddenAttributes,
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportKanban(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseKanban } = await import("./parser-XDVELHRK.js");
+  const { renderKanban } = await import("./renderer-6EEZHMH4.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const kanbanParsed = parseKanban(content, effectivePalette);
+  if (kanbanParsed.error || kanbanParsed.columns.length === 0) return "";
+  const container = document.createElement("div");
+  container.style.position = "absolute";
+  container.style.left = "-9999px";
+  document.body.appendChild(container);
+  const kanbanCollapsedLanes = viewState?.cl ? new Set(viewState.cl) : void 0;
+  const sourceCollapsedColumns = kanbanParsed.columns.filter((c) => c.collapsed).map((c) => c.id);
+  const kanbanCollapsedColumns = viewState?.cc || sourceCollapsedColumns.length > 0 ? /* @__PURE__ */ new Set([...sourceCollapsedColumns, ...viewState?.cc ?? []]) : void 0;
+  renderKanban(container, kanbanParsed, effectivePalette, ctx.isDark, {
+    activeTagGroup: resolveActiveTagGroup(
+      kanbanParsed.tagGroups,
+      kanbanParsed.options["active-tag"],
+      ctxTagOverride(ctx)
+    ),
+    currentSwimlaneGroup: viewState?.swim ?? kanbanParsed.options["lane-by"] ?? null,
+    ...kanbanCollapsedLanes !== void 0 && {
+      collapsedLanes: kanbanCollapsedLanes
+    },
+    ...kanbanCollapsedColumns !== void 0 && {
+      collapsedColumns: kanbanCollapsedColumns
+    },
+    ...viewState?.cm !== void 0 && { compactMeta: viewState.cm },
+    exportMode
+  });
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportClass(ctx) {
+  const { content, theme, palette, exportMode } = ctx;
+  const { parseClassDiagram } = await import("./parser-NRAI6O25.js");
+  const { layoutClassDiagram } = await import("./layout-46N4JJYK.js");
+  const { renderClassDiagram } = await import("./renderer-TOCOVLHS.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const classParsed = parseClassDiagram(content, effectivePalette);
+  if (classParsed.error || classParsed.classes.length === 0) return "";
+  const classLayout = layoutClassDiagram(classParsed);
+  const PADDING = 20;
+  const titleOffset = classParsed.title ? 40 : 0;
+  const exportWidth = classLayout.width + PADDING * 2;
+  const exportHeight = classLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderClassDiagram(
+    container,
+    classParsed,
+    classLayout,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    void 0,
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportEr(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseERDiagram } = await import("./parser-KNSQSKQO.js");
+  const { layoutERDiagram } = await import("./layout-EE6GE46Y.js");
+  const { renderERDiagram } = await import("./renderer-W4M6QLIJ.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const erParsed = parseERDiagram(content, effectivePalette);
+  if (erParsed.error || erParsed.tables.length === 0) return "";
+  const erLayout = layoutERDiagram(erParsed);
+  const PADDING = 20;
+  const titleOffset = erParsed.title ? 40 : 0;
+  const exportWidth = erLayout.width + PADDING * 2;
+  const exportHeight = erLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderERDiagram(
+    container,
+    erParsed,
+    erLayout,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    resolveActiveTagGroup(
+      erParsed.tagGroups,
+      erParsed.options["active-tag"],
+      ctxTagOverride(ctx)
+    ),
+    // Semantic colors are on by default; the source `no-semantic-colors` flag
+    // suppresses them. An interactive `viewState.sem` overrides source.
+    viewState?.sem ?? (erParsed.options["no-semantic-colors"] === "on" ? false : void 0),
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportBoxesAndLines(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseBoxesAndLines } = await import("./parser-TRTHDFPP.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const blParsed = parseBoxesAndLines(content, effectivePalette);
+  if (blParsed.error || blParsed.nodes.length === 0) return "";
+  let blHiddenTagValues;
+  if (viewState?.htv) {
+    blHiddenTagValues = /* @__PURE__ */ new Map();
+    for (const [k, v] of Object.entries(viewState.htv)) {
+      blHiddenTagValues.set(k, new Set(v));
+    }
+  }
+  const { renderBoxesAndLinesForExport } = await import("./renderer-YY2OSF6E.js");
+  const { layoutBoxesAndLines } = await import("./layout-HRBZPFCN.js");
+  const blLayout = await layoutBoxesAndLines(blParsed);
+  const PADDING = 20;
+  const titleOffset = blParsed.title ? 40 : 0;
+  const exportWidth = blLayout.width + PADDING * 2;
+  const exportHeight = blLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  const blActiveTagGroup = ctxTagOverride(ctx);
+  renderBoxesAndLinesForExport(
+    container,
+    blParsed,
+    blLayout,
+    effectivePalette,
+    ctx.isDark,
+    {
+      exportDims: { width: exportWidth, height: exportHeight },
+      ...blActiveTagGroup !== void 0 && {
+        activeTagGroup: blActiveTagGroup
+      },
+      ...blHiddenTagValues !== void 0 && {
+        hiddenTagValues: blHiddenTagValues
+      },
+      exportMode
+    }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportSwimlane(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseSwimlane } = await import("./parser-ZSDPZYQP.js");
+  const { layoutSwimlane } = await import("./layout-N76NR4ZO.js");
+  const { renderSwimlaneForExport } = await import("./renderer-JGBKUCZD.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const swimParsed = parseSwimlane(content, effectivePalette);
+  if (swimParsed.error || swimParsed.nodes.length === 0) return "";
+  const swimLayout = layoutSwimlane(swimParsed);
+  const PADDING = 20;
+  const titleOffset = swimParsed.title ? 40 : 0;
+  const exportWidth = swimLayout.width + PADDING * 2;
+  const exportHeight = swimLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderSwimlaneForExport(
+    container,
+    swimParsed,
+    swimLayout,
+    effectivePalette,
+    ctx.isDark,
+    {
+      exportDims: { width: exportWidth, height: exportHeight },
+      activeTagGroup: resolveActiveTagGroup(
+        swimParsed.tagGroups,
+        swimParsed.options["active-tag"],
+        ctxTagOverride(ctx)
+      ),
+      exportMode: ctx.exportMode
+    }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportMindmap(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseMindmap } = await import("./parser-N5O4IHUN.js");
+  const { layoutMindmap } = await import("./layout-UM5F4DJB.js");
+  const { collapseMindmapTree } = await import("./collapse-SLINJQW6.js");
+  const { renderMindmap } = await import("./renderer-2XQQQ6QR.js");
+  const isDark = ctx.isDark;
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const mmParsed = parseMindmap(content, effectivePalette);
+  if (mmParsed.error) return "";
+  const collapsedNodes = new Set(viewState?.cg ?? []);
+  const collectCollapsed = (nodes) => {
+    for (const n of nodes) {
+      if (n.collapsed) collapsedNodes.add(n.id);
+      if (n.children.length) collectCollapsed(n.children);
+    }
+  };
+  collectCollapsed(mmParsed.roots);
+  const activeTagGroup = resolveActiveTagGroup(
+    mmParsed.tagGroups,
+    mmParsed.options["active-tag"],
+    ctxTagOverride(ctx)
+  );
+  const hideDescriptions = mmParsed.options["no-descriptions"] === "true" || viewState?.hd === true;
+  const { roots: effectiveRoots, hiddenCounts } = collapsedNodes && collapsedNodes.size > 0 ? collapseMindmapTree(mmParsed.roots, collapsedNodes) : { roots: mmParsed.roots, hiddenCounts: /* @__PURE__ */ new Map() };
+  const effectiveParsed = { ...mmParsed, roots: effectiveRoots };
+  const mmLayout = layoutMindmap(effectiveParsed, effectivePalette, {
+    interactive: false,
+    ...hiddenCounts.size > 0 && { hiddenCounts },
+    activeTagGroup,
+    hideDescriptions
+  });
+  const PADDING = 20;
+  const titleOffset = effectiveParsed.title ? 30 : 0;
+  const exportWidth = mmLayout.width + PADDING * 2;
+  const exportHeight = mmLayout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  const colorByDepth = viewState?.cbd ?? mmParsed.options["color-by-depth"] === "on";
+  renderMindmap(
+    container,
+    effectiveParsed,
+    mmLayout,
+    effectivePalette,
+    isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    void 0,
+    hideDescriptions,
+    colorByDepth ? null : activeTagGroup,
+    colorByDepth ? { colorByDepth: true, exportMode } : { exportMode }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportWireframe(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseWireframe } = await import("./parser-IXSZZQHY.js");
+  const { layoutWireframe } = await import("./layout-G23F7LDH.js");
+  const { renderWireframe } = await import("./renderer-QIWVHWZO.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const wireframeParsed = parseWireframe(content);
+  if (wireframeParsed.error || wireframeParsed.roots.length === 0 && wireframeParsed.modals.length === 0)
+    return "";
+  const wireframeLayout = layoutWireframe(wireframeParsed);
+  const exportWidth = wireframeLayout.width;
+  const exportHeight = wireframeLayout.height;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderWireframe(
+    container,
+    wireframeParsed,
+    wireframeLayout,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    theme
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportC4(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseC4 } = await import("./parser-FUSKFGZN.js");
+  const {
+    layoutC4Context,
+    layoutC4Containers,
+    layoutC4Components,
+    layoutC4Deployment
+  } = await import("./layout-5RA6QWR6.js");
+  const { renderC4Context, renderC4Containers } = await import("./renderer-UWA5XS74.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const c4Parsed = parseC4(content, effectivePalette);
+  if (c4Parsed.error || c4Parsed.elements.length === 0) return "";
+  const c4Level = ctx.options?.c4Level ?? viewState?.c4l ?? "context";
+  const c4System = ctx.options?.c4System ?? viewState?.c4s;
+  const c4Container = ctx.options?.c4Container ?? viewState?.c4c;
+  const c4Layout = c4Level === "deployment" ? layoutC4Deployment(c4Parsed) : c4Level === "components" && c4System && c4Container ? layoutC4Components(c4Parsed, c4System, c4Container) : c4Level === "containers" && c4System ? layoutC4Containers(c4Parsed, c4System) : layoutC4Context(c4Parsed);
+  if (c4Layout.nodes.length === 0) return "";
+  const PADDING = 20;
+  const titleOffset = c4Parsed.title ? 40 : 0;
+  const exportWidth = c4Layout.width + PADDING * 2;
+  const exportHeight = c4Layout.height + PADDING * 2 + titleOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  const renderFn = c4Level === "deployment" || c4Level === "components" && c4System && c4Container || c4Level === "containers" && c4System ? renderC4Containers : renderC4Context;
+  renderFn(
+    container,
+    c4Parsed,
+    c4Layout,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    { width: exportWidth, height: exportHeight },
+    resolveActiveTagGroup(
+      c4Parsed.tagGroups,
+      c4Parsed.options["active-tag"],
+      ctxTagOverride(ctx)
+    ),
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportFlowchart(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseFlowchart } = await import("./flowchart-parser-ZNSKIBVR.js");
+  const { layoutGraph } = await import("./layout-HWDSRX5E.js");
+  const { renderFlowchart } = await import("./flowchart-renderer-ZAEOL4DX.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const fcParsed = parseFlowchart(content, effectivePalette);
+  if (fcParsed.error || fcParsed.nodes.length === 0) return "";
+  const layout = layoutGraph(fcParsed);
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderFlowchart(
+    container,
+    fcParsed,
+    layout,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportInfra(ctx) {
+  const { content, theme, palette, viewState } = ctx;
+  const { parseInfra } = await import("./parser-OV7NOBW6.js");
+  const { computeInfra } = await import("./compute-G55RG53N.js");
+  const { layoutInfra } = await import("./layout-7QXCNOVS.js");
+  const { renderInfra, computeInfraLegendGroups } = await import("./renderer-BYCNMBF7.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const infraParsed = parseInfra(content);
+  if (infraParsed.error || infraParsed.nodes.length === 0) return "";
+  const infraComputed = computeInfra(infraParsed);
+  const infraLayout = layoutInfra(infraComputed);
+  const activeTagGroup = resolveActiveTagGroup(
+    infraParsed.tagGroups,
+    infraParsed.options["active-tag"],
+    ctxTagOverride(ctx)
+  );
+  const showInfraTitle = !!infraParsed.title && infraParsed.options["no-title"] !== "on";
+  const titleOffset = showInfraTitle ? 40 : 0;
+  const infraTagGroups = [...infraParsed.tagGroups];
+  const legendGroups = computeInfraLegendGroups(
+    infraLayout.nodes,
+    infraTagGroups,
+    effectivePalette
+  );
+  const legendOffset = legendGroups.length > 0 ? 28 : 0;
+  const exportWidth = infraLayout.width;
+  const exportHeight = infraLayout.height + titleOffset + legendOffset;
+  const container = createExportContainer(exportWidth, exportHeight);
+  renderInfra(
+    container,
+    infraLayout,
+    effectivePalette,
+    ctx.isDark,
+    showInfraTitle ? infraParsed.title : null,
+    showInfraTitle ? infraParsed.titleLineNumber : null,
+    infraTagGroups,
+    activeTagGroup,
+    false,
+    null,
+    null,
+    true,
+    viewState?.cg ? new Set(viewState.cg) : null
+  );
+  const infraSvg = container.querySelector("svg");
+  if (infraSvg) {
+    infraSvg.setAttribute("width", String(exportWidth));
+    infraSvg.setAttribute("height", String(exportHeight));
+  }
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportPert(ctx) {
+  const { content, theme, palette, viewState } = ctx;
+  const { parsePert } = await import("./parser-3STE62GB.js");
+  const { analyzePert } = await import("./analyzer-UYKBXAKR.js");
+  const { layoutPert } = await import("./layout-S2QBYSK2.js");
+  const { renderPert, measurePertAnalysisBlock } = await import("./renderer-AWWAF6XD.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const pertParsed = parsePert(content, { palette: effectivePalette });
+  if (pertParsed.error || pertParsed.activities.length === 0) return "";
+  const pertResolved = analyzePert(pertParsed);
+  const pertLayout = layoutPert(pertResolved);
+  const titleHeight = pertParsed.title && !pertParsed.options.noTitle ? 80 : 0;
+  const PERT_PADDING = 20;
+  const analysisOn = viewState?.an ?? !pertParsed.options.noAnalysis;
+  const fieldLabelsOn = viewState?.fl === true;
+  const exportW = pertLayout.width + PERT_PADDING * 2;
+  const analysisMeasured = analysisOn || fieldLabelsOn ? measurePertAnalysisBlock(pertResolved, exportW - 2 * PERT_PADDING, {
+    showSummary: false,
+    showTornado: analysisOn,
+    showScurve: analysisOn,
+    showFieldLegend: fieldLabelsOn
+  }) : { width: 0, height: 0 };
+  const exportH = pertLayout.height + PERT_PADDING * 2 + titleHeight + analysisMeasured.height;
+  const container = createExportContainer(exportW, exportH);
+  renderPert(
+    container,
+    pertResolved,
+    pertLayout,
+    effectivePalette,
+    ctx.isDark,
+    {
+      title: pertParsed.title,
+      exportDims: { width: exportW, height: exportH },
+      showSummary: false,
+      showTornado: analysisOn,
+      showScurve: analysisOn,
+      showFieldLegend: fieldLabelsOn
+    }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportGantt(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseGantt } = await import("./parser-AQETEVRW.js");
+  const { calculateSchedule } = await import("./calculator-LDYQCDDY.js");
+  const { renderGantt } = await import("./renderer-VACVQYML.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const ganttParsed = parseGantt(content, effectivePalette);
+  const resolved = calculateSchedule(ganttParsed);
+  if (resolved.tasks.length === 0) return "";
+  const EXPORT_W = 1200;
+  const EXPORT_H = 800;
+  const container = createExportContainer(EXPORT_W, EXPORT_H);
+  const sourceCollapsedGroups = resolved.groups.filter((g) => g.collapsed).map((g) => g.name);
+  const ganttCollapsedGroups = viewState?.cg || sourceCollapsedGroups.length > 0 ? /* @__PURE__ */ new Set([...sourceCollapsedGroups, ...viewState?.cg ?? []]) : void 0;
+  const sourceSwimlane = resolved.options.sort === "tag" ? resolved.options.defaultSwimlaneGroup ?? void 0 : void 0;
+  const ganttSwimlaneGroup = viewState?.swim ?? sourceSwimlane;
+  const ganttCollapsedLanes = viewState?.cl ? new Set(viewState.cl) : void 0;
+  renderGantt(
+    container,
+    resolved,
+    effectivePalette,
+    ctx.isDark,
+    {
+      ...ganttCollapsedGroups !== void 0 && {
+        collapsedGroups: ganttCollapsedGroups
+      },
+      ...ganttSwimlaneGroup !== void 0 && {
+        currentSwimlaneGroup: ganttSwimlaneGroup
+      },
+      ...ganttCollapsedLanes !== void 0 && {
+        collapsedLanes: ganttCollapsedLanes
+      },
+      currentActiveGroup: resolveActiveTagGroup(
+        resolved.tagGroups,
+        resolved.options.activeTag ?? void 0,
+        ctxTagOverride(ctx)
+      ),
+      exportMode
+    },
+    { width: EXPORT_W, height: EXPORT_H }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportState(ctx) {
+  const { content, theme, palette, viewState } = ctx;
+  const { parseState } = await import("./state-parser-Z2V23ATR.js");
+  const { layoutGraph } = await import("./layout-HWDSRX5E.js");
+  const { renderState } = await import("./state-renderer-RFYHSP4K.js");
+  const { collapseStateGroups } = await import("./state-collapse-HCGD6IVJ.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const stateParsed = parseState(content, effectivePalette);
+  if (stateParsed.error || stateParsed.nodes.length === 0) return "";
+  const sourceCollapsed = (stateParsed.groups ?? []).filter((g) => g.collapsed).map((g) => g.id);
+  const collapsedGroups = /* @__PURE__ */ new Set([
+    ...sourceCollapsed,
+    ...viewState?.cg ?? []
+  ]);
+  const {
+    parsed: effectiveParsed,
+    collapsedChildCounts,
+    originalGroups
+  } = collapsedGroups.size > 0 ? collapseStateGroups(stateParsed, collapsedGroups) : {
+    parsed: stateParsed,
+    collapsedChildCounts: /* @__PURE__ */ new Map(),
+    originalGroups: stateParsed.groups ?? []
+  };
+  const layout = layoutGraph(effectiveParsed, {
+    collapsedChildCounts,
+    originalGroups
+  });
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderState(
+    container,
+    effectiveParsed,
+    layout,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportTechRadar(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseTechRadar } = await import("./parser-2MFP2H2E.js");
+  const { renderTechRadarForExport } = await import("./renderer-ZGNTUWC4.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const radarParsed = parseTechRadar(content);
+  if (radarParsed.error || radarParsed.quadrants.length === 0) return "";
+  const RADAR_EXPORT_W = 1300;
+  const RADAR_EXPORT_H = 1500;
+  const container = createExportContainer(RADAR_EXPORT_W, RADAR_EXPORT_H);
+  renderTechRadarForExport(
+    container,
+    radarParsed,
+    effectivePalette,
+    ctx.isDark,
+    { width: RADAR_EXPORT_W, height: RADAR_EXPORT_H },
+    viewState,
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportJourneyMap(ctx) {
+  const { content, theme, palette, exportMode } = ctx;
+  const { parseJourneyMap } = await import("./parser-I6KXEYFK.js");
+  const { renderJourneyMap } = await import("./renderer-CLJHQPBJ.js");
+  const { layoutJourneyMap } = await import("./layout-HYZPWAK5.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const jmParsed = parseJourneyMap(content, effectivePalette);
+  if (jmParsed.error || jmParsed.phases.length === 0 && jmParsed.steps.length === 0)
+    return "";
+  const jmLayout = layoutJourneyMap(jmParsed, effectivePalette, {
+    isDark: ctx.isDark
+  });
+  const container = createExportContainer(
+    jmLayout.totalWidth,
+    jmLayout.totalHeight
+  );
+  renderJourneyMap(container, jmParsed, effectivePalette, ctx.isDark, {
+    exportDims: { width: jmLayout.totalWidth, height: jmLayout.totalHeight },
+    exportMode
+  });
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportCycle(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const { parseCycle } = await import("./parser-VQP2UJ6W.js");
+  const { renderCycleForExport } = await import("./renderer-Z7I3W2PP.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const cycleParsed = parseCycle(content);
+  if (cycleParsed.error || cycleParsed.nodes.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderCycleForExport(
+    container,
+    cycleParsed,
+    effectivePalette,
+    ctx.isDark,
+    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT },
+    viewState,
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportMap(ctx) {
+  const { content, theme, palette, options } = ctx;
+  const { parseMap } = await import("./parser-4FL2CMDG.js");
+  const { resolveMap } = await import("./resolver-NOAA7ID7.js");
+  const { renderMapForExport } = await import("./renderer-SMIBCRVB.js");
+  const { mapExportDimensions } = await import("./dimensions-J3FHIMJ6.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const mapParsed = parseMap(content, effectivePalette);
+  let mapData = options?.mapData;
+  if (!mapData) {
+    const { loadMapData } = await import("./load-data-EHDDZ5ZS.js");
+    try {
+      mapData = await loadMapData();
+    } catch {
+      return "";
+    }
+  }
+  const mapResolved = resolveMap(mapParsed, mapData);
+  const dims = mapExportDimensions(
+    mapResolved,
+    mapData,
+    EXPORT_WIDTH,
+    options?.mapAspect
+  );
+  const container = createExportContainer(dims.width, dims.height);
+  renderMapForExport(
+    container,
+    mapResolved,
+    mapData,
+    effectivePalette,
+    ctx.isDark,
+    dims
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportPyramid(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parsePyramid } = await import("./parser-XKRP7QKP.js");
+  const { renderPyramidForExport } = await import("./renderer-KQB7UGDS.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const pyramidParsed = parsePyramid(content);
+  if (pyramidParsed.error || pyramidParsed.layers.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderPyramidForExport(
+    container,
+    pyramidParsed,
+    effectivePalette,
+    ctx.isDark,
+    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportRing(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseRing } = await import("./parser-O5J4VBII.js");
+  const { renderRingForExport } = await import("./renderer-ZTR3DER3.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const ringParsed = parseRing(content);
+  if (ringParsed.error || ringParsed.layers.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderRingForExport(container, ringParsed, effectivePalette, ctx.isDark, {
+    width: EXPORT_WIDTH,
+    height: EXPORT_HEIGHT
+  });
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportTreemap(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseTreemap } = await import("./parser-CFZD5IBL.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const treemapParsed = parseTreemap(content, effectivePalette);
+  if (treemapParsed.error || treemapParsed.roots.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  const dims = { width: EXPORT_WIDTH, height: EXPORT_HEIGHT };
+  if (treemapParsed.options.radial) {
+    const { renderTreemapRadialForExport } = await import("./renderer-radial-C32GPJQ7.js");
+    renderTreemapRadialForExport(
+      container,
+      treemapParsed,
+      effectivePalette,
+      ctx.isDark,
+      dims
+    );
+  } else {
+    const { renderTreemapForExport } = await import("./renderer-7MVLWWQD.js");
+    renderTreemapForExport(
+      container,
+      treemapParsed,
+      effectivePalette,
+      ctx.isDark,
+      dims
+    );
+  }
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportBlock(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseBlock } = await import("./parser-4OGOBJJ4.js");
+  const { renderBlockForExport } = await import("./renderer-PGX2TKVS.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const blockParsed = parseBlock(content, effectivePalette);
+  if (blockParsed.error || blockParsed.top.rows.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderBlockForExport(container, blockParsed, effectivePalette, ctx.isDark, {
+    width: EXPORT_WIDTH,
+    height: EXPORT_HEIGHT
+  });
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportRaci(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseRaci } = await import("./parser-Y6WTBU76.js");
+  const { renderRaciForExport } = await import("./renderer-WZRREQ2P.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const raciParsed = parseRaci(content, effectivePalette);
+  if (raciParsed.error) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderRaciForExport(container, raciParsed, effectivePalette, ctx.isDark, {
+    width: EXPORT_WIDTH,
+    height: EXPORT_HEIGHT
+  });
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+function beginVizExport() {
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  const dims = {
+    width: EXPORT_WIDTH,
+    height: EXPORT_HEIGHT
+  };
+  return { container, dims };
+}
+async function exportSlope(ctx) {
+  const { content, theme, palette } = ctx;
+  const parsed = parseSlope(content, palette);
+  if (parsed.error || parsed.data.length === 0) return "";
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const { container, dims } = beginVizExport();
+  renderSlopeChart(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    dims
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportArc(ctx) {
+  const { content, theme, palette } = ctx;
+  const parsed = parseArc(content, palette);
+  if (parsed.error || parsed.links.length === 0) return "";
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const { container, dims } = beginVizExport();
+  renderArcDiagram(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    dims
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportTimeline(ctx) {
+  const { content, theme, palette, viewState, exportMode } = ctx;
+  const parsed = parseTimeline(content, palette);
+  if (parsed.error || parsed.timelineEvents.length === 0) return "";
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const { container, dims } = beginVizExport();
+  renderTimeline(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    dims,
+    resolveActiveTagGroup(
+      parsed.timelineTagGroups,
+      parsed.timelineActiveTag,
+      ctxTagOverride(ctx)
+    ),
+    // Swimlane axis from source (`lane-by <group>` / `sort tag:<group>` →
+    // timelineDefaultSwimlaneTG), with a viewState.swim override.
+    viewState?.swim ?? parsed.timelineDefaultSwimlaneTG,
+    void 0,
+    void 0,
+    exportMode
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportWordcloud(ctx) {
+  const { content, theme, palette } = ctx;
+  const parsed = parseWordcloud(content, palette);
+  if (parsed.error || parsed.words.length === 0) return "";
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const { container, dims } = beginVizExport();
+  await renderWordCloudAsync(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    dims
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportVenn(ctx) {
+  const { content, theme, palette } = ctx;
+  const parsed = parseVenn(content, palette);
+  if (parsed.error || parsed.vennSets.length < 2) return "";
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const { container, dims } = beginVizExport();
+  renderVenn(container, parsed, effectivePalette, ctx.isDark, void 0, dims);
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportQuadrant(ctx) {
+  const { content, theme, palette } = ctx;
+  const parsed = parseQuadrant(content, palette);
+  if (parsed.error || parsed.quadrantPoints.length === 0) return "";
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const { container, dims } = beginVizExport();
+  renderQuadrant(
+    container,
+    parsed,
+    effectivePalette,
+    ctx.isDark,
+    void 0,
+    dims
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportVisualization(ctx) {
+  const { content, theme, palette, viewState } = ctx;
+  const parsed = parseVisualization(content, palette);
+  if (parsed.type !== "sequence") {
+    if (parsed.error) {
+      const looksLikeSequence = /->|~>|<-/.test(content);
+      if (!looksLikeSequence) return "";
+    } else {
+      return "";
+    }
+  }
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const isDark = ctx.isDark;
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  const { parseSequenceDgmo } = await import("./parser-PQ3POX45.js");
+  const { renderSequenceDiagram } = await import("./renderer-6W5462RB.js");
+  const seqParsed = parseSequenceDgmo(content, effectivePalette);
+  if (seqParsed.error || seqParsed.participants.length === 0) return "";
+  const collapsedSections = viewState?.cs ? new Set(viewState.cs) : void 0;
+  const collapsedGroups = viewState?.cg ? new Set(viewState.cg.map(Number).filter((n) => Number.isFinite(n))) : void 0;
+  const seqActiveTagGroup = ctxTagOverride(ctx);
+  renderSequenceDiagram(
+    container,
+    seqParsed,
+    effectivePalette,
+    isDark,
+    void 0,
+    {
+      exportWidth: EXPORT_WIDTH,
+      ...seqActiveTagGroup !== void 0 && {
+        activeTagGroup: seqActiveTagGroup
+      },
+      ...collapsedSections !== void 0 && { collapsedSections },
+      ...collapsedGroups !== void 0 && { collapsedGroups }
+    }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+
+// src/utils/hover-styles.ts
+var MAX_HOVER_GROUPS = 40;
+var DEFAULT_DIM_OPACITY = 0.4;
+var LIFT_DECL = "filter:saturate(1.4) brightness(1.06)";
+var TRANSITION_DECL = "transition:filter .12s ease, opacity .12s ease";
+function escCssString(value) {
+  let out = "";
+  for (const ch of value) {
+    const code = ch.codePointAt(0);
+    if (ch === '"') out += '\\"';
+    else if (ch === "\\") out += "\\\\";
+    else if (ch === "<") out += "\\3c ";
+    else if (code < 32 || code === 127)
+      out += "\\" + code.toString(16) + " ";
+    else out += ch;
+  }
+  return out;
+}
+function selfRule(markSelector) {
+  return `${markSelector}:hover{${LIFT_DECL}}`;
+}
+function enumeratedRule(mark, attr, v, emphasis, dimOpacity) {
+  const lit = escCssString(v);
+  const trigger = `svg:has(${mark}[${attr}="${lit}"]:hover)`;
+  return emphasis === "lift" ? `${trigger} ${mark}[${attr}="${lit}"]{${LIFT_DECL}}` : `${trigger} ${mark}:not([${attr}="${lit}"]){opacity:${dimOpacity}}`;
+}
+function legendRule(mark, attr, v, emphasis, dimOpacity) {
+  const entryLit = escCssString(v.toLowerCase());
+  const attrLit = escCssString(v);
+  const trigger = `svg:has([data-legend-entry="${entryLit}"]:hover)`;
+  return emphasis === "lift" ? `${trigger} ${mark}[${attr}="${attrLit}"]{${LIFT_DECL}}` : `${trigger} ${mark}:not([${attr}="${attrLit}"]){opacity:${dimOpacity}}`;
+}
+function connectionRule(spec, id, dimOpacity) {
+  const lit = escCssString(id);
+  const { hoverSelector, hoverAttr, edgeSelector, fromAttr, toAttr } = spec;
+  const trigger = `svg:has(${hoverSelector}[${hoverAttr}="${lit}"]:hover)`;
+  return `${trigger} ${edgeSelector}:not([${fromAttr}="${lit}"]):not([${toAttr}="${lit}"]){opacity:${dimOpacity}}`;
+}
+function buildHoverCss(spec, derived = {}, emphasisOverride) {
+  const emphasis = emphasisOverride ?? spec.emphasis ?? "lift";
+  const dimOpacity = spec.dimOpacity ?? DEFAULT_DIM_OPACITY;
+  const selfOn = spec.selfEmphasis !== false;
+  const values = derived.values ?? [];
+  const ids = derived.ids ?? [];
+  const base = [];
+  if (selfOn) {
+    base.push(selfRule(spec.markSelector));
+    if (!spec.animatesOpacity) {
+      base.push(`${spec.markSelector}{${TRANSITION_DECL}}`);
+    }
+  }
+  const cross = [];
+  if (spec.strategy === "structural" && spec.groupSelector) {
+    const g = spec.groupSelector;
+    cross.push(
+      emphasis === "lift" ? `svg:has(${g}:hover) ${g}:hover{${LIFT_DECL}}` : `svg:has(${g}:hover) ${g}:not(:hover){opacity:${dimOpacity}}`
+    );
+  } else if (spec.strategy === "enumerated" && spec.groupAttr) {
+    const legendCount = spec.legend ? values.length : 0;
+    if (values.length + legendCount > MAX_HOVER_GROUPS) {
+      base.push(
+        `/* hover: ${values.length} groups exceeds cap ${MAX_HOVER_GROUPS}; self-emphasis only */`
+      );
+    } else {
+      for (const v of values) {
+        cross.push(
+          enumeratedRule(
+            spec.markSelector,
+            spec.groupAttr,
+            v,
+            emphasis,
+            dimOpacity
+          )
+        );
+      }
+      if (spec.legend) {
+        for (const v of values) {
+          cross.push(
+            legendRule(
+              spec.markSelector,
+              spec.groupAttr,
+              v,
+              emphasis,
+              dimOpacity
+            )
+          );
+        }
+      }
+    }
+  } else if (spec.strategy === "connection") {
+    if (ids.length > MAX_HOVER_GROUPS) {
+      base.push(
+        `/* hover: ${ids.length} nodes exceeds cap ${MAX_HOVER_GROUPS}; self-emphasis only */`
+      );
+    } else {
+      for (const id of ids) cross.push(connectionRule(spec, id, dimOpacity));
+    }
+  }
+  const parts = [...base];
+  if (cross.length) parts.push(`@media (hover:hover){${cross.join("")}}`);
+  return parts.join("");
+}
+var HOVER_SPECS = {
+  pie: {
+    markSelector: ".dgmo-datum",
+    strategy: "enumerated",
+    groupAttr: "data-emph-key",
+    legend: true
+  },
+  bar: {
+    markSelector: ".dgmo-datum",
+    strategy: "enumerated",
+    groupAttr: "data-emph-key",
+    legend: true
+  },
+  funnel: {
+    markSelector: ".dgmo-datum",
+    strategy: "enumerated",
+    groupAttr: "data-emph-key",
+    legend: true
+  },
+  heatmap: {
+    markSelector: ".dgmo-datum",
+    strategy: "enumerated",
+    groupAttr: "data-emph-key",
+    legend: true
+  },
+  "polar-area": {
+    markSelector: ".dgmo-datum",
+    strategy: "enumerated",
+    groupAttr: "data-emph-key",
+    legend: true
+  },
+  // ── CROSS-FREE diagram charts — FIXED-attr keys, DOM-verified (Task 3) ──
+  // Purely additive: the baked CSS lights up embeds; the app keeps its own live
+  // JS emphasis (it renders via direct calls, never render()), so no double-up
+  // and no renderer edits. Tag-group charts (treemap/event-line/block/map —
+  // keyed on a per-diagram `data-tag-<slug>`) are deferred: they need
+  // active-tag-slug discovery in the injector.
+  gantt: {
+    markSelector: ".gantt-task",
+    strategy: "enumerated",
+    groupAttr: "data-group"
+  },
+  timeline: {
+    markSelector: ".tl-event",
+    strategy: "enumerated",
+    groupAttr: "data-group"
+  },
+  // raci cells AND column headers both carry `data-role-id`; keying on the bare
+  // attr makes hovering either lift the whole role (cross-column highlight).
+  raci: {
+    markSelector: "[data-role-id]",
+    strategy: "enumerated",
+    groupAttr: "data-role-id"
+  },
+  // ── CROSS-FREE connection charts (node hover → dim non-incident edges) ──
+  sequence: {
+    markSelector: ".participant",
+    strategy: "connection",
+    hoverSelector: ".participant",
+    hoverAttr: "data-participant-id",
+    edgeSelector: ".message-arrow",
+    fromAttr: "data-from",
+    toAttr: "data-to"
+  },
+  arc: {
+    markSelector: ".arc-node",
+    strategy: "connection",
+    hoverSelector: ".arc-node",
+    hoverAttr: "data-node",
+    edgeSelector: ".arc-link",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  pert: {
+    markSelector: ".pert-node",
+    strategy: "connection",
+    hoverSelector: ".pert-node",
+    hoverAttr: "data-activity-id",
+    edgeSelector: ".pert-edge",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  // ── CROSS-FREE tag-group charts — active group discovered at scan time ──
+  // The mark carries `data-tag-<slug>` for the ONE active tag group; the
+  // injector reads the slug from `data-legend-active` (F9). `data-tag-*` values
+  // and `data-legend-entry` are both lowercased, so legend pairing casing lines
+  // up. (map is excluded — it carries two tag kinds on different marks.)
+  treemap: {
+    markSelector: ".dgmo-treemap-cell",
+    strategy: "enumerated",
+    groupAttrMode: "tag-active",
+    legend: true
+  },
+  block: {
+    markSelector: ".dgmo-block-cell",
+    strategy: "enumerated",
+    groupAttrMode: "tag-active",
+    legend: true
+  },
+  "event-line": {
+    markSelector: ".dgmo-event-dot",
+    strategy: "enumerated",
+    groupAttrMode: "tag-active",
+    legend: true
+  },
+  // ── Connection graph-family — edge endpoint attrs baked in the renderers ──
+  // Hover a node → dim edges not incident to it. Node id ↔ edge from/to.
+  flowchart: {
+    markSelector: ".fc-node",
+    strategy: "connection",
+    hoverSelector: ".fc-node",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".fc-edge-group",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  state: {
+    markSelector: ".st-node",
+    strategy: "connection",
+    hoverSelector: ".st-node",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".st-edge-group",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  "boxes-and-lines": {
+    markSelector: ".bl-node",
+    strategy: "connection",
+    hoverSelector: ".bl-node",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".bl-edge-group",
+    fromAttr: "data-from",
+    toAttr: "data-to"
+  },
+  infra: {
+    markSelector: ".infra-node",
+    strategy: "connection",
+    hoverSelector: ".infra-node",
+    hoverAttr: "data-infra-node",
+    edgeSelector: ".infra-edge",
+    fromAttr: "data-from",
+    toAttr: "data-to"
+  },
+  c4: {
+    markSelector: ".c4-card",
+    strategy: "connection",
+    hoverSelector: ".c4-card",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".c4-edge-group",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  class: {
+    markSelector: ".cd-class",
+    strategy: "connection",
+    hoverSelector: ".cd-class",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".cd-edge-group",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  er: {
+    markSelector: ".er-table",
+    strategy: "connection",
+    hoverSelector: ".er-table",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".er-edge-group",
+    fromAttr: "data-source",
+    toAttr: "data-target"
+  },
+  org: {
+    markSelector: ".org-node",
+    strategy: "connection",
+    hoverSelector: ".org-node",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".org-edge",
+    fromAttr: "data-from",
+    toAttr: "data-to"
+  },
+  sitemap: {
+    markSelector: ".sitemap-node",
+    strategy: "connection",
+    hoverSelector: ".sitemap-node",
+    hoverAttr: "data-node-id",
+    edgeSelector: ".sitemap-edge-group",
+    fromAttr: "data-from",
+    toAttr: "data-to"
+  },
+  cycle: {
+    markSelector: ".cycle-node",
+    strategy: "connection",
+    hoverSelector: ".cycle-node",
+    hoverAttr: "data-node-index",
+    edgeSelector: ".cycle-edge",
+    fromAttr: "data-from",
+    toAttr: "data-to"
+  },
+  // ── CROSS-ADD — one attr baked in the renderer, then keyed here ──
+  scatter: {
+    markSelector: ".dgmo-datum",
+    strategy: "enumerated",
+    groupAttr: "data-category",
+    legend: true
+  },
+  quadrant: {
+    markSelector: ".point-group",
+    strategy: "enumerated",
+    groupAttr: "data-quadrant"
+  },
+  "version-control": {
+    markSelector: "[data-branch]",
+    strategy: "enumerated",
+    groupAttr: "data-branch"
+  },
+  // kanban: cards nest under a `.kanban-column` wrapper, so a structural rule
+  // gives column-focus with NO renderer edit — hovering any card puts its
+  // column into `:hover` and the others dim. `dim` (not lift) reads as
+  // "focus this column"; the marks' opacity is a presentation attr, which a
+  // `<style>` rule outranks (no RED-2 conflict).
+  kanban: {
+    markSelector: ".kanban-column",
+    strategy: "structural",
+    groupSelector: ".kanban-column",
+    emphasis: "dim",
+    selfEmphasis: false
+  },
+  // line: each series is a `g.dgmo-series` wrapping its line + data dots. The
+  // dots are hittable, so a structural rule dims other series when a point is
+  // hovered — no fat hit-path needed. (The plot-area hit overlay sits BEHIND
+  // the series, so dot hover still lands; verified in the browser e2e.)
+  line: {
+    markSelector: "g.dgmo-series",
+    strategy: "structural",
+    groupSelector: "g.dgmo-series",
+    emphasis: "dim",
+    selfEmphasis: false
+  },
+  swimlane: {
+    markSelector: "[data-lane]",
+    strategy: "enumerated",
+    groupAttr: "data-lane"
+  },
+  // tech-radar: blips are `<g>` carrying data-quadrant/data-ring/data-trend;
+  // only blips have data-trend (the sector wedges don't), so `[data-trend]`
+  // isolates them. Hover a blip → lift same-quadrant blips.
+  "tech-radar": {
+    markSelector: "[data-trend]",
+    strategy: "enumerated",
+    groupAttr: "data-quadrant"
+  },
+  // journey-map: faces carry data-score (the emotion). Hover a face → lift all
+  // same-score touchpoints across the journey.
+  "journey-map": {
+    markSelector: ".journey-face",
+    strategy: "enumerated",
+    groupAttr: "data-score"
+  },
+  // mindmap: nodes carry a single data-tag-<group> when tagged (no
+  // legend-active marker → the single-tag fallback in deriveFromSvg resolves
+  // it). Untagged → self-emphasis only.
+  mindmap: {
+    markSelector: ".mindmap-node",
+    strategy: "enumerated",
+    groupAttrMode: "tag-active"
+  },
+  // ── SELF-emphasis only (single-series / non-relational solid marks) ──
+  pyramid: { markSelector: ".pyramid-layer", strategy: "self" },
+  ring: { markSelector: ".ring-layer", strategy: "self" },
+  slope: { markSelector: ".slope-series", strategy: "self" },
+  // function: each curve is a `.dgmo-datum` path — self-emphasis floor only
+  // (thin line, no group).
+  function: { markSelector: ".dgmo-datum", strategy: "self" },
+  // map: POIs carry data-tag-<group> for the active legend group (resolved from
+  // data-legend-active). Hover a POI → lift same-group POIs. `lift` (never dim)
+  // sidesteps the decorative-layer / inactive-pill inline-opacity trap (F6).
+  // Region-tag (choropleth) maps have no POIs → self-emphasis only.
+  map: {
+    markSelector: "[data-poi]",
+    strategy: "enumerated",
+    groupAttrMode: "tag-active"
+  }
+};
+function deriveFromSvg(svg, spec) {
+  if (typeof document === "undefined") return {};
+  const holder = document.createElement("div");
+  holder.innerHTML = svg;
+  const root = holder.querySelector("svg");
+  if (!root) return {};
+  if (spec.strategy === "enumerated") {
+    let groupAttr = spec.groupAttr;
+    if (spec.groupAttrMode === "tag-active") {
+      const slug = root.querySelector("[data-legend-active]")?.getAttribute("data-legend-active");
+      if (slug) {
+        groupAttr = `data-tag-${tagAttrKey(slug)}`;
+      } else {
+        const names = /* @__PURE__ */ new Set();
+        root.querySelectorAll(spec.markSelector).forEach((el) => {
+          for (const a of Array.from(el.attributes)) {
+            if (a.name.startsWith("data-tag-")) names.add(a.name);
+          }
+        });
+        if (names.size !== 1) return {};
+        groupAttr = [...names][0];
+      }
+    }
+    if (!groupAttr) return {};
+    const attr = groupAttr;
+    const seen = /* @__PURE__ */ new Set();
+    root.querySelectorAll(`${spec.markSelector}[${attr}]`).forEach((el) => {
+      const v = el.getAttribute(attr);
+      if (v != null) seen.add(v);
+    });
+    return { values: [...seen], groupAttr: attr };
+  }
+  if (spec.strategy === "connection" && spec.hoverSelector && spec.hoverAttr) {
+    const seen = /* @__PURE__ */ new Set();
+    root.querySelectorAll(`${spec.hoverSelector}[${spec.hoverAttr}]`).forEach((el) => {
+      const v = el.getAttribute(spec.hoverAttr);
+      if (v != null) seen.add(v);
+    });
+    return { ids: [...seen] };
+  }
+  return {};
+}
+function injectHoverStyles(svg, chartType, opts) {
+  if (!opts?.bakeHover || !svg || !chartType) return svg;
+  const spec = HOVER_SPECS[chartType];
+  if (!spec) return svg;
+  const derived = deriveFromSvg(svg, spec);
+  const eff = derived.groupAttr ? { ...spec, groupAttr: derived.groupAttr } : spec;
+  const css = buildHoverCss(eff, derived, opts.emphasis);
+  if (!css) return svg;
+  const open = svg.match(/<svg\b[^>]*>/);
+  if (open?.index == null) return svg;
+  const at = open.index + open[0].length;
+  return `${svg.slice(0, at)}<style>${css}</style>${svg.slice(at)}`;
+}
+
+// src/render.ts
+var DOM_GLOBALS = [
+  "document",
+  "window",
+  "navigator",
+  "HTMLElement",
+  "SVGElement"
+];
+var DOM_STATE_KEY = /* @__PURE__ */ Symbol.for("diagrammo.dgmo.dom-globals");
+function domState() {
+  const g = globalThis;
+  return g[DOM_STATE_KEY] ??= {
+    refCount: 0,
+    installPromise: null,
+    installedByUs: false
+  };
+}
+async function installDom(state) {
+  const { JSDOM } = await loadJsdom();
+  const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+    url: "http://localhost/"
+  });
+  const win = dom.window;
+  const values = {
+    document: win.document,
+    window: win,
+    navigator: win.navigator,
+    HTMLElement: win.HTMLElement,
+    SVGElement: win.SVGElement
+  };
+  for (const key of DOM_GLOBALS) {
+    Object.defineProperty(globalThis, key, {
+      value: values[key],
+      configurable: true
+    });
+  }
+  state.installedByUs = true;
+}
+async function acquireDom() {
+  const state = domState();
+  if (typeof document !== "undefined" && !state.installedByUs) return;
+  state.refCount++;
+  if (!state.installPromise) state.installPromise = installDom(state);
+  await state.installPromise;
+}
+function releaseDom() {
+  const state = domState();
+  if (!state.installedByUs) return;
+  if (--state.refCount > 0) return;
+  for (const key of DOM_GLOBALS) {
+    delete globalThis[key];
+  }
+  state.installedByUs = false;
+  state.installPromise = null;
+  state.refCount = 0;
+}
+async function loadJsdom() {
+  const spec = ["js", "dom"].join("");
+  return import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    spec
+  );
+}
+async function render(content, options) {
+  const theme = options?.theme ?? "light";
+  const paletteName = options?.palette ?? "slate";
+  const bakeHover = options?.bakeHover ?? true;
+  const paletteColors = getPalette(paletteName)[theme === "dark" ? "dark" : "light"];
+  const parsed = parseDgmo(content);
+  let diagnostics = parsed.diagnostics;
+  const acOverride = resolveArcChordOverride(
+    content,
+    parsed.chartType,
+    paletteColors
+  );
+  const renderContent = acOverride?.content ?? content;
+  const chartType = acOverride?.type ?? parsed.chartType;
+  const category = acOverride ? "data-chart" : chartType ? getRenderCategory(chartType) : null;
+  const viewState = options?.viewState ?? (options?.legendState ? {
+    ...options.legendState.activeGroup !== void 0 && {
+      tag: options.legendState.activeGroup
+    },
+    ...options.legendState.hiddenAttributes !== void 0 && {
+      ha: options.legendState.hiddenAttributes
+    }
+  } : void 0);
+  if (category === "data-chart") {
+    await acquireDom();
+    try {
+      const raw = await renderDataChartD3(renderContent, theme, paletteColors);
+      const svg2 = injectHoverStyles(raw, chartType, { bakeHover });
+      return { svg: svg2, diagnostics };
+    } finally {
+      releaseDom();
+    }
+  }
+  await acquireDom();
+  let svg;
+  try {
+    svg = await renderForExport(
+      renderContent,
+      theme,
+      paletteColors,
+      viewState,
+      {
+        ...options?.c4Level !== void 0 && { c4Level: options.c4Level },
+        ...options?.c4System !== void 0 && { c4System: options.c4System },
+        ...options?.c4Container !== void 0 && {
+          c4Container: options.c4Container
+        },
+        ...options?.tagGroup !== void 0 && { tagGroup: options.tagGroup },
+        ...options?.mapData !== void 0 && { mapData: options.mapData }
+      }
+    );
+    svg = injectHoverStyles(svg, chartType, { bakeHover });
+  } finally {
+    releaseDom();
+  }
+  if (chartType === "map") {
+    try {
+      const [{ parseMap }, { resolveMap }, { loadMapData }] = await Promise.all(
+        [
+          import("./parser-4FL2CMDG.js"),
+          import("./resolver-NOAA7ID7.js"),
+          import("./load-data-EHDDZ5ZS.js")
+        ]
+      );
+      const data = options?.mapData ?? await loadMapData();
+      diagnostics = [...resolveMap(parseMap(content), data).diagnostics];
+    } catch {
+    }
+  }
+  return { svg, diagnostics };
+}
+
+// src/sharing.ts
+var import_lz_string = __toESM(require_lz_string(), 1);
+var DEFAULT_BASE_URL = "https://online.diagrammo.app";
+var COMPRESSED_SIZE_LIMIT = 8192;
+function encodeViewState(state) {
+  const keys = Object.keys(state);
+  if (keys.length === 0) return "";
+  return (0, import_lz_string.compressToEncodedURIComponent)(JSON.stringify(state));
+}
+function decodeViewState(encoded) {
+  if (!encoded) return {};
+  try {
+    const json = (0, import_lz_string.decompressFromEncodedURIComponent)(encoded);
+    if (!json) return {};
+    const parsed = JSON.parse(json);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function encodeDiagramUrl(dsl, options) {
+  const baseUrl = options?.baseUrl ?? DEFAULT_BASE_URL;
+  const compressed = (0, import_lz_string.compressToEncodedURIComponent)(dsl);
+  const byteSize = new TextEncoder().encode(compressed).byteLength;
+  if (byteSize > COMPRESSED_SIZE_LIMIT) {
+    return {
+      error: "too-large",
+      compressedSize: byteSize,
+      limit: COMPRESSED_SIZE_LIMIT
+    };
+  }
+  let hash = `dgmo=${compressed}`;
+  if (options?.viewState) {
+    const vsEncoded = encodeViewState(options.viewState);
+    if (vsEncoded) {
+      hash += `&vs=${vsEncoded}`;
+    }
+  }
+  if (options?.palette && options.palette !== "nord") {
+    hash += `&pal=${encodeURIComponent(options.palette)}`;
+  }
+  if (options?.theme && options.theme !== "dark") {
+    hash += `&th=${encodeURIComponent(options.theme)}`;
+  }
+  if (options?.filename) {
+    hash += `&fn=${encodeURIComponent(options.filename)}`;
+  }
+  return { url: `${baseUrl}?${hash}#${hash}` };
+}
+function decodeDiagramUrl(hash) {
+  const empty = { dsl: "", viewState: {} };
+  let filename;
+  let palette;
+  let theme;
+  if (!hash) return empty;
+  let raw = hash;
+  if (raw.startsWith("#") || raw.startsWith("?")) {
+    raw = raw.slice(1);
+  }
+  const parts = raw.split("&");
+  let payload = parts[0];
+  let viewState = {};
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq);
+    const val = part.slice(eq + 1);
+    if (key === "vs" && val) {
+      viewState = decodeViewState(val);
+    }
+    if (key === "pal" && val) palette = decodeURIComponent(val);
+    if (key === "th") {
+      const decoded = decodeURIComponent(val);
+      if (decoded === "light" || decoded === "dark") theme = decoded;
+    }
+    if (key === "fn" && val) filename = decodeURIComponent(val);
+  }
+  if (payload.startsWith("dgmo=")) {
+    payload = payload.slice(5);
+  }
+  const extras = {
+    ...palette !== void 0 && { palette },
+    ...theme !== void 0 && { theme },
+    ...filename !== void 0 && { filename }
+  };
+  if (!payload) return { dsl: "", viewState, ...extras };
+  try {
+    const result = (0, import_lz_string.decompressFromEncodedURIComponent)(payload);
+    return { dsl: result ?? "", viewState, ...extras };
+  } catch {
+    return { dsl: "", viewState, ...extras };
+  }
+}
+
+export {
+  renderSlopeChart,
+  orderArcNodes,
+  renderArcDiagram,
+  renderWordCloud,
+  renderVenn,
+  renderQuadrant,
+  renderForExport,
+  render,
+  encodeViewState,
+  decodeViewState,
+  encodeDiagramUrl,
+  decodeDiagramUrl
+};
+//# sourceMappingURL=chunk-IH6ZMVQ5.js.map