@diagrammo/dgmo 0.87.0 → 0.88.0

package/dist/{chunk-PJQZWJ5I.js → chunk-VW52W5F6.js}

@@ -1,3 +1,6 @@
+import {
+  layoutBracket
+} from "./chunk-ABP5BUD6.js";
 import {
   getRenderCategory,
   parseArc,
@@ -12,15 +15,32 @@ import {
 import {
   MAP_DX
 } from "./chunk-EOYPX6SF.js";
+import {
+  parseClock
+} from "./chunk-WP2RLGDI.js";
+import {
+  parseBracket
+} from "./chunk-ZUCXFXLD.js";
+import {
+  parseBody
+} from "./chunk-47E5UTXE.js";
 import {
   renderDataChartD3
 } from "./chunk-H2GEIFUF.js";
 import {
   computeQuadrantPointLabels
 } from "./chunk-KMU65FYM.js";
+import {
+  parseChart,
+  parseFunctionChart,
+  parseFunnel,
+  parseHeatmap,
+  parseSankey,
+  parseScatter
+} from "./chunk-7UDAIP6W.js";
 import {
   renderTimeline
-} from "./chunk-LPXC4I4R.js";
+} from "./chunk-JLETTWUJ.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
@@ -43,13 +63,118 @@ import {
 import {
   legendInlineSupported
 } from "./chunk-3DOQOXXI.js";
+import {
+  compactNumber
+} from "./chunk-FM3WAVB6.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";
+import {
+  parseCycle
+} from "./chunk-WQ6G6FFM.js";
+import {
+  parseJourneyMap
+} from "./chunk-NF5YKFRH.js";
+import {
+  parsePyramid
+} from "./chunk-PIXJL77H.js";
+import {
+  parseRing
+} from "./chunk-3C2FWS2J.js";
+import {
+  parseTreemap
+} from "./chunk-P3SKSKJI.js";
+import {
+  parseBlock
+} from "./chunk-MY6GUH26.js";
+import {
+  isBlockNode
+} from "./chunk-XSVWUOUZ.js";
+import {
+  parseGoal
+} from "./chunk-BOO24UMJ.js";
+import {
+  parseCountdown
+} from "./chunk-JQ57AWDL.js";
+import {
+  parseMap
+} from "./chunk-HTWH2XQL.js";
+import {
+  parseBoxesAndLines
+} from "./chunk-MHAYUS65.js";
+import {
+  parseSketch
+} from "./chunk-RU725VCJ.js";
+import {
+  parseSwimlane
+} from "./chunk-C7QRRTAW.js";
+import {
+  parseFamily
+} from "./chunk-FKZ2Y3Q5.js";
+import {
+  parseMindmap
+} from "./chunk-NGC3IZRY.js";
+import {
+  parseTechRadar
+} from "./chunk-6K7RODXG.js";
+import {
+  parseEventLine
+} from "./chunk-66YFDTT6.js";
+import {
+  parseTimelineDate
+} from "./chunk-GDJW64XE.js";
+import {
+  parseVersionControl
+} from "./chunk-QFHWYWQL.js";
+import {
+  parseKanban
+} from "./chunk-GUYVKGFN.js";
+import {
+  parseC4
+} from "./chunk-GSYZZFI5.js";
+import {
+  parseInfra
+} from "./chunk-GUTZCRBT.js";
+import {
+  parseGantt
+} from "./chunk-BAZT6CIF.js";
 import {
   measureText,
   wrapTextToWidth
 } from "./chunk-KAO7JL4I.js";
+import {
+  parseRaci
+} from "./chunk-3RYBTEF5.js";
+import {
+  parsePert
+} from "./chunk-UNNJCSSQ.js";
+import {
+  parseLiveLink
+} from "./chunk-7WGCQE2E.js";
+import {
+  parseSequenceDgmo
+} from "./chunk-VPASQOR3.js";
+import {
+  parseFlowchart
+} from "./chunk-JRUEIRJB.js";
+import {
+  parseState
+} from "./chunk-AYOVY75O.js";
+import {
+  parseClassDiagram
+} from "./chunk-A4XPI4YN.js";
+import {
+  parseERDiagram
+} from "./chunk-WPL5PFXE.js";
+import {
+  parseOrg
+} from "./chunk-FJNXXGTR.js";
+import {
+  parseSitemap
+} from "./chunk-UG2XG57E.js";
+import {
+  parseWireframe
+} from "./chunk-HSRQDWV7.js";
 import {
   resolveActiveTagGroup,
   tagAttrKey
@@ -128,8 +253,8 @@ function renderSlopeChart(container, parsed, palette, isDark, onClickItem, expor
   );
   const innerWidth = width - sMarginLeft - rightMargin;
   const innerHeight = height - sMarginTop - sMarginBottom;
-  const allValues = data.flatMap((d) => d.values);
-  const [minVal, maxVal] = d3Array.extent(allValues);
+  const allValues2 = data.flatMap((d) => d.values);
+  const [minVal, maxVal] = d3Array.extent(allValues2);
   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);
@@ -1990,10 +2115,10 @@ function ctxTagOverride(ctx) {
 }
 async function exportEventLine(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseEventLine } = await import("./parser-KFYRTGTC.js");
-  const { renderEventLineForExport } = await import("./renderer-3CTUWCO7.js");
+  const { parseEventLine: parseEventLine2 } = await import("./parser-KFYRTGTC.js");
+  const { renderEventLineForExport } = await import("./renderer-TPOZOAXR.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseEventLine(content, effectivePalette);
+  const parsed = parseEventLine2(content, effectivePalette);
   if (parsed.error || parsed.events.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderEventLineForExport(
@@ -2009,10 +2134,10 @@ async function exportEventLine(ctx) {
 }
 async function exportBody(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseBody } = await import("./parser-AKBVJHMK.js");
+  const { parseBody: parseBody2 } = await import("./parser-AKBVJHMK.js");
   const { renderBodyForExport } = await import("./renderer-JKV2DBYP.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseBody(content, effectivePalette);
+  const parsed = parseBody2(content, effectivePalette);
   if (parsed.error) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderBodyForExport(
@@ -2027,10 +2152,10 @@ async function exportBody(ctx) {
 }
 async function exportVersionControl(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseVersionControl } = await import("./parser-KZMJNKDW.js");
+  const { parseVersionControl: parseVersionControl2 } = await import("./parser-KZMJNKDW.js");
   const { renderVersionControlForExport } = await import("./renderer-BICLPGAH.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseVersionControl(content, effectivePalette);
+  const parsed = parseVersionControl2(content, effectivePalette);
   if (parsed.error || parsed.nodes.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderVersionControlForExport(
@@ -2052,13 +2177,13 @@ function unionHiddenAttributes(hideOption, ha) {
 }
 async function exportOrg(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseOrg, findOrgNodeIdByName } = await import("./parser-JOOAVBJI.js");
+  const { parseOrg: parseOrg2, findOrgNodeIdByName } = await import("./parser-JOOAVBJI.js");
   const { layoutOrg } = await import("./layout-QX5T6ZNE.js");
   const { collapseOrgTree, focusOrgTree, unionCollapsedOrgNodes } = await import("./collapse-JRGPUE67.js");
   const { renderOrg, ancestorTrailReserve } = await import("./renderer-36JH4OMC.js");
   const isDark = ctx.isDark;
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const orgParsed = parseOrg(content, effectivePalette);
+  const orgParsed = parseOrg2(content, effectivePalette);
   if (orgParsed.error) return "";
   const collapsedNodes = unionCollapsedOrgNodes(orgParsed, viewState?.cg);
   const activeTagGroup = resolveActiveTagGroup(
@@ -2116,13 +2241,13 @@ async function exportOrg(ctx) {
 }
 async function exportSitemap(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseSitemap } = await import("./parser-OKB64MMN.js");
+  const { parseSitemap: parseSitemap2 } = await import("./parser-OKB64MMN.js");
   const { layoutSitemap } = await import("./layout-LUQKAGGT.js");
   const { collapseSitemapTree } = await import("./collapse-ZWUFFCK2.js");
   const { renderSitemap } = await import("./renderer-WH2HWE5Z.js");
   const isDark = ctx.isDark;
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const sitemapParsed = parseSitemap(content, effectivePalette);
+  const sitemapParsed = parseSitemap2(content, effectivePalette);
   if (sitemapParsed.error || sitemapParsed.roots.length === 0) return "";
   const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : void 0;
   const activeTagGroup = resolveActiveTagGroup(
@@ -2168,10 +2293,10 @@ async function exportSitemap(ctx) {
 }
 async function exportKanban(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseKanban } = await import("./parser-ACW6C6OY.js");
+  const { parseKanban: parseKanban2 } = await import("./parser-ACW6C6OY.js");
   const { renderKanban } = await import("./renderer-3FF4QVGW.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const kanbanParsed = parseKanban(content, effectivePalette);
+  const kanbanParsed = parseKanban2(content, effectivePalette);
   if (kanbanParsed.error || kanbanParsed.columns.length === 0) return "";
   const container = document.createElement("div");
   container.style.position = "absolute";
@@ -2200,11 +2325,11 @@ async function exportKanban(ctx) {
 }
 async function exportClass(ctx) {
   const { content, theme, palette, exportMode } = ctx;
-  const { parseClassDiagram } = await import("./parser-GPW4ZHPQ.js");
+  const { parseClassDiagram: parseClassDiagram2 } = await import("./parser-GPW4ZHPQ.js");
   const { layoutClassDiagram } = await import("./layout-P6DTD4RT.js");
   const { renderClassDiagram } = await import("./renderer-A4LMOBZL.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const classParsed = parseClassDiagram(content, effectivePalette);
+  const classParsed = parseClassDiagram2(content, effectivePalette);
   if (classParsed.error || classParsed.classes.length === 0) return "";
   const classLayout = layoutClassDiagram(classParsed);
   const PADDING = 20;
@@ -2227,11 +2352,11 @@ async function exportClass(ctx) {
 }
 async function exportEr(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseERDiagram } = await import("./parser-J4DVNL4W.js");
+  const { parseERDiagram: parseERDiagram2 } = await import("./parser-J4DVNL4W.js");
   const { layoutERDiagram } = await import("./layout-EHTYSMV4.js");
   const { renderERDiagram } = await import("./renderer-R34GJL7U.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const erParsed = parseERDiagram(content, effectivePalette);
+  const erParsed = parseERDiagram2(content, effectivePalette);
   if (erParsed.error || erParsed.tables.length === 0) return "";
   const erLayout = layoutERDiagram(erParsed);
   const PADDING = 20;
@@ -2261,9 +2386,9 @@ async function exportEr(ctx) {
 }
 async function exportSketch(ctx) {
   const { content, theme, viewState, exportMode } = ctx;
-  const { parseSketch } = await import("./parser-KZMALSB2.js");
+  const { parseSketch: parseSketch2 } = await import("./parser-KZMALSB2.js");
   const effectivePalette = await resolveExportPalette(theme, ctx.palette);
-  const parsed = parseSketch(content, effectivePalette);
+  const parsed = parseSketch2(content, effectivePalette);
   if (parsed.error || parsed.nodes.length === 0 && parsed.boxes.length === 0) {
     return "";
   }
@@ -2295,9 +2420,9 @@ async function exportSketch(ctx) {
 }
 async function exportBoxesAndLines(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseBoxesAndLines } = await import("./parser-KYPP2DX6.js");
+  const { parseBoxesAndLines: parseBoxesAndLines2 } = await import("./parser-KYPP2DX6.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const blParsed = parseBoxesAndLines(content, effectivePalette);
+  const blParsed = parseBoxesAndLines2(content, effectivePalette);
   if (blParsed.error || blParsed.nodes.length === 0) return "";
   let blHiddenTagValues;
   if (viewState?.htv) {
@@ -2336,11 +2461,11 @@ async function exportBoxesAndLines(ctx) {
 }
 async function exportSwimlane(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseSwimlane } = await import("./parser-ZLKYDFI5.js");
+  const { parseSwimlane: parseSwimlane2 } = await import("./parser-ZLKYDFI5.js");
   const { layoutSwimlane } = await import("./layout-RANVNAKI.js");
   const { renderSwimlaneForExport } = await import("./renderer-QM23SWAM.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const swimParsed = parseSwimlane(content, effectivePalette);
+  const swimParsed = parseSwimlane2(content, effectivePalette);
   if (swimParsed.error || swimParsed.nodes.length === 0) return "";
   const swimLayout = layoutSwimlane(swimParsed);
   const PADDING = 20;
@@ -2368,11 +2493,11 @@ async function exportSwimlane(ctx) {
 }
 async function exportFamily(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseFamily } = await import("./parser-NPXPJHWN.js");
+  const { parseFamily: parseFamily2 } = await import("./parser-NPXPJHWN.js");
   const { layoutFamily } = await import("./layout-5VSMZPMG.js");
   const { renderFamilyForExport } = await import("./renderer-4NZZ5J2F.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseFamily(content, effectivePalette);
+  const parsed = parseFamily2(content, effectivePalette);
   if (parsed.error || parsed.persons.size === 0) return "";
   const layout = layoutFamily(parsed);
   const PADDING = 20;
@@ -2400,13 +2525,13 @@ async function exportFamily(ctx) {
 }
 async function exportMindmap(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseMindmap } = await import("./parser-NGHQQGD2.js");
+  const { parseMindmap: parseMindmap2 } = await import("./parser-NGHQQGD2.js");
   const { layoutMindmap } = await import("./layout-5NPBHV5F.js");
   const { collapseMindmapTree } = await import("./collapse-SLINJQW6.js");
   const { renderMindmap } = await import("./renderer-LODEVN3V.js");
   const isDark = ctx.isDark;
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const mmParsed = parseMindmap(content, effectivePalette);
+  const mmParsed = parseMindmap2(content, effectivePalette);
   if (mmParsed.error) return "";
   const collapsedNodes = new Set(viewState?.cg ?? []);
   const collectCollapsed = (nodes) => {
@@ -2453,11 +2578,11 @@ async function exportMindmap(ctx) {
 }
 async function exportWireframe(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseWireframe } = await import("./parser-HCGXNHHL.js");
+  const { parseWireframe: parseWireframe2 } = await import("./parser-HCGXNHHL.js");
   const { layoutWireframe } = await import("./layout-UIV56NUA.js");
   const { renderWireframe } = await import("./renderer-RWJ45DWH.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const wireframeParsed = parseWireframe(content);
+  const wireframeParsed = parseWireframe2(content);
   if (wireframeParsed.error || wireframeParsed.roots.length === 0 && wireframeParsed.modals.length === 0)
     return "";
   const wireframeLayout = layoutWireframe(wireframeParsed);
@@ -2478,7 +2603,7 @@ async function exportWireframe(ctx) {
 }
 async function exportC4(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseC4 } = await import("./parser-WEVTMBJ5.js");
+  const { parseC4: parseC42 } = await import("./parser-WEVTMBJ5.js");
   const {
     layoutC4Context,
     layoutC4Containers,
@@ -2487,7 +2612,7 @@ async function exportC4(ctx) {
   } = await import("./layout-CUFA7XJD.js");
   const { renderC4Context, renderC4Containers } = await import("./renderer-YDAVCRTP.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const c4Parsed = parseC4(content, effectivePalette);
+  const c4Parsed = parseC42(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;
@@ -2519,11 +2644,11 @@ async function exportC4(ctx) {
 }
 async function exportFlowchart(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseFlowchart } = await import("./flowchart-parser-GG7XBLQH.js");
+  const { parseFlowchart: parseFlowchart2 } = await import("./flowchart-parser-GG7XBLQH.js");
   const { layoutGraph } = await import("./layout-XUW444O5.js");
   const { renderFlowchart } = await import("./flowchart-renderer-THC6Y7EH.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const fcParsed = parseFlowchart(content, effectivePalette);
+  const fcParsed = parseFlowchart2(content, effectivePalette);
   if (fcParsed.error || fcParsed.nodes.length === 0) return "";
   const layout = layoutGraph(fcParsed);
   const container = createExportContainer(ctx.width, ctx.height);
@@ -2540,12 +2665,12 @@ async function exportFlowchart(ctx) {
 }
 async function exportInfra(ctx) {
   const { content, theme, palette, viewState } = ctx;
-  const { parseInfra } = await import("./parser-DGF3ZEO6.js");
+  const { parseInfra: parseInfra2 } = await import("./parser-DGF3ZEO6.js");
   const { computeInfra } = await import("./compute-JAP5E2E4.js");
   const { layoutInfra } = await import("./layout-SW3XWYKC.js");
   const { renderInfra, computeInfraLegendGroups } = await import("./renderer-SDUSBCJI.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const infraParsed = parseInfra(content);
+  const infraParsed = parseInfra2(content);
   if (infraParsed.error || infraParsed.nodes.length === 0) return "";
   const infraComputed = computeInfra(infraParsed);
   const infraLayout = layoutInfra(infraComputed);
@@ -2590,12 +2715,12 @@ async function exportInfra(ctx) {
 }
 async function exportPert(ctx) {
   const { content, theme, palette, viewState } = ctx;
-  const { parsePert } = await import("./parser-JXS4426S.js");
+  const { parsePert: parsePert2 } = await import("./parser-JXS4426S.js");
   const { analyzePert } = await import("./analyzer-R5UBTRO2.js");
   const { layoutPert } = await import("./layout-AM57TGN5.js");
   const { renderPert, measurePertAnalysisBlock } = await import("./renderer-RENDISO5.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const pertParsed = parsePert(content, { palette: effectivePalette });
+  const pertParsed = parsePert2(content, { palette: effectivePalette });
   if (pertParsed.error || pertParsed.activities.length === 0) return "";
   const pertResolved = analyzePert(pertParsed);
   const pertLayout = layoutPert(pertResolved);
@@ -2636,11 +2761,11 @@ async function exportPert(ctx) {
 }
 async function exportGantt(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseGantt } = await import("./parser-WUK6CP5X.js");
+  const { parseGantt: parseGantt2 } = await import("./parser-WUK6CP5X.js");
   const { calculateSchedule } = await import("./calculator-35YVW4QO.js");
-  const { renderGantt } = await import("./renderer-NX4YKWCJ.js");
+  const { renderGantt } = await import("./renderer-RNCYODNF.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const ganttParsed = parseGantt(content, effectivePalette);
+  const ganttParsed = parseGantt2(content, effectivePalette);
   const resolved = calculateSchedule(ganttParsed);
   if (resolved.tasks.length === 0) return "";
   const EXPORT_W = ctx.width;
@@ -2679,12 +2804,12 @@ async function exportGantt(ctx) {
 }
 async function exportState(ctx) {
   const { content, theme, palette, viewState } = ctx;
-  const { parseState } = await import("./state-parser-FE3RF6XY.js");
+  const { parseState: parseState2 } = await import("./state-parser-FE3RF6XY.js");
   const { layoutGraph } = await import("./layout-XUW444O5.js");
   const { renderState } = await import("./state-renderer-5IQ4OJUI.js");
   const { collapseStateGroups } = await import("./state-collapse-HCGD6IVJ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const stateParsed = parseState(content, effectivePalette);
+  const stateParsed = parseState2(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([
@@ -2718,10 +2843,10 @@ async function exportState(ctx) {
 }
 async function exportTechRadar(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseTechRadar } = await import("./parser-NOANDFJ4.js");
+  const { parseTechRadar: parseTechRadar2 } = await import("./parser-NOANDFJ4.js");
   const { renderTechRadarForExport } = await import("./renderer-A6ACVK4X.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const radarParsed = parseTechRadar(content);
+  const radarParsed = parseTechRadar2(content);
   if (radarParsed.error || radarParsed.quadrants.length === 0) return "";
   const RADAR_EXPORT_W = ctx.requestedWidth ?? 1300;
   const RADAR_EXPORT_H = ctx.requestedHeight ?? 1500;
@@ -2739,11 +2864,11 @@ async function exportTechRadar(ctx) {
 }
 async function exportJourneyMap(ctx) {
   const { content, theme, palette, exportMode } = ctx;
-  const { parseJourneyMap } = await import("./parser-C327BBE3.js");
+  const { parseJourneyMap: parseJourneyMap2 } = await import("./parser-C327BBE3.js");
   const { renderJourneyMap } = await import("./renderer-NHPKNNBD.js");
   const { layoutJourneyMap } = await import("./layout-SOPAVXIH.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const jmParsed = parseJourneyMap(content, effectivePalette);
+  const jmParsed = parseJourneyMap2(content, effectivePalette);
   if (jmParsed.error || jmParsed.phases.length === 0 && jmParsed.steps.length === 0)
     return "";
   const jmLayout = layoutJourneyMap(jmParsed, effectivePalette, {
@@ -2761,10 +2886,10 @@ async function exportJourneyMap(ctx) {
 }
 async function exportCycle(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseCycle } = await import("./parser-7OEE7QT6.js");
+  const { parseCycle: parseCycle2 } = await import("./parser-7OEE7QT6.js");
   const { renderCycleForExport } = await import("./renderer-4BIMRO4X.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const cycleParsed = parseCycle(content);
+  const cycleParsed = parseCycle2(content);
   if (cycleParsed.error || cycleParsed.nodes.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderCycleForExport(
@@ -2780,12 +2905,12 @@ async function exportCycle(ctx) {
 }
 async function exportMap(ctx) {
   const { content, theme, palette, options } = ctx;
-  const { parseMap } = await import("./parser-GEKPWSSK.js");
+  const { parseMap: parseMap2 } = await import("./parser-GEKPWSSK.js");
   const { resolveMap } = await import("./resolver-XSXE2TRX.js");
   const { renderMapForExport } = await import("./renderer-XRALFCIN.js");
   const { mapExportDimensions } = await import("./dimensions-6QAWEGIR.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const mapParsed = parseMap(content, effectivePalette);
+  const mapParsed = parseMap2(content, effectivePalette);
   const { data: mapData, reason } = await resolveMapDataSource(
     options?.mapData
   );
@@ -2816,10 +2941,10 @@ async function exportMap(ctx) {
 }
 async function exportPyramid(ctx) {
   const { content, theme, palette } = ctx;
-  const { parsePyramid } = await import("./parser-OVQTTTUJ.js");
+  const { parsePyramid: parsePyramid2 } = await import("./parser-OVQTTTUJ.js");
   const { renderPyramidForExport } = await import("./renderer-4BHOELCE.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const pyramidParsed = parsePyramid(content);
+  const pyramidParsed = parsePyramid2(content);
   if (pyramidParsed.error || pyramidParsed.layers.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderPyramidForExport(
@@ -2833,10 +2958,10 @@ async function exportPyramid(ctx) {
 }
 async function exportRing(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseRing } = await import("./parser-GZ3LVF72.js");
+  const { parseRing: parseRing2 } = await import("./parser-GZ3LVF72.js");
   const { renderRingForExport } = await import("./renderer-2OOPQ4CH.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const ringParsed = parseRing(content);
+  const ringParsed = parseRing2(content);
   if (ringParsed.error || ringParsed.layers.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderRingForExport(container, ringParsed, effectivePalette, ctx.isDark, {
@@ -2847,9 +2972,9 @@ async function exportRing(ctx) {
 }
 async function exportTreemap(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseTreemap } = await import("./parser-AN3MGHRL.js");
+  const { parseTreemap: parseTreemap2 } = await import("./parser-AN3MGHRL.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const treemapParsed = parseTreemap(content, effectivePalette);
+  const treemapParsed = parseTreemap2(content, effectivePalette);
   if (treemapParsed.error || treemapParsed.roots.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   const dims = { width: ctx.width, height: ctx.height };
@@ -2876,17 +3001,17 @@ async function exportTreemap(ctx) {
 }
 async function exportLiveLink(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseLiveLink } = await import("./parser-XYY5NHP4.js");
+  const { parseLiveLink: parseLiveLink2 } = await import("./parser-XYY5NHP4.js");
   const { renderLiveLinkCard } = await import("./renderer-YIZ7G4HU.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  return renderLiveLinkCard(parseLiveLink(content), effectivePalette, theme);
+  return renderLiveLinkCard(parseLiveLink2(content), effectivePalette, theme);
 }
 async function exportBlock(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseBlock } = await import("./parser-5655XSOR.js");
+  const { parseBlock: parseBlock2 } = await import("./parser-5655XSOR.js");
   const { renderBlockForExport } = await import("./renderer-KVAQE7PQ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const blockParsed = parseBlock(content, effectivePalette);
+  const blockParsed = parseBlock2(content, effectivePalette);
   if (blockParsed.error || blockParsed.top.rows.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderBlockForExport(container, blockParsed, effectivePalette, ctx.isDark, {
@@ -2897,10 +3022,10 @@ async function exportBlock(ctx) {
 }
 async function exportGoal(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseGoal } = await import("./parser-SA3RAJFS.js");
+  const { parseGoal: parseGoal2 } = await import("./parser-SA3RAJFS.js");
   const { renderGoalForExport } = await import("./renderer-222OTVQV.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseGoal(content, effectivePalette);
+  const parsed = parseGoal2(content, effectivePalette);
   if (parsed.error) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderGoalForExport(container, parsed, effectivePalette, ctx.isDark, {
@@ -2911,10 +3036,10 @@ async function exportGoal(ctx) {
 }
 async function exportCountdown(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseCountdown } = await import("./parser-LGS65QPN.js");
+  const { parseCountdown: parseCountdown2 } = await import("./parser-LGS65QPN.js");
   const { renderCountdownForExport } = await import("./renderer-DCFQDBGJ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseCountdown(content, effectivePalette);
+  const parsed = parseCountdown2(content, effectivePalette);
   if (parsed.error) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderCountdownForExport(container, parsed, effectivePalette, ctx.isDark, {
@@ -2925,10 +3050,10 @@ async function exportCountdown(ctx) {
 }
 async function exportClock(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseClock } = await import("./parser-256EIWB2.js");
+  const { parseClock: parseClock2 } = await import("./parser-256EIWB2.js");
   const { renderClockForExport } = await import("./renderer-PQYO2HCE.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseClock(content, effectivePalette);
+  const parsed = parseClock2(content, effectivePalette);
   if (parsed.error) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderClockForExport(container, parsed, effectivePalette, ctx.isDark, {
@@ -2939,10 +3064,10 @@ async function exportClock(ctx) {
 }
 async function exportBracket(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseBracket } = await import("./parser-DHSFIUPU.js");
-  const { renderBracketForExport, bracketExportDimensions } = await import("./renderer-ELYPDPNF.js");
+  const { parseBracket: parseBracket2 } = await import("./parser-DHSFIUPU.js");
+  const { renderBracketForExport, bracketExportDimensions } = await import("./renderer-XUPLAO4B.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const parsed = parseBracket(content, effectivePalette);
+  const parsed = parseBracket2(content, effectivePalette);
   if (parsed.error) return "";
   const { width, height } = bracketExportDimensions(parsed, effectivePalette);
   const container = createExportContainer(width, height);
@@ -2954,10 +3079,10 @@ async function exportBracket(ctx) {
 }
 async function exportRaci(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseRaci } = await import("./parser-LANGKWRG.js");
+  const { parseRaci: parseRaci2 } = await import("./parser-LANGKWRG.js");
   const { renderRaciForExport } = await import("./renderer-RMGN3Q7D.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
-  const raciParsed = parseRaci(content, effectivePalette);
+  const raciParsed = parseRaci2(content, effectivePalette);
   if (raciParsed.error) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   renderRaciForExport(container, raciParsed, effectivePalette, ctx.isDark, {
@@ -3087,9 +3212,9 @@ async function exportVisualization(ctx) {
   const effectivePalette = await resolveExportPalette(theme, palette);
   const isDark = ctx.isDark;
   const container = createExportContainer(ctx.width, ctx.height);
-  const { parseSequenceDgmo } = await import("./parser-PVIWHVGY.js");
+  const { parseSequenceDgmo: parseSequenceDgmo2 } = await import("./parser-PVIWHVGY.js");
   const { renderSequenceDiagram } = await import("./renderer-2KVQGGTT.js");
-  const seqParsed = parseSequenceDgmo(content, effectivePalette);
+  const seqParsed = parseSequenceDgmo2(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;
@@ -3697,10 +3822,729 @@ function applyRootA11y(svg, chartType) {
   );
   return svg.replace(rootTag, withA11y);
 }
+function applyRootDesc(svg, summary) {
+  if (!summary) return svg;
+  const m = svg.match(/<svg\b[^>]*>/);
+  if (!m) return svg;
+  const rootTag = m[0];
+  if (/\baria-describedby=/.test(rootTag)) return svg;
+  const id = `dgmo-desc-${fnv1a(summary)}`;
+  const withDesc = rootTag.replace(/^<svg\b/, `<svg aria-describedby="${id}"`) + `<desc id="${id}">${escapeAttr(summary)}</desc>`;
+  return svg.replace(rootTag, () => withDesc);
+}
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
 function escapeAttr(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 
+// src/utils/diagram-summary.ts
+var MAX_NAMES = 5;
+function listNames(names) {
+  const shown = names.length > MAX_NAMES + 1 ? names.slice(0, MAX_NAMES) : names.slice();
+  const rest = names.length - shown.length;
+  if (rest > 0) return `${shown.join(", ")} and ${rest} more`;
+  if (shown.length <= 1) return shown.join("");
+  return `${shown.slice(0, -1).join(", ")} and ${shown[shown.length - 1]}`;
+}
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function chartNoun(type) {
+  const words = type.replace(/-/g, " ");
+  return `${words.charAt(0).toUpperCase()}${words.slice(1)} chart`;
+}
+function allValues(parsed) {
+  return parsed.data.flatMap((d) => [d.value, ...d.extraValues ?? []]);
+}
+function seriesNames(parsed) {
+  if (parsed.seriesNames && parsed.seriesNames.length > 0) {
+    return parsed.seriesNames;
+  }
+  return parsed.series ? [parsed.series] : [];
+}
+function seriesPhrase(parsed) {
+  const names = seriesNames(parsed);
+  if (names.length > 1) {
+    return ` of ${plural(names.length, "series", "series")}, ${listNames(names)},`;
+  }
+  const one = names[0] ?? parsed.ylabel;
+  return one ? ` of ${one}` : "";
+}
+function rangePhrase(values) {
+  const lo = Math.min(...values);
+  const hi = Math.max(...values);
+  return lo === hi ? `every value is ${compactNumber(lo)}` : `values range from ${compactNumber(lo)} to ${compactNumber(hi)}`;
+}
+function summarizeChart(content) {
+  const parsed = parseChart(content);
+  if (parsed.error) return null;
+  const noun = chartNoun(parsed.type);
+  const points = parsed.data;
+  if (points.length === 0) return `${noun} with no data.`;
+  switch (parsed.type) {
+    case "pie":
+    case "polar-area": {
+      const total = points.reduce((sum, d) => sum + d.value, 0);
+      const parts = plural(
+        points.length,
+        parsed.type === "pie" ? "slice" : "wedge",
+        parsed.type === "pie" ? "slices" : "wedges"
+      );
+      const largest = points.reduce((a, b) => b.value > a.value ? b : a);
+      if (total <= 0) return `${noun} with ${parts}, all zero.`;
+      const pct = Math.round(largest.value / total * 100);
+      return `${noun} with ${parts} totalling ${compactNumber(total)}; the largest is ${largest.label} at ${pct}%.`;
+    }
+    case "radar":
+      return `${noun}${seriesPhrase(parsed)} across ${plural(points.length, "axis", "axes")}; ${rangePhrase(allValues(parsed))}.`;
+    case "line": {
+      const first = points[0].label;
+      const last = points[points.length - 1].label;
+      const span = points.length === 1 ? `at ${first}` : `from ${first} to ${last}`;
+      return `${noun}${seriesPhrase(parsed)} over ${plural(points.length, "point", "points")}, ${span}; ${rangePhrase(allValues(parsed))}.`;
+    }
+    case "bar": {
+      const head = `${noun}${seriesPhrase(parsed)} for ${plural(points.length, "category", "categories")}`;
+      if (seriesNames(parsed).length > 1 || points.length === 1) {
+        return `${head}; ${rangePhrase(allValues(parsed))}.`;
+      }
+      const lo = points.reduce((a, b) => b.value < a.value ? b : a);
+      const hi = points.reduce((a, b) => b.value > a.value ? b : a);
+      return `${head}, from ${lo.label} at ${compactNumber(lo.value)} to ${hi.label} at ${compactNumber(hi.value)}.`;
+    }
+  }
+}
+function summarizeSequence(content) {
+  const parsed = parseSequenceDgmo(content);
+  if (parsed.error) return null;
+  const names = parsed.participants.map((p) => p.label);
+  if (names.length === 0) return "Sequence diagram with no participants.";
+  const messages = parsed.messages.length;
+  const exchange = messages === 0 ? "with no messages" : `exchanging ${plural(messages, "message", "messages")}`;
+  return `Sequence diagram of ${plural(names.length, "participant", "participants")}, ${listNames(names)}, ${exchange}.`;
+}
+function countPeople(nodes) {
+  return nodes.reduce(
+    (n, node) => n + (node.isContainer ? 0 : 1) + countPeople(node.children),
+    0
+  );
+}
+function summarizeOrg(content) {
+  const parsed = parseOrg(content);
+  if (parsed.error) return null;
+  const people = countPeople(parsed.roots);
+  if (parsed.roots.length === 0) return "Org chart with no one in it.";
+  const head = `Org chart of ${plural(people, "person", "people")}`;
+  if (parsed.roots.length === 1) {
+    const root = parsed.roots[0];
+    const role = root.metadata["role"];
+    return `${head}, headed by ${root.label}${role ? ` (${role})` : ""}.`;
+  }
+  const tops = parsed.roots.map((r) => r.label);
+  return `${head} under ${plural(tops.length, "top-level entry", "top-level entries")}, ${listNames(tops)}.`;
+}
+function countTree(nodes) {
+  return nodes.reduce(
+    (n, node) => n + 1 + countTree(node.children),
+    0
+  );
+}
+function namedCount(names, one, many) {
+  return names.length === 0 ? `no ${many}` : `${plural(names.length, one, many)}, ${listNames(names)}`;
+}
+function summarizeFlowchart(content) {
+  const parsed = parseFlowchart(content);
+  if (parsed.error) return null;
+  if (parsed.nodes.length === 0) return "Flowchart with no steps.";
+  const decisions = parsed.nodes.filter((n) => n.shape === "decision").length;
+  const steps = `${plural(parsed.nodes.length, "step", "steps")}${decisions > 0 ? ` (${plural(decisions, "decision", "decisions")})` : ""}`;
+  const entered = new Set(parsed.edges.map((e) => e.target));
+  const starts = parsed.nodes.filter((n) => !entered.has(n.id)).map((n) => n.label);
+  const start = starts.length > 0 ? `, starting at ${listNames(starts)}` : "";
+  return `Flowchart of ${steps} and ${plural(parsed.edges.length, "connection", "connections")}${start}.`;
+}
+function summarizeState(content) {
+  const parsed = parseState(content);
+  if (parsed.error) return null;
+  const states = parsed.nodes.filter((n) => n.shape !== "pseudostate").map((n) => n.label);
+  return `State diagram of ${namedCount(states, "state", "states")}, with ${plural(parsed.edges.length, "transition", "transitions")}.`;
+}
+function summarizeClass(content) {
+  const parsed = parseClassDiagram(content);
+  if (parsed.error) return null;
+  const names = parsed.classes.map((c) => c.name);
+  return `Class diagram of ${namedCount(names, "class", "classes")}, with ${plural(parsed.relationships.length, "relationship", "relationships")}.`;
+}
+function summarizeEr(content) {
+  const parsed = parseERDiagram(content);
+  if (parsed.error) return null;
+  const names = parsed.tables.map((t) => t.name);
+  return `Entity-relationship diagram of ${namedCount(names, "table", "tables")}, with ${plural(parsed.relationships.length, "relationship", "relationships")}.`;
+}
+function summarizeKanban(content) {
+  const parsed = parseKanban(content);
+  if (parsed.error) return null;
+  const cards = parsed.columns.reduce((n, c) => n + c.cards.length, 0);
+  const columns = parsed.columns.map((c) => c.name);
+  return `Kanban board with ${plural(cards, "card", "cards")} across ${namedCount(columns, "column", "columns")}.`;
+}
+function c4Counts(elements) {
+  return elements.reduce(
+    (acc, el) => {
+      const below = c4Counts(el.children);
+      return {
+        elements: acc.elements + 1 + below.elements,
+        relationships: acc.relationships + el.relationships.length + below.relationships
+      };
+    },
+    { elements: 0, relationships: 0 }
+  );
+}
+function summarizeC4(content) {
+  const parsed = parseC4(content);
+  if (parsed.error) return null;
+  const counts = c4Counts(parsed.elements);
+  const relationships = counts.relationships + parsed.relationships.length;
+  const top = parsed.elements.map((e) => e.name);
+  const nested = counts.elements - top.length;
+  return `C4 diagram of ${namedCount(top, "top-level element", "top-level elements")}${nested > 0 ? `, holding ${nested} more` : ""}, with ${plural(relationships, "relationship", "relationships")}.`;
+}
+function countPages(nodes) {
+  return nodes.reduce(
+    (n, node) => n + (node.isContainer ? 0 : 1) + countPages(node.children),
+    0
+  );
+}
+function summarizeSitemap(content) {
+  const parsed = parseSitemap(content);
+  if (parsed.error) return null;
+  const tops = parsed.roots.map((r) => r.label);
+  return `Sitemap of ${plural(countPages(parsed.roots), "page", "pages")} under ${namedCount(tops, "top-level entry", "top-level entries")}.`;
+}
+function summarizeInfra(content) {
+  const parsed = parseInfra(content);
+  if (parsed.error) return null;
+  const names = parsed.nodes.map((n) => n.label);
+  return `Infrastructure diagram of ${namedCount(names, "component", "components")}, with ${plural(parsed.edges.length, "connection", "connections")}.`;
+}
+function ganttTasks(nodes, acc) {
+  for (const node of nodes) {
+    if (node.kind === "task") acc.tasks.push(node.label);
+    else {
+      if (node.kind === "group") acc.groups += 1;
+      ganttTasks(node.children, acc);
+    }
+  }
+  return acc;
+}
+function summarizeGantt(content) {
+  const parsed = parseGantt(content);
+  if (parsed.error) return null;
+  const { tasks, groups } = ganttTasks(parsed.nodes, { tasks: [], groups: 0 });
+  return `Gantt chart of ${namedCount(tasks, "task", "tasks")}${groups > 0 ? `, in ${plural(groups, "group", "groups")}` : ""}.`;
+}
+function summarizePert(content) {
+  const parsed = parsePert(content);
+  if (parsed.error) return null;
+  const names = parsed.activities.map((a) => a.name);
+  return `PERT chart of ${namedCount(names, "activity", "activities")}, with ${plural(parsed.edges.length, "dependency", "dependencies")}.`;
+}
+function summarizeBoxesAndLines(content) {
+  const parsed = parseBoxesAndLines(content);
+  if (parsed.error) return null;
+  const names = parsed.nodes.map((n) => n.label);
+  return `Boxes and lines diagram of ${namedCount(names, "box", "boxes")}, with ${plural(parsed.edges.length, "line", "lines")}.`;
+}
+function summarizeSketch(content) {
+  const parsed = parseSketch(content);
+  if (parsed.error) return null;
+  const names = parsed.nodes.map((n) => n.label);
+  return `Sketch of ${namedCount(names, "shape", "shapes")}, with ${plural(parsed.edges.length, "connection", "connections")}.`;
+}
+function summarizeSwimlane(content) {
+  const parsed = parseSwimlane(content);
+  if (parsed.error) return null;
+  const lanes = parsed.lanes.map((l) => l.label);
+  return `Swimlane diagram of ${plural(parsed.nodes.length, "step", "steps")} across ${namedCount(lanes, "lane", "lanes")}, with ${plural(parsed.edges.length, "connection", "connections")}.`;
+}
+function summarizeFamily(content) {
+  const parsed = parseFamily(content);
+  if (parsed.error) return null;
+  return `Family tree of ${plural(parsed.persons.size, "person", "people")} in ${plural(parsed.unions.length, "union", "unions")}.`;
+}
+function summarizeVersionControl(content) {
+  const parsed = parseVersionControl(content);
+  if (parsed.error) return null;
+  const branches = parsed.branches.map((b) => b.name);
+  return `Version control graph of ${plural(parsed.nodes.length, "commit", "commits")} on ${namedCount(branches, "branch", "branches")}.`;
+}
+function mindmapCounts(nodes) {
+  return nodes.reduce(
+    (acc, node) => {
+      if (node.collapsed) {
+        return {
+          shown: acc.shown + 1,
+          folded: acc.folded + countTree(node.children)
+        };
+      }
+      const below = mindmapCounts(node.children);
+      return {
+        shown: acc.shown + 1 + below.shown,
+        folded: acc.folded + below.folded
+      };
+    },
+    { shown: 0, folded: 0 }
+  );
+}
+function summarizeMindmap(content) {
+  const parsed = parseMindmap(content);
+  if (parsed.error) return null;
+  if (parsed.roots.length === 0) return "Mind map with no ideas.";
+  const { shown, folded } = mindmapCounts(parsed.roots);
+  const ideas = shown - parsed.roots.length;
+  const centres = parsed.roots.map((r) => r.label);
+  const hidden = folded > 0 ? `, with ${folded} more folded away` : "";
+  return `Mind map of ${plural(ideas, "idea", "ideas")} around ${listNames(centres)}${hidden}.`;
+}
+function summarizeWireframe(content) {
+  const parsed = parseWireframe(content);
+  if (parsed.error) return null;
+  const elements = countTree(parsed.roots);
+  const tops = parsed.roots.map((r) => r.label).filter((l) => l.length > 0);
+  const modals = parsed.modals.length > 0 ? `, plus ${plural(parsed.modals.length, "modal", "modals")}` : "";
+  const noun = `${parsed.formFactor.charAt(0).toUpperCase()}${parsed.formFactor.slice(1)} wireframe`;
+  return `${noun} of ${plural(elements, "element", "elements")}${tops.length > 0 ? `, in ${listNames(tops)}` : ""}${modals}.`;
+}
+function summarizeJourneyMap(content) {
+  const parsed = parseJourneyMap(content);
+  if (parsed.error) return null;
+  const steps = parsed.steps.length + parsed.phases.reduce((n, p) => n + p.steps.length, 0);
+  const phases = parsed.phases.map((p) => p.name);
+  const who = parsed.persona ? ` for ${parsed.persona.name}` : "";
+  return `Journey map${who} of ${plural(steps, "step", "steps")}${phases.length > 0 ? ` across ${namedCount(phases, "phase", "phases")}` : ""}.`;
+}
+function summarizeRaci(content) {
+  const parsed = parseRaci(content);
+  if (parsed.error) return null;
+  const tasks = parsed.tasksWithoutPhase.length + parsed.phases.reduce((n, p) => n + p.tasks.length, 0);
+  return `${parsed.variant.toUpperCase()} matrix of ${plural(tasks, "task", "tasks")} across ${namedCount(parsed.roleDisplayNames, "role", "roles")}.`;
+}
+function summarizeBody(content) {
+  const parsed = parseBody(content);
+  if (parsed.error) return null;
+  const parts = parsed.parts.map((p) => p.name);
+  return `Body diagram marking ${namedCount(parts, "part", "parts")}.`;
+}
+function summarizeBracket(content) {
+  const parsed = parseBracket(content);
+  if (parsed.error) return null;
+  const layout = layoutBracket(parsed);
+  const competitors = parsed.seeds.length > 0 ? parsed.seeds.length : new Set(
+    layout.matches.flatMap(
+      (m) => [m.top, m.bot].filter((n) => n !== null)
+    )
+  ).size;
+  const decided = layout.matches.filter((m) => m.winner !== null).length;
+  const champion = layout.champion ? `; ${layout.champion} won` : "";
+  return `Tournament bracket of ${plural(competitors, "competitor", "competitors")} in ${plural(layout.matches.length, "match", "matches")}, ${decided} decided${champion}.`;
+}
+function summarizeLiveLink(content) {
+  const parsed = parseLiveLink(content);
+  if (parsed.error || !parsed.id) return null;
+  return `Card linking to the shared diagram ${parsed.title ?? parsed.id}.`;
+}
+function axisRange(name, values) {
+  const lo = Math.min(...values);
+  const hi = Math.max(...values);
+  return lo === hi ? `${name} is ${compactNumber(lo)} throughout` : `${name} ranges from ${compactNumber(lo)} to ${compactNumber(hi)}`;
+}
+function summarizeScatter(content) {
+  const parsed = parseScatter(content);
+  if (parsed.error) return null;
+  const points = parsed.scatterPoints ?? [];
+  if (points.length === 0) return "Scatter chart with no points.";
+  const categories = [
+    ...new Set(points.map((p) => p.category).filter((c) => !!c))
+  ];
+  const groups = categories.length > 0 ? ` in ${namedCount(categories, "category", "categories")}` : "";
+  const x = axisRange(
+    parsed.xlabel ?? "x",
+    points.map((p) => p.x)
+  );
+  const y = axisRange(
+    parsed.ylabel ?? "y",
+    points.map((p) => p.y)
+  );
+  return `Scatter chart of ${plural(points.length, "point", "points")}${groups}; ${x} and ${y}.`;
+}
+function summarizeSankey(content) {
+  const parsed = parseSankey(content);
+  if (parsed.error) return null;
+  const links = parsed.links ?? [];
+  if (links.length === 0) return "Sankey diagram with no flows.";
+  const nodes = new Set(links.flatMap((l) => [l.source, l.target]));
+  const entered = new Set(links.map((l) => l.target));
+  const sources = [...nodes].filter((n) => !entered.has(n));
+  const from = sources.length > 0 ? `, flowing from ${listNames(sources)}` : "";
+  return `Sankey diagram of ${plural(links.length, "flow", "flows")} between ${plural(nodes.size, "node", "nodes")}${from}.`;
+}
+function summarizeHeatmap(content) {
+  const parsed = parseHeatmap(content);
+  if (parsed.error) return null;
+  const rows = parsed.heatmapRows ?? [];
+  const columns = parsed.columns ?? [];
+  if (rows.length === 0) return "Heatmap with no rows.";
+  let hot = { row: rows[0].label, col: 0, value: -Infinity };
+  for (const row of rows) {
+    row.values.forEach((value, col) => {
+      if (value > hot.value) hot = { row: row.label, col, value };
+    });
+  }
+  const head = `Heatmap of ${plural(rows.length, "row", "rows")} by ${plural(columns.length, "column", "columns")}`;
+  if (hot.value === -Infinity) return `${head}, with no values.`;
+  const where = columns[hot.col] ? `${hot.row}, ${columns[hot.col]}` : hot.row;
+  return `${head}; ${rangePhrase(rows.flatMap((r) => r.values))}, highest at ${where}.`;
+}
+function summarizeFunnel(content) {
+  const parsed = parseFunnel(content);
+  if (parsed.error) return null;
+  const stages = parsed.data;
+  if (stages.length === 0) return "Funnel chart with no stages.";
+  const first = stages[0];
+  const last = stages[stages.length - 1];
+  if (stages.length === 1) {
+    return `Funnel chart of 1 stage, ${first.label} at ${compactNumber(first.value)}.`;
+  }
+  const kept = first.value > 0 ? ` (${Math.round(last.value / first.value * 100)}% of the first)` : "";
+  return `Funnel chart of ${plural(stages.length, "stage", "stages")}, from ${first.label} at ${compactNumber(first.value)} to ${last.label} at ${compactNumber(last.value)}${kept}.`;
+}
+function summarizeFunction(content) {
+  const parsed = parseFunctionChart(content);
+  if (parsed.error) return null;
+  const names = (parsed.functions ?? []).map((f) => f.name);
+  const range = parsed.xRange ? ` for x from ${compactNumber(parsed.xRange.min)} to ${compactNumber(parsed.xRange.max)}` : "";
+  return `Function plot of ${namedCount(names, "function", "functions")}${range && names.length > 0 ? `,${range}` : range}.`;
+}
+function dateSpan(dates, toValue) {
+  const ranked = dates.map((d) => ({ d, t: toValue(d) })).filter(({ t }) => Number.isFinite(t)).sort((a, b) => a.t - b.t);
+  if (ranked.length === 0) return "";
+  const first = ranked[0];
+  const last = ranked[ranked.length - 1];
+  return first.t === last.t ? ` on ${first.d}` : ` from ${first.d} to ${last.d}`;
+}
+function summarizeTimeline(content) {
+  const parsed = parseTimeline(content);
+  if (parsed.error) return null;
+  const events = parsed.timelineEvents;
+  if (events.length === 0) return "Timeline with no events.";
+  const dates = events.flatMap(
+    (e) => e.endDate ? [e.date, e.endDate] : [e.date]
+  );
+  const groups = parsed.timelineGroups.map((g) => g.name);
+  const span = dateSpan(dates, parseTimelineDate);
+  const head = groups.length > 0 ? `Timeline of ${plural(events.length, "event", "events")} in ${namedCount(groups, "group", "groups")}${span ? `,${span}` : ""}` : `Timeline of ${plural(events.length, "event", "events")}${span}`;
+  const marks = [
+    parsed.timelineEras.length > 0 ? plural(parsed.timelineEras.length, "era", "eras") : null,
+    parsed.timelineMarkers.length > 0 ? plural(parsed.timelineMarkers.length, "marker", "markers") : null
+  ].filter((x) => x !== null);
+  return `${head}${marks.length > 0 ? `, marking ${marks.join(" and ")}` : ""}.`;
+}
+function summarizeEventLine(content) {
+  const parsed = parseEventLine(content);
+  if (parsed.error) return null;
+  const events = parsed.events;
+  if (events.length === 0) return "Event line with no events.";
+  const folded = new Set(
+    parsed.eras.filter((e) => e.collapsed).map((e) => e.name)
+  );
+  const hidden = events.filter((e) => e.era !== null && folded.has(e.era));
+  const shown = events.length - hidden.length;
+  const byValue = new Map(
+    events.filter((e) => e.date !== null && !e.future && e.dateValue !== null).map((e) => [e.date, e.dateValue])
+  );
+  const span = dateSpan([...byValue.keys()], (d) => byValue.get(d));
+  const eras = parsed.eras.length > 0 ? `, in ${plural(parsed.eras.length, "era", "eras")}` : "";
+  const away = hidden.length > 0 ? `, with ${hidden.length} more folded away` : "";
+  return `Event line of ${plural(shown, "event", "events")}${span}${eras}${away}.`;
+}
+function summarizeTechRadar(content) {
+  const parsed = parseTechRadar(content);
+  if (parsed.error) return null;
+  const blips = parsed.quadrants.reduce((n, q) => n + q.blips.length, 0);
+  const quadrants = parsed.quadrants.map((q) => q.name);
+  const rings = parsed.rings.map((r) => r.name);
+  return `Tech radar of ${plural(blips, "entry", "entries")} across ${namedCount(quadrants, "quadrant", "quadrants")}, in ${namedCount(rings, "ring", "rings")}.`;
+}
+function summarizeCycle(content) {
+  const parsed = parseCycle(content);
+  if (parsed.error) return null;
+  const stages = parsed.nodes.map((n) => n.label);
+  return `Cycle of ${namedCount(stages, "stage", "stages")}.`;
+}
+function summarizePyramid(content) {
+  const parsed = parsePyramid(content);
+  if (parsed.error) return null;
+  const layers = parsed.layers.map((l) => l.label);
+  const noun = parsed.inverted ? "Inverted pyramid" : "Pyramid";
+  if (layers.length === 0) return `${noun} with no layers.`;
+  return `${noun} of ${plural(layers.length, "layer", "layers")}, top to bottom: ${listNames(layers)}.`;
+}
+function summarizeRing(content) {
+  const parsed = parseRing(content);
+  if (parsed.error) return null;
+  const layers = parsed.layers.map((l) => l.label);
+  if (layers.length === 0) return "Ring diagram with no layers.";
+  return `Ring diagram of ${plural(layers.length, "layer", "layers")}, centre outward: ${listNames(layers)}.`;
+}
+function treemapLeaves(nodes) {
+  return nodes.flatMap(
+    (n) => n.children.length > 0 ? treemapLeaves(n.children) : [n]
+  );
+}
+function summarizeTreemap(content) {
+  const parsed = parseTreemap(content);
+  if (parsed.error) return null;
+  const leaves = treemapLeaves(parsed.roots);
+  if (leaves.length === 0) return "Treemap with no items.";
+  const total = leaves.reduce((sum, n) => sum + (n.value ?? 0), 0);
+  const largest = leaves.reduce(
+    (a, b) => (b.value ?? 0) > (a.value ?? 0) ? b : a
+  );
+  const groups = parsed.roots.every((r) => r.children.length > 0) ? parsed.roots : [];
+  const head = groups.length > 0 ? `Treemap of ${plural(leaves.length, "item", "items")} in ${namedCount(
+    groups.map((g) => g.label),
+    "group",
+    "groups"
+  )}, totalling ${compactNumber(total)}` : `Treemap of ${plural(leaves.length, "item", "items")} totalling ${compactNumber(total)}`;
+  return `${head}; the largest is ${largest.label} at ${compactNumber(largest.value ?? 0)}.`;
+}
+function blockCounts(grid) {
+  let shown = 0;
+  let folded = 0;
+  for (const cell of grid.rows.flat()) {
+    if (!isBlockNode(cell)) continue;
+    shown += 1;
+    if (!cell.grid) continue;
+    const inner = blockCounts(cell.grid);
+    if (cell.collapsed) folded += inner.shown + inner.folded;
+    else {
+      shown += inner.shown;
+      folded += inner.folded;
+    }
+  }
+  return { shown, folded };
+}
+function summarizeBlock(content) {
+  const parsed = parseBlock(content);
+  if (parsed.error) return null;
+  const { shown, folded } = blockCounts(parsed.top);
+  if (shown === 0) return "Block diagram with no blocks.";
+  const tops = parsed.top.rows.flat().filter(isBlockNode).map((b) => b.label);
+  const away = folded > 0 ? `, with ${folded} more folded away` : "";
+  return `Block diagram of ${plural(shown, "block", "blocks")}, in ${listNames(tops)}${away}.`;
+}
+function summarizeGoal(content) {
+  const parsed = parseGoal(content);
+  if (parsed.error) return null;
+  const now = compactNumber(parsed.now);
+  if (!parsed.hasTarget) return `Progress of ${now}, with no target set.`;
+  const pct = Math.round(parsed.now / parsed.target * 100);
+  return `Progress toward a target of ${compactNumber(parsed.target)}: ${now} so far, ${pct}%.`;
+}
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+var ORDINALS = ["first", "second", "third", "fourth", "fifth"];
+function cadencePhrase(rule) {
+  const weekday = WEEKDAYS[rule.weekday ?? -1] ?? "the same day";
+  switch (rule.kind) {
+    case "month-day":
+      return `every year on ${MONTHS[rule.month ?? -1] ?? "the same date"} ${rule.day ?? ""}`.trimEnd();
+    case "nth-weekday":
+      return `every month on the ${ORDINALS[(rule.nth ?? 0) - 1] ?? "same"} ${weekday}`;
+    case "last-weekday":
+      return `every month on the last ${weekday}`;
+    case "weekly":
+      return `every week on ${weekday}`;
+    case "interval": {
+      const n = rule.intervalN ?? 1;
+      const unit = rule.intervalUnit ?? "day";
+      return n === 1 ? `every ${unit}` : `every ${n} ${unit}s`;
+    }
+  }
+}
+function summarizeCountdown(content) {
+  const parsed = parseCountdown(content);
+  if (parsed.error) return null;
+  if (parsed.rule)
+    return `Countdown to an event that recurs ${cadencePhrase(parsed.rule)}.`;
+  return parsed.target ? `Countdown to ${parsed.target}.` : "Countdown with no date set.";
+}
+function summarizeClock(content) {
+  const parsed = parseClock(content);
+  if (parsed.error) return null;
+  const places = parsed.entries.map((e) => e.label);
+  return `World clock of ${namedCount(places, "place", "places")}.`;
+}
+function poiName(pos) {
+  return pos.kind === "name" ? pos.name : `${pos.lat}, ${pos.lon}`;
+}
+function summarizeMap(content) {
+  const parsed = parseMap(content);
+  if (parsed.error) return null;
+  const parts = [];
+  if (parsed.regions.length > 0) {
+    parts.push(
+      namedCount(
+        parsed.regions.map((r) => r.name),
+        "region",
+        "regions"
+      )
+    );
+  }
+  if (parsed.pois.length > 0) {
+    const names = parsed.pois.map((p) => p.label ?? poiName(p.pos));
+    parts.push(namedCount(names, "marked place", "marked places"));
+  }
+  for (const route of parsed.routes) {
+    const from = route.originLabel ?? poiName(route.origin);
+    parts.push(
+      `a route of ${plural(route.legs.length, "leg", "legs")} from ${from}`
+    );
+  }
+  if (parsed.edges.length > 0) {
+    parts.push(plural(parsed.edges.length, "connection", "connections"));
+  }
+  if (parts.length === 0) return "Map with nothing marked on it.";
+  return `Map showing ${parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join("; ")}; and ${parts[parts.length - 1]}`}.`;
+}
+function summarizeQuadrant(content) {
+  const parsed = parseQuadrant(content);
+  if (parsed.error) return null;
+  const items = plural(parsed.quadrantPoints.length, "item", "items");
+  const { topLeft, topRight, bottomLeft, bottomRight } = parsed.quadrantLabels;
+  const names = [topLeft, topRight, bottomLeft, bottomRight].filter((q) => q !== null).map((q) => q.text);
+  return names.length > 0 ? `Quadrant chart of ${items} across ${listNames(names)}.` : `Quadrant chart of ${items}.`;
+}
+function summarizeVenn(content) {
+  const parsed = parseVenn(content);
+  if (parsed.error) return null;
+  const sets = parsed.vennSets.map((s) => s.name);
+  const named = parsed.vennOverlaps.filter((o) => o.label).length;
+  const overlaps = named > 0 ? `, with ${plural(named, "named overlap", "named overlaps")}` : "";
+  return `Venn diagram of ${namedCount(sets, "set", "sets")}${overlaps}.`;
+}
+function summarizeSlope(content) {
+  const parsed = parseSlope(content);
+  if (parsed.error) return null;
+  const periods = parsed.periods;
+  const span = periods.length > 1 ? `, from ${periods[0]} to ${periods[periods.length - 1]}` : "";
+  return `Slope chart of ${plural(parsed.data.length, "item", "items")} across ${plural(periods.length, "period", "periods")}${span}.`;
+}
+function summarizeArc(content) {
+  const parsed = parseArc(content);
+  if (parsed.error) return null;
+  const nodes = new Set(parsed.links.flatMap((l) => [l.source, l.target]));
+  const noun = parsed.layout === "chord" ? "Chord diagram" : "Arc diagram";
+  const groups = parsed.arcNodeGroups.map((g) => g.name);
+  const inGroups = groups.length > 0 ? ` in ${namedCount(groups, "group", "groups")}` : "";
+  return `${noun} of ${plural(parsed.links.length, "link", "links")} between ${plural(nodes.size, "node", "nodes")}${inGroups}.`;
+}
+var TOP_WORDS = 3;
+function summarizeWordcloud(content) {
+  const parsed = parseWordcloud(content);
+  if (parsed.error) return null;
+  const words = parsed.words;
+  if (words.length === 0) return "Word cloud with no words.";
+  const top = [...words].sort((a, b) => b.weight - a.weight).slice(0, TOP_WORDS).map((w) => w.text);
+  return `Word cloud of ${plural(words.length, "word", "words")}; the largest ${top.length === 1 ? "is" : "are"} ${listNames(top)}.`;
+}
+var SUMMARIZERS = {
+  sequence: summarizeSequence,
+  org: summarizeOrg,
+  flowchart: summarizeFlowchart,
+  state: summarizeState,
+  class: summarizeClass,
+  er: summarizeEr,
+  kanban: summarizeKanban,
+  c4: summarizeC4,
+  sitemap: summarizeSitemap,
+  infra: summarizeInfra,
+  gantt: summarizeGantt,
+  pert: summarizePert,
+  "boxes-and-lines": summarizeBoxesAndLines,
+  sketch: summarizeSketch,
+  swimlane: summarizeSwimlane,
+  family: summarizeFamily,
+  "version-control": summarizeVersionControl,
+  mindmap: summarizeMindmap,
+  wireframe: summarizeWireframe,
+  "journey-map": summarizeJourneyMap,
+  raci: summarizeRaci,
+  body: summarizeBody,
+  bracket: summarizeBracket,
+  "live-link": summarizeLiveLink,
+  bar: summarizeChart,
+  line: summarizeChart,
+  pie: summarizeChart,
+  radar: summarizeChart,
+  "polar-area": summarizeChart,
+  scatter: summarizeScatter,
+  sankey: summarizeSankey,
+  heatmap: summarizeHeatmap,
+  funnel: summarizeFunnel,
+  function: summarizeFunction,
+  timeline: summarizeTimeline,
+  "event-line": summarizeEventLine,
+  "tech-radar": summarizeTechRadar,
+  cycle: summarizeCycle,
+  pyramid: summarizePyramid,
+  ring: summarizeRing,
+  treemap: summarizeTreemap,
+  block: summarizeBlock,
+  goal: summarizeGoal,
+  countdown: summarizeCountdown,
+  clock: summarizeClock,
+  map: summarizeMap,
+  quadrant: summarizeQuadrant,
+  venn: summarizeVenn,
+  slope: summarizeSlope,
+  arc: summarizeArc,
+  wordcloud: summarizeWordcloud
+};
+function summarizeDiagram(content, chartType) {
+  if (!chartType) return null;
+  const summarize = SUMMARIZERS[chartType];
+  return summarize ? summarize(content) : null;
+}
+
 // src/render.ts
 var DOM_GLOBALS = [
   "document",
@@ -3823,9 +4667,14 @@ async function render(content, options) {
         ...options?.width !== void 0 && { width: options.width },
         ...options?.height !== void 0 && { height: options.height }
       });
-      const svg2 = applyRootA11y(
-        injectHoverStyles(raw, chartType, { bakeHover }),
-        chartType
+      const svg2 = applyRootDesc(
+        applyRootA11y(
+          injectHoverStyles(raw, chartType, { bakeHover }),
+          chartType
+        ),
+        // The AUTHORED source and type: an arc `layout chord` is re-emitted
+        // above as internal `chord` content, which no summarizer reads.
+        summarizeDiagram(content, parsed.chartType)
       );
       return {
         svg: svg2,
@@ -3863,9 +4712,12 @@ async function render(content, options) {
         }
       }
     );
-    svg = applyRootA11y(
-      injectHoverStyles(svg, chartType, { bakeHover }),
-      chartType
+    svg = applyRootDesc(
+      applyRootA11y(
+        injectHoverStyles(svg, chartType, { bakeHover }),
+        chartType
+      ),
+      summarizeDiagram(content, parsed.chartType)
     );
   } finally {
     releaseDom();