@diagrammo/dgmo 0.8.19 → 0.8.21

package/src/d3.ts

@@ -4,8 +4,9 @@ import * as d3Shape from 'd3-shape';
 import * as d3Array from 'd3-array';
 import cloud from 'd3-cloud';
 import { FONT_FAMILY } from './fonts';
-import { injectBranding } from './branding';
 import { computeQuadrantPointLabels, type LabelRect } from './label-layout';
+import { MONTH_ABBR, computeTimeTicks } from './utils/time-ticks';
+import type { D3ExportDimensions } from './utils/d3-types';
 
 // ============================================================
 // Types
@@ -133,10 +134,7 @@ interface QuadrantLabels {
 }
 
 /** Optional explicit dimensions for CLI/export rendering (bypasses DOM layout). */
-export interface D3ExportDimensions {
-  width?: number;
-  height?: number;
-}
+export type { D3ExportDimensions } from './utils/d3-types';
 
 export interface ParsedVisualization {
   type: VisualizationType | null;
@@ -331,34 +329,6 @@ export function parseTimelineDate(s: string): number {
   );
 }
 
-/** Convert a fractional year number back to a Date (inverse of parseTimelineDate). */
-function fractionalYearToDate(frac: number): Date {
-  const year = Math.floor(frac);
-  const remainder = frac - year;
-  // Inverse of: (month-1)/12 + (day-1)/365 + hour/8760 + minute/525600
-  const monthFrac = remainder * 12;
-  const month = Math.floor(monthFrac); // 0-based
-  const monthRemainder = remainder - month / 12;
-  const dayFrac = monthRemainder * 365; // fractional day-of-year offset
-  const day = Math.floor(dayFrac) + 1;
-  const dayRemainder = dayFrac - Math.floor(dayFrac);
-  const hourFrac = dayRemainder * 24;
-  const hour = Math.floor(hourFrac);
-  const minute = Math.round((hourFrac - hour) * 60);
-  return new Date(year, month, day, hour, minute);
-}
-
-/** Convert a Date to a fractional year number. */
-function dateToFractionalYear(d: Date): number {
-  return (
-    d.getFullYear() +
-    d.getMonth() / 12 +
-    (d.getDate() - 1) / 365 +
-    d.getHours() / 8760 +
-    d.getMinutes() / 525600
-  );
-}
-
 /**
  * Adds a duration to a date string and returns the resulting date string.
  * Supports: d (days), w (weeks), m (months), y (years), h (hours), min (minutes)
@@ -2885,21 +2855,6 @@ function renderMarkers(
 // Timeline Time Scale
 // ============================================================
 
-const MONTH_ABBR = [
-  'Jan',
-  'Feb',
-  'Mar',
-  'Apr',
-  'May',
-  'Jun',
-  'Jul',
-  'Aug',
-  'Sep',
-  'Oct',
-  'Nov',
-  'Dec',
-];
-
 /**
  * Converts a DSL date string (YYYY, YYYY-MM, YYYY-MM-DD, or YYYY-MM-DD HH:MM) to a human-readable label.
  *   '1718'              → '1718'
@@ -2947,173 +2902,6 @@ function formatBoundaryLabel(dateStr: string, otherDateStr: string): string {
   return formatDateLabel(dateStr);
 }
 
-/**
- * Computes adaptive tick marks for a timeline scale.
- * - Multi-year spans → year ticks
- * - Within ~1 year → month ticks
- * - Within ~3 months → week ticks (1st, 8th, 15th, 22nd)
- *
- * Optional boundary parameters add ticks at exact data start/end:
- * - boundaryStart/boundaryEnd: numeric date values
- * - boundaryStartLabel/boundaryEndLabel: formatted labels for those dates
- */
-export function computeTimeTicks(
-  domainMin: number,
-  domainMax: number,
-  scale: d3Scale.ScaleLinear<number, number>,
-  boundaryStart?: number,
-  boundaryEnd?: number,
-  boundaryStartLabel?: string,
-  boundaryEndLabel?: string
-): { pos: number; label: string }[] {
-  const minYear = Math.floor(domainMin);
-  const maxYear = Math.floor(domainMax);
-  const span = domainMax - domainMin;
-
-  let ticks: { pos: number; label: string }[] = [];
-
-  // Year ticks for multi-year spans (need at least 2 boundaries)
-  const firstYear = Math.ceil(domainMin);
-  const lastYear = Math.floor(domainMax);
-  if (lastYear >= firstYear + 1) {
-    // Decimate ticks for long spans so labels don't overlap
-    const yearSpan = lastYear - firstYear;
-    let step = 1;
-    if (yearSpan > 80) step = 20;
-    else if (yearSpan > 40) step = 10;
-    else if (yearSpan > 20) step = 5;
-    else if (yearSpan > 10) step = 2;
-
-    // Align to step boundary so ticks land on round years (1700, 1710, …)
-    const alignedFirst = Math.ceil(firstYear / step) * step;
-    for (let y = alignedFirst; y <= lastYear; y += step) {
-      ticks.push({ pos: scale(y), label: String(y) });
-    }
-  } else if (span > 0.25) {
-    // Month ticks for spans > ~3 months
-    const crossesYear = maxYear > minYear;
-    for (let y = minYear; y <= maxYear + 1; y++) {
-      for (let m = 1; m <= 12; m++) {
-        const val = y + (m - 1) / 12;
-        if (val > domainMax) break;
-        if (val >= domainMin) {
-          ticks.push({
-            pos: scale(val),
-            label: crossesYear
-              ? `${MONTH_ABBR[m - 1]} '${String(y).slice(-2)}`
-              : MONTH_ABBR[m - 1],
-          });
-        }
-      }
-    }
-  } else if (span <= 0.000685) {
-    // Minute ticks for spans ≤ ~6 hours
-    // Adaptive step: >3h → 30min, >1h → 15min, >30min → 10min, else 5min
-    let stepMin = 5;
-    const spanHours = span * 8760;
-    if (spanHours > 3) stepMin = 30;
-    else if (spanHours > 1) stepMin = 15;
-    else if (spanHours > 0.5) stepMin = 10;
-
-    // Iterate from the start hour boundary
-    const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
-    startDate.setMinutes(
-      Math.floor(startDate.getMinutes() / stepMin) * stepMin,
-      0,
-      0
-    );
-
-    while (true) {
-      const val = dateToFractionalYear(startDate);
-      if (val > domainMax) break;
-      if (val >= domainMin) {
-        const hh = String(startDate.getHours()).padStart(2, '0');
-        const mm = String(startDate.getMinutes()).padStart(2, '0');
-        ticks.push({ pos: scale(val), label: `${hh}:${mm}` });
-      }
-      startDate.setMinutes(startDate.getMinutes() + stepMin);
-    }
-  } else if (span <= 0.00822) {
-    // Hour ticks for spans ≤ ~3 days
-    // Adaptive step: >2d → 6h, >1d → 3h, >12h → 2h, else 1h
-    let stepHour = 1;
-    const spanHours = span * 8760;
-    if (spanHours > 48) stepHour = 6;
-    else if (spanHours > 24) stepHour = 3;
-    else if (spanHours > 12) stepHour = 2;
-
-    // For single-day spans, just show HH:MM without the date prefix
-    const singleDay = spanHours <= 24;
-
-    const startDate = fractionalYearToDate(domainMin);
-    // Round down to nearest step boundary
-    startDate.setHours(
-      Math.floor(startDate.getHours() / stepHour) * stepHour,
-      0,
-      0,
-      0
-    );
-
-    while (true) {
-      const val = dateToFractionalYear(startDate);
-      if (val > domainMax) break;
-      if (val >= domainMin) {
-        const hh = String(startDate.getHours()).padStart(2, '0');
-        const mm = String(startDate.getMinutes()).padStart(2, '0');
-        if (singleDay) {
-          ticks.push({ pos: scale(val), label: `${hh}:${mm}` });
-        } else {
-          const mon = MONTH_ABBR[startDate.getMonth()];
-          const d = startDate.getDate();
-          ticks.push({ pos: scale(val), label: `${mon} ${d} ${hh}:${mm}` });
-        }
-      }
-      startDate.setHours(startDate.getHours() + stepHour);
-    }
-  } else {
-    // Week ticks for spans ≤ ~3 months (1st, 8th, 15th, 22nd of each month)
-    for (let y = minYear; y <= maxYear + 1; y++) {
-      for (let m = 1; m <= 12; m++) {
-        for (const d of [1, 8, 15, 22]) {
-          const val = y + (m - 1) / 12 + (d - 1) / 365;
-          if (val > domainMax) break;
-          if (val >= domainMin) {
-            ticks.push({
-              pos: scale(val),
-              label: `${MONTH_ABBR[m - 1]} ${d}`,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  // Add boundary ticks at exact data start/end if provided
-  // When a boundary tick collides with a standard tick, replace the standard tick
-  const collisionThreshold = 40; // pixels
-
-  if (boundaryStart !== undefined && boundaryStartLabel) {
-    const boundaryPos = scale(boundaryStart);
-    // Remove any standard ticks that would collide with the start boundary
-    ticks = ticks.filter(
-      (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
-    );
-    ticks.unshift({ pos: boundaryPos, label: boundaryStartLabel });
-  }
-
-  if (boundaryEnd !== undefined && boundaryEndLabel) {
-    const boundaryPos = scale(boundaryEnd);
-    // Remove any standard ticks that would collide with the end boundary
-    ticks = ticks.filter(
-      (t) => Math.abs(t.pos - boundaryPos) >= collisionThreshold
-    );
-    ticks.push({ pos: boundaryPos, label: boundaryEndLabel });
-  }
-
-  return ticks;
-}
-
 /**
  * Renders adaptive tick marks along the time axis.
  * Optional boundary parameters add ticks at exact data start/end.
@@ -6678,8 +6466,7 @@ function createExportContainer(width: number, height: number): HTMLDivElement {
 function finalizeSvgExport(
   container: HTMLDivElement,
   theme: string,
-  palette: PaletteColors,
-  options?: { branding?: boolean }
+  palette: PaletteColors
 ): string {
   const svgEl = container.querySelector('svg');
   if (!svgEl) return '';
@@ -6694,10 +6481,6 @@ function finalizeSvgExport(
   svgEl.querySelectorAll('[data-export-ignore]').forEach((el) => el.remove());
   const svgHtml = svgEl.outerHTML;
   document.body.removeChild(container);
-  if (options?.branding !== false) {
-    const brandColor = theme === 'transparent' ? '#888' : palette.textMuted;
-    return injectBranding(svgHtml, brandColor);
-  }
   return svgHtml;
 }
 
@@ -6709,14 +6492,8 @@ export async function renderForExport(
   content: string,
   theme: 'light' | 'dark' | 'transparent',
   palette?: PaletteColors,
-  orgExportState?: {
-    collapsedNodes?: Set<string>;
-    activeTagGroup?: string | null;
-    hiddenAttributes?: Set<string>;
-    swimlaneTagGroup?: string | null;
-  },
+  viewState?: import('./sharing').CompactViewState,
   options?: {
-    branding?: boolean;
     c4Level?: 'context' | 'containers' | 'components' | 'deployment';
     c4System?: string;
     c4Container?: string;
@@ -6739,14 +6516,14 @@ export async function renderForExport(
     const orgParsed = parseOrg(content, effectivePalette);
     if (orgParsed.error) return '';
 
-    // Apply interactive collapse state when provided
-    const collapsedNodes = orgExportState?.collapsedNodes;
+    // Apply interactive collapse state when provided (read from unified viewState)
+    const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : undefined;
     const activeTagGroup = resolveActiveTagGroup(
       orgParsed.tagGroups,
       orgParsed.options['active-tag'],
-      orgExportState?.activeTagGroup ?? options?.tagGroup
+      viewState?.tag ?? options?.tagGroup
     );
-    const hiddenAttributes = orgExportState?.hiddenAttributes;
+    const hiddenAttributes = viewState?.ha ? new Set(viewState.ha) : undefined;
 
     const { parsed: effectiveParsed, hiddenCounts } =
       collapsedNodes && collapsedNodes.size > 0
@@ -6778,7 +6555,7 @@ export async function renderForExport(
       activeTagGroup,
       hiddenAttributes
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'sitemap') {
@@ -6793,14 +6570,14 @@ export async function renderForExport(
     const sitemapParsed = parseSitemap(content, effectivePalette);
     if (sitemapParsed.error || sitemapParsed.roots.length === 0) return '';
 
-    // Apply interactive collapse state when provided
-    const collapsedNodes = orgExportState?.collapsedNodes;
+    // Apply interactive collapse state when provided (read from unified viewState)
+    const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : undefined;
     const activeTagGroup = resolveActiveTagGroup(
       sitemapParsed.tagGroups,
       sitemapParsed.options['active-tag'],
-      orgExportState?.activeTagGroup ?? options?.tagGroup
+      viewState?.tag ?? options?.tagGroup
     );
-    const hiddenAttributes = orgExportState?.hiddenAttributes;
+    const hiddenAttributes = viewState?.ha ? new Set(viewState.ha) : undefined;
 
     const { parsed: effectiveParsed, hiddenCounts } =
       collapsedNodes && collapsedNodes.size > 0
@@ -6832,7 +6609,7 @@ export async function renderForExport(
       activeTagGroup,
       hiddenAttributes
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'kanban') {
@@ -6853,10 +6630,14 @@ export async function renderForExport(
       activeTagGroup: resolveActiveTagGroup(
         kanbanParsed.tagGroups,
         kanbanParsed.options['active-tag'],
-        options?.tagGroup
+        viewState?.tag ?? options?.tagGroup
       ),
+      currentSwimlaneGroup: viewState?.swim ?? null,
+      collapsedLanes: viewState?.cl ? new Set(viewState.cl) : undefined,
+      collapsedColumns: viewState?.cc ? new Set(viewState.cc) : undefined,
+      compactMeta: viewState?.cm,
     });
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'class') {
@@ -6884,7 +6665,7 @@ export async function renderForExport(
       undefined,
       { width: exportWidth, height: exportHeight }
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'er') {
@@ -6914,22 +6695,32 @@ export async function renderForExport(
       resolveActiveTagGroup(
         erParsed.tagGroups,
         erParsed.options['active-tag'],
-        options?.tagGroup
-      )
+        viewState?.tag ?? options?.tagGroup
+      ),
+      viewState?.sem
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'boxes-and-lines') {
     const { parseBoxesAndLines } = await import('./boxes-and-lines/parser');
-    const { layoutBoxesAndLines } = await import('./boxes-and-lines/layout');
-    const { renderBoxesAndLinesForExport } =
-      await import('./boxes-and-lines/renderer');
-
     const effectivePalette = await resolveExportPalette(theme, palette);
     const blParsed = parseBoxesAndLines(content);
     if (blParsed.error || blParsed.nodes.length === 0) return '';
 
+    // Convert viewState.htv (Record<string, string[]>) to Map<string, Set<string>>
+    let blHiddenTagValues: Map<string, Set<string>> | undefined;
+    if (viewState?.htv) {
+      blHiddenTagValues = new Map();
+      for (const [k, v] of Object.entries(viewState.htv)) {
+        blHiddenTagValues.set(k, new Set(v));
+      }
+    }
+
+    const { layoutBoxesAndLines } = await import('./boxes-and-lines/layout');
+    const { renderBoxesAndLinesForExport } =
+      await import('./boxes-and-lines/renderer');
+
     const blLayout = layoutBoxesAndLines(blParsed);
     const PADDING = 20;
     const titleOffset = blParsed.title ? 40 : 0;
@@ -6945,10 +6736,104 @@ export async function renderForExport(
       theme === 'dark',
       {
         exportDims: { width: exportWidth, height: exportHeight },
-        activeTagGroup: options?.tagGroup,
+        activeTagGroup: viewState?.tag ?? options?.tagGroup,
+        hiddenTagValues: blHiddenTagValues,
       }
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
+  }
+
+  if (detectedType === 'mindmap') {
+    const { parseMindmap } = await import('./mindmap/parser');
+    const { layoutMindmap } = await import('./mindmap/layout');
+    const { collapseMindmapTree } = await import('./mindmap/collapse');
+    const { renderMindmap } = await import('./mindmap/renderer');
+
+    const isDark = theme === 'dark';
+    const effectivePalette = await resolveExportPalette(theme, palette);
+
+    const mmParsed = parseMindmap(content, effectivePalette);
+    if (mmParsed.error) return '';
+
+    const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : undefined;
+    const activeTagGroup = resolveActiveTagGroup(
+      mmParsed.tagGroups,
+      mmParsed.options['active-tag'],
+      viewState?.tag ?? options?.tagGroup
+    );
+    const hideDescriptions =
+      mmParsed.options['hide-descriptions'] === 'true' ||
+      viewState?.hd === true;
+
+    const { roots: effectiveRoots, hiddenCounts } =
+      collapsedNodes && collapsedNodes.size > 0
+        ? collapseMindmapTree(mmParsed.roots, collapsedNodes)
+        : { roots: mmParsed.roots, hiddenCounts: new Map<string, number>() };
+
+    const effectiveParsed = { ...mmParsed, roots: effectiveRoots };
+
+    const mmLayout = layoutMindmap(effectiveParsed, effectivePalette, {
+      interactive: false,
+      hiddenCounts: hiddenCounts.size > 0 ? hiddenCounts : undefined,
+      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 === true;
+
+    renderMindmap(
+      container,
+      effectiveParsed,
+      mmLayout,
+      effectivePalette,
+      isDark,
+      undefined,
+      { width: exportWidth, height: exportHeight },
+      undefined,
+      hideDescriptions,
+      colorByDepth ? null : activeTagGroup,
+      colorByDepth ? { colorByDepth: true } : undefined
+    );
+    return finalizeSvgExport(container, theme, effectivePalette);
+  }
+
+  if (detectedType === 'wireframe') {
+    const { parseWireframe } = await import('./wireframe/parser');
+    const { layoutWireframe } = await import('./wireframe/layout');
+    const { renderWireframe } = await import('./wireframe/renderer');
+
+    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,
+      theme === 'dark',
+      undefined,
+      { width: exportWidth, height: exportHeight },
+      theme
+    );
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'c4') {
@@ -6966,10 +6851,18 @@ export async function renderForExport(
     const c4Parsed = parseC4(content, effectivePalette);
     if (c4Parsed.error || c4Parsed.elements.length === 0) return '';
 
-    // Container/component-level rendering
-    const c4Level = options?.c4Level ?? 'context';
-    const c4System = options?.c4System;
-    const c4Container = options?.c4Container;
+    // Container/component-level rendering (viewState fallback for share links)
+    const c4Level =
+      options?.c4Level ??
+      (viewState?.c4l as
+        | 'context'
+        | 'containers'
+        | 'components'
+        | 'deployment'
+        | undefined) ??
+      'context';
+    const c4System = options?.c4System ?? viewState?.c4s;
+    const c4Container = options?.c4Container ?? viewState?.c4c;
 
     const c4Layout =
       c4Level === 'deployment'
@@ -7006,10 +6899,10 @@ export async function renderForExport(
       resolveActiveTagGroup(
         c4Parsed.tagGroups,
         c4Parsed.options['active-tag'],
-        options?.tagGroup
+        viewState?.tag ?? options?.tagGroup
       )
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'flowchart') {
@@ -7033,7 +6926,7 @@ export async function renderForExport(
       undefined,
       { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'infra') {
@@ -7052,7 +6945,7 @@ export async function renderForExport(
     const activeTagGroup = resolveActiveTagGroup(
       infraParsed.tagGroups,
       infraParsed.options['active-tag'],
-      options?.tagGroup
+      viewState?.tag ?? options?.tagGroup
     );
 
     const titleOffset = infraParsed.title ? 40 : 0;
@@ -7078,7 +6971,8 @@ export async function renderForExport(
       false,
       null,
       null,
-      true
+      true,
+      viewState?.cg ? new Set(viewState.cg) : null
     );
     // Restore explicit pixel dimensions for resvg (renderer uses 100%/viewBox for app scaling)
     const infraSvg = container.querySelector('svg');
@@ -7086,7 +6980,7 @@ export async function renderForExport(
       infraSvg.setAttribute('width', String(exportWidth));
       infraSvg.setAttribute('height', String(exportHeight));
     }
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'gantt') {
@@ -7108,10 +7002,19 @@ export async function renderForExport(
       resolved,
       effectivePalette,
       theme === 'dark',
-      undefined,
+      {
+        collapsedGroups: viewState?.cg ? new Set(viewState.cg) : undefined,
+        currentSwimlaneGroup: viewState?.swim ?? undefined,
+        collapsedLanes: viewState?.cl ? new Set(viewState.cl) : undefined,
+        currentActiveGroup: resolveActiveTagGroup(
+          resolved.tagGroups,
+          resolved.options.activeTag ?? undefined,
+          viewState?.tag ?? options?.tagGroup
+        ),
+      },
       { width: EXPORT_W, height: EXPORT_H }
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   if (detectedType === 'state') {
@@ -7135,7 +7038,7 @@ export async function renderForExport(
       undefined,
       { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
     );
-    return finalizeSvgExport(container, theme, effectivePalette, options);
+    return finalizeSvgExport(container, theme, effectivePalette);
   }
 
   const parsed = parseVisualization(content, palette);
@@ -7209,9 +7112,9 @@ export async function renderForExport(
       resolveActiveTagGroup(
         parsed.timelineTagGroups,
         undefined,
-        orgExportState?.activeTagGroup ?? options?.tagGroup
+        viewState?.tag ?? options?.tagGroup
       ),
-      orgExportState?.swimlaneTagGroup
+      viewState?.swim
     );
   } else if (parsed.type === 'venn') {
     renderVenn(container, parsed, effectivePalette, isDark, undefined, dims);
@@ -7235,5 +7138,5 @@ export async function renderForExport(
     );
   }
 
-  return finalizeSvgExport(container, theme, effectivePalette, options);
+  return finalizeSvgExport(container, theme, effectivePalette);
 }